phpFashion

Na navigaci | Klávesové zkratky

Co nevíte o output bufferingu v PHP

A co se ani v dokumentaci nedočtete, včetně záplaty na bezpečnostní díru a rady, jak zrychlit odezvu serveru a naopak ji nezbrzdit.

Output buffering umožňuje, aby výstup PHP skriptu (především funkcí echo) nebyl okamžitě odeslán do prohlížeče nebo terminálu, ale byl uchováván v paměti (tj. bufferu). Což se hodí k celé řadě věcí.

Zabránění vypisování na výstup:

ob_start();  // zapne output buffering
$foo->bar();  // veškerý výstup jde pouze do bufferu
ob_end_clean();  // buffer smaže a ukončí buffering

Zachytávání výstupu do proměnné:

ob_start();  // zapne output buffering
$foo->render();  // výstup jde pouze do bufferu
$output = ob_get_contents();  // obsah bufferu uloží do proměnné
ob_end_clean();  // buffer smaže a ukončí buffering

Dvojici ob_get_contents() a ob_end_clean() lze nahradit jedinou funkcí ob_get_clean(), z jejíhož názvu se sice vytratilo end, ale skutečně output buffering i vypíná:

$output = ob_get_clean();  // obsah bufferu uloží do proměnné a vypne buffering

V uvedených příkladech se obsah bufferu na výstup vůbec nedostal. Pokud jej naopak na výstup poslat chci, namísto ob_end_clean() jej ukončím funkcí ob_end_flush() . Pro současné získání obsahu bufferu, odeslání na výstup a ukončení bufferování existuje opět zkratka (i včetně chybějícího end v názvu): ob_get_flush().

Buffer lze kdykoliv vyprázdnit i bez nutnosti jej ukončit, a to pomocí ob_clean() (smaže jej) a nebo ob_flush() (pošle jej na výstup):

ob_start();  // zapne output buffering
$foo->bar();  // veškerý výstup jde pouze do bufferu
ob_clean();  // smažu obsah bufferu, ale buffering zůstává aktivní
$foo->render(); // výstup jde stále do bufferu
ob_flush(); // buffer posílám na výstup
$none = ob_get_contents();  // obsah bufferu je nyní prázdný řetězec
ob_end_clean();  // vypne output buffering

Do bufferu se posílá i výstup zapisovaný na php://output, naopak buffery lze obejít zápisem na php://stdout (nebo do STDOUT), což je k dispozici pouze pod CLI, tedy při spouštění skriptů z příkazové řádky.

Zanoření

Buffery je možné zanořovat, takže zatímco je jeden buffer aktivní, dalším voláním ob_start() se aktivuje buffer nový. Tedy ob_end_flush() a ob_flush() neposílají obsah bufferu na výstup, ale do nadřazeného bufferu. A teprve když žádný nadřazený není, posílá se obsah na skutečný výstup, tj. do prohlížeče nebo terminálu.

Proto je důležité buffering ukončit, a to i v případě, že v průběhu nastane výjimka:

ob_start();
try {
    $foo->render();
} finally {  // finally existuje od PHP 5.5
    ob_end_clean(); // nebo ob_end_flush()
}

Velikost bufferu

Buffer může také zrychlit generování stránky tím, že se do prohlížeče nebude odesílat každé jednotlivé echo, ale až větší objem dat (například 4kB). Stačí na začátku skriptu zavolat:

ob_start(NULL, 4096);

Jakmile velikost bufferu překročí 4096 bajtů (tzv. chunk size), automaticky se provede flush, tj. buffer se vyprázdní a odešle ven. Téhož se dá dosáhnout i nastavením direktivy output_buffering. V CLI režimu se ignoruje.

Ale pozor, spuštění bufferingu bez uvedení velikosti, tedy prostým ob_start(), způsobí, že se stránka nebude neodesílat průběžně, ale až se vykreslí celá, takže server bude naopak působit velmi líně!

HTTP hlavičky

Output buffering nemá žádný vliv na odesílání HTTP hlaviček, ty se zpracovávají jinou cestou. Nicméně díky bufferingu je možné odeslat hlavičky i poté, co se vypsal nějaký výstup, jelikož se stále drží v bufferu. Ovšem jde o vedlejší efekt, na který neradno spoléhat, protože není jistota, kdy výstup překročí velikost bufferu a odešle se.

Bezpečnostní díra

Při ukončení skriptu se všechny neukončené buffery vypíší na výstup. Což lze považovat za nepříjemnou bezpečnostní díru, pokud si například v bufferu připravujete citlivá data, která nejsou určená pro výstup a dojde přitom k chybě. Řešením je použít vlastní handler:

ob_start(function () { return ''; });

Handlery

Na output buffering lze navázat vlastní handler, tj. funkci, která obsah paměti zpracuje před odesláním ven:

ob_start(
    function ($buffer, $phase) { return strtoupper($buffer); }
);
echo 'Ahoj';
ob_end_flush(); // na výstup se dostane AHOJ

I funkce ob_clean() nebo ob_end_clean() vyvolají handler, ale výstup zahodí a ven neposílají. Přičemž handler může zjistit, která funkce je volána a reagovat na to. Používá se k tomu druhý parametr $phase, což je bitová maska (od PHP 5.4):

  • PHP_OUTPUT_HANDLER_START při otevření bufferu
  • PHP_OUTPUT_HANDLER_FINAL při ukončení bufferu
  • PHP_OUTPUT_HANDLER_FLUSH při volání ob_flush() (ale nikoliv ob_end_flush() nebo ob_get_flush())
  • PHP_OUTPUT_HANDLER_CLEAN při volání ob_clean(), ob_end_clean()ob_get_clean()
  • PHP_OUTPUT_HANDLER_WRITE při automatickém flush

Fáze start, final a flush (resp. clean) mohou klidně nastat současně, rozliší se pomocí binárního operátoru &:

if ($phase & PHP_OUTPUT_HANDLER_START) { ... }
if ($phase & PHP_OUTPUT_HANDLER_FLUSH) { ... }
elseif ($phase & PHP_OUTPUT_HANDLER_CLEAN) { ... }
if ($phase & PHP_OUTPUT_HANDLER_FINAL) { ... }

Fáze PHP_OUTPUT_HANDLER_WRITE nastává jen tehdy, pokud má buffer velikost (chunk size) a ta byla překročena. Jedná se tedy o zmíněný automatický flush. Jen pozor, konstanta PHP_OUTPUT_HANDLER_WRITE má hodnotu 0, proto nelze použít bitový test, ale:

if ($phase === PHP_OUTPUT_HANDLER_WRITE) { .... }

Handler nemusí podporovat všechny operace. Při aktivaci funkcí ob_start() lze jako třetí parametr uvést bitovou masku podporovaných operací:

  • PHP_OUTPUT_HANDLER_CLEANABLE – lze volat funkce ob_clean() a související
  • PHP_OUTPUT_HANDLER_FLUSHABLE – lze volat funkci ob_flush()
  • PHP_OUTPUT_HANDLER_REMOVABLE – buffer lze ukončit
  • PHP_OUTPUT_HANDLER_STDFLAGS – je kombinací všech tří flagů, výchozí chování

Tohle se týká i bufferingu bez vlastního handleru. Například pokud chci zachytávat výstupu do proměnné, nenastavím flag PHP_OUTPUT_HANDLER_FLUSHABLE a buffer tak nebude možné (třeba omylem) poslat na výstup funkcí ob_flush(). Nicméně lze tak učinit pomocí ob_end_flush() nebo ob_get_flush(), takže to poněkud ztrácí smysl.

Obdobně by měla absence flagu PHP_OUTPUT_HANDLER_CLEANABLE zamezit mazání bufferu, ale opět to nefunguje.

A nakonec absence PHP_OUTPUT_HANDLER_REMOVABLE činní buffer uživatelsky neodstranitelný, vypne se až při ukončení skriptu. Příkladem handleru, který je vhodné takto nastavit, je ob_gzhandler, který komprimuje výstup a tedy snižuje objem a zvyšuje rychlost datového přenosu. Jakmile se tento buffer otevře, odešle HTTP hlavičku Content-Encoding: gzip a veškerý další výstup musí být komprimovaný. Odstranění bufferu by rozbilo stránku.

Správné použití je tedy:

ob_start(
    'ob_gzhandler',
    16000, // bez chunk size by server data neodesílal průběžně
    PHP_OUTPUT_HANDLER_FLUSHABLE // ale ne removable nebo cleanable
);

Komprimaci výstupu můžete aktivovat také direktivou zlib.output_compression, která zapne buffering s jiným handlerem (netuším, v čem konkrétně se liší), bohužel s příznakem, že je odstranitelný. Protože je vhodné komprimovat přenos všech textových souborů, nejen v PHP generovaných stánek, je lepší kompresi aktivovat přímo na straně HTTP serveru.


Everything About Output Buffering in PHP

What you can't learn from the documentation + patch for security hole + advice on how to speed up server response.

Output buffering allows you to have output of PHP (primarily generated by echo) stored into an memory (ie. buffer) instead of immediately transmitted to the browser or terminal. Which is useful to a variety of tasks:

Preventing output:

ob_start();  // turns on output buffering
$foo->bar();  // all output goes only to buffer
ob_end_clean();  // clears buffer and closes buffering

Capturing the output to a variable:

ob_start();  // turns on output buffering
$foo->render();  // output goes only to buffer
$output = ob_get_contents();  // stores buffer contents to the variable
ob_end_clean();  // clears buffer and closes buffering

Pair ob_get_contents() and ob_end_clean() can be replaced by a single function ob_get_clean(), from whose name disappeared end although it actually turns off output buffering:

$output = ob_get_clean();  // stores buffer content into variable and turns off buffering

In the above examples, the received buffer was not sent to the output. If you want to send it, use ob_end_flush() instead of ob_end_clean(). To obtain the contents of the buffer, send it to the output and turn off buffering, there is again single function (including missing end in the name): ob_get_flush().

Buffer can be emptied at any time without having to turn it off, using ob_clean() (deletes it) or ob_flush() (sends it to output):

ob_start();  // turns on output buffering
$foo->bar();  // all output goes only to buffer
ob_clean();  // delete the contents of the buffer, but remains buffering active
$foo->render(); // output goes to buffer
ob_flush(); // send buffer output
$none = ob_get_contents();  // buffer content is now an empty string
ob_end_clean();  // turn off output buffering

Into buffer is also sent output written to php://output, while the buffers can be avoided by writing to` php://stdout` (or STDOUT), which is available only under the CLI, ie. when running scripts from command line.

Nesting

Buffers can be nested, so while one buffer is active, another ob_start() activates a new buffer. So ob_end_flush() and ob_flush() are not really sending the buffer to the output, but to the parent buffer. And only when there is no parent buffer, contents is sent to browser or terminal.

It is therefore important to turn off buffering, even if the occurs an exception:

ob_start();
try {
    $foo->render();
} finally {  finally exists since PHP 5.5
    ob_end_clean(); // or ob_end_flush()
}

Buffer size (chunk size)

Buffer may also improve server performace when PHP will not send each echo to the browser, but will send bigger chunks of data, for example, 4KB. Just call at the beginning of the script:

ob_start(NULL, 4096);

Once the buffer size exceeds 4096 bytes, PHP automatically executes flush, ie. the buffer is emptied and sent out. The same can be achieved by setting directive output_buffering, which is ignored in CLI.

Be careful, if you start buffering without the chunk size (ie. a simple ob_start()) it will cause that the page will not be sent continuously, but once at the end of the script, so the server will respond very sluggishly!

HTTP headers

Output buffering does not affect the HTTP headers, they are processed in different way. However, due to buffering you can send the headers even after the output was sent, because it is still in the buffer. However, you should not rely on this side effect, because there is no certainty when the output exceeds the buffer size.

Security hole

When the PHP script ends all pending buffers will write its contents to output. This can be considered annoying security hole. If you are preparing in buffer sensitive data that is not intended for output and error occurs, PHP writes it to output. The solution is to use a custom handler:

ob_start(function () { return ''; });

Custorm handlers

You can set own custom handler, ie. a function that processes the contents of the buffer before sending it out:

ob_start(
    function ($buffer, $phase) { return strtoupper($buffer); }
);
echo 'Hello';
ob_end_flush(); // outputs HELLO

Also ob_clean() and ob_end_clean() invoke handler, but will drop the output. The handler can determine which function is called and respond to it via second parameter $phase, which is a bit mask (since PHP 5.4)

  • PHP_OUTPUT_HANDLER_START when buffer is turned on
  • PHP_OUTPUT_HANDLER_FINAL when buffer is turned off
  • PHP_OUTPUT_HANDLER_FLUSH when calling ob_flush() (but not ob_end_flush() or ob_get_flush())
  • PHP_OUTPUT_HANDLER_CLEAN when calling ob_clean(), ob_end_clean() and ob_get_clean()
  • PHP_OUTPUT_HANDLER_WRITE automaticflush

Phases start, final and flush (resp. clean) can occur simultaneously. It can be distinguish using binary operator &:

if ($phase & PHP_OUTPUT_HANDLER_START) { ... }
if ($phase & PHP_OUTPUT_HANDLER_FLUSH) { ... }
elseif ($phase & PHP_OUTPUT_HANDLER_CLEAN) { ... }
if ($phase & PHP_OUTPUT_HANDLER_FINAL) { ... }

Phase PHP_OUTPUT_HANDLER_WRITE occurs only when the buffer size had been exceeded. It is an automatic flush. Just be careful, constant PHP_OUTPUT_HANDLER_WRITE has a value of 0, so you cannot use binary operator, but:

if ($phase === PHP_OUTPUT_HANDLER_WRITE) { .... }

Handler may not support all operations. The ob_start() can specify supported operations by bit mask in third parameter:

  • PHP_OUTPUT_HANDLER_CLEANABLE – you can call the function ob_clean() and related
  • PHP_OUTPUT_HANDLER_FLUSHABLE – you can call the ob_flush()
  • PHP_OUTPUT_HANDLER_REMOVABLE – buffer can be turned off
  • PHP_OUTPUT_HANDLER_STDFLAGS – is a combination of all three flags, the default behavior

These flags can be used without own handler. For example, if I want to capture the output to a variable, omitting PHP_OUTPUT_HANDLER_FLUSHABLE flag tells that buffer cannot be (perhaps mistakenly) send to output via ob_flush(). However, you can do so via ob_end_flush() or ob_get_flush(), so it loses some sense.

Similarly, the absence of flag PHP_OUTPUT_HANDLER_CLEANABLE avoid erasing the buffer, but again, it does not work.

And finally, the absence of PHP_OUTPUT_HANDLER_REMOVABLE means that buffer cannot be turned off by user. An example of a handler that is appropriate to be unremovable, is ob_gzhandler that compresses the output and thus reduces the traffic and increases the speed of data transmission. Once this buffer opens, it sends a HTTP header Content-Encoding: gzip and all other output must be compressed. So buffer must not be removed.

Proper usage is:

ob_start(
    'ob_gzhandler',
    16000, // to send data continuously
    PHP_OUTPUT_HANDLER_FLUSHABLE // but not removable and cleanable
);

