不懂Ruby的程序员,如何快速读懂Ruby代码

  1. 云栖社区>
  2. 博客>
  3. 正文

不懂Ruby的程序员,如何快速读懂Ruby代码

zchd 2013-01-22 16:44:00 浏览445
展开阅读全文
本问答的目标读者是不了解Ruby语言、但有别的编程语言经验的人。

  Ruby语言的代码可读性是很强的。本问答只把一些语法特点、以及别的语言中可能没有或不同的东西展现出来,目的在于让有别的编程语言经验的人能快速读懂Ruby代码。

  注意本问答讲的是Ruby语言本身(基于版本1.9),而不是Ruby on Rails,后者是Ruby的一种DSL,语言面貌上和Ruby有一定差异。
 


  Q:Ruby最有特点的语法形式是什么?

  或许是方法后接代码块的大量使用,以下面这行代码为例:

  file.each_line("x") { |line| print line }

  表示在file对象上调用each_line方法(以"x"为行的分隔符),该方法的功能是依次得到每一行,传递给后面的代码块,代码块把传来的行赋值给 line变量,然后在代码块里对line进行处理,处理完毕则从代码块返回each_line方法,再由它得到下一行,再一次传递给代码块。——像 each_line这样的方法,Ruby中称之为迭代器方法(iterator)。

  又比如这个例子:

  open('test.txt') { |f| line_array = f.readlines }

  用open方法打开test.txt文件,生成了一个File类的实例对象,并把这个对象传递给后面的代码块,赋值给变量f,然后代码块里对f进行操作,操作完毕后返回open方法,open方法再把f关闭,所以这一行代码相当于如下三行:

  f = open('test.txt')

  line_array = f.readlines

  f.close

  Ruby风格写法的好处:一行完成,逻辑紧凑;自动关闭文件,防止忘了f.close;

  当前scope少创建一个变量名f,代码块关闭后,f就消失了

  一个Ruby风格的完整命令就是由对象、方法(包含参数)、代码块(包含参数)构成的。有的方法可以不接代码块。

  Q:我看到有些代码和上面提到的写法不太像,是怎么回事?

  有些DSL看起来和Ruby语言本身不大像,但其实语法格局是一样的,只是通过一些设定伪装成别的风格。

  大致有四点导致这种情况:

  1、隐性地调用方法,让方法看起来像函数或关键词;

  Ruby中没有函数,全都是方法。方法就得在某个对象上调用,但是这个对象可以隐藏

  方法不在某个对象上显式调用,那它就一定是在self所指的对象上调用

  如open(file)实际是self.open(file),不过open是私有方法,不能显式写出对象

  2、省略了括起参数的括号;

  如open('test.txt','w')可以写成open 'test.txt', 'w'

  3、代码块的{...}改成do...end;

  open 'test.txt' do |line|

  end

  就相当于open('test.txt') {|line| }

  这是很常见的,{...}和do...end只在优先级上有一些不同,一般都可互换

  通常的风格是:代码块里的代码若只有一行,则用{},若有多行,则用do...end

  这只是风格管理,实际上即使是多行代码,你也可以用{}括起来

  4、省略作为方法参数的哈希(散列)字面量的花括号。

  很多方法喜欢拿一个哈希做参数,如果哈希是方法调用的最后一个参数,则花括号可省略

  task :name => :test 相当于 task({:name => :test})

  如下一段代码:

  HTMLForm.generate(STDOUT) do

  comment "This is a simple HTML form"

  form :name => "registration",

  :action => "http://www.example.com/register.cgi" do

  content "Name:"

  input :name => "name"

  content "Address:"

  textarea :name => "address", :rows=>6, :cols=>40 do

  "Please enter your mailing address here"

  end

  end

  end

  如果写“全”来,就相当于这样:

  HTMLForm.generate(STDOUT) {

  self.comment("This is a simple HTML form")

  self.form({:name => "registration",

  :action => "http://www.example.com/register.cgi"}) {

  self.content("Name:")

  self.input({:name => "name"})

  self.content("Address:")

  self.textarea({:name => "address", :rows=>6, :cols=>40}) {

  "Please enter your mailing address here"

  }

  }

  }

  Q:我听说Ruby分1.8和1.9两个版本,二者的语法有什么不同?

  目前Ruby流行1.8.x和1.9.x两个主要版本。1.9.x版使用新的解释器YARV,比1.8.x速度快;重写了String类,增加了Encoding类,从此可以完善处理多字节字符;杀手应用RoR也一早支持了1.9.x版;还有一些语法上的改进。

  本问答以1.9版语法为准,两个版本有一些语法差别,略提几条区别的线索:

  § 如果有require 'rubygems'的,为1.8版;

  § 如果看见$KCODE的,为1.8版;

  § 哈希的键值对之间可以用逗号(而非=>)分隔的,为1.8版;

  § if condition:这种和Python一样的写法(条件之后用冒号),为1.8版

  § {|a,b;x,y| }的写法(用分号隔开两类参数),一定是1.9版

  Q:有些写法感觉很奇怪,比如5.times { puts "Ruby! " },怎么理解?

  这种写法其实很酷。Ruby中一切值都是对象,包括整数。Integer类有实例方法times,依次传递0到n-1给后面的代码块,相当于运行n次后接的代码块。

  这一代码就是在5上调用方法times

  Q:Ruby代码中很少看见for...in/foreach的写法,为什么?

  相比for i in xx的循环方式,Ruby的风格是更喜欢用xx.each {|i| }这种调用迭代器方法的方式。

  对于数组for elem in array,迭代器方法写作array.each { |elem| }

  对于读文件的每行for line in file,迭代器方法写作file.each { |line| }

  相比for...in方式,迭代器方法更快,更灵活,更强大,比如对于一个file对象

  file.each_line { |line| } # 每次处理一行

  file.each(' ') { |para| } # 每次处理一段

  file.each_char { |char| } # 每次处理一个字符

  file.each_byte { |byte| } # 每次处理一个字节

  file.each_line.with_index(1) { |line, lineno| }

  # 传递行时,还把索引值(在这里就是行号)也传递给代码块

  这些都不是for...in擅长的

  至于for(i=0; i<10; i++)这种写法,Ruby当然是写成9.times {|i| }这种形式了

  Q:Benchmark::measure、Benchmark.measure两种写法有什么区别?

  表示方法调用,用::还是用.,完全是一样的,指向的是同一个方法,区别只在于作者怎么看待measure这个方法。

  符号::一般是用来分隔嵌套的模块、类、常量的,写成Benchmark::measure,像是表明measure是在Benchmark这个模块中定义的函数,Benchmark只是它的容器;而写成Benchmark.measure,像是在说measure是对Benchmark这个对象进行操作。

  从内部实现上说,Ruby中只有方法,没有函数;但从内涵上说,Benchmark::measure的意义更确切,所以有人愿意这样写。

  Q:Array#each是什么意思?

  Array#each的写法并不用在实际代码中,而是文档中约定俗成的一种写法,表示Array类中定义的实例方法:

  array = Array.new

  array.each {} # Array#each指的就是这里的each,是Array类的实例所用

  Q:::Foobar是什么意思?

  其中的::是分隔嵌套模块、类、一般常量的分隔符,::前面没有东西,表示到global scope去找这个常量。

  Q:经常听到Ruby“一切皆对象”的说法,怎么理解?

  严格来说,应该是Ruby中一切可独立的合法语言片段都是表达式,表达式都要返回一个值,而一切值在Ruby中都是对象。

  比如true false nil也是对象,分别是TrueClass、FalseClass、NilClass的实例

  比如if结构可独立,所以是表达式,所以要返回值,这个值总是一个对象,所以if结构可以赋值给一个变量:

  a = if x > y

  x + 4

  else

  y * 2

  end

  比如模块、类也是对象,String、Array等类是Class类的实例对象,Class作为对象也是Class这个类的实例

  Q:$foo、@bar和@@baz里的$、@、@@是什么意思?

  Ruby没有global、local之类关键词设定变量可见范围,而是采用变量自带标记的方式

  § 以小写字母或_开头的变量是局部变量

  §以$开头的是全局变量

  §以@开头的是每个对象自身的实例变量

  §以@@开头的是同类对象都可访问的类变量

  class A

  def initialize(var)

  @s=var

  @@ss=var

  end

  def to_s

  "s=#@s,ss=#@@ss"

  end

  end

  a=A.new("1")

  puts a.to_s

  b=A.new("2")

  puts b.to_s

  puts a.to_s

  $ ruby a.rb

  s=1,ss=1

  s=2,ss=2

  s=1,ss=2

  @@变量在一个实例里变了,所有实例都会变

  Q:大写字母开头的名称代表什么?

  大写字母开头的是常量,包括模块名、类名都以大写字母开头,如Array、Enumerable都是常量。常量的意思是这个名称和某个对象的联系是固定了的,但不表示那个对象不可更改,如:

  Foobar = [ 1, 2, 3 ]

  Foobar[2] = 99

  print Foobar # [1, 2, 99]

  要想常量所指的对象不可修改,那应该 Foobar = [ 1, 2, 3 ].freeze

  Q:STDIN、STDOUT、STDERR和$stdin、$stdout、$stderr有什么区别?

  STDIN这一类以大写字母开头,是常量;$stdin这一类以$开头,是全局变量。

  常量不可变,STDOUT总指向屏幕显示(除非运行ruby时在命令行设置>out 2>err之类),变量可变,所以$stdin可以替换成别的IO/File对象。

  全局的输出方法,如print puts等,总是向$stdout输出,而非向STDOUT输出,如:

  print 1 # 这时$stdout和STDOUT是一致的,输出到屏幕

  $stdout = open('output_file','w')

  print 2 # 这时输出到output_file了

  $stdout = STDOUT

  print 3 # 又输出到屏幕了

  Q:ARGV = ["a","b","c"]的写法为什么会报错?

  Perl里写@ARGV = qw(a b c)和Python里写sys.argv = ["a","b","c"]都是OK的

  Ruby这么写报错的原因其实也很简单,因为ARGV以大写字母开头,所以它是个常量,ruby解析器一启动,ARGV常量就设置好了,再用等号赋值的方式,表示你想改变这个常量跟某个对象之间的联系,对常量来说这是不行的

  所以在Ruby里得写成ARGV.replace ["a","b","c"],replace是Array类的一个实例方法,表示不改变对象,只替换内容

  Q:表示"什么都没有",用什么?null undef nil?

  用nil。Perl里用undef表示什么也没有,但在Ruby里,undef是取消方法定义的关键词。

  Q:在条件判断中,哪些算是真值,哪些算是假值?

  在Ruby里false、nil表示假,其他所有对象都为真,包括0、""、[]等

  Q:有些方法名称里有?和!,是什么意思?比如nil?和strip!

  方法名的最后可以有一个?或!,这只是一种命名习惯,让方法的涵义看起来更好懂

  加?的方法,通常都是返回true/false的

  像nil?的功能是检测它的对象是否是nil,obj.nil?感觉就是在问obj是nil吗?

  又如File.exist?("test.txt")感觉就是在问"test.txt"存在吗?

  加!的方法,总有一个对应的不加!的方法,通常不加!的生成新对象,而加!的是对本对象进行修改,如String类的strip和strip!:

  str = " abc "

  new_str = str.strip # 不改动原str对象,而是新生成一个字符串,删去了前后空白符

  str.strip! # 直接在原str对象上改动,删去str的前后空白符

  ?和!的使用并没有强制性的规定,你要定义一个返回true/false的方法,不加?也可以,或者某个以?结尾的方法,不返回true/false也可,!也是。总之?和!就是一般字符,不具有限定功能,只是增强可读性的

  Q:我看到有def []=(name, value)这样的写法,什么意思?难道定义了"[]="这个方法?

  Bingo![]=确实是一个方法。

  Ruby语言中很多(但不是全部)操作符实际上都是方法,比如像+ - * / % << == ** 等都是。既然是方法,就可以在自己的类里定义。

  str[2..4] = "xyz"其实相当于str.[]=(2..4,"xyz"),也就是在str对象上调用[]=方法,传递两个参数2..4和"xyz"

  Q:我看到[1,2,3,4].from(2)的写法,但是在官方API里没有看到from这个方法啊?

  说明from这个方法是第三方模块加到Array类里去的。

  Ruby的类是开放的,即使是核心的类,你也可以随意添加方法、undef方法、增加别名等等

  比如对于核心的String类:

  class String

  def to_file

  File.open(self)

  end

  end

  然后我就可以"filename.txt".to_file得到一个file对象了

  Q:String#length方法和String#size方法有没有区别?

  没有区别,这两个方法完全一样,是同义词。

  Ruby的标准API里有不少方法的用法是完全相同的,作者的考虑可能是让不同来源的程序员都有亲近感,或者在不同的上下文使用,更接近自然语言;我是觉得这种冗余不太必要,但对常见的同义词方法,还是应知道一点。

  如 String类的length和size同义,each_line和lines同义,each_char和chars同义,each_byte和 bytes同义;File类的each和each_line以及lines同义;Hash类的each和each_pair同义

  Q:File#gets方法和File#readline方法有没有区别?

  有区别,这两个方法都是读取文件下一行,但到文件末尾eof时,再gets会返回nil,而再readline会触发EOFError异常。

  Ruby标准API里也有一些这种大体相同,但有细微差别的方法。

  哪些方法是同义词,完全一样,哪些是近义,类似但有区别,确实给学习造成了一定的困难,只能是多查。

  Q::encoding :xyz是什么意思?

  这是Symbol类实例的字面量表示法,用个冒号放在字符之前,初学Ruby者可能容易把这个误认为是变量名。也可以写作:"encoding"这样,看起来就像个特殊的字符串,而不是变量名了,但通常是省略引号的。

  Q:Symbol类实例有什么用途?

  Ruby中的字符串是可变的,Symbol对象是不可变的,可以把Symbol对象理解为一种名称,一种标签。因为Symbol对象不可变,它用在哈希里当键比用字符串更有效率:

  person = { :name => 'Joey', :age => 21, :rank => 5 } # 就比

  person = { 'name' => 'Joey', 'age' => 21, 'rank' => 5 } # 更加ruby

  另外,在一些方法中,经常用symbol做参数,指代方法等的名称,如:

  str = "abc|def|ghi"

  array = str.send(:split, "|") # 向str发送消息,相当于str.split("|")

  Q:哈希字面量的写法是怎样的?

  用花括号,键和值用=>分隔开,如:

  hash = { :key1 => "val1", :key2 => "val2", :key3 => "val3" }

  Perl众注意,这个=>是从Perl来的,但Perl里=>跟逗号完全一样,但在Ruby里,=>跟逗号是不同的

  Q:哈希的键是有序的?

  1.9版本的哈希,键确实是有序的,你{:a => 1, :b => 2, :c => 3}用each迭代时,总是首先出:a,其次出:b,然后出:c

  但没看到官方保证后续版本一定也是这样,所以这就像杂牌充电器,你照样用来充电也没问题,但官方不给保修

  Q:不带花括号的写法,比如:encoding => 'gbk'是什么意思?

  还是一个hash,只是省略了花括号,这种写法常用在充当方法调用的最后一个参数时:

  file = File.open('test.txt', :encoding = > 'gbk') # 相当于

  file = File.open('test.txt', {:encoding = > 'gbk'}) # 第二个参数是个哈希

  open方法内部接了这个哈希,opt = {:encoding = > 'gbk'},就可通过opt[:encoding]获得文件编码值,进行下一步处理

  一些DSL很喜欢用这种方式来传递参数,比如:

  class HTMLForm < XMLGrammar

  element :form, :action => REQ,

  :method => "GET",

  :enctype => "application/x-www-form-urlencoded",

  :name => OPT

  element :input, :type => "text", :name => OPT, :value => OPT,

  :maxlength => OPT, :size => OPT, :src => OPT,

  :checked => BOOL, :disabled => BOOL, :readonly => BOOL

  element :textarea, :rows => REQ, :cols => REQ, :name => OPT,

  :disabled => BOOL, :readonly => BOOL

  element :button, :name => OPT, :value => OPT,

  :type => "submit", :disabled => OPT

  end

  看起来一个element带了好多参数,实际上呢,给它的只是两个参数

  element :button, :name => OPT, :value => OPT,

  :type => "submit", :disabled => OPT

  相当于:

  element(:button,{:name=>OPT, :value=>OPT, :type=>"submit", :disabled=>OPT})

  参数就是一个:button(symbol),一个hash

  Q:{a:1,b:2,c:3}也是哈希字面量么?是不是和Python的涵义一样?

  不一样。Python要这样写,a、b、c是三个变量,而在Ruby中(只限1.9版),这其实是

  { :a => 1, :b => 2, :c => 3 }的另一种写法,a、b、c是三个symbol

  为什么要引进这种写法呢?也是为了哈希做方法参数时好看

  File.open('test.txt', :encoding = > 'gbk') # 就可以写成

  File.open('test.txt', encoding: 'gbk')

  上面的例子,写成这样也可以:

  element :button, name: OPT, value: OPT, type: "submit", disabled: OPT

  Q:1..5、"a"..."z"是什么意思?

  是一个range对象的字面量表示法。1..5表示从1到5的范围,包含5(2个点包含尾端);

  "a"..."z"表示从"a"到"z"的范围,不含"z"(3个点不含尾端)

  这种写法是从Perl继承的,但是在Perl里1..5是一个列表,要写成1..得内存爆炸了,但在Ruby里,一个range对象只记录首端的1和尾端的,这么写没问题

  range对象可以迭代操作:(1..6).each {|i| print i}

  又如str[1..5]就是以一个range对象1..5做参数,表示第2个到第6个字符

  Q:=>还有什么用途?

  除了在hash里分隔键和值外,还用在异常处理语法里:

  begin # 异常处理语法

  # blah blah

  rescue ArgumentError => e # 若上面代码触发ArgumentError,则赋值给e

  # blah blah

  end

  还可以写成:rescue => e # 任何出现的异常都赋值给e

  Q:这一句什么意思?m = a / b rescue 0

  这是一种快捷的异常处理语法,A rescue B,若表达式A触发异常,则对B表达式求值并返回

  m = a / b rescue 0 # 假如b是0,出现除0错误,那么右边的0作为返回值

  $stdout = open(output_file,'w') rescue STDOUT

  # 若output_file没有写权限,出错,则返回STDOUT给$stdout

  Q:puts、p、print有什么区别?似乎Ruby众不喜欢用print?

  puts打印一个字符串,如果字符串末尾没有"\n"则添加换行,如果有则不添加

  puts "abc" # 实际打印的是"abc\n"

  puts "abc\n" # 实际打印的还是"abc\n",而非"abc\n\n"

  Ruby中用puts的情况应该比print多吧

  p 则是打印供程序员调试的字符串,会把不在ASCII范围的字符转义

  print "上下" # 打印出来:上下

  p "上下" # 打印出来:"\上\下" 引号也是打印出来的内容

  实际上 p obj相当于print obj.inspect,而obj.inspect相当于Python里的repr(obj)

  Q:字符串里的#{}是什么意思?比如"a + b = #{ a + b }"

  双引号内的表达式内插,如

  a = b = 3

  puts "a + b = #{ a + b }" # "a + b = 6"

  Q:"%s = %f" % ["pi", Math::PI]是什么意思?

  String类的%方法,调用在一个格式字符串之上,相当于printf出来新的字符串

  Q:string << "a"、string << 65,array << "a",file << "a"中的<<各代表什么意思?

  str << "a"表示将字符"a"加到str字符串尾端

  str << 65表示将码点65所代表的字符(这里也是"a")加到str字符串尾端

  Ruby中的字符串是可变的,用str << "a"的方式,是在str这个对象上直接修改,比str = str + "a"快,逻辑也清晰

  array << "a"表示将"a"追加到array末尾,作为最后一个元素

  file << ""表示打印到file对象,相当于file.print "a"

  对于整数来说,<<则是位移方法。对象不同,<<的涵义也不同,很好的duck typing例证

  Q:<<EOF是什么意思?

  这叫做Here Document,Perl众懂的。

  <<后面紧跟一个标记,从下一行开始到出现标记的行为止,其中字符串都存入这个Here Document,例如:

  str1 = <<HD1.upcase + <<HD2.downcase

  aaaaaaa

  bbbbbbb

  HD1

  XXXXXXX

  YYYYYYY

  HD2

  p str1 # "AAAAAAA\nBBBBBBB\nxxxxxxx\nyyyyyyy\n"

  这种代码相当于下面:

  str2 = "aaaaaaa

  bbbbbbb

  ".upcase + "XXXXXXX

  YYYYYYY

  ".downcase

  又如:

  eval_r(<<cmds)

  a = b = 3

  print a + b

  cmds # 上面黄色的字不是代码,而是字符串

  Q:`ls`是什么意思?

  在操作系统中运行``里的命令,如在Windows下运行dir命令,返回dir出现的信息

  `dir`.each_line.select { |line| line.start_with? '2011/09/08' }

  # dir返回的信息,挑选每一行以"2011/09/08"开头的

  Q:/[Rr]uby/是什么意思?

  正则表达式的字面量表示法,和Perl的正则表达式简写形式一样。

  Q:%w %q %Q %r是什么意思?

  从Perl继承并加以变化的语法糖。

  %w后接分界符(可以是%w{} %w() %w[] %w//等等),里面的字符串以空白符分开,这些字符串各自作为数组的元素

  %w( abc 123 def 456) # 相当于 [ 'abc', '123', 'def', '456']

  %q相当于单引号,只是中间出现\'不转义,主要用在字符串内有很多'和"时

  %q{abc'def'} # 相当于 'abc\'def\''

  %Q相当于双引号,主要也是用在字符串里有很多'和",只是里面可以内插表达式

  bar = "foo"

  %Q/foo"#{bar}"/ # => "foo\"foo\""

  单独的%//也代表双引号,是%Q//的简写

  %r相当于//,用于创建正则表达式

  Q:$` $& $' $1 $2是什么意思?

  当一个字符串和正则表达式匹配时,字符串中匹配正则表达式的那部分存入$&,之前的部分存入$`,之后的部分存入$'

  如果正则表达式里有捕获括号,则第一个捕获的子串存入$1,第二个存入$2,依次类推

  这种标点符号式的变量是直接从Perl中继承过来的,确实很丑陋,很影响代码可读性,现在Ruby对这些符号变量的使用是depreciated的

  要想涵义清楚点,要么可以导入English.rb模块

  require 'English'

  $MATCH # 相当于 $&

  $PREMATCH # 相当于 $`

  $POSTMATCH # 相当于 $'

  或者动用Regexp.last_match

  Regexp.last_match.to_s # 相当于 $&

  Regexp.last_match.pre_match # 相当于 $`

  Regexp.last_match.post_match # 相当于 $'

  类似的变量还有一些如$/ $* $.等,具体涵义可查相应的文档,自己写最好是不要用了

  Q:=~是什么意思?

  从Perl继承的,拿一个字符串和一个正则表达式进行匹配,返回第一次匹配的位置

  和Perl不同的是,在Ruby中string =~ regexp和regexp =~ string两种写法都可以

  Q:<=>是什么意思?

  a <=> b返回-1 / 0 / 1或nil,左小右大则返回-1,左大右小则返回1,左右相等则返回0

  比较没意义(不是同类对象比较)则返回nil,如123 <=> "abc"

  Q:===是什么意思?

  很多类定义了自己的===方法,涵义各不相同,例如:

  § Range类的===是测试参数是某个range的成员,如(1..10) === 5返回真

  § String类的===和==意义相同,都是测试两个字符串的值是否相等

  § Regexp类的===和=~意义相同,测试是否匹配

  § Class类的===是测试参数是否是类的成员

  String、Array、Integer这些类本身也是对象,是Class类的实例,所以下面都返回真

  String === "abc"

  Array === [1,2,3]

  Integer === 123

  有的语言成分依赖===,但没有显式地使用===,最主要的是case...when结构(见下一问)

  另外Arra#grep方法也依赖===

  a = [1, "abc", :sss, 4.6, "def", :bar ]

  p a.grep(String) # ["abc", "def"]

  Array#grep方法,是对数组的每个元素elem,用方法参数arg === elem为真的则保留

  这里就表示挑出String === elem为真的elem,也就是类为String的对象

  Q:case...when结构的用法是什么?

  最常见的case...when结构的用法如下:

  generation = case birthyear

  when 1946..1963 then "Baby Boomer"

  when 1964..1976 then "Generation X"

  when 1978..2000 then "Generation Y"

  else nil

  end

  case后面的表达式只求值一次,得到的值依次去被when后的对象用===比较,哪一次为真,则返回相应的值,此例中就是以1946..196、1964..1976、1978..2000三个range对象去===birthyear

  Q:赋值操作、方法定义和方法调用里的*是什么意思?

  § 赋值操作比如:

  x, *y = 1, 2, 3 # x == 1; y == [2,3]

  *x, y = 1, 2, 3 # x == [1,2]; y == 3

  x, *y, z = 1, 2 # x == 1; y == []; z == 2

  *这标记的作用好像是在说“你们先拿,剩下全归我”

  在平行赋值中,左边只可以有一个*,但是位置可以任意(1.8版本只能在最后)

  别的变量得到各自的值以后,剩下的全归*,变成一个数组(数组有可能为空)

  在方法定义中的情况一样,对于多参数而言,也是“你们先拿,剩下全归我”

  def foo(a,b,*x)

  # 表示调用foo时,至少要两个参数,赋值给a和b,剩下全给x,x是一个数组

  def bar(*args) # 表示可以有任意数量的参数

  方法调用中*的作用和定义相反,是放在一个数组之前,把其元素拆成参数

  args = [1,2,3]

  bar(args) # 传递给bar的是一个参数,数组[1,2,3]

  bar(*args) # 传递给bar的是3个参数,1,2,3

  Q:代码块是对象吗?

  不是。代码块不能独立存在,单独写{|n| n * 2 },是会报错的。

  但是代码块可以对象化,对象化后的代码块是Proc类的实例。

  将代码块对象化的写法主要有两种:

  proc1 = Proc.new {|n| n * 2 }

  proc2 = lambda {|n| n *2 }

  两种写法生成的proc对象有细微差别,break和return等的行为有异。

  Q:为什么这样写不行:foo = lambda {|n| n * 2 }; foo(5)

  Python类似的写法foo = lambda n: n * 2可行,但在Ruby中,foo得到的是一个对象,而非函数,不能在对象上加参数,当成方法用。

  所以得写成foo.call(5),表示在foo对象上调用call方法,传递参数5

  Q:代码块{ |a; x| }里设置参数的部分,分号后面的变量是什么意思?

  (1.8版本不可用)分号前面的a,用来接受方法传递过来的参数,自然是block-local的

  分号后面的x,则是设置别的block-local变量,在代码块中修改x,不会影响代码块外可能存在的x,如:

  x = a = 9

  3.times do |a; x|

  x = a * 2

  print [ a, x ] # 依次打印[0, 0][1, 2][2, 4]

  end

  print [ a, x ] # 仍然是[9, 9]

  x = a = 9

  3.times do |a|

  x = a * 2

  print [ a, x ]

  end

  print [ a, x ] # 变成[9, 4]了

  Q:->是什么意思?比如 ->(x,y=10) { print x*y }

  是1.9版本新加的lambda语法,把原本在代码块中的参数移到前面去了

  ->(x,y) { print x * y } # 相当于 lambda { |x,y| print x * y }

  有一个好处是参数可以设置默认值,->(x,y=10) {}

  有争议的地方是和别的语言中的->的涵义完全不同

  Q:不接代码块的each方法是什么意思?比如e = [ 1, 2, 3, 4, 5 ].each

  很多方法会根据是否后接block而运行不同的功能,返回不同的值。

  比如这个each方法,如果后接代码块,则会把数组中的每个元素依次传递给代码块,让它运行某些命令,而如果each方法未后接代码块,则返回一个Enumerator实例

  很多一般后接代码块的迭代方法若不加block,都返回Enumerator实例,如File类和String类的each_line、each_char等(这个不是语法规定,而是方法内部就这么处理的,具体参见官方API文档)

  Q:Enumerator类的作用是什么?

  可以说把迭代操作这个动作抽象化为对象。一般的用途包括:

  1、多个对象同时并行迭代,如:

  e1 = [ 1, 2, 3, 4, 5].each

  e2 = [ 99, 98, 97, 96 ,95].each

  new_array = []

  loop {

  new_array << e1.next

  new_array << e2.next

  }

  p new_array # [1, 99, 2, 98, 3, 97, 4, 96, 5, 95]

  2、给原来的迭代方法增加新的功能,如Enumerator类有一个方法with_index:

  e1 = string.each_char

  e2 = array.each

  e1.with_index(1) {|char,index| } # 参数1表示从1开始计数,无参数则从0开始

  e2.with_index {|elem,index| }

  这样传递给后面block的,就不仅包括原来的每个字符、每个元素,连带把对应的索引数也传了

  3、无限循环。可以定义一个带yield的方法,转换为Enumerator对象,实现无限循环

  def foo

  i = 0; loop { i = i + 3; yield i }

  end

  #foo {|i| print i} # 别运行,这是死循环

  e = to_enum(:foo)

  # to_enum的作用是把:foo这个symbol所指代的foo方法转为Enumerator对象

  1234.times { e.next } # 让它迭代1234次,可以无限迭代

  p e.next # 3705

  Q:yield是干什么用的?

  方法定义中把控制权交给代码块,是用来实现each这一类迭代方法的直接途径:

  def from_to_by(from, to, by)

  x = from

  while x <= to

  yield x

  x += by

  end

  end

  from_to_by(3,26,4) {|x| print x, " " } # 3 7 11 15 19 23

  自己的迭代方法就这样定义好了

  Q:iterator?是什么意思?

  现在一般写成block_given?,这就好理解一点了吧。

  在方法定义中用来判断这个方法在调用时是否后接代码块

  def foo

  if block_given?

  # blah blah

  else

  # blah blah

  end

  end

  这样一个方法就可以根据是否后接block而做不同的事了

  iterator? 是block_given?的同义词,字面意思是问当前方法是否用作iterator,用作iterator意味着必接block,像each这样的方法可以说是iterator方法,但不是所有后接代码块的都是iterator,如File.open(file) {|f| },这个时候说open是iterator就不太妥当,而说block_given?总是恰当的

  Q:方法定义和方法调用里的&是什么意思?比如def foo(a,b,&blk)

  在方法定义中,&连带后面的变量名必须是最后一个,表示把方法调用时的代码块转换为Proc实例

  def foo(a,b,&blk)

  # blah blah

  end

  foo(x,y) {|n| n + 1}

  # blk的值就相当于Proc.new {|n| n + 1}了

  如果没带代码块,不会报错,只是blk的值为nil了

  用这种方式最大的好处是:blk是一个对象,可以传递给别的方法

  而 blk.call(x,y) 相当于 yield x,y,blk.nil? 也可以达到和 block_given? 同样的目的,检测是否接了代码块

  Q:array.map(&:upcase)是什么意思?

  这种写法有点晦涩。上面已经说了&的涵义,&要求它后面的对象是个Proc实例,假如不是,则调用它的to_proc方法生成一个proc

  而Symbol类正好有一个实例方法to_proc

  :a_method.to_proc 变成的代码块相当于:

  Proc.new {|obj, *args| obj.send(:a_method,*args) }

  array.map(&:upcase)的理解过程是:

  一变:array.map {|obj, *args| obj.send(:upcase, *args) }

  二变:array.map {|obj, *args| obj.upcase(*args)

  三变:array.map {|obj| obj.upcase } # upcase这个方法不需参数

  Q:class Foo < Bar是什么意思?

  表示创建新的类Foo,是Bar的子类,Ruby用<形象地表示Foo和Bar之间的关系

  <也可以用来快速检测两个类或模块之间的关系,如String类是Object类的子类,则

  String < Object # true

  Object > String # true

  Q:class << obj是什么意思?

  打开obj的singleton类,通常用来定义singleton方法

  比如str是个字符串,也就是个String类的实例,String类的实例方法str都可以调用

  我们又可以定义只有str这个对象才能调用的方法,这样的方法就是str的singleton方法

  class << str

  def foo # 这个foo方法只能被str调用,不能被String类的其他实例调用

  # blah blah

  end

  end

  Q:def obj.method是什么意思?

  也是定义obj的singleton方法,直接定义,没有打开singleton class

  定义所谓类方法,也是这种方式:

  def String.foo

  # blah blah

  end

  实际上类也是对象,所谓类方法,也就是类对象的singleton方法

  Q:定义方法为什么不用self作为第一个参数?

  Ruby是纯OOP语言,没有函数,全是方法,所以省了传递self

  class String

  def foo(x,y,z)

  # blah blah

  end

  end

  str = "abc"

  str.foo(1,2,3)

  # 方法定义时的参数,和方法调用时的参数,看起来就一致了

  Q:Ruby中的self是变量么?

  不是变量,而是个关键词。在任何环境self都指向一个对象

  module Foo

  p self # self 为 Foo

  class Bar

  p self # self 为 Foo::Bar

  def baz

  p self # self 为调用此方法的对象

  end

  end

  end

  Q:sub、gsub方法是什么作用?

  String类的sub方法作用是替换子串并生成新字符串,gsub是替换所有匹配子串

  对应的sub!和gsub!是在原字符串上进行修改,不生成新对象

  String#replace并不是替换子串的作用,而是把字符串整个替换成别的值,但本身对象不变

  str = "abc"

  str.replace "def"

  # str有相同的object_id,但内容由"abc"替换为"def"了

  Q:String类的scan方法是什么作用?

  从一个字符串中抽取出所有匹配的子串

  str = "a1b2c3d4e5"

  p str.scan(/\d/) # ["1", "2", "3", "4", "5"]

  可以后接代码块依次处理每个匹配子串

  str.scan(/\d/) {|c| print c}

  Q:Array类的&和|表示什么意思?

  &表示返回两个数组的交集,去除重复元素

  [ 1, 1, 3, 5 ] & [ 1, 2, 3 ] #=> [ 1, 3 ]

  |表示返回两个数组的并集,去除重复元素

  [ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ]

网友评论

登录后评论
0/500
评论
zchd
+ 关注