Pełną listę funkcji znajdziecie w dokumentacji PHP,  poniżej najczęściej wykorzystywane.

Tablica (ang. array) to uporządkowany zbiór danych przechowywany w jednej zmiennej. Każdy element tablicy ma swój indeks (klucz) i wartość.

Zastosowania:
– Przechowywanie list danych (produkty, użytkownicy, etc.)
– Gromadzenie wyników z bazy danych
– Konfiguracja aplikacji
– Przesyłanie danych między funkcjami

Typy indeksów:
– Numeryczne (0, 1, 2, …) – tablice indeksowane
– Tekstowe (ciągi znaków) – tablice asocjacyjne

Sposób 1:

Inicjowanie tablicy za pomocą nawiasów kwadratowych [].

// Pusta tablica
$tablica = [];

// Tablica z wartościami
$owoce = ['jabłko', 'banan', 'gruszka'];

// Tablica asocjacyjna
$osoba = [
    'imie' => 'Jan',
    'nazwisko' => 'Kowalski',
    'wiek' => 30
];

// Dodawanie elementów
$owoce[] = 'pomarańcza';  // doda na końcu
$owoce[10] = 'kiwi';       // doda pod indeksem 10

W powyższym przykładzie wskazujemy konkretny nr indeksu w jaki ma zostać wpisana wartość np. $owoce[10] = 'kiwi’;. Odczytujemy ten zapis jako: w tablicy o nazwie „owoce” wstaw do indexu „10” wartość „kiwi”.

Podawanie indeksów nie jest konieczne:

$tablica[0] = "Wpis numer 0"; 
$tablica[] = "Wpis numer 1"; 
$tablica[] = "Wpis numer 2";

echo '<pre>';
print_r($tablica);
echo '</pre>';

/*
Wyświetli:
Array (
    [0] => Wpis numer 0 
    [1] => Wpis numer 1 
    [2] => Wpis numer 2
)
*/

Nie wskazanie podczas inicjowania tablicy konkretnych indexów danych uruchamia proces autonumerowania od ostatniej najwyższej wartości.

Sposób 2:

Inicjowanie tablicy za pomocą konstrukcji array(). Zalecenie: Używaj składni [] – krótsza i nowocześniejsza

// Pusta tablica
$tablica = array();

// Tablica z wartościami
$owoce = array('jabłko', 'banan', 'gruszka');

// Tablica asocjacyjna
$osoba = array(
    'imie' => 'Jan',
    'nazwisko' => 'Kowalski',
    'wiek' => 30
);

Możemy wskazywać konkretne indeksy, w których chcemy wstawić wartości. Wykonujemy to za pomocą wskazania „index => wartość”.

Trochę więcej o array() niżej.

Elementem tablicy może być każdy typ zmiennej (z innymi tablicami i obiektami włącznie).

Tablica dwuwymiarowa, zawiera dwa indeksy, np. $tablica[0][2] = 1; O nich troszkę niżej.

 Sposób 3:

Przypisywanie indeksowe

$tablica[0] = "Element 0";
$tablica[1] = "Element 1";
$tablica[2] = "Element 2";

// Bez podawania indeksu - auto-numeracja
$tablica[] = "Element 3";  // indeks 3
$tablica[] = "Element 4";  // indeks 4

Indexy zewnetrzne

Typy tablic

Tablica indeksowana (numeryczna)

Indeksy to liczby całkowite (domyślnie od 0).

$kolory = ['czerwony', 'zielony', 'niebieski'];

echo $kolory[0];  // czerwony
echo $kolory[1];  // zielony
echo $kolory[2];  // niebieski

// Pętla for
for ($i = 0; $i < count($kolory); $i++) {
    echo $kolory[$i] . "\n";
}

Tablica asocjacyjna

W PHP występuje też inny rodzaj tablic, tak zwane tablice asocjacyjne. Są to tablice, w których zamiast indeksów liczbowych używa się identyfikatorów znakowych (kluczy), a po polsku – nadajemy indeksom nazwy słowne, tak jak w nagłówkach zwykłej tabeli:

$osoba = [
    'imie' => 'Jan',
    'nazwisko' => 'Kowalski',
    'wiek' => 30,
    'miasto' => 'Warszawa'
];

echo $osoba['imie'];      // Jan
echo $osoba['nazwisko'];  // Kowalski

// Pętla foreach
foreach ($osoba as $klucz => $wartosc) {
    echo "$klucz: $wartosc\n";
}

Tablica wielowymiarowa

Tablica zawierająca inne tablice jako elementy.

// Dwuwymiarowa
$uczniowie = [
    ['Jan', 'Kowalski', 15],
    ['Anna', 'Nowak', 16],
    ['Piotr', 'Wiśniewski', 15]
];

echo $uczniowie[0][0];  // Jan
echo $uczniowie[1][1];  // Nowak

// Wielowymiarowa asocjacyjna
$produkty = [
    'elektronika' => [
        'laptop' => 3000,
        'telefon' => 1500,
        'tablet' => 800
    ],
    'odzież' => [
        'koszula' => 100,
        'spodnie' => 150
    ]
];

echo $produkty['elektronika']['laptop'];  // 3000

Podglądanie zawartości tabel

Aby w całości wyświetlić tablicę (podejrzeć jej zawartość) – wykorzystujemy funkcje:
print_r ($zmienna_tablicowa);
lub
var_dump($zmienna_tablicowa);

 print_r()

wyświetla tablice w sposób jasny i przejrzysty dla programisty, pokazując nazwy indeksów:

<pre>
<?php

    $a=array(
      'a' => 'jabłko', 
      'b' => 'banan', 
      'c' => array ('x', 'y', 'z')
    );

print_r($a);

?>
</pre>

/*zostanie wyświetlone:
Array
(
    [a] => jabłko
    [b] => banan
    [c] => Array
        (
            [0] => x
            [1] => y
            [2] => z
        )
)
*/

Operacje na tablicach

Sprawdzanie typu – is_array()

$zmienna = ['a', 'b', 'c'];

if (is_array($zmienna)) {
    echo "To jest tablica";
} else {
    echo "To nie jest tablica";
}

// Krótka forma
echo is_array($zmienna) ? 'tablica' : 'nie tablica';

Liczba elementów – count() / sizeof()

$owoce = ['jabłko', 'banan', 'gruszka', 'pomarańcza'];

echo count($owoce);   // 4
echo sizeof($owoce);  // 4 (alias count)

// Tablica wielowymiarowa
$multi = [
    [1, 2, 3],
    [4, 5, 6]
];

echo count($multi);              // 2 (tylko pierwsze poziom)
echo count($multi, COUNT_RECURSIVE);  // 8 (wszystkie elementy)

Dodawanie elementów

$owoce = ['jabłko', 'banan'];

// Na końcu
$owoce[] = 'gruszka';
array_push($owoce, 'pomarańcza', 'kiwi');

// Na początku
array_unshift($owoce, 'truskawka');

print_r($owoce);
// ['truskawka', 'jabłko', 'banan', 'gruszka', 'pomarańcza', 'kiwi']

$array[] = $value jest szybsze niż array_push().

Usuwanie elementów

$owoce = ['jabłko', 'banan', 'gruszka', 'pomarańcza'];

// Z końca
$ostatni = array_pop($owoce);
echo $ostatni;  // pomarańcza

// Z początku
$pierwszy = array_shift($owoce);
echo $pierwszy;  // jabłko

// Konkretny indeks
unset($owoce[1]);  // usuń 'banan'

// Wszystkie elementy
unset($owoce);
$owoce = [];  // lub tak

Łączenie tablic

$tablica1 = ['a', 'b', 'c'];
$tablica2 = ['d', 'e', 'f'];

// array_merge() - łączy tablice
$polaczona = array_merge($tablica1, $tablica2);
print_r($polaczona);
// ['a', 'b', 'c', 'd', 'e', 'f']

// Operator + (zachowuje klucze)
$tab1 = [0 => 'a', 1 => 'b'];
$tab2 = [0 => 'c', 2 => 'd'];
$wynik = $tab1 + $tab2;
print_r($wynik);
// [0 => 'a', 1 => 'b', 2 => 'd']  // klucz 0 z $tab2 został pominięty

// Spread operator (PHP 7.4+)
$polaczona = [...$tablica1, ...$tablica2];

Wyszukiwanie w tablicy

PHP
$owoce = ['jabłko', 'banan', 'gruszka'];

// in_array() - sprawdza czy wartość istnieje
if (in_array('banan', $owoce)) {
    echo "Jest banan!";
}

// array_search() - zwraca klucz (indeks)
$indeks = array_search('gruszka', $owoce);
echo $indeks;  // 2

// array_key_exists() - sprawdza czy klucz istnieje
$osoba = ['imie' => 'Jan', 'wiek' => 30];
if (array_key_exists('imie', $osoba)) {
    echo "Klucz 'imie' istnieje";
}

// isset() - szybsza alternatywa
if (isset($osoba['imie'])) {
    echo "Klucz 'imie' istnieje";

Wyciąganie kluczy i wartości

$osoba = [
    'imie' => 'Jan',
    'nazwisko' => 'Kowalski',
    'wiek' => 30
];

// Wszystkie klucze
$klucze = array_keys($osoba);
print_r($klucze);
// ['imie', 'nazwisko', 'wiek']

// Wszystkie wartości
$wartosci = array_values($osoba);
print_r($wartosci);
// ['Jan', 'Kowalski', 30]

// Odwrócenie kluczy z wartościami
$odwrocona = array_flip($osoba);
print_r($odwrocona);
// ['Jan' => 'imie', 'Kowalski' => 'nazwisko', 30 => 'wiek']

Przeglądanie tablic

Pętla for (dla tablic indeksowanych)

$liczby = [10, 20, 30, 40, 50];

for ($i = 0; $i < count($liczby); $i++) {
    echo $liczby[$i] . "\n";
}

// Lepiej - zachowaj count w zmiennej
$dlugosc = count($liczby);
for ($i = 0; $i < $dlugosc; $i++) {
    echo $liczby[$i] . "\n";
}

Pętla foreach (uniwersalna, zalecana)

// Tylko wartości
$owoce = ['jabłko', 'banan', 'gruszka'];

foreach ($owoce as $owoc) {
    echo $owoc . "\n";
}

// Klucze i wartości
$osoba = ['imie' => 'Jan', 'wiek' => 30];

foreach ($osoba as $klucz => $wartosc) {
    echo "$klucz: $wartosc\n";
}

// 🆕 Modyfikacja przez referencję
$liczby = [1, 2, 3, 4, 5];

foreach ($liczby as &$liczba) {
    $liczba *= 2;
}
unset($liczba);  // WAŻNE: zawsze unset po pętli z referencją!

print_r($liczby);
// [2, 4, 6, 8, 10]

Funkcja list() – destrukturyzacja

// Podstawowe użycie
$info = ['kawa', 'brązowa', 'kofeina'];
list($napoj, $kolor, $skladnik) = $info;

echo "$napoj jest $kolor a $skladnik czyni ją wyjątkową";
// kawa jest brązowa a kofeina czyni ją wyjątkową

// Pomijanie elementów
list($napoj, , $skladnik) = $info;
echo "$napoj zawiera $skladnik";
// kawa zawiera kofeina

// Krótka składnia (PHP 7.1+)
[$napoj, $kolor, $skladnik] = $info;

// Z kluczami asocjacyjnymi (PHP 7.1+)
$osoba = ['imie' => 'Jan', 'wiek' => 30, 'miasto' => 'Warszawa'];
['imie' => $imie, 'wiek' => $wiek] = $osoba;
echo "$imie ma $wiek lat";

reset() – ustawianie wskaźnika

$tablica = ['a', 'b', 'c'];

// Przesuń wskaźnik
next($tablica);
next($tablica);
echo current($tablica);  // c

// Zresetuj na początek
reset($tablica);
echo current($tablica);  // a

W nowoczesnym PHP rzadko używane – preferuj foreach.

Sortowanie tablic

sort() / rsort() – sortowanie wartości (indeksowane)

$liczby = [5, 2, 8, 1, 9];

// Rosnąco
sort($liczby);
print_r($liczby);  // [1, 2, 5, 8, 9]

// Malejąco
rsort($liczby);
print_r($liczby);  // [9, 8, 5, 2, 1]

// ⚠️ Uwaga: indeksy są resetowane!
$owoce = [2 => 'banan', 0 => 'jabłko', 1 => 'gruszka'];
sort($owoce);
print_r($owoce);
// [0 => 'banan', 1 => 'gruszka', 2 => 'jabłko']

asort() / arsort() – sortowanie wartości (asocjacyjne)

Zachowuje przypisanie kluczy do wartości.

$owoce = [
    'd' => 'mango',
    'a' => 'papaja',
    'b' => 'banan',
    'c' => 'aronia'
];

// Rosnąco
asort($owoce);
print_r($owoce);
// ['c' => 'aronia', 'b' => 'banan', 'd' => 'mango', 'a' => 'papaja']

// Malejąco
arsort($owoce);
print_r($owoce);
// ['a' => 'papaja', 'd' => 'mango', 'b' => 'banan', 'c' => 'aronia']

ksort() / krsort() – sortowanie kluczy

$owoce = [
    'd' => 'mango',
    'a' => 'papaja',
    'b' => 'banan',
    'c' => 'aronia'
];

// Rosnąco po kluczach
ksort($owoce);
print_r($owoce);
// ['a' => 'papaja', 'b' => 'banan', 'c' => 'aronia', 'd' => 'mango']

// Malejąco po kluczach
krsort($owoce);
print_r($owoce);
// ['d' => 'mango', 'c' => 'aronia', 'b' => 'banan', 'a' => 'papaja']

usort() / uasort() / uksort() – sortowanie własną funkcją

$osoby = [
    ['imie' => 'Jan', 'wiek' => 30],
    ['imie' => 'Anna', 'wiek' => 25],
    ['imie' => 'Piotr', 'wiek' => 35]
];

// usort() - sortowanie wartości
usort($osoby, function($a, $b) {
    return $a['wiek'] <=> $b['wiek'];  // sortuj po wieku
});

print_r($osoby);
// [['imie' => 'Anna', 'wiek' => 25], ['imie' => 'Jan', 'wiek' => 30], ...]

// Arrow function (PHP 7.4+)
usort($osoby, fn($a, $b) => $a['wiek'] <=> $b['wiek']);

// uasort() - zachowuje klucze
$oceny = ['Jan' => 4, 'Anna' => 5, 'Piotr' => 3];
uasort($oceny, fn($a, $b) => $b <=> $a);  // malejąco
print_r($oceny);
// ['Anna' => 5, 'Jan' => 4, 'Piotr' => 3]

Tabela funkcji sortujących

Funkcje tablicowe

explode() / implode() – string ↔ array

// explode() - dzieli string na tablicę
$tekst = "alfa;beta;gamma;delta";
$tablica = explode(";", $tekst);
print_r($tablica);
// ['alfa', 'beta', 'gamma', 'delta']

// Z limitem
$tablica = explode(";", $tekst, 2);
print_r($tablica);
// ['alfa', 'beta;gamma;delta']

// implode() / join() - łączy tablicę w string
$tekst = implode(";", $tablica);
echo $tekst;  // alfa;beta;gamma;delta

str_split() – dzieli string na znaki

$str = "Hello";

// Na pojedyncze znaki
$znaki = str_split($str);
print_r($znaki);
// ['H', 'e', 'l', 'l', 'o']

// Na fragmenty długości 2
$fragmenty = str_split($str, 2);
print_r($fragmenty);
// ['He', 'll', 'o']

array_slice() – wycina fragment tablicy

$owoce = ['jabłko', 'banan', 'gruszka', 'pomarańcza', 'kiwi'];

// Od indeksu 1, 3 elementy
$fragment = array_slice($owoce, 1, 3);
print_r($fragment);
// ['banan', 'gruszka', 'pomarańcza']

// Od końca
$ostatnie = array_slice($owoce, -2);
print_r($ostatnie);
// ['pomarańcza', 'kiwi']

// Zachowaj klucze
$fragment = array_slice($owoce, 1, 3, true);

array_splice() – usuwa/zastępuje fragment

$owoce = ['jabłko', 'banan', 'gruszka', 'pomarańcza'];

// Usuń 2 elementy od indeksu 1
$usuniete = array_splice($owoce, 1, 2);
print_r($owoce);     // ['jabłko', 'pomarańcza']
print_r($usuniete);  // ['banan', 'gruszka']

// Zastąp
$owoce = ['jabłko', 'banan', 'gruszka'];
array_splice($owoce, 1, 1, ['kiwi', 'mango']);
print_r($owoce);
// ['jabłko', 'kiwi', 'mango', 'gruszka']

// Wstaw bez usuwania
array_splice($owoce, 2, 0, ['truskawka']);

array_unique() – usuwa duplikaty

$liczby = [1, 2, 2, 3, 4, 4, 5];
$unikalne = array_unique($liczby);
print_r($unikalne);
// [0 => 1, 1 => 2, 3 => 3, 4 => 4, 6 => 5]

// Zresetuj indeksy
$unikalne = array_values(array_unique($liczby));
print_r($unikalne);
// [1, 2, 3, 4, 5]

array_reverse() – odwraca tablicę

$owoce = ['jabłko', 'banan', 'gruszka'];
$odwrocone = array_reverse($owoce);
print_r($odwrocone);
// ['gruszka', 'banan', 'jabłko']

// Zachowaj klucze
$odwrocone = array_reverse($owoce, true);

array_sum() / array_product()

$liczby = [1, 2, 3, 4, 5];

// Suma
echo array_sum($liczby);  // 15

// Iloczyn
echo array_product($liczby);  // 120

array_rand() – losowy element

$owoce = ['jabłko', 'banan', 'gruszka', 'pomarańcza'];

// Jeden losowy klucz
$klucz = array_rand($owoce);
echo $owoce[$klucz];

// Trzy losowe klucze
$klucze = array_rand($owoce, 3);
foreach ($klucze as $k) {
    echo $owoce[$k] . "\n";
}

array_chunk() – dzieli tablicę na mniejsze

$liczby = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

$chunki = array_chunk($liczby, 3);
print_r($chunki);
// [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

// Zachowaj klucze
$chunki = array_chunk($liczby, 3, true);

array_map() – transformacja elementów

$liczby = [1, 2, 3, 4, 5];

// Podwój każdą liczbę
$podwojone = array_map(function($x) {
    return $x * 2;
}, $liczby);
print_r($podwojone);
// [2, 4, 6, 8, 10]

// Arrow function (PHP 7.4+)
$podwojone = array_map(fn($x) => $x * 2, $liczby);

// Wiele tablic
$imiona = ['Jan', 'Anna'];
$nazwiska = ['Kowalski', 'Nowak'];

$pelne = array_map(function($imie, $nazwisko) {
    return "$imie $nazwisko";
}, $imiona, $nazwiska);
print_r($pelne);
// ['Jan Kowalski', 'Anna Nowak']

// Spread + array_map (PHP 7.4+)
$kwadraty = array_map(fn($x) => $x ** 2, range(1, 10));

array_filter() – filtrowanie elementów

$liczby = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Tylko parzyste
$parzyste = array_filter($liczby, function($x) {
    return $x % 2 == 0;
});
print_r($parzyste);
// [1 => 2, 3 => 4, 5 => 6, 7 => 8, 9 => 10]

// Arrow function
$parzyste = array_filter($liczby, fn($x) => $x % 2 == 0);

// Filtruj z kluczami
$osoby = ['Jan' => 25, 'Anna' => 17, 'Piotr' => 30];
$pelnoletni = array_filter($osoby, fn($wiek) => $wiek >= 18);
print_r($pelnoletni);
// ['Jan' => 25, 'Piotr' => 30]

// ARRAY_FILTER_USE_KEY - filtruj po kluczach
$filtered = array_filter($osoby, fn($klucz) => strlen($klucz) > 3, ARRAY_FILTER_USE_KEY);

array_reduce() – redukuje do pojedynczej wartości

$liczby = [1, 2, 3, 4, 5];

// Suma
$suma = array_reduce($liczby, function($carry, $item) {
    return $carry + $item;
}, 0);
echo $suma;  // 15

// Arrow function
$suma = array_reduce($liczby, fn($carry, $item) => $carry + $item, 0);

// Iloczyn
$iloczyn = array_reduce($liczby, fn($c, $i) => $c * $i, 1);
echo $iloczyn;  // 120

// Konkatenacja
$slowa = ['Hello', 'World', 'PHP'];
$zdanie = array_reduce($slowa, fn($c, $i) => $c . ' ' . $i, '');
echo trim($zdanie);  // Hello World PHP

array_walk() – modyfikacja w miejscu

$liczby = [1, 2, 3, 4, 5];

// Podwój każdy element
array_walk($liczby, function(&$wartosc, $klucz) {
    $wartosc *= 2;
});
print_r($liczby);
// [2, 4, 6, 8, 10]

// Z dodatkowym parametrem
array_walk($liczby, function(&$v, $k, $mnoznik) {
    $v *= $mnoznik;
}, 3);

array_column() – wyciąga kolumnę z wielowymiarowej

$osoby = [
    ['id' => 1, 'imie' => 'Jan', 'wiek' => 30],
    ['id' => 2, 'imie' => 'Anna', 'wiek' => 25],
    ['id' => 3, 'imie' => 'Piotr', 'wiek' => 35]
];

// Wyciągnij wszystkie imiona
$imiona = array_column($osoby, 'imie');
print_r($imiona);
// ['Jan', 'Anna', 'Piotr']

// Z kluczem
$iminaPoId = array_column($osoby, 'imie', 'id');
print_r($iminaPoId);
// [1 => 'Jan', 2 => 'Anna', 3 => 'Piotr']

Spread operator (PHP 7.4+)

$tab1 = [1, 2, 3];
$tab2 = [4, 5, 6];

// Łączenie
$polaczona = [...$tab1, ...$tab2];
print_r($polaczona);
// [1, 2, 3, 4, 5, 6]

// W argumentach funkcji
function suma(...$liczby) {
    return array_sum($liczby);
}

echo suma(1, 2, 3, 4, 5);  // 15
echo suma(...[10, 20, 30]);  // 60

// W array_merge
$wynik = [...$tab1, 'x', 'y', ...$tab2];
// [1, 2, 3, 'x', 'y', 4, 5, 6]

Null coalescing dla tablic (PHP 7.0+)

$config = ['db' => 'mysql', 'port' => 3306];

// Stary sposób
$host = isset($config['host']) ? $config['host'] : 'localhost';

// Null coalescing
$host = $config['host'] ?? 'localhost';

// Łańcuchowe (PHP 7.4+)
$wartość = $config['a'] ?? $config['b'] ?? $config['c'] ?? 'domyślna';

 Tablice superglobalne

Tablice superglobalne w PHP to automatycznie dostępne, globalne tablice zawierające dane zebrane od serwera, użytkownika lub z sesji, co oznacza, że można ich używać w dowolnym miejscu skryptu bez potrzeby ich deklarowania. 

$_GET

Przechowuje dane przekazane do skryptu za pomocą metody GET (np. parametry w adresie URL).

// URL: http://example.com/page.php?name=Jan&age=30

echo $_GET['name'];  // Jan
echo $_GET['age'];   // 30

// Bezpieczne pobieranie
$name = $_GET['name'] ?? 'Gość';
$age = filter_input(INPUT_GET, 'age', FILTER_VALIDATE_INT) ?? 0;

$_POST

Zawiera dane wprowadzone przez użytkownika w formularzach przesłanych metodą POST.

// Formularz wysłany metodą POST

$username = $_POST['username'] ?? '';
$password = $_POST['password'] ?? '';

// ⚠️ Walidacja!
$username = htmlspecialchars($username, ENT_QUOTES, 'UTF-8');

$_SERVER

Dostarcza informacji o serwerze i środowisku, w tym dane o połączeniu, adresie IP czy nagłówkach HTTP.

// Najczęściej używane:
echo $_SERVER['HTTP_HOST'];        // example.com
echo $_SERVER['REQUEST_URI'];      // /page.php?id=1
echo $_SERVER['REQUEST_METHOD'];   // GET, POST, etc.
echo $_SERVER['REMOTE_ADDR'];      // IP klienta
echo $_SERVER['HTTP_USER_AGENT'];  // przeglądarka
echo $_SERVER['SCRIPT_NAME'];      // /path/script.php
echo $_SERVER['DOCUMENT_ROOT'];    // ścieżka root serwera

// Pełna lista
echo '<pre>';
print_r($_SERVER);
echo '</pre>';

$_FILES

Używana do przetwarzania plików przesłanych do skryptu metodą POST.

// Formularz z <input type="file" name="plik">

if (isset($_FILES['plik'])) {
    $file = $_FILES['plik'];
    
    echo $file['name'];      // nazwa pliku
    echo $file['type'];      // typ MIME
    echo $file['size'];      // rozmiar w bajtach
    echo $file['tmp_name'];  // tymczasowa lokalizacja
    echo $file['error'];     // kod błędu (0 = OK)
    
    // Przeniesienie pliku
    if ($file['error'] === 0) {
        move_uploaded_file($file['tmp_name'], 'uploads/' . $file['name']);
    }
}

$_COOKIE

Zawiera ciasteczka (cookies) wysłane przez serwer WWW, które są dostępne w przeglądarce użytkownika.

// Ustawianie cookie
setcookie('username', 'Jan', time() + 3600);  // 1 godzina

// Odczytywanie
$username = $_COOKIE['username'] ?? 'Gość';

$_SESSION

Przechowuje dane użytkownika między różnymi stronami lub żądaniami (dane sesji).

// Rozpocznij sesję
session_start();

// Zapisz dane
$_SESSION['user_id'] = 123;
$_SESSION['username'] = 'Jan';

// Odczytaj dane
$userId = $_SESSION['user_id'] ?? null;

// Usuń zmienną
unset($_SESSION['username']);

// Zniszcz całą sesję
session_destroy();

$_ENV

Zawiera zmienne środowiskowe dostępne dla skryptu PHP.

$_REQUEST  – $_GET + $_POST + $_COOKIE

Jest to tablica, która zawiera dane zebrane jednocześnie z $_GET, $_POST i $_COOKIE

// Nie zalecane - lepiej używać konkretnych tablic
$id = $_REQUEST['id'] ?? 0;

// Lepiej:
$id = $_GET['id'] ?? $_POST['id'] ?? 0;

$GLOBALS

(ta jedna nie ma podłogi w nazwie) Tablica zawierająca odniesienia do wszystkich zmiennych o zasięgu globalnym w danym skrypcie.

$x = 10;
$y = 20;

function suma() {
    return $GLOBALS['x'] + $GLOBALS['y'];
}

echo suma();  // 30

// Nie zalecane - lepiej przekazywać jako argumenty

Jeżeli chcemy zobaczyć co dana tablica zawiera, wystarczy że wykonamy poniższy kod

echo "<pre>";
print_r($_SERVER); //tutaj wpisujemy nazwę tablicy
echo "</pre>";

Zadania:

1. Utworzyć dowolną tablicę asocjacyjną, posortować ją rosnąco i malejąco według wartości i wyświetlić elementy kolejno na ekranie.

2. Napisz skrypt obliczający sumę elementów w tablicy.

3. Utworzyć tablicę zawierającą kąty i kolejne wartości funkcji sin(x) w zakresie od 0 do 900 z krokiem 50 wyświetlić jej zawartość na ekranie: w 2 kolumnach (kąt –  wartość).

4. Wypełnij tablicę 1000 losowych liczb z zakresu od 1 do 10000. Wyznacz:

a) ile jest w tablicy liczb parzystych
b) ile jest w tablicy liczb nieparzystych
c) najmniejszą i największą liczbę w tablicy
d) średnią arytmetyczną wszystkich liczb z tablicy

