Programming Ruby(读书笔记)-1~2章

Interactive Ruby(命令行交互)

ruby:输入后，ctrl+d(end-of-file character)，即可执行

irb:是ruby提供的交互工具。

 

Ruby Documentation:RDoc and ri

RDoc与javadoc类似，用于导出source file中的API说明，导出的文件格式可以是HTML，也可以是ri格式。

ri:离线文档显示工具，比如ri GC或ri GC::enable。但在win下安装的runby环境中，上述命令没有对应的文档不输出，还需更多了解。

eg.

ri Array

ri Array.sort。

::用于类方法; #用与实例方法。

在线文档1 文档2

 

----------------------Ruby.new---------

Everything you manipulate is an object,and the results of those manipulations are themselves objects.

获取绝对值,java>num = Math.abs(num)；ruby> num=-1234 positive=num.abc，即已经内置。

不需要使用semicolons(分号)分隔，只是使用换行；使用#作为注释开始，代码缩进采用两个字符的风格，变量不需要声明，使用的时候自被创建分配。

 

puts say_goodnight("name") == puts(say_goodnight("name"))

 -------

 

创建字符串对象主要的两种方式：使用单引号，使用双引号。两者的差别是在ruby构造字符串对象是，单引号样式的会做更少，并且更少的异常，它只把输入的字符连接成串，而双引号样式需要做更多工作，第一，它要先查找是否有斜杠标识的替换符，如果有则替换它们为二进制的值，比如：

puts "And good night,\nGrandma"

打印：

And good night,

Grandma。

第二，ruby要解析串中的表达式，如#{name}，同样需要进行值替换。

所以，如果字符串中没有需要转义的字符，或者没有需要替换的变量值，最好使用单引号括起来，以提高性能，是这样的吧？

 

say_goodnight方法还可以更简化，return返回的是块中最后一句的值，所以，可以去掉中间的赋值操作，如下：

def say_goodnight(name)
  "Good night #{name}"
end

 puts say_goodnight('pa')打印的结果与更早前的一样。

--------------

Ruby的命名约定主要通过名称的前缀来标识：Local variables,method parameters,method names首字母小写或下划线；Global variables前缀$，instance variables前缀@，Class variables前缀@@，class names,module names,constants(常量全大写)首字母大写。

在上述约定的基础上，可使用字母、数字、下划线，但注意@后面不能是数字。

名称含多个单词时，instance variables用下划线，Class name使用MixedCase（每个单词首字母大写）

样例如下表：（Class variable与Global variable是什么概念？）

Local Variable:	name   fish_and_chips   x_axis   thx1138   _x   _26
Instance Variable:	@name   @point_1   @X   @_   @plan9
Class Variable:	@@total   @@symtab   @@N   @@x_pos   @@SINGLE
Global Variable:	$debug   $CUSTOMER   $_   $plan9   $Global
Class Name:	String   ActiveRecord   MyClass
Constant Name:	FEET_PER_MILE   DEBUG

----------Arrays and Hashes------------

Arrays与Hashes用来存储对象的集合，通过key来获取，arrays是通过整型，Hashes支持任何类型的key。它们都是根据需要自增长，array效率更高，hashes更灵活，两者都可以存储不同类型的对象。包括基础类型。

array:

a = [1, 'cat', 3.14]

puts "The first element is #{a[0]}"         //下标从0开始

 

a[2] = nil

puts "The array is now #{a.inspect}"

=>The array is now [1, "cat", nil]

注意：Ruby中的nil不同于其它语言的null,在此它同样表示一个对象，与其它对象一样，只是它用来表示nothing。

创建数组会因引号和逗号而麻烦，可以使用%w来简化这个操作，比如上面的示例也可以写成:

 

a = %w{cat bee dog elk}
puts a[0]

hash

与array不同的是，使用花括号{}来包含，array中方括号[]包含。并且每个元素是键值对的形式，中间使用=>来衔接，比如：

 

inst_section = {
  'cello' =>'string',
  'oboe' => 'brass'
}

 key必需唯一(不唯一 会覆盖)。

p inst_section['cello']         //p与puts类似，只是p会打印nil对象为nil，而puts则不打印。

对于不存在的key，默认返回nil，nil在条件表达式中即false。但是一些时候，我们希望它返回是0这种数值，比如，程序是计算单词在文章中出现的次数。则可使用下面的方式：使用Hash.new(0)

 

histogram = Hash.new(0)  //The default value is zero
histogram['ruby']         //打印0
histogram['ruby'] = histogram['rbuy'] +1 //赋值
histogram['ruby']    //打印1

 array与hash有很多有用的方法。

--------Symbols(标记)---

Java中，我们会使用这样代码用于这样的场景:

 

NORTH = 1;SOUTH = 2;WEST = 3;EAST = 4
if (direction == NORTH)
....

Ruby中则不需要先定义，可直接使用

 

if direction == :north
  #...
end

标识串以：作为前缀。There's no need to assign some kind of value to a symbol-Ruby take care of that for you.Ruby also guarantees that nomatter where it appears in your program,a particular symbol will have the some value.

标识在hash中常作为key使用，比如:

 

inst_section = {
  :cello => 'string'
}
puts "An oboe is #{inst_section[:cello]} instrument"

 为此，Ruby提供一种更简化的方式:

 

inst_section = {
cello: 'string'
}
puts "oboe is #{inst_section[:cello]} instrument"

 注意：使用key时，一定要:cello而不能cello或cello:

--------control structures控制结构----------

 

today = Time.now
if today.saturday?
  puts "Do chores around the house"
elsif today.sunday?
  puts "Relax"
else
  puts "Go to work"
end

 没有大括号，没有分号，只有end，同样while也是以end结束。

 

 

while line = gets        //gets是从标准输入中获取内容，赋给line，nil被认为                                          //false，则可终止while
  puts line.downcase
end

 这面这个示例是为了说明：Most statements in Ruby return a value,which means you can use them as conditions.

如果if or while只是一句表达式，则可以使用Ruby的statement modifiers作为快捷方式，比如：

 

if radiation > 3000
  puts "Danger, Will Robinson"
end
等同
puts "Danger, Will Robinson" if radiation > 3000

square = 4
while square < 1000
  square = square*square
end
等同
square = square*square while square < 1000

 -----------Regular Expressions-----------

Ruby中/pattern/表示正则表达式，它本身也是对象，即可作为对象处理。

/Perl|Python/字符串中包含Perl或Python。

/\d\d:\d\d:\d\d/ # a time such as 12:34:56

/Perl.*Python/ # Perl, zero or more other chars, then Python

/Perl Python/ # Perl, a space, and Python

/Perl *Python/ # Perl, zero or more spaces, and Python

/Perl +Python/ # Perl, one or more spaces, and Python

/Perl\s+Python/ # Perl, whitespace characters, then Python

 

/Ruby (Perl|Python)/ # Ruby, a space, and either Perl or Python

正则式的使用

使用：=~  'abc' =~ /a*b*c+/

结果要么是匹配的首位置，要么是nil，所以，也可以把匹配表达式用于if等条件判断，比如：

 

line = gets
if line =~ /Perl|Python/ #这只是一个匹配表达式，不表示把结果赋值给line
  puts "Script language menthioned : #{line}"
end
如果只是打印
puts line =~ /Perl|Python/ 则打印的是匹配的首位置
#Ruby的提供了用于字符串替换的方法
line = gets
newLine = line.sub(/Perl/, 'Ruby')  # Replace first Perl with Ruby
newLine = line.gsub(/Python/, 'Ruby') # Replace every Python with Ruby

 ------Blocks and Iterators 块与迭代器------------

代码块可分配给方法调用，就像它们是参数一样。使用代码块实现callback(比JAVA的内部类更简单)，to pass around chunks of code，或者实现迭代器。

代码块的定义：使用花括号包括或使用do与end包括。

 

{puts 'Hello'}
或
do
  club.enroll(person)
  person.socialize
end

 {}用于单行，do end用于多行

使用代码块

将代码块关联一个调用方法，you do this by putting the start of the block at the end of the source line containing the method call.将代码块放在包含了方法调用的行的后面。

 

greet {puts 'Hi'}
varbose_greet("Dave", "loyal customer") {puts 'Hi'}

 然后方法就可以调用一次或多次代码块了，通过使用yield。you can think of yield as being something like a method call that invokes the block associated with the call to the method containing the yield.

 

def call_block
  puts "Start of method"
  yield
  yield
  puts "End of method"
end
call_block {puts 'in the block'}

produces:
Start of metho
In the block
In the block
End of method

 块中的代码执行两次，一次yield调用一次。

Some people like to think of the association of a block with a method as a kind of argument passing.This works on one level,but it isn't really the whole story.You may be better off thinking of the block and the method as coroutines,whick transfer control backand forth between themselves.

可以调用时传入参数给代码块。在代码块中使用|params,....|列出来接入参数的名称。

 

def who_says_what
  yield('Dave', 'hello')
  yield('Andy', 'goodbye')
end
who_says_what {|person, phrase| puts "#{person} says #{phrase}"}
produces:
Dave says hello
Andy says goodbye

 代码块在贯穿整个Ruby包用于实现iterators（迭代器)-用于从集合中获取successive(连续的)元素的方法。

 

animals = %w{ant bee cat dog}
animals.each {|animal| puts animal}
produces:
ant
bee
cat 
dog

使得方法们 猛烈的来一波

 

['bee', 'dog', 'cat'].each {|animal| print animal, '  '}
5.times {print '*'}
3.upto(6) {|i| print i}
('a'..'e').each {|char| print char}
puts
produces:
cat dog horse *****3456abcde
#5与3都是对象，print打印没有换行

----------Reading and Writing---------------

 

printf("Number:%5.2f,\nString:%s\n", 1.23, 'hello')
produces:
Number: 1.23,
String: hello

 gets puts print都是输入输出的方法，但是下面的不知道怎么样才能使gets返回的是nil

 

while line = gets
  print line
end

 ---------命令行参数--------

定义文件:cmd_line.rb

puts "You gave #{ARGV.size} arguments"
p ARGV 
produces:
You gave 4 arguments
["ant", "bee", "cat", "dog"]

 -------------------------------------------------Onward and Upward--步步高升------------------------