Wat is het ‘nieuwe’ zoekwoord in JavaScript?

function Dog (age) {
  this.age = age;
}
const doggie = new Dog(12);
console.log(doggie);
console.log(Object.getPrototypeOf(doggie) === Dog.prototype) // true

8

Er zijn al enkele zeer grote antwoorden, maar ik plaatwerk een nieuwe om mijn observatie te benadrukken op zaak III hieronder over wat er gebeurt wanneer u een expliciete retourverklaring hebt in een functie die u newING UP. Bekijk onderstaande gevallen:

Case I :

var Foo = function(){
  this.A = 1; 
  this.B = 2;
};
console.log(Foo()); //prints undefined
console.log(window.A); //prints 1

hierboven is een gewone zaak van het oproepen van de anonieme functie die wordt gewezen door Foo. Wanneer u deze functie noemt, wordt het undefinedaangeduid. Aangezien er geen expliciete retourverklaring is, wordt JavaScript-interpreter krachtig een return undefined;verklaring aan het einde van de functie. Hier is het venster het aanroepobject (contextueel this) die nieuwe Aen Beigenschappen krijgt.

Case II :

var Foo = function(){
  this.A = 1;
  this.B = 2;
};
var bar = new Foo();
console.log(bar()); //illegal isn't pointing to a function but an object
console.log(bar.A); //prints 1

Hier JavaScript-interpreter zien van de newsleutelwoord creëert een nieuw object dat fungeert als het aanroepobject (contextueel this) van anonieme functie die wordt gewezen door Foo. In dit geval AEN BWORDEN EIGENSCHAPPEN OP HET NIEUWE aangemaakte object (in plaats van vensterobject). Aangezien u geen expliciete retourverklaring heeft, zodat JavaScript-interpreter krachtig een retourverklaring inzet om het nieuwe object dat is gemaakt door het gebruik van newTrefwoord weer te geven.

Case III :

var Foo = function(){
  this.A = 1;
  this.B = 2;
  return {C:20,D:30}; 
};
var bar = new Foo();
console.log(bar.C);//prints 20
console.log(bar.A); //prints undefined. bar is not pointing to the object which got created due to new keyword.

Hier nogmaals JavaScript-interpreter die het newtrefwoord ziet, creëert een nieuw object dat fungeert als het aanroepobject (contextuele this) van een anonieme functie waarnaar wordt verwezen door Foo. Nogmaals, Aen Bworden eigenschappen op het nieuw gemaakte object. Maar deze keer heb je een expliciete return-instructie, zodat de JavaScript-interpreter nietzelf iets doet.

Het ding om op te merken in het geval IIIis dat het object dat werd gemaakt vanwege het newtrefwoord, van uw radar is verdwenen. barverwijst eigenlijk naar een heel ander object dat niet het object is dat de JavaScript-interpreter heeft gemaakt vanwege het new-zoekwoord.

Een citaat van David Flanagan uit JavaScripit: The Definitive Guide (6e editie), Ch. 4, Pagina # 62:

Wanneer een expressie voor het maken van een object wordt geëvalueerd, eerst JavaScript
maakt een nieuw leeg object, net als degene die door het object is gemaakt
initialisatie {}. Vervolgens roept het de gespecificeerde functie op met de
opgegeven argumenten, waarbij het nieuwe object wordt doorgegeven als de waarde van de this
trefwoord. De functie kan dit dan gebruiken om de eigenschappen te initialiseren
van het nieuw gemaakte object. Functies geschreven voor gebruik als constructors
retourneer geen waarde, en de waarde van de expressie voor het maken van objecten
is het nieuw gemaakte en geïnitialiseerde object. Als een constructeur dat doet
retourneer een objectwaarde, die waarde wordt de waarde van het object
creatie-expressie en het nieuw gemaakte object wordt verwijderd.

—Aanvullende informatie—

De functies die in het codefragment van bovenstaande gevallen worden gebruikt, hebben speciale namen in de JS-wereld, zoals hieronder:

Case I en II– Constructorfunctie

Case III– Fabrieksfunctie. Fabrieksfuncties moeten nietworden gebruikt met newtrefwoord, wat ik heb gedaan om het concept in de huidige thread uit te leggen.

Je kunt het verschil tussen beide lezen in dezethread.

Antwoord 9

Javascript is een dynamische programmeertaal die het objectgeoriënteerde programmeerparadigma ondersteunt en wordt gebruikt voor het maken van nieuwe exemplaren van objecten.

Klassen zijn niet nodig voor objecten – Javascript is een prototype-gebaseerdetaal.

Antwoord 10

Het newsleutelwoord verandert de context waaronder de functie wordt uitgevoerd en retourneert een verwijzing naar die context.

Als u het trefwoord newniet gebruikt, is de context waaronder de functie Vehicle()draait dezelfde context van waaruit u het Vehiclefunctie. Het trefwoord thisverwijst naar dezelfde context. Wanneer u new Vehicle()gebruikt, wordt er een nieuwe context gemaakt, dus het trefwoord thisin de functie verwijst naar de nieuwe context. Wat je ervoor terugkrijgt is de nieuw gecreëerde context.

Antwoord 11

soms is code makkelijker dan woorden:

var func1 = function (x) { this.x = x; }                    // used with 'new' only
var func2 = function (x) { var z={}; z.x = x; return z; }   // used both ways
func1.prototype.y = 11;
func2.prototype.y = 12;
A1 = new func1(1);      // has A1.x  AND  A1.y
A2 =     func1(1);      // undefined ('this' refers to 'window')
B1 = new func2(2);      // has B1.x  ONLY
B2 =     func2(2);      // has B2.x  ONLY

