`
qzriso
  • 浏览: 243025 次
  • 性别: Icon_minigender_1
  • 来自: ph
社区版块
存档分类
最新评论

Ruby学习笔记

阅读更多
1、$variable 代表全局变量, @variable代表成员变量,@@variable代表类静态变量
2、双引号内解析表达式,"... #{expression}",对于全局标量或成员变量,花括号可省略
3、局部变量、成员方法参数、成员方法的命名约定都以小写字母或下划线开头
      类名称、模块名称、常量的命名约定都以大写字母开头
      一般多词组成的成员变量用下划线分割,如@test_int
      一般多词组成的类名采用骆驼形式,如TestInt
4、nil的含义是null,但不同于其他语言,在ruby里nil同样是一个对象,只不过代表了nothing的含义
5、%w{word1 word2 word3 ...} 等同于['word1','word2','word3',...]
6、Hash.new({default_value}) 产生一个缺省值为default_value的hash对象,默认缺省值为nil
7、对于单执行语句的条件/循环语句,可以简化成后置形式,如
       test = test + 1 if test > 10
或 test = test + 1 while test < 10
8、正则表达式判断,{subject} =~ /pattern/ ,也可以是/pattern/ =~ {subject},返回值是匹配的位置,或者nil(无匹配)
      除了返回匹配结果外,还会修改全局变量$&、$`、$'、$~、$1、...、$9
      $&表示匹配的字符串部分,$`表示匹配之前的部分,$'表示匹配之后的部分
      $~将包含匹配相关的所有信息,$1到$9表示部分匹配的内容
     字符串正则表达式替换,采用成员方法sub和gsub(替换全部),两者的使用方法有两种:
      - [g]sub(/pattern/,'somestr')      用字符串somestr去替换匹配指定pattern的部分(需要注意的是somestr会先被正则表达式引擎处理)
      - [g]sub(/pattern/) {|str| block} 对于匹配pattern的部分,调用对应代码块并用代码块返回的部分取代之(匹配部分会传递给代码块)
      在部分匹配并替换的字符串表达里,可以用\1、\2、...代表前面匹配的部分,还可以用\&代表最近的一次匹配、\+代表最近的一次部分匹配、 \`代表匹配之前的字符串、\'代表匹配之后的字符串;另外需要注意的是,替换字符串本身会被正则表达式引擎处理,因此需要用\\\\代表一个反斜杠符\
      {subject} !~ /pattern/ ,判断是否不满足某个pattern
9、代码块(Code Block),有两种表达形式{ ... } 和 do ... end,前者优先级更高,一般考虑单行用前者,多行用后者
      代码块可以传递给特定函数,特定函数里用yield关键词来调用代码块,见下例
     
def call_block
      puts "Start of method"
      yield
      yield
      puts "End of method"
end
call_block { puts "In the block" }
将输出如下:
Start of method
In the block
In the block
End of method
代码块可以定义参数,如{|param1,param2| ... },然后在调用函数里使用yield(参数1,参数2) 来传递参数并调用代码块
10、puts输出自动换行,print输出不换行
11、类继承 class <SomeClass> < BaseClass
       构造函数 initialize
       父类调用super(...),与其他语言不同的是,super可以出现在构造函数以外的函数里,效果是调用父类的同名函数(用同样的参数)
属性访问声明attr_reader、attr_writer ,用ruby特有的记号(symbol,形如:some_attr)作为参数,用来声明可访问的属性
属性设置方法名称采用 def <属性名>=(参数值) 的形式
12、类方法,相当于类静态方法,定义形式为def <类名>.<方法名>(...) 或 def self.<方法名>(...)
还有种定义形式 class << self
                           def <方法名>(...)
                           end
                         end
                       
13、Object成员函数dup,相当于clone
        Object成员函数freeze,调用后将变为只读特性,即无法修改,如果发生修改将产生TypeError异常
14、array访问采用array[index]的方式,如果index为负数,则代表从尾部倒过来访问,array[-1]即最后一个元素
访问子数组,array[index,count] 返回一个新的子数组
还可以用array[start..end] 获取[start,end]范围的子数组,以及array[start...end] 获取[start,end)的子数组(注意:将不包含第end项)
[index]= 可以用来替换指定位置的元素
[index,count]= 可以用来替换指定范围的元素或者插入元素
a = [ 1, 3, 5, 7, 9 ] ! [1, 3, 5, 7, 9]
a[2, 2] = 'cat' ! [1, 3, "cat", 9]
a[2, 0] = 'dog' ! [1, 3, "dog", "cat", 9]
a[1, 1] = [ 9, 8, 7 ] ! [1, 9, 8, 7, "dog", "cat", 9]
a[0..3] = [] ! ["dog", "cat", 9]
a[5..6] = 99, 98 ! ["dog", "cat", 9, nil, nil, 99, 98]
15、并行赋值 i1, i2 = 1, 1     相当于 i1= 1     i2= 1
16、具备Enumerable特性的容器(如数组),具有下列轮询函数
.each {|element| ...} 对每个元素执行代码块
.collect {|element| ...} 对每个元素执行代码块,并用返回值组成一个新的容器返回
.inject(initial) {|something,element| ...} something用initial作为初值,并对每个元素执行代码块,最后返回something;如果调用的时候没有个包含 initial,something的初值设为第一个元素
17、参数透明传递 *args,如def func(*args),即无论实际调用时传递了几个参数,都包含进args数组;函数内可以再使用anotherfunc(*args) 透明的把参数传递给另一个函数
同时,在实际传递参数时,如果是func(a,b,*array_of_params)的形式,数组array_of_params将被展开,即其中的元素被一个个传递进函数,例如:
def five(a, b, c, d, e)
    "I was passed #{a} #{b} #{c} #{d} #{e}"
end
five(1, 2, 3, 4, 5 )        ==> "I was passed 1 2 3 4 5"
five(1, 2, 3, *['a', 'b']) ==>    "I was passed 1 2 3 a b"
five(*(10..14).to_a)     ==> "I was passed 10 11 12 13 14"
18、File.open函数会根据是否传递有代码块,执行不同的逻辑
如果有代码块,那么先打开文件,以文件句柄为参数执行代码块,最后关闭文件,返回值为代码块的执行结果
如果没有代码块,那么就打开文件并返回文件句柄
通过Kernel.block_given? 方法可以检测是否在调用时传递了代码块
19、如果传递参数时最后一个参数前面加了&符号,该参数将作为代码块处理,并可以默认转型为Proc类型并赋值给其他变量
赋值给变量后,该变量(类型为Proc)可以调用call方法实现对代码块的调用,例如
songlist = SongList.new
class JukeboxButton < Button
     def initialize(label, &action)
       super(label)
       @action = action
     end
     def button_pressed
       @action.call(self)
     end
end
start_button = JukeboxButton.new("Start") { songlist.start }
pause_button = JukeboxButton.new("Pause") { songlist.pause }
20、Proc(代码块)的闭包特性
通过lamda方法创建的代码块具备闭包特性,即保留到全局空间路径上已申明的变量集(包括self),例如:
def n_times(thing)
     return lambda {|n| thing * n }
end
p1 = n_times(23)
p1.call(3) ! 69
p1.call(4) ! 92
p2 = n_times("Hello ")
p2.call(3) ! "Hello Hello Hello "
21、?代表取字符编码,如
?a => 97 # ASCII character
?\n => 10 # code for a newline (0x0a)
?\Ca => 1 # control a = ?A & 0x9f = 0x01
?\Ma => 225 # meta sets bit 7
?\M\Ca => 129 # meta and control a
?\C? => 127 # delete character
?\\ => 92 #\ character
22、字符串表达式。除了单引号、双引号以外,还可以用%q、%Q的形式
%q与单引号雷同,形如%q/test abcd/       <==> 'test abcd'
%Q与双引号雷同,形如%Q{Second/day: #{24*60*60}}    <==> "Second/day: #{24*60*60}"    <==> "Second/day: 86400"
%q、%Q后面的分隔符除接受[]、{}、()、<>对之外,接受相同的分隔符,如||,//,!!
除此之外,ruby还接受如下的结构构成字符串
string = <<END_OF_STRING
      The body of the string
      is the input lines up to
      one ending with the same
      text that followed the '<<'
END_OF_STRING
23、Range. 即形如0..20、'a'..'z'、0...10000
ruby用Range对象来表示range,即只会保存range的上下范围
range的成员方法to_a 可以将Range转化成一个新的数组
自定义的类型如果要支持Range,需要实现一系列函数,举例如下:
class VU
     include Comparable
     attr :volume
   def initialize(volume) # 0..9
     @volume = volume
   end
   def inspect
     '#' * @volume
   end
   # Support for ranges
   def <=>(other)
     self.volume <=> other.volume
   end
   def succ
     raise(IndexError, "Volume too big") if @volume >= 9
     VU.new(@volume.succ)
   end
end
medium_volume = VU.new(4)..VU.new(7)
medium_volume.to_a                        ==〉                 [####, #####, ######, #######]
medium_volume.include?(VU.new(3)) ==〉                 false
Range还可以用来测试某个变量是否落在范围之内,采用=== ,例如:
(1..10) === 5          ==〉 true
(1..10) === 15        ==〉 false
(1..10) === 3.14159 ==〉 true
('a'..'j') === 'c'          ==〉 true
('a'..'j') === 'z'          ==〉 false
24、方法中传递hash,只要该hash位于常规参数之后,和array格式及代码块参数之前的,可以省略hash的{}号
25、成员方法重定义,例如:
class Fixnum
     alias old_plus +
     # Redefine addition of Fixnums. This
     # is a BAD IDEA!
     def +(other)
       old_plus(other).succ
     end
end
1 + 2 ==> 4
a = 3
a += 4 ==> 8
a + a + a ==> 26
27、和unix shell类似,可以用`command ...` 来执行命令并用返回值作为替代的字符串,同时也接受%x的形式,如%x{ls}、%x[dir]等
28、并行赋值,支持*号数组扩展,例如:
a = [1, 2, 3, 4]
b, c = a          ==>    b == 1, c == 2
b, *c = a        ==>    b == 1, c == [2, 3, 4]
b, c = 99, a     ==>    b == 99, c == [1, 2, 3, 4]
b, *c = 99, a ==>    b == 99, c == [[1, 2, 3, 4]]
b, c = 99, *a ==>    b == 99, c == 1
b, *c = 99, *a ==> b == 99, c == [1, 2, 3, 4]
并行赋值还有一个级联拓展的特性,例如:
b, (c, d), e = 1,2,3,4         ==> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = [1,2,3,4]       ==> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = 1,[2,3],4      ==> b == 1, c == 2, d == 3, e == 4
b, (c, d), e = 1,[2,3,4],5    ==> b == 1, c == 2, d == 3, e == 5
b, (c,*d), e = 1,[2,3,4],5    ==> b == 1, c == 2, d == [3, 4], e == 5
29、defined? <expression>    如果表达式已定义,则返回表达式的特性;否则返回nil;如果expression是yield,且当前上下文里定义有代码块则返回"yield",否则返回nil。其他的例子如:
defined? 1          ==> "expression"
defined? dummy ==> nil
defined? printf     ==> "method"
defined? String    ==> "constant"
defined? $_         ==> "globalvariable"
defined? Math::PI ==> "constant"
defined? a = 1       ==> "assignment"
defined? 42.abs     ==> "method"
30、and、&& 、or、||返回决定最后值的那个子表达式的值,例如:
nil and true      ==> nil
false and true ==> false
99 and false     ==> false
99 and nil         ==> nil
99 and "cat"     ==> "cat"
false or nil        ==> nil
nil or false        ==> false
99 or false        ==> 99
因此 <var> ||= <val>,即<var> = <var> || <val>,也就是说当var为false或nil时,将var赋值为val
31、case 语句,如下:
case <target>
when <comparison> [then|:] <operation>
when <comparison> [then|:] <operation>
else <operation>
end
判断时调用 <comparison> === <target>
=== 符号不同于==,随着调用对象的不同有着不同的意义,如Range.=== obj 判断obj是否在range的范围内,Class.=== obj判断obj是否属某个class类型,RegExp.=== obj判断字符串是否匹配正则表达式,等等
32、for <element> in <container> ... 相当于<container>.each {|element| ...}
33、redo 表再次执行循环体(但不进行判断)
retry则彻底重新执行循环
注:retry还能彻底重新执行方法调用,如:
     def do_until(cond)
        break if cond
        yield
        retry
     end
     i = 0
     do_until(i > 10) do
        print i, " "
        i += 1
     end
produces:
0 1 2 3 4 5 6 7 8 9 10
34、loop do .. end 相当于c语言里的for(;;){..},需要用break、redo、next等进行逻辑编排和安排跳出
35、break可以提供参数,代表循环的返回值;若没有提供参数,则代表返回nil
36、代码块本身内部变量的生命期仅限于代码块内部,但如果在代码块到全局空间的上下文路径上已存在某个变量名称(哪怕变量是nil或者没有真正执行到过),而这个变量名称被用在了代码块里,那么代码块将使用这个变量,即即使代码块结束该变量的值仍然有效。例如:
x = nil
y = nil
[ 1, 2, 3 ].each do |x|
     y = x + 1
end
[ x, y ]    ==> [3, 4]
37、begin ... rescue [<ErrorType> [ => <exception_var> ] ] ... [raise] [else ...][ensure ...] end     ruby的异常处理流程
else部分是当没有异常发生时执行的代码
ensure相当于c++的__finally
rescue里的代码可以包含retry,表示重新执行begin后面的代码,例如:
@esmtp = true
begin
      # First try an extended login. If it fails because the
      # server doesn't support it, fall back to a normal login
      if @esmtp then
         @command.ehlo(helodom)
      else
         @command.helo(helodom)
      end
      rescue ProtocolError
      if @esmtp then
         @esmtp = false
         retry
      else
         raise
      end
end
38、抛出异常的几个形式:
raise      ==> 抛出当前异常,或者一个RuntimeError
raise "bad mp3 encoding"      ==> 抛出一个RuntimeError,并将其成员message置为"bad mp3 encoding"
raise InterfaceException, "Keyboard failure", caller ==> 抛出一个InterfaceException异常,将其成员message设为"Keyboard failure",以及调用堆栈变量设为Kernel.caller
39、catch .. throw的用法
catch [:symbol|"string"] do
     ...
     ...
     throw [:symbol|"string"] [,result]
end
当通过throw抛出标志或字符串,且该标志或字符串与catch语句里的标志/字符串时,整个catch块执行结束。如果throw提供了第二个参数(即result),result将作为整个catch块的返回值。例如:
def prompt_and_get(prompt)
     print prompt
     res = readline.chomp
     throw :quit_requested if res == "!"
res
end
catch :quit_requested do
     name = prompt_and_get("Name: ")
     age = prompt_and_get("Age: ")
     sex = prompt_and_get("Sex: ")
     # ..
     # process information
end
40、模块的Mixin特性,在调用成员方法时,搜索顺序是类自身=〉最近include的module=〉最远include的module=〉父类(继续递归,直到Object)
模块中定义的变量不会"传递"进加载该模块的代码上下文,只有函数会"传递"。例如:
a = "cat"
b = "dog"
require 'included'
a      ==> "cat"
b      ==> "dog"
b()    ==> 2
41、load/require的区别
load会无视是否已经加载模块而去加载,require只会加载模块一次
require还可以加载二进制模块,而且属于动态执行
load只是静态执行,且只能加载文本模块
全局变量 $" 代表了通过require加载的模块集合
42、加载路径是可以动态修改的:通过全局变量$:
43、Ruby自身的线程机制并没有利用操作系统的线程服务,因此在并发处理上比较薄弱
Thread.new(param1,param2,...) {|param1,param2,...|} 创建一个Ruby线程。
需要注意的是,Ruby线程之间共享全局变量、以及从全局空间到线程代码块的上下文路径上的所有变量。因此,上述param1、param2可能会在实际执行线程之前被主线程修改(因此,考虑利用dup和freeze成员方法)
ruby线程代码块里的局部变量不会被其他ruby线程共享
还有在主ruby线程退出时,会自动删除其他ruby线程(可能会造成问题),建议在主线程里使用Thread的join方法确保结束前其他子线程都已结束
Thread的value方法可以返回该线程执行的最后一个语句的返回值
Thread.current静态方法返回当前线程
Thread.list静态方法返回当前活动的线程列表
设置线程局部变量的方法:<threadref>[<varname>]= ...      <threadref>[<varname>]
44、线程的异常处理
如果Thread.abort_on_exception 静态变量为false,且ruby解释器的debug开关为关闭状态,线程产生的异常会导致线程结束,且该异常只有在调用join方法时可以捕获。例如:
threads = []
4.times do |number|
     threads << Thread.new(number) do |i|
       raise "Boom!" if i == 2
       print "#{i}\n"
     end
end
threads.each do |t|
    begin
      t.join
    rescue RuntimeError => e
       puts "Failed: #{e.message}"
    end
end
produces:
0
1
3
Failed: Boom!
如果Thread.abort_on_exception 静态变量为true,或ruby解释器的debug开关为打开状态,线程产生的异常会导致所有线程终止。例如:
Thread.abort_on_exception = true
threads = []
4.times do |number|
     threads << Thread.new(number) do |i|
       raise "Boom!" if i == 2
       print "#{i}\n"
     end
end
threads.each {|t| t.join }
produces:
0
1
prog.rb:5: Boom! (RuntimeError)
from prog.rb:4:in `initialize'
from prog.rb:4:in `new'
from prog.rb:4
from prog.rb:3:in `times'
from prog.rb:3
44、Monitor可以用来解决多Ruby线程访问同一个变量的互斥问题,形式有几种:
- 继承Monitor类
- mixin进MonitorMixin
- 产生一个Monitor对象,调用对象的synchronize方法并传递进一个代码块
在互斥代码块里如果需要临时放弃访问锁,需要先获取互斥对象的条件访问变量(通过new_cond),再调用条件访问变量的wait_while (传递进一个代码块来测试条件)
45、hash可以使用任意类型对象作为key,但需要注意对象的值发生改变时(或者对象是数组时数组的元素发生改变)对象的hash值会发生改变,那么hash可能会发生索引失效的问题。解决方法是调用rehash方法。例如:
arr = [1, 2]
hash = { arr => "value" }
hash[arr]        =====〉 "value"
arr[0] = 99
hash[arr]        =====〉 nil
hash.rehash    =====〉 {[99, 2]=>"value"}
hash[arr]        =====〉 "value"
46、调优方法:
- benchmark
- profiling 。通过命令行定义-r profile或者文件里require 'profile'
47、ruby源文件里可以定义若干个begin{...} end{...},这些块分别在加载和卸载这些文件时调用
48、如果@@变量定义在全局范围,相当于定义了一个类Object的静态变量,在作用上相当于一个全局变量
49、代码块内执行return [value] 的效果相当于跳出代码块并在定义代码块的上下文(即某个方法)里执行return [value];如果该上下文已不复存在(方法执行完毕),将产生LocalJumpError或ThreadError异常。例如:
def meth1
     (1..10).each do |val|
        return val # returns from method
     end
end
meth1 ===〉 1
===========================
def meth2(&b)
    b
end
res = meth2 { return }
res.call
produces:
prog.rb:5: unexpected return (LocalJumpError)
from prog.rb:5:in `call'
from prog.rb:6
============================
def meth3
     yield
end
t = Thread.new do
    meth3 { return }
end
t.join
produces:
prog.rb:6: return can't jump across threads (ThreadError)
from prog.rb:9:in `join'
from prog.rb:9
注:因为代码块定义在全局空间(即主线程),但执行return的线程是副线程;因此产生了线程跳跃异常
使用Proc.new产生的Proc对象表现与代码块相当,例如:
def meth4
     p = Proc.new { return 99 }
     p.call
     puts "Never get here"
end
meth4    ==〉 99
而用lamda或者proc产生的对象则不同,return仅仅是从代码块返回,对上下文没有影响
def meth5
      p = lambda { return 99 }
      res = p.call
      "The block returned #{res}"
end
meth5 ==〉 "The block returned 99"
50、<obj>.respond_to? (<symbol>) 检查对象是否支持某个方法调用,如
obj.respond_to? (:to_int)     
obj.respond_to?(:<<)
51、实现coerce(<other_obj>)方法可以实现double dispatch模式,即根据other_obj的类型进行动态操作符重载
coerce方法返回的是一个具有两个元素的数组,数组里第一个元素是other_obj对某个类型的转化,第二个元素是自身对某个类型的转化。例如:
class Roman
     def initialize(value)
       @value = value
     end
     def coerce(other)
       if Integer === other
          [ other, @value ]
       else
          [ Float(other), Float(@value) ]
       end
     end
     # .. other Roman stuff
end
iv = Roman.new(4)
xi = Roman.new(11)
3 * iv       ===〉 12
1.1 * xi     ===〉 12.1
注:coerce是针对对象作为操作符重载函数的参数时起作用的,即上述 3 +-*/ Roman的情况,如果是Roman +-*/ 3并不适用
52、定义一个与某个对象绑定的class,相当于以对象为单位扩展功能。
class << <object>
      ...
end
相当于
def <object>.<method1>
     ...
end
def <object>.<method2>
     ...
end
Object类的extend方法相当于定义了一个(Mod) is basically equivalent to
class <<obj
include Mod
end
如果是在class里使用extend,相当于动态添加模块里的方法作为类静态方法,例如:
module Humor
    def tickle
      "hee, hee!"
    end
end
class Grouchy
    extend Humor
end
Grouchy.tickle    ==〉 "hee, hee!"
53、在Ruby运行时中,任何类型本身在全局空间中都有一个同名常量,值是类型为Class的类对象(描述了这个类型)
比如String,全局空间里有常量String,值是类型为Class描述String类的对象
def factory(klass, *args)
     klass.new(*args)
end
factory(String, "Hello")    ==〉 "Hello"
factory(Dir, ".")              ==〉 #<Dir:0x1c90e4>
flag = true
(flag ? Array : Hash)[1, 2, 3, 4]      ==〉 [1, 2, 3, 4]
flag = false
(flag ? Array : Hash)[1, 2, 3, 4]      ==〉 {1=>2, 3=>4}
另外,如果一个类型为Class的类对象还没有名字(name属性为空),且被赋值给一个常量的,那么该常量的名字就作为这个类的名称。例如:
var = Class.new
var.name        ==〉 ""
Wibble = var
var.name        ==〉 "Wibble"
54、运行环境其实是在一个类型为Object的对象内部,全局空间相当于对象的私有域(private:),比如定义一个全局方法其实是定义在了运行时对象的私有域(相当于private: def ...)
55、dup和clone的区别
clone复制对象的所有东西,包括frozen状态 - 复制出的产物保持和原对象一样的frozen状态
dup则不复制frozen状态 - 复制出的产物不frozen
str1 = "hello"
str1.freeze     ==>    "hello"
str1.frozen?    ==> true
str2 = str1.clone
str2.frozen?    ==> true
str3 = str1.dup
str3.frozen?    ==> false
55、序列化时,一般对象可以直接利用Marshal.dump和Marshal.load去自动完成
如果要自己完成序列化过程的`,对象需要定义marshal_dump和marshal_load成员方法。marshal_dump返回一个可自动序列化的对象(该对象被自动序列化);marshal_load获得一个自动反序列化出来的对象,并通过它完成反序列化
class Special
    def initialize(valuable, volatile, precious)
      @valuable = valuable
      @volatile = volatile
      @precious = precious
    end
    def marshal_dump
       [ @valuable, @precious ]
    end
    def marshal_load(variables)
       @valuable = variables[0]
       @precious = variables[1]
       @volatile = "unknown"
    end
    def to_s
       "#@valuable #@volatile #@precious"
    end
end
obj = Special.new("Hello", "there", "World")
puts "Before: obj = #{obj}"
data = Marshal.dump(obj)
obj = Marshal.load(data)
puts "After: obj = #{obj}"
produces:
Before: obj = Hello there World
After: obj = Hello unknown World
56、YAML库可以用来将对象序列化为YAML格式,对象需要定义一个to_yaml_properties方法(返回需要序列化的属性名数组)
分享到:
评论
1 楼 fireflyman 2009-08-06  
1.Ruby基礎觀點-->Ruby中幾乎所有都是對象;

2.備注:#

3.語句行:
(1)每個語句以;號隔開
(2)一行一條語句

4.縮進處理:對于代碼編輯的縮進沒有要求,但是最好能達到2個字符的縮進

5.方法定義
def 方法名(參數1,參數2...)
    //語句行...
    //return...
end
其中()為可選擇項目

6.方法呼叫
      方法名(參數1,參數2...)
      如果只有一個參數,則可以這樣呼叫:方法名 參數1

7.字符串連接符號:+

8.回車換行符號:\n

9.Express Interpolation:雙引號括起來的字符串

10.Express定義:${...}

11.變量
全局變量:$打頭
實例變量:@打頭
類變量:@@打頭

12.類名,模板名,常量名必須首字母大寫

13.nil:無對象

14.數組定義:[數值1,數字2,]

15.Hash表:
   a={
        'key1'=>value1,
        'key2'=>value2,
         #...
   }
a['key1']

相关推荐

    Ruby学习笔记(学习心得)

    Ruby学习笔记 01 类的属性与方法 02 访问控制 03 Container(Array/Hash) 04 Iterator 05 简单数据类型 06 范围 07 方法 08 条件控制 09 异常处理

    rubyinstaller-devkit-3.0.2-1-x64 and Ruby 学习笔记.7z

    Ruby是一种面向对象的脚本语言,它以其简洁、优雅的语法和强大的功能而闻名。...通过安装Ruby和DevKit,你可以轻松地编写、编译和运行Ruby代码,同时结合学习笔记,可以深入理解Ruby语言及其生态系统。

    ruby学习笔记

    ruby基础笔记,自学笔记,ruby基础语法非常全面ruby基础笔记,自学笔记,ruby基础语法非常全面

    RubyStudy-master-ruby学习笔记

    学习 Ruby 的旅程即将开始! Ruby 是一种功能强大、灵活的编程语言,广泛应用于 Web 开发、脚本编写和系统管理等领域。下面是学习 Ruby 的一些实用建议:首先,了解 Ruby 的基本概念和语法。 Ruby 是一种面向对象的...

    个人ruby学习笔记

    从给定的文件信息中,我们可以提炼出一系列关于Ruby编程语言的重要知识点,涵盖基础语法、变量类型、...以上总结了Ruby的一些基础知识点,这些内容对于初学者掌握Ruby编程语言至关重要,同时也是进一步深入学习的基石。

    精华ruby学习笔记和代码

    这个笔记里包含了ruby的整型,字符串,浮点数,布尔等基础数据类型,还有数组,哈希hash的用法, 类的定义,函数方法,以及对象定义,其他高级用法解释,除了笔记记录的语法糖之外,还包含了一些解释性的代码,帮助...

    学习Ruby的笔记以及Demo源码.zip

    学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及...

    学习 Ruby 的笔记以及 Demo(简介、语言特性、应用场景、Ruby 注释、Ruby 文件的构造与析构语句Ruby 变量等)

    Ruby 学习笔记 1、简介 定义:一种简单快捷的面向对象脚本语言 开发者:松本行弘 开发时间:1995年 设计目的:A PROGRAMMER'S BEST FRIEND【程序员的最佳朋友】 文件扩展名:rb 2、语言特性 真正的面向对象编程语言 ...

    Ruby学习笔记一

    笔记: Ruby会默认返回方法中的最后一个值。 如果需要返回多个值,可以用数组来实现。 可以通过强制声明return来返回值。 基础的输出方法是用puts(输出一行),print(直接打印)。 基础的输入方法是gets(读入一行,...

    ruby 学习笔记(2) 类的基本使用

    ruby语言跟c#的一些重要差别在于: 1.ruby是动态语言,c#是静态语言–即对象在new出来以后,ruby还可以动态... …其它地方,等学习深入了再写出来 最后上一段测试代码,展示了ruby中类的基本用法: 代码如下: class Peop

    Ruby学习笔记之gem 命令详解

    这篇学习笔记将详细介绍 `gem` 命令及其相关工具,如 RVM (Ruby Version Manager) 的使用。 首先,我们通过 `ruby -v` 命令来查看当前系统中安装的 Ruby 版本。这有助于确保我们正在使用的是正确的版本。如果需要...

    ruby 学习笔记(1) 初识语法

    单从技术而言,ruby本身确实很爽,令程序员的工作变得轻松有趣! 下面的代码演示了如何找出100以内的素数: 代码如下: using System; namespace Mersenne { class Program { static void Main(string[] args) { for ...

    ruby笔记1ruby笔记1ruby笔记1

    标题中的"ruby笔记1ruby笔记1ruby笔记1"暗示了这是一份关于Ruby编程语言的学习笔记,可能包含了作者在学习过程中的重点、难点以及心得体验。描述中的内容重复了标题,进一步强调了这是关于Ruby的深入学习记录。标签...

    学习 Ruby 的笔记以及 Demo.zip

    本资源“学习 Ruby 的笔记以及 Demo.zip”显然包含了关于Ruby编程的学习资料和一些实际示例代码,旨在帮助初学者理解并掌握Ruby的基础及进阶特性。 首先,让我们深入了解一下Ruby的核心特性: 1. 面向对象:Ruby是...

    ruby编程学习笔记及demo

    Ruby是一种纯粹的面向对象编程语言。它由日本的松本行弘(まつもとゆきひろ/Yukihiro Matsumoto)创建于1993年。 您可以在 www.ruby-lang.org 的 Ruby 邮件列表上找到松本行弘(まつもとゆきひろ/Yukihiro ...

    Ruby自学笔记

    以上是Ruby自学笔记中提及的关键知识点的详细解读,如果要学好Ruby语言,深入理解这些基础知识是非常必要的。Ruby语言的这些特性与规则构成了其独特的编程范式,使得它在动态语言领域中占有一席之地。

Global site tag (gtag.js) - Google Analytics