亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Ruby的block怎么使用

發布時間:2022-01-14 14:46:17 來源:億速云 閱讀:152 作者:iii 欄目:大數據

這篇文章主要介紹“Ruby的block怎么使用”的相關知識,小編通過實際案例向大家展示操作過程,操作方法簡單快捷,實用性強,希望這篇“Ruby的block怎么使用”文章能幫助大家解決問題。

1. 塊(block)是一段「半自由」的代碼,其形在方法外,而魂歸方法里。

塊(block)代碼由{...}或do...end界定而成。

   [1, 2, 3].each{|i| i + 1}

塊(block)代碼不能被單獨調用,只能依附于方法,所以稱其為魂歸方法里。

2. 塊(block)魂歸自身,獲得完全自由的唯一方法就是,讓其對象化。

魂歸自身,意味著,它完全自由了,可被單獨調用了

 
  Proc.new{ puts "hello"}
  proc{ puts  "hello"}
  proc{|msg| puts "hello #{msg}"}
  
  lambda{puts "hello"}
  lambda{|msg = "world!"| puts "hello #{msg}"}
  
  ->{puts "hello"}
  ->(msg="world!"){puts "hello #{msg}"}

以上就是Ruby提供的所有塊(block)對象, 都是Proc類的對象。

3. 用不用塊(block),是你的自由,但是方法天生就是塊的魂歸之地。

Ruby中任何一個方法你都可以傳遞一個塊。

 
   def test;end
   test{ puts i}

上面的代碼,甚至都不會報錯,因為在test方法內部沒有去使用這個塊(block)。
顯然,你已經不能把塊(block)當成那個常規的方法參數了,雖然它的行為像參數。

4. 如何使用塊(block), 直接決定了它的命運!

A. 在方法內部使用yield關鍵字去引block的“魂”。

 
  def test
    yield
  end
  test{puts "hello test!"}
  
  def test(x)
    yield(x)
  end
  test('world!'){|x| puts "hello #{x}"}

yield關鍵字不僅可以掛載塊(block)代碼,而且可以給塊傳遞參數。

B. 魂歸自身式:使用「&」讓一個傳遞給方法的塊(block)魂歸自身。

 
  def test(&block)
    block.call("world")
  end
  
  test{|msg| puts "hello #{msg}"}

但是在方法內部,也可以使用「&」給塊對象(Proc對象)抽魂:

 
  def test(&block)
    inner_test(&block)
  end
  
  def inner_test
    yield("haha!")
  end
  
  test{|msg| puts "hello #{msg}"}

方法真陰險!有木有?

5. 爭風吃醋的block兄弟。

{...}和do ... end,雖然是塊(block)孿生兄弟,但是也有個誰先誰后的,使用的時候注意,否則它們會讓你知道誰才是老大!

  def test(block)
    block.call
  end
  
  test lambda do 
     puts "hello"
  end

你給test方法傳遞了一個自由的Proc對象,但是稍有不同,這個Proc對象是用do...end,但是,你執行代碼后會發現,這段代碼會拋出異常:ArgumentError: tried to create Proc object without a block

 
  test( lambda do
          puts "hello"
        end
      )

必須要這么修改才可以正常執行。或者使用:

 
  test lambda{puts "hello"}

這樣也可以正常工作。

可以看得出來, do...end 不如 {...}優先級高,{...}親近離它最近的那個lambda, 而do...end卻親近最遠的那個test。
感覺do...end有點混,所以類似于這種把Proc對象傳遞給方法的時候,一定要注意用括號,或者用{...}

不過由于這個拋出的異常,ArgumentError: tried to create Proc object without a block,我們倒是可以得到一個隱式傳遞block給方法的寫法:

 
  def test
    proc_obj = Proc.new
    proc.call
  end
  
  test{puts "hello"}

6. 塊(block)也有自尊。

 
  def test
    x = 1
    yield(x)
  end
  
  x = 2
  test{ puts x }

塊(block)有個超能力,穿透作用域。 上面例子里,塊(block)并沒有使用test方法里的變量x=1, 而是把塊(block)作用域外的變量x=2抓在了手里。

7. 對于塊(block)的自尊, 方法向你(Rubyist)求助!

 
  def test
    x = 1
    yield(x)
  end
  
  x = 2
  test{ |x| puts x }

你(Rubyist)往塊(block)里插入了個參數,頓時霸氣側漏。方法對你感激不盡,你驕傲的昂起了頭 。。。

8. 塊(block)還是不服!向你(Rubyist)求助,恢復其自由身!

