Typy danych w JavaScript

Ten artykuł wyjaśnia typy danych w JavaScript.

YouTube Video

Typy danych w JavaScript

JavaScript posiada typy danych do klasyfikowania wartości, które można ogólnie podzielić na typy prymitywne i typy obiektowe. Typy danych określają, jaki rodzaj danych jest przechowywany w zmiennej i wpływają na to, jak można nimi manipulować.

Typy Prymitywne

Typy prymitywne to proste typy danych reprezentujące pojedynczą wartość. JavaScript posiada następujące 7 typów prymitywnych.

number

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

• number to typ używany do obsługi wartości liczbowych, w tym liczb całkowitych i zmiennoprzecinkowych (dziesiętnych). Obsługa wartości przekraczających pewne limity skutkuje Infinity lub 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

• W JavaScript liczby są reprezentowane jako liczby zmiennoprzecinkowe. W rezultacie niektóre wartości dziesiętne (zwłaszcza te, które nie mogą być precyzyjnie reprezentowane w systemie binarnym) mogą nie być dokładnie odwzorowane.
• Gdy wymagane są precyzyjne obliczenia, na przykład w przypadku wartości pieniężnych, należy unikać takich błędów zaokrąglania. Na przykład można użyć BigInt lub dostosować liczbę miejsc dziesiętnych za pomocą 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 to typ danych używany do obsługi tekstu, reprezentujący ciąg znaków. Reprezentuje się go przez umieszczanie tekstu w pojedynczych (') lub podwójnych (") cudzysłowach. Od ES6 wprowadzono szablony napisów, które umożliwiają łatwe wstawianie zmiennych za pomocą odwrotnych apostrofów (). Aby wstawić zmienną, użyj składni ${}.

boolean

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

• boolean reprezentuje wartość logiczną i może przyjmować tylko dwie wartości: true lub false. Jest używany jako wynik wyrażeń warunkowych lub jako flaga.

null

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

• null to typ danych, który wyraźnie oznacza 'brak wartości.'. null jest ustawiane przez programistów w celu wskazania zamierzonej pustki.

undefined

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

• undefined to typ danych oznaczający 'niezdefiniowany.'. undefined jest automatycznie przypisywane, gdy zmienna została zadeklarowana, ale nie przypisano jej wartości.

bigint

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

• bigint to typ danych służący do obsługi dużych liczb całkowitych. bigint umożliwia precyzyjne przedstawienie dużych liczb całkowitych, które nie mogą być reprezentowane za pomocą typu number. Literały bigint są reprezentowane przez dodanie n na końcu liczby.
• bigint to typ przeznaczony do obsługi liczb całkowitych o dowolnym rozmiarze, bez ograniczeń zakresu. Jednak bigint i number nie mogą być bezpośrednio używane razem w operacjach, co wymaga ostrożności.

Symbol

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

• Symbol to typ danych używany do tworzenia unikalnych identyfikatorów. Powstaje przy użyciu Symbol() i może być używany jako właściwość obiektu. W przeciwieństwie do innych typów prymitywnych, Symbol ma unikalne wartości, więc nawet z taką samą zawartością jest traktowany jako inny Symbol.

Typy Obiektowe

Typy obiektowe to struktury danych, które mogą przechowywać wiele wartości. Obiekt to zbiór par klucz-wartość, który może posiadać właściwości i metody.

Object

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

• Object to zbiór właściwości (par klucz-wartość), który może przechowywać różne rodzaje danych. Obiekty są reprezentowane przez nawiasy klamrowe {}, a każda właściwość jest połączona znakiem : pomiędzy kluczem a wartością.

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 to lista przechowująca wiele wartości w uporządkowany sposób. Tablice są reprezentowane przez nawiasy kwadratowe [], a wartości są oddzielone przecinkami ,. Do każdego elementu można uzyskać dostęp za pomocą indeksu, który zaczyna się od 0.

Function

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

• Funkcje są typem obiektu i wielokrotnego użytku blokami kodu. Funkcje można definiować za pomocą słowa kluczowego function.

Inne Typy Obiektowe

• JavaScript posiada również wbudowane typy obiektowe, takie jak Date, RegExp, Map i Set. Służą one do obsługi danych zgodnie z konkretnymi przypadkami użycia.

Konwersja Typów

Niejawne i jawne konwersje typów są często wykonywane w JavaScript.

Niejawna Konwersja Typów

• JavaScript może automatycznie konwertować typy podczas wykonywania operacji pomiędzy różnymi typami.

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

• W tym przykładzie liczba 5 jest niejawnie konwertowana na ciąg znaków, co daje ciąg znaków "55".

Jawna Konwersja Typów

• Programiści mogą również wykonywać konwersje typów w sposób jawny.

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

• W tym przykładzie funkcja Number() jest używana do jawnej konwersji ciągu znaków "123" na liczbę 123.

Sprawdzanie Typów

W JavaScript można użyć operatora typeof, aby sprawdzić typ danych zmiennej.

 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 () {});

Wniosek

• Typy prymitywne obejmują number, string, boolean, null, undefined i symbol.
• Typy obiektowe obejmują Object, Array, Function i inne.
• Ponieważ występują zarówno automatyczne, jak i jawne konwersje typów, ważne jest zrozumienie właściwego użycia typów danych.

Możesz śledzić ten artykuł, korzystając z Visual Studio Code na naszym kanale YouTube. Proszę również sprawdzić nasz kanał YouTube.

YouTube Video