Vilket sätt är bäst för att skapa ett objekt i JavaScript? Är `var` nödvändigt innan en objektproperty?

Hittills har jag sett tre sätt att skapa ett objekt i JavaScript. Vilket sätt är bäst för att skapa ett objekt och varför?

Jag såg också att i alla dessa exempel används inte nyckelordet var före en egenskap — varför? Är det inte nödvändigt att deklarera var före namnet på en egenskap eftersom det nämns att egenskaper är variabler?

På det andra och tredje sättet är objektets namn med versaler medan på det första sättet är objektets namn med gemener. Vilken bokstavsstil bör vi använda för ett objektnamn?

Första sättet:

function person(fname, lname, age, eyecolor){
  this.firstname = fname;
  this.lastname = lname;
  this.age = age;
  this.eyecolor = eyecolor;
}

myFather = new person("John", "Doe", 50, "blue");
document.write(myFather.firstname + " is " + myFather.age + " years old.");

Andra sättet:

var Robot = {
  metal: "Titanium",
  killAllHumans: function(){
    alert("Exterminate!");
  }
};

Robot.killAllHumans();

Tredje sättet — JavaScript-objekt med arraysyntax:

var NewObject = {};

NewObject['property1'] = value;
NewObject['property2'] = value;
NewObject['method'] = function(){ /* function code here */ }

Svar #1

Det finns inget bästa sätt, det beror på ditt användningsfall.

  • Använd metod 1 om du vill skapa flera liknande objekt. I ditt exempel kallas Person (du bör börja namnet med en stor bokstav) för konstruktionsfunktionen. Detta är liknande klasser i andra OO-språk.
  • Använd sätt 2 om du bara behöver ett objekt av en sort (som en singleton). Om du vill att detta objekt ska ärva från ett annat, måste du däremot använda en konstruktionsfunktion.
  • Använd sätt 3 om du vill initiera objektets egenskaper beroende på andra egenskaper hos det eller om du har dynamiska egenskapsnamn.

Uppdatering: Som begärt exempel för det tredje sättet.

Beroende egenskaper:

Följande fungerar inte eftersom this inte hänvisar till book. Det finns inget sätt att initiera en egenskap med värden från andra egenskaper i ett objektliteral:

var book = {
    price: somePrice * discount,
    pages: 500,
    pricePerPage: this.price / this.pages
};

istället kan du göra:

var book = {
    price: somePrice * discount,
    pages: 500
};
book.pricePerPage = book.price / book.pages;
// or book['pricePerPage'] = book.price / book.pages;

Dynamiska egenskapsnamn:

Om egenskapsnamnet är lagrat i någon variabel eller skapas genom ett uttryck, måste du använda hakparentesnotation:

var name = 'propertyName';

// the property will be `name`, not `propertyName`
var obj = {
    name: 42
}; 

// same here
obj.name = 42;

// this works, it will set `propertyName`
obj[name] = 42;

Svar #2

Det finns olika sätt att definiera en funktion. Det beror helt på ditt behov. Nedan är några få stilar :-

  1. Objektkonstruktör
  2. Literal konstruktor
  3. Funktionsbaserad
  4. Prototypbaserad
  5. Funktions- och prototypbaserad
  6. Singleton-baserad

Exempel:

  1. Objektkonstruktör
var person = new Object();

person.name = "Anand",
person.getName = function(){
  return this.name ; 
};
  1. Literal konstruktor
var person = { 
  name : "Anand",
  getName : function (){
   return this.name
  } 
}
  1. funktion Konstruktor
function Person(name){
  this.name = name
  this.getName = function(){
    return this.name
  } 
}
  1. Prototyp
function Person(){};

Person.prototype.name = "Anand";
  1. Funktions-/Prototypkombination
function Person(name){
  this.name = name;
} 
Person.prototype.getName = function(){
  return this.name
}
  1. Enstöring
var person = new function(){
  this.name = "Anand"
}

Du kan prova det på konsolen om du har någon förvirring.

Svar #3

Det finns inget "bästa sätt" att skapa ett objekt. Varje sätt har fördelar beroende på ditt användningsområde.

Konstruktörsmönstret (en funktion tillsammans med new-operatorn för att anropa den) ger möjligheten att använda prototypbaserad arv, medan de andra sätten inte gör det. Så om du vill ha prototypbaserad arv är en konstruktörsfunktion ett bra sätt att gå.

Men om du vill ha prototypbaserad arv, kan du lika gärna använda Object.create, vilket gör arvet mer uppenbart.

Att skapa ett objektliteral (t.ex. var obj={foo: "bar"};) fungerar utmärkt om du råkar ha alla egenskaper du vill sätta till hands vid skapandet.

För att sätta egenskaper senare är syntaxen NewObject.property1 generellt att föredra framför NewObject['property1'] om du känner till egenskapens namn. Men den senare är användbar när du faktiskt inte har egenskapens namn i förväg (t.ex. NewObject[someStringVar]).

Hoppas det här hjälper!

Relaterade artiklar