Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Typy parametrów i zwracanych wartości
W tej lekcji11
Witaj ponownie w Parku Jurajskim! Po wielu wycieczkach po interfejsach i typach, Dr. Henry Wu zabierze nas dzisiaj do centrum operacyjnego parku, gdzie przyjrzymy się dokładniej typowaniu funkcji - czyli określaniu typów parametrów i zwracanych wartości. Jest to kluczowy element zapewnienia bezpieczeństwa i przewidywalności w naszym systemie zarządzania parkiem - podobnie jak ścisłe protokoły bezpieczeństwa są niezbędne dla sprawnego funkcjonowania Parku Jurajskiego.
Podstawy typowania funkcji
Określanie typów parametrów i zwracanych wartości to fundamentalny element TypeScript. Pozwala nam to jasno zdefiniować, jakie dane funkcja przyjmuje i co zwraca - tworząc wyraźny "kontrakt" dla tej funkcji.
// Podstawowa funkcja z typowanymi parametrami i zwracaną wartością
function obliczWymaganiaPokarmowe(
waga: number,
jestDrapieżnikiem: boolean,
wiek: number
): number {
// Dinozaury drapieżne potrzebują więcej kalorii
const wspólczynnikDiety = jestDrapieżnikiem ? 0.05 : 0.03;
// Młode dinozaury potrzebują więcej kalorii na jednostkę masy
const współczynnikWieku = wiek < 5 ? 1.2 : 1.0;
// Dzienna ilość pokarmu w kilogramach
return waga * wspólczynnikDiety * współczynnikWieku;
}
// Użycie funkcji
const dziennyPosiłekTRex = obliczWymaganiaPokarmowe(7500, true, 7);
console.log(`Dzienna ilość pokarmu dla T-Rex: ${dziennyPosiłekTRex} kg`);
const dziennyPosiłekBrachiosaurus = obliczWymaganiaPokarmowe(35000, false, 22);
console.log(`Dzienna ilość pokarmu dla Brachiosaurusa: ${dziennyPosiłekBrachiosaurus} kg`);Funkcja powyżej jasno definiuje, że przyjmuje trzy parametry: waga (number), jestDrapieżnikiem (boolean) i wiek (number), a zwraca wartość typu number. Dzięki temu IDE i kompilator TypeScript będą w stanie wychwycić potencjalne błędy, takie jak próba wywołania funkcji z nieprawidłowymi typami argumentów.
Parametry opcjonalne i domyślne
W Parku Jurajskim, niektóre procedury mają parametry opcjonalne lub domyślne wartości. Na przykład, gdy zlecamy badanie dinozaura, możemy określić poziom priorytetowości, ale jeśli tego nie zrobimy, przyjmowana jest standardowa wartość.
// Funkcja z parametrem opcjonalnym
function zaplanujBadanieDinozaura(
id: string,
typ: "rutynowe" | "specjalistyczne",
priorytet?: 1 | 2 | 3 // Opcjonalny parametr
): string {
// Jeśli priorytet nie został określony, używamy domyślnej wartości
const faktycznyPriorytet = priorytet || 2;
// Określamy termin badania na podstawie priorytetu
let terminWDniach: number;
switch (faktycznyPriorytet) {
case 1: terminWDniach = 1; break; // Nagły przypadek - następny dzień
case 2: terminWDniach = 7; break; // Standardowy priorytet - tydzień
case 3: terminWDniach = 30; break; // Niski priorytet - miesiąc
default: terminWDniach = 7;
}
// Obliczamy datę badania
const dataBadania = new Date();
dataBadania.setDate(dataBadania.getDate() + terminWDniach);
return `Badanie ${typ} dla dinozaura ${id} zaplanowane na ${dataBadania.toLocaleDateString()} (priorytet: ${faktycznyPriorytet})`;
}
// Wywołanie z wszystkimi parametrami
console.log(zaplanujBadanieDinozaura("TREX-01", "specjalistyczne", 1));
// Wywołanie bez parametru opcjonalnego
console.log(zaplanujBadanieDinozaura("STEG-03", "rutynowe"));
// Alternatywnie, można użyć parametru z wartością domyślną
function zaplanujBadanieDinozaura2(
id: string,
typ: "rutynowe" | "specjalistyczne",
priorytet: 1 | 2 | 3 = 2 // Parametr z wartością domyślną
): string {
// Reszta implementacji jak wyżej...
const dataBadania = new Date();
dataBadania.setDate(dataBadania.getDate() + (priorytet === 1 ? 1 : priorytet === 2 ? 7 : 30));
return `Badanie ${typ} dla dinozaura ${id} zaplanowane na ${dataBadania.toLocaleDateString()} (priorytet: ${priorytet})`;
}
// Wywołanie bez podania parametru z wartością domyślną
console.log(zaplanujBadanieDinozaura2("TRIC-02", "rutynowe"));Zauważ różnicę między parametrem opcjonalnym (oznaczanym przez ?) a parametrem z wartością domyślną (określanym przez = wartość). W obu przypadkach możemy pominąć ten parametr przy wywołaniu funkcji, ale podejście z wartością domyślną jest bardziej eleganckie i czytelne.
Typy zwracanych wartości
W typowaniu funkcji równie ważne jak typy parametrów są typy zwracanych wartości. TypeScript pozwala na precyzyjne określenie, co dokładnie funkcja zwraca, co pomaga w wykrywaniu potencjalnych błędów.
// Funkcja zwracająca liczbę
function obliczPojemnośćWybiegu(
długość: number,
szerokość: number,
typDinozaura: "mały" | "średni" | "duży"
): number {
const powierzchnia = długość * szerokość;
// Ile dinozaurów danego typu można bezpiecznie umieścić na danej powierzchni
switch (typDinozaura) {
case "mały": return Math.floor(powierzchnia / 50);
case "średni": return Math.floor(powierzchnia / 200);
case "duży": return Math.floor(powierzchnia / 1000);
default: return 0;
}
}
// Funkcja zwracająca string
function generujIdentyfikatorDinozaura(
gatunek: string,
numer: number
): string {
// Tworzymy identyfikator na podstawie pierwszych 4 liter gatunku i numeru
const prefiks = gatunek.slice(0, 4).toUpperCase();
// Formatujemy numer jako 3-cyfrowy z wiodącymi zerami
const numerSformatowany = numer.toString().padStart(3, '0');
return `${prefiks}-${numerSformatowany}`;
}
// Funkcja zwracająca boolean
function czyWybiegBezpieczny(
poziomBezpieczeństwa: number,
wymaganyPoziom: number,
ostatniPrzegląd: Date
): boolean {
// Sprawdzamy, czy poziom bezpieczeństwa jest wystarczający
if (poziomBezpieczeństwa < wymaganyPoziom) {
return false;
}
// Sprawdzamy, czy przegląd był w ciągu ostatnich 30 dni
const dzisiaj = new Date();
const trzydzieściDniTemu = new Date(dzisiaj);
trzydzieściDniTemu.setDate(dzisiaj.getDate() - 30);
return ostatniPrzegląd >= trzydzieściDniTemu;
}
// Przykłady użycia
const pojemnośćWybiegRaptorów = obliczPojemnośćWybiegu(100, 50, "średni");
console.log(`Wybieg raptorów może pomieścić ${pojemnośćWybiegRaptorów} osobników`);
const idNowegoDinozaura = generujIdentyfikatorDinozaura("Velociraptor", 42);
console.log(`Nowy raptor otrzymał ID: ${idNowegoDinozaura}`);
const statusWybiegTRex = czyWybiegBezpieczny(
5, // aktualny poziom
5, // wymagany poziom
new Date(2023, 4, 15) // data ostatniego przeglądu (15 maja 2023)
);
console.log(`Status bezpieczeństwa wybiegu T-Rex: ${statusWybiegTRex ? "BEZPIECZNY" : "WYMAGA UWAGI"}`);Funkcje zwracające void
Niektóre funkcje nie zwracają wartości - są wywoływane głównie dla ich efektów ubocznych, takich jak modyfikacja stanu systemu, wyświetlanie informacji czy zapisywanie danych. W TypeScript taki przypadek oznaczamy typem zwracanej wartości void.
// Funkcja nie zwracająca wartości (void)
function zarejestrujZmianyOgrodzenia(
idWybiegu: string,
napięcie: number,
dataZmiany: Date = new Date() // Domyślnie używamy aktualnej daty
): void {
// Zapisujemy informację o zmianie napięcia w ogrodzeniu
console.log(`[${dataZmiany.toISOString()}] Zmieniono napięcie w ogrodzeniu wybiegu ${idWybiegu} na ${napięcie}V`);
// W rzeczywistej aplikacji zapisalibyśmy te dane w bazie
// Funkcja nie zwraca żadnej wartości
}
// Wywołanie funkcji void
zarejestrujZmianyOgrodzenia("TRX-PADDOCK", 10000);Funkcje zwracające różne typy (union types)
W niektórych przypadkach funkcja może zwracać różne typy wartości w zależności od warunków lub parametrów. W TypeScript możemy to określić za pomocą union types.
// Funkcja zwracająca różne typy wartości
function pobierzDaneDinozaura(
id: string,
formatDanych: "podsumowanie" | "pełny" | "JSON"
): string | object | null {
// Symulacja bazy danych
const bazaDanych: Record<string, {
nazwa: string;
gatunek: string;
wiek: number;
waga: number;
statusZdrowia: string;
}> = {
"TREX-001": {
nazwa: "Rexy",
gatunek: "Tyrannosaurus Rex",
wiek: 7,
waga: 8000,
statusZdrowia: "dobry"
},
"VEL-001": {
nazwa: "Blue",
gatunek: "Velociraptor",
wiek: 4,
waga: 160,
statusZdrowia: "doskonały"
}
};
// Sprawdzamy, czy dinozaur istnieje
if (!bazaDanych[id]) {
console.error(`Nie znaleziono dinozaura o ID ${id}`);
return null;
}
const dino = bazaDanych[id];
// Zwracamy różne formaty w zależności od parametru
switch (formatDanych) {
case "podsumowanie":
return `${dino.nazwa} (${dino.gatunek}): ${dino.statusZdrowia}`;
case "pełny":
return `
ID: ${id}
Nazwa: ${dino.nazwa}
Gatunek: ${dino.gatunek}
Wiek: ${dino.wiek} lat
Waga: ${dino.waga} kg
Status zdrowia: ${dino.statusZdrowia}
`;
case "JSON":
return { id, ...dino };
default:
return null;
}
}
// Przykłady użycia
const podsumowanieRexy = pobierzDaneDinozaura("TREX-001", "podsumowanie");
console.log(podsumowanieRexy);
const pełneDaneBlue = pobierzDaneDinozaura("VEL-001", "pełny");
console.log(pełneDaneBlue);
const jsonDaneRexy = pobierzDaneDinozaura("TREX-001", "JSON") as object;
console.log(JSON.stringify(jsonDaneRexy, null, 2));
// Obsługa błędnych danych
const nieistniejącyDinozaur = pobierzDaneDinozaura("INDOMINUS-001", "podsumowanie");
if (nieistniejącyDinozaur === null) {
console.log("Nie znaleziono dinozaura");
}Funkcja pobierzDaneDinozaura zwraca string, object lub null w zależności od parametrów i warunków. Dzięki union types TypeScript wie, że wynik może być jednym z tych trzech typów i odpowiednio weryfikuje kod, który używa tej funkcji.
Typ funkcji (Function Types)
TypeScript umożliwia również definiowanie typów samych funkcji, co jest niezwykle przydatne przy przekazywaniu funkcji jako parametrów lub przypisywaniu ich do zmiennych.
// Definicja typu funkcji
type FunkcjaAlarmowa = (
poziomZagrożenia: number,
lokalizacja: string,
komunikat: string
) => void;
// Funkcja używająca funkcji jako parametru
function uruchomProceduręBezpieczeństwa(
idWybiegu: string,
poziomZagrożenia: number,
funkcjaAlarmowa: FunkcjaAlarmowa
): void {
console.log(`Uruchamianie procedury bezpieczeństwa dla wybiegu ${idWybiegu}`);
// Zamykanie bram
console.log(`- Zamykanie bram wybiegu ${idWybiegu}`);
// Aktywacja dodatkowych zabezpieczeń
if (poziomZagrożenia >= 4) {
console.log("- Aktywacja dodatkowego ogrodzenia elektrycznego");
console.log("- Wysłanie personelu bezpieczeństwa");
}
// Wywołanie przekazanej funkcji alarmowej
funkcjaAlarmowa(
poziomZagrożenia,
`Wybieg ${idWybiegu}`,
`Uruchomiono procedurę bezpieczeństwa poziomu ${poziomZagrożenia}`
);
}
// Implementacja funkcji alarmowej
const alertDlaCentrumKontroli: FunkcjaAlarmowa = (poziom, lokalizacja, komunikat) => {
console.log("=== ALERT DLA CENTRUM KONTROLI ===");
console.log(`Poziom zagrożenia: ${poziom}`);
console.log(`Lokalizacja: ${lokalizacja}`);
console.log(`Komunikat: ${komunikat}`);
console.log("===================================");
};
// Alternatywna funkcja alarmowa
const alertDlaPersoneluParku: FunkcjaAlarmowa = (poziom, lokalizacja, komunikat) => {
const priorytet = poziom >= 4 ? "KRYTYCZNY" : poziom >= 2 ? "WAŻNY" : "INFORMACYJNY";
console.log(`[${priorytet}] ${komunikat} w ${lokalizacja}`);
// W rzeczywistej aplikacji wysłalibyśmy tutaj powiadomienia do personelu
};
// Użycie funkcji z różnymi implementacjami funkcji alarmowej
uruchomProceduręBezpieczeństwa("RAPTOR-01", 3, alertDlaCentrumKontroli);
uruchomProceduręBezpieczeństwa("TREX-01", 5, alertDlaPersoneluParku);W powyższym przykładzie zdefiniowaliśmy typ funkcji FunkcjaAlarmowa, który określa sygnaturę funkcji przyjmującej trzy parametry i nie zwracającej wartości. Następnie użyliśmy tego typu, aby zdefiniować parametr w funkcji uruchomProceduręBezpieczeństwa i implementacje konkretnych funkcji alarmowych.
Typowanie funkcji z callbackiem
Funkcje z callbackami są powszechne w JavaScript, szczególnie w operacjach asynchronicznych. TypeScript pozwala na precyzyjne typowanie takich funkcji.
// Funkcja z callbackiem typowanym inline
function monitorujZdrowieZwierzęcia(
idZwierzęcia: string,
interwałWSekundach: number,
callback: (dane: { temperatura: number; tętno: number; poziomStresu: number }) => void
): void {
console.log(`Rozpoczęto monitoring zdrowia zwierzęcia ${idZwierzęcia} co ${interwałWSekundach} sekund`);
// Symulacja pierwszego pomiaru
const danePoczątkowe = {
temperatura: 38.5,
tętno: 72,
poziomStresu: 3
};
// Wywołanie callbacka z pierwszymi danymi
callback(danePoczątkowe);
// W rzeczywistej aplikacji ustawilibyśmy tutaj interwał do regularnego monitorowania
console.log("Monitoring uruchomiony");
}
// Użycie funkcji z callbackiem
monitorujZdrowieZwierzęcia("TREX-001", 60, (dane) => {
console.log("Otrzymano nowe dane zdrowotne:");
console.log(`- Temperatura: ${dane.temperatura}°C`);
console.log(`- Tętno: ${dane.tętno} uderzeń/min`);
console.log(`- Poziom stresu: ${dane.poziomStresu}/10`);
// Sprawdzenie alertów zdrowotnych
if (dane.temperatura > 39.5) {
console.log("ALERT: Podwyższona temperatura!");
}
if (dane.tętno > 100) {
console.log("ALERT: Przyspieszone tętno!");
}
if (dane.poziomStresu > 7) {
console.log("ALERT: Wysoki poziom stresu!");
}
});
// Można również zdefiniować typ callbacka oddzielnie
type CallbackMonitoringuZdrowia = (dane: {
temperatura: number;
tętno: number;
poziomStresu: number;
timeStamp?: Date; // opcjonalny parametr
}) => void;
// Funkcja z typem callbacka
function zaawansowanyMonitoringZdrowia(
idZwierzęcia: string,
opcje: { interwał: number; powiadomienia: boolean },
callback: CallbackMonitoringuZdrowia
): void {
console.log(`Konfiguracja zaawansowanego monitoringu dla ${idZwierzęcia}`);
console.log(`- Interwał: ${opcje.interwał} sekund`);
console.log(`- Powiadomienia: ${opcje.powiadomienia ? "włączone" : "wyłączone"}`);
// Symulacja danych z timestampem
const dane = {
temperatura: 38.2,
tętno: 68,
poziomStresu: 2,
timeStamp: new Date()
};
callback(dane);
}
// Użycie funkcji z typem callbacka
zaawansowanyMonitoringZdrowia("STEG-003", { interwał: 120, powiadomienia: true }, (dane) => {
const czasPomiaru = dane.timeStamp ? dane.timeStamp.toISOString() : "nieznany";
console.log(`[${czasPomiaru}] Dane zdrowotne: T:${dane.temperatura}°C, HR:${dane.tętno}, Stres:${dane.poziomStresu}/10`);
});Funkcje generyczne
Jedną z najpotężniejszych funkcji TypeScript są generyki, które pozwalają na tworzenie funkcji i typów, które działają z różnymi typami danych, zachowując przy tym bezpieczeństwo typów.
// Funkcja generyczna do filtrowania danych
function filtrujDane<T>(
dane: T[],
predykat: (element: T) => boolean
): T[] {
return dane.filter(predykat);
}
// Przykładowe dane dinozaurów
interface DaneDino {
id: string;
nazwa: string;
gatunek: string;
waga: number;
poziomNiebezpieczeństwa: number;
}
const dinozaury: DaneDino[] = [
{ id: "TREX-001", nazwa: "Rexy", gatunek: "T-Rex", waga: 8000, poziomNiebezpieczeństwa: 5 },
{ id: "VEL-001", nazwa: "Blue", gatunek: "Velociraptor", waga: 150, poziomNiebezpieczeństwa: 4 },
{ id: "TRIC-001", nazwa: "Tri", gatunek: "Triceratops", waga: 9000, poziomNiebezpieczeństwa: 2 },
{ id: "STEG-001", nazwa: "Spike", gatunek: "Stegosaurus", waga: 5000, poziomNiebezpieczeństwa: 2 },
{ id: "BRACH-001", nazwa: "Brachie", gatunek: "Brachiosaurus", waga: 40000, poziomNiebezpieczeństwa: 1 }
];
// Użycie generycznej funkcji z typem DaneDino
const niebezpieczneDinozaury = filtrujDane<DaneDino>(
dinozaury,
dino => dino.poziomNiebezpieczeństwa >= 4
);
console.log("Niebezpieczne dinozaury:");
niebezpieczneDinozaury.forEach(dino => {
console.log(`- ${dino.nazwa} (${dino.gatunek}): poziom zagrożenia ${dino.poziomNiebezpieczeństwa}`);
});
// Użycie tej samej funkcji z innym typem danych
const temperatury = [28.5, 29.2, 30.1, 27.8, 31.5, 30.8, 32.1, 29.5];
const wysokieTemperatury = filtrujDane<number>(
temperatury,
temp => temp > 30
);
console.log(`Zarejestrowano ${wysokieTemperatury.length} pomiarów z temperaturą powyżej 30°C`);
// Bardziej złożona funkcja generyczna dla operacji na danych
function przetwórzIZwróćDane<T, U>(
dane: T[],
transformacja: (element: T) => U
): U[] {
return dane.map(transformacja);
}
// Użycie złożonej funkcji generycznej
const raportDinozaurów = przetwórzIZwróćDane<DaneDino, { nazwa: string; poziomZagrożenia: string }>(
dinozaury,
dino => ({
nazwa: `${dino.nazwa} (${dino.gatunek})`,
poziomZagrożenia: dino.poziomNiebezpieczeństwa >= 4
? "WYSOKI"
: dino.poziomNiebezpieczeństwa >= 3
? "ŚREDNI"
: "NISKI"
})
);
console.log("Raport zagrożeń:");
raportDinozaurów.forEach(raport => {
console.log(`- ${raport.nazwa}: ${raport.poziomZagrożenia}`);
});Funkcje generyczne są niezwykle elastyczne i pozwalają na wielokrotne wykorzystanie tej samej logiki z różnymi typami danych, przy jednoczesnym zachowaniu bezpieczeństwa typów.
Przeciążanie funkcji (Function Overloading)
TypeScript umożliwia przeciążanie funkcji, co pozwala na zdefiniowanie wielu sygnatur funkcji z różnymi typami parametrów i zwracanych wartości.
// Przeciążenie funkcji dla różnych formatów ID
// Definicje sygnatur funkcji
function generujIdentyfikator(typ: "dinozaur", numer: number): string;
function generujIdentyfikator(typ: "pracownik", imię: string, nazwisko: string): string;
function generujIdentyfikator(typ: "lokalizacja", strefa: string, numer: number): string;
// Implementacja funkcji obsługująca wszystkie przypadki
function generujIdentyfikator(
typ: "dinozaur" | "pracownik" | "lokalizacja",
wartość1: number | string,
wartość2?: string
): string {
switch (typ) {
case "dinozaur":
// wartość1 jest numerem
return `DINO-${(wartość1 as number).toString().padStart(3, '0')}`;
case "pracownik":
// wartość1 jest imieniem, wartość2 jest nazwiskiem
if (typeof wartość1 === "string" && typeof wartość2 === "string") {
const inicjały = `${wartość1.charAt(0)}${wartość2.charAt(0)}`.toUpperCase();
return `EMP-${inicjały}-${Math.floor(Math.random() * 1000).toString().padStart(3, '0')}`;
}
throw new Error("Nieprawidłowe parametry dla typu 'pracownik'");
case "lokalizacja":
// wartość1 jest strefą, wartość2 jest numerem
if (typeof wartość1 === "string" && typeof wartość2 === "number") {
return `LOC-${wartość1.toUpperCase()}-${wartość2.toString().padStart(2, '0')}`;
}
throw new Error("Nieprawidłowe parametry dla typu 'lokalizacja'");
default:
throw new Error(`Nieznany typ identyfikatora: ${typ}`);
}
}
// Przykłady użycia dla różnych przeciążeń
const idDinozaura = generujIdentyfikator("dinozaur", 42);
console.log(`ID dinozaura: ${idDinozaura}`);
const idPracownika = generujIdentyfikator("pracownik", "John", "Hammond");
console.log(`ID pracownika: ${idPracownika}`);
const idLokalizacji = generujIdentyfikator("lokalizacja", "A", 5);
console.log(`ID lokalizacji: ${idLokalizacji}`);Przeciążanie funkcji pozwala na tworzenie bardziej elastycznych i czytelnych interfejsów API, gdzie ta sama funkcja może obsługiwać różne zestawy parametrów.
Typowanie funkcji asynchronicznych
W nowoczesnym JavaScript często używamy funkcji asynchronicznych. TypeScript doskonale współpracuje z obietnicami (Promises) i słowami kluczowymi async/await.
// Funkcja asynchroniczna zwracająca Promise<string>
async function pobierzDaneDinozauraZAPI(id: string): Promise<string> {
console.log(`Pobieranie danych dinozaura ${id} z API...`);
// Symulacja opóźnienia sieciowego
await new Promise(resolve => setTimeout(resolve, 1000));
// Symulacja danych z API
const dinozaury: Record<string, { nazwa: string; gatunek: string }> = {
"TREX-001": { nazwa: "Rexy", gatunek: "Tyrannosaurus Rex" },
"VEL-001": { nazwa: "Blue", gatunek: "Velociraptor" }
};
if (dinozaury[id]) {
const dino = dinozaury[id];
return `${dino.nazwa} (${dino.gatunek})`;
} else {
throw new Error(`Nie znaleziono dinozaura o ID ${id}`);
}
}
// Funkcja asynchroniczna zwracająca Promise<boolean>
async function sprawdźStatusZdrowia(id: string): Promise<boolean> {
console.log(`Sprawdzanie statusu zdrowia dinozaura ${id}...`);
try {
// Symulacja opóźnienia
await new Promise(resolve => setTimeout(resolve, 800));
// Symulacja wyniku (dla uproszczenia zawsze zwraca true)
return true;
} catch (error) {
console.error(`Błąd podczas sprawdzania statusu zdrowia: ${error}`);
return false;
}
}
// Funkcja asynchroniczna używająca wielu operacji asynchronicznych
async function przygotujRaportDinozaura(id: string): Promise<{
id: string;
dane: string;
statusZdrowia: boolean;
czasGenerowania: string;
}> {
console.log(`Przygotowywanie raportu dla dinozaura ${id}...`);
// Równoległe wykonanie dwóch operacji asynchronicznych
const [dane, statusZdrowia] = await Promise.all([
pobierzDaneDinozauraZAPI(id),
sprawdźStatusZdrowia(id)
]);
// Przygotowanie raportu
return {
id,
dane,
statusZdrowia,
czasGenerowania: new Date().toISOString()
};
}
// Użycie funkcji asynchronicznych
async function przykładUżyciaAsync() {
try {
const raport = await przygotujRaportDinozaura("TREX-001");
console.log("Raport gotowy:");
console.log(JSON.stringify(raport, null, 2));
// Próba pobrania nieistniejącego dinozaura
const nieistniejący = await pobierzDaneDinozauraZAPI("INDOMINUS-001")
.catch(error => {
console.error(`Wystąpił błąd: ${error.message}`);
return "Nieznany dinozaur";
});
console.log(`Wynik dla nieistniejącego: ${nieistniejący}`);
} catch (error) {
console.error(`Wystąpił błąd: ${error}`);
}
}
// Wywołanie funkcji
przykładUżyciaAsync();W powyższym przykładzie zdefiniowaliśmy kilka funkcji asynchronicznych zwracających różne typy obietnic (Promise<string>, Promise<boolean> i Promise<object>). TypeScript zapewnia pełne wsparcie typów dla tych funkcji i pozwala na bezpieczne łączenie operacji asynchronicznych.
Podsumowanie
Typowanie parametrów i zwracanych wartości funkcji to jeden z fundamentalnych elementów TypeScript, który pomaga w tworzeniu bezpiecznego, przewidywalnego i łatwego w utrzymaniu kodu. W kontekście naszego Parku Jurajskiego, dobre typowanie funkcji jest jak solidne protokoły bezpieczeństwa - pomagają zapobiec potencjalnym katastrofom, zanim się wydarzą.
| Technika | Zastosowanie w Parku Jurajskim |
|---|---|
| Podstawowe typowanie funkcji | Funkcje obliczające wymagania pokarmowe dinozaurów |
| Parametry opcjonalne i domyślne | Planowanie badań dinozaurów z różnymi priorytetami |
| Funkcje void | Rejestrowanie zmian w systemach bezpieczeństwa |
| Union types w zwracanych wartościach | Pobieranie danych dinozaurów w różnych formatach |
| Typy funkcji | Definiowanie funkcji alarmowych dla procedur bezpieczeństwa |
| Callbacki | Monitorowanie zdrowia dinozaurów |
| Funkcje generyczne | Filtrowanie i przetwarzanie różnych typów danych |
| Przeciążanie funkcji | Generowanie różnych typów identyfikatorów |
| Funkcje asynchroniczne | Pobieranie danych z API i generowanie raportów |
Dr. Wu podsumowuje: "W Parku Jurajskim każda procedura musi być precyzyjnie zdefiniowana i wykonana, aby zapewnić bezpieczeństwo zarówno gościom, jak i naszym cennym okazom. Podobnie w TypeScript, prawidłowe typowanie funkcji zapewnia, że każda operacja odbędzie się dokładnie tak, jak zaplanowano - bez niespodzianek. A jak wszyscy wiemy, w świecie dinozaurów niespodzianki rzadko bywają przyjemne."
Kod do tej lekcji: index.ts
// Typy parametrów i zwracanych wartości w Parku Jurajskim
console.log("Typy w funkcjach TypeScript\n");
// ===========================================
// 1. Podstawowe typy parametrów
// ===========================================
console.log("=== PODSTAWOWE TYPY PARAMETRÓW ===");
function feedDinosaur(name: string, amount: number): void {
console.log(`Feeding ${name} with ${amount}kg of food`);
}
feedDinosaur("Rexy", 400);
feedDinosaur("Blue", 50);
// ===========================================
// 2. Typy zwracanych wartości
// ===========================================
console.log("\n=== TYPY ZWRACANYCH WARTOŚCI ===");
// Zwraca string
function getDinosaurName(id: number): string {
return `Dinosaur-${id}`;
}
// Zwraca number
function calculateWeight(baseWeight: number, factor: number): number {
return baseWeight * factor;
}
// Zwraca boolean
function isDangerous(species: string): boolean {
const dangerousSpecies = ["Tyrannosaurus", "Velociraptor", "Spinosaurus"];
return dangerousSpecies.some(s => species.includes(s));
}
// Zwraca void (nic nie zwraca)
function logStatus(message: string): void {
console.log(`[LOG] ${message}`);
}
console.log("Name:", getDinosaurName(1));
console.log("Weight:", calculateWeight(1000, 1.5));
console.log("Dangerous:", isDangerous("Tyrannosaurus Rex"));
logStatus("System operational");
// ===========================================
// 3. Opcjonalne parametry
// ===========================================
console.log("\n=== OPCJONALNE PARAMETRY ===");
function createDinosaur(
name: string,
species: string,
age?: number, // opcjonalne
weight?: number // opcjonalne
): string {
let desc = `${name} (${species})`;
if (age !== undefined) desc += `, ${age} years old`;
if (weight !== undefined) desc += `, ${weight}kg`;
return desc;
}
console.log(createDinosaur("Rexy", "T-Rex"));
console.log(createDinosaur("Blue", "Velociraptor", 3));
console.log(createDinosaur("Delta", "Velociraptor", 3, 350));
// ===========================================
// 4. Domyślne wartości parametrów
// ===========================================
console.log("\n=== DOMYŚLNE WARTOŚCI ===");
function calculateFeedAmount(
weight: number,
dietType: "carnivore" | "herbivore" = "herbivore",
multiplier: number = 1.0
): number {
const basePercentage = dietType === "carnivore" ? 0.05 : 0.10;
return weight * basePercentage * multiplier;
}
console.log("Carnivore 8000kg:", calculateFeedAmount(8000, "carnivore"));
console.log("Herbivore 5000kg:", calculateFeedAmount(5000)); // domyślnie herbivore
console.log("Herbivore 5000kg x2:", calculateFeedAmount(5000, "herbivore", 2));
// ===========================================
// 5. Rest parameters
// ===========================================
console.log("\n=== REST PARAMETERS ===");
function createHerd(species: string, ...names: string[]): string[] {
return names.map(name => `${name} (${species})`);
}
const triceratopsHerd = createHerd(
"Triceratops",
"Tri",
"Trike",
"Sarah",
"Cera"
);
console.log("Herd:", triceratopsHerd);
function sumWeights(...weights: number[]): number {
return weights.reduce((sum, w) => sum + w, 0);
}
console.log("Total weight:", sumWeights(8000, 350, 300, 5000));
// ===========================================
// 6. Typy obiektowe jako parametry
// ===========================================
console.log("\n=== TYPY OBIEKTOWE ===");
interface Dinosaur {
name: string;
species: string;
age: number;
weight: number;
diet: "carnivore" | "herbivore" | "omnivore";
}
function displayDinosaur(dino: Dinosaur): string {
return `${dino.name} - ${dino.species} (${dino.age}y, ${dino.weight}kg, ${dino.diet})`;
}
const trex: Dinosaur = {
name: "Rexy",
species: "Tyrannosaurus Rex",
age: 5,
weight: 8000,
diet: "carnivore"
};
console.log(displayDinosaur(trex));
// Destrukturyzacja w parametrach
function getDinosaurInfo({ name, species, age }: Dinosaur): string {
return `${name} is a ${age}-year-old ${species}`;
}
console.log(getDinosaurInfo(trex));
// ===========================================
// 7. Union types w parametrach
// ===========================================
console.log("\n=== UNION TYPES ===");
type ID = string | number;
function findDinosaur(id: ID): string {
return typeof id === "string"
? `Finding by string ID: ${id}`
: `Finding by numeric ID: ${id}`;
}
console.log(findDinosaur("DINO-001"));
console.log(findDinosaur(42));
// ===========================================
// 8. Funkcje zwracające obiekty
// ===========================================
console.log("\n=== ZWRACANIE OBIEKTÓW ===");
function createDinosaurRecord(
name: string,
species: string
): { id: string; name: string; species: string; createdAt: Date } {
return {
id: `DINO-${Date.now()}`,
name,
species,
createdAt: new Date()
};
}
const newDino = createDinosaurRecord("Delta", "Velociraptor");
console.log("New record:", newDino);
// ===========================================
// 9. Funkcje zwracające funkcje
// ===========================================
console.log("\n=== HIGHER-ORDER FUNCTIONS ===");
function createMultiplier(factor: number): (value: number) => number {
return (value: number) => value * factor;
}
const double = createMultiplier(2);
const triple = createMultiplier(3);
console.log("Double 100:", double(100));
console.log("Triple 100:", triple(100));
// ===========================================
// 10. Type inference
// ===========================================
console.log("\n=== TYPE INFERENCE ===");
// TypeScript wywnioskuje typy
function inferredTypes(a: number, b: string) {
const sum = a + a; // number
const text = b + b; // string
return { sum, text }; // { sum: number; text: string }
}
const result = inferredTypes(5, "hello");
console.log("Inferred result:", result);
// ===========================================
// 11. Never type
// ===========================================
console.log("\n=== NEVER TYPE ===");
// Funkcja nigdy nie zwraca (zawsze rzuca wyjątek)
function throwError(message: string): never {
throw new Error(message);
}
// Funkcja nigdy się nie kończy (nieskończona pętla)
function infiniteLoop(): never {
while (true) {
// nieskończona pętla
}
}
console.log("Never type defined (but not called)");
// ===========================================
// 12. Overload signatures (zapowiedź)
// ===========================================
console.log("\n=== FUNCTION OVERLOADS - ZAPOWIEDŹ ===");
// Definicje przeciążeń
function processData(data: string): string;
function processData(data: number): number;
function processData(data: boolean): boolean;
// Implementacja
function processData(data: string | number | boolean): string | number | boolean {
if (typeof data === "string") {
return data.toUpperCase();
} else if (typeof data === "number") {
return data * 2;
} else {
return !data;
}
}
console.log("Process string:", processData("hello"));
console.log("Process number:", processData(42));
console.log("Process boolean:", processData(true));
// ===========================================
// 13. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Typy parametrów - określanie typów wejściowych");
console.log("Typy zwracanych wartości - co funkcja zwraca");
console.log("Opcjonalne parametry - parametry z ?");
console.log("Domyślne wartości - wartości domyślne");
console.log("Rest parameters - ...args");
console.log("Destrukturyzacja - { prop } w parametrach");
console.log("Union types - string | number");
console.log("Never - funkcje nigdy nie zwracające");
console.log("\nTypy funkcji 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. Jaka jest różnica między x?: string a x: string | undefined w parametrze funkcji?
2. Co oznacza typ zwracany void w TypeScript?
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj typowaną createDinosaur factory function z interfejsami dla różnych gatunków.
- Układanie w poziomie
Ułóż elementy funkcji TypeScript z typami parametrów i wartości zwracanej: