Datatyper i JavaScript

Den här artikeln förklarar datatyper i JavaScript.

YouTube Video

Datatyper i JavaScript

JavaScript har datatyper för att klassificera värden, som kan delas in i primitiva typer och objekttyper. Datatyper avgör vilken typ av data som lagras i en variabel och påverkar hur den kan hanteras.

Primitiva typer

Primitiva typer är enkla datatyper som representerar ett enda värde. JavaScript har följande 7 primitiva typer.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number är en typ som används för att hantera numeriska värden, inklusive heltal och flyttal (decimaler). Hantera värden som överstiger vissa gränser resulterar i Infinity eller NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• I JavaScript representeras siffror som flyttal. Som ett resultat kan vissa decimaltal (särskilt de som inte kan representeras exakt i binärt) inte uttryckas korrekt.
• När exakta beräkningar krävs, till exempel för monetära värden, är det nödvändigt att undvika sådana avrundningsfel. Till exempel kan du använda BigInt eller justera antalet decimaler med toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string är en datatyp som används för att hantera text och representerar en sekvens av tecken. Den representeras genom att omsluta texten med enkla citattecken (') eller dubbla citattecken ("). Från och med ES6 tillåter mallsträngar enkel inbäddning av variabler med hjälp av bakåtvända citattecken (). För att bädda in en variabel, använd syntaxen ${}.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean representerar ett logiskt värde och kan bara ha två värden: true eller false. Den används som resultat av villkorsuttryck eller som en flagga.

null

1let result = null;
2
3console.log("Value of result:", result);

• null är en datatyp som uttryckligen indikerar 'inget värde.'. null sätts av utvecklare för att indikera en avsiktlig tomhet.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined är en datatyp som betyder 'odefinierad.'. undefined tilldelas automatiskt när en variabel deklareras men inte tilldelas något värde.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint är en datatyp för att hantera stora heltal. bigint möjliggör en noggrann representation av stora heltal som inte kan representeras av typen number. bigint-bokstavsvärden representeras genom att lägga till n i slutet av ett tal.
• bigint är en typ för att hantera heltal av godtycklig storlek, utan begränsningar i omfånget. Dock kan bigint och number inte användas direkt tillsammans, så försiktighet krävs.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol är en datatyp som används för att skapa unika identifierare. Den skapas med Symbol() och kan användas som en egenskap hos ett objekt. Till skillnad från andra primitiva typer har Symbol unika värden, så även med samma innehåll behandlas det som en annan Symbol.

Objekttyper

Objekttyper är datastrukturer som kan lagra flera värden. Ett objekt är en samling av nyckel-värde-par och kan ha egenskaper och metoder.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object är en samling av egenskaper (nyckel-värdepar) som kan lagra olika typer av data. Objekt representeras av måsvingar {}, och varje egenskap förbinds av : mellan nyckeln och värdet.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array är en lista som innehåller flera värden i en ordnad form. Arrayer representeras av hakparenteser [], och värden separeras med kommatecken ,. Varje element nås med hjälp av ett index som börjar på 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Funktioner är en typ av objekt och återanvändningsbara kodblock. Funktioner kan definieras med nyckelordet function.

Andra objekttyper

• JavaScript har också inbyggda objekttyper som Date, RegExp, Map och Set. Dessa hanterar data enligt specifika användningsområden.

Typkonvertering

Implicit och explicit typkonverteringar utförs ofta i JavaScript.

Implicit typkonvertering

• JavaScript kan automatiskt konvertera typer vid operationer mellan olika typer.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• I det här exemplet omvandlas talet 5 implicit till en sträng, vilket resulterar i strängen "55".

Explicit typkonvertering

• Utvecklare kan också utföra typkonverteringar explicit.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• I det här exemplet används funktionen Number() för att explicit omvandla strängen "123" till talet 123.

Typkontroll

I JavaScript kan du använda operatorn typeof för att kontrollera datatypen för en variabel.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Slutsats

• Primitiva typer inkluderar number, string, boolean, null, undefined och symbol.
• Objekttyper inkluderar Object, Array, Function, bland andra.
• Eftersom både automatiska och explicita typkonverteringar sker är det viktigt att förstå rätt användning av datatyper.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video