my_num = 25

my_boollean = true  (or false)

my_string = "Ruby"

加(+)     
减 (-)
乘 (*)
除(/)
幂次方 (**)
求余 (%)

puts 带换行

print 不带换行

打印字符串:  print "HelloWorld" (不换行)

　　　　　　puts "HelloWorld" (换行)

打印变量：　name = "Ruby"

　　　　　　print "#{name}"　    #注意格式  "#{xxx}"

.length(计算字符串长度)    

name = "Ruby"

name.length  (返回4   等价于  "Ruby".length)

.reverse(反转字符串)

name.reverse(返回 ybuR  等价于 "Ruby”.reverse)

.upcase & .downcase (转换大小写)

name.upcase 和 name.upcase 分别返回 RUBY ruby

单行注释以 # 开头   eg. #I'm a comment

多行注释格式为  
=begin
I'm a comment!
I don't need any # symbols.
=end
注意：=和begin和end之间不能有空格   begin后面也不要有空格

变量名一般以小写字母开头， 单词之间用下划线分割, eg. counter, mastrful_method

Ruby不会阻止你用特殊符号如$, @等开头， 但是最好不要这么做， 容易产生歧义， 可读性降低。

用.操作符调用方法

可以每次单独调用一个方法也可以进行联合调用

如：name = "Ruby"

可以

　　name.downcase

　　name.reverse

　　name.upcase

也可以 name.downcase.reverse.upcase 这样调用

print "what's your first name?"
first_name = gets.chomp

gets是用来获取输入信息的方法，Ruby在其后面自动添加一个换行符\n   chomp是用来删除换行符的方法。
eg:
　　print "What's your first name?"
　　first_name = gets.chomp
　　print "What's your last name?"
　　last_name = gets.chomp
　　print "What are you from?"
　　city = gets.chomp
　　print "what's your state?"
　　state = gets.chomp

　　print "#{first_name}  #{last_name}  #{city}  #{state}"

print "Integer please: "
user_num = Integer(gets.chomp)

if user_num < 0
  puts "You picked a negative integer!"
elsif user_num > 0
  puts "You picked a positive integer!"
else
  puts "You picked zero!"
end

注意要以end结尾   elsif的写法(区别于elseif)

if(x<5) then statement1 end

unless x>=5 then statement1 end
这两句是对等的

if x<5 then statement1
else
statement2
end

unless x<5 then statement2 
else
statement1
end
也对等

unless 用来检验后面条件是否为假， 若假则执行后续代码， 若真则执行else (unless 相当于 if not)

相等  ==

不等  !=

大于 >

大于等于 >=

小于 <

小于等于 <=  

与 &&  或 ||  非 !

counter = 1
while counter < 11
  puts counter
  counter = counter + 1
end  #注意以end结尾

counter = 1
until counter > 10
  puts counter
  # Add code to update 'counter' here!
  counter += 1
end #注意以end结尾
注意： Ruby中没有前++和后++，前--后--。 但有+=， -=

for num in 1...10    #三个点表示前闭后开  输出1-9
　　puts num
end

for num in 1..15   #两个点表示前后都封闭， 输出1-15
　　puts num
end

i = 20
loop do
  i -= 1
  print "#{i}"
  break if i <= 0
end

i = 20
loop do
  i -= 1
  next if i % 2 != 0 
  print i
  break if i <= 0
end
输出 18 16 14 12 10 8 6 4 2 0 nil

一维数组表示方法：  array = [1,2,3,4,5]  #注意  用中括号

一维数组的遍历：
　　array = [1,2,3,4,5]
　　方式一：
　　array.each { |x| print"#{x+10}" }   #可以在||之间使用任何变量名， 用来保存从数组中取得的值

　　方式二：
　　array.each do |x|
　　　　x += 10
　　　　print "#{x}"
　　end

多维数组的遍历：
　　s = [["ham", "swiss"], ["turkey", "cheddar"], ["roast beef", "gruyere"]]
　　s.each do |sub_array|
　　　　sub_array.each do |y|
　　　　　　puts y
    　 end
　　end

.times像是for循环的超级压缩版
10.times {print "xxx"}   #打印10次 "xxx"

hash可以存储键值对，即key/value
创建hash
方式一：
my_hash = { "name" => "Eric",
  "age" => 26,
  "hungry?" => true
}

puts my_hash["name"]   #打印出 Eric
puts my_hash["age"]    #打印出 26
puts my_hash["hungry?"]#打印出 true

在花括号中添加key/value 对
用=>符号来实现key/value的对应

方式二  用Hash.new方法创建hash
pets = Hash.new   　　　　#注意Hash首字母要大写
pets["Stevie"] = "cat"
pets["Bowser"] = "hamster"
pets["Kevin Sorbo"] = "fish"

puts pets["Stevie"]
puts pets["Bowser"]
puts pets["Kevin Sorbo"]

Hash.new  创建了一个空的hash
可以用类似数组的方式向构造出的hash对象添加key/value， key作为下标， value作为值
同样可以用类似数组的方法打印key对应的value

遍历hash
restaurant_menu = {
  "noodles" => 4,
  "soup" => 3,
  "salad" => 2
}

restaurant_menu.each do |item, price|
  puts "#{item}: #{price}"
end
类似遍历数组， 针对上例，每次遍历hash，把hash的key赋给item, 把hash的key赋给price， 打印item和price

hash排序
　　puts "Please input: "
　　text = gets.chomp
　　words = text.split()
　　frequencies = Hash.new(0)
　　words.each do |letter|
　　　　frequencies[letter] += 1
　　end　　
　　frequencies = frequencies.sort_by do |word,count|
　　　　count
　　end

def double(n)
  return n * 2
end
def为方法定义关键字， 后面double为方法名，n为参数，return表示函数有返回值， 返回n*2，以end结尾， 方法名和end之间为函数体。

blocks可以理解为没有方法名的方法，blocks可以用关键字do...end表示，也可以用{}表示
例如：
1.times do
  puts "I'm a code block!"
end

1.times { puts "As am I!" }

symbol总是以:开头，后面必须紧跟一个字符或者一个下划线_ 

　　puts :foo.object_id 327458
　　puts :foo.object_id 327458
　　puts :"foo".object_id 327458

　　puts "foo".object_id 24303850
　　puts "foo".object_id 24300010
　　puts "foo".object_id    24296170 

　#在 Ruby 中每一个对象都有唯一的对象标识符（Object Identifier），可以通过 object_id 方法来得到一个对象的标识符。　
　根据上面程序， 可知 symbol和string的区别:
　每个 String 对象都是不同的，即便他们包含了相同的字符串内容；而对于 Symbol 对象，一个名字（字符串内容）唯一确定一个 Symbol 对象(即名字相同，则symbol相同)。
　
哈希表是symbol应用最广泛的地方。
下面这个哈希表表示按城市分类的一些机器的集合。
一个哈希表例子
                
hosts{
       'beijing' => 'machine1',
       'shanghai'  => 'machine2',
       'guangzhou' => 'machine3',
       'tianjin' =>  'machine4',
       'shenzhen' =>　'machine5'
}
如果要引用 beijing 的机器，使用 hosts['beijing'] 。但如果我们程序中要频繁引用哈希表中 value ，这样就不大好了，因为 Ruby 对每一次字符串引用都会生成一个 String 对象，累积下来这个开销是相当大的。

我们完全可以使用 Symbol ，因为对于这些 key 来讲，我们用的就是名字而已，例如下面hosts[:beijing]
使用 Symbol 作为 key
                
hosts　=　{
　:beijing　=>　'machine1',
　:shanghai　=>　'machine2',
　:guangzhou　=>　'machine3',
　:tianjin 　=>　'machine4',
　:shenzhen　=>　'machine5'
}
通常来讲，当你面临 String 还是 Symbol 的选择时，可以参考以下标准：

如果使用字符串的内容，这个内容可能会变化，使用 String
如果使用固定的名字或者说是标识符，使用 Symbol

:sasquatch.to_s  　　 　# ==> "sasquatch" (symbol转string)
"sasquatch".to_sym　　　# ==> :sasquatch (string转symbol)
"hello".intern 和 .to_sym效果相同都可以string转symbol　

new_hash = { 
      one: 1,
      two: 2,
      three: 3
}
冒号在symbol之后， 不再使用=>

my_hash = { one: 1, two: 2, three: 3 }

my_hash.each_key { |k| print k, " " }
# ==> one two three

my_hash.each_value { |v| print v, " " }
# ==> 1 2 3

　　Ruby方法总会返回最近的一次表达式所得到的值。
　　def add(a,b)
　　　　return a+b
　　end
　　等价于:
　　def add(a,b)
　　　　a+b
　　end

three = 3
puts three == 3 ? "Of course." : "What?"
# ==> puts "Of course."