Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Najlepsze praktyki
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 ustawienia7. 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 HEAD10. 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:
- Każda zmiana musi być przeglądnięta przez co najmniej jednego innego programistę
- Automatyczne testy muszą przejść przed scaleniem kodu
- 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:
- Utrata danych: Bezcenny materiał genetyczny dinozaurów utracony z powodu błędów w systemie
- Zagrożenie bezpieczeństwa: Awarie systemu prowadzące do ucieczki niebezpiecznych stworzeń
- Przerwy w działaniu: Zamknięcie parku z powodu problemów technicznych
- Trudności w rozwoju: Niemożność szybkiego wprowadzania nowych funkcji
- 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. Co oznacza zasada pojedynczej odpowiedzialności (Single Responsibility Principle)?
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: