Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Najlepsze praktyki

9 min czytania ·
W tej lekcji3

Tym razem Dr. Ian Malcolm wraz z całym zespołem Parku Jurajskiego przygotowali dla Ciebie kluczowy briefing. Po kilku incydentach w parku, w tym słynnej awarii systemu i ucieczce dinozaurów, zespół opracował zestaw najlepszych praktyk programistycznych, które mogłyby zapobiec podobnym katastrofom w przyszłości.

Zasady, które mogłyby uratować Park Jurajski

1. Waliduj wszystkie dane wejściowe

Problem w parku: System nie sprawdzał poprawnie danych o temperaturze inkubatorów jaj dinozaurów, co doprowadziło do niekontrolowanego rozmnażania się welociraptorów.

Rozwiązanie:

// Źle:
function ustawTemperaturęInkubatora(temperatura) {
  inkubator.temperatura = temperatura;
  // Co jeśli temperatura będzie zbyt wysoka? Lub to będzie string zamiast liczby?
}

// Dobrze:
function ustawTemperaturęInkubatora(temperatura) {
  // Sprawdzamy czy temperatura jest liczbą
  if (typeof temperatura !== 'number') {
    throw new Error('Temperatura musi być liczbą');
  }

  // Sprawdzamy czy temperatura mieści się w bezpiecznym zakresie
  if (temperatura < 20 || temperatura > 40) {
    throw new Error('Temperatura poza bezpiecznym zakresem (20-40°C)');
  }

  inkubator.temperatura = temperatura;
}

2. Używaj testów automatycznych

Problem w parku: Nikt nie przetestował systemu ogrodzenia elektrycznego w warunkach ekstremalnych, takich jak tropikalna burza.

Rozwiązanie:

// Zestaw testów dla systemu ogrodzenia
describe('System ogrodzenia', () => {
  test('powinien działać przy normalnym zasilaniu', () => {
    const ogrodzenie = new SystemOgrodzenia();
    ogrodzenie.włącz();
    expect(ogrodzenie.czyAktywne()).toBe(true);
  });

  test('powinien przełączyć się na zasilanie awaryjne podczas burzy', () => {
    const ogrodzenie = new SystemOgrodzenia();
    ogrodzenie.włącz();
    ogrodzenie.symulujPrzerwęWDostawieEnergii();
    expect(ogrodzenie.czyAktywne()).toBe(true);
    expect(ogrodzenie.źródłoZasilania).toBe('awaryjne');
  });

  test('powinien wysłać alert gdy baterie awaryjne są poniżej 20%', () => {
    const ogrodzenie = new SystemOgrodzenia();
    const alertMock = jest.fn();
    ogrodzenie.onNiskiPoziomBaterii = alertMock;

    ogrodzenie.ustawPoziomBaterii(15);

    expect(alertMock).toHaveBeenCalled();
  });
});

3. Stosuj zasadę pojedynczej odpowiedzialności

Problem w parku: Jeden system sterował zarówno drzwiami, jak i ogrodzeniami, kamerami oraz systemem bezpieczeństwa. Awaria jednego komponentu doprowadziła do kaskadowej awarii całego systemu.

Rozwiązanie:

// Źle:
class SystemParku {
  kontrolujDrzwi() { /* ... */ }
  zarządzajOgrodzeniem() { /* ... */ }
  monitorujKamery() { /* ... */ }
  sterujKlimatyzacją() { /* ... */ }
  // Ten obiekt robi zbyt wiele!
}

// Dobrze:
class SystemDrzwi {
  otwórz(id) { /* ... */ }
  zamknij(id) { /* ... */ }
  sprawdźStan(id) { /* ... */ }
}

class SystemOgrodzenia {
  włącz() { /* ... */ }
  wyłącz() { /* ... */ }
  sprawdźNapięcie() { /* ... */ }
}

class SystemMonitoringu {
  włączKamerę(id) { /* ... */ }
  wyłączKamerę(id) { /* ... */ }
  nagrywaj(id) { /* ... */ }
}

class CentralnySterownik {
  constructor(systemDrzwi, systemOgrodzenia, systemMonitoringu) {
    this.systemDrzwi = systemDrzwi;
    this.systemOgrodzenia = systemOgrodzenia;
    this.systemMonitoringu = systemMonitoringu;
  }

