Skalarne typy danych w JavaScript

Wprowadzenie do typów skalarnych

W JavaScript skalarne typy danych (ang. primitive types) to podstawowe, niepodzielne wartości, które nie są obiektami i nie mają metod ani właściwości. Są one przechowywane bezpośrednio w pamięci i przekazywane przez wartość.

JavaScript wyróżnia 7 typów skalarnych oraz jeden typ złożony (object), do którego należą tablice, obiekty, funkcje itp.

Typy skalarne w JavaScript
1. Number

Reprezentuje zarówno liczby całkowite, jak i zmiennoprzecinkowe. JavaScript używa 64-bitowego formatu IEEE 754.

let liczbaCalkowita = 42;
let liczbaZmiennoprzecinkowa = 3.14;
let naukowa = 1.5e3; // 1500
let nieskonczonosc = Infinity;
let nieLiczba = NaN; // Not a Number
Uwaga: W JavaScript nie ma oddzielnych typów dla liczb całkowitych i zmiennoprzecinkowych.
2. String

Reprezentuje tekst. Może być zapisany w pojedynczych lub podwójnych cudzysłowach.

let imie = 'Tadeusz';
let nazwisko = "Graczyk";
let pelneImie = `Tadeusz Graczyk`; // Template literal (ES6)
let tekstWieloliniowy = `To jest wieloliniowy tekst`;
Template literals: Pozwalają na łatwe wstawianie zmiennych (${zmienna}) i tworzenie tekstów wieloliniowych.
3. Boolean

Reprezentuje wartości logiczne: true lub false.

let jestPrawda = true;
let jestFalsz = false;
let wynik = 5 > 3; // true
4. Undefined

Reprezentuje zmienną, która została zadeklarowana, ale nie została przypisana żadna wartość.

let nieokreslona;
console.log(nieokreslona); // undefined
5. Null

Reprezentuje celowe brak wartości. Jest to jedyny typ, który ma tylko jedną wartość: null.

let nic = null;
console.log(nic); // null
Różnica między null i undefined: undefined oznacza, że zmienna nie została zdefiniowana, natomiast null oznacza, że zmienna została celowo ustawiona na brak wartości.
6. Symbol

Reprezentuje unikalną i niepowtarzalną wartość. Symbol jest używany głównie jako klucz w obiektach.

let symbol1 = Symbol();
let symbol2 = Symbol('opis');
let symbol3 = Symbol('opis'); // symbol3 !== symbol2
Zastosowanie: Symbole są używane głównie do tworzenia unikalnych kluczy w obiektach, które nie będą kolidować z innymi właściwościami.
7. BigInt

Reprezentuje liczby całkowite o dowolnej precyzji. Jest używany do operacji na bardzo dużych liczbach.

let duzaLiczba = 123456789012345678901234567890n;
let innaDuza = BigInt("123456789012345678901234567890");
Uwaga: Liczby BigInt są oznaczone literą n na końcu. Nie można ich mieszać z zwykłymi liczbami (number).
Operacje na typach skalarnych
Konwersja typów (Type Coercion)

JavaScript automatycznie konwertuje typy w niektórych sytuacjach:

console.log(5 + "3"); // "53" (konwersja liczby na string)
console.log("5" - 3); // 2 (konwersja stringa na liczbę)
console.log("5" == 5); // true (luźne porównanie)
console.log("5" === 5); // false (ścisłe porównanie)
Jawna konwersja typów
// Na string
let liczba = 42;
let tekst = String(liczba); // "42"
tekst = liczba.toString(); // "42"
tekst = liczba + ""; // "42"
// Na liczbę
let str = "42";
let num = Number(str); // 42
num = parseInt(str); // 42
num = +str; // 42
// Na boolean
let wartosc = "tekst";
let bool = Boolean(wartosc); // true
bool = !!wartosc; // true
Sprawdzanie typów

JavaScript oferuje kilka sposobów na sprawdzanie typów zmiennych:

1. Operator typeof
console.log(typeof 42); // "number"
console.log(typeof "tekst"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (błąd historyczny)
console.log(typeof {}); // "object"
console.log(typeof function() {}); // "function"
Uwaga: typeof null zwraca "object" - to historyczny błąd w JavaScript.
2. Instancja instanceof
console.log([] instanceof Array); // true
console.log({} instanceof Object); // true
console.log(new Date() instanceof Date); // true
3. Metoda Array.isArray()
console.log(Array.isArray([])); // true
console.log(Array.isArray({})); // false
Metody dostępne dla typów skalarnych

Chociaż typy skalarne nie są obiektami, JavaScript udostępnia metody dla niektórych z nich dzięki mechanizmowi autoboxing:

Metody dla String
let tekst = "Hello World";
console.log(tekst.length); // 11
console.log(tekst.toUpperCase()); // "HELLO WORLD"
console.log(tekst.substring(0, 5)); // "Hello"
console.log(tekst.includes("World")); // true
Metody dla Number
let liczba = 3.14159;
console.log(liczba.toFixed(2)); // "3.14"
console.log(liczba.toString()); // "3.14159"
console.log(Number.isNaN(NaN)); // true
console.log(Number.isInteger(42)); // true
Podsumowanie

Skalarne typy danych w JavaScript to fundament, na którym budowane są wszystkie programy w tym języku. Zrozumienie tych typów, ich zachowania i sposobów konwersji między nimi jest kluczowe dla pisania poprawnego i przewidywalnego kodu.

Pamiętaj, że:

  • Typy skalarne są przekazywane przez wartość.
  • JavaScript jest językiem słabo typowanym - typy są sprawdzane w czasie wykonania.
  • Konwersja typów może być automatyczna (implicit) lub jawną (explicit).
  • Typ null i undefined często powodują błędy - warto je rozróżniać.
```