Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Podstawowe typy danych (string, number, boolean, null, undefined)

11 min czytania ·
W tej lekcji8

Jak w Parku Jurajskim mamy różne gatunki dinozaurów, każdy z unikalnymi cechami i zachowaniami, tak w JavaScript mamy różne typy danych, z których każdy służy konkretnym celom. Zrozumienie tych typów jest kluczowe dla skutecznego programowania - to jak znajomość różnic między Velociraptorem a Triceratopsem dla pracownika parku.

Typy pierwotne (primitive types)

JavaScript posiada pięć głównych typów pierwotnych: string, number, boolean, null i undefined. Są to podstawowe "gatunki" w naszym cyfrowym parku.

1. String - teksty

Typ string reprezentuje tekst - sekwencję znaków ujętą w pojedyncze ('), podwójne (") lub grawisowe (`) cudzysłowy. To jak tabliczki informacyjne w Parku Jurajskim, które przekazują odwiedzającym ważne komunikaty.

// Różne sposoby deklarowania stringów
const dinoName = "Tyrannosaurus Rex";
const warningSign = 'Uwaga! Nie zbliżaj się do ogrodzenia!';
const locationInfo = `Znajdujesz się w sektorze B4`;

// Stringi mogą zawierać specjalne znaki
const multilineWarning = "Uwaga!\nNie karm dinozaurów!";  // \n oznacza nową linię

// Długość stringa (liczba znaków)
const nameLength = dinoName.length;  // 17

// Łączenie stringów (konkatenacja)
const fullWarning = warningSign + " " + dinoName + " jest niebezpieczny!";

// Template literals (szablony tekstowe) - tylko z grawisami (``)
const modernWarning = `${warningSign} ${dinoName} jest niebezpieczny!`;

Stringi są jak uniwersalny język komunikacji w parku - służą do wyświetlania informacji, wysyłania wiadomości i etykietowania zasobów.

Metody stringów

Stringi w JavaScript posiadają wbudowane metody, które pozwalają na ich manipulację, podobnie jak pracownicy parku mają narzędzia do zarządzania ekspozycjami:

const species = "Velociraptor";

// Zmiana wielkości liter
const upperCase = species.toUpperCase();  // "VELOCIRAPTOR"
const lowerCase = species.toLowerCase();  // "velociraptor"

// Wyszukiwanie w stringu
const hasRaptor = species.includes("raptor");  // true
const position = species.indexOf("raptor");    // 6 (indeksy zaczynają się od 0)
const startsWith = species.startsWith("Velo"); // true
const endsWith = species.endsWith("tor");      // true

// Wycinanie fragmentów
const firstFour = species.substring(0, 4);     // "Velo"
const lastSix = species.slice(-6);             // "raptor"

// Zamiana fragmentów
const newSpecies = species.replace("Veloci", "Micro"); // "Microraptor"

// Podział stringa na tablicę
const announcement = "Uwaga! Wszyscy goście proszeni są o ewakuację!";
const words = announcement.split(" ");  // ["Uwaga!", "Wszyscy", "goście", ...]

2. Number - liczby

Typ number reprezentuje zarówno liczby całkowite, jak i zmiennoprzecinkowe (ułamki dziesiętne). W przeciwieństwie do wielu innych języków programowania, JavaScript nie rozróżnia tych dwóch rodzajów - wszystkie są po prostu number.

To jak system numeryczny w parku używany do wszystkiego - od liczenia dinozaurów po mierzenie ich wagi czy wysokości.

// Liczby całkowite
const dinoCount = 37;
const parkSectors = 12;

// Liczby zmiennoprzecinkowe (ułamki dziesiętne)
const trexHeight = 5.6;  // metry
const raptorSpeed = 38.5;  // km/h

// Notacja naukowa
const atomSize = 1.5e-10;  // 0.00000000015
const dinosaurCellCount = 3.2e12;  // 3,200,000,000,000

// Nieskończoność i NaN (Not a Number)
const infinity = Infinity;  // Wartość nieskończona
const negInfinity = -Infinity;  // Wartość ujemnie nieskończona
const notANumber = NaN;  // Wynik nieprawidłowej operacji matematycznej, np. 0/0

Operacje na liczbach

Liczby w JavaScript wspierają wszystkie standardowe operacje matematyczne, podobnie jak naukowcy w parku przeprowadzają różne obliczenia:

// Podstawowe operacje arytmetyczne
const sum = 10 + 5;    // 15 (dodawanie)
const diff = 10 - 5;   // 5 (odejmowanie)
const product = 10 * 5;  // 50 (mnożenie)
const quotient = 10 / 5;  // 2 (dzielenie)
const remainder = 10 % 3;  // 1 (modulo - reszta z dzielenia)
const power = 10 ** 2;  // 100 (potęgowanie - 10 do potęgi 2)

// Obiekt Math do zaawansowanych operacji
const roundedHeight = Math.round(trexHeight);  // 6 (zaokrąglenie)
const ceilingHeight = Math.ceil(trexHeight);   // 6 (zaokrąglenie w górę)
const floorHeight = Math.floor(trexHeight);    // 5 (zaokrąglenie w dół)
const randomNumber = Math.random();   // Losowa liczba między 0 a 1
const maxSpeed = Math.max(42, 35, 38, 40);  // 42 (najwyższa wartość)
const sqrtValue = Math.sqrt(25);  // 5 (pierwiastek kwadratowy)

Uwaga na dokładność liczb zmiennoprzecinkowych

W JavaScript (i wielu innych językach) liczby zmiennoprzecinkowe mogą prowadzić do nieoczekiwanych wyników, podobnie jak nieprzewidziane zachowania dinozaurów:

const precisionIssue = 0.1 + 0.2;  // Oczekujemy 0.3, ale dostajemy 0.30000000000000004

// Rozwiązanie - użycie zaokrąglenia lub stałej przeskalowanej:
const fixedResult = Number((0.1 + 0.2).toFixed(1));  // 0.3
const scaledResult = (0.1 * 10 + 0.2 * 10) / 10;  // 0.3

3. Boolean - wartości logiczne

Typ boolean ma tylko dwie możliwe wartości: true (prawda) lub false (fałsz). To jak system alarmowy w parku, który może być włączony lub wyłączony.

// Podstawowe wartości boolean
const fenceActive = true;
const parkClosed = false;

// Wyrażenia logiczne zwracają boolean
const isTRexDangerous = true;
const isParkOpen = !parkClosed;  // true (negacja)
const isSafeToEnter = fenceActive && isParkOpen;  // true (AND - i)
const needsAttention = !fenceActive || parkClosed;  // false (OR - lub)

Wartości boolean są kluczowe dla podejmowania decyzji w programie - podobnie jak systemy bezpieczeństwa w parku, które decydują, czy otworzyć bramę, uruchomić alarm czy ewakuować sektor.

// Użycie boolean w instrukcjach warunkowych
if (fenceActive) {
    console.log("Zagroda zabezpieczona");
} else {
    console.log("UWAGA! Zagroda niezabezpieczona!");
    activateEmergencyProtocol();
}

// Operatory porównania zwracają boolean
const isDangerousSpecies = dinosaurType === "Velociraptor" || dinosaurType === "T-Rex";
const isHerbivore = dinosaurDiet !== "mięsożerca";
const isTooBig = dinosaurHeight > 3;
const isInRange = visitorDistance >= 50;

4. null - celowy brak wartości

Wartość null reprezentuje celowy brak wartości - jest to jawne wskazanie, że zmienna nie zawiera żadnej wartości. To jak pusta zagroda w parku, specjalnie przygotowana, ale aktualnie bez dinozaura.

// Zmienna z wartością null
let selectedDinosaur = null;  // Aktualnie żaden dinozaur nie jest wybrany

// Null jest często używany jako wartość początkowa
let scannedChip = null;  // Przed skanowaniem chip nie zawiera danych

// Sprawdzanie, czy wartość to null
if (selectedDinosaur === null) {
    console.log("Żaden dinozaur nie został wybrany");
}

// Null jest wartością falsy
if (!selectedDinosaur) {
    console.log("To się również wyświetli dla null");
}

5. undefined - niezdefiniowana wartość

Wartość undefined oznacza, że zmienna została zadeklarowana, ale nie została jej przypisana żadna wartość. To jak niezagospodarowana działka w parku - istnieje, ale nie określono jeszcze, co na niej będzie.

// Zadeklarowana, ale niezainicjalizowana zmienna
let newDinosaur;  // automatycznie ma wartość undefined

// Funkcja bez jawnego return zwraca undefined
function checkEnclosure() {
    // Brak instrukcji return
}
const result = checkEnclosure();  // result ma wartość undefined

// Sprawdzanie, czy wartość to undefined
if (newDinosaur === undefined) {
    console.log("Dinozaur nie został jeszcze określony");
}

// undefined jest wartością falsy
if (!newDinosaur) {
    console.log("To się również wyświetli dla undefined");
}

Różnice między null i undefined

Choć oba typy reprezentują "brak wartości", istnieją między nimi ważne różnice:

  • null to celowy brak wartości (jak pusta zagroda)
  • undefined to niezamierzony brak wartości (jak nieprzydzielone miejsce)
// typeof pokazuje różnicę
typeof null;        // "object" (to jest historyczny błąd w JavaScript)
typeof undefined;   // "undefined"

// W kontekście równości
null == undefined;  // true (równość nieścisła)
null === undefined; // false (równość ścisła)

Symbol i BigInt - nowsze typy pierwotne

Nowsze wersje dodały dwa kolejne typy pierwotne: Symbol (ES2015) i BigInt (ES2020). Razem z pięcioma typami opisanymi wyżej JavaScript ma siedem typów pierwotnych.

Symbol - unikalny identyfikator

// Tworzenie unikalnych identyfikatorów
const dinoId = Symbol('dino-id');
const enclosureId = Symbol('enclosure-id');

// Każdy Symbol jest unikalny
const id1 = Symbol('id');
const id2 = Symbol('id');
console.log(id1 === id2);  // false, choć mają ten sam opis

BigInt - duże liczby całkowite

// Tworzenie BigInt przez dodanie 'n' na końcu liczby lub funkcję BigInt()
const dinoGenomeSize = 9007199254740991n;
const sameBigInt = BigInt(9007199254740991);

// BigInt może reprezentować liczby większe niż Number.MAX_SAFE_INTEGER
console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991

Sprawdzanie typu

Aby zidentyfikować typ danej wartości (podobnie jak identyfikacja gatunku dinozaura), możemy użyć operatora typeof:

typeof "Triceratops";  // "string"
typeof 42;            // "number"
typeof true;          // "boolean"
typeof null;          // "object" (uwaga: to jest historyczny błąd w JavaScript)
typeof undefined;     // "undefined"
typeof Symbol();      // "symbol"
typeof 42n;           // "bigint"

// Dla funkcji i obiektów
typeof function() {};  // "function"
typeof {};             // "object"
typeof [];             // "object" (tablice są obiektami w JavaScript)

Konwersja typów (type coercion)

JavaScript automatycznie konwertuje typy podczas operacji, co czasem może prowadzić do nieoczekiwanych rezultatów - podobnie jak nieoczekiwane zachowanie hybrydowych dinozaurów w parku.

// Automatyczna konwersja na string
"Dinozaur " + 5;  // "Dinozaur 5" (liczba 5 została skonwertowana na string)

// Automatyczna konwersja na number
"5" - 2;  // 3 (string "5" został skonwertowany na liczbę)
"5" * 2;  // 10 (string "5" został skonwertowany na liczbę)

// Automatyczna konwersja na boolean
if ("Dinozaur") {
    // Ten kod się wykona, bo niepusty string jest traktowany jako true
}

if (0) {
    // Ten kod się NIE wykona, bo 0 jest traktowane jako false
}

Wartości falsy i truthy

W JavaScript każda wartość może być skonwertowana na boolean. Wartości automatycznie konwertowane na false nazywamy "falsy", a te konwertowane na true - "truthy".

Wartości falsy:

  • false
  • 0
  • "" (pusty string)
  • null
  • undefined
  • NaN

Wszystkie inne wartości są truthy, w tym:

  • true
  • Każda liczba inna niż 0 (włącznie z ujemnymi i ułamkami)
  • Każdy niepusty string
  • Każdy obiekt, tablica i funkcja
// Przykłady konwersji na boolean
Boolean(0);        // false
Boolean("");       // false
Boolean(null);     // false
Boolean(undefined);// false
Boolean(NaN);      // false

Boolean(1);        // true
Boolean("text");   // true
Boolean([]);       // true (pusta tablica jest truthy)
Boolean({});       // true (pusty obiekt jest truthy)

Jawna konwersja typów

Aby uniknąć nieoczekiwanych rezultatów, zaleca się jawne konwertowanie typów - podobnie jak w Parku Jurajskim zawsze lepiej jest mieć pełną kontrolę nad dinozaurami:

// Konwersja na string
String(42);           // "42"
(42).toString();      // "42"
42 + "";              // "42" (używa niejawnej konwersji)

// Konwersja na number
Number("42");         // 42
parseInt("42", 10);   // 42 (druga liczba to system liczbowy, np. 10 dla dziesiętnego)
parseFloat("42.5");   // 42.5
+"42";                // 42 (używa niejawnej konwersji)

// Konwersja na boolean
Boolean(1);           // true
Boolean(0);           // false
!!"wartość";          // true (podwójna negacja)

Bezpieczne sprawdzanie typów

W rzeczywistych aplikacjach, podobnie jak w protokołach bezpieczeństwa parku, warto stosować rygorystyczne sprawdzanie typów:

// Sprawdzanie, czy zmienna jest stringiem
function isString(value) {
    return typeof value === 'string' || value instanceof String;
}

// Sprawdzanie, czy zmienna jest liczbą (z dodatkowym sprawdzeniem NaN)
function isNumber(value) {
    return typeof value === 'number' && !isNaN(value);
}

// Sprawdzanie, czy zmienna jest boolean
function isBoolean(value) {
    return typeof value === 'boolean';
}

// Sprawdzanie, czy zmienna ma wartość null
function isNull(value) {
    return value === null;
}

// Sprawdzanie, czy zmienna ma wartość undefined
function isUndefined(value) {
    return typeof value === 'undefined';
}

Praktyczny przykład: System inwentaryzacji dinozaurów

Poniższy przykład ilustruje użycie różnych typów danych w kompleksowym systemie:

// Stałe konfiguracyjne
const PARK_NAME = "Jurassic Park";
const MAX_CAPACITY = 50;
const SECURITY_LEVELS = {
    LOW: 1,
    MEDIUM: 2,
    HIGH: 3,
    CRITICAL: 4
};

// System inwentaryzacji dinozaurów
function processDinosaurData(dinoId, name, species, height, isDangerous) {
    // Sprawdzenie typów danych
    if (typeof dinoId !== 'number' || !Number.isInteger(dinoId) || dinoId <= 0) {
        return "Błąd: Nieprawidłowy ID dinozaura";
    }

    if (typeof name !== 'string' || name.trim() === '') {
        return "Błąd: Nieprawidłowa nazwa dinozaura";
    }

    if (typeof height !== 'number' || height <= 0) {
        return "Błąd: Nieprawidłowa wysokość dinozaura";
    }

    if (typeof isDangerous !== 'boolean') {
        return "Błąd: Parametr niebezpieczeństwa musi być typu boolean";
    }

    // Przetwarzanie danych
    let securityLevel = null;

    if (isDangerous) {
        securityLevel = height > 3 ? SECURITY_LEVELS.CRITICAL : SECURITY_LEVELS.HIGH;
    } else {
        securityLevel = height > 5 ? SECURITY_LEVELS.MEDIUM : SECURITY_LEVELS.LOW;
    }

    // Przygotowanie raportu dinozaura
    const dinoRecord = {
        id: dinoId,
        name: name,
        species: species || "Nieznany", // Zabezpieczenie przed undefined
        height: height,
        dangerous: isDangerous,
        securityLevel: securityLevel,
        enclosureType: getEnclosureType(securityLevel),
        lastUpdated: new Date().toISOString()
    };

    // Zwracamy raport
    return dinoRecord;
}

// Funkcja pomocnicza
function getEnclosureType(securityLevel) {
    switch(securityLevel) {
        case SECURITY_LEVELS.LOW:
            return "Otwarty wybieg";
        case SECURITY_LEVELS.MEDIUM:
            return "Standardowe ogrodzenie";
        case SECURITY_LEVELS.HIGH:
            return "Wzmocnione ogrodzenie z monitoringiem";
        case SECURITY_LEVELS.CRITICAL:
            return "Izolowana zagroda wysokiego bezpieczeństwa";
        default:
            return "Nieokreślony";
    }
}

// Przykład użycia
const trexData = processDinosaurData(
    1,
    "Rexy",
    "Tyrannosaurus Rex",
    5.6,
    true
);

console.log(trexData);

Podsumowanie

  1. String - reprezentuje tekst

    • Jak tabliczki informacyjne w parku
    • Ujęty w ', " lub `
    • Posiada wiele wbudowanych metod (np. toUpperCase(), indexOf())
  2. Number - reprezentuje liczby całkowite i zmiennoprzecinkowe

    • Jak system numeryczny w parku
    • Obsługuje wszystkie standardowe operacje matematyczne
    • Należy uważać na precyzję liczb zmiennoprzecinkowych
  3. Boolean - wartości logiczne true lub false

    • Jak system alarmowy (włączony/wyłączony)
    • Podstawa dla podejmowania decyzji (instrukcje warunkowe)
    • Powstaje też w wyniku operacji porównania
  4. null - celowy brak wartości

    • Jak pusta, przygotowana zagroda
    • Ustawiana jawnie przez programistę
    • Reprezentuje "nic" lub "nieznane"
  5. undefined - niezdefiniowana wartość

    • Jak nieprzydzielone jeszcze miejsce w parku
    • Pojawia się automatycznie dla niezainicjalizowanych zmiennych
    • Również jako domyślny wynik funkcji bez return

Zrozumienie typów danych w JavaScript jest fundamentem skutecznego programowania - podobnie jak znajomość różnych gatunków dinozaurów jest kluczowa dla pracowników Parku Jurajskiego. Każdy typ ma swoje zastosowania, ograniczenia i zachowania, które trzeba znać, aby uniknąć nieoczekiwanych "incydentów" w kodzie!

W następnej lekcji omówimy konwersję typów i operacje na typach danych - to jak nauczyć się bezpiecznej i efektywnej pracy z różnymi gatunkami dinozaurów w parku.

Kod do tej lekcji: index.js
// System Diagnostyczny - Funkcje
// Ćwiczenie: Tworzenie i wywoływanie funkcji

// Deklaracja funkcji
function checkDinosaur(name, health) {
  console.log("Badanie: " + name);
  if (health > 80) {
    return name + " - stan: DOSKONAŁY";
  } else if (health > 50) {
    return name + " - stan: DOBRY";
  } else {
    return name + " - stan: WYMAGA OPIEKI";
  }
}

// Wywołanie funkcji
console.log(checkDinosaur("T-Rex", 95));
console.log(checkDinosaur("Raptor", 72));
console.log(checkDinosaur("Brachio", 45));

// Funkcja z wartością domyślną
function feedDinosaur(name, amount = 50) {
  console.log(name + " nakarmiony: " + amount + " kg");
}

feedDinosaur("T-Rex", 200);
feedDinosaur("Compy"); // użyje domyślnej wartości 50

// Twoje zadanie:
// 1. Stwórz funkcję calculateAge(birthYear) obliczającą wiek
// 2. Stwórz funkcję z parametrem domyślnym
// 3. Wywołaj je z różnymi argumentami

// Twój kod tutaj:

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jakie wartości może przyjmować typ boolean w JavaScript?

  2. 2. Co zwróci typeof 42 w JavaScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zadeklaruj trzy zmienne opisujące próbkę DNA: nazwę gatunku (string), wagę w kilogramach (number) i to, czy dinozaur jest mięsożercą (boolean). Wyświetl w konsoli każdą zmienną razem z jej typem, używając typeof.

  1. PytanieTyp boolean
  2. PytanieOperator typeof
  3. Zadanie z kodemPraktyka: Typy danych

Przydatne artykuły