Wird das "neue" Schlüsselwort von JavaScript als schädlich angesehen? [geschlossen]

In einer anderen Frage wies ein Benutzer darauf hin, dass die newVerwendung des Schlüsselworts gefährlich sei, und schlug eine Lösung für die Objekterstellung vor, die nicht verwendet wurde new. Ich habe nicht geglaubt, dass das stimmt, hauptsächlich, weil ich Prototype, Scriptaculous und andere hervorragende JavaScript-Bibliotheken verwendet habe und jeder von ihnen das newSchlüsselwort verwendet hat.

Trotzdem habe ich gestern Douglas Crockfords Vortrag im YUI-Theater gesehen und er sagte genau das Gleiche, dass er das newSchlüsselwort nicht mehr in seinem Code verwendet hat ( Crockford in JavaScript - Akt III: Function the Ultimate - 50:23 Minuten ).

Ist es "schlecht", das newSchlüsselwort zu verwenden? Was sind die Vor- und Nachteile der Verwendung?

Crockford hat viel getan, um gute JavaScript-Techniken bekannt zu machen. Seine Stellungnahme zu Schlüsselelementen der Sprache hat viele nützliche Diskussionen ausgelöst. Trotzdem gibt es viel zu viele Menschen, die jede Verkündigung von "schlecht" oder "schädlich" als Evangelium betrachten und sich weigern, über die Meinung eines Mannes hinauszuschauen. Es kann manchmal etwas frustrierend sein.

Die Verwendung der durch das newSchlüsselwort bereitgestellten Funktionalität hat mehrere Vorteile gegenüber der Erstellung jedes Objekts von Grund auf neu:

1. Vererbung von Prototypen . Die native Vererbungstechnik von JavaScript ist ein einfaches und überraschend effektives Mittel zur Wiederverwendung von Code, obwohl sie von denjenigen, die an klassenbasierte OO-Sprachen gewöhnt sind, oft mit einer Mischung aus Misstrauen und Spott betrachtet wird. Und das neue Schlüsselwort ist das kanonische (und einzige plattformübergreifende) Mittel, um es zu verwenden.
2. Performance. Dies ist ein Nebeneffekt # 1: Wenn ich für jedes Objekt 10 Methoden hinzufügen möchte ich schaffen, ich könnte nur eine Erstellungsfunktion schreiben , dass manuell jede Methode zu jedem neuen Objekt zuordnet ... Oder ich könnte sie auf die zuweisen Erstellungsfunktionen prototypeund newzum Ausstempeln neuer Objekte. Dies ist nicht nur schneller (es wird kein Code für jede Methode des Prototyps benötigt), sondern es wird auch vermieden, dass jedes Objekt mit separaten Eigenschaften für jede Methode überlagert wird. Auf langsameren Computern (oder insbesondere langsameren JS-Interpreten) kann dies beim Erstellen vieler Objekte zu einer erheblichen Zeit- und Speicherersparnis führen.

Und ja, newhat einen entscheidenden Nachteil, der durch andere Antworten geschickt beschrieben wird: Wenn Sie vergessen, ihn zu verwenden, wird Ihr Code ohne Vorwarnung beschädigt. Glücklicherweise lässt sich dieser Nachteil leicht abmildern - fügen Sie der Funktion selbst einfach ein bisschen Code hinzu:

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...
}

Jetzt können Sie die Vorteile nutzen, newohne sich um Probleme sorgen zu müssen, die durch versehentlichen Missbrauch verursacht wurden. Sie können der Prüfung sogar eine Behauptung hinzufügen, wenn Sie der Gedanke an fehlerhaften Code stört. Oder verwenden Sie, wie einige kommentiert haben, die Prüfung, um eine Laufzeitausnahme einzuführen:

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

(Beachten Sie, dass mit diesem Snippet vermieden werden kann, dass der Name der Konstruktorfunktion fest codiert wird, da das Objekt im Gegensatz zum vorherigen Beispiel nicht tatsächlich instanziiert werden muss. Daher kann es ohne Änderung in jede Zielfunktion kopiert werden.)

John Resig geht in seinem einfachen "Klassen" -Instanzierungsbeitrag ausführlich auf diese Technik ein und fügt standardmäßig ein Mittel hinzu, um dieses Verhalten in Ihre "Klassen" zu integrieren. Auf jeden Fall eine Lektüre wert ... ebenso wie sein bevorstehendes Buch Secrets of the JavaScript Ninja , das in diesem und vielen anderen "schädlichen" Merkmalen der JavaScript-Sprache verborgenes Gold findet (das Kapitel darüber withist besonders aufschlussreich für diejenigen von uns, die es ursprünglich entlassen haben diese vielfach bösartige Funktion als Spielerei).

Ich habe gerade einige Teile seines Crockfords-Buches "Javascript: The Good Parts" gelesen. Ich habe das Gefühl, dass er alles, was ihn jemals gebissen hat, als schädlich ansieht:

Über Schalter fallen durch:

Ich erlaube niemals, dass Switch-Fälle zum nächsten Fall durchfallen. Ich habe einmal einen Fehler in meinem Code gefunden, der durch einen unbeabsichtigten Durchfall verursacht wurde, unmittelbar nachdem ich eine heftige Rede darüber gehalten hatte, warum Durchfallen manchmal nützlich war. (Seite 97, ISBN 978-0-596-51774-8)

Über ++ und -

Es ist bekannt, dass die Operatoren ++ (Inkrementieren) und - (Dekrementieren) zu schlechtem Code beitragen, indem sie zu übermäßigen Tricks ermutigen. Sie sind nach fehlerhafter Architektur die zweitwichtigsten, wenn es darum geht, Viren und andere Sicherheitsbedrohungen zu aktivieren. (Seite 122)

Über neu:

Wenn Sie beim Aufrufen einer Konstruktorfunktion vergessen, das neue Präfix anzugeben, ist dieses nicht an das neue Objekt gebunden. Leider ist dies an das globale Objekt gebunden. Anstatt Ihr neues Objekt zu erweitern, werden Sie globale Variablen überlisten. Das ist wirklich schlimm Es gibt keine Kompilierungswarnung und keine Laufzeitwarnung. (Seite 49)

Es gibt noch mehr, aber ich hoffe, Sie bekommen das Bild.

Meine Antwort auf Ihre Frage: Nein, es ist nicht schädlich. Aber wenn Sie vergessen, es zu verwenden, wenn Sie sollten, könnten Sie einige Probleme haben. Wenn Sie sich in einer guten Umgebung entwickeln, bemerken Sie das.

Aktualisieren

Ungefähr ein Jahr nach dem Schreiben dieser Antwort wurde die 5. Ausgabe von ECMAScript veröffentlicht, die den strengen Modus unterstützt . Ist im strengen Modus thisnicht mehr an das globale Objekt gebunden, sondern an undefined.

Javascript ist eine dynamische Sprache. Es gibt unzählige Möglichkeiten, Fehler zu machen, wo eine andere Sprache Sie aufhalten würde.

Das Vermeiden einer grundlegenden Sprachfunktion, beispielsweise newauf der Grundlage von Unordnung, ist ein bisschen so, als würden Sie Ihre glänzenden neuen Schuhe ausziehen, bevor Sie durch ein Minenfeld gehen, nur für den Fall, dass Ihre Schuhe schlammig werden.

Ich verwende eine Konvention, bei der Funktionsnamen mit einem Kleinbuchstaben beginnen und 'Funktionen', die eigentlich Klassendefinitionen sind, mit einem Großbuchstaben beginnen. Das Ergebnis ist ein wirklich überzeugender visueller Hinweis darauf, dass die 'Syntax' falsch ist:

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

Darüber hinaus helfen gute Namensgewohnheiten. Nachdem alle Funktionen Dinge getan haben, sollte der Name ein Verb enthalten, während Klassen Objekte darstellen und Substantive und Adjektive ohne Verb sind.

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

Es ist interessant, wie die Syntaxfärbung von SO den obigen Code interpretiert hat.

Ich bin ein Neuling in Javascript, also bin ich vielleicht nicht so erfahren darin, einen guten Standpunkt dazu zu bieten. Dennoch möchte ich meine Meinung zu dieser "neuen" Sache teilen.

