Podstawy Java Script

<script>
    alert("Witaj na mojej stronie!");
</script>

<script src="plik.js"></script>

<script src="skrypt.js" defer></script>

<script src="skrypt.js" async></script>

console.log("Wartość zmiennej x:", x);

// To jest komentarz jednolinijkowy
let x = 3;  // Komentarz po instrukcji

/* 
To jest komentarz
wielolinijkowy.
Obejmuje kilka linii tekstu.
*/
let y = 3;

var zmiennaGlobalna = "zmienna globalna";
let zmiennaLokalna = "wprowadzona w ES6";
innaZmiennaLokalna = "taki zapis jest możliwy, ale nie jest zalecany";
const STALA = "wartości";

var wylosowana = 5;
const PI = 3.14;
let liczba = 5;

if (true) {
  let liczba = 10;
  wylosowana = 10;
}

console.log("liczba:     " + liczba);
console.log("wylosowana: " + wylosowana);
console.log("PI:         " + PI);

let wiek = 40; // liczba całkowita
let pi = 3.14; // liczba zmiennoprzecinkowa

let duzaLiczba = 1234567890123456789012345678901234567890n;

let napis = "Witaj, świecie!";

let prawda = true;
let falsz = false;

let osoba = {
  imie: "Pioter",
  wiek: 50
};

let owoce = ["jabłka", "banany", "pomarańcze"];

let niezdefiniowana;
console.log(niezdefiniowana);  // wyświetli "undefined"

let pusta = null;

let wynik = 3 + 3;  // dodawanie, wynik = 6
let wynik = 3 - 2;  // odejmowanie, wynik = 1
let wynik = 3 * 3;  // mnożenie, wynik = 9
let wynik = 12 / 3; // dzielenie, wynik = 4
let wynik = 10 % 3; // reszta z dzielenie, wynik = 1
let wynik = 3 ** 3; // potęgowanie (ES6), wynik = 27

let wiek = 40;
wiek++; // wiek = 41;

let jablka = 5;
jablka-- // jablka = 4;

6 == 5 // 6 równa się 5 - fałsz
6 != 5 // 6 jest różne od 5 - prawda
6 > 5  // 6 jest większe od 5 - prawda
6 < 5  // 6 jest mniejsze od 5 - fałsz
6 >= 5 // 6 jest większe lub równe 5 - prawda
6 <= 5 // 6 jest mniejsze lub równe 5 - fałsz

5 === "5" // 5 jest identyczne jak tekst "5" (porównywany jest tu także typ danych) - fałsz
5 === 5   // 5 jest identyczne jak 5 - prawda
5 !== "5" // 5 nie jest identyczne jak tekst "5" - prawda
5 !== 5   // 5 nie jest identyczne jak 5 - fałsz

true && false - operator AND (oba warunki muszą być prawdziwe) - fałsz
true || false - operator OR (jeden z warunków musi być prawdziwy) - prawda
!true - operator NOT (zamienia wartość na przeciwną) - fałsz

let x = 5; // pod zmienną x przypisaliśmy 5
let y = x; // pod zmienną y przypisaliśmy to co było w x (czyli 5)

let zwierze = "kot";
let typ = typeof zwierze; // pod zmienną typ znajdzie się "string"

if (warunek) {
    // kod do wykonania, jeśli warunek jest prawdziwy
}

let liczba = 8;
if (liczba > 4) {
    console.log("Liczba jest większa od 4");
}

if (warunek) {
    // kod do wykonania, jeśli warunek jest prawdziwy
} else {
    // kod do wykonania, jeśli warunek jest fałszywy
}

let liczba = 8;
if (liczba > 4) {
    console.log("Liczba jest większa od 4");
} else {
    console.log("Liczba nie jest większa od 4");
}

if (warunek1) {
    // kod do wykonania, jeśli warunek1 jest prawdziwy
} else if (warunek2) {
    // kod do wykonania, jeśli warunek2 jest prawdziwy
} else {
    // kod do wykonania, jeśli żaden z warunków nie jest prawdziwy
}

let liczba = 8;
if (liczba > 4) {
    console.log("Liczba jest większa od 4");
} else if (liczba == 4) {
    console.log("Liczba jest równa 4");
} else {
    console.log("Liczba jest mniejsza od 4");
}

warunek ? prawda : fałsz;

let liczba = 8;
liczba > 4 ? console.log("Liczba jest większa od 4") : console.log("Liczba nie jest większa od 4");

switch(wartość) {
    case możliwość1:
        // kod do wykonania, gdy wartość równa się możliwość1
        break;
    case możliwość2:
        // kod do wykonania, gdy wartość równa się możliwość2
        break;
    // ... więcej przypadków ...
    default:
        // kod do wykonania, jeśli żadna z możliwości nie jest prawdziwa
}

let kolor = "żółty";
switch (kolor) {
    case "czerwony":
        console.log("Kolor pomidora");
        break;
    case "niebieski":
        console.log("Kolor słońca");
        break;
    default:
        console.log("Nie znam tego koloru");
}

for (inicjalizacja; warunek; aktualizacja) {
    // kod do wykonania w każdej iteracji
}