5. (dla klas, które miały HTMLa) Napisz skrypt, który za pomocą formularza przekaże dane osobowe do tablicy (imię, nazwisko, klasa, grupa) i wyświetli je na ekranie.

5. (dla klas, które nie miały HTMLa) Napisz skrypt, który rozdzieli po spacji podany ciąg (imię, nazwisko, klasa, grupa) dodając wydzielone elementy do tablicy i wyświetli ją na ekranie.

6. Napisz skrypt, który stworzy tablicę wielowymiarową zawierająca następujące dane: nazwy kontynentów (min 3) -> państwa mieszczące się na danym kontynencie (min 3) -> miasta w danym państwie (min 3). Posortuj tablicę rosnąco wg klucza: kontynent, państwo, miasto.

7. Utwórz tablicę czteroelementową zawierającą następujące wartości: “Fioletowy”, “Niebieski”, “Różowy”, “Zielony”. Następnie użyj jej do wyświetlenia listy:

• Fioletowy
• Niebieskie
• Różowy
• Zielony

8. Zsumuj wszystkie elementy z tablicy: $wartosci = [1, 15, 12, 51, 08, -11]. Wykorzystaj pętle for

9. Oblicz temperaturę średnią. Posłuż się tablicą $wartosci przechowującą odczytane temperatury:

$wartosci = [20, 17, 22, 20, 16, 31, 22, 15, 13, -12, 16, 7, 1, 0, -7, -10];

10. Wyświetl wszystkie elementy tablicy: $auta = [„VW”, „Audi”, „BMW”, „Mercedes”]. Użyj pętli foreach.

11. Napisz skrypt odnajdujący największy element tablicy:
$liczby = [10, 15, 9, 61, 78, 2, 44, 21, 30];

12. Napisz skrypt, który wyświetla nazwę kraju i jego stolicę . Posłuż się tablicą $europa:
$europa = array(„Włochy” => „Rzym”, „Belgia” => „Bruksela”,
„Dania” => „Kopenhaga”, „Finlandia” => „Helsinki”,
„Francja => „Paryż”, „Niemcy” => „Berlin”,
„Rosja” => „Moskwa”, „Polska” => „Warszawa”);
// tu umieść kod wyświetlający informacje wg schematu:
// Kraj: Włochy, stolica: Rzym
// …
// Kraj: Polska, stolica: Warszawa

13. Napisać funkcję o nazwie ListaLiczb (o 3 parametrach: $zakres1, $zakres2, $ilosc) wczytujący do utworzonej wewnątrz funkcji tablicy $tab losowe liczby całkowite z zakresu od $zakres1 do
$zakres2 w ilości $ilosc.
Należy przy tym najpierw sprawdzić, czy $zakres1 jest mniejsze lub równe $zakres2 – jeśli nie, to należy zamienić między sobą obie liczby.
Dodatkowo, jeśli $ilosc nie jest większa od zera, to wyświetlić komunikat o błędzie („Ilość elementów w tablicy musi być większa od 0.”) i przerwać działanie funkcji.
Ostatecznie funkcja wyświetla liczby z tablicy w postaci listy nienumerowanej.

Ściągawka funkcji tablicowych

Dobre praktyki

1. Preferuj [] nad array()

// ŹLE - stara składnia
$tab = array(1, 2, 3);

// DOBRZE - nowoczesna składnia
$tab = [1, 2, 3];

2. Używaj array_map/filter zamiast pętli

// ŹLE - niepotrzebna pętla
$podwojone = [];
foreach ($liczby as $liczba) {
    $podwojone[] = $liczba * 2;
}

// DOBRZE - array_map
$podwojone = array_map(fn($x) => $x * 2, $liczby);

3. Unset referencji po foreach

foreach ($tablica as &$wartosc) {
    $wartosc *= 2;
}
unset($wartosc);  // ZAWSZE!

4. Waliduj dane z superglobalnych

// ŹLE
$id = $_GET['id'];

// DOBRZE
$id = filter_input(INPUT_GET, 'id', FILTER_VALIDATE_INT) ?? 0;

5. Używaj spread operator dla łączenia

// ŹLE - wolniejsze
$polaczona = array_merge($tab1, $tab2, $tab3);

// DOBRZE - szybsze (PHP 7.4+)
$polaczona = [...$tab1, ...$tab2, ...$tab3];