  uruchomProcedurębezpieczeństwa() {
    // Teraz koordynuje niezależne systemy
    this.systemDrzwi.zamknij('wszystkie');
    this.systemOgrodzenia.włącz();
    this.systemMonitoringu.nagrywaj('wszystkie');
  }
}

4. Obsługuj błędy i wyjątki

Problem w parku: System transportu jaj nie posiadał obsługi błędów, co doprowadziło do utraty cennego materiału genetycznego, gdy jeden z czujników przestał działać.

Rozwiązanie:

// Źle:
function przenieśJajo(idJaja, docelowaPozycja) {
  const jajo = bazaDanych.pobierzJajo(idJaja);
  ramięRobotyczne.przenieś(jajo, docelowaPozycja);
  bazaDanych.aktualizujPozycję(idJaja, docelowaPozycja);
  // Co jeśli którakolwiek z tych operacji się nie powiedzie?
}

// Dobrze:
async function przenieśJajo(idJaja, docelowaPozycja) {
  try {
    // Pobieramy jajo z bazy
    const jajo = await bazaDanych.pobierzJajo(idJaja);
    if (!jajo) {
      throw new Error(`Jajo o ID ${idJaja} nie zostało znalezione`);
    }

    // Przenosimy jajo za pomocą ramienia robotycznego
    try {
      await ramięRobotyczne.przenieś(jajo, docelowaPozycja);
    } catch (błąd) {
      console.error('Błąd podczas przenoszenia jaja:', błąd);
      wyslijAlert('Błąd ramienia robotycznego', błąd.message);
      return false;
    }

    // Aktualizujemy pozycję w bazie danych
    await bazaDanych.aktualizujPozycję(idJaja, docelowaPozycja);

    // Logujemy udaną operację
    logOperacji.dodaj(`Jajo ${idJaja} przeniesione do ${docelowaPozycja}`);

    return true;
  } catch (błąd) {
    console.error('Krytyczny błąd podczas przenoszenia jaja:', błąd);
    wyslijAlert('Krytyczny błąd', błąd.message);
    uruchomProcedurębezpieczeństwa();
    return false;
  }
}

5. Dokumentuj swój kod

Problem w parku: Po odejściu głównego inżyniera, nikt nie wiedział dokładnie jak działa system kontroli dostępu.

Rozwiązanie:

/**
 * Weryfikuje poziom dostępu pracownika do stref parku.
 *
 * @param {Object} pracownik - Obiekt zawierający dane pracownika
 * @param {string} pracownik.id - Unikalny identyfikator pracownika
 * @param {string} pracownik.imię - Imię pracownika
 * @param {string} pracownik.nazwisko - Nazwisko pracownika
 * @param {number} pracownik.poziomDostępu - Poziom dostępu pracownika (1-5)
 * @param {string} strefa - Identyfikator strefy, do której pracownik próbuje uzyskać dostęp
 * @returns {boolean} - Zwraca true, jeśli pracownik ma dostęp do strefy, false w przeciwnym razie
 *
 * @example
 * // Sprawdź czy Dr. Wu ma dostęp do laboratorium
 * const drWu = { id: '001', imię: 'Henry', nazwisko: 'Wu', poziomDostępu: 5 };
 * const dostęp = sprawdźDostęp(drWu, 'laboratorium');
 * console.log(dostęp); // true
 */
function sprawdźDostęp(pracownik, strefa) {
  // Mapa wymaganych poziomów dostępu dla różnych stref
  const wymaganyPoziom = {
    'publiczna': 1,
    'administracja': 2,
    'zwierzęta roślinożerne': 3,
    'drapieżniki': 4,
    'laboratorium': 5
  };

  // Sprawdź czy strefa istnieje
  if (!wymaganyPoziom.hasOwnProperty(strefa)) {
    console.warn(`Nieznana strefa: ${strefa}`);
    return false;
  }

  // Porównaj poziom dostępu pracownika z wymaganym dla strefy
  return pracownik.poziomDostępu >= wymaganyPoziom[strefa];
}

6. Unikaj globalnego stanu

Problem w parku: System kontroli klimatu używał globalnych zmiennych do przechowywania ustawień, co pozwoliło błędowi w module sterowania wentylacją wpłynąć na cały system klimatyzacji.

Rozwiązanie:

// Źle:
let globalnaTemperatura = 22;
let globalnaWilgotność = 70;

function ustawTemperaturęWDżungli() {
  // Modyfikuje zmienne globalne
  globalnaTemperatura = 28;
  globalnaWilgotność = 90;
}

function ustawTemperaturęWLaboratorium() {
  // Również modyfikuje te same zmienne globalne!
  globalnaTemperatura = 20;
  globalnaWilgotność = 50;
}

// Co się stanie, jeśli obie funkcje zostaną wywołane blisko siebie w czasie?

// Dobrze:
class KontrolerKlimatu {
  constructor() {
    this.strefy = new Map();
  }

  ustawParametryStefy(idStrefy, temperatura, wilgotność) {
    this.strefy.set(idStrefy, { temperatura, wilgotność });
  }

  pobierzParametryStefy(idStrefy) {
    return this.strefy.get(idStrefy);
  }
}

const kontrolerKlimatu = new KontrolerKlimatu();

kontrolerKlimatu.ustawParametryStefy('dżungla', 28, 90);
kontrolerKlimatu.ustawParametryStefy('laboratorium', 20, 50);

// Teraz każda strefa ma własne niezależne ustawienia

7. Stosuj DRY (Don't Repeat Yourself)

Problem w parku: Kod do sprawdzania stanu zagrożenia był powielony w kilku systemach, więc poprawka błędu w jednym systemie nie została wprowadzona w pozostałych.

Rozwiązanie:

// Źle:
function sprawdźZagrożenieWSystemieDrzwi() {
  if (czujniki.ruch > 10 && czujniki.dźwięk > 80 && !jestDzień()) {
    ogłośAlarm('Podejrzana aktywność przy drzwiach!');
  }
}

function sprawdźZagrożenieWSystemieOgrodzenia() {
  // Ten sam logika jest powtórzona!
  if (czujniki.ruch > 10 && czujniki.dźwięk > 80 && !jestDzień()) {
    ogłośAlarm('Podejrzana aktywność przy ogrodzeniu!');
  }
}

// Dobrze:
function wykryjPodejrzanąAktywność() {
  return czujniki.ruch > 10 && czujniki.dźwięk > 80 && !jestDzień();
}

function sprawdźZagrożenieWSystemieDrzwi() {
  if (wykryjPodejrzanąAktywność()) {
    ogłośAlarm('Podejrzana aktywność przy drzwiach!');
  }
}

function sprawdźZagrożenieWSystemieOgrodzenia() {
  if (wykryjPodejrzanąAktywność()) {
    ogłośAlarm('Podejrzana aktywność przy ogrodzeniu!');
  }
}

8. Pisz kod dla ludzi, nie dla komputerów

Problem w parku: Kod genetyczny napisany przez Dr. Wu był tak zagmatwany, że nikt inny nie rozumiał jak dokładnie tworzono hybrydowe dinozaury.

Rozwiązanie:

// Źle:
function ms(d,g,s) {
  const r = [];
  for(let i=0;i<d.length;i++) {
    if(d[i].g === g && d[i].t > s) {
      r.push(d[i]);
    }
  }
  return r;
}

// Dobrze:
/**
 * Filtruje dinozaury według gatunku i minimalnego poziomu siły
 */
function filtrujDinozauryPoGatunkuISile(dinozaury, gatunek, minimalnaSila) {
  const wyfiltrowane = [];

  for (let i = 0; i < dinozaury.length; i++) {
    const dinozaur = dinozaury[i];

    if (dinozaur.gatunek === gatunek && dinozaur.siła > minimalnaSila) {
      wyfiltrowane.push(dinozaur);
    }
  }

  return wyfiltrowane;
}

// Lub jeszcze lepiej, używając nowoczesnego JavaScript:
function filtrujDinozauryPoGatunkuISile(dinozaury, gatunek, minimalnaSila) {
  return dinozaury.filter(dinozaur =>
    dinozaur.gatunek === gatunek && dinozaur.siła > minimalnaSila
  );
}

9. Używaj kontroli wersji

Problem w parku: Zespół IT nie używał systemu kontroli wersji, więc po wprowadzeniu nowej funkcjonalności, która okazała się zawierać błędy, nie można było łatwo przywrócić poprzedniej działającej wersji.

Rozwiązanie:

# Inicjalizacja repozytorium Git
git init

# Dodanie plików do repozytorium
git add .

# Pierwszy commit
git commit -m "Początkowa wersja systemu Parku Jurajskiego"

# Tworzenie nowej gałęzi na potrzeby rozwoju nowej funkcjonalności
git checkout -b nowy-system-karmienia

# Praca nad funkcjonalnością...

# Zapisanie zmian
git add zmodyfikowane-pliki
git commit -m "Dodano automatyczny system karmienia dla drapieżników"

# Łączenie zmian z główną gałęzią po testach
git checkout main
git merge nowy-system-karmienia

# W przypadku problemów, można szybko wrócić do poprzedniej wersji
git revert HEAD

10. Stosuj przeglądowanie kodu (code review)

Problem w parku: Dennis Nedry wprowadził tylne drzwi do systemu bezpieczeństwa, których nikt nie zauważył, ponieważ nie było procesu przeglądania kodu.

Podejście w zespole:

  1. Każda zmiana musi być przeglądnięta przez co najmniej jednego innego programistę
  2. Automatyczne testy muszą przejść przed scaleniem kodu
  3. Stosowanie listy kontrolnej podczas przeglądania:
    • Czy kod jest zgodny ze standardami?
    • Czy potencjalne problemy bezpieczeństwa zostały zaadresowane?
    • Czy dokumentacja została zaktualizowana?
    • Czy testy pokrywają nowy kod?

Koszt nieprzestrzegania najlepszych praktyk

Jak już wiemy z historii Parku Jurajskiego, nieprzestrzeganie najlepszych praktyk programistycznych może prowadzić do katastrofalnych konsekwencji:

  1. Utrata danych: Bezcenny materiał genetyczny dinozaurów utracony z powodu błędów w systemie
  2. Zagrożenie bezpieczeństwa: Awarie systemu prowadzące do ucieczki niebezpiecznych stworzeń
  3. Przerwy w działaniu: Zamknięcie parku z powodu problemów technicznych
  4. Trudności w rozwoju: Niemożność szybkiego wprowadzania nowych funkcji
  5. Problemy z utrzymaniem: Trudny do zrozumienia i naprawy kod

Ćwiczenie

Wyobraź sobie, że jesteś głównym programistą w Parku Jurajskim. Zidentyfikuj wszystkie potencjalne problemy w poniższym kodzie i przepisz go zgodnie z najlepszymi praktykami:

// System monitorowania dinozaurów w Parku Jurajskim
var dinos = [];
var alarmy = 0;

function dodaj(name, type, area, dangerLvl) {
  dinos.push({n: name, t: type, a: area, d: dangerLvl, h: 100});
  console.log('dodano: ' + name);
}

function check() {
  for (var i=0; i<dinos.length; i++) {
    if (dinos[i].h < 50) {
      console.log('UWAGA! Dinozaur ' + dinos[i].n + ' ma niski poziom zdrowia!');
      alarmy = alarmy + 1;
    }

    if (dinos[i].a != dinos[i].lockArea && dinos[i].d > 3) {
      console.log('NIEBEZPIECZEŃSTWO! Drapieżnik poza strefą!');
      alarmy = alarmy + 1;
    }
  }

  if (alarmy > 0) alert('Mamy problemy...');
}

// Przykład użycia
dodaj('Rex', 'T-Rex', 'B5', 5);
dodaj('Tri', 'Triceratops', 'A2', 2);
dinos[0].h = 30;
dinos[0].a = 'X3'; // Poza przypisaną strefą!
check();

Pamiętaj, w świecie programowania, tak jak w Parku Jurajskim - życie zawsze znajdzie sposób... na ujawnienie nieprzemyślanych rozwiązań! Dlatego stosuj najlepsze praktyki, aby twój kod był bezpieczny, utrzymywalny i efektywny.

Kod do tej lekcji: main.js
// Dobre praktyki z modułami - Park Jurajski
console.log("Dobre Praktyki z Modułami\n");

// ===========================================
// 1. JASNA STRUKTURA FOLDERÓW
// ===========================================

console.log("=== 1. Struktura Projektu ===\n");
console.log(`jurassic-park/
├── src/
│   ├── models/
│   │   ├── Dinosaur.js
│   │   ├── Enclosure.js
│   │   └── index.js
│   ├── services/
│   │   ├── DinosaurService.js
│   │   ├── SecurityService.js
│   │   └── index.js
│   ├── utils/
│   │   ├── validators.js
│   │   ├── formatters.js
│   │   └── index.js
│   ├── config/
│   │   └── constants.js
│   └── index.js
└── package.json`);

// ===========================================
// 2. JEDNĄ ODPOWIEDZIALNOŚĆ NA MODUŁ
// ===========================================

console.log("\n=== 2. Single Responsibility ===\n");

// DOBRZE - każdy moduł robi jedno
const DinosaurValidator = {
  validate(data) {
    return data.name && data.species;
  }
};

const DinosaurFormatter = {
  format(dinosaur) {
    return `${dinosaur.name} - ${dinosaur.species}`;
  }
};

// ŹLE - jeden moduł robi za dużo
const DinosaurEverything = {
  validate() {},
  format() {},
  save() {},
  load() {},
  update() {},
  delete() {}
};

console.log("Moduły z jedną odpowiedzialnością");
console.log("Unikaj 'god objects'");

// ===========================================
// 3. NAZEWNICTWO
// ===========================================

console.log("\n=== 3. Konwencje Nazewnictwa ===\n");

console.log("DOBRZE:");
console.log("  DinosaurService.js - klasa/serwis");
console.log("  constants.js - stałe");
console.log("  utils.js - funkcje użytkowe");
console.log("  index.js - re-export");

console.log("\nŹLE:");
console.log("  dino.js - niejasne");
console.log("  stuff.js - zbyt ogólne");
console.log("  temp.js - tymczasowe pliki");

// ===========================================
// 4. DEPENDENCY INJECTION
// ===========================================

console.log("\n=== 4. Dependency Injection ===\n");

// DOBRZE - dependencies jako parametry
class ParkManager {
  constructor(dinosaurService, securityService) {
    this.dinosaurService = dinosaurService;
    this.securityService = securityService;
  }
}

// ŹLE - hard-coded dependencies
class BadParkManager {
  constructor() {
    this.dinosaurService = new DinosaurService();
    this.securityService = new SecurityService();
  }
}

console.log("Przekazuj zależności");
console.log("Nie twórz zależności wewnątrz");

// ===========================================
// 5. EKSPORTUJ TYLKO CO POTRZEBNE
// ===========================================

console.log("\n=== 5. Minimalna Powierzchnia API ===\n");

// DOBRZE - eksportuj tylko publiczne API
const DinosaurModule = {
  // Publiczne
  createDinosaur(name) {
    return _createInternal(name);
  },

  getDinosaur(id) {
    return _findById(id);
  }
};

// Prywatne funkcje (nie eksportowane)
function _createInternal(name) {
  return { name, id: Math.random() };
}

function _findById(id) {
  return { id };
}

console.log("Minimalna publiczna powierzchnia");
console.log("Nie eksportuj internal helpers");

// ===========================================
// 6. DOKUMENTACJA
// ===========================================

console.log("\n=== 6. Dokumentacja Modułów ===\n");

/**
 * Dinosaur Service
 * Handles all dinosaur-related operations
 *
 * @module DinosaurService
 * @exports {Object} Service object with public methods
 *
 * @example
 * import DinosaurService from './DinosaurService';
 * const dino = DinosaurService.create('Rex');
 */
const DinosaurService = {
  /**
   * Creates a new dinosaur
   * @param {string} name - Dinosaur name
   * @returns {Object} Dinosaur object
   */
  create(name) {
    return { name };
  }
};

console.log("JSDoc dla publicznych API");
console.log("README dla większych modułów");

console.log("\n=== PODSUMOWANIE PRAKTYK ===\n");
console.log("1. Jasna struktura folderów");
console.log("2. Jedna odpowiedzialność na moduł");
console.log("3. Jasne nazwy plików");
console.log("4. Dependency Injection");
console.log("5. Minimalne eksporty");
console.log("6. Dokumentacja");
console.log("7. Testy dla każdego modułu");
console.log("8. Unikaj circular dependencies");

console.log("\nCzyste moduły = lepszy kod!");

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 oznacza zasada pojedynczej odpowiedzialności (Single Responsibility Principle)?

  2. 2. Dlaczego walidacja danych wejściowych jest kluczowa w programowaniu?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy tworzenia niezawodnego kodu od pierwszego do ostatniego:

  1. PytanieZasada pojedynczej odpowiedzialności
  2. PytanieWalidacja danych wejściowych
  3. Ułóż w kolejnościEtapy pisania niezawodnego kodu

Przydatne artykuły