Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Typy podstawowe (string, number, boolean, any, unknown)
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 dolarachBoolean - 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ść.
| Typ | Zastosowanie w Parku Jurajskim | Przykład | ||
|---|---|---|---|---|
| string | Nazwy, opisy, identyfikatory | "Velociraptor", "P-12" | ||
| number | Wiek, waga, koszty | 5, 7500.5, 38.2 | ||
| boolean | Statusy, warunki, flagi | true, false | ||
| any | Dane o nieznanej strukturze (używaj z rozwagą!) | System legacy, dane zewnętrzne | ||
| unknown | Bezpieczniejsza alternatywa dla any | Dane, które wymagają walidacji | ||
| union types | Wartości, które mogą być różnych typów | string | number | null |
| literal types | Ograniczony 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. 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: