Quelle est la différence entre " new Object()` et littéral d'objet de la notation?

Quelle est la différence entre ce constructeur de base de la syntaxe pour la création d'un objet:

person = new Object()

...et cette syntaxe littérale:

person = {
    property1 : "Hello"
};

Il semble que les deux font la même chose, bien que JSLint préfère vous utilisez littéral d'objet de notation.

Lequel est le mieux et pourquoi?

Tout de même: a = new Object, a = new Object(), a = {}, littérale est beaucoup plus simple et quelques tests, j'ai couru il y a un moment dire que c'est plus rapide, les nouveaux compilateurs peuvent avoir causé ma déclaration fausse. Même s'applique à littérale des tableaux
J'espère que vous déclarez vos variables avec la var mot-clé dans le code de votre application pour éviter de polluer l'espace de noms global et la création de la nécessité de regarder au-delà de l'enregistrement en cours dans la pile pour les variables.
hey man, bon conseil. Mais que voulez-vous dire par "l'enregistrement en cours dans la pile"? Si je suis absent quelque chose que j'aimerais savoir c'
Fondamentalement, à tout moment pendant l'exécution d'un programme, il y a une pile de dossiers ou de blocs. Chaque enregistrement a une liste de variables qui ont été créés dans le champ d'application. En JavaScript, si une expression contient une variable et l'interprète ne peut pas le trouver dans la pile d'enregistrement pour cette portée, il va continuer jusqu'à l'enregistrement suivant jusqu'à ce qu'il trouve la variable. Plus d'infos davidshariff.com/blog/...
En évitant de JSLint est la première étape pour devenir un bon développeur. À l'aide de new est une convention qui transcende l'inutile tatillon d'une médiocre de la langue. Utilisation new parce que sa signification est claire. Dans 99,9% des cas, les gains de performance ne sont pas pertinents.
médiocre de la langue selon qui?

InformationsquelleAutor ectype | 2011-01-04

116

Ils font tous les deux la même chose (à moins que quelqu'un fait quelque chose d'inhabituel), d'autres que votre deuxième on crée un objet et ajoute une propriété. Mais la notation littérale prend moins d'espace dans le code source. C'est clairement reconnaissable en tant que ce qui se passe, afin de l'utiliser new Object(), vous êtes vraiment juste en tapant plus et (en théorie, si ce n'est optimisé par le moteur JavaScript) faire une fonction inutile d'appel.

Ces
```
person = new Object() /*You should put a semicolon here too.  
It's not required, but it is good practice.*/ 
-or-

person = {
    property1 : "Hello"
};
```
techniquement, il n'est pas la même chose. La première crée un objet. La deuxième crée et attribue une propriété. Pour le premier à être le même que vous avez alors besoin d'une deuxième étape, de créer et d'attribuer la propriété.

Le "quelque chose d'inhabituel" que quelqu'un pourrait faire serait de l'ombre ou de céder à la valeur par défaut Object global:
```
//Don't do this
Object = 23;
```
Dans ce très inhabituel cas, new Object échoue mais {} fonctionne.

Dans la pratique, il n'y a pas de raison d'utiliser new Object plutôt que {} (sauf si vous l'avez fait très inhabituel chose).
- L'auteur a choisi cette réponse est correcte, mais elle est incomplète. Savoir qu'il existe des différences entre les deux syntaxes quand vous entrez dans l'allocation de la mémoire.
- Il n'y a pas de différences. Si vous faites allusion à l'une des réponses sous, c'est hors-sujet, comme il est de parler de prototype à base de modèle d'objet et à l'héritage (le code il y a des configurations d'un Obj classe qui hérite de l'Objet ordinaire). Cette question n'est pas sur la création d'une instance d'une certaine classe personnalisée - c'est à propos de la création de l'instance de l'Objet, et la bonne réponse à cette question est "il n'y a pas de différence".
- Pour info également () new Object() n'est pas nécessaire. ( parlons pas nécessaire truc)
- Je pense que nous n'avons pas besoin d'utiliser nouveau dans la spécification actuelle. Laissez-moi savoir vos pensées @kevin
- il y a des différences entre les deux syntaxes quand vous entrez dans l'allocation de la mémoire" Non, il n'y en a pas.
- Oui, new Object et Object() (en l'appelant sans arguments) faire la même chose, d'aussi loin que la 3ème édition spec en 1999 (je n'ai pas essayer de trouver une version plus ancienne).
- J'ai le DEUXIÈME cas, le point-virgule n'est pas obligatoire. Javascript est la noyade dans les parenthèses, les crochets et des points-virgules;
- Votre dernière phrase n'a aucun sens.
InformationsquelleAutor kemiller2002
221

Il n'y a pas de différence pour un objet simple sans méthodes comme dans votre exemple.
Cependant, il y a une grande différence lorsque vous commencez à ajouter des méthodes à votre objet.

Manière littérale:
```
function Obj( prop ) { 
    return { 
        p : prop, 
        sayHello : function(){ alert(this.p); }, 
    }; 
} 
```
Prototype:
```
function Obj( prop ) { 
    this.p = prop; 
} 
Obj.prototype.sayHello = function(){alert(this.p);}; 
```
Deux façons de permettre la création d'instances de Obj comme ceci:
```
var foo = new Obj( "hello" ); 
```
Cependant, avec la manière littérale, vous apportez une copie de la sayHello méthode au sein de chaque instance de vos objets. Alors que, avec le prototype, la méthode est définie dans l'objet prototype et partagée entre toutes les instances de l'objet.
Si vous avez beaucoup d'objets ou à un grand nombre de méthodes, la manière littérale peut conduire à d'assez grandes la mémoire des déchets.
- Cela semble être la bonne et la réponse plus complète.
- Pour moi, la question était plus sur les différences entre l'utilisation de new Object() vs {} pour créer des objets vides.
- Et qu'est ce que cela répond.
- En dehors de la première phrase, cette réponse ne fait pas de fournir tous les renseignements au sujet de l'OP de la question. Il ne contient même pas 'new Object()` n'importe où. Franchement, je pense que M. David a mal compris la question.
- Lorsque j'ai posté cette acceptés réponse était déjà là et accepté. Et il répond que l'OP question si je n'allais pas répéter la même chose. J'ai posté ma réponse principalement à élargir le sujet au-delà de vide/de simples objets. Dans ce cas, il est une différence importante qui mérite d'être mentionnée.
- Cette réponse est hors-sujet. Dans votre code, Obj est une catégorie distincte hérite de l'Objet. Lorsque vous utilisez un objet littéral de notation, vous utilisez la classe d'Objet, pas de Obj. Bien sûr, la configuration d'une classe avec une méthode dans son prototype est en train de faire mémoire de l'empreinte plus petite que la création d'un lot d'Objets simples et en ajoutant de la méthode que leurs propriétés, mais qui est complètement sans rapport avec la question posée ici. La bonne réponse à cette question est "non, il n'y a absolument aucune différence (peut-être à l'exception de la lisibilité)".
- Bien que l'entrée est assez ancien: Le "littéraire" chemin crée un objet, mais renvoie ainsi une fermeture whie dans votre Protoype façon dont il fonctionne simplement la fonction. Donc, je doute que les échantillons sont vraiment comparables.
- Cela a littéralement RIEN à voir avec la question, et peut entraîner de la confusion à cause de cela. Mise sur le prototype est une chose complètement différente que de mettre une propriété sur l'objet lui-même...et qui s'applique si le bien que vous faites est une fonction ou pas. Vous êtes de prendre cela comme c'est une "méthode vs non-fonction de la propriété de chose", alors qu'en réalité, les fonctions et les non-valeurs de la fonction peut être attribuée également à l'objet réel ou le prototype de l'objet, et de l'affecter à le prototype n'a rien à voir avec cette question.
- ^le tl;dr version de c'est que cette réponse est fondamentalement en disant: "C'est différent si vous faites quelque chose de totalement différent."
- Je suis venu pour cette réponse, basée sur une question qui était comme la mienne, mais a fini par apprendre exactement ce que j'avais besoin de savoir. Je vous remercie.
- Si vous utilisez une IIFE qui retourne une fonction, vous pouvez utiliser la "portée privée" astuce pour seulement déclarer la fonction une fois, mais lui permettre d'être un membre de chaque instance de la fonction constructeur.
- Bien la copie d'une fonction autour, c'est du gaspillage, cependant, vous pouvez définir un "global" de la fonction sayHello(obj) et ne sayHello(foo) au lieu de foo.sayHello().
InformationsquelleAutor Rémy DAVID
53

En JavaScript, on peut déclarer un nouvel objet vide de deux façons:
```
var obj1 = new Object();  
var obj2 = {};  
```
Je n'ai rien trouvé de suggérer qu'il n'y a aucune différence significative de ces deux quant à la façon dont ils fonctionnent en arrière-plan (corrigez-moi si je me trompe – je voudrais bien savoir). Cependant, la deuxième méthode (à l'aide de l'objet de la notation littérale) offre quelques avantages.
1. Il est plus court (10 caractères pour être précis)
2. Il est plus facile, et plus structurée de manière à créer des objets à la volée
3. Il n'a pas d'importance si certains bouffon a, par inadvertance, substituée à l'Objet
Envisager un nouvel objet qui contient le Nom des membres et TelNo. À l'aide de la new Object() de la convention, nous pouvons le créer comme ceci:
```
var obj1 = new Object();  
obj1.Name = "A Person";  
obj1.TelNo = "12345"; 
```
La Expando Propriétés fonction de JavaScript nous permet de créer des nouveaux membres de cette façon, à la volée, et nous réalisons ce que prévoyaient. Cependant, cette voie n'est pas très structuré ou encapsulé. Que faire si nous voulions définir les membres lors de la création, sans avoir à compter sur expando propriétés et de l'affectation post-création?

C'est là l'objet de la notation littérale peut aider:
```
var obj1 = {Name:"A Person",TelNo="12345"};  
```
Ici, nous avons réalisé le même effet dans une ligne de code et de manière significative moins de caractères.

Une discussion approfondie à la construction de l'objet des méthodes ci-dessus peuvent être trouvés à: JavaScript et la Programmation Orientée Objet (POO).

Et enfin, quel est l'idiot qui l'emportait sur l'Objet? Avez-vous pense que ce n'était pas possible? Eh bien, cette JSFiddle prouve le contraire. À l'aide de l'objet de la notation littérale nous empêche de tomber sous le coup de cette bouffonnerie.

(À partir de http://www.jameswiseman.com/blog/2011/01/19/jslint-messages-use-the-object-literal-notation/)
- Comment au sujet de l'Objet.Créer? Voir: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
- Si vous allez à la faveur des littéraux d'objet sur new Object() en raison de la possibilité que quelque chose a remplacé la fonction de l'Objet, vous devez également écrire des gardes de partout lorsque vous utilisez les aides comme Object.keys pour s'assurer qu'il n'est pas indéfini, qui descend dans l'absurdité. Je serais toujours recommandons l'utilisation de la notation littérale, mais je pense que cet argument tombe à l'eau quand on pense aux conséquences de penser de cette façon.
InformationsquelleAutor James Wiseman
40

Sur ma machine à l'aide de Node.js, j'ai couru le suivant:
```
console.log('Testing Array:');
console.time('using[]');
for(var i=0; i<200000000; i++){var arr = []};
console.timeEnd('using[]');

console.time('using new');
for(var i=0; i<200000000; i++){var arr = new Array};
console.timeEnd('using new');

console.log('Testing Object:');

console.time('using{}');
for(var i=0; i<200000000; i++){var obj = {}};
console.timeEnd('using{}');

console.time('using new');
for(var i=0; i<200000000; i++){var obj = new Object};
console.timeEnd('using new');
```
Remarque, c'est une extension de ce que l'on trouve ici: Pourquoi est arr = [] plus vite que d'arr = new Array?

ma sortie a été le suivant:
```
Testing Array:
using[]: 1091ms
using new: 2286ms
Testing Object:
using{}: 870ms
using new: 5637ms
```
donc clairement {} et [] sont plus rapides qu'à l'aide de nouveau pour créer des objets vides/tableaux.
- Bonne démo pour les spectacles !
- J'ai l'impression que c'est la réponse que la question a été vraiment à la recherche d', mais je voudrais l'avoir vu, ce sont également testés sur un objet avec un peu de propriétés pour s'en assurer.
- Chiffres intéressants. Il y a des gens qui ont besoin d'être conscient de cela, mais je retiens que l'affectation de même un maigre de 200 000 objets ne va me coûter 5.6 ms, donc je ne vais pas vous en préoccuper.
- Sur le Nœud 10.13.0 les choses ONT CHANGÉ Tests de Tableau: à l'aide de[]: 117.178 ms à l'aide de nouveau: 116.947 mme Objet de Test: à l'aide de{}: 116.252 ms à l'aide de nouveau: 115.910 ms
InformationsquelleAutor rjloura
30

Tout le monde parle ici de les similitudes entre les deux. Je vais souligner les différences.
1. À l'aide de new Object() vous permet de passer à un autre objet. Le résultat évident est que l'objet nouvellement créé sera réglé à la même référence. Voici un exemple de code:
```
var obj1 = new Object();
obj1.a = 1;
var obj2 = new Object(obj1);
obj2.a //1
```
2. L'utilisation n'est pas limitée à des objets aussi en programmation orientée objet, les objets. D'autres types pourraient être transmis à trop. La fonction permet de définir le type en conséquence. Par exemple, si nous passons entier 1, un objet de type numéro sera créé pour nous.
```
var obj = new Object(1);
typeof obj //"number"
```
3. L'objet créé à l'aide de la méthode ci-dessus (new Object(1)) serait converti en type d'objet si une propriété est ajouté.
```
var obj = new Object(1);
typeof obj //"number"
obj.a = 2;
typeof obj //"object"
```
4. Si l'objet est une copie d'un enfant de la classe de l'objet, on pourrait ajouter la propriété sans la conversion de type.
```
var obj = new Object("foo");
typeof obj //"object"
obj === "foo" //true
obj.a = 1;
obj === "foo" //true
obj.a //1
var str = "foo";
str.a = 1;
str.a //undefined
```
- je suis très confus sur les deux dernières lignes.. Pourquoi si vous affectez à la str.a la valeur 1, str.une n'est pas défini?.. @Jermin Bazazin
- parce que str est de type string de sorte que vous ne peut pas attribuer une propriété à elle. jsfiddle.net/grq6hdx7/1
- merci @ChrisB
- A la réponse de 4 a changé? Je reçois faux, pas vrai, en dernier Chrome 53 var obj = new Object("foo"); typeof obj; obj === "foo" // true
InformationsquelleAutor Jermin Bazazian
17

En fait, il existe plusieurs façons de créer des objets en JavaScript. Quand vous voulez juste pour créer un objet, il n'y a aucun avantage de la création de "constructeur à base de" objets à l'aide de "nouveau" de l'opérateur. C'est même que la création d'un objet à l'aide de "littéral d'objet de syntaxe". Mais "constructeur à base de" les objets créés avec "nouveau" opérateur vient d'utilisation incroyable quand vous pensez au sujet de "prototypes héritage". Vous ne pouvez pas maintenir la chaîne d'héritage avec les objets créés avec la syntaxe littérale. Mais vous pouvez créer une fonction constructeur, attacher des propriétés et des méthodes de son prototype. Alors si vous affectez cette fonction constructeur pour toute variable à l'aide de "nouveau" de l'opérateur, il sera de retour un objet qui aura accès à toutes les méthodes et propriétés sont attachées avec le prototype de la fonction constructeur.

Voici un exemple de création d'un objet à l'aide de la fonction constructeur (voir explication du code en bas):
```
function Person(firstname, lastname) {
    this.firstname = firstname;
    this.lastname = lastname;
}

Person.prototype.fullname = function() {
    console.log(this.firstname + ' ' + this.lastname);
}

var zubaer = new Person('Zubaer', 'Ahammed');
var john = new Person('John', 'Doe');

zubaer.fullname();
john.fullname();
```
Maintenant, vous pouvez créer autant d'objets que vous le souhaitez par l'instanciation de Personne en fonction de construction et chacun d'eux sera hériter fullname() de celui-ci.

Note:
"ce mot clé" fera référence à un objet vide à l'intérieur d'une fonction constructeur et chaque fois que vous créez un nouvel objet, d'une Personne à l'aide de "nouveau" de l'opérateur, il retourne un objet contenant toutes les propriétés et méthodes associées à la "ce" mot-clé. Et ces objets va hériter des méthodes et des propriétés qui y sont attachés avec la prototype de la Personne en fonction de constructeur (ce qui est le principal avantage de cette approche).

Par la manière, si vous voulez obtenir la même fonctionnalité avec "littéral d'objet" syntaxe, vous devez le créer fullname() sur tous les objets comme ci-dessous:
```
var zubaer = {
    firstname: 'Zubaer',
    lastname: 'Ahammed',
    fullname: function() {
        console.log(this.firstname + ' ' + this.lastname);
    }
};

var john= {
    firstname: 'John',
    lastname: 'Doe',
    fullname: function() {
        console.log(this.firstname + ' ' + this.lastname);
    }
};

zubaer.fullname();
john.fullname();
```
Enfin, si vous demandez maintenant pourquoi devrais-je utiliser fonction constructeur approche au lieu de littéral d'objet approche:

*** Prototypes héritage permet à une simple chaîne de l'héritage qui peut être extrêmement utile et puissant.

*** Il permet d'économiser la mémoire en héritant commun des méthodes et des propriétés définies dans les fonctions constructeur de prototype. Sinon, vous devez copier encore et encore dans tous les objets.

J'espère que cela a du sens.
- Merci! Karl, pour ajouter le manque de "ce" dans l'objet littéral. C'était une horrible erreur..je ne devrais pas faire ce type d'erreur.
- "Vous ne peut pas hériter d'un objet créé avec la syntaxe littérale." - Pas vrai (je crois). Vous pouvez utiliser Object.create(<object defined using literal notation>) ou new Object(<object defined using literal notation>) et de créer de l'héritage des chaînes en tant que de besoin.
- Merci pour votre commentaire. En fait, il devrait être "Vous ne pouvez pas maintenir la chaîne d'héritage avec les objets créés avec la syntaxe littérale". Réponse en plusieurs étapes: 1. Objet.create(): Oui, il est possible de passer un objet littéral, et qu'elle sera de retour un nouvel objet prototype, qui est passé de l'objet littéral. Mais il ne sait pas ce qu'est c'est à la fonction constructeur ou ne me souviens pas que littéral d'objet à partir de laquelle il a été créé. Donc, testobj1.constructeur de retour d'une fonction vide et il n'y aura pas moyen d'ajouter des propriétés ou des méthodes à l'objet en question littérale que celle du parent/ancêtre.
- 2. new Object(): Presque la même chose qui se passe dans ce cas. En outre, il est encore pire si vous pensez à ce sujet de mémoire. Au lieu de mettre les propriétés et les méthodes de prototype, c'est juste des copies de tout, de l'objet passé littéral et le met dans l'objet retourné. Il n'est pas bon pour la mémoire. A l'inverse, j'ai mis l'accent sur une véritable héritage de la chaîne avec un constructeur fonction de l'endroit où vous pouvez modifier les méthodes et les propriétés à la volée et d'autres objets créés à l'aide de la méthode de constructeur sont également touchés car ils sont pointant vers cette fonction constructeur seulement (au lieu de les copier).
- Exemple: function Person(firstname, lastname) { this.firstname = firstname; this.lastname = lastname; } Person.prototype.fullname = function() { console.log(this.firstname + ' ' + this.lastname); } var zubaer = new Person('Zubaer', 'Ahammed'); var john = new Person('John', 'Doe'); zubaer.fullname(); // Zubaer Ahammed john.fullname(); // John Doe zubaer.constructor.prototype.fullname = function() { console.log( 'Hello ' + this.firstname); } zubaer.fullname(); // Hello Zubaer john.fullname(); // Hoello John
- En fin de compte, les Objets créés forme d'une fonction constructeur sait d'où ils sont hérités/créé.
- quand je suis en cours d'exécution de votre code rien ne se passe, pourquoi ?
InformationsquelleAutor Md. Zubaer Ahammed
8

Aussi, selon certains O'Really javascript, des livres....(cité)

Une autre raison pour l'utilisation de littéraux contrairement au constructeur de l'Objet est qu'il n'existe pas de résolution de portée. Car il est possible que vous avez créé un constructeur local avec le même nom, l'interprète doit rechercher le champ d'application de la chaîne à partir de l'endroit que vous appelez Objet() tout le chemin jusqu'à ce qu'il trouve l'Objet global constructeur.
- attendez O'Really une faute de frappe ou une volonté délibérée de jeu de mots? Ils doivent utiliser que pour la commercialisation de leurs livres!
InformationsquelleAutor adolfo_isassi
3

J'ai trouvé une différence, pour ES6/ES2015. Vous ne pouvez pas retourner un objet en utilisant le raccourci flèche syntaxe de la fonction, sauf si vous entourer l'objet avec new Object().
```
> [1, 2, 3].map(v => {n: v});
[ undefined, undefined, undefined ]
> [1, 2, 3].map(v => new Object({n: v}));
[ { n: 1 }, { n: 2 }, { n: 3 } ]
```
C'est parce que le compilateur est confondu par le {} crochets et pense n: i est un étiquette: déclaration construire; le point-virgule est facultative afin de ne pas se plaindre à ce sujet.

Si vous ajoutez une autre propriété de l'objet qu'il va enfin lever une erreur.
```
$ node -e "[1, 2, 3].map(v => {n: v, m: v+1});"
[1, 2, 3].map(v => {n: v, m: v+1});
                           ^

SyntaxError: Unexpected token :
```
- Vous pouvez toujours utiliser une flèche de fonction, vous avez besoin de plus d'accolades et de retour: [1, 2, 3].map(v => { return {n: v}; }); vous net la même chose...
- Bien sûr, vous pouvez utiliser les flèches de fonctions, ce dont je parle est la version courte, c'est à dire param => return_value, et la différence entre l'utilisation de {} et new Object() dans ce cas.
- Vous pouvez toujours utiliser la version courte ET régulière flèche fonctions. Juste envelopper les {n: v} avec une paire de parenthèses: [1, 2, 3].map(v => ({n: v}));
InformationsquelleAutor Andrei Simionescu

2019 mise à Jour

J'ai couru le même code que @rjloura sur mon OSX High Sierra 10.13.6 nœud version 10.13.0 et ce sont les résultats

console.log('Testing Array:');
console.time('using[]');
for(var i=0; i<200000000; i++){var arr = []};
console.timeEnd('using[]');

console.time('using new');
for(var i=0; i<200000000; i++){var arr = new Array};
console.timeEnd('using new');

console.log('Testing Object:');

console.time('using{}');
for(var i=0; i<200000000; i++){var obj = {}};
console.timeEnd('using{}');

console.time('using new');
for(var i=0; i<200000000; i++){var obj = new Object};
console.timeEnd('using new');


Testing Array:
using[]: 117.613ms
using new: 117.168ms
Testing Object:
using{}: 117.205ms
using new: 118.644ms

InformationsquelleAutor PirateApp

-2

L'utilisation de la mémoire est différente si vous créez 10 mille instances.
new Object() ne garder qu'un seul exemplaire alors que {} conservera 10 mille exemplaires.
- new crée un nouvel objet. Ils ont tous deux prendre la même quantité de mémoire.
InformationsquelleAutor Richard Miao US

Vous devez vous connecter pour publier un commentaire.