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']