Ich komme aus der C # -Welt, in der die Verwendung des Schlüsselworts "neu" so natürlich ist, dass es das Fabrikdesignmuster ist, das mir komisch vorkommt.

Wenn ich zum ersten Mal in Javascript codiere, merke ich nicht, dass es das "neue" Schlüsselwort und den neuen Code wie im YUI-Muster gibt, und es dauert nicht lange, bis ich in eine Katastrophe gerate. Ich verliere den Überblick darüber, was eine bestimmte Zeile tun soll, wenn ich auf den Code zurückblicke, den ich geschrieben habe. Chaotischer ist, dass mein Verstand nicht wirklich zwischen Objektinstanzgrenzen wechseln kann, wenn ich den Code "trocken laufen lasse".

Dann fand ich das "neue" Schlüsselwort, das für mich "Dinge trennt". Mit dem neuen Schlüsselwort werden Dinge erstellt. Ohne das neue Schlüsselwort weiß ich, dass ich es nicht mit dem Erstellen von Dingen verwechseln werde, es sei denn, die von mir aufgerufene Funktion gibt mir starke Hinweise darauf.

Zum Beispiel habe var bar=foo();ich keine Ahnung, welcher Balken möglicherweise sein könnte ... Ist es ein Rückgabewert oder ist es ein neu erstelltes Objekt? Aber var bar = new foo();ich weiß mit Sicherheit, dass Bar ein Objekt ist.

Ein weiterer Fall für Neues ist das, was ich Pooh Coding nenne . Winnie the Pooh folgt seinem Bauch. Ich sage, geh mit der Sprache, die du benutzt, nicht dagegen .

Es besteht die Möglichkeit, dass die Betreuer der Sprache die Sprache für die Redewendungen optimieren, die sie zu fördern versuchen. Wenn sie ein neues Schlüsselwort in die Sprache einfügen, halten sie es wahrscheinlich für sinnvoll, beim Erstellen einer neuen Instanz klar zu sein.

Code, der gemäß den Absichten der Sprache geschrieben wurde, wird mit jeder Version effizienter. Und Code, der die Schlüsselkonstrukte der Sprache vermeidet, wird mit der Zeit leiden.

EDIT: Und das geht weit über die Leistung hinaus. Ich kann die Zeiten zählt , die ich gehört habe (oder die) „Warum zum Teufel hat sie das ?“ wenn Sie seltsam aussehenden Code finden. Es stellt sich oft heraus, dass es zu der Zeit, als der Code geschrieben wurde, einen "guten" Grund dafür gab. Das Befolgen des Tao der Sprache ist Ihre beste Versicherung dafür, dass Ihr Code in einigen Jahren nicht verspottet wird.

Ich habe einen Beitrag darüber geschrieben, wie das Problem des Aufrufs eines Konstruktors ohne das neue Schlüsselwort gemindert werden kann.
Es ist größtenteils didaktisch, zeigt jedoch, wie Sie Konstruktoren erstellen können, die mit oder ohne newfunktionieren, und erfordert nicht, dass Sie in jedem Konstruktor Boilerplate-Code zum Testen hinzufügen this.

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

Hier ist der Kern der Technik:

/**
 * 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() {}
}

So verwenden Sie es:

// 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);

Die Gründe für die Nichtverwendung des neuen Schlüsselworts sind einfach:

Wenn Sie es überhaupt nicht verwenden, vermeiden Sie die Gefahr, dass Sie es versehentlich weglassen. Das von YUI verwendete Konstruktionsmuster ist ein Beispiel dafür, wie Sie das neue Schlüsselwort insgesamt vermeiden können. "

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

Alternativ könnten Sie so:

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

Auf diese Weise laufen Sie jedoch Gefahr, dass jemand vergisst, das neue Schlüsselwort zu verwenden, und dass dieser Operator nur ein Fubar ist. AFAIK es gibt keinen Vorteil, dies zu tun (außer Sie sind daran gewöhnt).

Am Ende des Tages: Es geht darum, defensiv zu sein. Können Sie die neue Anweisung verwenden? Ja. Macht es Ihren Code gefährlicher? Ja.

Wenn Sie jemals C ++ geschrieben haben, entspricht dies dem Setzen von Zeigern auf NULL, nachdem Sie sie gelöscht haben.

Ich denke, "neu" fügt dem Code Klarheit hinzu. Und Klarheit ist alles wert. Gut zu wissen, dass es Fallstricke gibt, aber sie durch Vermeidung von Klarheit zu vermeiden, scheint mir nicht der richtige Weg zu sein.

Fall 1: newist nicht erforderlich und sollte vermieden werden

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

Fall 2: newist erforderlich, andernfalls wird eine Fehlermeldung angezeigt

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

Hier ist die kürzeste Zusammenfassung der beiden stärksten Argumente für und gegen die Verwendung des newOperators:

Gegenargument new

1. Funktionen, die mithilfe des newOperators als Objekte instanziiert werden sollen , können katastrophale Auswirkungen haben, wenn sie fälschlicherweise als normale Funktionen aufgerufen werden. In einem solchen Fall wird der Code einer Funktion in dem Bereich ausgeführt, in dem die Funktion aufgerufen wird, anstatt wie beabsichtigt im Bereich eines lokalen Objekts. Dies kann dazu führen, dass globale Variablen und Eigenschaften mit katastrophalen Folgen überschrieben werden.
2. Schließlich erscheint es einigen Programmierern hässlich , zu schreiben function Func(), dann aufzurufen Func.prototype und Dinge hinzuzufügen, damit Sie aufrufen können new Func(), um Ihr Objekt zu konstruieren, die aus architektonischen und stilistischen Gründen lieber einen anderen Stil der Objektvererbung verwenden würden.

Weitere Informationen zu diesem Argument finden Sie in Douglas Crockfords großartigem und prägnantem Buch Javascript: The Good Parts. In der Tat überprüfen Sie es trotzdem.

Argument für new

1. Die Verwendung des newOperators zusammen mit der prototypischen Zuweisung ist schnell.
2. Das Problem, dass der Code einer Konstruktorfunktion versehentlich im globalen Namespace ausgeführt wird, kann leicht verhindert werden, wenn Sie immer ein bisschen Code in Ihre Konstruktorfunktionen aufnehmen, um zu überprüfen, ob sie korrekt aufgerufen werden, und in den Fällen, in denen dies nicht der Fall ist und den Anruf wie gewünscht entsprechend behandeln.

In John Resigs Beitrag finden Sie eine einfache Erklärung dieser Technik und eine allgemein tiefere Erklärung des von ihm befürworteten Vererbungsmodells.

Ich stimme Pez und einigen hier zu.

Mir scheint klar, dass "neu" eine selbstbeschreibende Objekterstellung ist, bei der das von Greg Dean beschriebene YUI-Muster vollständig verdeckt ist .

Die Möglichkeit, dass jemand schreiben könnte var bar = foo;oder var bar = baz();wo baz keine Methode zum Erstellen von Objekten ist, scheint weitaus gefährlicher zu sein.

Ich denke, neu ist böse, nicht weil es Probleme verursachen kann, wenn Sie vergessen, es versehentlich zu verwenden, sondern weil es die Vererbungskette durcheinander bringt und das Verständnis der Sprache erschwert.

JavaScript ist prototypbasiert objektorientiert. Daher MUSS jedes Objekt so aus einem anderen Objekt erstellt werden var newObj=Object.create(oldObj). Hier wird oldObj als Prototyp von newObj bezeichnet (daher "prototypbasiert"). Dies bedeutet, dass eine Eigenschaft, die in newObj nicht gefunden wird, in oldObj durchsucht wird . newObj ist daher standardmäßig ein leeres Objekt, scheint jedoch aufgrund seiner Prototypkette alle Werte von oldObj zu haben .

Auf der anderen Seite , wenn Sie tun , var newObj=new oldObj()der Prototyp, NEWOBJ ist oldObj.prototype , die unnötig schwer zu verstehen ist.

Der Trick ist zu verwenden

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

Es ist innerhalb dieser Funktion und nur hier sollte neu verwendet werden. Verwenden Sie danach einfach die Object.create () -Methode. Die Methode löst das Prototypproblem.