230

たとえば、Rubyのドキュメント:dup

一般に、cloneおよびdupは子孫クラスで異なるセマンティクスを持つ場合があります。内部状態をclone含むオブジェクトを複製するために使用されますが、dup通常は子孫オブジェクトのクラスを使用して新しいインスタンスを作成します。

しかし、いくつかのテストを行ったところ、実際には同じであることがわかりました。

class Test
   attr_accessor :x
end

x = Test.new
x.x = 7
y = x.dup
z = x.clone
y.x => 7
z.x => 7

では、2つの方法の違いは何ですか?

4

6 に答える 6

314

サブクラスは、これらのメソッドをオーバーライドして、異なるセマンティクスを提供する場合があります。それObject自体、2つの重要な違いがあります。

まず、cloneシングルトンクラスをコピーしますが、コピーしdupません。

o = Object.new
def o.foo
  42
end

o.dup.foo   # raises NoMethodError
o.clone.foo # returns 42

次に、clone凍結状態を保持しますが、保持しdupません。

class Foo
  attr_accessor :bar
end
o = Foo.new
o.freeze

o.dup.bar = 10   # succeeds
o.clone.bar = 10 # raises RuntimeError

これらのメソッドのRubinius実装 は、非常に明確で、かなり準拠したRuby実装であるため、これらの質問に対する回答のソースになることがよくあります。

于 2012-04-17T00:24:38.137 に答える
201

ActiveRecordを扱う場合にも、大きな違いがあります。

dupIDを設定せずに新しいオブジェクトを作成するため、を押すと新しいオブジェクトをデータベースに保存できます。.save

category2 = category.dup
#=> #<Category id: nil, name: "Favorites"> 

clone同じIDで新しいオブジェクトを作成するため、その新しいオブジェクトに加えられたすべての変更は、ヒットした場合に元のレコードを上書きします.save

category2 = category.clone
#=> #<Category id: 1, name: "Favorites">
于 2014-07-09T09:32:36.170 に答える
30

1つの違いは、凍結されたオブジェクトの場合です。凍結されたオブジェクトのcloneも凍結されます(凍結されたdupオブジェクトのは凍結されません)。

class Test
  attr_accessor :x
end
x = Test.new
x.x = 7
x.freeze
y = x.dup
z = x.clone
y.x = 5 => 5
z.x = 5 => TypeError: can't modify frozen object

もう1つの違いは、シングルトンメソッドです。ここで同じ話は、dupそれらをコピーしませんが、コピーcloneします。

def x.cool_method
  puts "Goodbye Space!"
end
y = x.dup
z = x.clone
y.cool_method => NoMethodError: undefined method `cool_method'
z.cool_method => Goodbye Space!
于 2012-04-17T00:18:09.483 に答える
5

新しいドキュメントには良い例が含まれています。

class Klass
  attr_accessor :str
end

module Foo
  def foo; 'foo'; end
end

s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.extend(Foo) #=> #<Klass:0x401b3a38>
s1.foo #=> "foo"

s2 = s1.clone #=> #<Klass:0x401b3a38>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401b3a38>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
于 2015-12-15T12:06:35.477 に答える
4

どちらもほぼ同じですが、cloneはdupよりも1つ多くのことを行います。クローンでは、オブジェクトのフリーズ状態もコピーされます。dupでは、常に解凍されます。

 f = 'Frozen'.freeze
  => "Frozen"
 f.frozen?
  => true 
 f.clone.frozen?
  => true
 f.dup.frozen?
  => false 
于 2015-02-05T13:36:34.300 に答える
1

クローンを使用して、Rubyでプロトタイプベースのプログラミングを行うことができます。RubyのObjectクラスは、cloneメソッドとdupメソッドの両方を定義します。cloneとdupはどちらも、コピーしているオブジェクトの浅いコピーを生成します。つまり、オブジェクトのインスタンス変数はコピーされますが、参照するオブジェクトはコピーされません。例を示します。

class Apple
  attr_accessor :color
  def initialize
    @color = 'red'
  end
end

apple = Apple.new
apple.color
 => "red"
orange = apple.clone
orange.color 
 => "red"
orange.color << ' orange'
 => "red orange" 
apple.color
 => "red orange"

上記の例では、オレンジ色のクローンがアップルオブジェクトの状態(つまり、インスタンス変数)をコピーしますが、アップルオブジェクトが他のオブジェクト(文字列オブジェクトの色など)を参照している場合、それらの参照はコピーされません。代わりに、リンゴとオレンジの両方が同じオブジェクトを参照しています!この例では、参照は文字列オブジェクト「red」です。orangeがappendメソッド<<を使用して既存のStringオブジェクトを変更すると、stringオブジェクトが「redorange」に変更されます。これは事実上、apple.colorも変更します。これは、両方が同じStringオブジェクトを指しているためです。

ちなみに、代入演算子=は、新しいオブジェクトを代入して、参照を破棄します。これがデモンストレーションです:

class Apple
  attr_accessor :color
  def initialize
    @color = 'red'
  end
end

apple = Apple.new
apple.color
=> "red"
orange = apple.clone
orange.color
=> "red"
orange.color = 'orange'
orange.color
=> 'orange'
apple.color
=> 'red'

上記の例では、オレンジ色のクローンのカラーインスタンスメソッドに新しいオブジェクトを割り当てたときに、アップルと同じオブジェクトを参照しなくなりました。したがって、appleのcolorメソッドに影響を与えることなく、orangeのcolorメソッドを変更できますが、appleから別のオブジェクトを複製すると、その新しいオブジェクトは、コピーされたインスタンス変数内のappleと同じオブジェクトを参照します。

dupは、コピーしているオブジェクトの浅いコピーも生成します。上記と同じデモをdupに対して実行すると、まったく同じように機能することがわかります。ただし、cloneとdupには2つの大きな違いがあります。まず、他の人が述べたように、クローンはフリーズ状態をコピーしますが、dupはコピーしません。これは何を意味するのでしょうか?Rubyの「凍結」という用語は、不変の難解な用語であり、それ自体がコンピューターサイエンスの命名法であり、何かを変更できないことを意味します。したがって、Rubyでフリーズしたオブジェクトを変更することはできません。事実上、不変です。フリーズされたオブジェクトを変更しようとすると、RubyはRuntimeError例外を発生させます。cloneはフリーズ状態をコピーするため、cloneされたオブジェクトを変更しようとすると、RuntimeError例外が発生します。逆に、dupはフリーズ状態をコピーしないため、

class Apple
  attr_accessor :color
  def initialize
    @color = 'red'
  end
end

apple = Apple.new
apple.frozen?
 => false 
apple.freeze
apple.frozen?
 => true 
apple.color = 'crimson'
RuntimeError: can't modify frozen Apple
apple.color << ' crimson' 
 => "red crimson" # we cannot modify the state of the object, but we can certainly modify objects it is referencing!
orange = apple.dup
orange.frozen?
 => false 
orange2 = apple.clone
orange2.frozen?
 => true 
orange.color = 'orange'
 => "orange" # we can modify the orange object since we used dup, which did not copy the frozen state
orange2.color = 'orange'
RuntimeError: can't modify frozen Apple # orange2 raises an exception since the frozen state was copied via clone

次に、さらに興味深いことに、cloneはシングルトンクラス(したがってそのメソッド)をコピーします!これは、Rubyでプロトタイプベースのプログラミングを行う場合に非常に便利です。まず、実際にシングルトンメソッドがcloneでコピーされることを示してから、Rubyでのプロトタイプベースのプログラミングの例に適用できることを示しましょう。

class Fruit
  attr_accessor :origin
  def initialize
    @origin = :plant
  end
end

fruit = Fruit.new
 => #<Fruit:0x007fc9e2a49260 @origin=:plant> 
def fruit.seeded?
  true
end
2.4.1 :013 > fruit.singleton_methods
 => [:seeded?] 
apple = fruit.clone
 => #<Fruit:0x007fc9e2a19a10 @origin=:plant> 
apple.seeded?
 => true 

ご覧のとおり、フルーツオブジェクトインスタンスのシングルトンクラスがクローンにコピーされます。したがって、複製されたオブジェクトはシングルトンメソッド:seeded?にアクセスできます。しかし、これはdupには当てはまりません。

apple = fruit.dup
 => #<Fruit:0x007fdafe0c6558 @origin=:plant> 
apple.seeded?
=> NoMethodError: undefined method `seeded?'

現在、プロトタイプベースのプログラミングでは、他のクラスを拡張し、ブループリントとして機能する親クラスからメソッドが派生するクラスのインスタンスを作成するクラスはありません。代わりに、ベースオブジェクトがあり、そのメソッドと状態がコピーされたオブジェクトから新しいオブジェクトを作成します(もちろん、クローンを介して浅いコピーを実行しているため、インスタンス変数が参照するオブジェクトはJavaScriptと同じように共有されますプロトタイプ)。次に、複製されたメソッドの詳細を入力することにより、オブジェクトの状態を入力または変更できます。次の例では、ベースフルーツオブジェクトがあります。すべての果物にはシードがあるため、メソッドnumber_of_seedsを作成します。ただし、リンゴには1つのシードがあるため、クローンを作成して詳細を入力します。これで、Appleのクローンを作成するときに、メソッドのクローンを作成するだけでなく、状態のクローンも作成しました。cloneは状態(インスタンス変数)の浅いコピーを行うことを忘れないでください。そのため、アップルのクローンを作成してred_appleを取得すると、red_appleには自動的に1つのシードが含まれます。red_appleは、Appleから継承するオブジェクトと考えることができます。AppleはFruitから継承します。したがって、それが私がフルーツとアップルを利用した理由です。クローンのおかげで、クラスとオブジェクトの区別を廃止しました。

Fruit = Object.new
def Fruit.number_of_seeds=(number_of_seeds)
  @number_of_seeds = number_of_seeds
end
def Fruit.number_of_seeds
  @number_of_seeds
end
 Apple = Fruit.clone
 => #<Object:0x007fb1d78165d8> 
Apple.number_of_seeds = 1
Apple.number_of_seeds
=> 1
red_apple = Apple.clone
 => #<Object:0x007fb1d892ac20 @number_of_seeds=1> 
red_apple.number_of_seeds
 => 1 

もちろん、プロトタイプベースのプログラミングではコンストラクターメソッドを使用できます。

Fruit = Object.new
def Fruit.number_of_seeds=(number_of_seeds)
  @number_of_seeds = number_of_seeds
end
def Fruit.number_of_seeds
  @number_of_seeds
end
def Fruit.init(number_of_seeds)
  fruit_clone = clone
  fruit_clone.number_of_seeds = number_of_seeds
  fruit_clone
end
Apple = Fruit.init(1)
 => #<Object:0x007fcd2a137f78 @number_of_seeds=1> 
red_apple = Apple.clone
 => #<Object:0x007fcd2a1271c8 @number_of_seeds=1> 
red_apple.number_of_seeds
 => 1 

最終的に、cloneを使用すると、JavaScriptプロトタイプの動作に似たものを取得できます。

于 2019-02-06T17:26:50.373 に答える