Voor mij, zolang ik geen prototype, gebruik ik stijl van func2 omdat het me een beetje meer flexibiliteit geeft binnen en buiten de functie.

12

Het newtrefwoord is voor het maken van nieuwe objectinstanties. En ja, javascript is een dynamische programmeertaal, die het objectgeoriënteerde programmeerparadigma ondersteunt. De conventie over de naamgeving van objecten is: gebruik altijd hoofdletters voor objecten die door het nieuwe trefwoord moeten worden geïnstantieerd.

obj = new Element();

Antwoord 13

Het sleutelwoord newmaakt instanties van objecten met behulp van functies als constructor. Bijvoorbeeld:

var Foo = function() {};
Foo.prototype.bar = 'bar';
var foo = new Foo();
foo instanceof Foo; // true

Instances erven van het prototypevan de constructorfunctie. Dus gezien het bovenstaande voorbeeld…

foo.bar; // 'bar'

Antwoord 14

Javascript is geen objectgeoriënteerde programmeertaal (OOP), daarom is het LOOK UP-proces
in javascript werken met behulp van ‘DELEGATIEPROCES’ook bekend als prototype-delegatie of prototypische overerving.

Als u probeert de waarde van een eigenschap te halen uit een object dat het niet heeft, wordt de
JavaScript-engine kijkt naar het prototype van het object (en het prototype, stap voor stap hoger)
het is een prototypeketen totdat de keten eindigt op null, wat Object.prototype == nullis (Standard Object Prototype).
Als de eigenschap of methode op dit moment niet is gedefinieerd, wordt undefinedgeretourneerd.

Dus met het newtrefwoord zijn enkele taken die handmatig zijn uitgevoerd, bijvoorbeeld

1. Handmatige objectcreatie, bijv. newObj.
2. Verborgen binding creëren met behulp van proto(ook bekend als: dunder proto) in JS spec [[prototype]](dwz proto)
3. verwijzen naar en eigenschappen toewijzen aan newObj
4. teruggave van newObjobject.

Alles wordt handmatig gedaan.

function CreateObj(value1, value2) {
  const newObj = {};
  newObj.property1 = value1;
  newObj.property2 = value2;
  return newObj;
}
var obj = CreateObj(10,20);
obj.__proto__ === Object.prototype;              // true
Object.getPrototypeOf(obj) === Object.prototype // true

Javascript-zoekwoord newhelpt dit proces te automatiseren:

1. nieuwe letterlijke objectwaarde wordt gemaakt, geïdentificeerd door this:{}
2. verwijzen naar en eigenschappen toewijzen aan this
3. Verborgen binding Creatie [[prototype]] (d.w.z. proto)naar Function.prototype gedeelde ruimte.
4. impliciete terugkeer van thisobject {}

function CreateObj(value1, value2) {
  this.property1 = value1;
  this.property2 = value2;
}
var obj = new CreateObj(10,20);
obj.__proto__ === CreateObj.prototype             // true
Object.getPrototypeOf(obj) == CreateObj.prototype // true

Constructeurfunctie aanroepen zonder het nieuwe trefwoord:

=> this: Window

function CreateObj(value1, value2) {
  var isWindowObj = this === window;
  console.log("Is Pointing to Window Object", isWindowObj);
  this.property1 = value1;
  this.property2 = value2;
}
var obj = new CreateObj(10,20); // Is Pointing to Window Object false
var obj = CreateObj(10,20); // Is Pointing to Window Object true
window.property1; // 10
window.property2; // 20

Antwoord 15

Nou ja, JavaScript kan per si sterk verschillen van platform tot platform, aangezien het altijd een implementatie is van de originele specificatie EcmaScript.

In elk geval, onafhankelijk van de implementatie, zullen alle JavaScript-implementaties die het EcmaScript-specificatierecht volgen, u een objectgeoriënteerde taal geven. Volgens de ES-norm:

ECMAScript is een objectgeoriënteerde programmeertaal voor:
berekeningen uitvoeren en computationele objecten manipuleren
binnen een hostomgeving.

Dus nu we het erover eens zijn dat JavaScript een implementatie is van EcmaScript en daarom een objectgeoriënteerde taal is. De definitie van de new-bewerking in elke objectgeoriënteerde taal, zegt dat een dergelijk sleutelwoord wordt gebruikt om een objectinstantie te maken van een klasse van een bepaald type (inclusief anonieme typen, in gevallen zoals C#).

In EcmaScript gebruiken we geen klassen, zoals je kunt lezen in de specificaties:

ECMAScript gebruikt geen klassen zoals die in C++, Smalltalk of Java. In plaats daarvan kunnen objecten op verschillende manieren worden gemaakt, waaronder via
een letterlijke notatie of via constructors die objecten maken en vervolgens code uitvoeren die ze allemaal of een deel ervan initialiseert door initiële
waarden aan hun eigenschappen. Elke constructor is een functie met a
eigenschap met de naam ―
prototype ‖ dat wordt gebruikt om op prototypes gebaseerde overerving en gedeelde eigenschappen te implementeren. Objecten zijn gemaakt door
constructors gebruiken in nieuwe expressies; bijvoorbeeld nieuwe
Date(2009,11) maakt een nieuw Date-object aan. Een constructor aanroepen
zonder nieuw te gebruiken heeft consequenties die afhankelijk zijn van de constructor.
Datum () produceert bijvoorbeeld een reeksvertegenwoordiging van de
huidige datum en tijd in plaats van een object.