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 is a string
let x = "Hello, World";
// x is a number
x = 100;
// x is now a boolean
x = true;
Om du vill hitta den aktuella datatypen för en variabel, använd sorts operatör.
// x is a string
let x = "Hello, World";
console.log(typeof(x));
// x is a number
x = 100;
console.log(typeof(x));
// x is now a boolean
x = true;
console.log(typeof(x));
Produktion:
string
number
boolean
1. Nummerdatatyp i JavaScript
Nummerdatatypen i JavaScript använder formatet IEEE-754 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 det inbyggda Math-objektet.
Några exempel för att skapa siffror i JavaScript:
// Using literal declaration
let n1 = 100;
let n2 = 456.234;
// Using the Number() constructor
let n3 = Number(100);
// Conversion to integer
let n4 = Number.parseInt("456.234");
// Conversion to float
let n5 = Number.parseFloat("456.234");
let n6 = Number.parseFloat("1.13e3");
// Unary conversion to number
let 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:
let 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).
let 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).
let x = 0x53;
console.log(x);
Produktion:
83
Flyttalssiffror
Följande sats skapar en variabel som innehåller ett flyttal:
let x = 324.56;
Du kan använda e-notation för att representera mycket stora eller mycket små tal.
let 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.
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 fakulteten av stora tal, representera solens massa, tidsstämplar med mikrosekunders precision och så vidare, är BigInt vad du vill 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.
let big1 = 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. Boolesk datatyp i JavaScript
Den booleska datatypen kan ha två värden: Sann och falsk. Booleska värden är resultatet av logiska jämförelser.
let x1 = true;
console.log(x1);
let x2 = !true;
console.log(x2);
let x3 = !!true;
console.log(x3);
let x4 = (false && true);
console.log(x4);
let x5 = (false || true);
console.log(x5);
let x6 = (2 == "2");
console.log(x6);
let x7 = (2 === "2");
console.log(x7);
let x8 = (null === undefined);
console.log(x8);
let x9 = (0 == "");
console.log(x9);
let x10 = (100 > 12);
console.log(x10);
Produktion:
true
false
true
false
true
true
false
false
true
true
Du kan konvertera ett värde av vilken annan datatyp som helst till en boolesk datatyp med hjälp av Boolean() fungera.
// Strings
console.log(Boolean(''));
console.log(Boolean('abc'));
console.log(Boolean('123'));
// Numbers
console.log(Boolean(0));
console.log(Boolean(1));
console.log(Boolean(-1));
console.log(Boolean(NaN));
console.log(Boolean(Infinity));
// Others
console.log(Boolean([1, 2, 3]));
console.log(Boolean(undefined));
console.log(Boolean(null));
Produktion:
false
true
true
false
true
true
false
true
true
false
false
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.
let str1 = "Hi";
let str2 = 'Hi';
let str3 = "How're you?";
// Using to escape the single quote (')
let str4 = 'How're you?';
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.
// Embedding variable within a string
let x = "Hello";
let str1 = `${x}, How're you?`;
console.log(str1);
// Embedding expression within a string
let str2 = `Sum of 20 + 30 is: ${20 + 30}`;
console.log(str2);
// Embedding function call within a string
function calculateSum(a, b) {
return a + b;
}
let str3 = `Sum of 20 + 30 is: ${calculateSum(20, 30)}`;
console.log(str3);
Produktion:
Hello, How're you?
Sum of 20 + 30 is: 50
Sum of 20 + 30 is: 50
JavaScript tillhandahåller också flera strängmetoder för 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.
let n = null;
Många programmerare blir förvirrade mellan null och odefinierad. Det är svårt 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.
let x;
console.log(typeof(x));
Produktion:
undefined
Du kan uttryckligen tilldela odefinierad till en variabel, men det rekommenderas starkt att undvika det.
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.
let 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:
false
false
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 {…}).
let obj1 = new Object();
let obj2 = {};
Varje objekt innehåller en valfri lista med egenskaper, där en egenskap är ett nyckel:värde-par. Du kan komma åt värdena från objektet med hjälp av punktnotation eller arrayliknande notation (hakparenteser).
let obj = {
"key1" : "value1",
"key2" : "value2"
}
console.log(obj.key1);
console.log(obj["key2"]);
Produktion:
value1
value2
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 vad du kan med JavaScript.
Men vet du hur JavaScript fungerar under huven?
Om författaren
Yuvraj Chandra (80 artiklar publicerade)
Yuvraj är en datavetenskapsstudent vid University of Delhi, Indien. Han brinner för Full Stack Web Development. När han inte skriver undersöker han djupet i olika teknologier.
Mer från Yuvraj Chandra
Prenumerera på vårt nyhetsbrev
Gå med i vårt nyhetsbrev för tekniska tips, recensioner, free e-böcker och exklusiva erbjudanden!
Klicka här för att prenumerera
