Come si crea un metodo per un object personalizzato in JavaScript?

E ‘come …

var obj = new Object(); obj.function1 = function(){ //code } 

o qualcosa di simile?

 var newObj = { met1 : function () { alert('hello'); } }; 

Quindi, il metodo può essere chiamato come tale:

 newObj.met1(); 

Btw, quando dichiari un nuovo object, usa l’object letterale ( {} ), non il new Object() costruttore new Object() .

Puoi vedere dalle risposte che hai già che c’è più di un modo.

 #1 var o = new Object(); o.method = function(){} #2 var o = new Object(); o.prototype.method = function(){} #3 function myObject() { this.method = function(){} } var o = new myObject(); #4 function myObject() {} myObject.prototype.method = function(){} var o = new myObject(); #5 var o = { method: function(){} } 

# 3 e # 4 stanno usando una funzione di costruzione. questo significa che puoi usarli per creare un numero di oggetti della stessa ‘class’ (le classi non esistono realmente in JavaScript)

La # 4 è diversa dalla # 3 perché tutti gli oggetti costruiti con # 4 condivideranno un metodo identico di “metodo” perché è una proprietà del loro prototipo. Ciò consente di risparmiare memoria (ma solo una piccola quantità) e se si modifica il metodo del prototipo, tutti gli oggetti # 4 verranno immediatamente aggiornati, anche se sono già stati istanziati.

# 1, # 2 e # 5 sono tutti praticamente equivalenti. Questo perché probabilmente ce ne sarà solo uno alla volta, quindi il fatto che # 2 abbia il metodo aggiunto al prototipo non ha molta importanza. (non prendendo in considerazione la clonazione)

Ci sono ancora altri modi per aggiungere metodi agli oggetti usando le fabbriche con chiusura o aggiungendo proprietà / metodi “statici” a funzioni o funzioni nidificate private … 🙂

Generalmente usa la proprietà prototype :

 function YourObject() { // } YourObject.prototype.yourMethod= function() { // } 

Una cosa che non ho ancora visto è la ragione per cui si potrebbe voler usare la proprietà prototype su, per esempio, notazione letterale dell’object: così facendo si garantisce che la definizione della funzione venga condivisa tra tutte le istanze degli oggetti creati dal proprio prototipo di funzione, piuttosto di una volta per istanziazione.

Non preoccuparti fratello, qui il codice è:

  var myObj=function(){ var value=null this.setValue=function(strValue){ this.value=strValue; }; this.getValue=function(){ return this.value; }; }; 

Puoi chiamare questo object in questo modo:

  var obj= new myObj(); obj.setValue("Hi!"); alert(obj.getValue()); 
 Function.prototype.implement = function(member, value) { this[member] = value; return this; } function MyFunction() { //... } (function($){ $.implement("a", "blabla") .implement("b", function(){ /* some function */ }) .implement("c" {a:'', b:''}); })(MyFunction); 

Con es6 puoi farlo in questo modo:

 var a = { func(){ return 'The value'; } } document.getElementById('out').innerHTML = a.func(); 
 

Puoi anche fare quanto segue invece di usare il metodo “Object.create ()”.

Chiamata di funzione:

 com.blah.MyChildObj.prototype = createObject(com.blah.MyParentObj.prototype, com.blah.MyChildObj); 

Definizione della funzione:

 function createObject(theProto, theConst) { function x() {}; x.prototype = theProto; x.prototype.constructor = theConst; return new x(); }