JavaScript-Datentypen verstehen: Primitiv vs. Nicht-Primitiv

In JavaScript werden Datentypen in zwei Hauptkategorien unterteilt: Primitive und Nicht-Primitive (Referenztypen). Diese Unterscheidung ist wichtig, um zu verstehen, wie Daten im Speicher gespeichert und abgerufen werden. Lassen Sie uns jeden Typ aufschlüsseln und sehen, wie er funktioniert.

Primitive Datentypen

JavaScript hat 7 primitive Datentypen:

1. Zeichenfolge
   
   Stellt Textdaten dar, z. B. „Hello World“.

2. Nummer
   
   Stellt sowohl Ganzzahl- als auch Gleitkommazahlen dar, z. B. 100, 100,3. Im Gegensatz zu einigen anderen Sprachen unterscheidet JavaScript nicht zwischen Ganzzahlen und Gleitkommazahlen – sie sind alle nur Zahlen.
   

   const score = 100;
   const scoreValue = 100.3;
   console.log(typeof scoreValue); // Output: number
   

3. Boolean
   
   Stellt logische Werte dar: wahr oder falsch.
   

   const isLoggedIn = true;
   console.log(typeof isLoggedIn); // Output: boolean
   

4. Symbol
   
   Stellt einen eindeutigen Bezeichner dar. Selbst wenn zwei Symbole mit derselben Beschreibung erstellt werden, sind sie unterschiedlich.
   

   const id = Symbol('123');
   const anotherId = Symbol('123');
   console.log(id === anotherId); // Output: false
   

5. Null
   
   Stellt ein absichtliches Fehlen jeglichen Objektwerts dar.
   

   const outsideTemp = null;
   console.log(typeof outsideTemp); // Output: object
   

6. Undefiniert
   
   Stellt eine Variable dar, die deklariert wurde, aber noch keinem Wert zugewiesen wurde.
   

   let weather;
   console.log(typeof weather); // Output: undefined
   

7. BigInt
   
   Stellt Ganzzahlen mit beliebiger Genauigkeit dar, sodass Sie mit großen Zahlen arbeiten können, die über die sichere Ganzzahlgrenze von Number hinausgehen.
   

   const bigNumber = 23873847283748289483n;
   console.log(typeof bigNumber); // Output: bigint
   

Primitive Datentypen: Aufruf nach Wert

Primitive Typen werden direkt am Speicherort gespeichert, der einer Variablen zugeordnet ist. Wenn Sie einer anderen Variablen einen primitiven Wert zuweisen, wird eine neue Kopie des Werts erstellt.

let myName = "Aman";
let myOtherName = myName;
myOtherName = "Dawn";
console.log(myName);       // Output: Aman
console.log(myOtherName);  // Output: Dawn

Im obigen Beispiel hat die Änderung von myOtherName keine Auswirkungen auf myName, da eine neue Kopie des Werts erstellt wurde.

Nicht-primitive Datentypen

Zu den nicht-primitiven Typen, auch Referenztypen genannt, gehören:

1. Arrays
   
   Sammlungen von Elementen beliebiger Art, gespeichert als Liste.
   

   const heros = ["ironman", "spiderman", "batman"];
   console.log(typeof heros); // Output: object
   

2. Objekte
   
   Sammlungen von Schlüssel-Wert-Paaren, wobei die Schlüssel Zeichenfolgen oder Symbole sind und die Werte einen beliebigen Typ haben können.
   

   let myObj = {
       name: "Ayush",
       age: 21,
   };
   console.log(typeof myObj); // Output: object
   

3. Funktionen
   
   Codeblöcke zur Ausführung einer bestimmten Aufgabe, die in Variablen gespeichert werden können.
   

   const myFunction = function() {
       console.log("Hello World");
   };
   console.log(typeof myFunction); // Output: function
   

Nicht-primitive Datentypen: Call by Reference

Nicht-primitive Typen werden im Heap gespeichert und die Variable enthält einen Verweis (Speicheradresse) auf die tatsächlichen Daten. Wenn Sie einer anderen Variablen einen nicht-primitiven Typ zuweisen, verweisen beide Variablen auf denselben Speicherort.

let userOne = {
    email: "user1@google.com",
    upi: "user@ybl"
};
let userTwo = userOne;
userTwo.email = "aman@google.com";
console.log(userOne.email);  // Output: aman@google.com
console.log(userTwo.email);  // Output: aman@google.com

Im obigen Beispiel ändert sich durch die Änderung von userTwo.email auch userOne.email, da beide Variablen auf dasselbe Objekt im Speicher verweisen.

Wichtige Erkenntnisse

• Primitive Typen sind einfache Datentypen, die Werte direkt speichern. Sie sind unveränderlich und jede Variable enthält eine eigene Kopie der Daten.
• Nicht-primitive Typen sind komplexer und Variablen speichern Verweise auf die Daten. Änderungen an einer Variablen können sich auf andere auswirken, die auf dieselben Daten verweisen.
• Das Verständnis dieser Unterschiede ist entscheidend für das Schreiben von effizientem und fehlerfreiem Code in JavaScript.

Viel Spaß beim Codieren und wir sehen uns im nächsten!!!

Das obige ist der detaillierte Inhalt vonJavaScript-Datentypen verstehen: Primitiv vs. Nicht-Primitiv. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!