一切皆为对象

“Hello”.length

方法

定义：def开头 end结尾

命名一般采用下划线分隔单词

字符串中可以嵌入表达式

返回值：a）return+返回值 b) 函数最后一行代码的值为返回值（太神奇了）

类

定义：class 开头 end结尾

Initialize是构造方法

@开头的变量是实例变量（一个实例对应一个变量）

to_s 方法可重载

self. 定义类方法（用类名调用，类似类静态方法，不需实例化对象）

@@开头是类变量（类似静态变量）

类的继承

<表示继承

class Popsong < Song

         def initialize(name, artist, duration, lyrics)

                   super(name, artist, duration)

@lyrics=lyrics

         end

end

super调用父类同名方法

模块Module

模块是一种集中方法、类和常量的方法

好处：

1. 模块提供了一个namespace，防止命名冲突
2. 通过模块能实现混合插入（mixin）功能，混合插入机制实现了多重继承

定义：以module开头，以end结尾

块（block）

一种匿名函数，或称作闭包closure

{puts “hello world”}

或者

do

puts “Hi!”

end

还不太懂

Ruby基本数据类型

数字型

多大整数都可以显示，不会自动转换成浮点型

运算符

+-*/%**

%取模

**幂运算

&|^ 与或非

<<>>[]左移右移取位(从低到高)

abs取绝对值

ceil/floor/round 向下取整、向上取整、四舍五入

odd?/even?/zero? 奇数？偶数？零？ 返回bool型

times/upto/downto/step

# 执行n次block

5.times { puts "+" }           # 打印5个+

# 从1加到5

1.upto(5) { |i| print i, "+" }      # 1+2+..5+

# 从99减到95

99.downto(95) { |i| print i, "+" }     # 99+..95+

# 从50到80，以5为间隔

50.step(80, 5) { |i| print i, "+" }        # 50+55+..80+

字符串

双引号或者单引号

单引号内不执行转义

字符串典型方法

size/length/bytesize/empty?

其中size和length返回字符数

bytesize返回字节数

+/<< 字符串拼接

*  字符串重复

%格式化输出

"%05d" % 123                    # "00123"

"%-5s: %08x" % [ "ID", 123 ]   # "ID   : 123"

功能强大的[]

a = "hello there"

a[1]                     #=> "e"

a[1,3]                          #=> "ell"

a[1..3]                         #=> "ell"

a[-3,2]                         #=> "er"

a[-4..-2]                      #=> "her"

a[12..-1]                     #=> nil

a[-2..-4]                      #=> ""

a[/[aeiou](.)\1/]                 #=> "ell"

a[/[aeiou](.)\1/, 0]   #=> "ell"

a[/[aeiou](.)\1/, 1]   #=> "l"

a[/[aeiou](.)\1/, 2]   #=> nil

a["lo"]                         #=> "lo"

a["bye"]                      #=> nil

很神奇，很多不明白

start_with?/end_with?/include?

# 是否以he开头

"hello world".start_with? "he"       # true

# 是否以ld结尾

"hello world".end_with? "ld"  # true

# 是否包含hi

"hello world".include? "hi"      # false

upcase/downcase/swapcase/capitalize

puts "Hi, Ruby".upcase            # HI, RUBY

puts "Hi, Ruby".downcase       # hi, ruby

puts "Hi, Ruby".swapcase       # hI,rUBY

puts "hii, ruby".capitalize                  # Hi, ruby

encoding/force_encoding/encode

# 查看字符串的编码，若编码不为GBK则应该注意

puts "我爱Ruby".encoding     # ASCII-8BIT

# 强制转化编码，只改变编码标识，并不改变内容

#（当你知道其本来编码的时候非常有用）

"我爱Ruby".force_encoding("GBK")

# 假设某字符串是UTF-8编码的，可以encode为GBK

"我爱Ruby".encode("GBK")

split/scan

# 切割字符串为数组

"1,2,,3,4,,".split(',') # ["1", "2", "", "3", "4"]

# 扫描字符串为数组（与split相反）

a = "cruel world"

a.scan(/\w+/)                    # ["cruel", "world"]