Output compression can be also activate by directive zlib.output_compression, which turns on buffering with a different handler (I don't know how they differs), but unfortunately as removable buffer. Because it is appropriate to compress all text files, not only PHP output, it is better to activate compression on HTTP server.

I don't speak English well, so I welcome all corrections.


Nette Pro: úplně bez obalu

Blíží se spuštění Nette Pro. Chemix sepsal, o co jde, a já dokončuji web, kde bude vysvětleno, co to přinese. Protože jsem zaznamenal i nějaké obavy, rád bych je rozptýlil a zkusím proto Nette Pro popsat zcela bez obalu.

Například Martin Zlámal se ptal: „chci o frameworku přednášet na školách. Baví mě to – a hodně. Mění se tím pro mě něco? Můžu to vůbec dělat?“ a v tu chvíli jsem si uvědomil, že Nette Pro obestírá jakýsi závoj neporozumění. Takže postupně:

Co je cílem všeho toho snažení? No je jím přesně to, po čem všichni voláme:

  • chceme nové verze plné novinek
  • chceme perfektní release management
  • chceme, aby se řešily hlášené issues nebo pull requesty
  • chceme lepší dokumentaci reflektující novinky
  • chceme stabilitu a minimum BC breaků
  • chceme blog o tom, co se chystá
  • chceme vylepšit web a fórum
  • chceme tutoriály, příklady, videa, podcasty, tipy, triky, řešení
  • chceme ten obsah i v angličtině, protože
  • chceme, aby se o Nette psalo v zahraničí, aby se o něm přednášelo
  • chceme, aby Nette hodně dlouho fungovalo, protože na něm děláme weby

Některé cíle jsou idealistické, jiné velmi hmatatelné, podstatné je, že všechny vám určitě rezonují. Martinova ochota přednášet o Nette na školách do toho pochopitelně zapadá.

Co je důvodem vzniku Nette Pro? Bez obalu: získat peníze na uskutečnění toho všeho.

A proč jsou potřeba peníze? Protože potřebujeme zaplatit lidi.

A proč potřebujeme zaplatit lidi? Protože nemáme dobrovolníky.

Jako že jich je málo? Současná komunita nestačí?

Na rovinu: na Nette pracují vlastně 3 lidé:

  • Milo, který vymýšlí, vyvíjí, opravuje, dokumentuje a píše na blog o Nette Testeru, taktéž spravuje hosting pro nette.org. Dělá to jako dobrovolník ve volném čase mimo zaměstnání a výchovu malého dítěte.
  • Chemix, který organizuje a moderuje Poslední soboty, zajišťuje sponzory, prostory, přednášející. Dělá to jako dobrovolník, jinak působí jako kreativec na volné noze. Neumí anglickou gramatiku tak, aby si troufl vydávat články.
  • já, David, který vymýšlí, vyvíjí, opravuje a releasuje Tracy, Latte a vlastně celé Nette, taky dibi a Texy, psal dokumentaci, udržuje web nette.org a fórum. Dělá to jako dobrovolník v podstatě už veškerý svůj čas. Neumí anglickou gramatiku tak, aby si troufl vydávat články.

A řekl bych, že nás všechny to baví. Jenže to neškáluje :-)

A taky bych řekl, že nás dost nebaví, když (zejména ti velmi dobře obeznámení se situací a možnostmi) nás hejtujou, že vysoká očekávání neplníme.

Z téhle trojky už víc vymáčknout nepůjde a dnes už víme, že na příliv nových sil nelze spoléhat. Zkoušeli jsme leccos včetně hazardérství, ale nic nezabralo. Místo čekání, jestli se někdo chopí třeba vylepšování dokumentace, je lepší si prostě copywritera najít a normálně mu těch několik měsíců práce zaplatit.

Samozřejmě nechci připravit o kredit kluky, kteří věnují čas fóru, což je fakt důležitá činnost.

Jen jsme narazili na hranici toho, co lze na čistě dobrovolné bázi uskutečnit. A hledáme způsob, jak jí překonat. Potřebujeme angažovat i „nedobrovolníky“.

Proč se tito lidé nezaplatí z příjmů Nette? Bez obalu: Nette generuje příjem v řádu tisícikorun měsíčně.

Tudíž potřebujeme ty příjmy zvýšit. Mnohanásobně. Což vůbec není sranda. Ano, Nette je zřejmě nejpopulárnějším webových frameworkem u nás, běží na něm řada nesmírně výdělečných projektů, jenže z toho automaticky neplyne příjem pro Nette. Firmy jsou nemilosrdné, a pokud jim nenabídnete nějakou přidanou hodnotu, korunu nepustí.

A tou přidanou hodnotou (především) pro firmy má být právě Nette Pro.

Svým způsobem přidanou hodnotou je i to, že chceme dělat Nette pro fesionálně.

Samo o sobě to však nestačí. Vyrazili jsme proto do firem a ptali se jich, bez obalu, jak si můžeme být prospěšní. „My potřebujeme peníze, protože bez nich by Nette jen přešlapovalo na místě. Co vám můžeme za ně nabídnout?“ Někdo se chtěl zviditelnit. Někdo chtěl vyřešit issues. Někdo jen chtěl, aby se Nette dál vyvíjelo. Tak jsme myšlenky přetavili do balíčků.

Ony balíčky jsou tedy tím, o čem lidé prohlásili: „jo, tohle dovedu u nás ve firmě prosadit.“

Nebo řekli: „jo, tohle by se nám fakt hodilo.“ Ať už programátorům, nebo třeba HR či marketingu, protože to pomůže zviditelnit firmu nebo najít zaměstnance.

Takže dobrovolníci už nejsou potřeba? Jsou! Setsakramentsky moc!

V Nette bylo a bude téměř vše tvořeno dobrovolníky. Nette Pro je jen záplata jejich chronického/ochromujícího nedostatku.

Doufám, že když se peníze z Nette Pro použijí na vylepšení webu, dokumentace, tutoriálů, že ten tvůrčí kvas povzbudí komunitu k aktivitě. Potřebujeme Martiny, kteří budou jezdit po školách. Potřebujeme autory tutoriálů a doplňků, kteří si tímto způsobem udělají jméno. Potřebujeme nadšence, co o Nette budou psát články do zahraničních magazínů, aby se přitáhla i světová komunita. Nette Pro zaplatí překladatele. Ale práci dobrovolníků nenahradí.

A kdy se to spustí? Během pár dní.


Dibi 3.0 je venku, Texy na cestě

Zmodernizoval jsem kód knihoven Dibi a Texy, třídy přenesl do jmenných prostorů a využil syntaxe PHP 5.4. Zároveň jsem doplnil mechanismus, aby knihovny fungovaly i s existujícím kódem, který používá původní názvy tříd.

Výsledkem je Texy 2.8 (release notes) a Dibi 3.0 (release notes).

Dibi mělo nést původně označení 2.4, protože krom vnitřního refactoringu jsem nechtěl přidávat nebo měnit jakoukoliv funkčnost, jako u Texy 2.8, ale nakonec jsem pár vychytávek přidal a výsledkem je právě verze 3.0:

  • nové výjimky Dibi\ConstraintViolationException, ForeignKeyConstraintViolationException, NotNullConstraintViolationExceptionUniqueConstraintViolationException
  • MySQL: sloupec TIME se převádí na objekty DateInterval namísto DateTime (BC break)
  • SqlsrvDriver: doplněna podpora pro LIMIT & OFFSET
  • vylepšen Dibi\Fluent při použití limit & offset

Zmizely ovladače pro SQLite 2 a MsSqlDriver, které nejsou od PHP 5.3 podporované, a MsSql2005Driver se nyní jmenuje SqlsrvDriver (funguje i starý název). Statická třída dibi zůstává mimo jmenné prostory. Pokud si píšete vlastní ovladač, došlo ke změně v rozhraní u metod escape() & unescape() (viz).

Minimální požadovaná verze PHP je 5.4.4, obě knihovny jsou plně funkční i pod PHP 7. Minifikovaná verze je ve formě archívu PHAR.

Dibi postupně pokrývám testy. Jelikož nepoužívám MS SQL Server, je tento driver víceméně v rukou komunity. Pokud jej používáte, zkuste prosím zjistit, proč neprocházejí testy používané pro jiné servery a co je potřeba změnit.

Velmi pozvolna vzniká i Texy 3.0, ze kterého zmizí dnes už překonané funkce, jako je třeba podpora jiného kódování než UTF-8, jiného formátu než HTML5 atd.


Jak vyvíjet komfotrněji?

Nová verze Nette 2.3.7 přináší spoustu vylepšení, jedno z nich si ale rychle zamilujete. Jsou to chybové hlášky, které se vám pokusí napovědět, pokud uděláte překlep.

Určitě jste už někdy narazili na podobnou chybu:

Chcete v šabloně vykreslit komponentu a ona prý neexistuje. Může to mít celou řadu příčin, od nějakého opomenutí na straně presenteru, až po chybu v šabloně. Nebo se komponenta jmenuje jinak?

Nejhorší ze všeho jsou triviální přelkepy, které nevidíte, takže několikrát prověříte všechny možnosti a strávíte na tom dost času, než chybu odhalíte.

Nejnovější verze Nette má ale šikovnější chybovou hlášku:

Did you mean ‚signInForm‘? Aha! Hned je jasné, že na vině byl překlep a můžete ho rovnou opravit.

Pokud jste se někdy dlouze zasekli na velikosti písmenek, tj. že vám {control MyComponent} hlásil chybu Component with name ‚MyComponent‘ does not exist, o to více oceníte dovětek did you mean ‚myComponent‘?.

Pojďme k Nette\Database. Chybka v názvu databázového sloupce? Opět ji dostanete na stříbrném podnose:

Mimochodem, stejná feature bude i v příští verzi dibi, kterou prosím před vydáním otestujte.

Nette napovídá překlepy v názvech funkcí, metod, proměnných atd. Pokud vyvíjíte v IDE, neměly by se vám podobné chyby stávat, na druhou stranu málokteré IDE dokáže plnohodnotně napovídat třeba v šablonách. Ať už se spletete v názvu filtru nebo makra:

Případně v názvu proměnné:

Hláškou did you mean novinky zvyšující pohodlí nekončí. Nette vás nově upozorní na celou řadu dalších, dříve špatně odhalitelných, chyb. Jako například chybějící []

$myForm->onSuccess = [$this, 'myFormSucceeded'];
// namísto správného
$myForm->onSuccess[] = [$this, 'myFormSucceeded'];

nebo chybějící ()

{foreach $form->getErrors as $error}
// namísto správného
{foreach $form->getErrors() as $error}

či docela nebezpečné opomenutí, jelikož $user->isLoggedIn je vždy truthy:

{if $user->isLoggedIn} ... něco tajného ... {/if}
// namísto správného
{if $user->isLoggedIn()} ... něco tajného ... {/if}

To nyní povede k varování Did you forget parentheses after isLoggedIn?

Poznámka: pokud záměrně píšete v kódu metodu bez závorek, tj. $cb = $obj->getItems, protože chcete využít vlastnosti Nette\Object, která takto do $cb uloží callback na metodu getItems, a objeví se varování, použijte prosím standardní PHP zápis, tj. $cb = [$obj, 'getItems']. Při korektních běžných použitích se varování nezobrazuje.

Dále Latte vás upozorní, když použijete modifikátor na místě, kde se ignoruje, jako například:

{if $var |filter}

Did you mean „komfortněji“?

Nová verze Nette je tu od toho, aby vám usnadnila a zpříjemnila vývoj. A jak je to napovídání boží si doopravdy uvědomíte, až to vyzkoušíte.


Jak na souhlas s cookie ve zkurvené EU

Víte, že nejpozději do 30. září 2015 máte povinnost získat souhlas uživatelů, pokud používáte na svém webu třeba Google AdSense? Proč, nač a jak na to?

(Verze pro příznivce EU)

Evropská unie přišla se zkurvenou směrnicí (tzv. sušenkovým zákonem), podle které musí uživatel webu dát souhlas s používáním cookies nebo obdobných mechanismů. Souhlas musí být také kurva odvolatelný.

Výjimkou jsou cookies, které jsou nezbytné pro poskytnutí služby, kterou si uživatel sám vyžádal, například cookie pro zkurvený nákupní košík. Naopak příkladem cookies, které nejsou nezbytně nutné, jsou cookie pro analýzu návštěvnosti, reklamní systémy nebo zkurvené pluginy sociálních sítí.

Česko zkurvenou evropskou směrnici implementovalo tak, že ji vlastně ignorovalo. Což se zkurveně nelíbí Úřadu pro ochranu osobních údajů, který se tím bude zabývat. Zatím tedy u nás není potřeba uživatele zkurveně žádat o souhlas, nicméně provozovatelé webů mají povinnost informovat o rozsahu a účelu jejich zpracování, například v podmínkách používání na svých stránkách. Uživatelé také musí mít možnost takové zpracování odmítnout, kurva fix.

…pokračování

před 6 měsíci v rubrice Web | shlédnuto 18300×


Jak na souhlas s cookie v EU

Víte, že nejpozději do 30. září 2015 máte povinnost získat souhlas uživatelů, pokud používáte na svém webu třeba Google AdSense? Proč, nač a jak na to?

Evropská unie přišla se směrnicí (tzv. sušenkovým zákonem), podle které musí uživatel webu dát souhlas s používáním cookies nebo obdobných mechanismů. A souhlas musí být také odvolatelný.

Výjimkou jsou cookies, které jsou nezbytné pro poskytnutí služby, kterou si uživatel sám vyžádal, například cookie pro nákupní košík. Naopak příkladem cookies, které nejsou nezbytně nutné, jsou cookie pro analýzu návštěvnosti, reklamní systémy nebo pluginy sociálních sítí.

Česko evropskou směrnici implementovalo tak, že ji vlastně ignorovalo. Což se nelíbí Úřadu pro ochranu osobních údajů, který se tím bude zabývat. Zatím tedy u nás není potřeba uživatele žádat o souhlas, nicméně provozovatelé webů mají povinnost informovat o rozsahu a účelu jejich zpracování, například v podmínkách používání na svých stránkách. Uživatelé také musí mít možnost takové zpracování odmítnout.

A teď to podstatné: protože Google nerozlišuje, jak která země implementovala směrnici EU, jste v případě, že používáte jeho služby jako Google AdSense nebo Analytics s některou z inzertních funkcí (remarketing, demografické přehledy), povinni získat souhlas koncového uživatele. A to do 30. září 2015.

Jak na to?

S tím, jak žádost o souhlas formulovat, vám poradí web www.cookiechoices.org. Záleží především na tom, k čemu cookie používáte. Kupříkladu na tomto webu používám AdSense a Analytics, takže jsem použil tuto formulaci:

Tento web používá k poskytování služeb, personalizaci reklam a analýze návštěvnosti soubory cookie. Používáním tohoto webu s tím souhlasíte.

Řeším tím povinnost dát uživateli možnost používání cookie odmítnout (tím, že web opustí) a také odvolatelnost souhlasu (tím, že web opustí).

A teď čistě technicky. Souhlas s používáním cookies si budu ukládat do cookie nazvané např. eu-cookies. Panel s žádostí vložím do layoutu na konec stránky a zobrazím pouze pokud nebyl udělen. Příklad pro Latte:

