En introduktion till datatyper i JavaScript

En datatyp definierar typen och beteendet hos data – den talar om för kompilatorn eller tolken hur en programmerare avser att använda en bit data. De flesta programmeringsspråk stöder grundläggande datatyper som nummer, boolean, sträng, etc.

JavaScript stöder åtta datatyper: Number, BigInt, Boolean, String, Null, Undefined, Symbol och Object. I den här artikeln kommer du att lära dig om alla åtta JavaScript-datatyperna och hur du använder dem.

JavaScript-datatyper

Datatyper i JavaScript kan grovt klassificeras i två kategorier: Primitiva datatyper och icke-primitiva datatyper. Ett objekt är en icke-primitiv eller komplex datatyp, och resten är primitiva datatyper.

JavaScript är ett dynamiskt skrivet språk, vilket innebär att variabeltyper kontrolleras under körning. Samma variabel kan hålla värden av olika typer när som helst.

Till exempel:

// x är en sträng
let x = "Hej världen";
// x är ett tal
x = 100;
// x är nu ett booleskt värde
x = sant;

Om du vill hitta den aktuella datatypen för en variabel, använd sorts operatör.

// x är en sträng
let x = "Hej världen";
console.log (typ av (x));
// x är ett tal
x = 100;
console.log (typ av (x));
// x är nu ett booleskt värde
x = sant;
console.log (typ av (x));

Produktion:

sträng
siffra
booleskt

1. Nummerdatatyp i JavaScript

Nummerdatatypen i JavaScript använder IEEE-754 format för att representera både heltal och flyttal. Du kan utföra många operationer på tal i JavaScript som addition, subtraktion, division, multiplikation och så vidare. För att utföra mer komplexa operationer kan du använda den inbyggda Math objekt.

Några exempel för att skapa siffror i JavaScript:

// Använder bokstavlig deklaration
låt n1 = 100;
låt n2 = 456,234;
// Använda Number()-konstruktorn
låt n3 = Tal (100);
// Konvertering till heltal
låt n4 = Number.parseInt("456.234");
// Konvertering till flytande
låt n5 = Number.parseFloat("456.234");
låt n6 = Number.parseFloat("1.13e3");
// Enär konvertering till tal
låt n7 = +"345";
console.log (n1);
console.log (n2);
console.log (n3);
console.log (n4);
console.log (n5);
console.log (n6);
console.log (n7);

Produktion:

100
456.234
100
456
456.234
1130
345

Heltal

Följande sats skapar en variabel som innehåller ett heltal:

låt x = 21;

Om du vill skapa oktala (bas 8) literaler måste du använda 0o prefix med sekvensen av oktala siffror (siffror från 0 till 7).

låt x = 0o53;
console.log (x);

Produktion:

43

På samma sätt, om du vill skapa hexadecimala (bas 16) literaler, använd 0x prefix med sekvensen av hexadecimala siffror (0 till 9 och A till F).

låt x = 0x53;
console.log (x);

Produktion:

83

Flyttalssiffror

Följande sats skapar en variabel som innehåller ett flyttal:

låt x = 324,56;

Du kan använda e-notation för att representera mycket stora eller mycket små tal.

låt x = 1,13e6;
console.log (x);

Produktion:

1130000

JavaScript tillhandahåller även andra speciella numeriska värden som hör till siffra datatyp – NaN, Infinity och -Infinity.

• NaN: NaN står för Inte ett nummer vilket betyder ett ogiltigt nummer. Om du till exempel delar en sträng och ett tal blir resultatet NaN.

  console.log("MakeUseOf"/10);

  Produktion:

  NaN

  Intressant nog är NaN inte lika med någonting, inklusive sig själv.

  console.log (NaN == NaN);
  console.log (NaN == ("MakeUseOf"/10));
  console.log (NaN NaN);

  Produktion:

  falsk
  falsk
  falsk

  Dessutom, om ett matematiskt uttryck någonstans innehåller NaN, blir resultatet alltid NaN.
• Infinity och -Infinity: Oändlighet och -Oändlighet representerar det matematiska ∞ och -∞ respektive.

2. BigInt Datatyp i JavaScript

BigInt är en primitiv datatyp i JavaScript som kan representera heltal med godtycklig precision. Eftersom nummerdatatypen inte kan representera värden större än (2⁵³-1) eller värden mindre än -(2⁵³-1), används BigInt i sådana fall för att representera mycket stora eller små tal.

BigInt-nummer används sällan. Men om du verkligen behöver representera stora siffror, t.ex. för kryptografi, beräkning av factorial av stor siffror, som representerar solens massa, mikrosekundsprecisionstidsstämplar och så vidare, BigInt är vad du vill ha att använda.

Du kan skapa ett BigInt-värde genom att lägga till n till slutet av ett heltal eller genom att använda konstruktorn.

låt stor1 = 78649264972634817648747234872634876243862348763467547n;
let big2 = BigInt("78649264972634817648747234872634876243862348763467547");
console.log (big1);
console.log (big2);

Produktion:

78649264972634817648747234872634876243862348763467547n
78649264972634817648747234872634876243862348763467547n

BigInt-datatypen är ett relativt nytt tillägg till språket och stöds för närvarande av nästan alla webbläsare utom Internet Explorer.

3. Boolean datatyp i JavaScript

Den booleska datatypen kan ha två värden: Sann och falsk. Booleska värden är resultatet av logiska jämförelser.

låt x1 = sant;
console.log (x1);
låt x2 = !sant;
console.log (x2);
låt x3 = !!sant;
console.log (x3);
låt x4 = (falskt && sant);
console.log (x4);
låt x5 = (falskt || sant);
console.log (x5);
låt x6 = (2 == "2");
console.log (x6);
låt x7 = (2 "2");
console.log (x7);
låt x8 = (noll odefinierad);
console.log (x8);
låt x9 = (0 == "");
console.log (x9);
låt x10 = (100 > 12);
console.log (x10);

Produktion:

Sann
falsk
Sann
falsk
Sann
Sann
falsk
falsk
Sann
Sann

Du kan konvertera ett värde av vilken annan datatyp som helst till en boolesk datatyp med hjälp av Boolean() fungera.

// Strängar
console.log (Boolean(''));
console.log (Boolean('abc'));
console.log (Boolean('123'));
// Tal
console.log (Boolesk (0));
console.log (Boolesk (1));
console.log (Boolean(-1));
console.log (Boolean (NaN));
console.log (Boolesk (Infinity));
// Andra
console.log (Boolean([1, 2, 3]));
console.log (Boolesk (odefinierad));
console.log (Boolesk (null));

Produktion:

falsk
Sann
Sann
falsk
Sann
Sann
falsk
Sann
Sann
falsk
falsk

4. Strängdatatyp i JavaScript

En sträng är en sekvens med noll eller fler tecken. Strängar i JavaScript är oföränderliga och används huvudsakligen för att representera textdata. Indexeringen av strängar börjar från 0, dvs det första elementet är vid index 0, det andra vid 1, och så vidare.

Strängar måste omges av citattecken. Du kan använda någon av de tre typerna av citattecken för att skapa en sträng: Enkla citattecken, Dubbla citattecken eller Backticks.

Enkla och dubbla citattecken gör praktiskt taget samma sak, men en sträng som börjar med ett dubbelt citattecken måste sluta med ett dubbelt citattecken. Samma regel gäller för det enda citatet.

låt str1 = "Hej";
låt str2 = 'Hej';
let str3 = "Hur mår du?";
// Använda \ för att undvika det enda citattecken (')
let str4 = 'Hur mår du?';

Backticks är bokstavliga mallar och ger en viss utökad funktionalitet. Du kan bädda in variabler, uttryck och till och med funktionsanrop i strängen.

// Bädda in variabel i en sträng
let x = "Hej";
let str1 = `${x}, hur mår du?`;
console.log (str1);
// Bädda in uttryck i en sträng
let str2 = `Summan av 20 + 30 är: ${20 + 30}`;
console.log (str2);
// Inbädda funktionsanrop i en sträng
funktion beräknaSumma (a, b) {
returnera a + b;
}
let str3 = `Summan av 20 + 30 är: ${calculateSum (20, 30)}`;
console.log (str3);

Produktion:

Hej, hur mår du?
Summan av 20 + 30 är: 50
Summan av 20 + 30 är: 50

JavaScript tillhandahåller också flera strängmetoder att manipulera strängar.

5. Null datatyp i JavaScript

Datatypen noll har bara ett värde: null. Det representerar den avsiktliga frånvaron av något objektvärde.

låt n = noll;

Många programmerare blir förvirrade mellan null och odefinierad. Det är knepigt att förstå skillnaden mellan null och odefinierad i JavaScript.

6. Odefinierad datatyp i JavaScript

Den odefinierade typen är en speciell typ som betyder att "värdet inte tilldelas". När du deklarerar en variabel men inte initierar den tilldelas variabeln ett odefinierat värde.

låt x;
console.log (typ av (x));

Produktion:

odefinierad

Du kan uttryckligen tilldela odefinierad till en variabel, men det rekommenderas starkt att undvika det.

Relaterad: JavaScript-uppsättningsmetoder du bör behärska idag

7. Symbol Datatyp i JavaScript

En symbol är ett unikt och oföränderligt primitivt värde. Det används främst för att skapa unika identifierare för objekt.

Du kan skapa en symbol med hjälp av Symbol() fungera. Den accepterar också en valfri beskrivning (namn), men endast för felsökningsändamål.

låt sym1 = Symbol();
let sym2 = Symbol("data");

De Symbol() funktion skapar ett nytt unikt värde varje gång den anropas, även om du skapar symboler med samma beskrivning, skulle värdena vara annorlunda.

console.log (Symbol() == Symbol());
console.log (Symbol("data") == Symbol("data"));

Produktion:

falsk
falsk

Relaterad: JavaScript-kartmetoder du bör behärska idag

8. Objektdatatyp i JavaScript

I JavaScript är objekt samlingar av nyckel-värdepar, där nyckeln är en sträng och värde kan vara vilken datatyp som helst.

Du kan skapa ett tomt objekt i JavaScript med syntaxen "objektkonstruktor" (nytt objekt()) eller syntaxen "objekt bokstavlig" (lockiga klammerparenteser {...}).

låt obj1 = nytt objekt();
låt obj2 = {};

Varje objekt innehåller en valfri lista med egenskaper, där en egenskap är ett nyckel: värdepar. Du kan komma åt värdena från objektet med hjälp av punktnotation eller arrayliknande notation (hakparenteser).

låt obj = {
"nyckel1": "värde1",
"key2": "value2"
}
console.log (obj.key1);
console.log (obj["nyckel2"]);

Produktion:

värde1
värde2

Hur fungerar JavaScript?

JavaScript är ett av de mest populära programmeringsspråken på webben idag. Du kan använda JavaScript för att skapa webbplatser, webbapplikationer, serverapplikationer, spel, mobilappar, etc. Det räcker med att säga att du kan göra nästan allt du kan tänka dig med JavaScript.

Men vet du hur JavaScript fungerar under huven?

Vad är JavaScript och hur fungerar det?

Om du lär dig webbutveckling, här är vad du behöver veta om JavaScript och hur det fungerar med HTML och CSS.

Läs Nästa

Om författaren