Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Typy podstawowe (string, number, boolean, any, unknown)

7 min czytania ·
W tej lekcji12

Witaj z powrotem w naszej podróży po języku TypeScript w Parku Jurajskim! Dziś Dr. Henry Wu ma dla Ciebie szczególną lekcję. Tak jak kategoryzacja gatunków dinozaurów jest kluczowa dla ich właściwej hodowli i opieki, tak samo kategoryzacja danych w TypeScript jest fundamentalnym elementem pisania bezpiecznego kodu.

Dlaczego typy są ważne?

Bez odpowiedniej kategoryzacji, chaos szybko rozlałby się po Parku Jurajskim - wyobraź sobie karmienie drapieżników paszą dla roślinożerców lub umieszczenie małych, łagodnych gatunków w wybiegach wielkich drapieżników.

W programowaniu, typy pełnią podobną rolę - zapobiegają "mieszaniu gatunków" danych, które nie powinny być mieszane. Sprawdźmy podstawowe typy danych w TypeScript, wykorzystując przykłady związane z zarządzaniem parkiem.

String - ciągi znaków

Typ string w TypeScript reprezentuje teksty - nazwy gatunków, opisy, identyfikatory i inne dane tekstowe.

// Deklaracja zmiennych typu string
let nazwaGatunku: string = "Tyrannosaurus Rex";
let kodDNA: string = "ACGTTGCA";
let oznaczeniePaddocka: string = "P-12";

// Operacje na stringach
let pełnyOpis: string = `${nazwaGatunku} (kod DNA: ${kodDNA}) - wybieg ${oznaczeniePaddocka}`;
console.log(pełnyOpis.toUpperCase()); // Wyświetla: "TYRANNOSAURUS REX (KOD DNA: ACGTTGCA) - WYBIEG P-12"

Number - liczby

Typ number obsługuje zarówno liczby całkowite, jak i zmiennoprzecinkowe. Jest idealny do reprezentowania wieku dinozaurów, ich wagi, budżetu parku i innych wartości liczbowych.

// Deklaracja zmiennych typu number
let wiekDinozaura: number = 5; // w latach
let wagaDinozaura: number = 7500.5; // w kilogramach
let temperaturaCiała: number = 38.2; // w stopniach Celsjusza

// Operacje matematyczne
let dziennaRacjaŻywieniowa: number = wagaDinozaura * 0.05; // 5% wagi dziennie
let rocznyKosztUtrzymania: number = dziennaRacjaŻywieniowa * 365 * 10; // koszt karmy w dolarach

Boolean - wartości logiczne

Typ boolean reprezentuje wartości prawda/fałsz, idealne do śledzenia statusów, warunków czy flag w systemie parku.

// Deklaracja zmiennych typu boolean
let jestDrapieżnikiem: boolean = true;
let jestAktywny: boolean = false;
let jestDorosły: boolean = wiekDinozaura >= 3; // wartość wyliczona

// Zastosowanie w logice warunkowej
if (jestDrapieżnikiem && jestAktywny) {
  console.log("UWAGA: Aktywny drapieżnik! Sprawdź zabezpieczenia wybiegu!");
}

// Wykorzystanie w obiekcie konfiguracyjnym
let protokółBezpieczeństwa = {
  wymagaPodwójnegoOgrodzenia: jestDrapieżnikiem,
  wymagaMonitoringuNocnego: jestAktywny,
  dozwoloneDlaZwiedzających: !jestDrapieżnikiem || !jestAktywny
};

Any - dowolny typ

Typ any jest jak nieznany gatunek dinozaura, który może zachowywać się w nieprzewidywalny sposób. Pozwala na przypisanie dowolnej wartości do zmiennej i wykonywanie na niej dowolnych operacji - co może być niebezpieczne!

// Deklaracja zmiennych typu any
let próbkaBadawcza: any = "DNA-123";
próbkaBadawcza = 42; // Możemy zmienić typ na number
próbkaBadawcza = true; // Możemy zmienić typ na boolean
próbkaBadawcza = { typ: "krew", wiek: "nieznany" }; // Możemy zmienić typ na obiekt

// Niebezpieczne operacje
próbkaBadawcza.nieistniejącaMetoda(); // TypeScript nie zgłosi błędu!

