W świecie dynamicznie rozwijających się aplikacji internetowych, wzorce projektowe JavaScript odgrywają kluczową rolę w tworzeniu czytelnego, elastycznego i łatwego w utrzymaniu kodu. Stosowanie wzorców projektowych pozwala programistom na efektywne rozwiązywanie typowych problemów programistycznych, co zdecydowanie poprawia jakość tworzonego oprogramowania. W tym artykule przedstawimy najpopularniejsze wzorce projektowe, takie jak Singleton, Factory czy Module, oraz pokażemy, jak je implementować w codziennej pracy programisty. # singleton javascript, javascript module, factory pattern
JavaScript – co to jest i jak zacząć naukę?
Czym są wzorce projektowe?
Wzorce projektowe to sprawdzone rozwiązania powtarzających się problemów w projektowaniu oprogramowania. Stanowią one zbiór najlepszych praktyk, które pomagają w tworzeniu bardziej efektywnego i zorganizowanego kodu. Zastosowanie wzorców projektowych pozwala na:
Ułatwienie utrzymania kodu
Poprawę jego czytelności
Zwiększenie możliwości ponownego wykorzystania
Frontend Master 2026 · Kodożercy
Pisz kod, nie tylko prompty
Frontend Master 2026 to pakiet sześciu kursów Kodożerców (HTML, CSS, JavaScript, Git) w polskim wideo z 12-miesięcznym dostępem. Fundamenty frontu od pierwszej linijki kodu do deploy.
Wchodzę w to →
Klasyfikacja wzorców projektowych
Wzorce projektowe różnią się między sobą charakterem i zastosowaniem. Dzielimy je na trzy główne kategorie:
Wzorce kreacyjne – dotyczą tworzenia obiektów i instancji klas. Wzorce kreacyjne pozwalają na oddzielenie procesu tworzenia obiektów od ich implementacji.
Wzorce strukturalne – opisują, jak komponować klasy i obiekty w większe struktury.
Wzorce behawioralne – definiują interakcje i komunikację między obiektami.
Wzorce kreacyjne
Singleton (Singleton Design Pattern)
Singleton to wzorzec kreacyjny, który zapewnia istnienie tylko jednej instancji klasy i umożliwia globalny dostęp do niej.
Implementacja Singleton w JavaScript:
const Singleton = (function() {
let instance;
function createInstance() {
const object = new Object('I am the instance');
return object;
}
return {
getInstance: function() {
if (!instance) {
instance = createInstance();
}
return instance;
}
};
})();
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // Wyświetli trueStosowanie wzorca Singleton pozwala na kontrolowanie dostępu do unikalnej instancji obiektu w aplikacji.
Factory Pattern (Wzorzec Fabryka)
Factory Pattern, zwany także Simple Factory, to wzorzec projektowy, który dostarcza interfejs do tworzenia obiektów w klasie bazowej, ale pozwala podklasom zmieniać typ tworzonych obiektów.
Implementacja wzorca Fabryka w JavaScript:
class Pojazd {
constructor(typ) {
this.typ = typ;
}
info() {
console.log(`To jest pojazd typu: ${this.typ}`);
}
}
class FabrykaPojazdów {
static utwórzPojazd(typ) {
switch (typ) {
case 'samochód':
return new Pojazd('samochód');
case 'motocykl':
return new Pojazd('motocykl');
default:
return new Pojazd('nieznany');
}
}
}
const pojazd1 = FabrykaPojazdów.utwórzPojazd('samochód');
const pojazd2 = FabrykaPojazdów.utwórzPojazd('motocykl');
pojazd1.info(); // Wyświetli "To jest pojazd typu: samochód"
pojazd2.info(); // Wyświetli "To jest pojazd typu: motocykl"Wykorzystanie wzorca Fabryka upraszcza tworzenie obiektów i zwiększa elastyczność kodu.
Metoda Wytwórcza
Metoda wytwórcza to wzorzec kreacyjny, który definiuje interfejs do tworzenia obiektów, ale pozwala klasom podrzędnym decydować, jakiego typu obiekt zostanie utworzony.
Wzorce strukturalne
Module Pattern (Wzorzec Moduł)
Module Design Pattern pozwala na organizację kodu w moduły, które mogą ukrywać szczegóły implementacji i eksponować jedynie interfejs publiczny.
Implementacja wzorca Moduł w JavaScript:
const moduł = (function() {
// Zmienne i funkcje prywatne
let prywatnaZmienna = 'To jest prywatne';
function prywatnaFunkcja() {
console.log(prywatnaZmienna);
}
// Interfejs publiczny
return {
publicznaFunkcja: function() {
prywatnaFunkcja();
}
};
})();
moduł.publicznaFunkcja(); // Wyświetli "To jest prywatne"Stosowanie wzorca Moduł pomaga w enkapsulacji kodu i unikaniu konfliktów nazw w przestrzeni globalnej.
Facade Pattern (Wzorzec Fasada)
Facade Design Pattern dostarcza uproszczony interfejs do złożonego systemu, ułatwiając jego użycie.
Przykład zastosowania wzorca Fasada:
class Silnik {
uruchom() {
console.log('Silnik uruchomiony');
}
}
class Światła {
włącz() {
console.log('Światła włączone');
}
}
class Samochód {
constructor() {
this.silnik = new Silnik();
this.światła = new Światła();
}
jedź() {
this.silnik.uruchom();
this.światła.włącz();
console.log('Samochód jedzie');
}
}
const auto = new Samochód();
auto.jedź();Wykorzystanie wzorca Fasada upraszcza interakcje z złożonymi systemami i poprawia czytelność kodu.
Decorator Pattern (Wzorzec Dekorator)
Decorator Design Pattern pozwala na dynamiczne dodawanie nowych funkcjonalności do obiektów bez konieczności modyfikowania ich struktury.
Przykład zastosowania wzorca Dekorator:
function podstawowaFunkcja() {
console.log('Podstawowa funkcja');
}
function dekorator(funkcja) {
return function() {
console.log('Przed dekoracją');
funkcja();
console.log('Po dekoracji');
};
}
const udekorowanaFunkcja = dekorator(podstawowaFunkcja);
udekorowanaFunkcja();Flyweight Pattern (Wzorzec Pyłek)
Flyweight Design Pattern to wzorzec strukturalny, który pozwala na zaoszczędzenie pamięci poprzez współdzielenie wspólnych części stanu między wieloma obiektami.
Wzorce behawioralne
Wzorce behawioralne opisują interakcje i komunikację między obiektami w systemie.
Observer Pattern (Wzorzec Obserwator)
Observer Design Pattern definiuje zależność jeden-do-wielu między obiektami, tak że zmiana stanu jednego obiektu powoduje automatyczne powiadomienie i aktualizację innych. Jest to typowy behawioralny wzorzec projektowy.
Implementacja wzorca Obserwator w JavaScript:
class Subject {
constructor() {
this.obserwatorzy = [];
}
dodajObserwatora(obserwator) {
this.obserwatorzy.push(obserwator);
}
powiadomObserwatorów(zdarzenie) {
this.obserwatorzy.forEach(obserwator => obserwator.aktualizuj(zdarzenie));
}
}
class Obserwator {
aktualizuj(zdarzenie) {
console.log(`Otrzymano zdarzenie: ${zdarzenie}`);
}
}
const subject = new Subject();
const obserwator1 = new Obserwator();
const obserwator2 = new Obserwator();
subject.dodajObserwatora(obserwator1);
subject.dodajObserwatora(obserwator2);
subject.powiadomObserwatorów('Nowe dane');Wykorzystanie wzorca Obserwator jest powszechne w aplikacjach, gdzie wymagane jest reagowanie na zmiany stanu.
Mediator Pattern (Wzorzec Mediator)
Mediator Design Pattern centralizuje komunikację między obiektami, zmniejszając zależności między nimi.
Przykład zastosowania wzorca Mediator:
class Mediator {
wyslij(wiadomosc, nadawca) {
// Logika przekazywania wiadomości
console.log(`${nadawca} wysłał: ${wiadomosc}`);
}
}
class Uczestnik {
constructor(nazwa, mediator) {
this.nazwa = nazwa;
this.mediator = mediator;
}
wyslij(wiadomosc) {
this.mediator.wyslij(wiadomosc, this.nazwa);
}
}
const mediator = new Mediator();
const uczestnik1 = new Uczestnik('Jan', mediator);
const uczestnik2 = new Uczestnik('Anna', mediator);
uczestnik1.wyslij('Cześć!');
uczestnik2.wyslij('Witaj!');Command Pattern (Wzorzec Polecenie)
Command Design Pattern przekształca żądania w obiekty, co pozwala na parametryzowanie metod zleceniodawcy z różnymi żądaniami, kolejkowanie lub rejestrowanie żądań oraz wspieranie operacji cofania.
Przykład zastosowania wzorca Polecenie:
class Polecenie {
wykonaj() {}
}
class WłączŚwiatło extends Polecenie {
wykonaj() {
console.log('Światło włączone');
}
}
class WyłączŚwiatło extends Polecenie {
wykonaj() {
console.log('Światło wyłączone');
}
}
class Pilot {
ustawPolecenie(polecenie) {
this.polecenie = polecenie;
}
naciśnijPrzycisk() {
this.polecenie.wykonaj();
}
}
const pilot = new Pilot();
const włączŚwiatło = new WłączŚwiatło();
const wyłączŚwiatło = new WyłączŚwiatło();
pilot.ustawPolecenie(włączŚwiatło);
pilot.naciśnijPrzycisk(); // Wyświetli "Światło włączone"
pilot.ustawPolecenie(wyłączŚwiatło);
pilot.naciśnijPrzycisk(); // Wyświetli "Światło wyłączone"Chain of Responsibility (Wzorzec Łańcucha Zobowiązań)
Chain of Responsibility to wzorzec behawioralny, który pozwala przekazywać żądania wzdłuż łańcucha obiektów, aż któryś z nich obsłuży to żądanie.
Zastosowanie wzorców projektowych w aplikacjach internetowych
Zastosowanie wzorców projektowych w aplikacjach internetowych pozwala na tworzenie bardziej skalowalnych i łatwiejszych w utrzymaniu systemów. Współczesne frameworki i biblioteki, takie jak React czy Angular, często opierają się na tych wzorcach.
Wzorce widoku modelu, takie jak MVC (Model-View-Controller) czy MVVM (Model-View-ViewModel), są powszechnie stosowane w aplikacjach webowych do oddzielenia logiki biznesowej od interfejsu użytkownika.
Charakterystyki wzorców projektowych sprawiają, że są one niezwykle użyteczne w tworzeniu złożonych aplikacji. Wzorce projektowe dotyczące struktury kodu i interakcji między obiektami pozwalają na lepszą organizację i utrzymanie kodu.
Podsumowanie
Wzorce projektowe są nieodłącznym elementem profesjonalnego programowania w JavaScript. Znajomość i umiejętność ich zastosowania w codziennej pracy pozwala na tworzenie lepszego kodu, który jest łatwiejszy w utrzymaniu i bardziej elastyczny. Wzorce programowania, takie jak Singleton, Factory, Module czy Observer, są fundamentem w tworzeniu nowoczesnych aplikacji.
Stosowanie wzorców projektowych zdecydowanie poprawia jakość kodu i ułatwia jego rozwój. Warto poświęcić czas na zgłębienie tych najpopularniejszych wzorców projektowych, aby stać się lepszym programistą.
Zapraszamy do dalszej nauki i eksplorowania wzorców projektowych JavaScript, które z pewnością przyczynią się do podniesienia jakości Twojego kodu.
# singleton javascript, javascript module, factory pattern