<div class="eu-cookies" n:if="empty($_COOKIE[eu-cookies])">
    Tento web používá k poskytování služeb, personalizaci reklam a analýze
    návštěvnosti soubory cookie. Používáním tohoto webu s tím souhlasíte.
    <button>V pořádku</button>
    <a href="https://www.google.com/policies/technologies/cookies/">Další informace</a>
</div>
<noscript><style>.eu-cookies { display:none }</style></noscript>

Panel mám napozicovaný fixně, aby byl stále vidět. Sice tak ukrajuje kus prostoru zejména na mobilních zařízeních, ale to nevadí, uživatel stejně nemůže web používat, pokud neprojeví souhlas. Příklad stylu:

.eu-cookies {
    position: fixed;
    left: 0;
    top: 0;
    width: 100%;
    color: white;
    background-color: black;
    z-index: 1000;
}

.eu-cookies button {
    background: green;
    color: white;
}

A nakonec JavaScript, který po stisknutí tlačítka uloží souhlas do cookie (používám jQuery):

$('.eu-cookies button').click(function() {
    var date = new Date();
    date.setFullYear(date.getFullYear() + 10);
    document.cookie = 'eu-cookies=1; path=/; expires=' + date.toGMTString();
    $('.eu-cookies').hide();
});

Pokud používáte subdomény a cookie se má nastavit i pro ně, doplňte za path=/; ještě domain=.vasedomena.cz; (a tečka na začátku je důležitá).

Ještě poznámka: dokud souhlas nezískáte, neměla by vaše stránka obsahovat ani reklamu, ani měřící kódy.


Jak správně načítat webové fonty

Stránka by měla být čitelná ihned. Je velmi protivné, když si například v metru nemůžete přečíst článek jen kvůli tomu, že se nestihl načíst webový font.

Prohlížeče se totiž chovají tak, že text zobrazí až poté, co se font stáhne, aby zabránili tzv. Flash of Unstyled Text (FOUT), tedy nepříjemnému probliknutí jiného fontu. Problém je, že nemají žádný timeout, po jehož uplynutí by se použil alternativní font.

O tomhle tématu jsem psal už dříve a doporučoval pro mobilní zařízení webové fonty vůbec nepoužívat. Stejně krom autora grafiky to nikdy nepozná :-)

Mobilům (nebo lépe řečeno zařízením do šířky 500px) můžeme ulevit tímto způsobem:

/* font stáhneme jen na větších zařízeních */
@import "http://fonts.googleapis.com/css?family=PT+Serif" screen and (min-width: 500px);

body {
    font: 18px/1.7 Georgia, serif;
}

@media (min-width: 500px) {
    body { /* a font použijeme jen na větších zařízeních */
        font-family: 'PT Serif', Georgia, serif;
    }
}

Emulace timeoutu

Další možností je timeout implementovat pomocí JavaScriptu. Jenže zjistit, že se font načetl, není nic triviálního, dělá se to pomocí triků, jako je třeba detekce změny šířky předpřipraveného text atd. Font Loading API zatím podporuje jen Chrome. Takže lepší bude použít hotové řešení, jako je například Web Font Loader.

Web Font Loader

Knihovnu Web Font Loader vyvíjí Google společně s Typekit. Nedávno o ní psal Aleš Roubíček, takže na něj navážu a pokusím se upravit řešení tak, aby se skript načítal asynchronně a neblokoval stránku.

Do hlavičky vložte tento kód, kterým asynchronně načtete Web Font Loader a také příslušný font:

<script>
    WebFontConfig = { google: { families: ['PT+Serif:400:latin,latin-ext'] } };
</script>
<script src="https://ajax.googleapis.com/ajax/libs/webfont/1.5.18/webfont.js" async defer></script>

Web Font Loader umí detekovat stavy, kdy se font načítá a kdy už je načtený, a to pomocí událostí nebo nastavováním tříd elementu <html>. Jakmile je font načtený, nastaví třídu wf-active. Zároveň řeší timeout.

Upravíme styl tak, aby se font použil teprve ve správný okamžik:

body {
    font: 18px/1.7 Georgia, serif;
}

html.wf-active body {
    font-family: 'PT Serif', Georgia, serif;
}

Tohle řešení má ale potíž. Bude docházet k FOUT, tedy k probliknutí alternativního fontu. A to vypadá velmi ošklivě.

Proto během načítání písmo skryjeme, tak jak to dělají prohlížeče standardně, bez loaderu.

html.wf-loading * {
    color: transparent !important;
}

Třídu wf-loading musíme nastavit ihned, nelze čekat, až se Web Font Loader načte. Ale zároveň ji musíme odstranit, když načtení loaderu selže. Výsledný kód vypadá takto:

<script>
    WebFontConfig = { google: { families: ['PT+Serif:400:latin,latin-ext'] } };

    var el = document.documentElement;
    el.className += ' wf-loading';
    setTimeout(function() {
        el.className = el.className.replace(/(^|\s)wf-loading(\s|$)/g, ' ');
    }, 1000);
</script>
<script src="https://ajax.googleapis.com/ajax/libs/webfont/1.5.18/webfont.js" async defer></script>

Doplnění: tohle vypadá jako způsob, jak obejít jakékoliv probliknutí


Rychlejší stránky s Google Universal Analytics

Ukáži vám, jak zrychlit načítání Google Analytics nebo Web Loaderu a ještě zjednodušit měřící kód.

Tímto kódem vložíme do stránky měřící bod Google Analytics:

<script>
    (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
    m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
    })(window,document,'script','//www.google-analytics.com/analytics.js','ga');

    ga('create', 'UA-XXXXX-XX', 'auto');
    ga('send', 'pageview');
</script>

Když si ho odtemníme, vypadá takto:

<script>
    (function() {
        window['GoogleAnalyticsObject'] = 'ga';
        window['ga'] = window['ga'] || function() {
            (window['ga'].q = window['ga'].q || []).push(arguments)
        }, window['ga'].l = 1 * new Date();
        var script = document.createElement('script'),
            firstScript = document.getElementsByTagName('script')[0];
        script.async = 1;
        script.src = '//www.google-analytics.com/analytics.js';
        firstScript.parentNode.insertBefore(script, firstScript)
    })();

    ga('create', 'UA-XXXXX-XX', 'auto');
    ga('send', 'pageview');
</script>

Řádek window['GoogleAnalyticsObject'] = 'ga' říká, že objekt Google Analytics bude uložen v globální proměnné ga, nicméně je zbytečný, protože ga je výchozí hodnota.

Dále následuje vytvoření objektu v proměnné ga, který představuje jen dočasný zásobník, kam se ukládá sekvence volání jednotlivých příkazů, a po načtení skriptu bude nahrazen skutečným objektem Google Analytics. Uvedený kód se dá výrazně zjednodušit vypuštěním window a pokud na stránce není víc měřících kódu, můžeme zrušit i podmínky ga = ga || ... a dostáváme se k jednoduchému:

ga = function() { ga.q.push(arguments) };
ga.q = [];
ga.l = +new Date;

Dále následuje vytvoření elementu <script> a jeho vložení do stránky. Nastavení script.async = 1 je zbytečné, protože podle HTML specifikace je každý skriptem vkládaný <script> asynchronní.

Nicméně – neexistuje žádný důvod, proč element <script> vytvářet JavaScriptem. Je mnohem výhodnější použít normální HTML. Stránka se díky tomu načte rychleji, nedochází k blokování a může se využít preload scanner v moderních prohlížečích. Tím se dostáváme k této podobě:

<script>
    ga = function() { ga.q.push(arguments) };
    ga.q = [];
    ga.l = +new Date;
    ga('create', 'UA-XXXXX-XX','auto');
    ga('send','pageview');
</script>
<script src="//www.google-analytics.com/analytics.js" async></script>

Aby se kód načítal asynchronně i v prohlížečích IE 5.5 – 9, je nutné kromě atributu async přidat ještě defer.

V dnešní době se relativní URL //www.google-analytics.com dá považovat za antipattern, vhodnější je vždy používat https.

Finální podoba

Konečná podoba včetně minifikace vypadá takto:

<script>
    ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
    ga('create','UA-XXXXX-XX','auto');ga('send','pageview');
</script>
<script src="https://www.google-analytics.com/analytics.js" async defer></script>

Rychlejší, kratší a ještě navíc hezčí. Nechť slouží :-)

Web Font Loader

Podobným způsobem je vhodné načítat i Web Font Loader, tj. místo v dokumentaci uvedeného

<script>
   WebFontConfig = {
      typekit: { id: 'xxxxxx' }
   };

   (function(d) {
      var wf = d.createElement('script'), s = d.scripts[0];
      wf.src = 'https://ajax.googleapis.com/ajax/libs/webfont/1.5.18/webfont.js';
      s.parentNode.insertBefore(wf, s);
   })(document);
</script>

používejte

<script>
   WebFontConfig = {
      typekit: { id: 'xxxxxx' }
   };
</script>
<script src="https://ajax.googleapis.com/ajax/libs/webfont/1.5.18/webfont.js" async defer></script>

Google Tag Manager

Protože adresa skriptu se v kódu Tag Manageru skládá, uvedenou optimalizaci nelze bohužel použít.


Chrome a nekonečné přesměrování

Chrome 44 (beta) odesílá nově hlavičku HTTPS: 1, která může způsobovat problémy.

Na některých hostinzích (z těch co používám třeba WebSupport už to opravili) si pak PHP myslí, že požadavek je pod šifrovaným spojením HTTPS. Tj. proměnná $_SERVER['HTTPS'] === 'on'.

U aplikací v Nette, které neběží pod https, to pak způsobí nekonečný redirect. Aplikace si prostě myslí, že k ní přistupujete přes URL https://example.com a přesměrovává na http://example.com.

Můžete to vyzkoušet z příkazové řádky pomocí:

curl -I --header "HTTPS: 1" http://example.com`

Že je hlavička HTTPS: 1 problematická se už ví, takže je možné, že se změní a do Chrome nedostane. Každopádně jako rychlý workaround, aby nedocházelo ke smyčce přesměrování v betaverzi Chrome, je přidat na začátek bootstrap.php:

unset($_SERVER['HTTPS']);

Zároveň je dobré si uvědomit, že na některých hostinzích lze detekci šifrovaného spojení velmi snadno ošálit.

Doplnění: Chrome 45 už hlavičku HTTPS: 1 neodesílá.