In javascript, durante la creazione di proprietà, che è la strada giusta o la sintassi meglio?

Question

proprietà (chiavi) è possibile accedere e impostare utilizzando la notazione punto così come le parentesi quadre. qualche consiglio quando utilizzare dot prototipo sintassi

var myObj = {};   
myObj.myProp1 = 'value1'; //works, an expando property   
myObj[myProp2] = 'value2'; // FAILS, myProp2 is undefined
myObj["myProp2"] = 'value2'; // works, an expando property
myObj[2010]= 'value'; //note the key is number, still works, an expando property??   
myObj.2010 = 'value'; // FAILS. to use dot notation, key must be a string

myObj.prototype.myProp3 = 'value3' // whats the advantage?

Answer 1

Quando si utilizza la sintassi punto, il nome propery è un identificatore:

var myObj = {};
myObj.myProp1 = "value1";
myObj.myProp2 = "value2";

Come il nome della proprietà deve seguire le regole di denominazione di identificazione, si può per esempio, non iniziare con una cifra.

Quando si utilizza la sintassi di parentesi, il nome della proprietà è una stringa:

var myObj = {};
myObj["myProp1"] = "value1";
myObj["myProp2"] = "value2";

Che cosa è utilizzato nelle parentesi può essere una variabile, o qualsiasi tipo di espressione che si traduce in una stringa:

var myObj = {};
var prop1 = "myProp1";
myObj[prop1] = "value1";
myObj["myProp" + 2] = "value2";

Se si usa un numero come nome di proprietà, che verrà automaticamente convertito in una stringa, quindi questi hanno lo stesso risultato:

myObj[2010] = "value";
myObj["2010"] = "value";

È possibile anche utilizzare un letterale oggetto per impostare i valori:

var myObj = { myProp1: "value1", myProp2: "value2" };

(Notare che {} è anche un oggetto letterale, solo senza proprietà.)

Utilizzando il prototipo di un oggetto è utile solo se è stato chiamato tipi di oggetti (o in altro modo assegnare un prototipo per l'oggetto). Quando si creano oggetti utilizzando un oggetto letterale ogni oggetto ha il suo prototipo, in modo di mettere qualcosa nel prototipo ha lo stesso effetto di metterlo in oggetto.

Answer 2

L'aggiunta proprietà deve essere sia myObj.myProp o myObj["myProp"]. Questo è lo scenario ideale seguito e una buona pratica se usato in javascript.

Answer 3

Nel tuo caso, myObj.prototype.myProp3 = 'value3' dovrebbe non essere utilizzato perché letterali oggetto non hanno prototipi. Bene che fanno, ma non hanno una proprietà prototype (vedrai che myObj.prototype non è definito).

Prototipi sono utilizzate su funzioni per impostare le proprietà predefinite per tutti gli oggetti costruiti da quella funzione utilizzando la parola chiave new. Non è destinato ad essere utilizzato per l'assegnazione delle proprietà di singoli oggetti.

Answer 4

Per me, dipende da come userò l'oggetto.

Se ho intenzione di usarlo come un array associativo, una mappa di hash, o dove la sintassi punto sarebbe impossibile, io uso [ e ].

Tuttavia, se io li sto trattando come un oggetto, io uso la sintassi ..

Answer 5

In sostanza, non v'è alcuna differenza tra l'accesso a proprietà di un oggetto tramite il "" di sintassi o tramite il tasto.

var obj = new function(){this.x = "value";}
alert(obj.x === obj['x']); //it will output true

Ci sono momenti in cui non è possibile utilizzare il "" , Perché il nome della proprietà che si sta tentando di accedere non è un nome di variabile valido (come lei ha con il tasto numerico):

var obj = new function(){this['my-value'] = "my value";}
alert(obj['my-value']); // it will output "my value"
alert(obj.my-value); // it will trigger an exception , because the javascript 
//interpretor interprets "obj.my-value" as the 
//property "my" of obj minus the variable "value"

La grande differenza è il modo in cui il browser gestisce la sintassi. Come si può vedere qui , un mio amico ha fatto un po ' test e sembra che Chrome e IE lavoro molto più veloce con la sintassi punto mentre Firefox e Safari sono più "appassionati" la sintassi chiave.
In conclusione, è possibile utilizzare quasi ogni volta che uno di loro, anche se ci sono situazioni in cui i "" arriva un po ' "impreparati".

Sintassi prototipo, beh, quando si definisce un oggetto è possibile allegare i membri a ogni istanza, ma è anche possibile collegare i membri al prototipo di un oggetto, il che significa che ogni volta che viene creato un nuovo oggetto del tipo definito, erediterà automaticamente che gli Stati da essa di prototipo. Penso che sia meglio compresa con un esempio:

function Point(x,y){this.x = x;this.y = y;}
Point.prototype.toString = function(){
  return "I am a point with my x coord at "+this.x+" and my y coord at "+this.y;
}

function Point2(x,y){
  this.x = x;
  this.y = y;
  this.toString = function(){
    return "I'm a point too.I'm at x:"+this.x+", y:"+this.y;
  };
}

Quando si crea un new Point2, è il metodo toString un metodo di istanza e il codice JavaScript interprete alloca la memoria per questo metodo.
Quando si crea una 'nuova Point', è il metodo toString sarà incatenato su di essa la proprietà prototype. Ciò significa che nessuna memoria viene allocata per tale metodo.

var p = [], p2 = [];
for(var i = 0; i < 100000000; i++)
   {
     p.push(new Point(0,0));
     p2.push(new Point2(0,0));
   }

Se si prova questo, vedrete che entrambi gli oggetti sono perfetti lavorando, ma gli oggetti Point2 vorrà un po 'più memoria dal vostro sistema. Perché?
Il fatto è che quando si chiama il metodo new Point() di un toString(), le si rende conto di oggetto che non ha un membro chiamato "toString" e comincia a cercare in su di essa la catena di prototipi e ritorna membro della 'toString' trovato in dichiarazione dell'oggetto .
Nell'esempio di cui sopra, tutti gli elementi del p punterà il loro metodo toString a quello citato nel prototipo, mentre tutti gli elementi di p2 punterà a loro ogni copia del metodo.
Inoltre, se in seguito si desidera modificare il metodo toString, sarà molto facile da modificare per tutte le istanze Point:
Point.prototype.toString = function(){return "I'm a smarter point";}; Dopo di che, ogni istanza di new Point tornerà "Sono un punto più intelligente" quando si chiama il metodo di toString.
Se si tenta di modificarlo per le istanze Point2, è un po 'più difficile. Troverete che Point2.toString = function(){return "I'm a dumber point";} non funzionerà come previsto, si dovrà cambiare manualmente il metodo per ogni istanza:

for(var i in p2)
  p2[i].toString = function(){return "I'm a dumber point";};

ti lascio decidere su quale metodo è migliore: P

Answer 6

var myObj = function () {

};
myObj.prototype.myProp3 = 'value3' // whats the advantage?

Questo dovrebbe essere usato se si desidera utilizzare il myObj come un costrutto per creare più oggetti. vale a dire.

var obj1 = new myObj();

allora obj1 sarà anche ottenere la proprietà myProp3

modifica a cura nell'esempio precedente. utilizzare myObj come costruttore, dovrebbe essere dichiarato come una funzione