Ruby 簡明教程 Part 6

原創 dragonzhsd 2020-06-16 02:54

1.簡介

2.安裝

3.基本語法

4高級進階

 

 

------繼續

3.基本語法

3.12 Arrays 數組

Ruby 數值是有序的，整數爲索引的任何對象集合。數組中的每個元素與索引關聯使用。

和C或Java 一樣， 數組索引從0開始。負的索引被看作從數組尾部開始。-1代表數組最後的元素，-2代表倒數第二個元素，等等。

Ruby 數組可以容納String, Integer,Hash, Symbol,甚至數組對象。  Ruby arrays數組不像其它語言那麼嚴格，增加元素的時候自動增長。

3.12.1 Creating Arrays 創建數組

創建數組的方法很多。 一種是使用類方式new：

names = Array.new

創建時可以設置數組大小

names = Array.new(20)

可以用 size 或 length 方法返回數組大小

 

#!/usr/bin/ruby
names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 20

執行結果：

20
20

可以如下創建數組的時候給數組賦值

 

#!/usr/bin/ruby

names = Array.new(4, "mac")
puts "#{names}"

數組如下

["mac", "mac", "mac", "mac"]

你可以用塊的值來填充new 的數組

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"

注意，這兒的e是索引值，你可以自己修改表達式觀察。結果如下：

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

也可以用Array.[]來創建數組
nums = Array.[](1, 2, 3, 4,5)

另外一種方式，直接在[]內賦值建立數組

nums = Array[1, 2, 3, 4,5]

 Ruby的Kernel模塊有種數組方式，只接受一個參數，範圍，用來傳教數字數組(array of digits)。

 

#!/usr/bin/ruby
digits = Array(0..9)
puts "#{digits}"

結果

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3.12.2 Array Built-in Methods 數組內置方法

創建數組實例的方法

Array.[](...) [or] Array[...] [or] [...]

這將返回異常用給定對象填充的新數組。 用創建的數組，可以調用任何實例方法。

 

#!/usr/bin/ruby

digits = Array(0..9)
num = digits.at(6)
puts "#{num}"

結果

6

進一步具體的，可以查看官方文檔。

https://ruby-doc.org/

3.12.3 Array pack Directives 數組打包指令

簡明教程不具體講。舉幾個例子

 

a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

結果如下。

a  b  c
abc
ABC

3.13 Hash 哈希

注意：hash 內容來自 ruby 2.6.5. 如果運行代碼有問題，請安裝ruby2.6.5。或者理解有關內容，修改代碼。

Hash 是類似字典的集合，包含的鍵值唯一，每個鍵有對應的值。也叫做關聯數組，不過數組的索引是整數，而Hash允許用任何對象類型。

Hashe 遍歷根據鍵的插入順序來遍歷對應的值。可以用隱含形式創建Hash

grades = { "Jane Doe" => 10, "Jim Doe" => 6 }

對於符號類型的鍵，可以用：而不是=>

options = { :font_size => 10, :font_family => "Arial" }

可以如下

options = { font_size: 10, font_family: "Arial" }

每個命名的鍵，你都可以訪問E
options[:font_size]  # => 10

 Hash 可以用它的 ::new 方式創建：

grades = Hash.new
grades["Dorothy Doe"] = 9

 Hash 對不存在的鍵可以設置一個缺省值。如果沒有設置，則用nil。 可以給::new傳參來設置這個值。

grades = Hash.new(0)

也可以使用 default=方法
grades = {"Timmy Doe" => 8}
grades.default = 0

Hash 需要通過鍵來訪問值。
puts grades["Jane Doe"] # => 0

3.13.1 Common Uses 通常用法

hash 表示數據結構

books         = {}
books[:matz]  = "The Ruby Programming Language"
books[:black] = "The Well-Grounded Rubyist"

Hashe 讓函數具有命名的參數。如果hash 是方法調用的最後參數，則不需要括號，界面清潔。

Person.create(name: "John Doe", age: 27)

def self.create(params)
  @name = params[:name]
  @age  = params[:age]
end

3.13.2 Hash Keys 鍵

Two objects refer to the same hash key when their hash value is identical and the two objects are eql? to each other.

倆個對象的hash 值一致並且互相eql?,  那麼它們指向同一個hash key。 

 用戶自定義的類可以作爲hash key, 如果hash ,eql? 被重寫。默認情況，不同的實例指向不同hash keys.

典型的實現，hash 基於對象數據，而 eql? 是重寫方法的別名。

class Book
  attr_reader :author, :title

  def initialize(author, title)
    @author = author
    @title = title
  end

  def ==(other)
    self.class === other and
      other.author == @author and
      other.title == @title
  end

  alias eql? ==

  def hash
    @author.hash ^ @title.hash # XOR
  end
end

book1 = Book.new 'matz', 'Ruby in a Nutshell'
book2 = Book.new 'matz', 'Ruby in a Nutshell'

reviews = {}

reviews[book1] = 'Great reference!'
reviews[book2] = 'Nice and compact!'

reviews.length #=> 1

 

3.13.3 Public Class Methods  公共類方法

Hash[ key, value, ... ] → new_hash

Hash[ [ [key, value], ... ] ] → new_hash

Hash[ object ] → new_hash

以上格式，創建填充了給定對象的新 hash。

與 { key => value, ... }類似.  第一種格式鍵值成對出現，參數是偶數 。

第二三種方式單個參數，參數是鍵值對數組或可以轉換爲hash的對象。

Hash["a", 100, "b", 200]             #=> {"a"=>100, "b"=>200}
Hash[ [ ["a", 100], ["b", 200] ] ]   #=> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}

new → new_hash

new(obj) → new_hash

new {|hash, key| block } → new_hash

以上創建新的hash .

h = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"]           #=> 100
h["c"]           #=> "Go Fish"
# The following alters the single default object
h["c"].upcase!   #=> "GO FISH"
h["d"]           #=> "GO FISH"
h.keys           #=> ["a", "b"]

# While this creates a new default object each time
h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
h["c"]           #=> "Go Fish: c"
h["c"].upcase!   #=> "GO FISH: C"
h["d"]           #=> "Go Fish: d"
h.keys           #=> ["c", "d"]

try_convert(obj) → hash or nil

試圖將 obj  轉換成 hash,使用 #to_hash 方法. 返回轉換的 hash 或 nil 如果不成功。

Hash.try_convert({1=>2})   # => {1=>2}
Hash.try_convert("1=>2")   # => nil

3.13.4 Public Instance Methods 公共實例方法

hash < other → true or false

小於。如果hash 是other的子集，返回true， 否則false。

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 < h2    #=> true
h2 < h1    #=> false
h1 < h1    #=> false

hash <= other → true or false

小於等於。如果hash 是other的子集或全集，返回true， 否則false

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 <= h2   #=> true
h2 <= h1   #=> false
h1 <= h1   #=> true

hsh == other_hash → true or false

相等。倆個hash 相等如果他們含有同樣數目的鍵，並且對應的每個鍵值對都相當  (根據對象#==) 

h1 = { "a" => 1, "c" => 2 }
h2 = { 7 => 35, "c" => 2, "a" => 1 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2   #=> false
h2 == h3   #=> true
h3 == h4   #=> false

Hash 的順序不比較。
h1 = { "a" => 1, "c" => 2 }
h2 = { "c" => 2, "a" => 1 }
h1 == h2   #=> true

hash > other → true or false

大於。 如果 other 是 hash的子集。

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 > h2    #=> false
h2 > h1    #=> true
h1 > h1    #=> false

hash >= other → true or false

大於等於。判斷 other 是 hash 的全集或子集。

h1 = {a:1, b:2}
h2 = {a:1, b:2, c:3}
h1 >= h2   #=> false
h2 >= h1   #=> true
h1 >= h1   #=> true

hsh[key] → value

元素引用。獲取鍵對應的值。如果找不到，返回缺省值。 

h = { "a" => 100, "b" => 200 }
h["a"]   #=> 100
h["c"]   #=> nil

 

3.13.5 Element Assignment 元素賦值

 

h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h   #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}

 鍵key用做鍵的時候，它的值是不能改變的。（未凍結的String傳做Key的時候，會複製一份並凍結來作爲鍵）

a = "a"
b = "b".freeze
h = { a => 100, b => 200 }
h.key(100).equal? a #=> false
h.key(200).equal? b #=> true

any? [{ |(key, value)| block }] → true or false

any?(pattern) → true or false

assoc(obj) → an_array or nil

使用==比較Obj和key，搜索hash.找到返回鍵值對，否則返回nil. 

h = {"colors"  => ["red", "blue", "green"],
     "letters" => ["a", "b", "c" ]}
h.assoc("letters")  #=> ["letters", ["a", "b", "c"]]
h.assoc("foo")      #=> nil

clear → hsh

清除hash中的鍵值對。

h = { "a" => 100, "b" => 200 }   #=> {"a"=>100, "b"=>200}
h.clear                          #=> {}

compact → new_hash

返回一個清除nil鍵值對後的新hash.

h = { a: 1, b: false, c: nil }
h.compact     #=> { a: 1, b: false }
h             #=> { a: 1, b: false, c: nil }

compact! → hsh or nil

清除hash中的所有nil值。 如果沒有改變，返回nil；否則，返回清除後的hash。

h = { a: 1, b: false, c: nil }
h.compact!     #=> { a: 1, b: false }

compare_by_identity → hsh

讓hash 比較它的key 和identity。將完全相同的對象，看作相同的key.

h1 = { "a" => 100, "b" => 200, :c => "c" }
h1["a"]        #=> 100
h1.compare_by_identity
h1.compare_by_identity? #=> true
h1["a".dup]    #=> nil  # different objects.
h1[:c]         #=> "c"  # same symbols are all same.

compare_by_identity? → true or false

如果hash 會按照identity 比較key，就返回true 。hash默認爲false，執行完compare_by_identity後，compare_by_identity?就返回true.

default(key=nil) → obj

返回key不存在hash返回的缺省值。

h = Hash.new                            #=> {}
h.default                               #=> nil
h.default(2)                            #=> nil

h = Hash.new("cat")                     #=> {}
h.default                               #=> "cat"
h.default(2)                            #=> "cat"

h = Hash.new {|h,k| h[k] = k.to_i*10}   #=> {}
h.default                               #=> nil
h.default(2)                            #=> 20

default = obj → obj

設置鍵不存在時hash返回的缺省值。不可能將缺省值設置爲Proc。

h = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h["a"]     #=> 100
h["z"]     #=> "Go fish"
# This doesn't do what you might hope...
h.default = proc do |hash, key|
  hash[key] = key + key
end
h[2]       #=> #<Proc:0x401b3948@-:6>
h["cat"]   #=> #<Proc:0x401b3948@-:6>

default_proc → anObject

如果 Hash::new 被塊調用，就返回調用塊，否則返回nil。

h = Hash.new {|h,k| h[k] = k*k }   #=> {}
p = h.default_proc                 #=> #<Proc:0x401b3d08@-:1>
a = []                             #=> []
p.call(a, 2)
a                                  #=> [nil, nil, 4]

default_proc = proc_obj or nil

設置找不到鍵時執行的缺省proc。

h.default_proc = proc do |hash, key|
  hash[key] = key + key
end
h[2]       #=> 4
h["cat"]   #=> "catcat"

delete(key) → value

delete(key) {| key | block } → value

刪除鍵值對並返回key對應的值。如果沒有找到key，返回nil。如果可選項block給定，而且key沒有找到，傳入參數，並返回block結果。I

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 {| key, value | block } → hsh

delete_if → an_enumerator

刪除block爲true對應鍵值對。

If no block is given, an enumerator is returned instead. 如果沒有給定塊，則返回一個枚舉器。

h = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}

dig(key, ...) → object

抽取key對象序列指定的嵌套值, 任何一步遇到nil返回nil.

h = { foo: {bar: {baz: 1}}}

h.dig(:foo, :bar, :baz)     #=> 1
h.dig(:foo, :zot, :xyz)     #=> nil

g = { foo: [10, 11, 12] }
g.dig(:foo, 1)              #=> 11
g.dig(:foo, 1, 0)           #=> TypeError: Integer does not have #dig method
g.dig(:foo, :bar)           #=> TypeError: no implicit conversion of Symbol into Integer

each {| key, value | block } → hsh

each → an_enumerator

對應hash中的每個key,將鍵值對傳入block, 執行一次。

如果沒有指定塊，返回一個枚舉器。

h = { "a" => 100, "b" => 200 }
h.each {|key, value| puts "#{key} is #{value}" }

結果：

a is 100
b is 200

each_key {| key | block } → hsh

each_key → an_enumerator

對應每個key , 傳給block並執行一次。 

如果沒有指定塊，則返回枚舉器。

h = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }

結果
a
b

each_pair {| key, value | block } → hsh

each_pair → an_enumerator

對應hash中的每個將鍵值對傳入block, 執行一次。

如果沒有指定塊，返回一個枚舉器。

h = { "a" => 100, "b" => 200 }
h.each_pair {|key, value| puts "#{key} is #{value}" }

produces:

a is 100
b is 200

each_value {| value | block } → hsh

each_value → an_enumerator

對應每個value , 傳給block並執行一次。 

如果沒有指定塊，則返回枚舉器。

h = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }

produces:

100
200

empty? → true or false

檢查hash 是否是空的。.

{}.empty?   #=> true

eql?(other) → true or false

判斷hash和other是否對同樣的內容哈希。 每個哈希的順序不比較。

fetch(key [, default] ) → obj

fetch(key) {| key | block } → obj

獲取hash給定key對應的value。如果key沒有找到的情況：如果沒有其它參數，keyError 異常； 如果給定缺省值，返回缺省值；如果可選項block 指定，將執行代碼並返回結果。

h = { "a" => 100, "b" => 200 }
h.fetch("a")                            #=> 100
h.fetch("z", "go fish")                 #=> "go fish"
h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"

下例拋出異常，如果key沒有找到且沒有提供缺省值。 
h = { "a" => 100, "b" => 200 }
h.fetch("z")

結果
prog.rb:2:in `fetch': key not found (KeyError)
 from prog.rb:2

fetch_values(key, ...) → array

fetch_values(key, ...) { |key| block } → array

返回給定key對應值的數組，如果有沒有找到的key同事拋出KeyError。

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }

h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
h.fetch_values("cow", "bird")                  # raises KeyError
h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]

filter {|key, value| block} → a_hash

filter → an_enumerator

返回block過濾得到新hash。

沒有指定block ，則返回枚舉器。

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

#filter別名 #select的別名.

filter! {| key, value | block } → hsh or nil

filter! → an_enumerator

等同於 #keep_if,  滿足block條件的保留，刪除不滿足的，但是返回nil 如果hash沒有改變。.

#filter! 是 #select!的別名。

flatten → an_array

flatten(level) → an_array

將hash轉換成一維數組返回。 不同於Array#flatten, 此方法默認不遞歸。 可選項level決定遞歸深度。

a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
a.flatten    # => [1, "one", 2, [2, "two"], 3, "three"]
a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]

has_key?(key) → true or false

檢查是hash否包含指定的key ..

h = { "a" => 100, "b" => 200 }
h.has_key?("a")   #=> true
h.has_key?("z")   #=> false

s_value?(value) → true or false

檢查是hash否包含指定的value. 

h = { "a" => 100, "b" => 200 }
h.value?(100)   #=> true
h.value?(999)   #=> false

hash → integer

計算hash的hash-code，返回整數。

include?(key) → true or false

檢查hash是否包含指定key 。

h = { "a" => 100, "b" => 200 }
h.has_key?("a")   #=> true
h.has_key?("z")   #=> false

to_s → string

inspect → string

將hash 內容返回字符串。

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_s   #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"

 invert → new_hash

將鍵值對互換，生成新的hash返回。如果有重複值的key, 則保留最後的，前面的拋棄。

h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert   #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}

 如果key沒有重複值, #invert  不捲曲 involutive，即

h = { a: 1, b: 3, c: 4 }
h.invert.invert == h #=> true


可以比較hash 和 互換的hash的大小是否相等來測試是否鍵值有重複。
# no key with the same value
h = { a: 1, b: 3, c: 4 }
h.size == h.invert.size #=> true

# two (or more) keys has the same value
h = { a: 1, b: 3, c: 1 }
h.size == h.invert.size #=> false

keep_if {| key, value | block } → hsh

keep_if → an_enumerator

刪除不滿足條件的鍵值對。

如果沒有指定block, 返回枚舉器。

key(value) → key

查找value對應的key. 如果找不到，返回nil .

h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
h.key(200)   #=> "b"
h.key(300)   #=> "c"
h.key(999)   #=> nil

key?(key) → true or false

檢查指定的key 是否在hash中。

h = { "a" => 100, "b" => 200 }
h.has_key?("a")   #=> true
h.has_key?("z")   #=> false

keys → array

返回hash中的keys 數組。

h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys   #=> ["a", "b", "c", "d"]

length → integer

返回hash中鍵值對的個數。

h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.size          #=> 4
h.delete("a")   #=> 200
h.size          #=> 3
h.length        #=> 3

#length 是 #size 別名。

member?(key) → true or false

檢查hash是否有指定的key. 

h = { "a" => 100, "b" => 200 }
h.member?("a")   #=> true
h.member?("z")   #=> false

 注意 ： include? 和 member? 不像其它枚舉用==來測試相等。 

merge(other_hash1, other_hash2, ...) → new_hash

merge(other_hash1, other_hash2, ...) {|key, oldval, newval| block}→ new_hash

將給定hash 和 接收器的內容合併成一個新hash。

如果沒有指定block 重複key 的值將被每個other_hash的值覆蓋；如果指定block，則重複key的值將被block 的運算值替代。

當沒有任何參數，返回接收器的拷貝。

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge          #=> {"a"=>100, "b"=>200}
h1.merge(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
h1.merge(h2, h3)  #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
h1.merge(h2) {|key, oldval, newval| newval - oldval}
                  #=> {"a"=>100, "b"=>46,  "c"=>300}
h1.merge(h2, h3) {|key, oldval, newval| newval - oldval}
                  #=> {"a"=>100, "b"=>311, "c"=>300, "d"=>400}
h1                #=> {"a"=>100, "b"=>200}

merge!(other_hash1, other_hash2, ...) → hsh

merge!(other_hash1, other_hash2, ...) {|key, oldval, newval| block}

將給定參數的hashes的內容添加到接收者。

如果沒有指定block， 有重複鍵的條目被後來的覆蓋；如果指定了block， 重複key的值由block及receiver 和 other_hash 的值來決定。

h1 = { "a" => 100, "b" => 200 }
h1.merge!          #=> {"a"=>100, "b"=>200}
h1                 #=> {"a"=>100, "b"=>200}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
h1                 #=> {"a"=>100, "b"=>246, "c"=>300}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3)
                   #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3) {|key, v1, v2| v1 }
                   #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}

#update是 #merge!.的別名。

rassoc(obj) → an_array or nil

Searches through the hash comparing obj with the value using ==. Returns the first key-value pair (two-element array) that matches. See also Array#rassoc.

使用==比較obj和value,搜索hash. 返回第一個匹配的鍵值對，否則返回nil.

a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
a.rassoc("two")    #=> [2, "two"]
a.rassoc("four")   #=> nil

rehash → hsh

根據當前每個鍵的當前hash value 重建hash. 如果鍵值有改變，將重新索引hash. 當迭代器訪問hash的時候，調用Hash#rehash會導致RuntimeError.

a = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a]       #=> 100
a[0] = "z"
h[a]       #=> nil
h.rehash   #=> {["z", "b"]=>100, ["c", "d"]=>300}
h[a]       #=> 100

reject {|key, value| block} → a_hash

reject → an_enumerator

返回不滿足block條件的條目組成的新hash。

 如果沒有block, 返回一個枚舉器。

h = { "a" => 100, "b" => 200, "c" => 300 }
h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
h.reject {|k,v| v > 100}  #=> {"a" => 100}

reject! {| key, value | block } → hsh or nil

reject! → an_enumerator

與Hash#delete_if相同, 但返回nil 如果沒有變化。

replace(other_hash) → hsh

Replaces the contents of hsh with the contents of other_hash.

用指定參數的other_than 替換hash的內容。

h = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}

select {|key, value| block} → a_hash

select → an_enumerator

返回滿足block條件的條目組成的新hash。 

 如果沒有block, 返回一個枚舉器。

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

#filter是 #select的別名。

select! {| key, value | block } → hsh or nil

select! → an_enumerator

等同於 #keep_if,  不過返回nil如貴哦沒有改變。

#filter! 是 #select! 的別名。

shift → anArray or obj

將開頭的鍵值對從hash中刪除，並以[key,value]數組形式返回， 或者返回缺省值如果hash是空的。

h = { 1 => "a", 2 => "b", 3 => "c" }
h.shift   #=> [1, "a"]
h         #=> {2=>"b", 3=>"c"}

size → integer

返回hash鍵值對個數。

h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.size          #=> 4
h.delete("a")   #=> 200
h.size          #=> 3
h.length        #=> 3

#length 是 #size別名。

slice(*keys) → a_hash

Returns a hash containing only the given keys and their values.

h = { a: 100, b: 200, c: 300 }
h.slice(:a)           #=> {:a=>100}
h.slice(:b, :c, :d)   #=> {:b=>200, :c=>300}

store(key, value) → value

將給定的key,value以鍵值對形式存儲到hash .

h = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h   #=> {"a"=>9, "b"=>200, "c"=>4}
h.store("d", 42) #=> 42
h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}

to_a → array

將hash 轉換爲 嵌套數組 [[ key, value ],...]

h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
h.to_a   #=> [["c", 300], ["a", 100], ["d", 400]]

to_h → hsh or new_hash

to_h {|key, value| block } → new_hash

返回 self.  如果調用hash的子類，將接收者轉換成Hash 對象。 

如果指定block，則接收者的每一對的block結果將被被用作相應的對。

to_hash => hsh

返回 self.

to_proc → proc

返回將鍵值映射的Proc。

h = {a:1, b:2}
hp = h.to_proc
hp.call(:a)          #=> 1
hp.call(:b)          #=> 2
hp.call(:c)          #=> nil
[:a, :b, :c].map(&h) #=> [1, 2, nil]

to_s()

inspect的別名。

transform_keys {|key| block } → new_hash

transform_keys → an_enumerator

將key 用block變換。本方法不改變值value.

h = { a: 1, b: 2, c: 3 }
h.transform_keys {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys(&:to_s)        #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys.with_index {|k, i| "#{k}.#{i}" }
                                #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }

 如果沒有block, 返回一個枚舉器。

transform_keys! {|key| block } → hsh

transform_keys! → an_enumerator

將key 用block變換,替換原來的key,返回hash。本方法不改變值value.

h = { a: 1, b: 2, c: 3 }
h.transform_keys! {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
h.transform_keys!(&:to_sym)      #=> { a: 1, b: 2, c: 3 }
h.transform_keys!.with_index {|k, i| "#{k}.#{i}" }
                                 #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }

如果沒有指定block,則返回迭代器。

transform_values {|value| block } → new_hash

transform_values → an_enumerator

用block的新值更新hash中的value.然後返回hash.

本方法不改變keys。

h = { a: 1, b: 2, c: 3 }
h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
h.transform_values.with_index {|v, i| "#{v}.#{i}" }
                                     #=> { a: "1.0", b: "2.1", c: "3.2" }

如果沒有指定block,則返回迭代器。

transform_values! {|value| block } → hsh

transform_values! → an_enumerator

用block的新值更新hash中的value.然後返回hash.

本方法不改變keys。

h = { a: 1, b: 2, c: 3 }
h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
h.transform_values!(&:to_s)           #=> { a: "2", b: "5", c: "10" }
h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
                                      #=> { a: "2.0", b: "5.1", c: "10.2" }

如果沒有指定block,則返回迭代器。

update(other_hash1, other_hash2, ...) → hsh

update(other_hash1, other_hash2, ...) {|key, oldval, newval| block}

給定hash內容更新給接收者

 

h1 = { "a" => 100, "b" => 200 }
h1.merge!          #=> {"a"=>100, "b"=>200}
h1                 #=> {"a"=>100, "b"=>200}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
h1                 #=> {"a"=>100, "b"=>246, "c"=>300}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3)
                   #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}

h1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 246, "c" => 300 }
h3 = { "b" => 357, "d" => 400 }
h1.merge!(h2, h3) {|key, v1, v2| v1 }
                   #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}

#update 是 #merge!的別名.

value?(value) → true or false

檢查hash是否包含參數value. 返回 true/false.

h = { "a" => 100, "b" => 200 }
h.value?(100)   #=> true
h.value?(999)   #=> false

values → array

返回含有hash中values 的數組。

h = { "a" => 100, "b" => 200, "c" => 300 }
h.values   #=> [100, 200, 300]

values_at(key, ...) → array

返回keys對應values 的數組。

h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
h.values_at("cow", "cat")  #=> ["bovine", "feline"]

 

 

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

C、C++、Java的基礎常識介紹

      1、C        C 是20世紀70年代初由貝爾實驗室開發，最初爲UNIX系統設計的程序開發語言，後來逐步脫離UNIX而成爲獨立的開發語言，並有ANSI協會進行標準化。其顯著特點：        a、出現時間早，因此有大量

烧技湾 2020-07-07 04:51:46

個人理解的軟件設計模式

設計模式介紹 什麼是設計模式 模式的廣義描述：“每一個模式描述了一個不斷重複發生的問題，以及該問題的解決方案的核心。這樣，就能一次又一次地使用該方案而不必做重複勞動”。 面向對象設計模式的描述：“被用來在特定場景下解決一般設計問題的類和相

knight_zhuge 2020-07-06 14:43:24

JAVA編程實踐

引言 本培訓的主要目的是幫助被培訓者瞭解如何使用JAVA語言構造出高效的、不易出錯的、可維護的程序。同傳統的程序設計語言相比，JAVA語言通過語法上的精心設計，例如通過引用替換指針，已經避免了很多使用C++或者其他語言容易導致錯誤的地方

knight_zhuge 2020-07-06 14:43:24

JavaScript引擎研究總結與C、C++與互調用

什麼是JavaScript引擎 什麼是JavaScript引擎？簡單來講，就是能夠提供執行JavaScript代碼的運行環境。要解釋這一概念，需要了解一些編譯原理的基礎概念和現代語言需要的一些新編譯技術。 首先來看C/C++語

步基 2020-07-01 23:08:54

使內嵌式jetty服務器支持jsp

1.jetty是什麼 jetty是一個輕量級的web服務器，類似tomcat，但用起來比tomcat靈活，尤其是支持內嵌式使用。所謂內嵌式即以java語句的形式啓動jetty，這樣我們可以無需部署和啓動web容器就能達到同樣的效果。這對於

1501220038 2020-06-27 00:32:37

類是如何定義出來的

類是如何定義出來的 Object Oriented是多種軟件設計方法中的一種，其核心目標是爲了降低系統的複雜性，以及代碼複用。 在OO裏，一個類(Class)代表了一組具有共同結構和行爲的一組對象(Objects)，是OO語言的基

Horky 2020-06-26 07:33:58

[OOD-More C++ Idioms] 律師與委託人 (Attorney-Client)

律師與委託人 (Attorney-Client) 目的 控制訪問類實現細節的粒度。 動機 C++中的friend會開始類內部的所有細節，也因此破壞了封裝性。C++沒有提供可以選擇性使用某一部分私有成員的方式，要麼全部開放，要麼全部

Horky 2020-06-26 07:33:58

大型項目開發: 頭文件順序

經驗告訴我們，某些編碼實踐雖然在C++中完全合法，但是絕對不能應用於大型項目環境中。 大型項目環境下必須有適當的約束，否則很容易變得難以控制並很難維護（摘自<<大規模C++程序設計>>）。下面以Chromium中運用的兩個Coding S

Horky 2020-06-26 07:33:57

Google C++ Coding Style:引用參數

Google C++ Coding Style定義 輸入參數以值或者const引用形式傳入，輸出參數使用指針。 所有以引用形式輸入參數必須加上const，即const T&的形式。 即如下形式: void Foo(const st

Horky 2020-06-26 07:33:57

php巧妙使用&符

        php中,變量實際分爲兩部分,一部分爲變量名,另一部分爲變量內容.對變量而言,&符使得不同的名字的變量訪問同一個變量內容,這裏的名字指的是變量名,注意函數其實也是變量,同時&符號也經常作爲一種位運算符參與運算,以下爲工作中

zhangsheng_1992 2020-06-24 20:46:01

【C語言】21-struct結構體

基礎知識學習 M了個J 新浪微博：@M了個J，GITHUB：CODERMJLEE(歡迎★STAR點贊) http://www.cnblogs.com/mjios/archive/2013/03/24/2977910.html

AndraBeanDayo 2020-06-24 02:13:31

【C語言】23-結構體

基礎知識學習 來自：  新浪微博：@M了個Jhttp://www.cnblogs.com/mjios/archive/2013/03/24/2977910.html 相關知識整理 C專家編程精華篇----頭疼的C語言聲明：con

AndraBeanDayo 2020-06-24 02:13:31

VC++斷點調試

建立好工程，準備好代碼，開始調試 1.添加斷點（要查看值的變量）   先定位(光標移動到對應行)好要添加斷點的代碼行, 點擊工具欄中，小手的圖標。 2. debug模式運行代碼    運行點擊 圖片最左側的圖標就行，或者快捷鍵

AndraBeanDayo 2020-06-24 02:13:31

Servlet doPost方法同時上傳圖片和傳遞參數

上傳圖片和傳遞參數 上傳圖片和文件屬於enctype="multipart/form-data"  form中加入enctype="multipart/form-data"時整個表單被封裝,字符將轉成二進制流,因此request.ge

scalad 2020-06-23 20:07:14

python中的pass,del,exec,eval語句

(1)pass語句     pass代表該語句什麼都不做，因爲python中空代碼是非法的，比如一個if語句要求什麼內容都不做，我們就可以使用pass語句。   (2)del語句    一般來說python會刪除那些不在使用的對

scalad 2020-06-23 20:07:11