Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Funkcje
W tej lekcji16
W Parku Jurajskim zespół pracowników wykonuje różne wyspecjalizowane zadania: dr Wu zajmuje się genetyką, zespół bezpieczeństwa monitoruje ogrodzenia, a weterynarze dbają o zdrowie dinozaurów. Każdy specjalista wykonuje określone zadania, gdy jest o to proszony, bez konieczności tłumaczenia za każdym razem, jak dokładnie ma to zrobić.
W JavaScript funkcje działają podobnie - są to bloki kodu zaprojektowane do wykonywania określonych zadań. Funkcje można zdefiniować raz i wywołać wielokrotnie, co czyni kod bardziej modułowym, czytelnym i łatwiejszym w utrzymaniu.
Definiowanie funkcji
W JavaScript istnieje kilka sposobów definiowania funkcji. Zacznijmy od najbardziej podstawowej - deklaracji funkcji:
// Podstawowa składnia deklaracji funkcji
function functionName(parameter1, parameter2, ...) {
// Blok kodu do wykonania
return value; // Opcjonalna instrukcja zwracająca wartość
}W kontekście Parku Jurajskiego, moglibyśmy stworzyć funkcję do sprawdzania bezpieczeństwa wybiegu:
// Funkcja sprawdzająca bezpieczeństwo wybiegu
function checkEnclosureSafety(powerLevel, fenceCondition, dinoSpecies) {
// Warunki bezpieczeństwa zależne od gatunku
let minPowerLevel;
if (dinoSpecies === "Tyranozaur" || dinoSpecies === "Velociraptor") {
minPowerLevel = 90; // Dla niebezpiecznych drapieżników wymagamy wysokiego poziomu zasilania
} else if (dinoSpecies === "Dilofozaur" || dinoSpecies === "Karnotaur") {
minPowerLevel = 75; // Dla mniejszych drapieżników
} else {
minPowerLevel = 50; // Dla roślinożerców
}
// Sprawdzenie warunków bezpieczeństwa
if (powerLevel < minPowerLevel) {
return "NIEBEZPIECZNE: Zbyt niski poziom zasilania dla tego gatunku!";
}
if (fenceCondition !== "sprawne") {
return "NIEBEZPIECZNE: Ogrodzenie wymaga naprawy!";
}
return "BEZPIECZNE: Wybieg spełnia wszystkie wymogi bezpieczeństwa.";
}
// Przykłady użycia funkcji
let tRexInspectionResult = checkEnclosureSafety(85, "sprawne", "Tyranozaur");
console.log(`Wybieg T-Rex: ${tRexInspectionResult}`); // "Wybieg T-Rex: NIEBEZPIECZNE: Zbyt niski poziom zasilania dla tego gatunku!"
let triceratopsInspectionResult = checkEnclosureSafety(60, "sprawne", "Triceratops");
console.log(`Wybieg Triceratops: ${triceratopsInspectionResult}`); // "Wybieg Triceratops: BEZPIECZNE: Wybieg spełnia wszystkie wymogi bezpieczeństwa."Wyrażenia funkcyjne
Innym sposobem definiowania funkcji jest użycie wyrażenia funkcyjnego, gdzie funkcja jest przypisana do zmiennej:
// Wyrażenie funkcyjne
const functionName = function(parameter1, parameter2, ...) {
// Blok kodu do wykonania
return value; // Opcjonalnie
};Przykład z Parku Jurajskiego:
// Funkcja obliczająca dzienne zapotrzebowanie na pokarm
const calculateDailyFoodRequirement = function(species, weight, age) {
let baseFactor;
// Określenie podstawowego wskaźnika w zależności od diety
if (["Tyranozaur", "Velociraptor", "Spinozaur"].includes(species)) {
baseFactor = 0.10; // 10% wagi ciała dla mięsożerców
} else if (["Allozaur", "Karnotaur", "Dilofozaur"].includes(species)) {
baseFactor = 0.08; // 8% wagi ciała dla mniejszych mięsożerców
} else {
baseFactor = 0.15; // 15% wagi ciała dla roślinożerców (jedzą więcej, ale mniej kaloryczny pokarm)
}
// Korekta ze względu na wiek (młode osobniki jedzą proporcjonalnie więcej)
let ageFactor = age < 5 ? 1.5 : age < 10 ? 1.2 : 1.0;
// Obliczenie dziennego zapotrzebowania na pokarm w kg
let dailyRequirement = weight * baseFactor * ageFactor;
return Math.round(dailyRequirement * 10) / 10; // Zaokrąglenie do 1 miejsca po przecinku
};
// Przykłady użycia
console.log(`Dzienne zapotrzebowanie na pokarm dla młodego T-Rexa: ${calculateDailyFoodRequirement("Tyranozaur", 2000, 3)} kg`);
// "Dzienne zapotrzebowanie na pokarm dla młodego T-Rexa: 300 kg"
console.log(`Dzienne zapotrzebowanie na pokarm dla dorosłego Stegozaura: ${calculateDailyFoodRequirement("Stegozaur", 5000, 12)} kg`);
// "Dzienne zapotrzebowanie na pokarm dla dorosłego Stegozaura: 750 kg"Funkcje strzałkowe (Arrow functions)
Funkcje strzałkowe to bardziej zwięzły sposób zapisywania funkcji, wprowadzony w ES6:
// Składnia funkcji strzałkowej
const functionName = (parameter1, parameter2, ...) => {
// Blok kodu
return value;
};
// Dla prostych funkcji z jednym wyrażeniem, można pominąć klamry i słowo return
const simpleSum = (a, b) => a + b;Przykład zastosowania w Parku Jurajskim:
// Funkcja strzałkowa do klasyfikowania dinozaurów
const classifyDinosaur = (species, length, speed) => {
// Klasyfikacja zagrożenia na podstawie gatunku, rozmiaru i prędkości
if (["Tyranozaur", "Spinozaur"].includes(species) && length > 10) {
return "Najwyższe zagrożenie - Klasa A";
} else if (["Velociraptor", "Dilofozaur"].includes(species) && speed > 30) {
return "Wysokie zagrożenie - Klasa B";
} else if (["Allozaur", "Karnotaur"].includes(species)) {
return "Średnie zagrożenie - Klasa C";
} else if (species.includes("raptor") || speed > 40) {
return "Podwyższone zagrożenie - Klasa D";
} else {
return "Niskie zagrożenie - Klasa E";
}
};
// Proste funkcje strzałkowe bez bloku kodu
const isPredator = species => ["Tyranozaur", "Velociraptor", "Spinozaur", "Allozaur", "Karnotaur", "Dilofozaur"].includes(species);
const estimateSpeed = (limbLength, mass) => Math.round(limbLength * 0.7 * (100 / mass));
// Przykłady użycia
console.log(classifyDinosaur("Tyranozaur", 12, 27)); // "Najwyższe zagrożenie - Klasa A"
console.log(classifyDinosaur("Gallimim", 2, 45)); // "Podwyższone zagrożenie - Klasa D"
console.log(isPredator("Stegozaur")); // false
console.log(estimateSpeed(2.5, 20)); // 9Parametry funkcji
Funkcje mogą przyjmować parametry, które są zmiennymi lokalnymi dostępnymi wewnątrz funkcji:
Parametry domyślne
Od ES6 możemy definiować wartości domyślne dla parametrów:
function setIncubatorTemperature(species, temperature = 37.5) {
console.log(`Ustawiono temperaturę inkubatora dla jaj ${species} na ${temperature}°C`);
// Dalszy kod...
}
setIncubatorTemperature("Velociraptor"); // "Ustawiono temperaturę inkubatora dla jaj Velociraptor na 37.5°C"
setIncubatorTemperature("Triceratops", 36.2); // "Ustawiono temperaturę inkubatora dla jaj Triceratops na 36.2°C"Parametry resztowe (Rest parameters)
Pozwalają na przekazanie nieokreślonej liczby argumentów jako tablicy:
function monitorDinosaurs(...ids) {
console.log(`Monitorowanie ${ids.length} dinozaurów...`);
for (let id of ids) {
console.log(`Sprawdzanie dinozaura #${id}...`);
// Kod monitorowania...
}
return `Zakończono monitorowanie ${ids.length} dinozaurów.`;
}
console.log(monitorDinosaurs(101, 102, 103, 104, 105));
// Wyświetli:
// "Monitorowanie 5 dinozaurów..."
// "Sprawdzanie dinozaura #101..."
// "Sprawdzanie dinozaura #102..."
// "Sprawdzanie dinozaura #103..."
// "Sprawdzanie dinozaura #104..."
// "Sprawdzanie dinozaura #105..."
// "Zakończono monitorowanie 5 dinozaurów."Zwracanie wartości
Funkcje mogą zwracać wartości za pomocą instrukcji return:
function analyzeDnaSample(sample) {
// Kod analizy próbki...
if (!sample || sample.length < 10) {
return { success: false, message: "Niewystarczająca ilość materiału genetycznego." };
}
// Symulacja analizy
const species = ["Tyranozaur", "Triceratops", "Velociraptor", "Stegozaur", "Brontozaur"];
const randomIndex = Math.floor(Math.random() * species.length);
return {
success: true,
species: species[randomIndex],
dnaPurity: Math.round(Math.random() * 50 + 50), // 50-100%
completeness: Math.round(Math.random() * 40 + 60), // 60-100%
message: "Analiza zakończona pomyślnie."
};
}
const analysisResult = analyzeDnaSample("ACGTAAGTCCTGAT");
console.log(analysisResult);
// Przykładowy wynik:
// {
// success: true,
// species: "Velociraptor",
// dnaPurity: 87,
// completeness: 75,
// message: "Analiza zakończona pomyślnie."
// }
if (analysisResult.success) {
console.log(`Zidentyfikowano DNA ${analysisResult.species}a o czystości ${analysisResult.dnaPurity}%`);
} else {
console.log(`Błąd analizy: ${analysisResult.message}`);
}Zakres zmiennych (Scope)
Zmienne zdefiniowane wewnątrz funkcji są lokalne dla tej funkcji i nie są dostępne na zewnątrz:
function prepareJurassicIncident() {
// Zmienna lokalna, niedostępna poza funkcją
let secretSystemCode = "TRex1993";
console.log(`Kod wygenerowany wewnątrz funkcji: ${secretSystemCode}`);
return "Incydent przygotowany.";
}
prepareJurassicIncident();
// Próba dostępu do zmiennej lokalnej poza funkcją spowoduje błąd
// console.log(secretSystemCode); // ReferenceError: secretSystemCode is not defined
// Zmienne zdefiniowane na zewnątrz funkcji są dostępne wewnątrz
let jurassicParkLocation = "Isla Nublar";
function displayParkInfo() {
// Dostęp do zmiennej zewnętrznej
console.log(`Park Jurajski znajduje się na wyspie: ${jurassicParkLocation}`);
// Zmienna lokalna
let dinosaurCount = 200;
console.log(`Aktualna liczba dinozaurów: ${dinosaurCount}`);
}
displayParkInfo();
// console.log(dinosaurCount); // ReferenceError: dinosaurCount is not definedFunkcje zagnieżdżone
Funkcje mogą być zdefiniowane wewnątrz innych funkcji:
function conductScientificResearch(species) {
console.log(`Rozpoczęcie badań naukowych nad gatunkiem: ${species}`);
// Funkcja zagnieżdżona - dostępna tylko wewnątrz conductScientificResearch
function analyzeSample() {
console.log(`Analizowanie próbki DNA ${species}a...`);
return "Analiza kompletna";
}
// Inna funkcja zagnieżdżona
function simulateGrowth() {
console.log(`Symulowanie wzrostu i rozwoju ${species}a...`);
return "Symulacja ukończona";
}
// Wywołanie funkcji zagnieżdżonych
const analysisResult = analyzeSample();
const simulationResult = simulateGrowth();
return {
species,
analysisResult,
simulationResult,
researchDate: new Date().toISOString()
};
}
const researchReport = conductScientificResearch("Velociraptor");
console.log(researchReport);
// Funkcje zagnieżdżone nie są dostępne poza funkcją zewnętrzną
// analyzeSample(); // ReferenceError: analyzeSample is not definedFunkcje wyższego rzędu (Higher-order functions)
W JavaScript funkcje są obiektami pierwszej klasy, co oznacza, że mogą być przekazywane jako argumenty do innych funkcji lub zwracane przez funkcje:
// Funkcja przyjmująca inną funkcję jako parametr
function monitorEnclosure(enclosureId, alarmFunction) {
console.log(`Monitorowanie wybiegu #${enclosureId}`);
// Symulacja problemu
const anomalyDetected = Math.random() > 0.7;
if (anomalyDetected) {
// Wywołanie przekazanej funkcji w przypadku wykrycia problemu
alarmFunction(`Anomalia wykryta w wybiegu #${enclosureId}!`);
}
return { enclosureId, status: anomalyDetected ? "Anomalia" : "Normalny" };
}
// Funkcje, które mogą być przekazane jako argument
function soundAlarm(message) {
console.log(`ALARM DŹWIĘKOWY: ${message}`);
}
function visualAlarm(message) {
console.log(`ALARM WIZUALNY: ${message}`);
}
function staffNotifications(message) {
console.log(`POWIADOMIENIE SMS: ${message}`);
}
// Użycie funkcji wyższego rzędu z różnymi funkcjami alarmowymi
monitorEnclosure(1, soundAlarm);
monitorEnclosure(2, visualAlarm);
monitorEnclosure(3, staffNotifications);
// Możemy także przekazać funkcję anonimową
monitorEnclosure(4, function(message) {
console.log(`PROCEDURA AWARYJNA: ${message}`);
console.log("Uruchamianie protokołu ewakuacji...");
});
// Lub funkcję strzałkową
monitorEnclosure(5, message => console.log(`RAPORT DIAGNOSTYCZNY: ${message}`));Funkcja zwracająca funkcję
// Funkcja tworząca i zwracająca inną funkcję
function createSpeciesMonitor(species) {
// Zwracamy nową funkcję dostosowaną do konkretnego gatunku
return function(action) {
const actionTime = new Date().toLocaleTimeString();
console.log(`[${actionTime}] ${species}: ${action}`);
// Dodatkowa logika zależna od gatunku
if (["Tyranozaur", "Velociraptor", "Dilofozaur"].includes(species) && action.includes("blisko ogrodzenia")) {
console.log(`OSTRZEŻENIE! Niebezpieczny drapieżnik ${species} blisko ogrodzenia!`);
}
};
}
// Tworzenie monitorów dla różnych gatunków
const tRexMonitor = createSpeciesMonitor("Tyranozaur");
const triceratopsMonitor = createSpeciesMonitor("Triceratops");
// Używanie zwróconych funkcji
tRexMonitor("Porusza się w kierunku południowym");
tRexMonitor("Zbliża się blisko ogrodzenia");
triceratopsMonitor("Żeruje w północnej części wybiegu");Natychmiastowo wywoływane wyrażenia funkcyjne (IIFE)
IIFE (Immediately Invoked Function Expression) to funkcja, która jest zdefiniowana i wywołana natychmiast:
// Struktura IIFE
(function() {
// Kod funkcji...
})();
// IIFE z parametrami
(function(name) {
console.log(`Inicjalizacja systemu: ${name}`);
})("Park Jurajski");IIFE są przydatne do tworzenia prywatnego zakresu i unikania zanieczyszczania globalnego obiektu:
// Inicjalizacja systemu Parku Jurajskiego za pomocą IIFE
const jurassicParkSystem = (function() {
// Prywatne zmienne, niedostępne z zewnątrz
const securityCodes = {
mainGates: "GATES1993",
laboratory: "INGEN2015",
powerSystem: "NEDRY1992"
};
let systemStatus = "offline";
let securityLevel = 0;
// Prywatne funkcje
function validateCode(providedCode, requiredCode) {
return providedCode === requiredCode;
}
// Publiczny interfejs - tylko te funkcje będą dostępne na zewnątrz
return {
startSystem: function() {
systemStatus = "online";
securityLevel = 3;
console.log("System Parku Jurajskiego uruchomiony.");
return true;
},
checkStatus: function() {
return {
status: systemStatus,
securityLevel,
updateTime: new Date().toISOString()
};
},
grantAccess: function(area, code) {
if (!validateCode(code, securityCodes[area])) {
console.log(`Odmowa dostępu do obszaru: ${area}`);
return false;
}
console.log(`Dostęp przyznany do obszaru: ${area}`);
return true;
}
};
})();
// Używanie publicznego interfejsu
jurassicParkSystem.startSystem();
console.log(jurassicParkSystem.checkStatus());
jurassicParkSystem.grantAccess("mainGates", "GATES1993"); // true
jurassicParkSystem.grantAccess("laboratory", "nieprawidłowy kod"); // false
// Próba dostępu do prywatnych zmiennych nie powiedzie się
// console.log(jurassicParkSystem.securityCodes); // undefined
// console.log(jurassicParkSystem.validateCode); // undefinedRekurencja
Rekurencja to technika, w której funkcja wywołuje samą siebie:
// Funkcja rekurencyjna symulująca reprodukcję dinozaurów
function simulateReproduction(initialPopulation, yearsAhead, growthRate = 1.5) {
// Warunek zakończenia rekurencji
if (yearsAhead <= 0) {
return initialPopulation;
}
// Obliczenie nowej populacji po jednym roku
const newPopulation = Math.round(initialPopulation * growthRate);
console.log(`Rok ${yearsAhead} do końca symulacji. Populacja: ${newPopulation}`);
// Wywołanie rekurencyjne z nową populacją i zmniejszonym licznikiem lat
return simulateReproduction(newPopulation, yearsAhead - 1, growthRate);
}
// Początkowa populacja: 2 dinozaury, symulacja na 5 lat do przodu
const finalPopulation = simulateReproduction(2, 5);
console.log(`Końcowa populacja po 5 latach: ${finalPopulation}`);
// Wynik:
// Rok 5 do końca symulacji. Populacja: 3
// Rok 4 do końca symulacji. Populacja: 5
// Rok 3 do końca symulacji. Populacja: 8
// Rok 2 do końca symulacji. Populacja: 12
// Rok 1 do końca symulacji. Populacja: 18
// Końcowa populacja po 5 latach: 18Ważne jest, aby zawsze mieć warunek zakończenia rekurencji, aby uniknąć nieskończonych wywołań, które mogą spowodować błąd przepełnienia stosu.
Hoisting
Hoisting to zachowanie JavaScript, które "przenosi" deklaracje na górę ich zakresu:
// Możemy wywołać funkcję przed jej deklaracją dzięki hoistingowi
console.log(checkParkSafety()); // "Park bezpieczny"
// Deklaracja funkcji jest przeniesiona na górę
function checkParkSafety() {
return "Park bezpieczny";
}
// Jednak wyrażenia funkcyjne nie są w pełni hoistowane
// console.log(calculateRisk()); // Error: calculateRisk is not a function
// Tylko deklaracja zmiennej jest hoistowana, ale nie jej wartość
var calculateRisk = function() {
return "Niskie ryzyko";
};
// Podobnie z let i const - są hoistowane, ale nie inicjalizowane
// console.log(analyzeData); // ReferenceError: Cannot access 'analyzeData' before initialization
let analyzeData = function() {
return "Analiza kompletna";
};Domknięcia (Closures)
Domknięcie powstaje, gdy funkcja wewnętrzna ma dostęp do zakresu funkcji zewnętrznej, nawet po jej zakończeniu:
function createDinosaurCounter(roomName) {
let dinosaurCount = 0;
// Funkcja wewnętrzna tworzy domknięcie
function updateCounter(change) {
dinosaurCount += change;
console.log(`${roomName}: Aktualna liczba dinozaurów: ${dinosaurCount}`);
return dinosaurCount;
}
return {
addDinosaur: function() {
return updateCounter(1);
},
removeDinosaur: function() {
return updateCounter(-1);
},
getDinosaurCount: function() {
return dinosaurCount;
}
};
}
// Tworzenie dwóch niezależnych liczników dla różnych pomieszczeń
const enclosureACounter = createDinosaurCounter("Wybieg A");
const enclosureBCounter = createDinosaurCounter("Wybieg B");
enclosureACounter.addDinosaur(); // "Wybieg A: Aktualna liczba dinozaurów: 1"
enclosureACounter.addDinosaur(); // "Wybieg A: Aktualna liczba dinozaurów: 2"
enclosureBCounter.addDinosaur(); // "Wybieg B: Aktualna liczba dinozaurów: 1"
enclosureACounter.removeDinosaur(); // "Wybieg A: Aktualna liczba dinozaurów: 1"Domknięcia są niezwykle przydatne w tworzeniu funkcji fabrycznych, enkapsulacji danych, i w realizacji wzorców projektowych.
Dobre praktyki przy używaniu funkcji
Jedna funkcja, jedno zadanie: Funkcje powinny być zaprojektowane do wykonywania jednego, konkretnego zadania. Ułatwia to testowanie, debugowanie i utrzymanie kodu.
Opisowe nazwy funkcji: Używaj jasnych, opisowych nazw funkcji, które wskazują na ich przeznaczenie (np.
loginUserzamiastuFunc1).Ograniczenie liczby parametrów: Staraj się ograniczać liczbę parametrów. Jeśli funkcja wymaga wielu parametrów, rozważ użycie obiektu opcji:
// Zamiast:
function configureSecuritySystem(powerLevel, sensorSensitivity, reactionTime, operationMode, notifications) {
//
}
// Użyj:
function configureSecuritySystem(options) {
const {
powerLevel = 100,
sensorSensitivity = "wysoka",
reactionTime = 5,
operationMode = "automatyczny",
notifications = true
} = options;
//
}
// Wywołanie:
configureSecuritySystem({
powerLevel: 90,
reactionTime: 3,
operationMode: "ręczny"
});Unikanie efektów ubocznych: Staraj się, aby funkcje nie zmieniały zmiennych spoza swojego zakresu ani przekazanych im obiektów i tablic (funkcja dostaje odwołanie do tego samego obiektu, więc zmiana będzie widoczna na zewnątrz).
Konwencje zwracania wartości: Bądź konsekwentny w zwracaniu wartości. Unikaj funkcji, które czasami zwracają wartość, a czasami nie.
Obsługa błędów: Zawsze uwzględniaj potencjalne błędy i obsługuj je odpowiednio, używając bloków try-catch lub zwracając obiekty statusu.
function cloneDinosaur(dna) {
try {
if (!dna || dna.length < 100) {
throw new Error("Niewystarczająca ilość DNA do klonowania");
}
// Kod klonowania...
return {
success: true,
dinosaur: { species: "Velociraptor", id: "VR-" + Math.floor(Math.random() * 1000) }
};
} catch (error) {
console.error(`Błąd klonowania: ${error.message}`);
return {
success: false,
error: error.message
};
}
}Przyszłość JavaScript - TC39 i propozycje rozwoju języka
Podobnie jak DNA dinozaurów nieustannie ewoluowało, aby dostosować się do zmieniającego się środowiska, JavaScript również przechodzi ciągły proces ewolucji. Za tym procesem stoi TC39 - komitet techniczny odpowiedzialny za rozwój języka JavaScript.
Czym jest TC39?
TC39 (Technical Committee 39) to grupa ekspertów, która zarządza rozwojem specyfikacji ECMAScript (oficjalnej nazwy standardu JavaScript). W skład TC39 wchodzą przedstawiciele firm takich jak Google, Mozilla, Apple, Microsoft oraz innych organizacji i niezależni eksperci.
Podobnie jak rada naukowa Parku Jurajskiego decyduje o tym, które gatunki dinozaurów będą hodowane i jak będą zarządzane, TC39 decyduje o tym, jakie nowe funkcjonalności trafią do JavaScript i w jakiej formie.
Proces propozycji - etapy 0-4
Każda nowa funkcjonalność w JavaScript przechodzi przez etapy (stages) 0, 1, 2, 2.7, 3 i 4, od pomysłu do implementacji:
Stage 0 - Strawman (Strach na wróble)
Najwcześniejszy etap - to jak pierwsza szkicowa wizja nowego gatunku dinozaura na papierze. Każdy może zgłosić pomysł. Nie ma żadnych formalnych wymagań, to po prostu miejsce na dzielenie się pomysłami.
Stage 1 - Proposal (Propozycja)
Komitet uznał, że pomysł jest wart rozważenia. To jak faza, gdy naukowcy Parku Jurajskiego zdecydowali, że warto poważnie rozważyć klonowanie konkretnego gatunku. Na tym etapie:
- Identyfikuje się problem, który propozycja ma rozwiązać
- Opisuje się ogólne rozwiązanie
- Identyfikuje się potencjalne wyzwania
Stage 2 - Draft (Szkic)
Propozycja ma teraz wstępną specyfikację techniczną. To jak szczegółowy plan genetyczny i procedury hodowlane dla nowego dinozaura. Na tym etapie:
- Składnia jest w dużej mierze ukształtowana
- Semantyka jest opisana formalnie
- Oczekuje się, że funkcjonalność zostanie ostatecznie włączona do języka
Stage 2.7 - Zatwierdzona specyfikacja (od 2024 roku)
Komitet zatwierdził specyfikację, a teraz powstają testy zgodności (test262). Dopiero z nimi przeglądarki zaczynają implementację.
Stage 3 - Candidate (Kandydat)
Specyfikacja jest kompletna i czeka na feedback z implementacji. To jak pierwsze próby klonowania - mamy kompletny plan, teraz testujemy go w praktyce. Na tym etapie:
- Przeglądarki i środowiska zaczynają implementować funkcjonalność
- Zbiera się feedback od programistów
- Wprowadza się jedynie drobne poprawki
Stage 4 - Finished (Ukończona)
Propozycja jest gotowa do włączenia do oficjalnej specyfikacji ECMAScript! To jak moment, gdy nowy dinozaur pomyślnie się wykluwa i jest gotowy do prezentacji w parku. Na tym etapie:
- Co najmniej dwie niezależne implementacje istnieją
- Testy są napisane i zaakceptowane
- Funkcjonalność zostanie włączona do następnej wersji ECMAScript
Ciekawe propozycje na różnych etapach
Przyjrzyjmy się kilku fascynującym propozycjom, które mogą zmienić sposób, w jaki piszemy kod JavaScript:
Pipeline Operator (|>) - Stage 2
Operator pipeline pozwala na łańcuchowanie operacji w bardziej czytelny sposób, podobnie jak kanały w systemie transportu wody w Parku Jurajskim:
// Bez pipeline operator
const result = Math.round(Math.max(5, 10, 15) * 2);
// Z pipeline operator (% oznacza wynik poprzedniego kroku)
const result = Math.max(5, 10, 15)
|> % * 2
|> Math.round(%);
// Przykład z systemem bezpieczeństwa parku
const securityStatus = fetchSensorData()
|> filterActiveSensors(%)
|> analyzeThreatLevel(%)
|> generateSecurityReport(%);Records & Tuples - propozycja wycofana
Records & Tuples, czyli niezmienne struktury danych porównywane przez wartość, doszły do Stage 2, ale w 2025 roku komitet wycofał tę propozycję. To dobry przykład, że nie każda propozycja trafia do języka.
Pattern Matching - Stage 1
Potężny mechanizm dopasowywania wzorców, który sprawia, że kod warunkowy staje się bardziej czytelny. To jak system klasyfikacji dinozaurów - możemy precyzyjnie dopasować działania do różnych typów:
// Zamiast wielu if/else lub switch
const handleDinosaur = (dino) => {
match (dino) {
when ({ species: "Tyrannosaurus Rex", health: health }) if (health < 50) -> {
return "Wezwij weterynarza dla T-Rexa!";
}
when ({ diet: "carnivore", escaped: true }) -> {
return "ALARM! Drapieżnik uciekł!";
}
when ({ species: "Velociraptor" }) -> {
return "Sprawdź zabezpieczenia wybiegu";
}
when ({ health: h }) if (h > 90) -> {
return "Dinozaur w doskonałej kondycji";
}
default -> {
return "Standardowa procedura monitoringu";
}
}
};Decorators - Stage 3
Dekoratory pozwalają na modyfikowanie klas i ich członków w deklaratywny sposób. To jak system tagów i czipów dla dinozaurów - dodajemy dodatkowe funkcjonalności bez modyfikowania podstawowej struktury:
// Dekorator do logowania wywołań metod
function log(method, context) {
return function (...args) {
console.log(`Wywołanie ${context.name} z argumentami: ${JSON.stringify(args)}`);
const result = method.apply(this, args);
console.log(`Wynik: ${result}`);
return result;
};
}
class DinosaurMonitor {
@log
checkHealth(dinosaurId) {
// Sprawdzanie stanu zdrowia
return "healthy";
}
@log
feedDinosaur(dinosaurId, foodAmount) {
// Karmienie dinozaura
return "fed";
}
}
// Każde wywołanie metody będzie automatycznie logowane!
const monitor = new DinosaurMonitor();
monitor.checkHealth("TREX-001");
// Konsola: Wywołanie checkHealth z argumentami: ["TREX-001"]
// Konsola: Wynik: healthyJak śledzić rozwój języka?
Jeśli chcesz być na bieżąco z ewolucją JavaScript, podobnie jak naukowcy Parku Jurajskiego monitorują ewolucję swoich dinozaurów, możesz:
Repozytorium GitHub TC39: https://github.com/tc39/proposals
- Pełna lista wszystkich propozycji z ich aktualnymi statusami
- Dyskusje i dokumentacja techniczna
TC39 Meeting Notes: https://github.com/tc39/notes
- Notatki ze spotkań komitetu
- Wgląd w proces decyzyjny
Can I Use: https://caniuse.com
- Sprawdzanie wsparcia przeglądarek dla nowych funkcji
- Planowanie, kiedy bezpiecznie używać nowych funkcjonalności
Babel: https://babeljs.io
- Możliwość eksperymentowania z nowymi funkcjami już teraz
- Transpilacja nowoczesnego kodu do wersji obsługiwanej przez starsze przeglądarki
TC39 Website: https://tc39.es
- Oficjalna strona komitetu
- Dokumentacja procesu i zasad
Dlaczego warto śledzić propozycje TC39?
- Przygotowanie na przyszłość - poznanie nadchodzących funkcji pozwala planować architekturę aplikacji z myślą o przyszłości
- Wpływ na język - społeczność może zgłaszać feedback i wpływać na kształt nowych funkcjonalności
- Przewaga konkurencyjna - znajomość najnowszych możliwości języka czyni cię bardziej wartościowym programistą
- Lepsza jakość kodu - nowe funkcje często oferują czystsze i bezpieczniejsze sposoby rozwiązywania problemów
Podobnie jak Park Jurajski nieustannie ewoluuje, dodając nowe gatunki i ulepszając systemy bezpieczeństwa, JavaScript także nieustannie się rozwija. Zrozumienie procesu TC39 i śledzenie nowych propozycji to jak posiadanie mapy genetycznej przyszłości języka - pozwala nam przygotować się na to, co nadchodzi, i kształtować tę przyszłość poprzez aktywny udział w społeczności.
Podsumowanie
Funkcje w JavaScript, podobnie jak wyspecjalizowane zespoły w Parku Jurajskim, pozwalają na:
- Organizację kodu - grupowanie powiązanej logiki w jednym miejscu
- Wielokrotne użycie - definiowanie logiki raz i używanie jej wielokrotnie
- Abstrakcję - ukrywanie szczegółów implementacji za prostym interfejsem
- Modularność - budowanie złożonych systemów z prostszych, niezależnych komponentów
Główne koncepcje dotyczące funkcji:
- Różne sposoby definiowania: deklaracje, wyrażenia, funkcje strzałkowe
- Parametry i argumenty, w tym parametry domyślne i resztowe
- Zwracanie wartości
- Zakres zmiennych
- Funkcje wyższego rzędu
- Rekurencja
- Domknięcia
Poznaliśmy też mechanizm TC39 i proces rozwoju JavaScript - od propozycji Stage 0 do gotowej implementacji w Stage 4. Zrozumienie tego procesu pozwala nam być na bieżąco z ewolucją języka i przygotować się na przyszłość programowania w JavaScript.
W następnej lekcji połączysz wszystko, czego się nauczyłeś, w projekcie końcowym.
Kod do tej lekcji: index.js
// Funkcje w JavaScript
// Różne sposoby definiowania i używania funkcji
// === Deklaracja funkcji ===
console.log("=== Deklaracja funkcji ===");
function sprawdzZdrowie(nazwa, zdrowie) {
if (zdrowie > 80) {
return nazwa + " - DOSKONAŁY";
} else if (zdrowie > 50) {
return nazwa + " - DOBRY";
} else {
return nazwa + " - WYMAGA OPIEKI";
}
}
console.log(sprawdzZdrowie("T-Rex", 95));
console.log(sprawdzZdrowie("Raptor", 72));
console.log(sprawdzZdrowie("Brachio", 45));
// === Parametry domyślne ===
console.log("\n=== Parametry domyślne ===");
function nakarmDinozaura(nazwa, ilosc = 50) {
console.log(nazwa + " nakarmiony: " + ilosc + " kg");
}
nakarmDinozaura("T-Rex", 200);
nakarmDinozaura("Compy"); // użyje domyślnej wartości 50
// === Arrow functions ===
console.log("\n=== Arrow functions ===");
const obliczWiek = (rokOdkrycia) => 2024 - rokOdkrycia;
console.log("T-Rex odkryty w 1905, lata badań:", obliczWiek(1905));
console.log("Triceratops odkryty w 1889, lata badań:", obliczWiek(1889));
// Arrow z wieloma liniami
const profilDinozaura = (nazwa, waga, dieta) => {
const zagrozenie = dieta === "mięsożerca" ? "WYSOKIE" : "NISKIE";
return nazwa + " (" + waga + "kg) - Zagrożenie: " + zagrozenie;
};
console.log(profilDinozaura("T-Rex", 7000, "mięsożerca"));
console.log(profilDinozaura("Brachio", 80000, "roślinożerca"));
// === Funkcje jako argumenty (callback) ===
console.log("\n=== Callback ===");
const dinozaury = ["T-Rex", "Velociraptor", "Triceratops"];
dinozaury.forEach(function(dino, index) {
console.log((index + 1) + ". " + dino);
});
// Z arrow function
const wagi = [7000, 15, 8000, 80000];
const duze = wagi.filter(w => w > 5000);
console.log("\nDuże dinozaury (>5000kg):", duze);
// === Return ===
console.log("\n=== Funkcja z return ===");
function znajdzNajwiekszego(tablica) {
let max = tablica[0];
for (const wartosc of tablica) {
if (wartosc > max) {
max = wartosc;
}
}
return max;
}
console.log("Najcięższy:", znajdzNajwiekszego(wagi), "kg");
// Twoje zadanie:
// 1. Stwórz funkcję obliczającą średnią z tablicy
// 2. Użyj arrow function do filtrowania danych
// 3. Napisz funkcję z parametrem domyślnym
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 to jest parametr domyślny (default parameter) w funkcji?
2. Co nowoczesny silnik JavaScript (np. V8) robi z fragmentem kodu, który wykonuje się bardzo często („gorącym” kodem)?
3. Co zwróci wyrażenie 0 === false w JavaScript?
4. Która warstwa aplikacji webowej jest odpowiedzialna za komunikację z serwerem?
5. Jaki jest PIERWSZY krok w procesie debugowania JavaScript?
6. Jaki zakres mają zmienne zadeklarowane za pomocą let i const?
Zadania praktyczne w grze
- Edytor kodu
Napisz funkcję calculateFoodPortion(diet, weightKg), która zwraca dzienną porcję jedzenia w kg: 5% wagi dla diety 'carnivore', 3% dla 'herbivore' i 4% dla 'omnivore'. Wywołaj ją dla T-Rexa ('carnivore', 8000) i wyświetl wynik w konsoli.
- Układanie w poziomie
Ułóż elementy wywołania funkcji z argumentami:
- Układanie w pionie
Uporządkuj etapy definiowania i wywoływania funkcji w JavaScript:
- Klikanie w kolejności
Ułóż elementy deklaracji funkcji w prawidłowej kolejności:
- Edytor kodu
Napisz funkcję calculateFossilAge(currentYear, fossilYear), która zwraca wiek skamieniałości w milionach lat: (currentYear - fossilYear) / 1000000. Rok sprzed naszej ery zapisz jako liczbę ujemną. Wywołaj ją dla T-Rexa (2024, -68000000) i wyświetl wynik w konsoli.
- Klikanie w kolejności
Ułóż elementy arrow function w prawidłowej kolejności:
- Edytor kodu
Masz dane wybiegu: const voltage = 8500 i const fenceHealth = 40. Utwórz zmienną isSafe, która jest prawdą, gdy voltage > 5000 i jednocześnie fenceHealth > 50 (użyj &&), oraz zmienną needsAttention, która jest prawdą, gdy fenceHealth < 50 lub voltage === 0 (użyj ||). Wyświetl obie w konsoli.
Zadania po tej lekcji
- PytanieParametry funkcji
- Zadanie z kodemPraktyka: Funkcje
- Ułóż w kolejnościWywołanie funkcji
- Ułóż w kolejnościEtapy definiowania i wywoływania funkcji
- Kliknij w kolejnościSortowanie: Deklaracja funkcji
- Zadanie z kodemĆwiczenie: Napisz funkcję obliczającą wiek skamieniałości
- Kliknij w kolejnościSortowanie: Arrow function
- PytanieSilnik JavaScript a często wykonywany kod
- PytanieOperator ścisłego porównania
- PytanieWarstwy aplikacji webowej
- Zadanie z kodemPraktyka: Operatory porównania i logiczne
- PytanieProces debugowania JavaScript
- PytanieZakres zmiennych let i const