Jak v Nette 3.0 použít BasePresenter?

Díky, to je rozhodně v plánu…
Já jsem trochu ztroskotal už na té metodě createTemplate. Ale už jsem to rozchodil, nově je potřeba ITemplateFactory.

abstract class BasePresenter extends Nette\Application\UI\Control
{
	/** @var Nette\Application\UI\ITemplateFactory */
	private $templateFactory;

	protected function createTemplate(): Nette\Application\UI\ITemplate
	{
		$template = $this->templateFactory->createTemplate();
		return $template;
	}
}

Editoval nettolog (20. 4. 2020 23:58)

No registrace v createTemplate metodě má asi jedinou výhodu: registrace probíhá lazy až když je potřeba template.
V kodu co poslal @Polki se nejspíš template vytváří vždy, ikdyž by nebyl potřeba.

@nettolog Ta hláška co si poslal je jen změna signature metody, kdy se přidal nativní return typehint, ale to už si vyřešil sám a správně.

@CZechBoY Pravda, pokud chceš mít vše lazy, tak přepsat metodu createTemplate je asi nejlepší řešení. Lidi to třeba ještě dělají v beforeRender aby to bylo až těsně před, jelikož když se dojde až na render metodu, tak by teoreticky mělo nastat pouze vykreslení. Pořád je ale nejčistější createTemplate jen jsem chtěl nastínit, že není třeba.

@petrpavel Jasně, že jde. Jenom si představ, co by si uvnitř musel ošetřovat a registrovat za defaultní filtry apod. Lepší by bylo podědit Nette\Bridges\ApplicationLatte\TemplateFactory a v ní přepsat tu metodu createTemplate takže by třída vypadala takto:

namespace App\Model;

use Nette\Bridges\ApplicationLatte\Template;
use Nette\Bridges\ApplicationLatte\TemplateFactory;
use Nette\Application\UI\Control;
use Nette\Application\UI\ITemplate;

class MyTemplateFactory extends TemplateFactory
{
    public function createTemplate(Control $control = null): ITemplate {
        /** @var Template $template */
        $template = parent::createTemplate($control);
        $template->addFilter('filter', [$this, 'filter']);
        // nebo
        $template->addFunction('funct', [$this, 'funct']);
        return $template;
    }

    public function filter($param) {
        return $param . ' paramFiltered';
    }

    public function funct($param) {
        return $param . ' Function done';
    }
}

a v configu by byla zaregistrovaná takto:

services:
	latte.templateFactory: App\Model\MyTemplateFactory

Problém tohoto řešení je, že nechceš vždy všude registrovat všechny tyto filtry. Pro komponenty budeš mít třeba více filtrů, než pro presentery, protože když máš aplikaci dobře navrženou, tak se o vykreslování částí stránky starají převážně komponenty a presentery jsou jen takový prostředník, který ví, kterou komponentu kdy vykreslit. V takovém případě nechceš zbytečně registrovat filtry a funkce do presenterů, když to není třeba a ani je nevyužiješ. Takže toto řešení by se mělo používat jen v případech, kdy si si jistý, že danou funkci/filter na 100% využiješ všude.

EDIT Stále chápu, že je otrava registrovat každou funkri/filtr zvlášť v jednotlivých presenterech. Například v modulech, kde nechceš nějaký base presenter společný pro všechny moduly, ale funkcí máš mraky. Na to vznikl Univerzální filter Tedy nadefinuješ ty filtry v jedné třídě a pak tam, kde tuto skupinu filtrů potřebuješ zaregistruješ v metodě createTemplate pouze tuto skupinu filtrů.

Editoval Polki (21. 4. 2020 11:23)

Ja treba pouzivam nejaky zakladni/obecny (napr. formatovani casu) filtry tak, ze je registruju v konfiguraci. Potom pridavam specificky filtry v presenterrch/komponentach v metode createTemplate.

@Polki muzes prosim dat odkaz na nejake info, kde bych videl, ze jsou anonymni funkce o cca 40% pomalejsi na vykon? To by me opravdu zajimalo.

Jinak rict takhle obecne, ze jsou anonymni funkce zlo je podle me mimo, vzdycky zalezi na pouziti. Nekde sice snizuji citelnost, ale nekde ji zase zvysuji. Napriklad kdyz pouzivam array_map, array_filter, atd.

Znovupouzitelne take jsou, kdyz si ji ulozis do promenne.

Editoval F.Vesely (21. 4. 2020 14:15)

@FVesely Nemám moc čas hledat nějaké dopodrobna rozebrané články jak to funguje a proč to pomalejší je zkus pogooglit sám.
Toto je jeden z prvních odkazů jak relevantní je nevím nečetl jsem (2 odstavec).

Pokud se ti nechce hledat, nebo nevěříš zkus si spustit:

<?php

function profileTime(string $name, callable $callback): void
{
    $start = microtime(TRUE);

    for($i = 0; $i < 100000; $i++){
        $callback($i);
    }

    $end = microtime(TRUE);
    echo 'The code with ' . $name . ' function took ' . ($end - $start) . ' seconds to complete. <br />';
}

function mul2(int $x): int
{
    return $x * 2;
}

profileTime('anonymous', function (int $x): int
{
    return $x * 2;
});

profileTime('regular', 'mul2');

na tom to jde pěkně vidět.

Pokud jde o znovupoužitelnost tak proměnná ano, ale zase nastává problém předání funkce mezi funkcemi, mezi třídami a tak vůbec prostě můžeš, když ji uložíš do proměnné, zavolat vícekrát, ale pořád ji musíš uchovávat v proměnné, kterou si musíš předávat a IDE ti nenapoví například nad návratovým typem té anonymní funkce, takže nemůžeš(můžeš ale nenapoví ti) dělat například zřetězení, jak je tomu například u formulářových prvků…

Pokud jde o přehlednost, tak za mě jednoznačně 0. Třeba u těch polí. Když zavolám:

$result = array_map([$helper, 'trim'], $array);

Tak mi to přijde rozhodně přehlednější(hned vím, že se nad každým prvkem zavolá trim), než když napíšu třeba toto (kód pro trim převzat z oficiální Nette Strings.php knihovny):

array_map(function ($subject) {
    $charlist = preg_quote(" \t\n\r\0\x0B\u{A0}", '#');
    $replacement = '';
    $pattern = '#^[' . $charlist . ']+|[' . $charlist . ']+$#Du';
    $func = 'preg_replace';
    $args = [$pattern, $replacement, $subject, -1];
    $messages = [
        0 => 'Internal error',
        1 => 'Backtrack limit was exhausted',
        2 => 'Recursion limit was exhausted',
        3 => 'Malformed UTF-8 data',
        4 => 'Offset didn\'t correspond to the begin of a valid UTF-8 code point',
        6 => 'Failed due to limited JIT stack space', // PREG_JIT_STACKLIMIT_ERROR
    ];

    $res = Callback::invokeSafe($func, $args, function (string $message) use ($args): void {
        // compile-time error, not detectable by preg_last_error
        throw new Exception($message . ' in pattern: ' . implode(' or ', (array) $args[0]));
    });

    if (($code = preg_last_error()) // run-time error, but preg_last_error & return code are liars
        && ($res === null || !in_array($func, ['preg_filter', 'preg_replace_callback', 'preg_replace'], true))
    ) {
        throw new Exception(($messages[$code] ?? 'Unknown error')
                . ' (pattern: ' . implode(' or ', (array) $args[0]) . ')', $code);
    }
    return $res;
}, $array);

Prostě přehlednost na jednoduchý trim je tatam a pokud si nenapíšu komentář, co že ta anonymní funkce dělá, tak za půl roku budu úplně v pasti. Musel bych do detailu studovat, co ta funkce vlastně dělá.

A to se nezmiňuji o tom, že na polích u toho array_map se právě projeví ta vlastnost pomalosti to je ta nejrizikovější oblast.

Nicméně takové vědomosti jsou zlato, za které lidi dost platí. :) Během příštího měsíce budu o takových věcech (správný návrh kódu + optimalizace) dělat kurzy. Nechci sem však tahat reklamu, tak nenapíšu odkaz Sorry budeš muset hledat. :)

@FVesely Momentálně mám svůj laptop v servisu a jako náhradní jsem dostal nějakou šunku, která má výkon jako lenochod, takže mi takové malé opakování stačilo.

Tvůj kód výše jsem pustil na svém stroji 10×, udělal průměr a hodnoty, které mi vyšly jsou zde:

PHP 7.3.12
anonymous: 1.9683794021606
  regular: 1.1340770721436
class pub: 1.2802527189255
class sta: 1.279154920578

Na takové měření moc nelze používat online emulátory. Kdo ví, jak jsou uvnitř dělané a výsledek pak je zkreslený. Zkoušel jsem to spustit i na produkčním serveru a tam jsou hodnoty podobné, akorát o řád nižší. Nepřu se, že s určitými optimalizacemi na straně PHP by mohly výsledky dopadnout jinak, to určitě mohly.

Psal jsem taky, cituji: Obecně se anonymní funkce hodí maximálně tak na inline funkce (s jedním příkazem), které ještě ideálně hodnotu nijak extrémně nemění. A i tady bych si to asi rozmyslel.
Tedy tvůj lambda výraz je ještě v pohodě. V praxi jsem se ovšem s takovým použitím setkal poskromnu a lidi tam cpou 150 řádkové metody… A pokud jde o příklad, jak jsi psal, tak při takovém použití se zase setkávám často s tím, že v kódu je něco jako: $post_ids = array_map(fn($post) => $post->id, $posts);, jinde $ord_ids = array_map(fn($orders) => $order->id, $orders); dále $book_ids = array_map(fn($book) => $book->id, $books); atd.. To je ještě v poho, i když očividně nějaký DRY princip těmto lidem nic neříká. No problém nastane ve chvíli, kdy se zjistí, že nově nechtějí mít jako identifikátor sloupeček id, ale UUID ale zároveň id sloupec chtějí v databázi nechat (například kvůli ušetření paměti ve vazbách atd..)
V tu chvíli přichází na řadu dlouhý refaktoring a lidi se bijí do hlavy, proč jsem to neudělal hned na začátku jinak. Mluvím z 14 let dlouhé praxe nevymýšlím si. Takových případů je mraky. Prostě se nám osvědčilo anonymní funkce vůbec nepoužívat a vyřešilo se tím spousta věcí.

To jsou taky důvody, proč jsme schopní srazit čas výkonu skriptu na výpis jednoduché statistiky nad 13000 uživateli z 10s na 23ms.

Krásný příklad na přehlednost je například tento:

$music()->
   filter(function ($value, $key) {
     return (strtolower($key) == 'music type' && strtolower($value) == 'jazz')
   })->
   pluck('title')->
   sortBy('title')->
   each(function($song) {
     return ucfirst(strtolower($song['title']));
   });

předělaný na

$music()->
   filter(jazzonly())->
   pluck('title')->
   sortBy('title')->
   each(casefix());

Opět. nahoře jsou inline funkce, které se dají zapsat tvým způsobem, ale čitelnost, nebo zjistit co dělají? 0. Nehledě na testování, nebo nedej bůh úpravy. Zatímco druhý příklad je jasný a výřečný. Není zde nic navíc, co by rušilo kód a hlavně, podle názvu funkce hned víš, co se děje. – převzato z článku zde.

Věřím, že existuje jasný příklad, kde se použít dají a měly by se. My však takový příklad, kde by bylo na 100% jasné, že to je v pohodě ještě nenašli. To by sis musel být jo sakra jistý, že ti sedí právě tam a nechceš ji jinde, aby si nemusel složitě předávat proměnné a to mi trochu připomíná Davidovu pohádku o singletonu

Editoval Polki (22. 4. 2020 9:37)

@Polki tipuju, že si zapomněl vypnout xdebug :) benchmarky musíš spouštět s -n parametrem

@Polki asi jsem našel ten zdroj, který zmiňuješ – jen říká to, že Closures jsou o 16% méně náročné, nikoliv naopak https://wiki.php.net/…fromcallable a pro lepší výkon je tak lepší použít Closure::fromCallable

zkusil jsem to přidat do toho benchmarku, co zmiňuje @FVesely a dostalo se to pak na časy anonymní funkce

@Polki netuším, co děláš špatně – zkoušel jsem to v několika prostředích a všude je volání closure rychlejší. zkusil si to spouštět s tím -n přepínačem? imho tam budeš mít nějakou extension, která to zpomaluje