ruby進階

  • 相同數字的object_id不會變，相同字符串會變
1.object_id //200
1.object_id //200

"a".object_id //1200
"a".object_id //1220
  • ruby interpreter(解釋器)將所有的symbol存放在一張symbol table里，symbol很快，但是不會被垃圾回收(garbage collecter)
Array.new(3,"abc") // 三個元素都是一個引用，改其中一個其他的都會變化
Array.new(3) {"abc"} // 不同引用，改其中一個不會影響其他
  • 數組常用方法
arr = [1,2,3,1,2]
arr.uniq // 去重，[1,2,3]
arr.last / arr[-1]  // 取最后一位
arr.shuffle // 打亂數組
[[1,2,3],[4,5]].flatten  // [1,2,3,4,5]
arr.each {|value| p value}
arr.each_with_index {|value,index| p "#{index}: #{value}"}
arr.reverse_each {|value| p value}
arr.sort // 排序
arr.select {|value| value>3}
arr.compact // 去掉數組里的 nil
array.any? {|value| value > 3}  // 數組里是否存在大于3的值
  • hash 常用方法
h = {a:1 , b:2}
h.assoc :b  // [:b,2]
h.has_value? 2
h.has_key? :b
h.keys // [:a,:b]
h.values  // [1,2]
h.to_a // [[:a,1],[:b,2]]
h.merge({c:3}) // {a:1 ,b:2, c:3}
h.each {|key,value| p [key,value]}
h.each_key {|key| p key}
h.each_value {|value| p value}
h.select {|key| key == :a} // {:a => 1}
h.delete a //刪除a
  • 集合 Set，無重復
Set.new [1,2]
s = _
s.add 'foo'
b = Set.new [2,3]
s & b // {2}，求交集
s | b //  求并集
s <= b // 求子集
  • Range
r = 1..2 // [1,2]
r = 1...2 // [1,2)
r.include? 2 //true

a  = [1,2,3,4]
a[1..2] // [2,3]
  • ruby中如何讓 symbol 和 string 實現相同效果？？？
  • 方法風格：在開頭把所有會return的情況都走完 
def method x
  return if x.blank? || x.empty?
  func1 ...
  func2 ...
end
  • 單例方法：只對當前對象有效 
str = "hello"
def str.foo
  p self
end

arr = [1,2,3]
def arr.+ num
  self.dup << num
end

arr.+ 4 // [1,2,3,4]
  • 方法別名：讓方法在不同環境下更加語義化 
def foo
  p "foo"
end

alias :bar :foo
  • ruby方法傳參
  1. 默認參數
  2. 任意多參數
def foo a,*b,c
  p a
  p b 
  p c
end

foo 1,2,3,4,5 
// 1  [2,3,4]  5
  1. hash參數：傳入hash參數時，大括號可以省略
def foo hash
  h.each do |key,value|
    p [key,value]
  end
end

foo({a:1,b:2})
foo(a:1,b:2) // 傳入hash參數時，大括號可以省略
  • load：如果在irb里load一個ruby文件，不僅可以跑一遍程序，還會把文件里的變量或者方法load到當前irb環境里
  • block里的return，指的是從包含這個block的方法return，如果這個block沒被方法包含，是不能return的
  • proc
// & 這個符號就相當于把block轉換為proc，相當于一個方法變量
def foo(&block)
  a = 2
  block.call(a)
end

foo {|v| p v}

---------------------------------

arr = %w(a b c)
arr.map(&:capitalize)  // 這里相當于 capitalize這個method 轉為 proc ，proc 再轉為 block
  • lambda proc 區別：
  1. proc參數可以多傳少傳，lambda必須傳準確的參數個數
  2. proc更像block，lambda更像method
  3. return
p = Proc.new {|x| return if x > 0}
p.call(1) // 報錯

l = lambda {|x| return if x > 0}
l.call(1)  // 不會報錯
  • Class and Object:
  1. Class 可以看做一個 container of methods
  2. Object is a receiver,that can respond to those methods
class Point 
end

p = Point.new

p.methods(false) // 不顯示繼承的方法，只顯示父類的方法

class Point
  attr_accessor :x,:y
  
  def initialize x,y
    @x,@y = x,y
  end

  def first_quadrant?
    x > 0 && y > 0
    // 相當于 self.x > 0 && self.y > 0
    // 如果要修改實例變量的話，必須 @x = 1 或者 self.x = 1
  end

  def +(p2)
    Point.new(x + p2.x, y + p2.y)
  end

  // self在method上就是類方法，self在里面就是實例方法
  def self.second_quradrant?(x,y)
    x < 0 && y > 0
    // 這里如果有self也是指類
  end

  // 批量定義class methods
  class << self
    def foo
    end

    def bar
    end
  end

  @@origin = 0
  // 類變量的getter必須自己定義?
  def self.get_origin
    @@origin
  end

  ORIGIN = 2

end

p1 = Point.new 1,2
p2 = Point.new 2,3

p1 + p2

Point.get_origin
Point::ORIGIN  // 獲取常量的方式
  • ruby中一個class的所有方法都可以被繼承
  • public protected private
  1. 如果想繼承一個方法，最好使用public或者protected，因為private也會被overload，可能造成不期望的后果
  2. 實例化對象只能調用public，protected和private只能在class內部調用
  3. 三者都可以被inheriate
  4. private 只能在內部隱式調用
class A
  def func1
    // 直接調用不會報錯
    func1
    func2
  end 

  def func2
  end

  def func3
  end 

  protected :fun2
  private :fun3
end
  1. 在class內部，可以在obj上調用protected，不能調用private
class A
  def func1
    // self就是對應的實例化對象，可以call protected，不能call private
    self.func2 // 不會報錯
    self.fun3  // 報錯
  end

  def func2
  end

  def func3
  end 

  protected :fun2
  private :fun3
end

a = A.new
a.func1
  1. 類方法不能調用實例方法，只能調用類方法，實例方法中可以訪問實例方法和類方法
  2. 類方法不能被overload，實例方法(三種)可以
  3. 類方法中不能引用實例變量，實例方法可以引用類變量和實例變量
  4. 類方法中不能super
  • module只能將instance method mixin進來，不能mixin class method
  • module可以通過extend等方法將instance method mixin成class method
module Helper
  def self.a
    p 'a'
  end

  def b
    p 'b'
  end
end

class P
  extend Helper
end

P.b // b
  • 如果既想mixin instance method，又想mixin class method，可以使用included這個hooks：
module Helper
  def a
    p 'a'
  end

  module ClassMethods
    def b
      p 'b'
    end
  end

  // when include in klass, the hook is called
  def self.included(klass)
    klass.extend ClassMethods
  end
end

class P
  include Helper
end

P.included_modules  // [Helper,Kernel]
P.include?(Helper) // true
p = P.new
p.a
P.b
  • ruby可以理解為沒有class method，單例方法存儲在對象的singleton_class中，是該對象的singleton_class的instance method。因此extend本質上就是把method include到class的singleton_class中
str = "hello"
def str.foo
   'foo'
end
str.singleton_class
str.singleton_class.class  // Class
str.singleton_methods // [:foo]
str.singleton_class.instance_methods(false) // [:foo]

class Foo
  def self.foo
      'foo'
  end
end

Foo.singleton_methods // [:foo]
Foo.singleton_class.instance_methods(false) // [:foo]
Foo.singleton_methods == Foo.singleton_class.instance_methods(false) // true
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 之前講述了基礎的Rack使用，現在我們來試試深入Rack，如果不了解Rack，可以去看看之前一篇最基礎的 Ruby...
    感覺被掏空閱讀 1,879評論 0贊 4
  • 簡介 基本上所有的 Ruby web framework 都是Rack App，web框架大多都是基于rack之上...
    感覺被掏空閱讀 2,841評論 0贊 8
  • ruby中的簡寫 1. puts "hihihi" #等同于 puts("hihihi") 2.每個函數的...
    Joke_Ape閱讀 565評論 0贊 0
  • 從訂閱的ruby-weekly郵件里看到這篇文章，看完后覺得寫得不錯，比較細致，簡單翻譯一下，留備后用原文章地址 ...
    peterzd閱讀 1,964評論 1贊 50
  • ruby簡介 Ruby 是一種開源的面向對象程序設計的服務器端腳本語言 ruby安裝（mac） 我們可以在終端中測...
    狂猿閱讀 406評論 0贊 0