for (let i = 1; i < 4; i++) {
    console.log(i);
}

while (warunek) {
    // kod do wykonania w każdej iteracji
}

let i = 1;
while (i < 5) {
    console.log(i);
    i++;
}

do {
    // kod do wykonania w każdej iteracji
} while (warunek);

let i = 1;
do {
    console.log(i);
    i++;
} while (i < 5);

for (const element of iterable) {
    // kod do wykonania dla każdego elementu
}

let kolory = ['czerwony', 'żółty', 'niebieski'];
for (const kolor of kolory) {
    console.log(kolor);
}

for (const klucz in obiekt) {
    // kod do wykonania dla każdego klucza
}

let osoba = {imie: 'Maciej', wiek: 40};
for (const klucz in osoba) {
    console.log(klucz, osoba[klucz]);
}

for (let i = 1; i < 80; i++) {

    if (i == 4) {
        continue; // pominie wartość 4 i przejdzie do kolejnej iteracji
    }
    if (i == 6) {
        break; // przerywa pętlę
    }
    console.log(i);
}

function nazwaFunkcji(parametr1, parametr2, ...) {
    // ciało funkcji
}

function powitaj(imie) {
    console.log("Cześć, " + imie + "!");
}

powitaj("Maciej");  // Wyświetli: "Cześć, Maciej!"

function powitaj(imie = "Pioter") {
    console.log("Cześć, " + imie + "!");
}

powitaj();  // Wyświetla: "Cześć, Pioter!"
powitaj("Maciej");  // Wyświetla: "Cześć, Maciej!"

function dodaj(a, b) {
    return a + b;
}

let suma = dodaj(4, 8);  // suma = 12

const hello = function() {
    console.log("Hello!")
}

hello ();  // Wyświetli napis: "Hello!"

const dodaj = (a, b) => a + b;

console.log(dodaj(4, 8));  // Wyświetli: 12

(function() {
    console.log("Natychmiast po definicji!");
})();

let obiekt = {
    klucz1: 'wartość1',
    klucz2: 'wartość2',
    metoda1: function() {
        console.log(this.klucz1);
    }
};

console.log(obiekt.klucz1);  // wartość1
console.log(obiekt['klucz2']);  // wartość2

obiekt.klucz3 = 'wartość3';
obiekt.klucz1 = 'nowa wartość1';

let tablica = [1, "Maciej", 3.14];

let tablica = [1, "Maciej", 3.14];
console.log(tablica[1]);  // element1

let tablica = [1, "Maciej", 3.14];
tablica.push('kropek');  // dodaje element na końcu tablicy
console.log(tablica[3]);
tablica.pop();  // usuwa ostatni element tablicy

let tablica = [1, "Maciej", 3.14];
console.log(tablica.length);  // 3

for (let i = 0; i < tablica.length; i++) {
    console.log(tablica[i]);
}

tablica.forEach(function(element) {
    console.log(element);
});

// Dodaje jeden lub więcej elementów na końcu tablicy i zwraca nową długość tablicy.
push(element1, ..., elementN);

// Usuwa ostatni element z tablicy i zwraca go.
pop(); 

// Usuwa pierwszy element z tablicy i zwraca go.
shift();

// Dodaje jeden lub więcej elementów na początek tablicy i zwraca nową długość tablicy.
unshift(element1, ..., elementN); 

// Łączy dwie lub więcej tablic.
concat(value1, ..., valueN);

// Łączy wszystkie elementy tablicy w ciąg znaków.
join(separator);

// Wycina fragment tablicy i zwraca go jako nową tablicę.
slice(begin, [end]);

// Dodaje/usuwa elementy z tablicy.
splice(start, deleteCount, item1, ..., itemN);

// Wykonuje podaną funkcję dla każdego elementu tablicy.
forEach(callback(element, index, array), [thisArg]);

// Tworzy nową tablicę z wynikami wywołania podanej funkcji dla każdego elementu tablicy.
map(callback(element, index, array), [thisArg]);

// Tworzy nową tablicę z wszystkimi elementami, które przechodzą test określony w funkcji.
filter(callback(element, index, array), [thisArg]);

// Aplikuje funkcję na akumulator i każdy element tablicy (od lewej do prawej), aby zredukować ją do pojedynczej wartości.
reduce(callback(accumulator, currentValue, currentIndex, array), initialValue);

// Jak reduce, ale przetwarza od prawej do lewej.
reduceRight(callback(accumulator, currentValue, currentIndex, array), initialValue);

// Sprawdza, czy przynajmniej jeden element tablicy spełnia test określony w funkcji.
some(callback(element, index, array), [thisArg]);

// Sprawdza, czy wszystkie elementy tablicy spełniają test określony w funkcji.
every(callback(element, index, array), [thisArg]);

// Zwraca wartość pierwszego elementu w tablicy, który spełnia test określony w funkcji.
find(callback(element, index, array), [thisArg]);

// Zwraca indeks pierwszego elementu tablicy, który spełnia test określony w funkcji.
findIndex(callback(element, index, array), [thisArg]);

// Odwraca kolejność elementów tablicy.
reverse();

// Sortuje elementy tablicy.
sort([compareFunction]);

// Zwraca pierwszy indeks, w którym dany element można znaleźć w tablicy, lub -1, jeśli takiego elementu nie ma.
indexOf(searchElement, [fromIndex]);

// Zwraca ostatni indeks, w którym można znaleźć dany element w tablicy, lub -1, jeśli takiego elementu nie ma.
lastIndexOf(searchElement, [fromIndex]);

// Sprawdza, czy tablica zawiera określony element.
includes(searchElement, [fromIndex]);

// Wypełnia część tablicy jedną wartością.
fill(value, start, end);

// Kopiuje część tablicy do innej lokalizacji w tej samej tablicy.
copyWithin(target, start, [end]);

// Spłaszcza tablicę do określonej głębokości.
flat([depth]);

// Najpierw mapuje każdy element za pomocą funkcji mapującej, a następnie spłaszcza tablicę o jeden poziom.
flatMap(callback, [thisArg]);

// Sprawdza, czy podana wartość jest tablicą.
Array.isArray(value);

// Zwraca znak w określonej pozycji.
charAt(position);

// Zwraca wartość Unicode znaku w określonej pozycji.
charCodeAt(position);

// Łączy dwa lub więcej ciągów znaków i zwraca nowy ciąg.
concat(string2, string3,..., stringX);

// Sprawdza, czy ciąg zawiera określony fragment; zwraca true lub false.
includes(searchString, position);

// Sprawdza, czy ciąg kończy się określonym fragmentem; zwraca true lub false.
endsWith(searchString, length);

// Zwraca indeks, w którym można znaleźć określony fragment w ciągu, lub -1, jeśli fragmentu nie ma.
indexOf(searchValue, fromIndex);

// Zwraca ostatni indeks, w którym można znaleźć określony fragment w ciągu, lub -1, jeśli fragmentu nie ma.
lastIndexOf(searchValue, fromIndex);

// Wyszukuje dopasowanie w ciągu za pomocą wyrażenia regularnego i zwraca wynik w postaci tablicy lub null.
match(regexp);

// Zwraca nowy ciąg znaków zawierający określoną liczbę kopii oryginalnego ciągu.
repeat(count);

// Zastępuje fragment ciągu innym fragmentem lub wynikiem funkcji.
replace(searchFor, replaceWith);

// Wyszukuje dopasowanie do wyrażenia regularnego w ciągu i zwraca indeks początku dopasowania lub -1.
search(regexp);

// Wycina fragment ciągu i zwraca go jako nowy ciąg.
slice(beginIndex, endIndex);

// Dzieli ciąg na tablicę podciągów na podstawie separatora.
split(separator, limit);

// Sprawdza, czy ciąg zaczyna się określonym fragmentem; zwraca true lub false.
startsWith(searchString, position);

// Zwraca fragment ciągu między dwoma indeksami.
substring(indexStart, indexEnd);

// Zwraca ciąg ze wszystkimi literami w formie małych liter.
toLowerCase();

// Zwraca ciąg ze wszystkimi literami w formie wielkich liter.
toUpperCase();

// Usuwa białe znaki z obu końców ciągu.
trim();

// Usuwa białe znaki z początku ciągu.
trimStart() lub trimLeft();

// Usuwa białe znaki z końca ciągu.
trimEnd() lub trimRight();

// Zwraca pierwotną wartość ciągu.
valueOf();

// Zwraca wartość bezwzględną liczby
Math.abs(number);

// Zaokrągla liczbę w górę do najbliższej liczby całkowitej
Math.ceil(number);

// Zaokrągla liczbę w dół do najbliższej liczby całkowitej
Math.floor(number);

// Zaokrągla liczbę do najbliższej liczby całkowitej
Math.round(number);

// Zwraca największą wartość z listy liczb
Math.max(numbers);

// Zwraca najmniejszą wartość z listy liczb
Math.min(numbers);

// Zwraca wartość liczby x podniesionej do potęgi y
Math.pow(x, y);

// Zwraca pierwiastek kwadratowy liczby
Math.sqrt(number);

// Zwraca sinus kąta (kąt w radianach)
Math.sin(angleInRadians);

// Zwraca cosinus kąta (kąt w radianach)
Math.cos(angleInRadians);

// Zwraca tangens kąta (kąt w radianach)
Math.tan(angleInRadians);

// Zwraca arcus sinus wartości (wynik w radianach)
Math.asin(number);

// Zwraca arcus cosinus wartości (wynik w radianach)
Math.acos(number);

// Zwraca arcus tangens wartości (wynik w radianach)
Math.atan(number);

// Zwraca arcus tangens dwóch zmiennych (y, x) (wynik w radianach)
Math.atan2(y, x);

// Zwraca e podniesione do potęgi argumentu
Math.exp(number);

// Zwraca logarytm naturalny (podstawa e) liczby
Math.log(number);

// Zwraca najbliższą liczbę całkowitą
Math.trunc(number);

// Zwraca losową liczbę między 0 a 1
Math.random();