JavaScript'in "yeni" anahtar kelimesi zararlı mıdır? [kapalı]

Başka bir soruda , kullanıcı newanahtar kelimenin kullanımının tehlikeli olduğunu belirtti ve kullanmayan nesne oluşturma için bir çözüm önerdi new. Bunun doğru olduğuna inanmadım, çünkü Prototip, Scriptaculous ve diğer mükemmel JavaScript kütüphanelerini kullandım ve herkes newanahtar kelimeyi kullandı .

Buna rağmen dün Douglas Crockford'un YUI tiyatrosundaki konuşmasını izliyordum ve aynı şeyi söyledi, newartık kodunda artık anahtar kelimeyi kullanmadı ( JavaScript üzerinde Crockford - III. Hareket: Ultimate - 50:23) dakika ).

newAnahtar kelimeyi kullanmak 'kötü' mü? Kullanmanın avantajları ve dezavantajları nelerdir?

Crockford, iyi JavaScript tekniklerini popülerleştirmek için çok şey yaptı. Dilin kilit unsurları konusundaki görüşlü tutumu birçok yararlı tartışmaya yol açtı. Bununla birlikte, her bir "kötü" veya "zararlı" bildirisini müjde olarak alan ve bir adamın görüşünün ötesine bakmayı reddeden çok fazla insan var. Bazen biraz sinir bozucu olabilir.

newAnahtar kelime tarafından sağlanan işlevselliğin kullanımının, her bir nesneyi sıfırdan oluşturmanın birkaç avantajı vardır:

1. Prototip mirası . Sınıf tabanlı OO dillerine alışkın olanlar tarafından sık sık şüphe ve alay konusu ele alınsa da, JavaScript'in yerel miras tekniği basit ve şaşırtıcı derecede etkili bir kod yeniden kullanımı aracıdır. Ve yeni anahtar kelime, kanonik (ve yalnızca mevcut platformlar arası) onu kullanma yöntemidir.
2. Verim. Bu # 1 bir yan etkisidir: Ben oluşturmak her nesneye 10 yöntemleri eklemek istiyorsanız, ben olabilir sadece manuel her yeni nesneye her yöntemi atar bir yaratılış fonksiyon yazmak ... Ya ben onları atayabilirsiniz oluşturma işlevlerini prototypeve newyeni nesneleri damgalamak için kullanın . Bu sadece daha hızlı olmakla kalmaz (prototip üzerindeki her bir yöntem için kod gerekmez), her bir nesne için her nesnenin ayrı özelliklerle balonlanmasını önler. Daha yavaş makinelerde (veya özellikle daha yavaş JS tercümanlarında) çok sayıda nesne oluşturulduğunda bu, zaman ve bellekte önemli bir tasarruf anlamına gelebilir.

Ve evet, newdiğer cevaplar tarafından açıkça tanımlanan bir önemli dezavantajı var: Kullanmayı unutursanız, kodunuz uyarı vermeden kırılacaktır. Neyse ki, bu dezavantaj kolayca hafifletilebilir - sadece işlevin kendisine biraz kod ekleyin:

function foo()
{
   // if user accidentally omits the new keyword, this will 
   // silently correct the problem...
   if ( !(this instanceof foo) )
      return new foo();

   // constructor logic follows...
}

Artık newyanlışlıkla yanlış kullanımdan kaynaklanan sorunlar hakkında endişelenmenize gerek kalmadan avantajlara sahip olabilirsiniz. Hatta bozuk kod düşüncesinin sessizce sizi rahatsız edip etmediğini kontrol etmek için bir iddia da ekleyebilirsiniz. Veya bazılarının yorumladığı gibi, bir çalışma zamanı istisnası tanıtmak için bu denetimi kullanın:

if ( !(this instanceof arguments.callee) ) 
   throw new Error("Constructor called as a function");

(Bu snippet'in, yapıcı işlev adının sabit kodlanmasını önleyebileceğini unutmayın; önceki örnekten farklı olarak, nesneyi gerçekten başlatmaya gerek yoktur - bu nedenle, değişiklik yapılmadan her hedef işleve kopyalanabilir.)

John Resig, basit "Sınıf" Örnekleme gönderisinde bu teknikle ilgili ayrıntılara girer ve varsayılan olarak bu davranışı "sınıflarınıza" dahil etmenin bir yolunu da içerir. Kesinlikle bir oku ... onun yaklaşan kitap, olduğu gibi JavaScript Ninja Sırları Bu ve diğer pek çok "zararlı" altın gizlenmiş bulduğu, JavaScript dili özellikleri ( bölüm üzerinde withözellikle bizler için aydınlatmaktır başlangıçta görevden kim hile olarak bu çok kötü huylu özellik).

Crockfords'ın "Javascript: The Good Parts" kitabının bazı bölümlerini okudum. Onu ısırmış her şeyi zararlı olarak gördüğü hissini alıyorum:

Hakkında geçiş hakkında:

Anahtar kasalarının bir sonraki davaya düşmesine asla izin vermem. Bir keresinde kodumda, düşmenin neden bazen yararlı olduğu konusunda güçlü bir konuşma yaptıktan hemen sonra istenmeyen bir düşüşün neden olduğu bir hata buldum. (sayfa 97, ISBN 978-0-596-51774-8)

++ ve - hakkında

++ (artış) ve - (azaltma) operatörlerinin, aşırı hileyi teşvik ederek kötü koda katkıda bulunduğu bilinmektedir. Virüsleri ve diğer güvenlik menülerini etkinleştirme konusunda yalnızca hatalı mimariden ikincisidirler. (sayfa 122)

Hakkında yeni:

Bir yapıcı işlevini çağırırken yeni öneki eklemeyi unutursanız , bu yeni nesneye bağlanmaz. Ne yazık ki, bu global nesneye bağlı olacaktır , bu nedenle yeni nesnenizi büyütmek yerine global değişkenleri zorlayacaksınız. Bu gerçekten kötü. Derleme uyarısı yoktur ve çalışma zamanı uyarısı yoktur. (sayfa 49)

Dahası var, ama umarım resmi alırsın.

Sorunuza cevabım: Hayır, zararlı değil. ancak eğer kullanmanız gerektiğinde kullanmayı unutursanız, bazı sorunlarınız olabilir. Eğer iyi bir ortamda gelişiyorsanız bunu fark edersiniz.

Güncelleme

Bu cevabın yazılmasından yaklaşık bir yıl sonra, ECMAScript'in 5. baskısı katı mod desteği ile yayınlandı . Katı modda, thisartık global nesneye bağlı değildir undefined.

Javascript dinamik dil olarak başka bir dilin sizi durduracağı bir milyon yol var.

Dağınık newolabileceğiniz gibi temel bir dil özelliğinden kaçınmak , bir mayın tarlasında yürümeden önce parlak yeni ayakkabılarınızı çıkarmak gibi, ayakkabılarınızı çamurlu tutabilirsiniz.

İşlev adlarının küçük harfle başladığı ve aslında sınıf tanımları olan 'işlevlerin' büyük harfle başladığı bir kural kullanıyorum. Sonuç 'sözdiziminin' yanlış olduğu konusunda oldukça ilgi çekici bir görsel ipucudur:

var o = MyClass();  // this is clearly wrong.

Bunun üzerine iyi adlandırma alışkanlıkları yardımcı olur. Tüm işlevlerden sonra bir şeyler yapar ve bu nedenle adında bir fiil olmalıdır, sınıflar nesneleri temsil eder ve fiilsiz isimler ve sıfatlardır.

var o = chair() // Executing chair is daft.
var o = createChair() // makes sense.

SO'nun sözdizimi renginin yukarıdaki kodu nasıl yorumladığı ilginç.

Javascript için acemi değilim, belki de sadece bu iyi bir bakış açısı sağlama konusunda çok deneyimli değilim. Yine de bu "yeni" şey hakkındaki görüşümü paylaşmak istiyorum.

"Yeni" anahtar kelimesini kullanmanın o kadar doğal olduğu C # dünyasından geldim, bu bana garip görünen fabrika tasarım deseni.

Javascript ilk kod, YUI desen bir gibi "yeni" anahtar kelime ve kod olduğunu ve afete çalıştırmak için uzun sürmez farkında değilim. Ben yazdım kodu geri bakarken ne belirli bir satır ne yapması gerektiğini takip kaybeder. Daha karmakarışık kod "kuru çalışan" zaman aklım gerçekten nesne örnekleri sınırları arasında geçiş olamaz.

Sonra, "yeni" anahtar kelimeyi buldum, bu benim için "ayrı" şeyler. Yeni anahtar kelime ile bir şeyler yaratır. Yeni anahtar kelime olmadan, çağırdığım işlev bana bununla ilgili güçlü ipuçları vermediği sürece bir şeyler oluşturmakla karıştırmayacağımı biliyorum.

Örneğin, var bar=foo();hangi bar muhtemelen olabilir gibi hiçbir ipucu var .... Bu bir dönüş değeri mi yoksa yeni oluşturulan bir nesne mi? Ama var bar = new foo();biliyorum ki bar bir nesne.

Başka bir durum için yeni ben dediğimiz Pooh Kodlama . Winnie the Pooh karnını takip ediyor. Gitmem demek ile , değil kullandığınız dilin karşı buna.

Büyük olasılıkla, dili koruyan kişiler dili teşvik etmeye çalıştıkları deyimler için optimize edeceklerdir. Dile yeni bir anahtar kelime koyarlarsa, muhtemelen yeni bir örnek oluştururken açık olmanın mantıklı olduğunu düşünürler.

Dilin niyetlerini takiben yazılan kod, her sürümde verimlilikte artacaktır. Ve dilin temel yapılarından kaçınan kod zamanla acı çekecektir.

EDIT: Ve bu performansın ötesine geçer. "Cehennem yaptıkları neden yaptığını Duydum kez saymak (veya adı geçen) olamaz o ?" garip görünümlü bir kod bulurken. Kodun yazıldığı sırada, bunun için "iyi" bir neden olduğu sık sık ortaya çıkıyor. Dilin Tao'yu takip etmek, kodunuzu birkaç yıl sonra alay etmediğiniz için en iyi sigortanızdır.

Yeni anahtar kelime olmadan bir kurucu çağırma sorununu nasıl azaltacağına dair bir yazı yazdım.
Çoğunlukla didaktiktir, ancak birlikte veya onsuz çalışan kurucuları nasıl oluşturabileceğinizi gösterir newve her kurucuda test etmek için kazan plakası kodu eklemenizi gerektirmez this.

http://js-bits.blogspot.com/2010/08/constructors-without-using-new.html

İşte tekniğin özü:

/**
 * Wraps the passed in constructor so it works with
 * or without the new keyword
 * @param {Function} realCtor The constructor function.
 *    Note that this is going to be wrapped
 *    and should not be used directly 
 */
function ctor(realCtor){
  // This is going to be the actual constructor
  return function wrapperCtor(){
    var obj; // object that will be created
    if (this instanceof wrapperCtor) {
      // Called with new
      obj = this;
    } else {
      // Called without new. Create an empty object of the
      // correct type without running that constructor
      surrogateCtor.prototype = wrapperCtor.prototype;
      obj = new surrogateCtor();
    }
    // Call the real constructor function
    realCtor.apply(obj, arguments);
    return obj;
  }

  function surrogateCtor() {}
}

Bunu nasıl kullanacağınız aşağıda açıklanmıştır:

// Create our point constructor
Point = ctor(function(x,y){
  this.x = x;
  this.y = y;
});

// This is good
var pt = new Point(20,30);
// This is OK also
var pt2 = Point(20,30);

Yeni anahtar kelimeyi kullanmamanın ardındaki mantık basit:

Hiç kullanmamakla, yanlışlıkla atlayarak gelen tuzaklardan kaçınırsınız. YUI'nin kullandığı inşaat modeli, yeni anahtar kelimeyi nasıl tamamen önleyebileceğinize bir örnektir "

var foo = function () {
    var pub= { };
    return pub;
}
var bar = foo();

Alternatif olarak şunları yapabilirsiniz:

function foo() { }
var bar = new foo();

Ancak bunu yaparak, yeni anahtar kelimeyi kullanmayı unutan birinin riski vardır ve bu operatör tamamen fubar olur. AFAIK bunu yapmanın bir avantajı yoktur (alışık olduğunuzdan başka).

Günün Sonunda: Savunma olmakla ilgili. Yeni ifadeyi kullanabilir misiniz? Evet. Kodunuzu daha tehlikeli hale getiriyor mu? Evet.

C ++ yazdıysanız, işaretçileri sildikten sonra NULL değerine ayarlamak benzerdir.

Bence "yeni" koda netlik katıyor. Ve netlik her şeye değer. Tuzaklar olduğunu bilmek güzel, ama açıklıktan kaçınarak onlardan kaçınmak benim için bir yol gibi görünmüyor.

Durum 1: newgerekli değildir ve kaçınılmalıdır

var str = new String('asd');  // type: object
var str = String('asd');      // type: string

var num = new Number(12);     // type: object
var num = Number(12);         // type: number

Durum 2: newgerekli, aksi takdirde bir hata alırsınız

new Date().getFullYear();     // correct, returns the current year, i.e. 2010
Date().getFullYear();         // invalid, returns an error

İşte, newoperatörün kullanımı için ve aleyhine en güçlü iki argümanın yapabileceği en kısa özet :

Karşıt arguman new

1. newOperatör kullanılarak nesneler olarak başlatılması için tasarlanan işlevlerin, normal işlevler olarak yanlış çağrıldıklarında felaket etkileri olabilir. Böyle bir durumda bir işlevin kodu, amaçlandığı gibi yerel bir nesnenin kapsamı yerine, işlevin çağrıldığı kapsamda yürütülür. Bu, küresel değişkenlerin ve özelliklerin felaketle sonuçlanmasına neden olabilir.
2. Son olarak, nesnenizi inşa etmek için çağırabileceğiniz function Func()ve yazarak bir Func.prototypeşeyler çağırıp ekleyerek new Func(), mimari ve stilistik nedenlerle başka bir nesne mirası stili kullanmayı tercih eden bazı programcılar için çirkin görünüyor.

Bu argüman hakkında daha fazla bilgi için Douglas Crockford'un harika ve özlü kitabı Javascript: The Good Parts'a göz atın. Aslında yine de kontrol edin.

Lehine tartışma new

1. Kullanmak new Prototypal atama ile birlikte operatöre hızlı.
2. Bir yapıcı işlevinin kodunu genel ad alanında yanlışlıkla çalıştırmayla ilgili şeyler, yapıcı işlevlerinize her zaman doğru bir şekilde çağrılıp çağrılmadığını kontrol etmek için her zaman bir miktar kod eklerseniz kolayca engellenebilir ve , çağrıyı istediğiniz gibi uygun şekilde yönetme.

Bu tekniğin basit bir açıklaması ve savunduğu kalıtım modelinin genel olarak daha derin bir açıklaması için John Resig'in görevine bakınız .

Pez ve bazılarına katılıyorum.

Bana göre "yeni" nin, Greg Dean'in tanımladığı YUI modelinin tamamen gizlendiği kendini tanımlayıcı bir nesne yaratımı olduğu açık .

Birinin yazabileceği var bar = foo;veya var bar = baz();bazın bir nesne oluşturma yöntemi olmadığı olasılığı çok daha tehlikeli görünüyor .

Yeni bir şey kötü olduğunu düşünüyorum, çünkü yanlışlıkla kullanmayı unutursanız sorunlara neden olabilir, ancak miras zincirini bozduğundan, dili anlamak daha zor hale gelir.

JavaScript prototip tabanlı nesne yönelimlidir. Bu nedenle her nesne böyle bir nesneden oluşturulmalıdır ZORUNLU var newObj=Object.create(oldObj). İşte oldObj prototipi denir newObj (dolayısıyla "prototip tabanlı"). Bu, bir özellik newObj içinde bulunmazsa , oldObj'de aranacağını gösterir . Bu nedenle , varsayılan olarak newObj boş bir nesne olacaktır, ancak prototip zinciri nedeniyle tüm oldObj değerlerine sahip gibi görünmektedir .

Bunu yaparsanız Öte yandan var newObj=new oldObj(), prototipi newObj olan oldObj.prototype anlamak gereksiz yere zordur.

Hile kullanmak

Object.create=function(proto){
  var F = function(){};
  F.prototype = proto;
  var instance = new F();
  return instance;
};

Bu fonksiyonun içindedir ve sadece burada yeni kullanılmalıdır. Bundan sonra sadece Object.create () yöntemini kullanın. Yöntem, prototip sorununu çözer.