a.scan(/(..)(..)/)                  # [["cr", "ue"], ["l ", "wo"]]

a.scan(/\w+/) {|w| print "<<#{w}>> " }

# <<cruel>> <<world>>

strip/rstrip/lstrip

# 去除字符串旁边的空白

"    hello    ".lstrip             # "hello   "

"    hello    ".rstrip             # "    hello"

"    hello    ".strip              # "hello"

each_char/each_byte/each_line/

# 遍历字符

"hello".each_char {|c| print c, ' ' }

# h e l l o

# 遍历字节

"hello".each_byte {|c| print c, ' ' }

# 104 101 108 108 111

# 遍历每一行

"hello\nworld".each {|s| p s}

#

        "hello\n"

        "world"

数组

表示

[ 3.14159, "pie", 99 ]      # 中括号

Array.new                           # 相当于 []

%w{ haha xixi hoho }         # %w方式定义字符串数组

Ruby的数组（及其他集合）中成员类型不必一样，这就是传说中的异构

典型方法

+/-/*/&/<<

# +等于concat

[ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]

# - 即A集合减去B集合中所有的元素

[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]

[ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]

# 两个数组的交集

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

#  把一个对象push到数组当中

[ 1, 2 ] << "c" << "d" << [ 3, 4 ]

#=> [ 1, 2, "c", "d", [ 3, 4 ] ]

[]

# []的有三种用法

a = [ "a", "b", "c", "d", "e" ]

        a[2] +  a[0] + a[1]   #=> "cab"

        a[6]           #=> nil

        a[1, 2]               #=> [ "b", "c" ]

        a[1..3]                #=> [ "b", "c", "d" ]

        a[4..7]                #=> [ "e" ]

        a[6..10]             #=> nil

        a[-3, 3]               #=> [ "c", "d", "e" ]

        # special cases

        a[5]           #=> nil

        a[5, 1]                #=> []

        a[5..10]             #=> []

find/find_all

# find到一个即返回，别名detect

(1..100).find {|i|

         i % 5 == 0 and i % 7 == 0

}  

#=> 35

# find_all找到全部符合条件的对象，别名select

(1..100).find_all {|i|

         i % 5 == 0 and i % 7 == 0

}  

#=> [35,70]

first/last/join

a = [ "q", "r", "s", "t" ]

# 第一个元素

a.first                          #=> "q"

a.first(2)                     #=> ["q","r"]前两个元素

# 最后一个元素

a.last     #=> "t"

# 把数组变成字符串

[ "a", "b", "c" ].join #=> "abc"

[ "a", "b", "c" ].join("-")   #=> "a-b-c"

inject/collect

# inject理解的难点在于block中的两个参数

# sum是上一次block的返回值，初始化为0或nil

# n是遍历数组的每一个元素

[5,6,7,8,9,10].inject {|sum, n| sum + n }            #=> 45

输出45

遍历

# collect别名map，遍历数组并改变它们的内容后输出

a = [ "a", "b", "c", "d" ]

a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]

each/each_with_index/cycle

# 遍历元素

a = [ "a", "b", "c" ]

a.each {|x| print x, " -- " }遍历元素输出，以—分隔

# 遍历元素并带上下标 第一个参数是数组值，第二个参数是下标

a.each_with_index {|obj, i| print "a[#{i}] : #{obj}" }

# 循环一个数组

a.cycle {|x| puts x }        # print, a, b, c, a, b, c,.. forever.

a.cycle(2) {|x| puts x }    # print, a, b, c, a, b, c.

delete/delete_if/insert/pop/push

# 删除所有的b字符串

a = [ "a", "b", "b", "b", "c" ]

a.delete "b"                        # b

# 删除满足条件的元素

a.delete_if {|x| x >= "b" }                  # ["a"]

# 在某序列前插入对象

a.insert(2, “b1")                         # ["a", "b", "b1"...

# pop和push组合起来可以把一个Array直接当成Stack

a.pop                                    # "c"

a.push "d"       

sort/uniq/shuffle/shift

# 自动排序

[ "b", "c", "a" ].sort                   # ["a","b","c"]

# 去重

[ "a", "a", "b", "b", "c" ] .uniq          # ["a", "b", "c"]

# 随机变化 洗牌么~

a = [ 1, 2, 3 ]

a.shuffle                     # [2, 3, 1]

a.shuffle                     # [1, 3, 2]

#shift是神马？

哈希Hash

表示

[]表示数组，{}表示hash 跟perl一样么

{ "foo"=>123, "bar"=>456 }             # 大括号

典型方法

[]/[]=

# 取Hash中的某key的值

h = { "a" => 100, "b" => 200 }

h["a"]                                   #=> 100

h["c"]                                  #=> nil

# 设置Hash的对象

h["a"] = 9

h["c"] = 4

h               #=> {"a"=>9, "b"=>200, "c"=>4}

has_key?/has_value?

# 验证Hash中是否存在某key

h = { "a" => 100, "b" => 200 }

h.has_key?("a")                #=> true

#验证Hash中是否存在某value

h.has_value?(999)   #=> false

each/each_key

# 取Hash中的某key的值

h = { "a" => 100, "b" => 200 }

h.each {|key, value| puts "#{key} is #{value}" }

h.each_key {|key| puts key }

*each若只一个参数，则取出每个键值对

h.each {|key| puts "#{key}" }

delete/delete_if/select

# 删除某个key

h = { "a" => 100, "b" => 200 }

h.delete("a")                      #=> 100

# 只删除满足条件的

h.delete_if {|key, value| key >= "b" }

# 挑选出元素

h = { "a" => 100, "b" => 200, "c" => 300 }

h.select {|k,v| v < 200}              #=> {"a" => 100}

范围Range

表示

.. 相当于[]

…相当于[ ）

1..10                # 包含10

1...10                # 不包含10

'a'..'z'               # 从a到z的字母

0...anArray.length

典型方法

to_a/begin/end

# 把范围展开

(1..7).to_a                 #=> [1, 2, 3, 4, 5, 6, 7]

# 取头

(1..7).begin                #=> 1

# 取尾

(1..7).end                   #=> 7

===/include?

# ===主要是用在case when语句中，相当于在range中查找某值

# 与include?结果相同

("a".."z").include?("g")  # => true

("a".."z")===("g")  # => true

each

# 把范围展开

(10..15).each do |n|

     print n, ' '

end

# =》 10 11 12 13 14 15

正则表达式Regexp

表示

a = Regexp.new('^\s*[a-z]')             # /^\s*[a-z]/

b = /^\s*[a-z]/                   # 两个斜杠是最简单的表示法

c = %r{^\s*[a-z]}                         # /^\s*[a-z]/

d = %r<^\s*[a-z]>                      # /^\s*[a-z]/

典型方法

=~、!~、

#确定匹配

/a/ =~ "Fats Waller"                  # true

# match是=~的别名

/a/.match "Fats Waller"           # true

# 否定匹配

/z/ !~ "Fats Waller"          # false

表达式

条件控制if（注意elsif）

if count > 10

    puts "Try again"

elsif tries == 3

    puts "You lose"

else

    puts "Enter a number"

end

条件控制unless

unless  等价于  if not ，意思是： 除非 或 如果不

puts "ok" unless count > 10

真或假

只有false和nil是假，其余的都为真

puts "not execute" if nil

puts "execute" if 1

puts "execute" if 0

puts "not execute" if false

puts "execute" if true

puts "execute" if ""

puts "execute" if Array.new

case…when

其实也就是大家熟悉的switch case，只不过更加高级一点

例如：

case 主角状态
when "昏迷"
   print "你昏迷了.."
when "中毒"
   print "你中毒了.."
when "昏睡"
   print "你昏睡了.."

else

    print "未知状态"
end

每个when后面不用再跟break了

通用比较操作符

循环

while表示循环地球人都知道，Ruby里面until也可以用来循环，意思与while相反，直到条件为真，才停止操作

while i <= 60

    # ...

end

等价于

until i > 60

    # ...

end

转自：http://www.cnblogs.com/lunashang/archive/2012/05/07/2487600.html