Object-Oriented JavaScript (OOJS) 3 manieren om objecten-instanties te maken

Wanneer een programmeertaal is alles over objecten, het eerste dat we moeten leren is hoe objecten te maken. Het maken van objecten in JavaScript is vrij eenvoudig: een paar accolades zal het werk echter wel doen ook niet de enige manier om een ​​object te maken noch de enige manier je zult het ooit moeten gebruiken.

In JavaScript zijn objectexemplaren gemaakt van ingebouwde objecten en ontstaan ​​wanneer het programma wordt uitgevoerd. Bijvoorbeeld, Datum is een ingebouwd object dat ons informatie geeft over datums. Als we de huidige datum op een pagina willen weergeven, dan doen we dat heb een runtime instance nodig van Datum die de informatie over de huidige datum bevat.

JavaScript stelt ons ook in staat om definieer onze eigen objecten die tijdens runtime eigen instanties van objecten kunnen produceren. In JavaScript, alles is een object en elk object heeft een ultieme voorouder riep Voorwerp. Het maken van een objectinstantie wordt aangeroepen instantiatie.

1. Het nieuwe operator

Een van de meest voorkomende en bekende methoden om een ​​nieuw objectinstantie te maken, is door de ... gebruiken nieuwe operator.

Je hebt een nodig bouwer om het te maken nieuwe werk van de operator. Een constructor is een methode van een object dat a samenstelt nieuw exemplaar van dat object. De basissyntaxis ziet er als volgt uit:

 nieuwe constructor () 

Een constructeur kan dat accepteer argumenten die kan worden gebruikt om eigenschappen te wijzigen of toe te voegen aan de objectinstantie die wordt geconstrueerd. De constructeur heeft dezelfde naam als het object waartoe het behoort.

Hier is een voorbeeld van het maken van een instantie van de Datum() voorwerp met de nieuwe trefwoord:

 dt = new Datum (2017, 0, 1) console.log (dt) // zo jan 01 2017 00:00:00 GMT + 0100 

Datum() is de constructor om een ​​nieuw te maken Datum voorwerp. Verschillende constructeurs voor een object verschillende argumenten gebruiken om dezelfde soort objectinstanties te maken met gevarieerde attributen.

Niet alle ingebouwde objecten in JavaScript kunnen worden geïnstantieerd zoals Datum. Er zijn objecten die kom niet met een constructeur: Wiskunde, JSON en reflecteren, maar het zijn nog steeds gewone voorwerpen.

Onder de ingebouwde objecten die constructor (s) hebben, Symbool kan niet worden aangeroepen in de constructormethode om een ​​nieuw te maken Symbool aanleg. Het kan alleen maar zijn genoemd als een functie die een nieuw geeft Symbool waarde.

Ook, onder de ingebouwde objecten die constructor (s) hebben, hoeven niet alle hun constructors te worden aangeroepen met de nieuwe operator om te worden geïnstantieerd. Functie, reeks, Fout, en RegExp kunnen ook als functies worden genoemd, zonder gebruik van de nieuwe sleutelwoord, en zij zullen een instantie instantiëren en retourneren.

2. De reflecteren voorwerp

Backend programmeurs zijn misschien al bekend met Reflectie-API's. Reflectie is een functie van programmeertalen voor inspecteer en werk enkele basisentiteiten bij, zoals objecten en klassen, tijdens runtime.

In JavaScript kon je al optreden sommige reflectie operaties met Voorwerp. Maar, a juiste Reflection API uiteindelijk ook in JavaScript is ontstaan.

De reflecteren object heeft een aantal methoden om maak en update objectinstanties. De reflecteren voorwerp heeft geen constructor, dus het kan niet worden geïnstantieerd met de nieuwe operator, en, net zoals Wiskunde en JSON, het kan niet als een functie worden aangeroepen een van beide.

Echter, reflecteren heeft een equivalent van de nieuwe operator: de Reflect.construct () methode.

 Reflect.construct (target, argumentsList [, newTarget]) 

Beide doelwit en de optionele newTarget argumenten zijn objecten met hun eigen constructeurs, terwijl argumentsList is een lijst met argumenten worden doorgegeven aan de constructor van doelwit.

 var dt = Reflect.construct (Datum, [2017, 0, 1]); console.log (dt); // zo jan 01 2017 00:00:00 GMT + 0100 

De code hierboven heeft hetzelfde effect als instantiating Datum() de ... gebruiken nieuwe operator. Hoewel je nog steeds kunt gebruiken nieuwe, Reflectie is een ECMAScript 6-standaard. Het staat je ook toe om gebruik maken van de newTarget argument, wat een ander voordeel is ten opzichte van de nieuwe operator.

De waarde van newTarget's prototype (om precies te zijn, het is het prototype van newTargetde constructeur) wordt het prototype van de nieuw gemaakte instantie.

Een prototype is het eigendom van een Object, waarvan de waarde is ook een object, de eigenschappen van het oorspronkelijke object dragen. Kortom, een object haalt zijn leden uit zijn prototype.

Hier laten we een voorbeeld zien:

 klasse A constructor () this.message = function () console.log ('message from A') class B constructor ()  message () console.log ('message from B')  data () console.log ('data from B') obj = Reflect.construct (A, [], B) console.log (obj.message ()); // bericht van A console.log (obj.data ()); // data uit B console.log (obj instanceof B) // true 

Door te passeren B als het derde argument voor Reflect.construct (), de prototype waarde van de obj object is gemaakt om hetzelfde te zijn als het prototype van B's constructor (die de eigenschappen heeft bericht en gegevens).

Dus, obj kan toegang krijgen tot de bericht en gegevens, beschikbaar bij zijn prototype. Maar sinds obj is gemaakt met EEN, het heeft ook zijn eigen bericht het ontvangen van EEN.

Hoewel obj is geconstrueerd als een array, dat is het geen instantie van reeks, omdat zijn prototype is ingesteld op Voorwerp.

 obj = Reflect.construct (Array, [1,2,3], Object) console.log (obj) // Array [1, 2, 3] console.log (obj instanceof Array) // false 

Reflect.construct () kan handig zijn als u een object wilt maken meer dan één blauwdruk gebruiken.

3. Het Object.create () methode

U kunt ook een maken nieuw gewoon object met een specifiek prototype via Object.create (). Ook dit lijkt misschien erg op het gebruik van de nieuwe operator, maar dat is het niet.

 Object.create (O [, propertiesObject]) 

De O argument is een object dat dient het prototype voor het nieuwe object dat wordt gemaakt. De optionele propertiesObject argument is a lijst met eigenschappen misschien wilt u toevoegen aan het nieuwe object.

 klasse A constructor ()  message () console.log ('message from A') var obj = Object.create (nieuw A (), data: writable: true, configurable: true, value: function () return 'data from obj') console.log (obj.message ()) // bericht van A console.log (obj.data ()) // data van obj obj1 = Object.create ( new A (), foo: beschrijfbaar: true, configureerbaar: true, value: function () return 'foo from obj1') console.log (obj1.message ()) // bericht van een console. log (obj1.foo ()) // foo from obj1 

In de obj object, de toegevoegde eigenschap is gegevens, terwijl in obj1, haar foo. Dus, zoals u ziet, kunnen we hebben eigenschappen en methoden toegevoegd aan een nieuw object.

Dit is geweldig als je wilt creëren meerdere objecten van dezelfde soort maar met verschillende aanvullende eigenschappen of methoden. De Object.create () syntaxis bespaart de moeite om ze allemaal afzonderlijk te coderen.