Ruby 中的一些基本概念

liuxingqi bio photo By liuxingqi Comment

Public VS Protected VS Private

  1. Public 方法可以在任何地方被调用，没有任何限制。方法默认是 public 的，但有两个例外，initialize 方法是 private 的， 在类外定义的“全局”方法也是Object对象的私有方法；
  2. Private 方法是实现一个类时使用的内部方法。它只能被这个类或子类的实例方法所调用。它不能被一个显式的接收者所调用，只能被 self所隐式调用。这就意味着私有方法只能在当前对象的的上下文中被调用，你不能调用另外一个对象的私有方法。类的私有方法可以被子类继承，子类可以调用 并覆盖父类的私有方法；
  3. Protected 方法与私有方法的相似之处是它也只能在该类或子类的内部被调用，不同之处在于它可以被该类的实例显式调用。

根据实例来分析：

class A
  def test1
    test4
  end

  def test2
    self.test4
  end

  def test3
    A.new.test4
  end

  private
    def test4
      puts "hello, world!"
    end

    def self.test5
      puts "hello, Jason!"
    end
end

a = A.new
a.test1 => hello, world!
#私有方法可以在当前对象的上下文中被调用

a.test2 => NoMethodError: private method `test4' called for #<A:0x007f80b9144c40>
#私有方法不能被显式的接收者调用，即使接收者是self

a.test3 => NoMethodError: private method `test4' called for #<A:0x007f80b914c508>
#私有方法不能被显式的接收者调用,更不能调用其他对象的私有方法

a.test4 => NoMethodError: private method `test4' called for #<A:0x007f80b9144c40>
#同上，私有方法不能被显式的接收者调用

A.test5 => hello, Jason!
#private只作用于实例方法，对类方法是不生效的，如果要让类方法称为私有的，应当使用 private_class_method

如果在此处把 private 改成 protected，让我们再来看看结果是什么样的:

class A
  def test1
    test4
  end

  def test2
    self.test4
  end

  def test3
    A.new.test4
  end

  protected
    def test4
      puts "hello, world!"
    end

    def self.test5
      puts "hello, Jason!"
    end
end

a = A.new
a.test1 => hello, world!
#protected方法可以在当前对象的上下文中被调用

a.test2 => NoMethodError: private method `test4' called for #<A:0x007f80b9144c40>
#protected方法在方法定义中可以被显式的接收者self调用

a.test3 => NoMethodError: private method `test4' called for #<A:0x007f80b914c508>
#protected方法可以被属于同一类或子类的其他对象所调用

a.test4 => NoMethodError: private method `test4' called for #<A:0x007f80b9144c40>
#protected方法在类定义外不能被显式的接收者调用

A.test5 => hello, Jason!
#protected只作用于实例方法，对类方法是不生效的

从上面的例子可以看出，private 和 protected 的区别并不是很大，它们都不能在类定义外被显式的接收者 所调用，但在方法定义中可以被调用，只是在方法定义中，private 也不能被显式调用，但是 protected 可以， 并且 protected 可以被属于同一类或子类的其他对象所调用，但 private 却不可以。

Require VS Load

Require

require.rb:

def test
    puts "hello, world"
end
test

test.require.rb:

puts require "./require.rb"
puts require './require.rb'

output：

hello, world
true
false
Load

load.rb:

def test
    puts "hello, world"
end
test

test.require.rb:

puts load "./load.rb"
puts load "./load.rb"

output：

hello, world
true
hello, world
true

从上面两个例子可以看出，require 和 load 的区别是：如果多次加载同一文件，require 只加载一次，而 load 会加载多次。

Include VS Extend

定义一个 module A, class Test1, class Test2:

module A
  def test
     puts "hello,world!"
  end
end

class Test1
  include A
end

class Test2
  extend A
end

output:

Test1.test => NoMethodError: private method `test' called for Test1:Class
Test1.new.test => hello,world
Test2.test => hello,world
Test2.new.test => NoMethodError: private method `test' called for #<Test2:0x007fa44287bf98>

因此，我们可以看出，如果在一个类中 include 一个模块，模块中的方法将成为类的实例方法，如果 extend 一个 模块，模块中的方法将成为类的类方法。

我们再定义一个 module B, class Test3:

module B
  def test
    puts "hello Jason"
  end
end

class Test3
  include A
  include B
end

Test3.new.test => hello Jason

如果类中 include 了多个模块，并且模块中有相同的方法，后加载的会覆盖之前加载的方法。

Dup VS Clone

这两个方法分配一个调用者所属的实例，然后把调用者的所有实例变量及修改都拷贝到新创建的对象中。 dup 和 clone 用的都是浅拷贝，即如果实例变量包含对其他对象的引用，那么拷贝的是引用而不是对象本身。 它们的区别是：

  • clone 比 dup 拷贝更彻底，它还拷贝调用者的单键方法。
class A
end

a = A.new

def a.play
   puts "play"
end

a.play => "play"
b = a.clone
b.play => "play"
c = a.dup
c.play => "undefined method `play' for #<A:0x007fcbb184eed0> (NoMethodError)"

单键方法是指只对单个对象生效的方法，类方法是特殊的单键方法

  • clone 保留对象 frozen 状态， 而 dup 不会
class Foo
  attr_accessor :bar
end
o = Foo.new
o.freeze # 防止对象被修改

o.dup.bar = 10   # succeeds
o.clone.bar = 10 # RuntimeError: can't modify frozen Foo
comments powered by Disqus