UWAGA: Dr. Wu stanowczo odradza nadużywanie typu any - to jak wpuszczanie niezidentyfikowanych dinozaurów do parku bez odpowiednich zabezpieczeń! Używaj go tylko w ostateczności, gdy naprawdę nie wiesz, jakiego typu dane otrzymasz.

Unknown - nieznany typ, ale bezpieczniejszy

Typ unknown jest jak nowy gatunek dinozaura w kwarantannie - zanim go wypuścisz, musisz dokładnie sprawdzić jego właściwości.

// Deklaracja zmiennych typu unknown
let noweOdkrycie: unknown = pobierzDaneZWykopaliska();

// Nie możemy wykonywać operacji bezpośrednio
// noweOdkrycie.metoda(); // Error: Object is of type 'unknown'

// Musimy najpierw sprawdzić typ
if (typeof noweOdkrycie === "string") {
  console.log(noweOdkrycie.toUpperCase()); // OK
} else if (typeof noweOdkrycie === "number") {
  console.log(noweOdkrycie.toFixed(2)); // OK
} else if (noweOdkrycie instanceof DinoFragment) {
  console.log(noweOdkrycie.analizujDNA()); // OK
}

Typy literałowe - ograniczenie wartości

Typy literałowe (literal types) pozwalają na zdefiniowanie ścisłego zbioru dozwolonych wartości, co jest przydatne np. przy definiowaniu gatunków dinozaurów czy stref bezpieczeństwa.

// Typy literałowe
type GatunekDrapieżnika = "Tyrannosaurus" | "Velociraptor" | "Spinosaurus";
type PoziomZagrożenia = 1 | 2 | 3 | 4 | 5;
type StatusWybiegu = "aktywny" | "w konserwacji" | "zamknięty";

// Wykorzystanie typów literałowych
let obecnyDrapieżnik: GatunekDrapieżnika = "Velociraptor";
let zagrożenie: PoziomZagrożenia = 4;
let statusWybieguT: StatusWybiegu = "aktywny";

// Próba przypisania niedozwolonej wartości spowoduje błąd
// obecnyDrapieżnik = "Stegosaurus"; // Error: Type '"Stegosaurus"' is not assignable to type 'GatunekDrapieżnika'

Type Inference - automatyczne wykrywanie typów

TypeScript potrafi automatycznie wywnioskować typ zmiennej na podstawie przypisanej wartości, co pozwala na pisanie bardziej zwięzłego kodu.

// Automatyczne wykrywanie typów
let nazwaDino = "Blue"; // TypeScript wywnioskuje typ string
let wiek = 3; // TypeScript wywnioskuje typ number
let jestAktywna = true; // TypeScript wywnioskuje typ boolean

// TypeScript zapobiega błędnemu przypisaniu
// nazwaDino = 42; // Error: Type 'number' is not assignable to type 'string'

Union Types - typy unii

Union types pozwalają na określenie, że zmienna może przyjmować wartości kilku różnych typów, co jest przydatne w wielu scenariuszach parku.

// Deklaracja zmiennej, która może być string lub number
let identyfikator: string | number;

identyfikator = "TREX-001"; // OK
identyfikator = 12345; // OK
// identyfikator = true; // Error: Type 'boolean' is not assignable to type 'string | number'

// Funkcja obsługująca różne typy dinozaurów
function przetwórzDane(dane: string | number | boolean) {
  if (typeof dane === "string") {
    return dane.toUpperCase();
  } else if (typeof dane === "number") {
    return dane.toFixed(2);
  } else {
    return dane ? "AKTYWNY" : "NIEAKTYWNY";
  }
}

Null i Undefined

W TypeScript, null i undefined to specjalne wartości, które mogą być użyteczne do reprezentowania braku danych, np. gdy dinozaur jeszcze nie został oznaczony tagiem RFID.

// Z włączoną opcją strictNullChecks w tsconfig.json
let tagRFID: string | null = null; // Dinozaur jeszcze nie otrzymał tagu
let ostatniBadanie: Date | undefined; // Badanie jeszcze nie było przeprowadzone

// Sprawdzanie przed użyciem
function sprawdźStatus(dino: { nazwa: string, tag: string | null }) {
  if (dino.tag === null) {
    return `${dino.nazwa} nie posiada tagu RFID - wymaga oznaczenia`;
  } else {
    return `${dino.nazwa} oznaczony tagiem ${dino.tag}`;
  }
}

Praktyczne zastosowanie typów podstawowych

Rozważmy system monitorowania zdrowia dinozaurów, gdzie używamy różnych typów danych:

// Interfejs opisujący strukturę danych dinozaura
interface DaneDinozaura {
  id: number;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
  jestDrapieżnikiem: boolean;
  statusZdrowia: "dobry" | "średni" | "wymaga uwagi" | "krytyczny" | null;
  tagRFID: string | null;
  ostatnieBadanie: Date | undefined;
}

// Funkcja sprawdzająca, czy dinozaur wymaga interwencji weterynarza
function wymagaInterwencji(dino: DaneDinozaura): boolean {
  // Dinozaur wymaga interwencji, jeżeli:
  // - jego status zdrowia jest krytyczny
  // - nie miał badania w ciągu ostatnich 30 dni
  // - nie posiada tagu RFID

  const dzisiaj = new Date();
  const trzydzieściDniWstyecz = new Date();
  trzydzieściDniWstyecz.setDate(dzisiaj.getDate() - 30);

  return (
    dino.statusZdrowia === "krytyczny" ||
    dino.statusZdrowia === null ||
    dino.tagRFID === null ||
    (dino.ostatnieBadanie === undefined || dino.ostatnieBadanie < trzydzieściDniWstyecz)
  );
}

// Przykładowe wykorzystanie
const raptorBlue: DaneDinozaura = {
  id: 101,
  nazwa: "Blue",
  gatunek: "Velociraptor",
  wiek: 5,
  waga: 350,
  jestDrapieżnikiem: true,
  statusZdrowia: "dobry",
  tagRFID: "VR-101-BLUE",
  ostatnieBadanie: new Date("2023-08-15")
};

const trixie: DaneDinozaura = {
  id: 205,
  nazwa: "Trixie",
  gatunek: "Triceratops",
  wiek: 12,
  waga: 8500,
  jestDrapieżnikiem: false,
  statusZdrowia: "wymaga uwagi",
  tagRFID: "TC-205-TRIXIE",
  ostatnieBadanie: undefined
};

console.log(`Blue wymaga interwencji: ${wymagaInterwencji(raptorBlue)}`);
console.log(`Trixie wymaga interwencji: ${wymagaInterwencji(trixie)}`);

Podsumowanie

Właściwe używanie typów podstawowych w TypeScript jest jak precyzyjne zarządzanie różnymi gatunkami dinozaurów w Parku Jurajskim - zapewnia bezpieczeństwo i przewidywalność.

TypZastosowanie w Parku JurajskimPrzykład
stringNazwy, opisy, identyfikatory"Velociraptor", "P-12"
numberWiek, waga, koszty5, 7500.5, 38.2
booleanStatusy, warunki, flagitrue, false
anyDane o nieznanej strukturze (używaj z rozwagą!)System legacy, dane zewnętrzne
unknownBezpieczniejsza alternatywa dla anyDane, które wymagają walidacji
union typesWartości, które mogą być różnych typówstringnumbernull
literal typesOgraniczony zestaw wartości"aktywny""nieaktywny"

W następnej lekcji przyjrzymy się bardziej złożonym typom, takim jak tablice, krotki i enumeracje, które pozwolą nam na jeszcze lepsze modelowanie struktury danych naszego parku.

Dr. Henry Wu przypomina: "Tak jak w genetyce dinozaurów, w TypeScript precyzja typów jest kluczem do sukcesu i uniknięcia... niespodzianek."

Kod do tej lekcji: index.ts
// Typy podstawowe w Parku Jurajskim
console.log("Typy podstawowe TypeScript\n");

// ===========================================
// 1. STRING - teksty
// ===========================================
console.log("=== TYP STRING ===");

let species: string = "Tyrannosaurus Rex";
let dnaCode: string = "ACGTTGCA";
let paddockId: string = "P-12";

// Template literals
let fullDescription: string = `${species} (DNA: ${dnaCode}) - Paddock ${paddockId}`;
console.log(fullDescription);
console.log(`Uppercase: ${species.toUpperCase()}`);

// ===========================================
// 2. NUMBER - liczby
// ===========================================
console.log("\n=== TYP NUMBER ===");

let age: number = 5; // lata
let weight: number = 7500.5; // kg
let temperature: number = 38.2; // °C
let hexValue: number = 0xFF; // 255
let binaryValue: number = 0b1010; // 10

console.log(`Age: ${age} years`);
console.log(`Weight: ${weight}kg`);
console.log(`Temperature: ${temperature}°C`);

// Operacje matematyczne
let dailyFeed: number = weight * 0.05;
let yearlyFeedCost: number = dailyFeed * 365 * 10;
console.log(`Daily feed: ${dailyFeed}kg`);
console.log(`Yearly cost: $${yearlyFeedCost}`);

// ===========================================
// 3. BOOLEAN - wartości logiczne
// ===========================================
console.log("\n=== TYP BOOLEAN ===");

let isCarnivore: boolean = true;
let isActive: boolean = false;
let isAdult: boolean = age >= 3;
let isHungry: boolean = true;
let isDangerous: boolean = isCarnivore && isHungry;

console.log(`Is carnivore: ${isCarnivore}`);
console.log(`Is active: ${isActive}`);
console.log(`Is adult: ${isAdult}`);
console.log(`Is dangerous: ${isDangerous}`);

// Logika warunkowa
if (isDangerous) {
  console.log("Security level: CRITICAL");
} else {
  console.log("Security level: NORMAL");
}

// ===========================================
// 4. ANY - dowolny typ (unikaj!)
// ===========================================
console.log("\n=== TYP ANY ===");

let mysteryData: any = "unknown";
mysteryData = 123; // OK
mysteryData = true; // OK
mysteryData = { type: "fossil" }; // OK

console.log("ANY nie sprawdza typów - używaj ostrożnie!");
console.log("Mystery data:", mysteryData);

// ===========================================
// 5. UNKNOWN - bezpieczniejszy any
// ===========================================
console.log("\n=== TYP UNKNOWN ===");

let unknownData: unknown = "mysterious DNA sequence";

// Musimy sprawdzić typ przed użyciem
if (typeof unknownData === 'string') {
  console.log("Unknown data length:", unknownData.length);
} else {
  console.log("Not a string");
}

console.log("UNKNOWN wymaga sprawdzenia typu");

// ===========================================
// 6. NULL i UNDEFINED
// ===========================================
console.log("\n=== NULL I UNDEFINED ===");

let emptyValue: null = null;
let notInitialized: undefined = undefined;

let optionalSpecies: string | null = null; // może być string lub null
let optionalAge: number | undefined; // może być number lub undefined

console.log("Empty value:", emptyValue);
console.log("Not initialized:", notInitialized);
console.log("Optional species:", optionalSpecies);
console.log("Optional age:", optionalAge);

// Sprawdzanie null/undefined
function displaySpecies(s: string | null): void {
  if (s !== null) {
    console.log(`Species: ${s}`);
  } else {
    console.log("Species unknown");
  }
}

displaySpecies(species);
displaySpecies(null);

// ===========================================
// 7. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("string - teksty i znaki");
console.log("number - liczby (int, float, hex, binary)");
console.log("boolean - true/false");
console.log("any - dowolny typ (unikaj)");
console.log("unknown - bezpieczniejszy any");
console.log("null - brak wartości");
console.log("undefined - niezainicjalizowane");

console.log("\nTypy podstawowe opanowane!");

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. Co robi operator : po nazwie zmiennej w TypeScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zdefiniuj zmienne z typami string, number i boolean opisujące dinozaura.

  • Układanie w poziomie

    Ułóż elementy deklaracji zmiennej z typem w TypeScript:

  • Klikanie w kolejności

    Ułóż elementy funkcji TypeScript z typami:

  1. PytanieType annotation
  2. Zadanie z kodemPraktyka: Typy podstawowe
  3. Ułóż w kolejnościSkładnia type annotation
  4. Kliknij w kolejnościSortowanie: Type annotation dla funkcji

Przydatne artykuły