Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript

Funkcje

18 min czytania ·
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)); // 9

Parametry 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 defined

Funkcje 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 defined

Funkcje 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); // undefined

Rekurencja

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: 18

Waż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

  1. Jedna funkcja, jedno zadanie: Funkcje powinny być zaprojektowane do wykonywania jednego, konkretnego zadania. Ułatwia to testowanie, debugowanie i utrzymanie kodu.

  2. Opisowe nazwy funkcji: Używaj jasnych, opisowych nazw funkcji, które wskazują na ich przeznaczenie (np. loginUser zamiast uFunc1).

  3. 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"
});
  1. 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).

  2. Konwencje zwracania wartości: Bądź konsekwentny w zwracaniu wartości. Unikaj funkcji, które czasami zwracają wartość, a czasami nie.

  3. 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: healthy

Jak ś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:

  1. Repozytorium GitHub TC39: https://github.com/tc39/proposals

    • Pełna lista wszystkich propozycji z ich aktualnymi statusami
    • Dyskusje i dokumentacja techniczna
  2. TC39 Meeting Notes: https://github.com/tc39/notes

    • Notatki ze spotkań komitetu
    • Wgląd w proces decyzyjny
  3. Can I Use: https://caniuse.com

    • Sprawdzanie wsparcia przeglądarek dla nowych funkcji
    • Planowanie, kiedy bezpiecznie używać nowych funkcjonalności
  4. Babel: https://babeljs.io

    • Możliwość eksperymentowania z nowymi funkcjami już teraz
    • Transpilacja nowoczesnego kodu do wersji obsługiwanej przez starsze przeglądarki
  5. TC39 Website: https://tc39.es

    • Oficjalna strona komitetu
    • Dokumentacja procesu i zasad

Dlaczego warto śledzić propozycje TC39?

  1. Przygotowanie na przyszłość - poznanie nadchodzących funkcji pozwala planować architekturę aplikacji z myślą o przyszłości
  2. Wpływ na język - społeczność może zgłaszać feedback i wpływać na kształt nowych funkcjonalności
  3. Przewaga konkurencyjna - znajomość najnowszych możliwości języka czyni cię bardziej wartościowym programistą
  4. 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:

  1. Organizację kodu - grupowanie powiązanej logiki w jednym miejscu
  2. Wielokrotne użycie - definiowanie logiki raz i używanie jej wielokrotnie
  3. Abstrakcję - ukrywanie szczegółów implementacji za prostym interfejsem
  4. 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. 1. Co to jest parametr domyślny (default parameter) w funkcji?

  2. 2. Co nowoczesny silnik JavaScript (np. V8) robi z fragmentem kodu, który wykonuje się bardzo często („gorącym” kodem)?

  3. 3. Co zwróci wyrażenie 0 === false w JavaScript?

  4. 4. Która warstwa aplikacji webowej jest odpowiedzialna za komunikację z serwerem?

  5. 5. Jaki jest PIERWSZY krok w procesie debugowania JavaScript?

  6. 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.

  1. PytanieParametry funkcji
  2. Zadanie z kodemPraktyka: Funkcje
  3. Ułóż w kolejnościWywołanie funkcji
  4. Ułóż w kolejnościEtapy definiowania i wywoływania funkcji
  5. Kliknij w kolejnościSortowanie: Deklaracja funkcji
  6. Zadanie z kodemĆwiczenie: Napisz funkcję obliczającą wiek skamieniałości
  7. Kliknij w kolejnościSortowanie: Arrow function
  8. PytanieSilnik JavaScript a często wykonywany kod
  9. PytanieOperator ścisłego porównania
  10. PytanieWarstwy aplikacji webowej
  11. Zadanie z kodemPraktyka: Operatory porównania i logiczne
  12. PytanieProces debugowania JavaScript
  13. PytanieZakres zmiennych let i const

Przydatne artykuły