Cache < Command 繼承
https://www.cnblogs.com/tardis/p/4004438.html 更多繼承
有時， 我們希望子類從父類繼承來的方法可以做與父類不相同的事情，這就需要在子類中重寫方法。例如， 你有一個類名字叫Email繼承于類Message，兩個類都有send方法，但是Email類的send方法需要有郵件地址和一系列郵件協(xié)議，但是Message中的send方法并不知道這些，與其在Email類中添加send_mail方法，而從父類繼承的send方法棄之不用， 不如顯式的修改send方法以適應(yīng)Email的需求。
另一方面， 有時子類發(fā)現(xiàn)它所需要的繼承自父類的方法已經(jīng)被改寫， 不要驚慌， 我們可以直接獲取父類的響應(yīng)方法， 這需要使用super關(guān)鍵字。
當(dāng)你在方法中調(diào)用super， 這就是告訴Ruby，在父類中找到與調(diào)用super的這個方法同名的函數(shù)，如果找到， 那么Ruby將會使用其父類版本的這個方法。
:: 語法
@cache = Downloader::Cache.new(Config.instance.cache_root + 'Pods')
你可以通過在方法名稱前加上類或模塊名稱和 . 來調(diào)用類或模塊中的方法。你可以使用類或模塊名稱和兩個冒號 :: 來引用類或模塊中的常量。
:: 是一元運算符，允許在類或模塊內(nèi)定義常量、實例方法和類方法，可以從類或模塊外的任何地方進行訪問。
請記?。涸?Ruby 中，類和方法也可以被當(dāng)作常量。
多行字符串
https://www.runoob.com/ruby/ruby-syntax.html
#!/usr/bin/ruby -w
# -*- coding : utf-8 -*-
print <<EOF
這是第一種方式創(chuàng)建here document 。
多行字符串。
EOF
print <<"EOF"; # 與上面相同
這是第二種方式創(chuàng)建here document 。
多行字符串。
EOF
print <<`EOC` # 執(zhí)行命令
echo hi there
echo lo there
EOC
print <<"foo", <<"bar" # 您可以把它們進行堆疊
I said foo.
foo
I said bar.
bar
<<-EOS
### Installation Source
```/
Executable Path: #{actual_path}
```/
EOS
返回值
https://www.runoob.com/ruby/ruby-method.html
Ruby 中的每個方法默認都會返回一個值。這個返回的值是最后一個語句的值。例如：
def actual_path
$PROGRAM_NAME
end
Ruby語法解釋：attr_reader,attr_writer和attr_accessor
變量set 和get
attr_accessor :required
alias_method :required?, :required
# @return [Boolean]
# Indicates if the argument is repeatable (= can appear multiple
# times in the command, which is indicated by '...' in the banner)
#
attr_accessor :repeatable
attr_accessor :abc
等同于
def abc
return @abc
end
def abc=(abc)
@abc = abc
end
ruby中的alias和alias_method
new_name 和old_name
（12）alias :new_name :old_name 可以用來給方法取別名。alias是個關(guān)鍵字，和他類似的還有一個Module#alias_method方法
https://blog.csdn.net/raosheng1993/article/details/45458821 的第12點
if 語法
https://haicoder.net/ruby/ruby-else.html 這里面有所有的if語法記錄
message = verbose_prefix + message if config.verbose?
puts_indented message if config.verbose?
如果 if 語句條件為真，則會執(zhí)行相對應(yīng)的代碼
#!/usr/bin/ruby -w
# -*- coding : utf-8 -*-
puts "HaiCoder(www.haicoder.net)"
$debug=1
print "debug\n" if $debug
程序運行后，控制臺輸出如下：
因為 debug 變量為 1，所以我們這里輸出了 debug。
Ruby if修飾符總結(jié)
在 Ruby 中，if 修飾詞組表示當(dāng) if 右邊之條件成立時才執(zhí)行 if 左邊的式子。即如果 conditional 為真，則執(zhí)行 code。
:語法
冒號:
http://www.itdecent.cn/p/28d7f3a17b29
# spec.authors = { "#{data[:author_name]}" => "#{data[:author_email]}" }
def pod(set, mode = :normal)
if mode == :name_and_version
puts_indented "#{set.name} #{set.versions.first.version}"
else
當(dāng)我說{ :bla => 1, :bloop => 2 }時，:到底是做什么的？我在某個地方讀到過關(guān)于它是如何類似于一個字符串，但不知怎的是一個符號.
:foo是一個名為"foo"的符號.符號有一個明顯的特點，即任何兩個命名相同的符號都是相同的:
"foo".equal? "foo" # false
:foo.equal? :foo # true
這使得比較兩個符號的速度非常快(因為只涉及指針比較，而不是像比較字符串中的所有字符那樣)，而且不會有大量相同符號的副本.
此外，與字符串不同，符號是不可變的.
unless 用法
help! 'A Podfile path is required.' unless @path
https://haicoder.net/ruby/ruby-unless.html
在 Ruby 中，unless 語句和 if 語句作用相反，即如果 conditional 為假，則執(zhí)行 code。如果 conditional 為真，則執(zhí)行 else 子句中指定的 code。
Ruby unless語句詳解
語法
unless conditional [then]
code
[else
code ]
end
include ProjectDirectory 用法
unless repl_command == '\n'
def execute_repl_command(repl_command)
unless repl_command == '\n'
repl_commands = repl_command.split
subcommand = repl_commands.shift.capitalize
arguments = repl_commands
subcommand_class = Pod::Command::IPC.const_get(subcommand)
subcommand_class.new(CLAide::ARGV.new(arguments)).run
signal_end_of_output
end
end
concat(super)
def self.options
[
['--template-url=URL', 'The URL of the git repo containing a compatible template'],
].concat(super)
end
private
用法
ensure 關(guān)鍵字
當(dāng)一個方法結(jié)束工作時我們也許需要進行清理工作.也許一個打開的文件需要關(guān)閉,緩沖區(qū)的數(shù)據(jù)應(yīng)清空等等.如果對于每一個方法這里永遠只有一個退出點,我們可以心安理得地將我們的清理代碼放在一個地方并知道它會被執(zhí)行;但一個方法可能從多個地方返回,或者因為異常我們的清理代碼被意外跳過.
使用 ensure 語句
有時候，無論是否拋出異常，您需要保證一些處理在代碼塊結(jié)束時完成。例如，您可能在進入時打開了一個文件，當(dāng)您退出塊時，您需要確保關(guān)閉文件。
ensure 子句做的就是這個。ensure 放在最后一個 rescue 子句后，并包含一個塊終止時總是執(zhí)行的代碼塊。它與塊是否正常退出、是否拋出并處理異常、是否因一個未捕獲的異常而終止，這些都沒關(guān)系，ensure 塊始終都會運行。
https://www.runoob.com/ruby/ruby-exceptions.html
yield if block_given?
from_path = config.podfile_path.dirname if config.podfile_path
if pathname
from_path = config.podfile_path.dirname if config.podfile_path
from_path ||= Pathname.pwd
path = begin
Pathname(pathname).relative_path_from(from_path)
rescue
pathname
end
"`#{path}`"
else
https://juejin.cn/post/6844903683524673550 講了block的回調(diào)
private
https://blog.csdn.net/qq284489030/article/details/88369791
總結(jié)一下
public方法可以被定義它的類和子類訪問，并可以被類和子類的實例對象調(diào)用；
protected方法可以被定義它的類和子類訪問，不能被類和子類的實例對象調(diào)用，但可以被該類和子類的實例對象(所有)訪問；
private方法可以被定義它的類和子類訪問，不能被類和子類的實例對象調(diào)用，且實例對象只能訪問自己的private方法。
問號
def repo_update?(default: false)
if @repo_update.nil?
default
else
@repo_update
end
end
def initialize(argv)
@repo_update = argv.flag?('repo-update')
super
end
在Ruby中有很多方法是以?和!號結(jié)尾的
“？”被用于標示謂詞，即返回Boolean直的方法，如Array.empty?(判斷數(shù)組中元素是否為空)
“！”出現(xiàn)在方法名尾部的感嘆號表明使用該方法是需要多加小心。許多Ruby的核心類都定義了
成對的方法，它們具有同樣的名稱，只是結(jié)尾相差一個“！”,通常情況下，不帶感嘆號的方法返
調(diào)用該方法的一個拷貝，二帶感嘆號的方法則是一個可變方法，該方法會修改原來的對象，如Array
類中的sort和sort!
ruby中的方法可以以問號和嘆號結(jié)尾,問號通常用于謂語方法，這種方法返回一個布爾值。例如array和hash類都定義了一個empty?方法，這個方法用于測試數(shù)據(jù)結(jié)構(gòu)中有沒有元素。
如果方法以嘆號結(jié)尾，這意味著我們在使用這個方法的時候要小心，比如大多數(shù)核心的ruby類庫方法都提供兩個同名的方法，一個以嘆號結(jié)尾，一個沒有，
區(qū)別在于，如果使用沒有嘆號結(jié)尾的方法，你在調(diào)用它的時候會得到當(dāng)前對象的一個拷貝而不會修改原始對象，而如果使用帶有嘆號的方法，你在調(diào)用它的時候會直接修改當(dāng)前對象的值。
嘆號 !
2.以感嘆號結(jié)尾的方法。一般表示這是危險的，或者會修改接收者對象的方法。
def insert_sort!
(0...self.length).to_a.each do |j|
key = self[j]
i = j - 1;
while i >= 0 and self[i] > key
self[i+1] = self[i]
i = i-1
end
self[i+1] = key
end
self
end`
運行上述代碼之后，會對傳入的數(shù)據(jù)進行排序，修改了（接收者）對象。
Ruby核心類都定義了成對的方法，它們有同樣的名字，彼此的差別在于其中一個以感嘆號結(jié)尾，而另一個沒有，通常情況下，不帶感嘆號的方法返回調(diào)用該方法的對象的一個修改過的拷貝，而帶感嘆號的方法則是一個可變的方法，該方法會修改原對象。
3.以等號結(jié)尾的方法。一般被賦值的方法以等號結(jié)尾。
def validate!
def validate!
<<
``` section << " (branch `#{@branch}`)" if @branch```
方法傳參 (關(guān)鍵字參數(shù))
7.3.4 關(guān)鍵字參數(shù)
https://www.kancloud.cn/imxieke/ruby-base/107294
關(guān)鍵字參數(shù)是 Ruby 2.0 中的新特性。
在目前為止介紹過的方法定義中，我們都需要定義調(diào)用方法時的參數(shù)個數(shù)以及調(diào)用順序。而使用關(guān)鍵字參數(shù)，就可以將參數(shù)名與參數(shù)值成對地傳給方法內(nèi)部使用。
使用關(guān)鍵字參數(shù)定義方法的語法如下所示：
def 方法名（參數(shù) 1: 參數(shù) 1 的值, 參數(shù) 2: 參數(shù) 2 的值, …)
希望執(zhí)行的處理
end
除了參數(shù)名外，使用“參數(shù)名 : 值”這樣的形式還可以指定參數(shù)的默認值。用關(guān)鍵字參數(shù)改寫計算立方體表面積的 area 方法的程序如下所示：
def area2(x: 0, y: 0, z: 0)
xy = x * y
yz = y * z
zx = z * x
(xy + yz + zx ) * 2
end
p area2(x: 2, y: 3, z: 4) #=> 52
p area2(z: 4, y: 3, x: 2) #=> 52 （改變參數(shù)的順序）
p area2(x: 2, z: 3) #=> 12 （省略y）
這個方法有參數(shù) x、y、z，各自的默認值都為 0。調(diào)用該方法時，可以像 x: 2 這樣，指定一對實際的參數(shù)名和值。在用關(guān)鍵字參數(shù)定義的方法中，每個參數(shù)都指定了默認值，因此可以省略任何一個。而且，由于調(diào)用方法時也會把參數(shù)名傳給方法，所以參數(shù)順序可以自由地更改。
不過，如果把未定義的參數(shù)名傳給方法，程序就會報錯，如下所示：
area2(foo: 0) #=> 錯誤：unknown keyword: foo（ArgumentError）
為了避免調(diào)用方法時因指定了未定義的參數(shù)而報錯，我們可以使用“** 變量名”的形式來 接收未定義的參數(shù)。下面這個例子的方法中，除了關(guān)鍵字參數(shù) x、y、z 外，還定義了 **arg 參數(shù)。參數(shù) arg 會把參數(shù)列表以外的關(guān)鍵字參數(shù)以散列對象的形式保存。
def meth(x: 0, y: 0, z: 0, **args)
[x, y, z, args]
end
p meth(z: 4, y: 3, x: 2) #=> [2, 3, 4, {}]
p meth(x: 2, z: 3, v: 4, w: 5) #=> [2, 0, 3, {:v=>4, :w=>5}]
關(guān)鍵字參數(shù)與普通參數(shù)的搭配使用
關(guān)鍵字參數(shù)可以與普通參數(shù)搭配使用。
def func(a, b: 1, c:2)
┊
end
上述這樣定義時，a 為必須指定的普通參數(shù)，b、c 為關(guān)鍵字參數(shù)。調(diào)用該方法時，可以像下面這樣，首先指定普通參數(shù)，然后是關(guān)鍵字參數(shù)。
func(1, b: 2, c: 3)
用散列傳遞參數(shù)
調(diào)用用關(guān)鍵字參數(shù)定義的方法時，可以使用以符號作為鍵的散列來傳遞參數(shù)。這樣一來，程序就會檢查散列的鍵與定義的參數(shù)名是否一致，并將與散列的鍵一致的參數(shù)名傳遞給方法。
def area2(x: 0, y: 0, z: 0)
xy = x * y
yz = y * z
zx = z * x
(xy + yz + zx ) * 2
end
args1 = {x: 2, y: 3, z: 4}
p area2(args1) #=> 52
args2 = {x: 2, z: 3} #=> 省略y
p area2(args2) #=> 12
方法調(diào)用
branch_name, = Executable.capture_command('git', %w(name-rev --name-only HEAD), :capture => :out, :chdir => source.repo)
方法定義
def self.capture_command(executable, command, capture: :merge, env: {}, **kwargs)
bin = which!(executable)
require 'open3'
command = command.map(&:to_s)
case capture
when :merge then Open3.capture2e(env, [bin, bin], *command, **kwargs)
when :both then Open3.capture3(env, [bin, bin], *command, **kwargs)
when :out then Open3.capture3(env, [bin, bin], *command, **kwargs).values_at(0, -1)
when :err then Open3.capture3(env, [bin, bin], *command, **kwargs).drop(1)
when :none then Open3.capture3(env, [bin, bin], *command, **kwargs).last
end
end
箭頭 向左, 向右
Ruby語言的非操作符(Nonoperator)和操作符(Operator)
https://www.huoxiaoqiang.com/ruby/rubylang/1516.html
1.<< 和 >>代表左移或右移
puts 1<<2
輸出結(jié)果為：4
代表1的二進制向左移動4位，即x<<y,x*2**y。平時用不到這種方法
2.字符串拼接
test = "you"
txt = "sb"
p test<<txt
輸出結(jié)果為：yousb
3.數(shù)組添加元素
ar = Array.new
ar<<3
p ar
輸出結(jié)果為：[3]
**字符串拼接和數(shù)組添加元素不能使用>>
git!(%W(-C #{dir} pull))
https://www.delftstack.com/zh/howto/ruby/ruby-what-does-w-mean/
array = ["one", "two", "three"]
輸出：
["one", "two", "three"]
它有效，但輸入引號和逗號需要花費大量時間和精力。Ruby 為我們提供了更優(yōu)雅的解決方案。
%w 語法用于創(chuàng)建字符串?dāng)?shù)組，而不需要在每個元素之間使用逗號或引號。
每個元素都將被視為一個字符串，并應(yīng)以空格分隔。
array = %w[1 two 3.4 [] {}]
輸出：
["1", "two", "3.4", "[]", "{}"]
if path =~ %r{https?://}
@podspecs_paths.each do |path|
if path =~ %r{https?://}
require 'cocoapods/open-uri'
output_path = podspecs_tmp_dir + File.basename(path)
=~ 是正則表達式
https://www.runoob.com/ruby/ruby-regular-expressions.html
正則表達式是一種特殊序列的字符，它通過使用有專門語法的模式來匹配或查找字符串集合。
<<
files << (pathname = Pathname.new(path))
-
1.<< 和 >>代表左移或右移
puts 1<<2
輸出結(jié)果為：4
代表1的二進制向左移動4位，即x<<y,x2*y。平時用不到這種方法
-
2.字符串拼接
test = "you"
txt = "sb"
p test<<txt
輸出結(jié)果為：yousb
-
3.數(shù)組添加元素
ar = Array.new
ar<<3
p ar
輸出結(jié)果為：[3]
**字符串拼接和數(shù)組添加元素不能使用>>
reject的用法
].concat(super).reject { |(name, _)| name == '--no-repo-update' }
reject和reject!
reject返回不滿足代碼塊的元素數(shù)組
reject！刪除數(shù)組中滿足代碼塊的元素
a=[1,2,3,5]
a.reject! {|x| x<4}
p a #[5]
b = [1,2,3,4,5]
c = b.reject {|x| x>4}
p c
p b
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
||= 的符號
@lockfile ||= begin
https://blog.csdn.net/lihuan974683978/article/details/8686297
a||=123
就是 當(dāng)a存在但是沒有賦值時 a＝123
extend 關(guān)鍵字
extend:在定義類時使用,把module的實例方法作為當(dāng)前類的類方法.
module Test
def class_type
"This class is of type:#{self.class}"
end
end
class TestClass
extend Test
end
puts TestClass.class_type #=> This class is of type:Class
module Pod
class Command
class Repo < Command
self.abstract_command = true
# @todo should not show a usage banner!
#
self.summary = 'Manage spec-repositories'
self.default_subcommand = 'list'
#-----------------------------------------------------------------------#
extend Executable
executable :git
def dir
config.repos_dir + @name
end
end
end
end
=> 箭頭函數(shù)
=>將鍵與哈希映射文字中的值分開。它不可重載，也沒有專門連接到符號。
哈希圖文字的形式為{key1 => value1, key2 => value2, ...}，但是當(dāng)用作函數(shù)的最后一個參數(shù)時，可以省略花括號。因此，當(dāng)您看到類似f(:a => 1, :b => 2)的函數(shù)調(diào)用時，將使用一個參數(shù)調(diào)用f，這是一個具有鍵:a和:b以及值1和2的哈希映射。
def pre_download(sandbox)
title = "Pre-downloading: `#{name}` #{description}"
UI.titled_section(title, :verbose_prefix => '-> ') do
target = sandbox.pod_dir(name)
begin
download_result = Downloader.download(download_request, target, :can_cache => can_cache)
rescue Pod::DSLError => e
raise Informative, "Failed to load '#{name}' podspec: #{e.message}"
rescue => e
raise Informative, "Failed to download '#{name}': #{e.message}"
end
spec = download_result.spec
raise Informative, "Unable to find a specification for '#{name}'." unless spec
def download_request
Downloader::Request.new(
:name => name,
:params => params,
)
end
? !
https://wenku.baidu.com/view/387eeb85f624ccbff121dd36a32d7375a417c6db.html
resuce
ruby 異常處理 begin rescue end
begin
代碼1
rescue
代碼2
end
如果執(zhí)行 代碼1 發(fā)生異常 則轉(zhuǎn)至 代碼2
若正常，則執(zhí)行完跳出
運算符號
https://ke.qq.com/itdoc/ruby/ruby-operator.html
各種運算符
**
將右側(cè)操作數(shù)指定為左側(cè)操作數(shù)的指數(shù)
**=
指數(shù)冪并賦值運算符
<=>
組合比較運算符
.eql?
檢查比較操作數(shù)相等和類型是否相同？
equal?
檢查比較對象ID是否相等
//更多請閱讀：https://www.yiibai.com/ruby/operators.html
<=>
組合比較運算符。如果第一個操作數(shù)等于秒，則返回0，如果第一個操作數(shù)大于第二個，則返回1，如果第一個操作數(shù)小于第二個則返回-1。
<=>
組合比較運算符。如果第一個操作數(shù)等于秒，則返回0，如果第一個操作數(shù)大于第二個，則返回1，如果第一個操作數(shù)小于第二個則返回-1。
10 等于？
如果接收方和參數(shù)具有相同的對象標識，則為真。
.join 和.tap 關(guān)鍵詞
def self.capture_command!(executable, command, **kwargs)
capture_command(executable, command, **kwargs).tap do |result|
result = Array(result)
status = result.last
unless status.success?
output = result[0..-2].join
raise Informative, "#{executable} #{command.join(' ')}\n\n#{output}".strip
end
end
end
join方法的定義
>> a
=> [42, 8, 17, 7, "foo", "bar"]
>> a.join # 沒有連接符
=> "428177foobar"
>> a.join(', ') # 連接符是一個逗號和空格
=> "42, 8, 17, 7, foo, bar"
https://ruby-china.org/topics/5348
分享 Rails 技巧之 tap & try
當(dāng)讀者遇到：
user = User.new
user.username = "foobar"
user.save!
他們必須遵循所有三行，然后才能認識到它只是在創(chuàng)建一個名為user.
如果是：
user = User.new.tap do |u|
u.username = "foobar"
u.save!
end
那么這將立即清楚。讀者不必閱讀塊內(nèi)的內(nèi)容即可知道實例user已創(chuàng)建。
正如博主所做的那樣，使用點擊只是一種方便的方法。在您的示例中，這可能有點矯枉過正，但在您想與用戶一起做很多事情的情況下，點擊可以說提供了一個更簡潔的界面。因此，也許在以下示例中可能會更好：
user = User.new.tap do |u|
u.build_profile
u.process_credit_card
u.ship_out_item
u.send_email_confirmation
u.blahblahyougetmypoint
end
使用上面的方法可以很容易地快速看到所有這些方法都組合在一起，因為它們都引用同一個對象（本例中的用戶）。替代方案是：
user = User.new
user.build_profile
user.process_credit_card
user.ship_out_item
user.send_email_confirmation
user.blahblahyougetmypoint
同樣，這是有爭議的 - 但可以證明第二個版本看起來有點混亂，并且需要更多的人工解析才能看到所有方法都在同一個對象上被調(diào)用。
gsub
https://blog.csdn.net/sqlxx/article/details/8164554
ruby中帶“!"和不帶"!"的方法的最大的區(qū)別就是帶”!"的會改變調(diào)用對象本身了。比方說str.gsub(/a/, 'b')，不會改變str本身，只會返回一個新的str。而str.gsub!(/a/, 'b')就會把str本身給改了。
但是gsub和gsub!還有另外一個不同點就是，gsub不管怎么樣都會返回一個新的字符串，而gsub!只有在有字符被替換的情況下才會返回一個新的字符串，假如說沒有任何字符被替換，gsub!只會返回nil.
example:
'abc'.gsub(/a/, 'b') #返回'bbc'
'abc'.gsub!(/a/, 'b') #返回'bbc'
'abc'.gsub(/d/,'a') #返回'abc'
'abc'.gsub!(/d/, 'a') #返回nil
scan match
https://blog.csdn.net/cz9025/article/details/90202839
用法：
新建文件xx.rb內(nèi)容為：
module ModuleName
def fn
p "module cz"
end
end
以獲得module名為例：
Dir["xx.rb"].each do |file|
name1 = File.read(file).scan(/module (.*)/)
p name1
name2 = File.read(file).match(/module (.*)/)
p name2
name3 = File.read(file).scan(/hh (.*)/)
p name3
name4 = File.read(file).match(/hh (.*)/)
p name4
end
運行結(jié)果為：
區(qū)別
scan:
??查找全部匹配的內(nèi)容，返回一個數(shù)組。
??如果未匹配到，返回[]。
??返回結(jié)果：()匹配到的內(nèi)容。
match:
??只匹配第一次，返回為MatchData類型。
??如果未匹配到，返回nil。
??返回結(jié)果：完整匹配部分+（）匹配到的內(nèi)容。
.map(&:to_s)
https://wenku.baidu.com/view/39aae24e26c52cc58bd63186bceb19e8b8f6ecae.html
Hash.key？(obj)方法
https://www.nhooo.com/note/qa55qj.html
在本文中，我們將研究Hash.key？(obj)方法。由于該方法的名稱完全不同，因此無法進行假設(shè)。讓我們閱讀其定義并在語法和程序代碼的幫助下了解其實現(xiàn)。
方法說明：
該方法是Public實例方法，屬于Hash類，它位于Ruby語言庫中。Hash.key？()方法用于檢查鍵（鍵值）是否為特定Hash實例的一部分，并且該Hash實例應(yīng)為普通的Hash實例。它將搜索整個哈希，并根據(jù)其搜索結(jié)果。讓我們來看一下語法，并演示該方法的程序代碼。
如果您正在考慮它將返回什么，那么讓我告訴您，它將返回一個布爾值。如果在哈希表中找到鍵，則返回值將為true；如果找不到哈希表實例的一部分，則返回值為false。
語法：
Hash_instance.key?(obj)
Argument(s) 需要：
此方法僅使用一個參數(shù)，而該參數(shù)不過是我們要檢查其存在性的鍵。
范例1：
=begin
Ruby program to demonstrate Hash.key? method
=end
hsh = {"colors" => "red","letters" => "a", "Fruit" => "Grapes"}
puts "Hash.key? implementation:"
puts "Enter the Key you want to search: "
ky = gets.chomp
if (hsh.key?(ky))
puts "Key found successfully"
else
puts "Key not found!"
end
輸出
Hash.key? implementation:
Enter the Key you want to search:
colors
Key found successfully
在上面的代碼中，您可以觀察到我們在普通的Hash實例上調(diào)用Hash.key？()方法。當(dāng)它在用戶輸入的哈希對象中發(fā)現(xiàn)鍵存在時，它返回true。
范例2：
=begin
Ruby program to demonstrate Hash.key? method
=end
hsh = {"colors" => "red","letters" => "a", "Fruit" => "Grapes"}
hsh1 = {"cars" => "800","bike" => "pulsar", "phone" => "A50"}
hsh2 = {"one"=> hsh, "two" => hsh1}
puts "Hash.key? implementation:"
puts "Enter the Key you want to search: "
ky = gets.chomp
if (hsh2.key?(ky))
puts "Key found successfully"
else
puts "Key not found!"
end
輸出結(jié)果
Hash.key? implementation:
Enter the Key you want to search:
colors
Key not found!
說明：
在上面的代碼中，您可以驗證Hash.key？()方法不適用于作為多個Hash實例集合的Hash實例。即使對象是Hash實例的一部分，它也會返回false。
