JavaScript mirası: Object.create ve yeni

JavaScript'te bu iki örnek arasındaki fark nedir:

Önkoşul:

function SomeBaseClass(){
}

SomeBaseClass.prototype = {
    doThis : function(){
    },

    doThat : function(){
    }
}

Object.create kullanarak kalıtım örneği A:

function MyClass(){
}

MyClass.prototype = Object.create(SomeBaseClass.prototype);

Yeni anahtar kelimeyi kullanan kalıtım örneği B

function MyClass(){
}

MyClass.prototype = new SomeBaseClass();

Her iki örnek de aynı şeyi yapıyor gibi görünüyor. Ne zaman birini diğerine tercih edersiniz?

Ek bir soru: Prototipte işlevin kendi kurucusuna bir referansın depolandığı aşağıdaki bağlantıdaki (satır 15) kodu düşünün. Bu neden yararlıdır?

https://github.com/mrdoob/three.js/blob/master/src/loaders/ImageLoader.js

Alıntı (bağlantıyı açmak istemiyorsanız):

THREE.ImageLoader.prototype = {

    constructor: THREE.ImageLoader
}

Sorunuzda bundan bahsetmiştiniz Both examples seem to do the same thing, bu hiç doğru değil çünkü

İlk örneğiniz

function SomeBaseClass(){...}
SomeBaseClass.prototype = {
    doThis : function(){...},
    doThat : function(){...}
}
function MyClass(){...}
MyClass.prototype = Object.create(SomeBaseClass.prototype);

Bu örnekte, sadece devralan SomeBaseClass' prototypeEğer bir mülk varsa ama ne SomeBaseClassbeğendiniz

function SomeBaseClass(){ 
    this.publicProperty='SomeValue'; 
}

ve eğer onu beğenirsen

var obj=new MyClass();
console.log(obj.publicProperty); // undefined
​console.log(obj);​

objNesne olmayacak publicPropertygibi özellik bu örnekte .

İkinci örneğiniz

MyClass.prototype = new SomeBaseClass();

Yürütme oluyor constructorbir örneğini yaparak, işlevi SomeBaseClassve bütün miras SomeBaseClassnesne. Yani, kullanırsan

    var obj=new MyClass();
    console.log(obj.publicProperty); // SomeValue
    console.log(obj);​

Bu durumda publicPropertyözelliği, bu örnektekiobj gibi nesne için de mevcuttur .

Yana Object.createbazı eski tarayıcılarda kullanılamaz, bu durumda size kullanabilirsiniz

if(!Object.create)
{
    Object.create=function(o){
        function F(){}
        F.prototype=o;
        return new F();
    }
}

Yukarıdaki kod, Object.createmevcut değilse yalnızca işlevi ekler, böylece Object.createişlevi kullanabilirsiniz ve bence yukarıdaki kod, Object.creategerçekte ne yaptığını açıklar . Umarım bir şekilde yardımcı olur.

Her iki örnek de aynı şeyi yapıyor gibi görünüyor.

Bu senin durumunda doğru.

Ne zaman birini diğerine tercih edersiniz?

Bir SomeBaseClassişlev gövdesine sahip olduğunda , bu newanahtar sözcükle çalıştırılır . Bu genellikle amaçlanmamıştır - yalnızca prototip zincirini kurmak istersiniz. Hatta bazı durumlarda , özel kapsamlı değişkenleri aynı ayrıcalıklı yöntemleri miras aldıkları için tüm örnekler tarafından paylaşılan bir nesneyi gerçekten başlattığınız için ciddi sorunlara neden olabilir MyClass. Diğer yan etkiler de düşünülebilir.

Yani genel olarak tercih etmelisiniz Object.create. Yine de bazı eski tarayıcılarda desteklenmemektedir; newçoğu zaman (bariz) bir zararı olmadığı için yaklaşımı çok sık görmenizin nedeni budur . Ayrıca bu cevaba bir göz atın .

Amaçlandığı Object.create()gibi kullanırsanız fark belirgin hale gelir . Aslında, prototypekelimeyi kodunuzdan tamamen gizler , işi kaputun altında yapar. Kullanarak Object.create(), gibi gidebiliriz

var base =  {
    doThis : function(){
    },

    doThat : function(){
    }
};

Ve bundan sonra diğer nesneleri genişletebilir / miras alabiliriz

var myObject = Object.create( base );
// myObject will now link to "base" via the prototype chain internally

Yani bu başka bir kavram, daha "nesne yönelimli" bir engelleme yolu. Object.create()Örneğin , kutunun dışında bir "yapıcı işlevi" yoktur . Ancak elbette, bu nesneler içinde kendi kendini tanımlayan bir yapıcı işlevi oluşturabilir ve çağırabilirsiniz .

Kullanmak için bir argüman Object.create()daha görünebilir olmasıdır doğal etmek mix / * devralır * diğer nesnelerden, Javascriptleri kullanmaktan daha varsayılan yol .

Java betiğinde uzman değilim ama burada "Object.create" ve "new" arasındaki farkı anlamak için basit bir örnek var ..

1. adım: bazı özellikler ve eylemlerle ana işlevi oluşturun ..

function Person() {

this.name = 'venkat';

this.address = 'dallas';

this.mobile='xxxxxxxxxx'

}

Person.prototype.func1 = function () {

    return this.name + this.address;
}

2. adım: New anahtar sözcüğünü kullanarak Kişi işlevinin üzerine çıkan bir çocuk işlevi (PersonSalary) oluşturun ..

function PersonSalary() {
    Person.call(this);
}
PersonSalary.prototype = new Person();

PersonSalary();

Adım 3: Object.create anahtar sözcüğünü kullanarak Person işlevinin üzerine uzanan ikinci çocuk işlevi (PersonLeaves) oluşturun .

function PersonLeaves() {
 Person.call(this);
}
PersonLeaves.prototype = Object.create(Person.prototype);


PersonLeaves();

// Şimdi her iki alt işlev prototipini kontrol edin.

PersonSalary.prototype
PersonLeaves.prototype

bu çocuk işlevlerin her ikisi de Kişi (ana işlev) prototipine bağlanır ve yöntemlerine erişebilir, ancak yeniyi kullanarak çocuk işlev oluşturursanız, ihtiyacımız olmayan tüm üst özelliklere sahip yepyeni bir nesne döndürür ve ayrıca herhangi bir şey oluşturduğunuzda nesne veya işlev "Yeni" kullanılarak yürütülür ve bizim olmasını istemediğimiz üst işlev yürütülür.

İşte çıkarımlar

Üst işlevdeki bazı yöntemlere yetki vermek istiyorsanız ve yeni bir nesnenin oluşturulmasını istemiyorsanız, Object.create kullanmak en iyi yoldur.