你(Rubyist)幫塊(block)實現了自由身,使用lambda對象化了塊

 
  def test
    x = 1
    lambda{ puts x}
  end
  
  lambda_proc_obj = test
  lambda_proc_obj.call

這下塊對象(lambda_proc_obj)出氣了, lambda_proc_obj想啥時候調用就啥時候調用(lambda_proc_obj.call)。
lambda_proc_obj心想:「哥把你這方法打包了,掌握著你的數據(x=1),再也不看你臉色了。」
噢, 原來如此, 讓塊(block)完全自由以后變成Proc對象, 它就有閉包的超能力了,好可怕!

9. 兩種塊對象(Proc對象), 兩種命運,可悲可嘆!。

A. 被方法所奴役 : 必須要執行的代碼段

 
  proc_obj = Proc.new{ return "from proc return"}
  # proc_obj = proc {return  "from proc return"}
  
  def test(block)
    msg = block.call
    puts "hello! #{msg}!"
  end
  
  test(proc_obj)

這段代碼會拋出LocalJumpError異常, 用Proc.new和proc{}定義的Proc對象,是不能使用return的。
這就意味著,這個Proc對象,一旦被call,就必須要執行完。

注意這里test方法傳遞一個本身就是Porc的對象,并沒有使用&。

再看看這段代碼,看看這倆Proc對象對arity的關心程度(是否檢查塊對象的參數個數)

 
def call_with_too_many_args(closure)
  begin
      puts "closure arity: #{closure.arity}"
      closure.call(1,2,3,4,5,6)
      puts "Too many args worked"
  rescue Exception => e
      puts "Too many args threw exception #{e.class}: #{e}"
  endend
 def two_arg_method(x,y)endputs "Proc.new:"; call_with_too_many_args(Proc.new {|x,y|})puts "proc:"    ; call_with_too_many_args(proc {|x,y|})

這段代碼可以看出來, Proc.new或proc{}定義的proc對象,完全是方法的奴隸啊!
工作必須執行完不說(無法return),參數個數給傳多少都不能發出半點怨言啊!僵尸? 奴隸?

B. 一段匿名的方法體

 
  lambda_proc_obj = lambda{return "return from lambda proc"}
  # lambda_proc_obj = ->{return "return from lambda proc"}

  def test(block)
    msg = block.call
    puts "hello! #{msg}!"
  end
  
  test(lambda_proc_obj)

可以看得出來,lambda proc對象是可以正常返回的.

 
  puts "lambda:"  ; call_with_too_many_args(lambda {|x,y|})

這段代碼,就明白了,lambda{}方式創建的Proc對象,才是真正的自由塊對象啊!
工作想休息的時候就休息(可以return), 給傳的參數多了,也可以發出怨言。
自由的空氣,真好。

看來lambda proc和Method對象,有點類似:

 
  puts "Method:"  ; call_with_too_many_args(method(:two_arg_method))

10. 你(Rubyist)有四種方式對可憐的塊對象呼來喝去。

 
  lm_proc_obj = lambda{puts  "hello world!"}
  
  lm_proc_obj.call
  lm_proc_obj.() #無參數必須給一個空的括號
  lm_proc_obj[] #無參數必須給一個空的中括號
  
  lm_proc_obj = lambda{|msg| puts  "hello #{msg}!"}
  
  lm_proc_obj.call("world")
  lm_proc_obj.("world") 
  lm_proc_obj["world"]
  lm_proc_obj === "world"

看到第四種方式,你應該想到,你可以在case語句里使用proc對象了吧?

 
  def response_code?(code)
    ->(response) { response.code == code }
  end

  case response
  when response_code?(200) then 'OK'
  when response_code?(404) then 'Not found'
  else 'Unknown code'
  end

關于“Ruby的block怎么使用”的內容就介紹到這里了,感謝大家的閱讀。如果想了解更多行業相關的知識,可以關注億速云行業資訊頻道,小編每天都會為大家更新不同的知識點。

向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

兴义市| 镇远县| 栾川县| 高邑县| 佳木斯市| 吉水县| 靖边县| 古浪县| 景宁| 中宁县| 青川县| 通许县| 石城县| 宁河县| 定安县| 永仁县| 绥芬河市| 西吉县| 九江市| 高阳县| 阳谷县| 唐山市| 延津县| 香港| 潼南县| 桦甸市| 云梦县| 大厂| 亳州市| 儋州市| 上犹县| 淮阳县| 明溪县| 如东县| 吉林省| 罗城| 平利县| 德昌县| 万安县| 杭锦旗| 迁西县|