Ruby入門筆記

標籤：

Ruby入門筆記

 

一切皆為對象

“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基礎資料型別 (Elementary Data Type)

 

數字型

多大整數都可以顯示，不會自動轉換成浮點型

運算子

+-*/%**

%模數

**冪運算

&|^ 與或非

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

 

 

 

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

 

RegexRegexp

表示

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

Ruby入門筆記