1. 基本的ruby語法
1.1 變量、常量和類型
1) 定義變量
變量類型 |
描述 |
示例 |
局部變量(或僞變量) |
以小寫字母或下劃線卡頭 |
var _var |
全局變量 |
以$開頭 |
$var |
類變量 |
類中定義,以@@開頭 |
@@var |
實例變量 |
對象中定義,以@開頭 |
@var |
常量 |
以大寫字母開頭 |
Var |
2) 變量內插
在雙引號內使用“#{變量名}”內插變量
a = 2 b = 3 puts "#{a} + #{b} = #{a+b}" #輸入結果爲:2 + 3 = 5 |
1.2 註釋
1)單行註釋:以#開頭,如: #註釋內容
2)多行註釋:在=begin 和 =end 之間定義,如:
=begin
註釋內容
=end
1.3 循環和分支
1.3.1 條件語句
If 形式 |
unless 形式 |
a =1 if y==3 |
a=1 unless y!=3 |
x= if a > 0 then b else c end |
x= unless a<=0 then a else b end |
if x<5 then a =1 else a =2 end |
unless x<5 then a =2 else a =1 end |
1.3.2 循環結構
#while循環 i= 0 while i< list.size do print “#list[i] ” I += 1 end |
#until循環 i= 0 until i == list.size do print “#list[i]” i += 1 end |
#for循環 for x in lisy do print “#{x}” end |
#each循環 list.each do |x| print “#{x}” end |
#loop循環 i = 0 n = list.size-1 loop do print “#{list[i]}” i += 1 break id i > n end |
#times循環 n = list.size n.times do |i| print “#{list[i]}” end |
#upto循環 n =list.size–1 0.upto(n) do |i| print “#{list[i]}” end |
#each_index循環 list.each_index do |x| print “#{list[x]}” end |
1.3.3 異常
begin x = Math.sqrt(y/z) rescue ArgumentError #匹配錯誤類型 puts "Error taking square root" rescue ZeroDivisionError #匹配錯誤類型 puts "Attempted division by zero" else puts "Other Error" ensure #這部分代碼在最後一定會執行 end |
1.3.4 類
class Hello #類名必須以大寫字母開頭 @@myname = "John" #類變量
def initialize(name,phone) @name,@phone = name,phone #定義實例變量 end
def hello #定義類方法 puts "#{@name}的電話是#{@phone}" end end
f = Hello.new("Tom","13100000000") #創建類對象 f.hello #調用類方法,結果爲:Tom的電話是13100000000 |
1.3.5 模塊
方法 |
說明 |
include ‘watir’ |
將模塊的功能添加到當前空間中,不加載已加載的文件 |
extend ‘watir’ |
將模塊的函數添加到對象中 |
load ‘watir’ |
讀取文件,並將其插入到源文件的當前位置,以便從這個位置開始就可以使用其定義 |
1.3.6 case語句
case x when 1..10 #匹配數字 puts "First branch" when foobar() #批量方法返回的值 puts "Second branch" when /^hel.*/ #匹配正則表達式 puts "Third branch" else puts "Last branch" end |
函數名稱 |
說明 |
示例 |
* |
將字符串拷貝N次 |
“ha”*4 >> “hahahaha” |
+ << concat |
連接字符串 |
“yes” + “no” >> “yesno” "yes" << "no" >> “yesno” "yes".concat("no") |
<=> |
比較字符串,返回值如下: 大於:-1 等於:0 小於:1 |
"Ab" <=> "ab" >> -1 "ab" <=> "ab" >> 0 "ab" <=> "Ab" >> 1 |
== 或 === |
判斷兩個對象是否相等 |
"1" == "1" >>true "1" == 1 >>flase |
=~ |
匹配正則表達式 |
"abc123abc" =~ /"d/ >> 3 |
[ ] 或 slice |
返回字符串的某一範圍內的值 |
“abc”[0,2] >> “ab” "hello"[/llo/] >> “llo” “abc” slice [0,2] >> “ab” |
[ ]= |
替換字符串的某一範圍內的值 |
a = “hello word” a[1,2]= “OO” puts a >>” hOOlo word” |
capitalize capitalize! |
把字符串的首字母大寫,其他字母小寫 |
"hi,Ruby".capitalize >> “Hi,ruby” |
chomp chomp! |
刪除字符串後的空白字符 |
"string"r"n".chomp >> ” string” |
chop |
刪除最後一個字符 |
"string".chop >> “strin” |
count |
返回該字符串中含的字符個數 |
a = "hello world" a.count "lo" >> 5 (l出現 3次,o出現 2次) |
delete delete! |
刪除字符 |
"hello".delete "l","lo" » "heo" "hello".delete "lo" » "he" |
downcase downcase! |
將大寫字母改寫爲小寫 |
"hEllO".downcase » "hello" |
upcase upcase! |
將小寫字母改寫爲大寫 |
"hEllO".upcase » "HELLO" |
swapcase swapcase! |
將所有的大寫字母改爲小寫字母, 小寫字母改爲大寫字母。 |
"Hello".swapcase » "hELLO" |
each |
對字符串中的各行進行迭代操作 |
"Hi"nRuby". each { |s| puts s} |
each_byte |
對字符串中的各個字節進行迭代操作 |
"Hi"nRuby". each_byte { |s| puts s} |
each_line |
對字符串中的每一行進行迭代操作 |
"Hi"nRuby". each_line { |s| puts s} |
empty? |
判斷字符串是否爲空 |
"hello".empty? » false "".empty? » true |
gsub gsub! |
以replace來替換字符串中所有與pattern相匹配的部分 |
"hello".gsub(/[aeiou]/, '*') » "h*ll*" |
hash |
返回字符串的哈希值 |
"h".hash >> 107 |
include? |
若字符串中包含substr子字符串的話,就返回真 |
"hello".include? "lo" » true "hello".include? "ol" » false |
index |
按照從左到右的順序搜索子字符串,並返回搜索到的子字符串的左側位置. 若沒有搜索到則返回nil |
"hello".index('lo') » 3 "hello".index('a') » nil |
length |
返回字符串的字節數 |
"hello".length >> 5 |
replace |
替換字符串的內容 |
s = "hello" » "hello" s.replace "world" » "world" |
sub 或 sub! |
用replace來替換首次匹配pattern的部分。 |
"hello".sub(/[aeiou]/, '*') » "h*llo" |
reverse reverse! |
對字符串進行反轉 |
"stressed".reverse » "desserts" |
scan |
使用正則表達式re反覆對self進行匹配操作,並以數組的形式返回匹配成功的子字符串 |
a = "cruel world" a.scan(/"w+/) » ["cruel", "world"] a.scan(/.../) » ["cru", "el ", "wor"] |
split |
使用sep指定的pattern來分割字符串,並將分割結果存入數組 |
"mellow yellow".split("ello") » ["m", "w y", "w"] |
squeeze squeeze! |
壓縮由str所含字符構成的重複字符串 |
"yellow moon".squeeze » "yelow mon" " now is the".squeeze(" ") » " now is the" |
strip strip! |
刪除頭部和尾部的所有空白字符。空白字符是指" "t"r"n"f"v"。 |
" hello ".strip » "hello" ""tgoodbye"r"n".strip » "goodbye" |
tr 或tr! |
若字符串中包含search字符串中的字符時,就將其替換爲replace字符串中相應的字符 |
hello".tr('aeiou', '*') » "h*ll*" "hello".tr('^aeiou', '*') » "*e**o" |
tr_s 或tr_s! |
若字符串中包含search字符串中的字符時,就將其替換爲replace字符串中相應的字符。同時,若替換部分中出現重複字符串時,就將其壓縮爲1個字符 |
"hello".tr_s('l', 'r') » "hero" "hello".tr_s('el', '*') » "h*o" "hello".tr_s('el', 'hx') » "hhxo" |
在從self到max的範圍內,依次取出下一個字符串”後將其傳給塊,進行迭代操作 |
"a1".upto("a3") {|s| puts s} » a1"na2"na3 |
|
to_f |
將字符串轉爲浮點數 |
"45.67 degrees".to_f » 45.67 |
to_i |
將字符串轉爲整數 |
"99 red balloons".to_i » 99 |
to_s |
將字符串轉爲字符串 |
|
函數名稱 |
說明 |
示例 |
== |
判斷兩個Hash是否相等 |
h1 = {"a" => 1, "c" => 2} h2 = { "a" => 1, "c" => 2, 7 => 35 } h1 == h2 » false |
[ ] |
返回指定鍵值對應的對象 |
h = { "a" => 100, "b" => 200 } h["a"] » 100 h["c"] » nil |
[ ]= |
向Hash添加記錄 |
h = { "a" => 100, "b" => 200 } h["a"] = 9 h["c"] = 4 h » {"a"=>9, "b"=>200, "c"=>4} |
clear |
清空哈希表的內容. 返回self. |
h = { "a" => 100, "b" => 200 } h.clear » {} |
default |
返回哈希表的默認值 |
h = { "a" => 100, "b" => 200 } h.default = "Go fish" h["a"] » 100 h["z"] » "Go fish" |
delete |
從詞典中刪除和鍵值相符的記錄 |
h = { "a" => 100, "b" => 200 } h.delete("a") » 100 h.delete("z") » nil h.delete("z") { |el| "#{el} not found" } » "z not found" |
delete_if |
通過過程塊來刪除特定鍵值的記錄 |
h = { "a" => 100, "b" => 200 } h.delete_if {|key, value| key >= "b" } » {"a"=>100} |
each |
Hash表的迭代操作,對錶的每一個詞對進行迭代操作 |
h = { "a" => 100} h.each {|key, value| print key, " is ",value,""n"} » a is 100 |
each_key |
對錶的每一個鍵對進行迭代操作 |
h = { "a" => 100, "b" => 200 } h.each_key {|key| print key } » ab |
each_value |
針對value進行迭代操作 |
h = { "a" => 100, "b" => 200 } h.each_value {|value| print value } » 100200 |
empty? |
判斷哈希表是否爲空,空則返回true |
{}.empty? » true |
fetch |
如果能找到鍵值爲key的hash值,則返回Hash值; 如果找不到,則返回默認值或指定值; 如果默認值和指定值都找不到,拋異常 |
h = { "a" => 100, "b" => 200 } h.fetch("a") » 100 h.fetch("z", "go fish") » "go fish" h.fetch("k") »in `fetch': key not found (IndexError) |
has_key? |
判斷是否存在相符的key值 |
h = { "a" => 100, "b" => 200 } h.has_key?("a") » true h.has_key?("z") » false |
key? |
h. key?("z") » false |
|
include? |
h.include?("b") » true |
|
has_value? |
判斷是否存在相符的value值 |
h = { "a" => 100, "b" => 200 } h.has_value?(100) » true h.has_value?(999) » false |
value? |
h.value?(100) » true h.value?(999) » false |
|
index |
返回給定值的鍵值,未找到返nil |
h = { "a" => 100, "b" => 200 } h.index(200) » "b" h.index(999) » nil |
indexes |
返回一系列給定的鍵值對應值組成的數組 |
h = { "a" =>100, "b" =>200, "c" =>300 } h.indexes("a", "c") » [100,300] h.indexes("a","z") » [100,nil] |
indices |
h.indexes("a", "c") » [100,300] h.indexes("a", "z") » [100,nil] |
|
invert |
將元素值和索引互換,返回變換後的哈希表. 注意:若原哈希表中若干不同的索引對應相同的元素值時,其變換結果將無法預測. |
h = { "n" => 100,"m" => 100,"y" => 300} h.invert » {300=>"y",100=>"n"} |
keys |
返回一個包含所有key的數組. |
h = { "a" => 100, "b" => 200 } h.keys » ["a", "b"] |
values |
返回一個包含所有vakue的數組. |
h = { "a" => 100,"b" => 200,"c" => 300 } h.values » [100, 200, 300] |
length |
返回詞典中元素的個數 |
h = { "d" =>100, "a"=> 200, "v" => 300} h.length » 3 h. size » 3 |
size |
||
rehash |
重新計算索引對應的哈希表值。 當與索引對應的哈希表值發生變化時,若不使用該方法來重新計算的話,將無法取出與索引對應的哈希表值。 |
a = [ "a", "b" ] c = [ "c", "d" ] h = { a => 100, c => 300 } a[0] = "z" h.rehash » {["z", "b"]=>100, ["c", "d"]=>300} h[a] » 100 |
replace |
以另外一張Hash表的內容來替換當前Hash表的內容 |
h = {"a" =>100, "b" =>200 } h.replace({ "c" => 300, "d" => 400 }) » {"c"=>300, "d"=>400} |
shift |
刪除一個哈希表元素後 再以[key,value]數組的形式將其返回 |
h = { 1 => "a", 2 => "b", 3 => "c" } h.shift » [1, "a"] h » {2=>"b", 3=>"c"} |
sort |
對Hash進行排序 按鍵值從小到大排序 |
h = { "b" => 30, "a" => 20, "c" => 10 } h.sort » [["a", 20], ["b", 30], ["c", 10]] h.sort {|a,b| a[1]<=>b[1]} » [["c", 10], ["a", 20], ["b", 30]] |
to_a |
把Hash錶轉換爲數組 數組按Hash表的鍵值從小到大排序 |
h = {"c" =>300,"a" =>100,"d" =>400} » [["a", 100], ["c", 300], ["d", 400]] |
to_s |
把Hash錶轉換爲字符串 |
h = { "c" => 300, "a" => 100, "d" => 400} h.to_s » "a100c300d400" |
update |
用一張Hash表去更新另外張Hash表 |
h1 = { "a" => 100, "b" => 200 } h2 = { "b" => 254, "c" => 300 } h1.update(h2) » {"a"=>100, "b"=>254, "c"=>300} |
函數名稱 |
說明 |
示例 |
& |
數組與,返回兩數組的交集 |
[1,2] & [2,3] » [2] |
* |
複製數組n次 |
[1,2]*2 » [1,2,1,2] |
+ |
返回兩數組的並集,但不排除重複元素 |
[1,2]+[2,3] » [1,2,2,3] |
<< |
追加元素,但不排除重複元素 |
[1,2]<<[2,3] » [1,2,2,3] |
| |
追加元素,但排除重複元素 |
1,2] | [2,3] » [1,2,3] |
- |
返回第一個數組與第二個數組不同的元素 |
[1,2]-[2,3] » [1] |
<=> |
比較數組 |
[1,2]<=>[2,3] »flase |
== |
比較數組,若所有元素均相等時返回真 |
[1,2]==[2,1] »flase |
assoc |
從數組的每個元素中尋找指定對象 |
[[1,2],[3,4]].assoc(2) » [1,2] |
at |
找到數組的第N個元素 負數表示逆向查找 |
["a","b","c","d","e"].at(0) » "a" ["a","b","c","d","e"].at(-1) » "e" |
clear |
刪除數組中的所有元素 |
["a","b","c","d","e"]. clear |
collect collect! |
用一個過程塊對數組的每個元素進行處理 |
["a","b","c","d"].collect {|x| x + "!" } » ["a!", "b!", "c!", "d!"] |
compact compact! |
刪除值爲nil的元素後生成新數組並返回它 |
["a",nil,"b",nil,"c",nil].compact » ["a", "b", "c"]
|
delete |
刪除元素,如果元素重複,全部刪除 |
a = [ "a", "b", "b", "b", "c" ] a.delete("b") puts a » ["a","c"] |
刪除pos所指位置的元素並返回它。若pos超出數組範圍則返回nil |
a = %w( ant bat cat dog ) a.delete_at(2) » "cat" a » ["ant", "bat", "dog"] a.delete_at(99) » nil |
|
delete_if |
根據條件刪除 |
a = [ "a", "b", "c" ] a.delete_if {|x| x >= "b" } » ["a"] |
each |
對數組的每個元素按值進行迭代操作 |
a = [ "a", "b", "c" ] a.each {|x| print x, " -- " } » "a -- b -- c --" |
each_index |
對數組的每個元素按索引進行迭代操作 |
a = [ "a", "b", "c" ] a.each_index {|x| print x, " -- " } » "0 -- 1 -- 2 --" |
empty? |
判斷數組是否爲空,爲空則返回真 |
[].empty? » true |
eql! |
比較兩數組是否相等 |
["a","b","c"].eql?(["a","b","c"]) » true |
填充數組 |
["a","b","c","d"].fill("x") » ["x","x","x","x"] ["a","b","c","d"].fill("z", 2, 2) » ["x", "x", "z", "z"] |
|
first |
返回數組的首元素。若沒有首元素則返回nil |
[ "q", "r", "s", "t" ].first » "q" |
last |
返回數組末尾的元素。若數組爲空時,返回nil |
["w","x","y","z"].last » "z" |
include? |
判斷數組中是否包含元素 |
a = [ "a", "b", "c" ] a.include?("b") » true a.include?("z") » false |
返回數組中第一個==val的元素的位置 |
a = [ "a", "b", "c" ] a.index("b") » 1 a.index("z") » nil |
|
以數組形式返回其索引值與各參數值相等的元素 |
a = [ "a", "b", "c", "d", "e", "f", "g" ] a.indexes(0, 2, 4) » ["a", "c", "e"] a.indexes( 2, 4, 12) » [ "c", "e", nil] |
|
insert |
在索引爲nth的元素前面插入第2參數以後的值 |
ary = %w(foo bar baz) ary.insert 2,'a','b' p ary » ["foo", "bar", "a", "b", "baz"] |
join |
將數組元素按一定的分隔符連接起來 |
[ "a", "b", "c" ].join » "abc" [ "a", "b", "c" ].join("-") » "a-b-c" |
length size |
返回數組長度。若數組爲空則返回0 |
[1,2,3].length » 3 [1,2,3].size » 3 |
nitems |
返回非nil元素的個數 |
[ 1, nil, 3, nil, 5 ].nitems » 3 |
pop |
刪除末尾元素並返回它。若數組爲空則返回nil |
a = [ "a", "m", "z" ] a.pop » "z" p a » ["a", "m"] |
push |
添加新元素 |
["a","b"].push(['1','2']) » ["a", "b", ["1", "2"]] |
rassoc |
遍歷數組每個元素(元素必須是數組),匹配索引爲1的值是否與查找的字符相等,返回第一個相等的元素 |
a = [[15,1], [25,2], [35,2]] p a.rassoc(2) » [25, 2] |
replace |
替換數組元素 |
a = ["a","b"] a.replace(["x","y","z"]) p a »["x", "y", "z"] |
reverse reverse! |
將所有元素以逆序重新排列生成新數組並返回它 |
["a","b","c" ].reverse » ["c", "b", "a"] |
rindex |
返回最後一個值相等的元素的索引值 |
a = [ "a","b","b","b","c"] a.rindex("b") » 3 |
shift |
刪除數組的首元素並返回它。剩餘元素依次提前。若數組爲空返回nil。 |
args = ["-m","-q","filename"] args.shift » "-m" args » ["-q", "filename"] |
sort sort! |
從小到大排序 |
a = [ "d", "a", "e", "c", "b" ] a.sort » ["a", "b", "c", "d", "e"] |
uniq uniq! |
刪除數組中的重複元素後生成新數組並返回它 |
a = [ "a", "a", "b", "b", "c" ] a.uniq » ["a", "b", "c"] |
unshift |
在數組第一個元素前添加元素 |
a = [ "b", "c", "d" ] a.unshift("a") » ["a", "b", "c", "d"] |
to_s |
將數組的所有元素連接成字符串 |
["a","e","i","o"].to_s » "aeio" |
函數名稱 |
說明 |
示例 |
chr |
返回數字的ACSII碼 |
65.chr >> “A” |
downto |
接收一個block,從大到小循環執行 |
5.downto(2) { |i| puts i} >> 5 4 3 2 |
upto |
接收一個block,從小到大循環執行 |
2.upto(5) { |i| puts i} >> 2 3 4 5 |
next或succ |
返回下一個數 |
1.next >> 2 1.succ >>2 |
step |
以固定步長循環執行 |
1.step(10,2) { |i| puts i} >> 1 2 3 5 7 |
times |
循環執行n次 |
5.times { |i| puts i} >> 1 2 3 4 5 |