Od php 4.3 až php 8

PHP 4.0-4.3 - k OOP

Tento kód by bylo možné rozjet na PHP verze 4.3 a novější. Zavedení interface a implementace tříd v tomto kódu nepředstavuje problém pro PHP verze 4.3, protože podpora pro tyto koncepty existovala již od PHP 4.0. Rozhraní (interfaces) a implementace interface byly zahrnuty ve specifikaci PHP 4.0, což umožňuje vytvářet rozhraní a implementovat je v třídách.

// PHP 5.0 -> interface Shape {
//     public function getArea();
//
class Shape {
    // Prázdný konstruktor - nelze použít abstract konstruktor
    function Shape() {
    }
}
 

// PHP 5.0 -> class Circle implements Shape {

class Circle extends Shape {
    private $radius;

    function Circle($radius) {
        $this->radius = $radius;
    }

    function getArea() {
        return 3.14 * $this->radius * $this->radius;
    }
}


// PHP 5.0 -> class Square implements Shape {
class Square extends Shape {
    private $side;     // PHP 5.0 nevyžaduje definici Square; v PHP 5.0 je třeba __construct a getarea     function Square($side) {
        $this->side = $side;
    }

    function getArea() {
        return $this->side * $this->side;
    }
}

$shapes = array(new Circle(5), new Square(4));
foreach ($shapes as $shape) {
    echo "Plocha: " . $shape->getArea() . " jednotek čtverečních<br>";
} 

V tomto kódu se místo interface používá třída Shape pro společný základ obou tříd Circle a Square.
 Toto je starší způsob, jak vytvářet podobné struktury. Funkcionalita by
 měla být podobná, ale syntaxe se liší od modernějšího přístupu s 
rozhraním. 

PHP 4.0

Zavedení funkce array_map pro aplikování funkce na elementy pole. Funkce array_map v PHP slouží k aplikaci zadané funkce na každý prvek pole a vytvoření nového pole s výsledky těchto funkcí. Můžete tímto způsobem provést transformaci, úpravy nebo aplikovat jiné operace na každý prvek pole..

Syntaxe

array_map(callback $callback, array $array1, array ...$arrays): array

• $callback je funkce, která bude aplikována na každý prvek pole.
• $array1 je pole, které chcete zpracovat.
• $arrays jsou další pole, pokud chcete provádět operace na více typech polí současně.

Funkce array_map projde každý prvek pole (nebo příslušných prvků v případě více polí) a použije na něj zadanou funkci $callback. Výsledky těchto volání jsou shromážděny do nového pole, které je následně vráceno jako výstup.

Příklad:

function square($n) { return $n * $n; } $numbers = [1, 2, 3, 4, 5]; $squaredNumbers = array_map("square", $numbers); print_r($squaredNumbers);

Výstup:

Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

V tomto příkladu jsme definovali funkci square, která vynásobí číslo samo se sebou. Poté jsme použili array_map pro aplikaci této funkce na každý prvek pole $numbers, čímž jsme získali pole s druhými mocninami těchto čísel.

 

Tady jsou některá vylepšení a novinky, které byly přidány v rámci verzí PHP od 4.4 do 4.8:

PHP 4.4

• Přidání funkcí pro podporu práce s 64bitovými čísly (intval(), floatval() atd.).
• Vylepšení detekce kódování souborů pomocí funkce mb_detect_encoding().
• Přidání globálního pole $_ENV pro přístup k prostředí.
• Přidání možnosti vypínat a zapínat globální proměnné pomocí php.ini.
• Přidání podpory pro nové vestavěné funkce jako memory_get_usage() a get_declared_classes().

PHP 4.5

• Přidání podpory pro magic_quotes_gpc vytvořením funkce get_magic_quotes_gpc().
• Přidání funkce date_sunrise() a date_sunset() pro výpočet času východu a západu slunce.
• Vylepšení výkonu pro víceúčelové řádkové komentáře.

PHP 4.6

• Přidání funkce imagecreatefrompng() pro práci s PNG obrázky.
• Přidání funkce array_diff_key() pro porovnávání polí na základě klíčů.
• Zavedení direktivy zend.ze1_compatibility_mode pro lepší kompatibilitu se starším kódem.

PHP 4.7

• Přidání možnosti nastavení typu obsahu (MIME type) při odesílání emailu funkcí mail().
• Přidání funkce http_build_str() pro tvorbu HTTP dotazu jako řetězce.
• Zavedení podpory pro 64bitové systémy s funkcemi pro práci s velkými čísly.

PHP 4.8

• Přidání rozšíření mysqli pro lepší podporu MySQL databází.
• Přidání funkcí pro práci s datovými strukturami JSON pomocí rozšíření json.
• Vylepšení podpory pro 64bitové systémy pro zvýšení výkonu a stabilitu.
• Přidání rozšíření session pro ukládání stavu mezi HTTP požadavky.

memory_get_usage: Tato funkce slouží k získání aktuálního využití paměti skriptem. Nemusí být povolena nebo zakázána na serveru, protože toto nastavení ovlivňuje pouze dostupnost informace o paměťovém využití skriptu, nikoliv jeho funkčnost.

Magic Quotes: Magic Quotes byla funkce v PHP, která automaticky zpětně lomila speciální znaky v uživatelském vstupu, což mohlo mít za následek nežádoucí efekty v databázi nebo při zobrazení dat. get_magic_quotes_gpc() byla funkce, která indikovala, zda jsou tyto magic quotes aktivní v superglobálních proměnných jako $_GET, $_POST, $_REQUEST, $_COOKIE a $_SERVER. Pokud byly aktivní, funkce mohla být použita k odstranění zpětných lomítek.

date_sunrise() a date_sunset(): Tyto funkce slouží k výpočtu času východu a západu slunce pro daný den na základě zadaných souřadnic. Můžeš specifikovat koordináty (zeměpisnou šířku a délku), datum a časovou zónu, a funkce ti vrátí čas východu nebo západu slunce. Výsledek je závislý na zeměpisné šířce, délce a datu, nikoliv na nastavení locale.

array_diff_key: Ano, funkce array_diff_key() slouží k porovnání klíčů v polích a nalezení rozdílů mezi nimi. Například, když máš dvě pole a chceš najít rozdíly ve klíčích mezi nimi, můžeš použít tuto funkci. Výsledek bude obsahovat klíče, které jsou pouze v jednom z polí.

Příklad k PHP 4.7 a http_build_str():

php

$queryData = array(
    'name' => 'John',
    'age' => 30,
    'city' => 'New York'
);

$queryString = http_build_str($queryData);
// Vytvoří řetězec 'name=John&age=30&city=New%20York'

Příklad nových funkcí pro práci s velkými čísly:

php

$bigNumber1 = gmp_init('1234567890123456789012345678901234567890');
$bigNumber2 = gmp_init('9876543210987654321098765432109876543210');
$sum = gmp_add($bigNumber1, $bigNumber2);
// $sum bude obsahovat součet velkých čísel

Rozšíření session: Toto rozšíření zahrnuje funkce pro efektivnější a bezpečnější práci se sessions. Můžeš ukládat proměnné mezi jednotlivými HTTP požadavky uživatele bez nutnosti používat cookies. Tím lze například uchovávat informace o uživateli, jako je jeho stav přihlášení, obsah nákupního košíku apod., aniž by bylo nutné záviset na cookies.

Mělo by to být http_build_query() místo http_build_str(). Tady je korektní příklad a vysvětlení:

$queryData = array(
    'name' => 'John',
    'age' => 30,
    'city' => 'New York'
);

$queryString = http_build_query($queryData);
// Vytvoří řetězec 'name=John&age=30&city=New%20York'

http_build_query() slouží k převedení asociativního pole (např. data z formuláře) na URL kódovaný řetězec, který se často používá jako součást URL parametrů v HTTP požadavcích. Tento proces je užitečný zejména při tvorbě odkazů s parametry nebo při odesílání dat metodou GET.

V tomto příkladu by měl výstup $queryString vypadat následovně:

name=John&age=30&city=New%20York

Tento řetězec by mohl být použit například v odkazu nebo v HTTP požadavku, aby byla zachována struktura a hodnoty z původního pole ve formátu vhodném pro použití v URL.

PHP 4.9 nebyla vydána, alespoň podle oficiálního seznamu verzí PHP. Vylepšení a novinky se tedy konkrétně vážou k verzím PHP 5.0 a vyšším.

PHP 5.0 (červen 2004):

• Zavedení objektově orientovaného programování (OOP) s kompletním přepracováním tříd, dědičnosti, polymorfismu a dalších prvků OOP.

PHP 5.1 (listopad 2005):

• Zavedení podpory pro PHP Data Objects (PDO) pro práci s databázemi.
• Zavedení interfejsů a abstraktních tříd.

zde jsou příklady vytvoření abstraktní třídy, její implementace a využití:

1. Vytvoření abstraktní třídy:

abstract class Shape {
    abstract public function getArea();
}

class Circle extends Shape {
    private $radius;

    public function __construct($radius) {
        $this->radius = $radius;
    }

    public function getArea() {
        return 3.14 * $this->radius * $this->radius;
    }
}

class Square extends Shape {
    private $side;

    public function __construct($side) {
        $this->side = $side;
    }

    public function getArea() {
        return $this->side * $this->side;
    }
}

2. Využití abstraktní třídy:

$circle = new Circle(5);
$square = new Square(4);

echo "Plocha kruhu: " . $circle->getArea() . " jednotek čtverečních<br>";
echo "Plocha čtverce: " . $square->getArea() . " jednotek čtverečních";

V tomto příkladu je abstraktní třída Shape, která definuje abstraktní metodu getArea(). Tato metoda je implementována v odvozených třídách Circle a Square, které jsou od abstraktní třídy odvozeny. Tímto způsobem můžete vytvářet hierarchie tříd, které sdílejí společné vlastnosti a chování definované v abstraktní třídě.

PHP 5.2 (listopad 2006)

• Přidání rozšíření filter pro filtrace a validaci vstupních dat.
• Zavedení funkce json_encode() pro práci s JSON formátem.

1. Rozšíření filter pro filtrace a validaci vstupních dat:

$input = "user@example.com";
$filteredInput = filter_var($input, FILTER_VALIDATE_EMAIL);

if ($filteredInput !== false) {
    echo "Email je platný.";
} else {
    echo "Neplatný email.";
}

2. Funkce json_encode() pro práci s JSON formátem:

$data = array(
    "name" => "John",
    "age" => 30,
    "city" => "New York"
);

$jsonData = json_encode($data);

echo $jsonData;

Tato vylepšení zavedla lepší zabezpečení a kontrolu vstupních dat díky funkcím pro filtraci a validaci. Dále přidala podporu pro práci s formátem JSON, což je častý formát pro výměnu dat mezi aplikacemi.

PHP 5.3 (červen 2009)

• Zavedení víceřádkových způsobů zápisu (string literals) Heredoc a Nowdoc.  Díky ním lze vkládat rozsáhlé textové bloky do kódu bez potřeby escapovat zvláštní znaky, a zároveň zachovat formátování řetězců.

• Zavedení anonymních funkcí (closure) a podpora lambdových funkcí.
• Zavedeno klíčové slovo use pro anonymní funkce.
  
• Přidání funkcí pro manipulaci s jmennými prostory (namespaces).
• Vylepšení výjimečného zacházení (exception handling) s podporou namespace.

1. Heredoc:

   php

   $name = "John";
   $message = <<<EOT
   Hello $name,
   Welcome to our website!
   EOT;
   
   echo $message;
   

   Nowdoc:

   php

   $name = "John";
   $message = <<<'EOT'
   Hello $name,
   Welcome to our website!
   EOT;
   
   echo $message;
    
   funkce htmlspecialchars() stále zůstává důležitou součástí PHP, i když máte k dispozici heredoc a nowdoc pro víceřádkové řetězce. Heredoc a nowdoc jsou užitečné pro vytváření víceřádkových řetězců bez nutnosti escapovat znaky, ale htmlspecialchars() je stále potřebné pro zabezpečení vstupních dat, která mohou obsahovat speciální znaky, aby nedocházelo k nechtěným interpretacím HTML kódu v těchto datech.
   Funkce htmlspecialchars() se používá na nahrazení speciálních znaků, jako jsou <, >, &, atd., do jejich ekvivalentních HTML entit, což zajišťuje, že text bude zobrazen přesně tak, jak by měl, bez ohledu na to, co obsahuje.
   Takže i když můžete použít heredoc nebo nowdoc pro vytváření víceřádkových řetězců, stále je vhodné používat htmlspecialchars() při práci s daty, která mají být zobrazena v HTML, aby se zabránilo riziku cross-site scripting (XSS) útoků nebo nechtěnému chování v aplikaci.
    

    
2. Anonymní funkce a lambda funkce (closures):

$add = function($a, $b) {
    return $a + $b;
};

$result = $add(3, 5); // $result bude 8

Klíčové slovo use je součástí syntaxe anonymních funkcí - uzávěr. Slouží k tomu, aby bylo možné uzávěrám předat proměnné z okolního kontextu, které by jinak byly mimo dosah uzávěry. Pomocí klíčového slova use můžete specifikovat, které proměnné chcete "zachytit" a předat uzávěře pro její použití. Tím umožňuje klíčové slovo use explicitně říct, které proměnné by měly být dostupné v anonymní funkci.

Například:

$factor = 2;

$multiplier = function($number) use ($factor) {
    return $number * $factor;
};

echo $multiplier(5); // Vypíše: 10

Ve výše uvedeném příkladu je proměnná $factor zachycena pomocí klíčového slova use a je dostupná v rámci anonymní funkce $multiplier, i když by jinak byla mimo dosah funkce.

2. Jmenné prostory (namespaces):

namespace MyProject;

class MyClass {
    // třída v rámci jmenného prostoru MyProject
}

$obj = new MyClass(); // vytvoření instance třídy pomocí jmenného prostoru

3. Vylepšení výjimečného zacházení (exception handling) s podporou namespace:

namespace MyProject;

class MyException extends \Exception {}

try {
    // nějaký kód, který může způsobit výjimku
    throw new MyException("Toto je výjimka z mého projektu");
} catch (MyException $e) {
    echo "Chyba: " . $e->getMessage();
} catch (\Exception $e) {
    echo "Obecná chyba: " . $e->getMessage();
}

Tato vylepšení umožňují lepší organizaci kódu, izolaci funkcionalit a lepší zacházení s chybami a výjimkami v rozsáhlejších projektech.

PHP 5.4 (březen 2012)

• Zavedení krátké syntaxe pro pole ("short array syntax") s použitím závorek [], což zjednodušuje zápis polí.

PHP 5.5 (červenec 2013):

• Generátory: Zavedení generátorů umožnilo vytvářet iterátory pomocí jednoduché syntaxe a snižovalo paměťovou náročnost v případech, kdy bylo potřeba zpracovat velké množství dat.

Generátory umožňují vytvářet iterátory jednoduše a efektivně, což je užitečné, když pracujete s velkým množstvím dat. Generátory umožňují iteraci přes data bez nutnosti uložit všechna data v paměti najednou. Zde je příklad:

Příklad 1:

function simpleGenerator() {
    yield 1;
    yield 2;
    yield 3;
}

foreach (simpleGenerator() as $value) {
    echo $value . "\n";
}

Příklad 2:

function simpleGenerator() { ... }
$generator = simpleGenerator();
echo $generator->current(); // Vypíše: 1 (aktuální položka)
$generator->next(); // Posune pointer na další položku
echo $generator->current(); // Vypíše: 2
$generator->rewind(); // Vrátí pointer na začátek
echo $generator->current(); // Vypíše: 1

 

PHP 5.6 (srpen 2014)

• Variadické funkce: Možnost použít proměnný počet argumentů u funkcí pomocí operátoru "...". 
  

Příklad: 
function sum(...$numbers) {
    $total = 0;
    foreach ($numbers as $number) {
        $total += $number;
    }
    return $total;
}

echo sum(1, 2, 3); // Vypíše: 6
echo sum(10, 20, 30, 40); // Vypíše: 100

Využití operátoru "...", který umožňuje použít "unpacking" pro argumenty funkcí. To znamená, že argumenty zavolání funkce budou automaticky zabaleny do pole a předány do funkce jako pole. V případě funkce sum můžete použít neomezený počet argumentů, ať už jich je kolikkoliv.

Funkce sum přijímá proměnný počet argumentů, které jsou automaticky zabaleny do pole $numbers. Následně je v cyklu projdou a sečtou, což umožňuje vytvořit funkci, která pracuje s různým počtem čísel bez potřeby předdefinovaného počtu argumentů.

PHP 5.7 (červenec 2015)

• Scalar Type Declarations: Byla přidána možnost definovat typy skalárních hodnot (int, float, string, bool) jako parametry funkcí a návratové hodnoty funkcí.
• Return Type Declarations: Možnost definovat návratový typ funkcí.
• Anonymous Classes: Zavedení anonymních tříd, což jsou třídy, které nejsou pojmenovány, a vytvářejí se dynamicky.
• Generator Return Expressions: Možnost použít return ve funkci generátoru pro vrácení hodnoty.

PHP 5.8 (březen 2017)

• Return Type Hinting for Scalar Types: Rozšíření podpory pro návratové typy funkcí o skalární typy.
• Nullable Types: Možnost definovat typy jako nullable (null nebo daný typ).
• Builtin Web Server Improvements: Vylepšení vestavěného webového serveru.
• Closure::call(): Možnost volání uzávěrů s daným kontextem.
• New Operators: Přidání nových operátorů: **= (exponenciální přiřazení), ??= (null coalesce přiřazení).

PHP 7.0 (3. prosince 2015)

PHP 7.0 přinesla několik klíčových změn a novinek, které měly zásadní vliv na jazyk a jeho funkcionality. Zde jsou více detailů k některým z těchto novinek:

1. Zrychlení výkonu a Zend Engine 3.0: PHP 7.0 představilo významné zvýšení výkonu díky novému enginu Zend Engine 3.0. Díky optimalizacím a vylepšené správě paměti se PHP 7.0 stalo výrazně rychlejším než jeho předchůdce. Webové aplikace spuštěné pod PHP 7.0 běžely mnohem rychleji a efektivněji.

2. Null Coalescing Operator (??): Tento nový operátor umožňuje snadněji pracovat s hodnotami null. Pokud první hodnota výrazu není null, vrátí se tato hodnota, jinak se vrátí druhá hodnota. To usnadnilo kontrolu a manipulaci s hodnotami, které mohou být null.

3. Skalární typy v argumentech funkcí: PHP 7.0 přineslo možnost specifikovat očekávaný typ argumentu u funkcí. To znamená, že při volání funkce lze definovat, jaký typ dat se očekává. Tímto způsobem bylo možné lépe kontrolovat vstupy a snížit riziko chyb.

4. Návratové typy funkcí: Stejně jako u argumentů, bylo nyní možné definovat typ dat, který funkce vrátí. To znamená, že kód byl lépe dokumentovaný a mohly být aplikovány další vrstvy kontroly.

5. Skládání názvů jmenných prostorů: PHP 7.0 umožnilo skládat názvy jmenných prostorů pomocí operátoru "". To znamená, že bylo snazší pracovat s hlubšími strukturami jmenných prostorů a organizovat kód lépe.

6. Unicode (UTF-8) podpora: PHP 7.0 zavedlo plnou podporu pro Unicode a UTF-8 kódování. To bylo důležité pro mezinárodní aplikace, které pracují s různými jazyky a znakovými sadami.

7. Další vylepšení: Kromě těchto hlavních novinek přinesla verze PHP 7.0 i další vylepšení, jako například optimalizace a opravy chyb, což vedlo k celkově stabilnějšímu a výkonnějšímu prostředí pro vývoj webových aplikací.

PHP 7.1 (Prosinec 2016)

1. Nullable types: Možnost definovat parametry funkcí nebo návratové hodnoty jako nullable (null nebo daný typ).

2. Void return type: Byla přidána možnost definovat návratový typ funkce jako void, což označuje, že funkce nevrací žádnou hodnotu.

3. Short array syntax for list(): Zavedení zkrácené syntaxe pro destrukci pole s pomocí list().

4. Symmetric array destructuring: Možnost destrukturovat pole do jednotlivých proměnných pomocí nového operátoru [...].

5. Keys of arrays: Funkce array_keys() nyní umožňuje pracovat s klíči asociativních polí.

6. Catching multiple exceptions types: Možnost zachytávat více typů výjimek v jednom bloku catch.

7. Support for negative string offsets: Podpora negativních offsetů pro řetězce.

8. Context sensitive lexer: Zrychlení analýzy zdrojového kódu díky kontextově citlivému lexeru.

9. Iterable pseudo-type: Zavedení pseudo-typu iterable pro parametry funkcí nebo návratové hodnoty.

PHP 7.2 (Listopad 2017):

1. Argument type declarations: Možnost definovat typy argumentů funkcí při deklaraci funkce.

2. Object type declarations: Zavedení nového typu object pro parametry funkcí a návratové hodnoty.

3. Nullable types in parameter: Možnost definovat nullable typy pro parametry funkcí.

