Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Czym jest TypeScript i jego zalety
W tej lekcji6
Wprowadzenie: Problem z parkiem dinozaurów
Witaj w nowym rozdziale naszej przygody w Parku Jurajskim! Wyobraź sobie następującą sytuację: programiści parku stworzyli system kontroli dostępu do zagród dinozaurów, który miał chronić zarówno gości, jak i pracowników. Wszystko działało świetnie, dopóki w pewnym momencie...
// system-kontroli-dostępu.js
function przyznajDostep(pracownik, poziomDostępu) {
if (pracownik.uprawnienia >= poziomDostępu) {
return true;
}
return false;
}
// W innym miejscu systemu
const drMalcolm = {
imie: "Ian",
nazwisko: "Malcolm",
rola: "Matematyk"
// ups... brak pola 'uprawnienia'!
};
// Próba dostępu do zagrody dinozaurów
const dostępDoT_Rex = przyznajDostep(drMalcolm, 5);
console.log("Dostęp do zagrody T-Rex:", dostępDoT_Rex); // false, ale bez błędu!
// Później w kodzie...
if (dostępDoT_Rex) {
otworz_brame_do_zagrody('t-rex'); // Ta operacja nigdy nie zostanie wykonana
} else {
console.log("Dr Malcolm nie ma dostępu"); // To się wykona, ale nikt nie zauważył błędu
}Czy zauważyłeś, co poszło nie tak? W obiekcie drMalcolm zabrakło właściwości uprawnienia, przez co system niepoprawnie odmówił mu dostępu! W JavaScript ta sytuacja nie wygenerowała żadnego błędu - po prostu właściwość uprawnienia była undefined, co przy porównaniu z liczbą dało wynik false.
Wyobraź sobie teraz konsekwencje takiej sytuacji w prawdziwym parku dinozaurów:
- Dr Malcolm nie może wejść do swojej strefy pracy
- Systemy bezpieczeństwa nie działają jak powinny
- Co gorsza - nikt nie wie, że istnieje problem!
To właśnie w takich sytuacjach przydaje się TypeScript.
Czym jest TypeScript?
TypeScript to nadzbiór (superset) języka JavaScript, który dodaje opcjonalne statyczne typowanie. Został stworzony przez Microsoft i jest rozwijany jako projekt open source.
Wyobraź sobie TypeScript jako zaawansowany system bezpieczeństwa dla Parku Jurajskiego:
- JavaScript to park bez kamer i czujników - wszystko działa, dopóki nic złego się nie wydarzy
- TypeScript to park wyposażony w kamery, czujniki ruchu i system alarmowy, który wykrywa problemy ZANIM dinozaury uciekną z wybiegów
Ta sama sytuacja w TypeScript wyglądałaby tak:
// system-kontroli-dostępu.ts
// Definiujemy interfejs określający, jak powinien wyglądać obiekt pracownika
interface Pracownik {
imie: string;
nazwisko: string;
rola: string;
uprawnienia: number; // Wymagane pole!
}
function przyznajDostep(pracownik: Pracownik, poziomDostępu: number): boolean {
if (pracownik.uprawnienia >= poziomDostępu) {
return true;
}
return false;
}
// W innym miejscu systemu
const drMalcolm = {
imie: "Ian",
nazwisko: "Malcolm",
rola: "Matematyk"
// TypeScript wyłapie błąd: Property 'uprawnienia' is missing in type
// '{ imie: string; nazwisko: string; rola: string; }' but required in type 'Pracownik'.
};
// Ta linia spowoduje błąd kompilacji - TypeScript nas ochroni!
const dostępDoT_Rex = przyznajDostep(drMalcolm, 5);W powyższym przykładzie TypeScript wykryje błąd już na etapie pisania kodu, zanim oprogramowanie zostanie uruchomione. To jak system ostrzegający nas, że drzwi do zagrody są otwarte, zanim dinozaur zdąży uciec!
Najważniejsze zalety TypeScript
1. Wykrywanie błędów na wczesnym etapie
Podobnie jak system monitoringu w Parku Jurajskim, TypeScript wykrywa potencjalne problemy jeszcze na etapie pisania kodu:
function nakarmDinozaura(dinozaur: { gatunek: string; dietaTyp: string; }): void {
let jedzenie;
if (dinozaur.dietaTyp === 'roślinożerny') {
jedzenie = 'liście paproci';
} else if (dinozaur.dietaTyp === 'mięsożerny') {
jedzenie = 'mięso';
}
console.log(`Karmienie ${dinozaur.gatunek}a jedzeniem: ${jedzenie}`);
}
// TypeScript ostrzeże, że literówka 'roslinozerca' nie pasuje do żadnego warunku
const triceratops = { gatunek: 'Triceratops', dietaTyp: 'roslinozerca' };
nakarmDinozaura(triceratops);
// Bez TypeScript ten dinozaur dostałby "undefined" jako jedzenie!2. Lepsza dokumentacja kodu
TypeScript działa jak dokładny inwentarz wszystkich dinozaurów w parku:
// Bez TypeScript - co to są za parametry? Co zwraca ta funkcja?
function utworzWybieg(id, nazwa, pojemnosc, typOgrodzenia) {
//
}
// Z TypeScript - natychmiastowa dokumentacja!
function utworzWybieg(
id: number,
nazwa: string,
pojemnosc: number,
typOgrodzenia: 'standardowe' | 'elektryczne' | 'wzmocnione'
): { id: number; status: 'aktywny' | 'w budowie' | 'zamknięty' } {
//
return { id, status: 'w budowie' };
}3. Lepsze wsparcie IDE (podpowiadanie kodu)
Dzięki TypeScript, twoje środowisko programistyczne (IDE) będzie dokładnie wiedzieć, jakie operacje możesz wykonać na danym obiekcie:
const dinosaur = { name: 'Rex', species: 'T-Rex', weight: 8000 }
dinosaur.name.toUpperCase() // po kropce edytor podpowiada name, species i weight, a po drugiej kropce metody stringa
dinosaur.height // błąd: Property 'height' does not exist on type '{ name: string; species: string; weight: number; }'To jak mapa Parku Jurajskiego z dokładnymi wskazówkami, gdzie znajdują się poszczególne wybiegi i jakie dinozaury są w nich trzymane.
4. Bezpieczniejsze refaktoryzacje
Kiedy wprowadzasz zmiany w systemie zarządzania parkiem, TypeScript ostrzega cię o wszystkich miejscach, które wymagają aktualizacji:
// Przed refaktoryzacją
interface Dinozaur {
id: number;
gatunek: string;
niebezpieczny: boolean;
}
// Po refaktoryzacji - zmiana typu pola
interface Dinozaur {
id: number;
gatunek: string;
poziomZagrozenia: number; // od 1 do 10 zamiast boolean
}
// TypeScript wskaże wszystkie miejsca, gdzie używaliśmy "niebezpieczny"
// i teraz musimy użyć "poziomZagrozenia"5. Typy dla bibliotek zewnętrznych
Nawet jeśli używasz zewnętrznych bibliotek napisanych w czystym JavaScript, możesz korzystać z plików definicji typów, które zapewniają podpowiadanie kodu i kontrolę typów:
// Instalacja typów dla biblioteki do analizy DNA
// npm install --save-dev @types/dino-dna-analyzer
import { analizujDNA } from 'dino-dna-analyzer';
// Teraz TypeScript zna typy parametrów i zwracanych wartości
const wynik = analizujDNA({
sekwencja: 'ACGTACGT',
gatunekBazowy: 'żaba'
});
console.log(wynik.kompletnosc); // TypeScript zna dostępne pola6. Wsparcie dla nowoczesnych funkcji JavaScript
TypeScript pozwala korzystać z najnowszych funkcji JavaScript, nawet jeśli docelowe środowisko ich nie obsługuje:
// Użycie nowoczesnej składni JavaScript
const dinozaury = ['T-Rex', 'Velociraptor', 'Triceratops'];
const [najgrozniejszy, ...pozostale] = dinozaury;
// Optional chaining i nullish coalescing
const dane = {
park: {
// sektor może nie istnieć
}
};
const nazwaSektora = dane.park?.sektor?.nazwa ?? "Nieznany sektor";7. Stopniowa migracja
Jedną z największych zalet TypeScript jest możliwość stopniowego wprowadzania go do istniejących projektów JavaScript:
- Zmień rozszerzenie pliku z
.jsna.ts - Początkowo ignoruj błędy za pomocą
// @ts-ignorelub używając typuany - Stopniowo dodawaj typy do kodu, zaczynając od najbardziej krytycznych części
To jak stopniowe usprawnianie systemów bezpieczeństwa w Parku Jurajskim, sektor po sektorze, zamiast zamykania całego parku na czas modernizacji.
Ograniczenia TypeScript
Oczywiście, jak każda technologia, TypeScript ma swoje ograniczenia:
- Dodatkowy etap kompilacji - kod TypeScript musi zostać przekonwertowany na JavaScript przed uruchomieniem
- Stroma krzywa uczenia - dla początkujących programistów JavaScript, nauka typów może być wyzwaniem
- Fałszywe poczucie bezpieczeństwa - TypeScript wykrywa błędy związane z typami, ale nie chroni przed błędami logicznymi
- Typ
any- można "oszukać" system typów używającany, co niweluje zalety TypeScript
Kiedy warto użyć TypeScript?
TypeScript sprawdza się najlepiej w następujących scenariuszach:
- Duże projekty z wieloma programistami - jak zarządzanie całym Parkiem Jurajskim
- Długotrwałe projekty - gdy kod będzie utrzymywany przez długi czas
- Kompleksowe aplikacje biznesowe - gdy błędy mogą mieć poważne konsekwencje
- Biblioteki i narzędzia Open Source - aby ułatwić innym programistom korzystanie z twojego kodu
Podsumowanie
TypeScript jest jak zaawansowany system bezpieczeństwa dla Parku Jurajskiego:
- JavaScript: "Mamy dinozaury w klatkach, wszystko powinno być w porządku."
- TypeScript: "Każdy dinozaur jest monitorowany, mamy alert przy najmniejszej anomalii, a pracownicy mają jasne instrukcje postępowania."
Dodając typowanie do kodu JavaScript, zyskujesz:
- Wcześniejsze wykrywanie błędów
- Lepszą dokumentację
- Wydajniejsze narzędzia programistyczne
- Bezpieczniejsze refaktoryzacje
W następnych lekcjach zaczniemy szczegółowo poznawać system typów TypeScript i zobaczymy, jak możemy wykorzystać go do budowania bardziej niezawodnych systemów - takich, które nie pozwoliłyby dinozaurom uciec z parku!
Kod do tej lekcji: index.ts
// TypeScript w Parku Jurajskim - Wprowadzenie i podstawy
console.log("Witaj w TypeScript - Parku Jurajskim!");
console.log("Poznajemy TypeScript i jego zalety w bezpiecznym kodzie\n");
// ===========================================
// 1. Problem z JavaScript - brak typów
// ===========================================
console.log("=== 1. PROBLEM Z JAVASCRIPT ===");
// JavaScript - problemy z typami
function grantAccessJS(employee: any, accessLevel: any): boolean {
// W JavaScript nie ma sprawdzania typów
if (employee.permissions >= accessLevel) {
return true;
}
return false;
}
// Niebezpieczne dane - brak sprawdzania
const drMalcolmJS: any = {
name: "Ian Malcolm",
role: "Mathematician"
// Brak pola 'permissions'!
};
// To się wykonuje bez błędu, ale zwraca nieprawidłowy wynik
const accessJS = grantAccessJS(drMalcolmJS, 5);
console.log("JavaScript access result:", accessJS); // undefined >= 5 = false
console.log("JavaScript pozwala na błędy typów w runtime");
console.log("Trudne debugowanie");
console.log("Brak IntelliSense/autouzupełniania\n");
// ===========================================
// 2. TypeScript - rozwiązanie problemu
// ===========================================
console.log("=== 2. TYPESCRIPT - ROZWIĄZANIE ===");
// Definicja interfejsu dla pracownika
interface Employee {
name: string;
role: string;
permissions: number;
department?: string; // Opcjonalne pole
}
// Funkcja z typami TypeScript
function grantAccess(employee: Employee, accessLevel: number): boolean {
if (employee.permissions >= accessLevel) {
return true;
}
return false;
}
// Poprawne dane z typami
const drMalcolm: Employee = {
name: "Ian Malcolm",
role: "Mathematician",
permissions: 3
};
const accessTS = grantAccess(drMalcolm, 5);
console.log("TypeScript access result:", accessTS);
console.log("TypeScript sprawdza typy w compile-time");
console.log("Lepsze IntelliSense i autouzupełnianie");
console.log("Wczesne wykrywanie błędów\n");
// ===========================================
// 3. Podstawowe typy TypeScript
// ===========================================
console.log("=== 3. PODSTAWOWE TYPY TYPESCRIPT ===");
// Typy prymitywne
let dinosaurName: string = "Tyrannosaurus Rex";
let dinosaurAge: number = 68000000;
let isExtinct: boolean = true;
let unknownData: unknown = "mysterious data";
let nothingHere: null = null;
let notDefined: undefined = undefined;
// Tablice
let dinosaurSpecies: string[] = ["T-Rex", "Triceratops", "Velociraptor"];
let dangerLevels: Array<number> = [9, 6, 8]; // Alternatywna składnia
// Tuple - tablica o stałej długości i typach
let dinosaurInfo: [string, number, boolean] = ["T-Rex", 8000, true];
// Enum - numerowane stałe
enum SecurityLevel {
Green = 1,
Yellow = 2,
Orange = 3,
Red = 4,
Critical = 5
}
let currentSecurity: SecurityLevel = SecurityLevel.Orange;
console.log("Current security level:", SecurityLevel[currentSecurity]);
// Union types - jeden z kilku typów
type DinosaurDiet = "carnivore" | "herbivore" | "omnivore";
let trexDiet: DinosaurDiet = "carnivore";
// Literal types
type DinosaurPeriod = "Triassic" | "Jurassic" | "Cretaceous";
let period: DinosaurPeriod = "Cretaceous";
console.log("Podstawowe typy TypeScript zdefiniowane!\n");
// ===========================================
// 4. Interfejsy i typy obiektów
// ===========================================
console.log("=== 4. INTERFEJSY I TYPY OBIEKTÓW ===");
// Interfejs dla dinozaura
interface Dinosaur {
readonly id: string; // Tylko do odczytu
name: string;
species: string;
diet: DinosaurDiet;
weight: number;
dangerLevel: number;
isActive?: boolean; // Opcjonalne
// Metody w interfejsie
roar(): string;
feed(food: string): void;
}
// Implementacja interfejsu
class TyrannosaurusRex implements Dinosaur {
readonly id: string;
name: string;
species: string;
diet: DinosaurDiet;
weight: number;
dangerLevel: number;
isActive: boolean;
constructor(name: string) {
this.id = `DINO-${Date.now()}`;
this.name = name;
this.species = "Tyrannosaurus Rex";
this.diet = "carnivore";
this.weight = 8000;
this.dangerLevel = 9;
this.isActive = true;
}
roar(): string {
return `${this.name} roars: ROAAAAAR!`;
}
feed(food: string): void {
console.log(`${this.name} eats ${food}`);
}
hunt(prey: string): string {
return `${this.name} hunts ${prey}`;
}
}
const rexy = new TyrannosaurusRex("Rexy");
console.log("Dinosaur created:", rexy.name);
console.log("Roar:", rexy.roar());
rexy.feed("goat");
// Extending interfaces
interface CarnivorousDinosaur extends Dinosaur {
huntingStyle: string;
packSize: number;
hunt(prey: string): string;
}
// Type aliases dla złożonych typów
type DinosaurCollection = {
[key: string]: Dinosaur;
};
type EnclosureStatus = "secure" | "breached" | "maintenance";
console.log("Interfejsy i typy obiektów zdefiniowane!\n");
// ===========================================
// 5. Generics - typy parametryczne
// ===========================================
console.log("=== 5. GENERICS - TYPY PARAMETRYCZNE ===");
// Generic function
function createContainer<T>(item: T): { content: T; timestamp: Date } {
return {
content: item,
timestamp: new Date()
};
}
// Użycie z różnymi typami
const dinoContainer = createContainer<Dinosaur>(rexy);
const stringContainer = createContainer<string>("Important data");
const numberContainer = createContainer<number>(42);
console.log("Dino container:", dinoContainer.content.name);
console.log("String container:", stringContainer.content);
// Generic interface
interface Repository<T> {
items: T[];
add(item: T): void;
find(predicate: (item: T) => boolean): T | undefined;
getAll(): T[];
}
// Implementation dla dinozaurów
class DinosaurRepository implements Repository<Dinosaur> {
items: Dinosaur[] = [];
add(dinosaur: Dinosaur): void {
this.items.push(dinosaur);
console.log(`Added ${dinosaur.name} to repository`);
}
find(predicate: (dinosaur: Dinosaur) => boolean): Dinosaur | undefined {
return this.items.find(predicate);
}
getAll(): Dinosaur[] {
return [...this.items];
}
findByDiet(diet: DinosaurDiet): Dinosaur[] {
return this.items.filter(dino => dino.diet === diet);
}
}
const dinoRepo = new DinosaurRepository();
dinoRepo.add(rexy);
// Generic constraints
interface HasName {
name: string;
}
function logName<T extends HasName>(item: T): T {
console.log(`Logging: ${item.name}`);
return item;
}
logName(rexy); // Works - Dinosaur has name
// logName(123); // Error - number doesn't have name
console.log("Generics działają!\n");
// ===========================================
// 6. Utility Types - wbudowane typy pomocnicze
// ===========================================
console.log("=== 6. UTILITY TYPES ===");
// Partial - wszystkie pola opcjonalne
type PartialDinosaur = Partial<Dinosaur>;
function updateDinosaur(dino: Dinosaur, updates: PartialDinosaur): Dinosaur {
return { ...dino, ...updates };
}
const updatedRexy = updateDinosaur(rexy, { isActive: false });
console.log(`${updatedRexy.name} is active: ${updatedRexy.isActive}`);
// Pick - wybór określonych pól
type DinosaurSummary = Pick<Dinosaur, "name" | "species" | "dangerLevel">;
function createSummary(dino: Dinosaur): DinosaurSummary {
return {
name: dino.name,
species: dino.species,
dangerLevel: dino.dangerLevel
};
}
const summary = createSummary(rexy);
console.log("Dinosaur summary:", summary);
// Omit - usunięcie określonych pól
type PublicDinosaurInfo = Omit<Dinosaur, "id" | "dangerLevel">;
function getPublicInfo(dino: Dinosaur): PublicDinosaurInfo {
const { id, dangerLevel, ...publicInfo } = dino;
return publicInfo;
}
// Record - mapowanie kluczy do wartości
type DinosaurStats = Record<DinosaurDiet, number>;
const dietStats: DinosaurStats = {
carnivore: 3,
herbivore: 7,
omnivore: 2
};
console.log("Diet statistics:", dietStats);
// Required - wszystkie pola wymagane
type RequiredDinosaur = Required<Dinosaur>;
console.log("Utility types działają!\n");
// ===========================================
// 7. Zaawansowane typy
// ===========================================
console.log("=== 7. ZAAWANSOWANE TYPY ===");
// Mapped types
type ReadonlyDinosaur = {
readonly [K in keyof Dinosaur]: Dinosaur[K];
};
// Conditional types
type DinosaurSound<T> = T extends "carnivore" ? "ROAR" : "HONK";
type TRexSound = DinosaurSound<"carnivore">; // "ROAR"
type TriceratopsSound = DinosaurSound<"herbivore">; // "HONK"
// Template literal types
type EventName<T extends string> = `dinosaur-${T}`;
type DinosaurEvents = EventName<"fed" | "escaped" | "sleeping">;
// Function types
type DinosaurEventHandler = (dinosaur: Dinosaur, event: DinosaurEvents) => void;
const eventHandler: DinosaurEventHandler = (dino, event) => {
console.log(`Event ${event} for ${dino.name}`);
};
eventHandler(rexy, "dinosaur-fed");
console.log("Zaawansowane typy działają!\n");
// ===========================================
// 8. Praktyczny przykład - System zarządzania parkiem
// ===========================================
console.log("=== 8. SYSTEM ZARZĄDZANIA PARKIEM ===");
// Kompleksny system typów dla parku
interface Enclosure {
id: string;
name: string;
capacity: number;
type: "carnivore" | "herbivore" | "mixed";
securityLevel: SecurityLevel;
dinosaurs: Dinosaur[];
isLocked: boolean;
}
interface ParkEvent {
id: string;
timestamp: Date;
type: "feeding" | "escape" | "maintenance" | "visitor";
entityId: string;
severity: "low" | "medium" | "high" | "critical";
message: string;
}
class ParkManager {
private enclosures: Map<string, Enclosure> = new Map();
private eventLog: ParkEvent[] = [];
addEnclosure(enclosure: Omit<Enclosure, "id">): string {
const id = `ENC-${Date.now()}`;
const newEnclosure: Enclosure = { ...enclosure, id };
this.enclosures.set(id, newEnclosure);
this.logEvent({
type: "maintenance",
entityId: id,
severity: "low",
message: `Enclosure ${enclosure.name} created`
});
return id;
}
addDinosaurToEnclosure(dinosaurId: string, enclosureId: string): boolean {
const enclosure = this.enclosures.get(enclosureId);
if (!enclosure) {
console.log("Enclosure not found");
return false;
}
if (enclosure.dinosaurs.length >= enclosure.capacity) {
console.log("Enclosure at capacity");
return false;
}
// W prawdziwej aplikacji pobieralibyśmy dinozaura z repozytorium
console.log(`Dinosaur ${dinosaurId} added to ${enclosure.name}`);
return true;
}
private logEvent(event: Omit<ParkEvent, "id" | "timestamp">): void {
const newEvent: ParkEvent = {
...event,
id: `EVT-${Date.now()}`,
timestamp: new Date()
};
this.eventLog.push(newEvent);
}
getEventsByType<T extends ParkEvent["type"]>(type: T): ParkEvent[] {
return this.eventLog.filter(event => event.type === type);
}
getParkStatus(): {
enclosureCount: number;
totalDinosaurs: number;
securityLevel: SecurityLevel;
recentEvents: ParkEvent[];
} {
const enclosures = Array.from(this.enclosures.values());
const totalDinosaurs = enclosures.reduce((sum, enc) => sum + enc.dinosaurs.length, 0);
const maxSecurityLevel = Math.max(...enclosures.map(enc => enc.securityLevel));
return {
enclosureCount: enclosures.length,
totalDinosaurs,
securityLevel: maxSecurityLevel as SecurityLevel,
recentEvents: this.eventLog.slice(-5)
};
}
}
// Test systemu
const parkManager = new ParkManager();
const enclosureId = parkManager.addEnclosure({
name: "T-Rex Paddock",
capacity: 2,
type: "carnivore",
securityLevel: SecurityLevel.Critical,
dinosaurs: [],
isLocked: true
});
parkManager.addDinosaurToEnclosure("rexy", enclosureId);
const status = parkManager.getParkStatus();
console.log("Park status:", status);
console.log("\nTypeScript Park Management System działa!\n");
// ===========================================
// 9. Zalety TypeScript
// ===========================================
console.log("=== 9. ZALETY TYPESCRIPT ===");
console.log("BEZPIECZEŃSTWO TYPÓW:");
console.log(" • Wykrywanie błędów w compile-time");
console.log(" • Zapobieganie typowym błędom JavaScript");
console.log(" • Pewność co do struktury danych\n");
console.log("LEPSZE NARZĘDZIA:");
console.log(" • IntelliSense/autouzupełnianie");
console.log(" • Refactoring z pewną siebie IDE");
console.log(" • Automatyczne sprawdzanie składni\n");
console.log("DOKUMENTACJA KODU:");
console.log(" • Typy służą jako dokumentacja");
console.log(" • Jasne API interfejsów");
console.log(" • Czytelniejszy kod dla zespołu\n");
console.log("SKALOWALNOŚĆ:");
console.log(" • Łatwiejsze zarządzanie dużymi projektami");
console.log(" • Lepsze współpraca w zespole");
console.log(" • Mniejsze ryzyko regresji\n");
console.log("ZGODNOŚĆ Z JAVASCRIPT:");
console.log(" • Stopniowa migracja z JS");
console.log(" • Używanie bibliotek JavaScript");
console.log(" • Kompilacja do czystego JS\n");
console.log("TypeScript - bezpieczniejszy JavaScript dla Parku Jurajskiego!");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. Jaka jest najważniejsza zaleta TypeScript w porównaniu z JavaScript?
2. Jaka jest relacja między TypeScript a JavaScript?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zdefiniuj zmienną gatunekDinozaura typu string i przypisz jej wartość 'T-Rex'.