Jaka jest różnica między javascript a ecmascript?

Jeśli kiedykolwiek próbowałeś zrozumieć świat frontendu, to na pewno natknąłeś się na dwa pojęcia, które wyglądają jakby były synonimami: JavaScript i ECMAScript. I nic dziwnego – w internecie często używa się ich zamiennie, co tylko wprowadza zamieszanie.

Ale prawda jest taka, że JavaScript ≠ ECMAScript, choć są ze sobą bardzo blisko związane. To trochę jak różnica między przepisem kulinarnym a gotowym daniem. Przepis mówi, co powinno być w środku, a danie to to, co faktycznie dostajesz na talerzu.

W tym artykule przeprowadzę Cię przez całą historię, kontekst, techniczne szczegóły i praktyczne przykłady, żebyś już nigdy nie zastanawiał się, czym te dwa pojęcia się różnią.

1. Skąd w ogóle wzięły się JavaScript i ECMAScript?

Zacznijmy od początku, bo bez tego trudno zrozumieć, dlaczego mamy dwa różne terminy.

JavaScript – język, który powstał w pośpiechu

JavaScript został stworzony w 1995 roku przez Brendana Eicha w firmie Netscape. I to w zaledwie… 10 dni. Tak, dobrze czytasz. Dziesięć dni.

Netscape potrzebował języka, który pozwoliłby dodawać interaktywność do stron internetowych – coś lekkiego, łatwego do nauczenia i działającego w przeglądarce.

JavaScript szybko stał się popularny, ale pojawił się problem: każda przeglądarka zaczęła implementować go po swojemu.

Efekt? Kod działający w jednej przeglądarce potrafił kompletnie wysypać się w innej.

ECMAScript – standard, który miał to wszystko uporządkować

Żeby uniknąć chaosu, Netscape zgłosił JavaScript do organizacji standaryzującej – ECMA International.

W 1997 roku powstała pierwsza oficjalna specyfikacja języka: ECMAScript (ES1).

Od tego momentu ECMAScript stał się standardem, a JavaScript – implementacją tego standardu.

2. Najprostsze możliwe wyjaśnienie różnicy

Jeśli miałbym to streścić w jednym zdaniu:

ECMAScript to standard języka, a JavaScript to jego praktyczna implementacja, rozszerzona o dodatkowe funkcje.

ECMAScript mówi: „Język powinien mieć takie typy danych, takie zasady działania funkcji, takie konstrukcje składniowe”.

JavaScript mówi: „OK, implementuję to, ale dodam jeszcze obsługę DOM, eventy, WebAPI i inne rzeczy potrzebne w przeglądarce”.

3. ECMAScript to teoria, JavaScript to praktyka

Wyobraź sobie, że ECMAScript to instrukcja obsługi samochodu. A JavaScript to sam samochód, którym faktycznie jeździsz.

Instrukcja mówi, jak działa silnik, jakie są pedały, jak zmienia się biegi. Ale nie mówi nic o tym, czy samochód ma klimatyzację, radio, GPS czy podgrzewane fotele.

Tak samo:

• ECMAScript opisuje składnię, typy, operatory, funkcje, klasy, moduły itd.
• JavaScript dodaje:
  • manipulację DOM,
  • obsługę zdarzeń,
  • fetch API,
  • WebSockets,
  • WebGL,
  • localStorage,
  • i całą masę innych rzeczy.

4. Czy JavaScript może istnieć bez ECMAScript?

Nie. JavaScript jest zbudowany na ECMAScript.

To tak jakby zapytać, czy można mieć pizzę bez ciasta. Można mieć sos i dodatki, ale to już nie pizza.

5. Czy ECMAScript może istnieć bez JavaScript?

Tak. I co więcej – istnieje.

ECMAScript jest implementowany nie tylko przez JavaScript, ale także przez:

• ActionScript (kiedyś używany w Adobe Flash),
• JScript (implementacja Microsoftu),
• Duktape (silnik dla IoT),
• Rhino i Nashorn (silniki JS dla Javy).

To pokazuje, że ECMAScript to naprawdę tylko standard, a nie język przypisany do przeglądarek.

6. Dlaczego ludzie mylą JavaScript z ECMAScript?

Powodów jest kilka:

1. Bo większość programistów pracuje z JavaScriptem, a nie z samym standardem

Mało kto czyta specyfikację ECMAScript – jest długa, techniczna i mało przystępna.

2. Bo nowe wersje ECMAScript wpływają na JavaScript

Kiedy wychodzi ES6, ES7, ES8 itd., wszyscy mówią „nowy JavaScript”, choć tak naprawdę chodzi o nową wersję standardu.

3. Bo w praktyce różnice są niewidoczne

Dla programisty JavaScript to po prostu JavaScript – działa w przeglądarce i tyle.

7. Jak wyglądają wersje ECMAScript?

Najbardziej znana jest wersja ECMAScript 2015, czyli ES6. To ona wprowadziła:

• let i const,
• klasy,
• moduły,
• arrow functions,
• template strings,
• promisy.

Od tego czasu nowe wersje wychodzą co roku: ES2016, ES2017, ES2018 itd.

8. Przykład: ECMAScript definiuje składnię, JavaScript dodaje funkcjonalność

ECMAScript (standard)

ECMAScript mówi, że możesz napisać:

class Osoba {
  constructor(imie) {
    this.imie = imie;
  }

  przywitaj() {
    return `Cześć, jestem ${this.imie}`;
  }
}

To czysta składnia języka – nic więcej.

JavaScript (implementacja)

JavaScript pozwala Ci zrobić coś więcej:

document.querySelector("button").addEventListener("click", () => {
  alert("Kliknięto przycisk!");
});

Tutaj używasz:

• document – WebAPI,
• querySelector – WebAPI,
• addEventListener – WebAPI,
• alert – WebAPI.

Żadna z tych rzeczy nie jest częścią ECMAScript.

9. Co dokładnie wchodzi w skład ECMAScript?

ECMAScript definiuje:

• typy danych (Number, String, Boolean, Object, Symbol, BigInt),
• operatory,
• instrukcje (if, for, while, switch),
• funkcje,
• klasy,
• moduły,
• prototypy,
• obiekty globalne (Math, JSON, Date),
• zasady działania silnika (hoisting, zakresy, this).

Nie definiuje:

• DOM,
• BOM,
• fetch,
• WebSockets,
• localStorage,
• event loop (to definiuje WHATWG),
• API przeglądarkowych.

10. JavaScript to ECMAScript + WebAPI + środowisko wykonawcze

JavaScript to tak naprawdę zestaw trzech elementów:

1. ECMAScript – składnia i logika języka

To fundament.

2. WebAPI – funkcje dostarczane przez przeglądarkę

To wszystko, co pozwala manipulować stroną.

3. Silnik JavaScript (np. V8, SpiderMonkey, Chakra)

To program, który wykonuje kod.

11. Przykład praktyczny: Node.js

Node.js to świetny przykład, który pokazuje różnicę.

Node.js:

• używa ECMAScript jako języka,
• ale nie ma DOM,
• za to ma własne API: fs, http, path, process.

Czyli:

Node.js to JavaScript bez WebAPI przeglądarkowych, ale z własnymi API.

12. Dlaczego ECMAScript jest tak ważny?

Bo dzięki niemu:

• kod działa tak samo w każdej przeglądarce,
• nowe funkcje języka są wprowadzane w sposób uporządkowany,
• programiści wiedzą, czego się spodziewać,
• narzędzia takie jak Babel mogą kompilować kod do starszych wersji.

Bez ECMAScript mielibyśmy chaos jak w latach 90.

13. Czy JavaScript może mieć funkcje, których nie ma w ECMAScript?

Tak – i ma ich mnóstwo.

Przykład:

fetch("https://example.com")
  .then(res => res.json())
  .then(data => console.log(data));

fetch nie jest częścią ECMAScript. To WebAPI.

14. Czy ECMAScript może mieć funkcje, których nie ma JavaScript?

Teoretycznie tak – jeśli przeglądarka jeszcze ich nie zaimplementowała.

Przykład: Nowe funkcje z ES2023 mogą być dostępne w Node.js, ale nie w Safari.

15. Kod pokazujący różnicę w praktyce

Kod zgodny z ECMAScript (działa wszędzie)

const suma = (a, b) => a + b;
console.log(suma(2, 3));

Kod zależny od JavaScript w przeglądarce

document.body.style.background = "red";

Tu zależny od JavaScript w Node.js

const fs = require("fs");
fs.writeFileSync("plik.txt", "Hello!");

ECMAScript to standard języka, a JavaScript to jego implementacja rozszerzona o funkcje środowiska (przeglądarki lub Node.js).