4. Trailing commas in list syntax: Zavedení podpory pro závěrečnou čárku v seznamu, pole nebo argumentu volání funkce.

5. Private class constants: Možnost definovat privátní konstanty v třídách.

6. Improved type inference for foreach(): Zlepšení inferenčního chování při iteraci pomocí foreach().

7. RFC: Parameter Type Widening: Možnost šířit typ parametru při dědičnosti tříd.

8. RFC: Deprecate and Remove: __autoload(): Odepsání funkce __autoload().

9. RFC: Deprecations for PHP 7.2: Deprecace několika funkcí a vlastností v PHP 7.2.

10. RFC: Object typehint: Zavedení object typehintu pro rozhraní a třídy.

11. RFC: Convert numeric keys in object/array casts: Zavedení konverze numerických klíčů při přetypování na objekt nebo pole.

PHP 7.3 (výskyt: prosinec 2018)

• Flexible Heredoc and Nowdoc Syntax: Zavedení nové syntaxe pro Heredoc a Nowdoc, která umožňuje flexibilnější manipulaci s odsazením a interpolačními řetězci. (Heredoc a Nowdoc jsou způsoby zápisu víceřádkových řetězcových literálů (stringů) v jazyce PHP. Jsou často používány k definici dlouhých textových bloků, například HTML, SQL dotazů nebo jiných víceřádkových řetězcových hodnot, které mohou obsahovat speciální znaky, interpolace a další struktury.)
  
• Trailing Commas in Function Calls: Možnost použít čárku na konci seznamu argumentů funkce, což usnadňuje správu změn.
• Array Destructuring in Function Calls: Možnost destrukturovat pole přímo při volání funkce. Umožňuje destrukturovat (rozložit) prvky pole přímo během volání funkce. Toto je užitečné, když chcete předat různé hodnoty z pole do funkce a pracovat s nimi jednodušeji.
• is_countable() Function: Přidání funkce is_countable(), která umožňuje ověřit, zda daná hodnota může být použita jako pole při volání count().

Příklad destrukce pole přímo při volání funkce ...

function addNumbers($a, $b) {
    return $a + $b;
}

$numbers = [10, 5];

// Před PHP 7.1:
$result = addNumbers($numbers[0], $numbers[1]);
echo $result; // Vypíše: 15

// Od PHP 7.1 s použitím Array Destructuring:
$result = addNumbers(...$numbers);
echo $result; // Vypíše: 15 

V tomto příkladu se funkce addNumbers volá s dvěma argumenty, které jsou destrukturovány z pole $numbers pomocí operátoru .... Tím se kód zkrátí a zpřehlední.

PHP 7.4 (výskyt: listopad 2019)

• Arrow Functions: Zavedení krátké syntaxe pro anonymní funkce s jedním výrazem a automatickým zachycením kontextu.
• Typed Properties: Možnost definovat typy pro vlastnosti tříd, což zlepšuje kontrolu datových typů.
• Covariant Returns and Contravariant Parameters: Zlepšení podpory pro variace typů při zdědění metod v třídách a rozhraních.
• Null Coalescing Assignment Operator: Zavedení operátoru ??= pro efektivnější přiřazování hodnoty, pokud je hodnota null.
• Preloading: Zavedení možnosti přednačítání kódu pro zrychlení spouštění skriptů.

Arrow Functions (také nazývané "short syntax anonymous functions") jsou novinkou v PHP 7.4, která zavádí zjednodušenou syntaxi pro definici anonymních funkcí s jedním výrazem. Tyto funkce automaticky zachytávají kontext (závěrečný stav) okolního kódu.

Příklad:

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

// Před PHP 7.4:
$squared = array_map(function($number) {
    return $number * $number;
}, $numbers);

// Od PHP 7.4 s použitím Arrow Function:
$squared = array_map(fn($number) => $number * $number, $numbers);

print_r($squared); // Vypíše: Array ( [0] => 1 [1] => 4 [2] => 9 [3] => 16 [4] => 25 )

V tomto příkladu funkce je definována pomocí zjednodušené syntaxe s použitím šipky =>. Tato syntaxe je vhodná pro jednoduché výrazy a zpřehledňuje kód. Arrow Functions automaticky zachytávají proměnné ze svého okolí, což umožňuje jejich použití bez nutnosti explictně používat klíčové slovo use pro zachycení kontextu.