Ruby 简单入门（二）

8..Ruby 中有意思的东西

• ‘#’号被用来做单行注释
• 单行语句不需要以；分号结尾，不过要想使两条单条语句放在一行可以使用，稍后代码例子一起放出
• 反斜杠除了转义还可以用来连接字符
• 变量是不需要声明的，但是还是要注意作用域

# 单行注释
a = 1  #没有；结尾
b = 2; c = 3 #两行语句在一行的时候
name = "Cass \
Dean"   # \连接
puts "#{name}"
puts "goodbye"

结果：

Cass Dean
goodbye

9..一切皆对象Objects

1.5.floor()   #=> "1" 
普通的判断语句是

if( x > 7 && x < 12 ) { ... }
Ruby中完全可以这么写

if x.between?(7,12) do ...
10..Big Numbers
数字中，ruby自动改变精度

for i in 1..1000
  puts "2 ** #{i} = #{2**i}"
end
结果是

2 ** 1 = 2
2 ** 2 = 4
2 ** 3 = 8
2 ** 4 = 16
2 ** 5 = 32
2 ** 6 = 64
2 ** 7 = 128
2 ** 8 = 256
2 ** 9 = 512
2 ** 10 = 1024
...
2 ** 1000 = 107150860718626732094842504906000181056140481170553360744375038837035105112493612249319837881569585812759467291755314682518714528569231404
359845775746985748039345677748242309854210746050623711418779541821530464749835819412673987675591655439460770629145711964776865421676604298316526243868
37205668069376

显然，1024和 2的10000次方不是同一个数据类型，通过.class.to_s查看之，

x = 1000000
puts "#{x}  "+x.class.to_s    => 1000000  Fixnum
x = x * x
puts "#{x}  "+x.class.to_s    => 1000000000000  Bignum
x = x / 1000000
puts "#{x}  "+x.class.to_s    => 1000000  Fixnum
11..交换参数
这个不多说了，看代码就知道了，说的就是交换变量的时候，api直接封装到了不用中间变量就可以相互交换值。

i = 0
j = 1
puts "i = #{i}, j=#{j}"
i,j = j,i
puts "i = #{i}, j=#{j}"
结果是

i = 0, j=1
i = 1, j=0

12..集合Collections

 
 
Arrays		
	1，array中的元素可以是不同类型的

		
nums = [1, 2.0, "three"]
puts nums[2]  => three
	2，array的索引可以使用负数

nums = [1, 2.0, "three", "four"]
puts nums[-1]   => four
	这里的nums[-1]其实就是nums[nums.length()-1]
	3，还可以想JQuery那样，使用first或last直接取首末值

[1,2,3].last  => 3
[1,2,3].first => 1
	4，使用length来取数组的大小

	5，可以使用%w快速建立数组，减少符号使用

	
my_array = %w{nokia google apple} #简单的字符串数组
	6，使用inspect可以查看array所有元素，而p座位puts obj.inspect的缩写，经常使用

myarray = [1,2,5,7]
puts myarray
puts myarray.inspect
p myarray
结果是

1
2
5
7
[1, 2, 5, 7]
[1, 2, 5, 7]
	7，其他操作

1，&符号有点交集的意思  

puts [1,2,3] & [3,4,5]  #  prints 3  

2，+代表两个array所有元素的合并，重复也合并  

puts [1,2,3]+ [3,4,5]  #  prints 1,2,3,3,4,5  

3， -代表除掉前者中的元素在后者中存在的元素  

puts [1,2,3] - [3,4,5]  #  prints 1,2  

4，pop 方法，返回最后一个元素，同时删除此元素  

alpha = ["a","b","c","d","e","f"]  
puts "pop="+alpha.pop   # pop=f  
puts alpha.inspect      # ["a", "b", "c", "d", "e"]  

5，push 代表在前者后插入后者所有元素 
 
alpha = ["a","b","c"]  
alpha.push("x","y","z")  
puts alpha.inspect      # ["a", "b", "c", "x", "y", "z"]  

6，shift 返回第一个元素，和pop一样，会把自己从array中删除  

alpha = ["a","b","c","d","e","f"]  
puts "shift="+alpha.shift   # shift=a  
puts alpha.inspect      # ["b", "c", "d", "e", "f"]  

7，unshift 和shift相反，在前面插入  

alpha = ["a","b","c"]  
alpha.unshift("x","y","z")  
puts alpha.inspect      # ["x", "y", "z", "a", "b", "c"]  

 
 
	Hashes
	1,简单的hash

	
cars = {
'altima' => 'nissan',
'camry' => 'toyota',
'rx7' => 'mazda'
}
puts cars['rx7']   =>   mazda
	2，动态填充hash

	
dict = {}  
dict['H'] = 'Hydrogen' 
dict['He'] = 'Helium'
dict['Li'] = 'Lithium'
p dict['H']       # prints "Hydrogen"
p dict.length     # prints 3
p dict.values     # prints ["Lithium", "Helium", "Hydrogen"]
p dict.keys       # prints ["Li", "He", "H"]
p dict            # prints {"Li"=>"Lithium", "He"=>"Helium", "H"=>"Hydrogen"}

	3，Hash[]可以想数组那样快速建立hash

	
toppings = Hash["pancakes","syrup","Pizza","Pepper","Cereal","Sugar"]
puts toppings.inspect
#{"Pizza"=>"Pepper", "Cereal"=>"Sugar", "pancakes"=>"syrup"}
	4,each迭代一下下

toppings = Hash["pancakes","syrup","Pizza","Pepper","Cereal","Sugar"]
toppings.each{|key, value| puts "#{key} points to #{value}"}
#Pizza points to Pepper
#Cereal points to Sugar
#pancakes points to syrup
	5,select 快速筛选

salaries = Hash["dean",10.9,"tommy",7.5,"castiel",6.0,"ruby",6.5]
salaries.inspect
mySalaryArray = salaries.select{|name,salary| salary > 7.0}
puts mySalaryArray.inspect #prints  [["tommy", 7.5], ["dean", 10.9]]

   
   
	Ranges 范围
	..和...的魅力

	
('a'..'g').each{ |letter| puts letter }
结果是

a
b
c
d
e
f
g
(1...3).each{ |num| puts num }
结果

1
2
对比一下就知道..和...的区别了