Kurs JavaScript i TypeScript · Moduł 1: Podstawy JavaScript
Historia i znaczenie JavaScript
W tej lekcji6
Witaj w fascynującym świecie JavaScript! Podobnie jak paleontolodzy odkrywający tajemnice przeszłości w Parku Jurajskim, my zanurzymy się w historii i znaczeniu języka, który zrewolucjonizował sposób, w jaki postrzegamy i tworzymy współczesne aplikacje internetowe.
Narodziny JavaScript
JavaScript narodził się w 1995 roku za sprawą Brendana Eicha, który stworzył go w zaledwie 10 dni podczas pracy w Netscape Communications. Początkowo nazwany "Mocha", a później "LiveScript", ostatecznie przyjął nazwę "JavaScript" ze względów marketingowych, aby wykorzystać popularność języka Java, mimo że oba języki mają niewiele wspólnego poza podobieństwem składni.
To trochę jak odkrycie nowego gatunku dinozaura - choć może przypominać znane wcześniej stworzenia, ma swoje unikalne cechy i zdolności!
Ewolucja języka
JavaScript, podobnie jak świat dinozaurów, przeszedł przez wiele "er" ewolucyjnych:
- 1997: Standaryzacja jako ECMAScript (ES1)
- 1999: ES3 wprowadził bardziej zaawansowane funkcje wyrażeń regularnych, obsługę wyjątków (try/catch) i lepszą obsługę ciągów znaków
- 2009: ES5 dodał metody tablicowe (map, filter, reduce), strict mode i lepsze wsparcie dla JSON
- 2015: ES6/ES2015 przyniósł prawdziwą rewolucję z nowymi strukturami danych, klasami, funkcjami strzałkowymi, modułami, obietnicami (promises) i wieloma innymi funkcjami
- 2016-obecnie: Coroczne aktualizacje (ES2016, ES2017...) dodające nowe funkcjonalności
Ta ewolucja przypomina adaptację dinozaurów do zmieniającego się środowiska - JavaScript stale ewoluował, aby sprostać wymaganiom coraz bardziej złożonych aplikacji internetowych.
Znaczenie JavaScript w ekosystemie webowym
JavaScript jest jak T-Rex w świecie programowania webowego - stoi na szczycie łańcucha pokarmowego! Jest jedynym językiem programowania natywnie obsługiwanym przez przeglądarki, co czyni go niezbędnym do tworzenia interaktywnych stron internetowych. Jego znaczenie można podsumować w kilku kluczowych punktach:
1. Wszechobecność
JavaScript znajduje się na praktycznie każdej nowoczesnej stronie internetowej. Według danych statystycznych, jest używany na ponad 95% wszystkich stron.
2. Uniwersalność
JavaScript wyrwał się z ograniczeń przeglądarki i obecnie można go znaleźć:
- Na serwerze (Node.js)
- W aplikacjach mobilnych (React Native, Ionic)
- W aplikacjach desktopowych (Electron)
- W IoT (Internet Rzeczy) i urządzeniach wbudowanych
3. Bogaty ekosystem
Środowisko JavaScript to jak tętniący życiem ekosystem, pełen frameworków, bibliotek i narzędzi:
- Frameworki frontendowe (React, Angular, Vue)
- Frameworki backendowe (Express, Nest.js)
- Narzędzia do budowania (webpack, Parcel)
- Rozwiązania fullstackowe (Next.js, Nuxt)
JavaScript a przyszłość
JavaScript, podobnie jak genom dinozaurów przechowywany w bursztynie w Parku Jurajskim, zawiera w sobie możliwości, które dopiero zaczęliśmy odkrywać. Z rosnącą popularnością WebAssembly, JavaScript może współpracować z wysokowydajnym kodem skompilowanym, otwierając nowe możliwości dla aplikacji internetowych.
Podobnie jak naukowcy w Parku Jurajskim wykorzystali przełomowe technologie, aby przywrócić do życia wymarłe gatunki, programiści stale rozwijają nowe technologie oparte na JavaScript, przesuwając granice tego, co jest możliwe w sieci.
Dlaczego warto uczyć się JavaScript?
Uczenie się JavaScript to jak zdobywanie klucza do bram Parku Jurajskiego - otwiera dostęp do fascynującego świata możliwości:
- Ogromny rynek pracy - deweloperzy JavaScript są jednymi z najbardziej poszukiwanych specjalistów IT
- Szybkie prototypowanie - możliwość szybkiego tworzenia interaktywnych aplikacji
- Niska bariera wejścia - do rozpoczęcia nauki potrzebujesz tylko przeglądarki internetowej
- Wszechstronność - jeden język, niezliczone możliwości zastosowania
Podsumowanie
JavaScript, niczym dinozaury w Parku Jurajskim, przeszedł długą drogę ewolucji od skromnych początków do dominacji w swoim ekosystemie. Dziś jest fundamentalnym elementem rozwoju web i stale poszerza swoje terytorium.
W następnych lekcjach zagłębimy się w praktyczne aspekty JavaScript, ucząc się "oswajać" ten potężny język, podobnie jak trenerzy w Parku Jurajskim uczyli się współpracować z prehistorycznymi stworzeniami.
Przygotuj się na fascynującą podróż przez świat JavaScript - twoją przepustkę do tworzenia własnych cudów technologii, równie zdumiewających jak dinozaury przywrócone do życia!
Kod do tej lekcji: index.js
// Witaj w świecie JavaScript!
// Poznajemy historię i znaczenie języka
console.log("Witaj w Parku Jurajskim JavaScript!");
// 1. JavaScript w różnych okresach - ewolucja języka
console.log("\n=== Ewolucja JavaScript ===");
// ES5 (2009) - podstawowe metody tablicowe
const dinosaurNames = ["Tyrannosaurus", "Triceratops", "Velociraptor", "Stegosaurus"];
// Metoda map - transformacja danych
const dinosaursWithTitle = dinosaurNames.map(function(name) {
return "Dr. " + name;
});
console.log("ES5 map:", dinosaursWithTitle);
// Metoda filter - filtrowanie danych
const longNames = dinosaurNames.filter(function(name) {
return name.length > 10;
});
console.log("ES5 filter (długie nazwy):", longNames);
// 2. ES6/ES2015 - nowoczesne funkcje
console.log("\n=== ES6+ Nowoczesny JavaScript ===");
// Arrow functions
const modernDinosaurs = dinosaurNames.map(name => `${name}`);
console.log("ES6 arrow functions:", modernDinosaurs);
// Template literals
const favoriteDinosaur = "Tyrannosaurus Rex";
const description = `Mój ulubiony dinozaur to ${favoriteDinosaur}.
Jest królem wszystkich dinozaurów!`;
console.log("Template literals:", description);
// Destructuring
const [first, second, ...rest] = dinosaurNames;
console.log("Destructuring - pierwszy:", first);
console.log("Destructuring - drugi:", second);
console.log("Destructuring - reszta:", rest);
// 3. Obiekty dinozaurów - różne sposoby tworzenia
console.log("\n=== Tworzenie obiektów ===");
// ES5 sposób
function createDinosaurES5(name, period, diet) {
return {
name: name,
period: period,
diet: diet,
roar: function() {
return this.name + " mówi: ROAAR!";
}
};
}
const trex = createDinosaurES5("T-Rex", "Kredowy", "Mięsożerca");
console.log("ES5 obiekt:", trex);
console.log("ES5 metoda:", trex.roar());
// ES6+ sposób - skrócona składnia obiektów
function createDinosaurES6(name, period, diet) {
return {
name,
period,
diet,
roar() {
return `${this.name} mówi: ROAAR!`;
},
getInfo() {
return `${this.name} żył w okresie ${this.period} i był ${this.diet}`;
}
};
}
const velociraptor = createDinosaurES6("Velociraptor", "Kredowy", "Mięsożerca");
console.log("ES6 obiekt:", velociraptor);
console.log("ES6 informacje:", velociraptor.getInfo());
// 4. Klasy ES6
console.log("\n=== Klasy ES6 ===");
class Dinosaur {
constructor(name, period, diet, weight) {
this.name = name;
this.period = period;
this.diet = diet;
this.weight = weight;
}
roar() {
return `${this.name} wydaje potężny ryk!`;
}
getDetails() {
return {
name: this.name,
period: this.period,
diet: this.diet,
weight: `${this.weight} kg`,
sound: this.roar()
};
}
// Metoda statyczna
static compareDinosaurs(dino1, dino2) {
if (dino1.weight > dino2.weight) {
return `${dino1.name} jest cięższy od ${dino2.name}`;
} else if (dino1.weight < dino2.weight) {
return `${dino2.name} jest cięższy od ${dino1.name}`;
} else {
return `${dino1.name} i ${dino2.name} mają podobną wagę`;
}
}
}
const stegosaurus = new Dinosaur("Stegosaurus", "Jurski", "Roślinożerca", 5000);
const allosaurus = new Dinosaur("Allosaurus", "Jurski", "Mięsożerca", 4000);
console.log("Stegosaurus:", stegosaurus.getDetails());
console.log("Porównanie:", Dinosaur.compareDinosaurs(stegosaurus, allosaurus));
// 5. Promises i async/await - symulacja ładowania danych
console.log("\n=== Asynchroniczność ===");
// Promise
function loadDinosaurData(name) {
return new Promise((resolve, reject) => {
setTimeout(() => {
const dinosaurDB = {
"Tyrannosaurus": { period: "Kredowy", discovered: 1905 },
"Triceratops": { period: "Kredowy", discovered: 1889 },
"Stegosaurus": { period: "Jurski", discovered: 1877 }
};
if (dinosaurDB[name]) {
resolve({ name, ...dinosaurDB[name] });
} else {
reject(new Error(`Dinozaur ${name} nie został znaleziony w bazie!`));
}
}, 1000);
});
}
// Async/await
async function getDinosaurInfo(name) {
try {
console.log(`Szukam informacji o ${name}...`);
const data = await loadDinosaurData(name);
console.log(`Znaleziono: ${name} z okresu ${data.period}, odkryty w ${data.discovered} roku`);
return data;
} catch (error) {
console.log("Błąd:", error.message);
}
}
// Test różnych funkcji
getDinosaurInfo("Tyrannosaurus");
getDinosaurInfo("Brontosaurus"); // Ten nie istnieje w bazie
// 6. Modules - eksport i import (symulacja)
console.log("\n=== Modules (symulacja) ===");
// Symulujemy eksport/import
const DinosaurModule = {
// Eksportowane funkcje
createHerbivore(name, weight) {
return new Dinosaur(name, "Nieznany", "Roślinożerca", weight);
},
createCarnivore(name, weight) {
return new Dinosaur(name, "Nieznany", "Mięsożerca", weight);
},
// Eksportowana stała
PERIODS: ["Triasowy", "Jurski", "Kredowy"],
// Domyślny eksport
default: Dinosaur
};
// Używanie "zaimportowanych" funkcji
const brachiosaurus = DinosaurModule.createHerbivore("Brachiosaurus", 80000);
const spinosaurus = DinosaurModule.createCarnivore("Spinosaurus", 7000);
console.log("Brachiosaurus:", brachiosaurus.getDetails());
console.log("Dostępne okresy:", DinosaurModule.PERIODS);
// 7. Demonstracja wszystkich typów danych
console.log("\n=== Typy danych w JavaScript ===");
const dataTypes = {
// Prymitywne typy
string: "Tyrannosaurus Rex",
number: 68000000, // Wiek w latach
boolean: true, // Czy jest mięsożercą
undefined: undefined,
null: null,
symbol: Symbol("unique-dinosaur-id"),
bigint: 999999999999999999999n,
// Obiekty
object: { name: "Triceratops", horns: 3 },
array: ["T-Rex", "Velociraptor", "Triceratops"],
function: function() { return "Jestem funkcją!"; },
date: new Date(),
regexp: /dinozaur/gi
};
console.log("Wszystkie typy danych:");
for (const [key, value] of Object.entries(dataTypes)) {
console.log(`${key}: ${typeof value} = ${String(value)}`);
}
console.log("\nGratulacje! Poznałeś historię i podstawy JavaScript!");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 jest JavaScript?
2. Kto stworzył JavaScript?
3. Która cecha NIE opisuje JavaScript?
4. Jaki jest związek między JavaScript a Java?
5. Co to jest ECMAScript?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj chronologicznie kamienie milowe JavaScript: