|
Ruby語言學習系列--基本的ruby語法
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 += 1
end
|
#until循環
i= 0
until i == list.size do
print “#list”
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 += 1
break id i > n
end
|
#times循環
n = list.size
n.times do |i|
print “#{list}”
end
|
#upto循環
n =list.size–1
0.upto(n) do |i|
print “#{list}”
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
|
Ruby語言學習系列--String 類函數
|
函數名稱
|
說明
|
示例
|
|
*
|
將字符串拷貝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"
|
|
swapcaseswapcase!
|
將所有的大寫字母改爲小寫字母，
小寫字母改爲大寫字母。
|
"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"
|
|
upto
|
在從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
|
將字符串轉爲字符串
|
|
ruby學習系列--Hash類函數
|
函數名稱
|
說明
|
示例
|
|
==
|
判斷兩個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}
|
Ruby語言學習系列--Array類函數
|
函數名稱
|
說明
|
示例
|
|
&
|
數組與，返回兩數組的交集
|
[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"]
|
|
delete_at
|
刪除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
|
|
fill
|
填充數組
|
["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
|
|
index
|
返回數組中第一個==val的元素的位置
|
a = [ "a", "b", "c" ]
a.index("b") » 1
a.index("z") » nil
|
|
indexes
|
以數組形式返回其索引值與各參數值相等的元素
|
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"
|
Ruby語言學習系列--Numeric類函數
|
函數名稱
|
說明
|
示例
|
|
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
|
Ruby語言學習系列--Float類函數
|
函數名稱
|
說明
|
示例
|
|
ceil
|
返回比float大的最小整數
|
(2.98).ceil >> 3
|
|
floor
|
返回比float小的最大整數
|
(2.98). floor >> 2
|
|
round
|
四捨五入到一個整數
|
(2.98). round >> 3
|
|
to_i
|
返回float截掉小數點後的整數
|
(2.98).to_i >> 2
|
|
