Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Strukturyzacja kodu w większym projekcie
W tej lekcji11
Po przejściu przez wszystkie najważniejsze techniki JavaScript, nadszedł czas, aby spojrzeć na szerszy obraz - jak organizować kod w większych projektach. Nieodpowiednia struktura kodu może doprowadzić do katastrofy podobnej do tej, z którą mieliśmy do czynienia w Parku Jurajskim - chaos, błędy i trudność w zarządzaniu systemem.
Dlaczego struktura projektu jest ważna?
Wyobraź sobie, że całą infrastrukturę Parku Jurajskiego zarządzaną przez jeden ogromny system. Wszystkie zabezpieczenia wybiegów, monitorowanie zdrowia dinozaurów, zarządzanie przepływem zwiedzających, gastronomia, laboratoria genetyczne - wszystko w jednym, monolitycznym programie. Katastrofa czeka tuż za rogiem, prawda?
Dobrze zaprojektowana struktura projektu zapewnia:
- Utrzymywalność - łatwiejsze znajdowanie i naprawianie błędów
- Skalowalność - możliwość dodawania nowych funkcjonalności bez naruszania istniejących
- Testowalność - możliwość testowania komponentów w izolacji
- Łatwość współpracy - wielu programistów może pracować równolegle nad różnymi częściami systemu
- Czytelność - łatwiejsze zrozumienie, jak działa system
Organizacja folderów i plików
Istnieje wiele podejść do organizacji kodu w większych projektach JavaScript, ale przyjrzyjmy się kilku sprawdzonym wzorcom, które sprawdziłyby się w systemie zarządzania Parkiem Jurajskim.
1. Podział według typów (Type-Based)
Jedna z popularnych struktur, szczególnie w mniejszych aplikacjach, to grupowanie plików według ich typu:
jurassic-park-management/
├── src/
│ ├── components/ # Komponenty UI
│ ├── services/ # Serwisy do komunikacji z API
│ ├── utils/ # Narzędzia pomocnicze
│ ├── models/ # Definicje typów i interfejsów
│ ├── hooks/ # Niestandardowe hooki
│ ├── constants/ # Stałe używane w aplikacji
│ ├── assets/ # Obrazy, czcionki, itp.
│ ├── styles/ # Style CSS/SCSS
│ └── tests/ # Testy
└── package.jsonW tej strukturze, jeśli chcemy dodać nową funkcjonalność, np. monitorowanie zdrowia dinozaurów, będziemy musieli dodać:
- Komponenty UI w
/components - Serwis do pobierania danych w
/services - Może nowe modele w
/models - Pomocnicze narzędzia w
/utils
To podejście jest proste i zrozumiałe, ale w miarę rozrostu projektu może stać się trudniejsze do zarządzania, ponieważ powiązane ze sobą pliki są rozrzucone po różnych katalogach.
2. Podział według funkcjonalności (Feature-Based)
Alternatywne podejście to organizowanie kodu według funkcjonalności biznesowej:
jurassic-park-management/
├── src/
│ ├── common/ # Współdzielone komponenty, style, utils
│ ├── features/
│ │ ├── dinosaur-monitoring/ # Wszystko związane z monitorowaniem dinozaurów
│ │ │ ├── components/
│ │ │ ├── services/
│ │ │ ├── hooks/
│ │ │ ├── utils/
│ │ │ └── tests/
│ │ ├── enclosure-security/ # Wszystko związane z zabezpieczeniami wybiegów
│ │ │ ├── components/
│ │ │ ├── services/
│ │ │ └──
│ │ ├── visitor-management/ # Wszystko związane z zarządzaniem zwiedzającymi
│ │ │ ├── components/
│ │ │ ├── services/
│ │ │ └──
│ │ └──
│ ├── core/ # Core functionality
│ │ ├── api/
│ │ ├── auth/
│ │ └── config/
│ └── app.js
└── package.jsonW tej strukturze, jeśli pracujemy nad systemem monitorowania dinozaurów, wszystkie potrzebne pliki znajdują się w jednym miejscu. To podejście jest bardziej skalowalne dla dużych projektów, ponieważ funkcjonalności są od siebie odizolowane.
3. Struktura modułowa (Modular Structure)
Jeszcze bardziej zaawansowane podejście to organizacja kodu w postaci modułów, które są w pełni enkapsulowane:
jurassic-park-management/
├── src/
│ ├── modules/
│ │ ├── dinosaur-monitoring/
│ │ │ ├── components/
│ │ │ ├── services/
│ │ │ ├── store/
│ │ │ ├── utils/
│ │ │ ├── index.js # Eksportuje publiczne API modułu
│ │ │ └── README.md # Dokumentacja modułu
│ │ ├── enclosure-security/
│ │ │ ├──
│ │ │ └── index.js
│ │ └──
│ ├── shared/ # Współdzielone zasoby
│ │ ├── components/
│ │ ├── utils/
│ │ └── hooks/
│ ├── core/ # Core functionality
│ │ ├── api/
│ │ ├── router/
│ │ └── store/
│ └── app.js
└── package.jsonW tym podejściu każdy moduł jest traktowany jako "mini-aplikacja" z własnym API udostępnianym przez plik index.js. Inne moduły mogą korzystać tylko z tego, co jest jawnie eksportowane, co zapewnia lepszą enkapsulację i zmniejsza zależności między modułami.
Architektura aplikacji
Struktura folderów to tylko część zagadnienia. Równie ważne jest zaprojektowanie odpowiedniej architektury aplikacji, która określa, jak różne części kodu współpracują ze sobą.
1. Model-View-Controller (MVC)
Klasyczny wzorzec MVC dzieli aplikację na trzy główne komponenty:
- Model - zarządza danymi i logiką biznesową
- View - odpowiada za prezentację danych użytkownikowi
- Controller - pośredniczy między Modelem a View, obsługując interakcje użytkownika
W kontekście Parku Jurajskiego:
- Model - dane o dinozaurach, wybiegach, zwiedzających
- View - interfejs użytkownika dla pracowników parku
- Controller - obsługa żądań, np. otwarcie/zamknięcie wybiegu, sprawdzenie zdrowia dinozaura
2. Flux / Redux
Flux (i jego implementacja Redux) to architektura oparta na jednokierunkowym przepływie danych, która świetnie sprawdza się w aplikacjach React.
┌──────────┐ ┌──────────┐ ┌───────────────┐
│ Action │──────>│ Store │──────>│ Components │
└──────────┘ └──────────┘ └───────────────┘
│
│
V
┌──────────┐
│ Actions │
└──────────┘W kontekście Parku Jurajskiego:
- Actions: "OPEN_ENCLOSURE", "FEED_DINOSAUR", "ACTIVATE_EMERGENCY_PROTOCOL"
- Store: Stan aplikacji zawierający dane o wszystkich dinozaurach, wybiegach, etc.
- Components: UI dla pracowników parku, pokazujące aktualny stan parku
3. Clean Architecture / Hexagonal Architecture
Te architektury kładą nacisk na oddzielenie logiki biznesowej od infrastruktury (UI, bazy danych, etc.), co ułatwia testowanie i zmiany infrastruktury bez naruszania core'owej funkcjonalności.
┌────────────────────────────────────────────┐
│ Core (Domain) │
│ ┌──────────────────────────────────────┐ │
│ │ Application │ │
│ │ ┌──────────────────────────────┐ │ │
│ │ │ Interfejs │ │ │
│ │ │ (Controllers, Presenters...) │ │ │
│ │ └──────────────────────────────┘ │ │
│ └──────────────────────────────────────┘ │
└────────────────────────────────────────────┘
│ │
┌──────────┘ └──────────┐
│ │
┌───▼────────────┐ ┌──────────▼───┐
│ UI │ │ Infrastructure│
│ (React, Vue..)│ │ (DB, API...) │
└────────────────┘ └──────────────┘W kontekście Parku Jurajskiego:
- Core Domain: Główna logika biznesowa - jak monitorować zdrowie dinozaurów, zarządzać wybiegami, etc.
- Application: Przypadki użycia - karmienie dinozaurów, otwieranie/zamykanie wybiegów, itp.
- Interface: Adaptery pomiędzy rdzeniem a infrastrukturą
- Infrastructure: Konkretne implementacje - UI dla pracowników, baza danych z informacjami o dinozaurach, API do systemów zabezpieczeń, itp.
Modularyzacja kodu
Niezależnie od wybranej struktury folderów i architektury, kluczowe jest właściwe podzielenie kodu na mniejsze, spójne moduły.
1. Modularyzacja według odpowiedzialności
Każdy moduł powinien mieć jasno określoną, pojedynczą odpowiedzialność:
// dinosaurHealthMonitor.js - odpowiedzialny tylko za monitorowanie zdrowia dinozaurów
export function checkVitalSigns(dinosaurId) {
//
}
export function alertHealthIssue(dinosaurId, issue) {
//
}
// enclosureSecurity.js - odpowiedzialny tylko za bezpieczeństwo wybiegów
export function checkEnclosureSecurity(enclosureId) {
//
}
export function activateEmergencyProtocol(enclosureId) {
//
}2. Czyste interfejsy między modułami
Moduły powinny komunikować się ze sobą przez czyste, dobrze zdefiniowane interfejsy:
// Moduł wyższego poziomu korzysta z interfejsów modułów niższego poziomu
import { checkVitalSigns } from './dinosaurHealthMonitor';
import { checkEnclosureSecurity } from './enclosureSecurity';
// parkSafetySystem.js
export async function performSafetyCheck() {
const dinosaurs = await fetchAllDinosaurs();
const enclosures = await fetchAllEnclosures();
// Używamy interfejsów innych modułów
const healthIssues = dinosaurs.map(checkVitalSigns);
const securityIssues = enclosures.map(checkEnclosureSecurity);
return {
healthIssues: healthIssues.filter(issue => issue !== null),
securityIssues: securityIssues.filter(issue => issue !== null)
};
}3. Dependency Injection
Wstrzykiwanie zależności to technika, która pozwala na odwrócenie zależności między modułami, co ułatwia testowanie i zmiany:
// Bez DI
function DinosaurMonitor() {
// Bezpośrednia zależność
const vitalSignsMonitor = new VitalSignsMonitor();
return {
checkDinosaur(dinosaur) {
return vitalSignsMonitor.check(dinosaur);
}
};
}
// Z DI
function DinosaurMonitor(vitalSignsMonitor) {
return {
checkDinosaur(dinosaur) {
return vitalSignsMonitor.check(dinosaur);
}
};
}
// Możemy teraz wstrzyknąć różne implementacje
const realMonitor = DinosaurMonitor(new VitalSignsMonitor());
const testMonitor = DinosaurMonitor(new MockVitalSignsMonitor());Zarządzanie importami
W dużych projektach zarządzanie importami może stać się problematyczne. Oto kilka technik, które pomagają utrzymać je w porządku:
1. Indeksy baryłkowe (Barrel exports)
Pliki indeksowe, które re-eksportują wszystkie publiczne elementy z danego katalogu:
// dinosaurMonitoring/index.js
export * from './vitalSigns';
export * from './behaviorAnalysis';
export * from './healthAlerts';
// W innym module
import { checkVitalSigns, analyzeBehavior } from './dinosaurMonitoring';
// Zamiast
import { checkVitalSigns } from './dinosaurMonitoring/vitalSigns';
import { analyzeBehavior } from './dinosaurMonitoring/behaviorAnalysis';2. Aliasy importów
Wiele narzędzi bundlujących (jak webpack, Vite) pozwala na definiowanie aliasów dla ścieżek importów:
// webpack.config.js
module.exports = {
resolve: {
alias: {
'@core': path.resolve(__dirname, 'src/core'),
'@features': path.resolve(__dirname, 'src/features'),
'@shared': path.resolve(__dirname, 'src/shared'),
}
}
};
// W kodzie
import { activateProtocol } from '@core/security';
import { DinosaurCard } from '@features/dinosaurs/components';To eliminuje problem względnych ścieżek (../../..) i sprawia, że importy są bardziej czytelne.
Zarządzanie stanem aplikacji
W większych aplikacjach zarządzanie stanem staje się kluczowym wyzwaniem. Oto kilka podejść:
1. Centralne zarządzanie stanem (Redux, MobX)
Przechowywanie całego stanu aplikacji w jednym miejscu:
// Akcje Redux dla systemu monitorowania dinozaurów
const UPDATE_DINOSAUR_HEALTH = 'UPDATE_DINOSAUR_HEALTH';
const ALERT_HEALTH_ISSUE = 'ALERT_HEALTH_ISSUE';
// Reducer
function dinosaurHealthReducer(state = initialState, action) {
switch (action.type) {
case UPDATE_DINOSAUR_HEALTH:
return {
...state,
dinosaurs: state.dinosaurs.map(dino =>
dino.id === action.payload.id
? { ...dino, health: action.payload.health }
: dino
)
};
case ALERT_HEALTH_ISSUE:
return {
...state,
alerts: [...state.alerts, action.payload]
};
default:
return state;
}
}2. Zmodularyzowany stan (Redux Toolkit, Zustand)
Podzielenie stanu na mniejsze, niezależne "plasterki":
// Slice stanu odpowiedzialny za dinozaury
const dinosaurSlice = createSlice({
name: 'dinosaurs',
initialState: { list: [], loading: false, error: null },
reducers: {
fetchStart: (state) => {
state.loading = true;
},
fetchSuccess: (state, action) => {
state.list = action.payload;
state.loading = false;
},
updateHealth: (state, action) => {
const { id, health } = action.payload;
const dinosaur = state.list.find(d => d.id === id);
if (dinosaur) dinosaur.health = health;
}
}
});
// Slice stanu odpowiedzialny za wybiegi
const enclosureSlice = createSlice({
name: 'enclosures',
initialState: { list: [], securityStatus: {} },
reducers: {
//
}
});3. Server State vs. Client State
Rozróżnienie między danymi pochodzącymi z serwera a stanem UI:
// Dane z serwera - obsługiwane przez React Query
const { data: dinosaurs, isLoading, error } = useQuery(
'dinosaurs',
() => fetchDinosaurs()
);
// Stan UI - obsługiwany lokalnie
const [selectedDinosaurId, setSelectedDinosaurId] = useState(null);Zarządzanie efektami ubocznymi
W dużych aplikacjach, zarządzanie efektami ubocznymi (side effects) takimi jak żądania API, operacje I/O, etc. staje się skomplikowane. Oto kilka podejść:
1. Scentralizowane zarządzanie (Redux Saga, Redux Thunk)
// Redux Saga dla monitorowania zdrowia dinozaurów
function* monitorDinosaurHealthSaga() {
while (true) {
try {
// Pobierz wszystkie dinozaury
const dinosaurs = yield call(api.fetchAllDinosaurs);
// Sprawdź zdrowie każdego dinozaura
for (const dinosaur of dinosaurs) {
const healthData = yield call(api.fetchDinosaurHealth, dinosaur.id);
// Aktualizuj stan
yield put(updateDinosaurHealth(dinosaur.id, healthData));
// Jeśli zdrowie jest krytyczne, zgłoś alert
if (healthData.status === 'critical') {
yield put(alertHealthIssue(dinosaur.id, healthData));
}
}
// Poczekaj 5 minut przed kolejnym sprawdzeniem
yield delay(5 * 60 * 1000);
} catch (error) {
console.error('Health monitoring error:', error);
yield put(monitoringError(error));
// Poczekaj 1 minutę przed ponowną próbą
yield delay(60 * 1000);
}
}
}2. Hooki efektów (React Query, SWR)
// Hook React Query do zarządzania danymi dinosaura i ich zdrowiem
function useDinosaurHealth(dinosaurId) {
return useQuery(
['dinosaurHealth', dinosaurId],
() => api.fetchDinosaurHealth(dinosaurId),
{
// Odświeżaj dane co 1 minutę
refetchInterval: 60 * 1000,
// Reaguj na zmiany zdrowia
onSuccess: (data) => {
if (data.status === 'critical') {
notifyHealthIssue(dinosaurId, data);
}
}
}
);
}
// W komponencie
function DinosaurMonitor({ dinosaurId }) {
const { data, isLoading, error } = useDinosaurHealth(dinosaurId);
if (isLoading) return <Loading />;
if (error) return <Error message={error.message} />;
return (
<div className={`health-status ${data.status}`}>
<h2>Zdrowie dinozaura: {data.status}</h2>
<div>Temperatura: {data.temperature}°C</div>
<div>Tętno: {data.heartRate} BPM</div>
<div>Aktualizacja: {formatTime(data.timestamp)}</div>
</div>
);
}Testowanie dużych aplikacji
W dużych projektach kompleksowe testowanie jest kluczowe. Oto kilka poziomów testów, które należy rozważyć:
1. Testy jednostkowe (Unit Tests)
Testowanie pojedynczych modułów w izolacji:
// Test funkcji checkVitalSigns z modułu dinosaurHealthMonitor
describe('dinosaurHealthMonitor', () => {
describe('checkVitalSigns', () => {
it('should correctly identify healthy dinosaurs', () => {
const healthyDino = {
id: 'trex1',
temperature: 38,
heartRate: 70,
bloodOxygen: 95
};
const result = checkVitalSigns(healthyDino);
expect(result.status).toBe('healthy');
expect(result.issues).toHaveLength(0);
});
it('should detect high temperature', () => {
const feverishDino = {
id: 'trex1',
temperature: 42, // Too high
heartRate: 70,
bloodOxygen: 95
};
const result = checkVitalSigns(feverishDino);
expect(result.status).toBe('issue');
expect(result.issues).toContain('high temperature');
});
});
});2. Testy integracyjne (Integration Tests)
Testowanie współpracy między modułami:
// Test współpracy między modułem zdrowia i modułem alertów
describe('Health monitoring integration', () => {
it('should generate alerts for health issues', async () => {
// Przygotuj mocki
const mockAlertSystem = {
sendAlert: jest.fn()
};
const mockDinosaurData = {
id: 'raptor2',
temperature: 43, // Krytycznie wysoka
heartRate: 120, // Przyspieszone tętno
bloodOxygen: 85 // Niski poziom tlenu
};
// Utwórz system monitorowania z zamockowanym systemem alertów
const healthMonitor = createHealthMonitor(mockAlertSystem);
// Wywołaj funkcję monitorującą
await healthMonitor.checkAndAlert(mockDinosaurData);
// Sprawdź, czy alert został wysłany
expect(mockAlertSystem.sendAlert).toHaveBeenCalledWith(
expect.objectContaining({
dinosaurId: 'raptor2',
severity: 'critical',
issues: expect.arrayContaining([
expect.stringMatching(/temperature/i),
expect.stringMatching(/heart rate/i),
expect.stringMatching(/oxygen/i)
])
})
);
});
});3. Testy end-to-end (E2E Tests)
Testowanie pełnych ścieżek użytkownika:
// Test E2E procesu reagowania na awarię wybiegu
describe('Enclosure breach response', () => {
it('should activate emergency protocol on fence failure', async () => {
// Zaloguj się jako administrator systemu
await login('admin', 'password');
// Przejdź do panelu zarządzania wybiegami
await navigateTo('enclosures');
// Symuluj awarię płotu
await simulateFenceFailure('enclosure-b12');
// Sprawdź, czy alarm został aktywowany
const alarmStatus = await getElement('.alarm-status');
expect(alarmStatus).toHaveClass('active');
// Sprawdź, czy protokół awaryjny został uruchomiony
const protocolStatus = await getElement('.emergency-protocol');
expect(protocolStatus.textContent).toContain('Aktywny');
// Sprawdź, czy powiadomienia zostały wysłane
const notifications = await getElements('.notification');
expect(notifications).toHaveLength(2); // Do zespołu bezpieczeństwa i kierownictwa
// Symuluj naprawę płotu
await repairFence('enclosure-b12');
// Sprawdź, czy alarm został wyłączony
const updatedAlarmStatus = await getElement('.alarm-status');
expect(updatedAlarmStatus).not.toHaveClass('active');
});
});Dokumentacja kodu
W dużych projektach dokumentacja staje się niezbędna. Oto różne poziomy dokumentacji, które należy rozważyć:
1. Dokumentacja kodu (komentarze, JSDoc)
/**
* Sprawdza i ocenia zdrowie dinozaura na podstawie jego parametrów życiowych.
*
* @param {Object} dinosaur - Obiekt dinozaura do sprawdzenia
* @param {string} dinosaur.id - Unikalny identyfikator dinozaura
* @param {number} dinosaur.temperature - Temperatura ciała dinozaura w stopniach Celsjusza
* @param {number} dinosaur.heartRate - Tętno dinozaura w uderzeniach na minutę
* @param {number} dinosaur.bloodOxygen - Poziom tlenu we krwi dinozaura (0-100%)
*
* @returns {Object} Obiekt z oceną zdrowia
* @returns {string} returns.status - Status zdrowia: 'healthy', 'issue', 'critical'
* @returns {Array<string>} returns.issues - Lista wykrytych problemów zdrowotnych
*
* @example
* const healthAssessment = checkVitalSigns({
* id: 'trex1',
* temperature: 38.5,
* heartRate: 75,
* bloodOxygen: 92
* });
* // { status: 'healthy', issues: [] }
*/
function checkVitalSigns(dinosaur) {
// implementacja...
}2. Dokumentacja modułów (README.md)
Każdy moduł powinien mieć swój własny plik README.md, który opisuje jego funkcjonalność, interfejs i użycie:
# Moduł monitorowania zdrowia dinozaurów
Ten moduł odpowiada za monitorowanie i ocenę stanu zdrowia dinozaurów w Parku Jurajskim.
## Funkcjonalności
- Regularne sprawdzanie parametrów życiowych dinozaurów
- Wykrywanie problemów zdrowotnych i generowanie alertów
- Historyczne śledzenie stanu zdrowia i trendów
- Automatyczne powiadamianie personelu weterynaryjnego
## API
### `checkVitalSigns(dinosaur)`
Sprawdza zdrowie dinozaura na podstawie jego parametrów życiowych.
### `monitorHealth(dinosaurId, interval)`
Rozpoczyna cykliczne monitorowanie zdrowia dinozaura.
### `stopMonitoring(dinosaurId)`
Zatrzymuje monitorowanie zdrowia dinozaura.
## Przykłady użycia
~~~js
// Jednorazowe sprawdzenie zdrowia
const healthStatus = checkVitalSigns(dinosaur);
// Rozpoczęcie ciągłego monitorowania
const stopMonitoring = monitorHealth('trex1', 60000); // co minutę
// Zatrzymanie monitorowania
stopMonitoring();Integracja z innymi modułami
Ten moduł korzysta z:
- API systemów sensorycznych (src/modules/sensors)
- Systemu alertów (src/modules/alerts)
Jest używany przez:
- Dashboard zarządzania parkiem (src/modules/dashboard)
- System bezpieczeństwa (src/modules/security)
### 3. Dokumentacja architektury (diagragram, ADR)
Dokumentowanie decyzji architektonicznych jest kluczowe dla zrozumienia, dlaczego system został zaprojektowany w określony sposób. Pomocne są tutaj:
- **Diagramy architektury** (C4, UML)
- **Architecture Decision Records (ADR)** - dokumenty opisujące ważne decyzje architektoniczne, ich kontekst i konsekwencje
~~~text
# ADR 001: Wybór Redux jako systemu zarządzania stanem
## Kontekst
Aplikacja zarządzania Parkiem Jurajskim potrzebuje mechanizmu zarządzania stanem, który obsłuży:
- Złożony stan globalnz (dane o dinozaurach, wybiegach, zwiedzających)
- Asynchroniczne operacje (komunikacja z systemami w parku)
- Śledzenie historii zmian stanu (audyt bezpieczeństwa)
## Decyzja
Zdecydowaliśmy się użyć Redux z Redux Toolkit i Redux Saga jako głównego mechanizmu zarządzania stanem.
## Uzasadnienie
- **Przewidywalność**: Redux zapewnia jednokierunkowy przepływ danych
- **Middleware**: Redux Saga ułatwia zarządzanie złożonymi operacjami asynchronicznymi
- **DevTools**: Narzędzia deweloperskie Redux ułatwiają debugowanie
- **Ekosystem**: Bogate ekosystem bibliotek i narzędzi
- **Time Travel Debugging**: Możliwość śledzenia historii zmian stanu
## Konsekwencje
### Pozytywne
- Jasny przepływ danych w aplikacji
- Łatwiejsze debugowanie problemów ze stanem
- Możliwość audytu działań użytkowników
### Negatywne
- Zwiększona ilość kodu (actions, reducers, selectors)
- Wyższa krzywa uczenia dla nowych członków zespołu
- Potencjalny overhead wydajnościowy przy niewłaściwym użyciuDobre praktyki dla dużych projektów JavaScript
1. Ustanów standardy kodowania
Zdefiniuj i egzekwuj standardy kodowania za pomocą narzędzi jak ESLint, Prettier:
// .eslintrc.json
{
"extends": [
"eslint:recommended",
"plugin:react/recommended"
],
"rules": {
"react/prop-types": "error",
"no-unused-vars": "error",
"no-console": ["warn", { "allow": ["warn", "error"] }],
"prefer-const": "error"
}
}2. Używaj typowania (TypeScript, PropTypes)
// typescript
interface DinosaurVitalSigns {
id: string;
temperature: number;
heartRate: number;
bloodOxygen: number;
}
interface HealthAssessment {
status: 'healthy' | 'issue' | 'critical';
issues: string[];
lastChecked: Date;
}
function checkVitalSigns(dinosaur: DinosaurVitalSigns): HealthAssessment {
// implementacja...
}3. Automatyzuj testy i wdrożenia (CI/CD)
Skonfiguruj potoki CI/CD, które automatycznie uruchamiają testy, analizę statyczną kodu i wdrażają aplikację:
# .github/workflows/ci.yml
name: CI/CD
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main, develop ]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Node.js
uses: actions/setup-node@v2
with:
node-version: '14'
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
- name: Run linting
run: npm run lint
- name: Build
run: npm run build
deploy:
needs: test
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
# ... kroki wdrożenia4. Stosuj Code Reviews
Ustanów proces Code Review, który zapewni, że kod jest sprawdzany przez co najmniej jednego innego programistę przed włączeniem do głównej gałęzi.
5. Monitoruj wydajność
Implementuj monitorowanie wydajności aplikacji, aby szybko wykrywać i naprawiać problemy:
// Przykład konfiguracji własnego narzędzia do monitorowania wydajności
const performanceMonitor = {
eventTiming: {},
startTiming(eventName) {
this.eventTiming[eventName] = {
start: performance.now()
};
},
endTiming(eventName) {
if (this.eventTiming[eventName]) {
const start = this.eventTiming[eventName].start;
const duration = performance.now() - start;
// Loguj do serwera monitorowania
logPerformanceMetric(eventName, duration);
// Generuj alert, jeśli operacja trwała zbyt długo
if (duration > performanceThresholds[eventName]) {
alertPerformanceIssue(eventName, duration);
}
delete this.eventTiming[eventName];
}
}
};
// Użycie
function loadDinosaurData(id) {
performanceMonitor.startTiming('loadDinosaurData');
return fetchDinosaurData(id)
.then(data => {
performanceMonitor.endTiming('loadDinosaurData');
return data;
})
.catch(error => {
performanceMonitor.endTiming('loadDinosaurData');
throw error;
});
}Podsumowanie
Strukturyzacja kodu w większych projektach JavaScript to złożone zagadnienie, które wymaga przemyślanego podejścia. Kluczowe aspekty to:
- Organizacja folderów i plików - wybór odpowiedniej struktury zależnej od rozmiaru i charakteru projektu
- Architektura aplikacji - zdefiniowanie, jak różne części aplikacji współpracują ze sobą
- Modularyzacja kodu - dzielenie kodu na mniejsze, spójne moduły o jasno określonych odpowiedzialnościach
- Zarządzanie importami - utrzymywanie czytelnych i efektywnych importów
- Zarządzanie stanem aplikacji - wybór odpowiedniego podejścia do zarządzania stanem
- Zarządzanie efektami ubocznymi - organizacja operacji asynchronicznych i innych efektów ubocznych
- Testowanie - wdrożenie kompleksowej strategii testowania
- Dokumentacja - zapewnienie dobrze udokumentowanego kodu i architektury
Stosując te zasady, możesz uniknąć chaosu, który mógłby prowadzić do "katastrofy" w twoim projekcie JavaScript - podobnie jak odpowiednia organizacja i zarządzanie pomogłyby uniknąć katastrofy w Parku Jurajskim!
Kod do tej lekcji: main.js
// ES Modules w przeglądarce - Park Jurajski
console.log("ES Modules w Przeglądarce\n");
// Demonstracja <script type="module">
console.log("=== Przykład HTML ===\n");
console.log(`<!DOCTYPE html>
<html>
<head>
<title>Park Jurajski</title>
</head>
<body>
<!-- ES Module w przeglądarce -->
<script type="module">
import { Dinosaur } from './dinosaur.js';
const rex = new Dinosaur('Rex');
console.log(rex);
</script>
<!-- Fallback dla starych przeglądarek -->
<script nomodule>
console.log('Twoja przeglądarka nie wspiera ES Modules');
</script>
</body>
</html>`);
// Dynamiczny import w przeglądarce
console.log("\n=== Dynamiczny Import ===\n");
async function loadDinosaurModule() {
try {
console.log("⏳ Ładowanie modułu...");
// Symulacja dynamicznego importu
const module = {
Dinosaur: class {
constructor(name) {
this.name = name;
}
}
};
console.log("Moduł załadowany!");
const dino = new module.Dinosaur('Blue');
console.log("Utworzono:", dino);
} catch (error) {
console.error("Błąd ładowania:", error);
}
}
loadDinosaurModule();
// Import maps
console.log("\n=== Import Maps ===\n");
console.log(`<script type="importmap">
{
"imports": {
"dinosaurs": "/modules/dinosaurs.js",
"security": "/modules/security.js",
"lodash": "https://cdn.skypack.dev/lodash"
}
}
</script>
<script type="module">
// Teraz możemy używać aliasów
import { Dinosaur } from 'dinosaurs';
import { Security } from 'security';
import _ from 'lodash';
</script>`);
console.log("\nES Modules w przeglądarce:");
console.log("Natywne wsparcie (bez bundlera)");
console.log("Automatyczne defer");
console.log("Strict mode domyślnie");
console.log("Import maps dla aliasów");
console.log("\nNowoczesne przeglądarki = natywne moduły!");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. Czym różni się podział projektu według typów (type-based) od podziału według funkcjonalności (feature-based)?
Zadania praktyczne w grze
- Edytor kodu
Stwórz modularną strukturę z podziałem na odpowiedzialności i jasnym API każdego modułu.