pronto.ee

Tomorrow will be cancelled due to lack of interest

PHP 8.0: Muudatus funktsioonis strrpos()

PHP

Nüüd kus PHP 7.x-i enam parketikõlbulikuks ei peeta ilmneb, et mitte kõik rakendused ei taha uuemate PHP versioonidega toimida. Mitte alati ei ole nende põhjus üheselt selge ning töö käigus ilmnevad siin ja seal pooldokumenteeritud muudatused mis võivad lohakale arendajale kaika valusal kombel kordaratesse torgata. Üheks selliseks funktsiooniks on strrpos().

Selleks, et asja olemusest aru saada tuleb vaadata kõigepealt funktsiooni signatuuri ja pöördumisväärtuseid. Php.net ütleb selles kohta nii:

strrpos(string $haystack, string $needle, int $offset = 0): int|false

Returns the position where the needle exists relative to the beginning of the haystack string (independent of search direction or offset).

Returns false if the needle was not found.

Enne PHP 8.0-t töötas see funktsioon nõnda, et kui $offset läks string piiridest välja (tavaliselt oli selle põhjuseks tühi $haystack) oli pöördumisväärtuseks false. Alates PHP 8.0-st on tulemuseks hoopis:

Fatal error:  Uncaught ValueError: strrpos(): Argument #3 ($offset) must be contained in argument #1 ($haystack)

Ehk siis tulemuseks on kriitiline viga ning koodi edasi töötlemine lõpetatakse. Ühest küljest on see halb, sest dokumentatsioon seda situatsioon ei kata. Teisest küljest on see mõistetav, sest strrpos() on lõppeks ikkagi funktsioon ning hea tava näeb PHP-s ette, et küllalt ressursimahukaid funktsioone ei kasutata tuvastamaks kas andmeid on võimalik töödelda või mitte. Igal juhul oleks korrektne lahendus kontrollida if lausega ega string juhtumisi pole tühi. Alternatiivse variandina võib try / catch-iga püüda kinni \ValueError ja jätkata nii nagu algne kood ette nägi. See viimane lahendus läheb loomulikult vastuolla heade tavadega, kuid teinekord on oluline lihtsalt kood käima saada.

Siinkohas oleks paslik märkida, et \ValueError on uuendus mis toodi sisse PHP 8.0-s. Ehk siis sellepüüdmine ei toimi varasemate PHP-dega. Kui kood peab olema ka tagurpidi ühilduv peaks kasutama kas \Exception-it või klassi polyfillimist:

if (!class_exists('\ValueError')) {
    class ValueError extends \Error {
    }    
}

Ahjaa, märkuseks niipalju veel, et kuigi algne teemapüstitus puudutas ühte konkreetset funktsiooni mõjutab see muudatus veel teisigi, näiteks strpos(), range(), array_rand() ja võib-olla midagi veel on samuti selles muudatusest mõjutatud.

PHP 8.3: json_validate()

Kuigi PHP 8.3 ei ilmu just homme (hetkel on see planeeritud selle aasta 23. novembriks) on aeg hakata kaema sellega kaasnevaid uuendusi. Esimeseks neist saab olema uus funktsioon json_validate().

PHP

JSON (JavaScript Object Notation) on avatud andmestandard mida on juba aastaid kasutatud andmete vahetamiseks ning salvestamiseks, mis on õhuke ning minimaalselt ressurssi nõudev ja ühes sellega päris paljudes kontekstides praeguseks asendanud XML-i. Praeguseks on nii, et kui mingid asjad peavad veebis omavahel andmeid vahetama, siis tavaliselt kasutavad nad selleks JSON formaati. Asjale muidugi aitab kaasa ka nüanss, et JSON on enam-vähem inimloetav, andmete kontrollimiseks ei ole seetõttu vaja eraldi tööriistu.

Samas on PHP-s JSON-ga seotud üks väike kuid tülikas probleem: nimelt selleks, et kontrollida andmeformaadi õigsust pidi varem andmed json_decode() abil objektiks konverteerima. Kui andmemahud olid piisavalt suured, siis tõstis see andmevahetuskihi jaoks nõudeid protsessorile või töötlemisajale, mis näiteks AWS-i puhul kippus kiiresti reaalseteks kuludeks muutuma. Sestap siis json_validate(), mille eesmärk on vaid andmeid kontrollida.

Funktsiooni signatuur näeb välja selline:

/**  
 * Validates a given string to be valid JSON.
 * 
 * @param string $json String to validate  
 * @param int $depth Set the maximum depth. Must be greater than zero.  
 * @param int $flags Bitmask of flags.  
 * @return bool True if $json contains a valid JSON string, false otherwise.  
 */  
function json_validate(string $json, int $depth = 512, int $flags = 0): bool {  
}

Kes tahab sellest funtksioonist rohkem teada saada vaadaku siia ja kui kedagi beaks huvitama bitmaski väärtused, siis selle info leiab siit.

Märkuseks veel niipalju, et seda funktsioon on võimalik polyfillida, ehk siis koodi on võimalik teha vanemate PHP versioonidega ühilduvaks kasutade järgmist meetodit:

if (!function_exists('json_validate')) {  
  function json_validate(string $json, int $depth = 512, int $flags = 0): bool {  
    if ($flags !== 0 && $flags !== \JSON_INVALID_UTF8_IGNORE) {  
      throw new \ValueError('json_validate(): Argument #3 ($flags) must be a valid flag (allowed flags: JSON_INVALID_UTF8_IGNORE)');  
    }  

    if ($depth <= 0 ) {  
      throw new \ValueError('json_validate(): Argument #2 ($depth) must be greater than 0');  
    }  

    \json_decode($json, null, $depth, $flags);  

    return \json_last_error() === \JSON_ERROR_NONE;  
  }  
}

See lahendus on hetkel PHP 8.0 ühilduv ning kui \ValueError asendada näiteks \Exception-ga, siis töötab see isegi PHP 7.3-ga. Sestap võib selle funktsioni juba praegu oma koodi lisada.

PHP 8.1: Readonly

PHP

Seekordseks teemaks on PHP 8.1-s sisse toodud uus piirang mille aluseks on readonly muutujad (propertyd).

Kes ei tea, siis readonly muutujat ei saa pärast initsialiseerimist enam muuta, funktsionaalsus mida üsna sageli läheb vaja siis kui andmeid komponentide vahel vahetatakse. Kuni viimase ajani saavutati see funktsionaalsuse getterite ja setteritega. Ma toon ühe näite readonlyst:

<?php

class Test
{
    public readonly string $test;

    public function update(string $test): void
    {
        $this->test = $test;
    }
}

$test = new Test();
$test->update('test');
echo "Initalize";
$test->update('test');
echo "Overwrite";

Kui järgnev kood lasta läbi PHP 8.1-e (varasemate versioonidega ei tööta see üldse), on tulemuseks:

Initalize
Fatal error: Uncaught Error: Cannot modify readonly property Test::$test in /data01/virt58215/domeenid/www.discordia.ee/dev/test.php:9
Stack trace:
#0 /data01/virt58215/domeenid/www.discordia.ee/dev/test.php(16): Test->update('test')
#1 {main}
  thrown in /data01/virt58215/domeenid/www.discordia.ee/dev/test.php on line 9

Nagu näha funktsiooni mis readonly muutujat modifitseerib teistkordne väljakutsumine viskab oodatult exceptioni.

Aga.

Sellel on ka üsna tülikas kõrvalnäht; nimelt on readonly nüüd reserveeritud sõna, mis praktikas tähendab seda, et kui kui teha selline klass:

<?php

class ReadOnly
{
}

… annab interpreteerimisel tulemuse:

Parse error: syntax error, unexpected token "readonly", expecting identifier in /data01/virt58215/domeenid/www.discordia.ee/dev/readonly.php on line 3

Miks see oluline on?

Oluline on see sellepärast, et päris suur hulk erinevaid rakendusi kasutavad ReadOnly klassi kasutajaliideses vaid lugemiseks mõeldud vormielemendi deklareerimiseks. Siinkohas oleks paslik märkida, et see võtmesõna on tõstutundetu, ehk siis sama viga tuleb ka READONLY, readonly, READonly, jne. puhul. Ning siis kui me tahame luua sellenimelisi traite, interfacesi, jne.

Seal on ka üks kentsakas erand: PHP 8.1 lubab deklareerida readonly() funktsioone. Põhjuseks see, et maailma kõige populaarsem sisuhaldusplatvorm WordPress kasutab seda nõnda laialdaselt, et PHP arendajatel ei olnud muud valikut kui seda eraldi lubada.

PHP8: tüübimaagia

PHP

PHP8 tõi sisse hulgaliselt täiendusi tüüpidega majandamisesse ning PHP8.1 lisas sinna omakorda peale täiendava kihi. Selles postituses keskendume me siiski vaid PHP8 muudatustel.

PHP on n.ö. nõrkade tüüpidega (weak typing) keel, mis praktikast tähendab seda, et erinevaid tüüpe on võimalik võrrelda ja nende väärtuseid teineteisele omistada; selleks vajalik tüüpide kantimine (type coercion) toimub automaatselt. Teinekord paraku soovimatute kõrvalnähtudega. PHP8 üritab jõudumööda neid soovimatuid kõrvaltoimed kas siis vältida või vähemalt pakub võimaluse neid kontrolli all hoida.

Tüüpide võrdlemine

Klassikaline erinevus PHP7 ja PHP8 vahel ilmneb järgnevas võrdluses:

if ('something' == 0) {
    echo 'true';
} else {
    echo 'false';
}

Nii 'something' kui 0 võivad olla muutujad; PHP7 puhul on vastuseks true, PHP8 puhul false. Asi on selles, et kui võrdluses on int ja string, siis proovitakse stringist teha int. Kuna tegemist on mittenumbrilise tekstiga, siis PHP7 pani selle väärtuseks 0 sellal kui PHP8 jaoks väärtus puudub ja sellest ka erinev tulemus. Samasuguse tulemuse annab näites järgnev lõik:

if ('42something' == 42) {
    echo 'true';
} else {
    echo 'false';
}

Selline tüüpide kantimine on teinekord väga mugav, näiteks XML failide töötlemisel, kuid sisaldab endas riske ja tänu sellele võib juhtuda, et kood mis toimis PHP7-s ei tööta enam PHP8-s. Märkuseks nii paljud, et:

if ('42' == 42) {
    echo 'true';
} else {
    echo 'false;
}

… on true vaatamata PHP versioonile, kuna ’42’ on string mida on võimalik üheselt intiks kantida.

Muudatus tüüpide kantimises torkab silma ka siis kui kasutada < ja > võrdluseid. Kui varem kanditi string intiks ja seejärel võrreldi, siis nüüd kui stringi ei ole võimalik konvertida on number alati väiksem kui string. Need nüansid laienevad muudelegi võrdlustele, näiteks in_array käitub nüüd pisut erinevalt.

Ma siiski tooks enne järgmise näite juurde minekut eraldi välja erisuse kui kasutada switchi.

switch(0) {
    case 'a' : print "case A\n"; break;
    case 0   : print "case 0\n"; break;
}
 
switch('a') {
    case 'a' : print "case A\n"; break;
    case 0   : print "case 0\n"; break;
}
 
switch(0) {
    case 0   : print "case 0\n"; break;
    case 'a' : print "case A\n"; break;
}
 
switch('a') {
    case 0   : print "case 0\n"; break;
    case 'a' : print "case A\n"; break;
}

Annab PHP7 puhul tulemuseks

case A
case A
case 0
case 0

ja PHP 8 puhul

case 0
case A
case 0
case A

Mis on eelnevat arvestades igati loogiline ja enamasti ka soovitud tulemus. Ehk siis nõrkade tüüpidega manipuleerides võib juhtuda, et kood käitub pisut teisi.

Unionid

PHP7 tõi keelde funktsioonide pöördumistüübi ning PHP7.1 nullitavad tüübid (nullable types). Et vältida soovimatut tüüpide kantimist ning aidata IDE-si soovituste andmisel on funktsioonidel võimalik anda tüüp nii sisendi kui väljundi jaoks. Nullitavad tüübid (algavad ? märgiga) näitavad, et tüüp võib (näiteks kui vastus ei leita) olla ka null. Näide:

public function doStuff(int $i): ?string
{
    // stuff
}

Aga mis siis kui sisend (või väljund) võib olla rohkem kui ühte tüüpi? Iseenesest pole midagi valesti selles kui muutujaid kanditakse enne või pärast funktsiooni välja kutsumist kuid see on tülikas, lisab ballasti ja ei aita loetavusele kaasa. Sestap tõi PHP8 sisse unionid. Näide:

public function add(int|float $a, int|float $b): int|float
{
    return $a + $b;
}

Märkuseks niipalju, et null ei tegelikult tüüp, vaid tüübi puudumine ja sestap ei ole string|null endiselt korrektne konstruktsioon ja selle asemel tuleks kasutada ?string tüüpi.

mixed tüüp

Teinekord on vaja lihtsalt konstruktsiooni kus lubatud on kõik tüübid KAASA ARVATUD null. Selleks puhuks tõi PHP8 sisse pseudotüübi nimega mixed. Näiteks:

public function doStuff(mixed $input): bool
{
    // stuff
}

Muutujad mille tüüp pole veel selge tüüp on samuti mixed. Kuna mixed sisaldab kõiki tüüpe ei oma int|mixed ja ?mixed mingit tähendust ning annavad seetõttu vea. Samal põhjusel ei eksisteeri is_mixed funktsiooni ning samuti ei ole võimalik teha $b = (mixed)$a.

Üks asi veel: alatest PHP8-st ei ole enam võimalik deklareerida klassi nimega mixed. Kuni sinnamaani oli see teoreetiliselt võimalik.

PHP8: konstruktori parameetrite eskaleerimine

PHP

Konstruktori parameetrite eskaleerimine (Constructor Property Promotion) on tõenäoliselt kõige praktilisem uuendus mille PHP8 endaga kaasa tõi. Ühes dependency injectionite ja reflectionite järjest laialdasema kasutamisega näeb tavalise konstruktori signatuur koos parameetrite, muutujate ja omistustega välja umbes selline:

protected Database $database;
protected Config $config;
protected Source $source;

public function __construct(Database $database, Config $config, Source $source)
{
    $this->database = $database;
    $this->config = $config;
    $this->source = $source;

ning objekti enda initsialiseerimine selle klassi põhjal selline:

$adapter = new Adapter($database, $config, $source);

Keerukamate rakenduste puhul kasutavad objektid kümneid muid objekte eriti kui mängus on reflectionid mis initsialiseerimise poole suuresti automatiseerivad ja arendajat seoserägastikuga kaasnevast peavalust säästavad. Paraku tingib see samas olukorra kus injectioneid tehakse väga kergekäeliselt ning iga klassi konstruktoris on hulgaliselt parameetreid mis siis ükshaaval klassimuutujate külge kleebitakse. Ning tõsisemates raamistikes / rakendustes on klasse sadu kui mitte tuhandeid.

See on nüri, see võtab aega, see muudab koodi pikaks ja ühes sellega loetamatuks.

PHP8-s näeb analoogne kood välja selline:

public function __construct(protected Database $database, protected Config $config, protected Source $source)
{

Kui erandjuhud näiteks referentside (need & märgiga algavad muutujad) näol kõrvale jätta, on parameetrites deklareeritud muutujate skoop ja ühes sellega nähtavus alati piiratud funktsiooniga. Erandiks on PHP8-s konstruktor kus nähtavuse lisamine ütleb klassile, et nähtavusega muutujad tuleb automaatselt eskaleerida klassiüleseks ning nende nähtavus (private, protected, public) oleks mida iganes nende nähtavuseks määrati. Muutujad millel nähtavust pole jäävad endiselt vaid konstruktorile endale nähtavaks.

Nagu näha on see tükk maad lühem, loetavam ja suures plaanis on seal palju vähem ruumi vigadele. Seal on siiski mõned nüansid millega peab arvestama:

  1. Eskaleerivaid muutjaid saab deklareerida AINULT konstruktoris
  2. Nõnda deklareeritud muutujaid EI SAA uuesti (eraldi) deklareerida
  3. Variadic muutujaid EI SAA eskaleerida
  4. Callable tüüpi muutujaid EI SAA eskaleerida
  5. Abstract konstruktorid EI TOETA eskaleerimist.

Enamus neist ülaltoodud piirangutes on tegelikult äärmiselt loogilised ning kui nende üle mõelda aitavad mõista eskaleerimise olemust. Seega eskaleerigem mõnuga!

PHP8: nullikindel operaator

PHP

Vajadus nullikindla operaatori (null-safe operator) järele eksisteerib PHP-s juba mõnda aega. Põhimõtteliselt võimaldab see nüüd kasutada pöördumisväärtuste ahelat ilma täiendavate kontrollideta ka siis kui seda kasutatakse koos väärtustamata tüüpidega (nullable types).

Et sellest paremini aru saada tuleb vaadata mõlemat asja eraldi. Väärtustamata tüübid lisati PHP-sse hulk aastaid tagasi versioonis 7.1. Klassikaline väärtustamata tüübiga meetodi signatuur näeb välja selline:

public function getSession(): ?Session
{
    // Code
}

Praktikas tähendab see seda, et kirjeldatud funktsioonil võib olla kahte tüüpi pöördumisväärtus: Session või null. Null on spetsiifiline tüüp mida kasutatakse sellistel puhkudel kui väärtust ei leita: näiteks antud juhul oleks täiesti legitiimne viis tagastada null kui sessioon on initsialiseerimata. Siinkohas on oluline mõista, et see on legitiimne viis ainult siis kui tõepoolest selline olukord on loomulik voo osa, näiteks sellisel puhul kui kasutaja pole sisse loginud. Kui sessiooni ei ole ühel või teisel (tehnilisel) põhjusel võimalik pärida, siis on korrektseks lahenduseks Exceptioni viskamine. See võimaldab vahet teha vastuse puudumisel ja veal.

Tähelepanuks niipalju, et väärtustamata tüüpe võib kasutada ka sisendaväärtustena. Näiteks:

$user->setAddress(?Address $address);

Tüüpide kasutamine pole tänapäeva PHP-s küll otseselt kohustuslik kuid sellele vaatamata rangelt soovituslik; see võimaldab IDE-del automaatselt tuvastada koodis vigu ning vältida olukorda kus funktsioonile antakse ette vale parameeter mille PHP automaatselt ootamatute tagajärgedega enda jaoks sobivaks konverteerib.

Pöördumisväärtuste ahel on PHP veelgi kauem eksisteerinud. Klassikaline ahel näeb välja selline:

$country = $app->getSession()->getUser()->getAddress()->getCountry();

See võimaldab juhul kui pöördumisväärtuseks on objekt selle meetodeid koheselt kasutada. Probleem tekib siis kui mõne meetodi pöördumisväärtuseks on null. Sellistel puhkudel on tulemuseks: Fatal error: Uncaught Error: Call to a member function getSession() on null in .... Kuna eelnevalt sai toonitatud, et null võib olla meetodil täiesti legitiimne pöördumisväärtus sunnib see arendajat iga pöördumisväärtust eraldi kontrollima mis oma olemusel muudaks kogu kontseptsiooni kasutuks.

PHP8 tõi sellele probleemile lahenduse nullikindlate operaatorite (null-safe operators) näol. Praktikas näeb see välja selline:

$country = $app->getSession()?->getUser()?->getAddress()?->getCountry();

Sellisel puhul kui ükskõik milline ülaltoodud meetod annab tagasi null väärtuse, lõpetatakse ilma veata ahela edasine täitmine ning muutuja $country saab väärtuseks null. Selline lähenemine muudab koodi oluliselt lühemaks ja loetavamaks.

Oluline on siiski pidada silmas paari nüansse:

  1. ?-> tuleks kasutada ainult siis kui pöördumisväärtus võib reaalselt null olla. Vastasel korral on see probleemi vaiba serva alla lükkamine ehk siis reaalne viga võib arenduse käigus märkamata jääda.
  2. Seda saab kasuatada ainult lugemiseks. Muutujaid selle kaudu omistada ei saa. Näiteks $country()?->countryCode = 'EE'; annab tulemuseks Fatal error: Can't use nullsafe operator in write context in …
  3. See operaator annab varasemata PHP versioonidega vea: Parse error: syntax error, unexpected '->' (T_OBJECT_OPERATOR) in …
  4. Seda meetodit ei ole võimalike kasutada läbi viidete (references): &$country->getCode(); annab tulemuseks: Fatal error: Cannot take reference of a nullsafe chain in …

PHP8: match avaldis

PHP

Ma olen viimastel aastatel päris palju pidanud algajate arendajate koodi hindama ja üks asi mis mulle silma torkab on see kui harva kasutatakse switch-i tingimuste lahendamiseks. Selle asemel leiab koodist erineval kujul terve leegioni if, else ja elseif lauseid. Ma ei hakka sellest hetkel pikemalt pajatama; jätke lihtsalt meelde, et switch on teie sõber. Kui seda õigesti kasutada siis muudab see koodi loetavamaks ja lühemaks.

PHP8 tõi sisse uue viisi tingimustega tegelemiseks mis on segu switch-ist ja kolmekordsetest (ternary) operaatoritest. Kui ei tule kohe meelde mida kolmekordne operaator endast kujutab, siis tüüpiliselt näeb see välja selline:

$i = $condition ? 'true' : 'false';

Uue viisi nimi on match ja kui tingimused klapivad, siis muudab see koodi veelgi lühemaks ja veelgi loetavamaks. Pidage meeles, et iga rida koodi on midagi mida tuleb jooksvalt hooldada ja vajaduse korral uuendada. Kui loetavus sellest ei kannata, siis mida vähem koodi seda parem. Toon siinkohas ühe näite kasutades eelmises postituses mainitud anonüümseid funktsioone:

$animal = 'dog';

$voice = match($animal) {
    'dog' => function() {return 'woof';},
    'cat' => function() {return 'meow';},
    'poro' => function() {return 'perkele!';},
    default => function() {return 'huh?';}
};

echo $voice();

Siinkohas oleks paslik ära märkida paar nüanssi. Esiteks match eeldab, et muutuja $animal on deklareeritud. Kuigi ta selle peale tööd ei katkesta ning väärtustab tulemi default-iga, kuvab ta vaikimisi hoiatuse: Warning: Undefined variable $animal

Teiseks on oluline, et match-i parameeter ja väärtus millega võrreldakse ('dog', 'cat', jne.) oleks sama tüüpi. Näiteks kui võrrelda väärtuseid 1 ja '1', siis on tulemuseks default. See on sarnane PHP === võrdlusega, kus erinevaid tüüpe ei ühtlustata nagu tehakse == võrdluse puhul.

Kolmandaks PEAB valik sisaldama tõest väärtust (kasvõi default-i näol). Kui lahendit ei leita on tulemuseks: Fatal error: Uncaught UnhandledMatchError: Unhandled match value of type string in ...

Teinekord kasutavad arendajad analoogse tulemuse jaoks nimelisi massiive:

$animal = 'dog';
$voices = [
    'dog' => function() {return 'woof';},
    'cat' => function() {return 'meow';},
    'poro' => function() {return 'perkele!';}
];

echo $voices[$animal]();

Sellel on kaks eelist: esiteks nagu näha on see ilma kontrollideta veelgi lühem ja teiseks töötab see varajasemate PHP versioonidega. Samas ei toeta see default-i mis praktikas tähendab seda, et tuleb kontrollida kas sellise nimega element eksisteerib, funktsioonid deklareeritakse isegi siis kui neid ei kasutata (see ei ole probleem kui väärtuseks on skalaarmuutujad nagu int, float, string jne.) ja tüüpi ei kontrollita. Sellise lahenduse kasutamine on iseenesest samuti ok ehk siis valik tuleb teha lähtuvalt ülaltoodud piirangutest.

PHP8: create_function() eemaldati

PHP

Ma olen viimased kuu aega PHP8 sees ringi mütanud eesmärgiga aru saada mis sealt uut leiab ja kuidas sellest võimalikult palju kasu lõigata ning olen sealt leidnud päris mitu tähelepanu väärivad asjad. Püüan osadest neist paari sõnaga kirjutada.

Selle konkreetse postituse teemaks on create_function() nimeline funktsioon, õigemini selle puudumine PHP8-s. Algselt lisati see PHP4-le ning selle mõte oli tuua PHP-sse anonüümsed funktsioonid. PHP5-e viimastes versioonides muudeti see kõik juba keele osaks, kuid mingil seletamatul põhjusel jätkas suur hulk arendajaid selle funktsiooni kasutamist vaatamata sellele, et funktsiooni MITTE kasutamiseks oli päris mitu head põhjust; näiteks kasutab nõnda loodud funktsioon globaalset mälu ning seda ei ole võimalik vabastada. Kuna tegemist on jõhkra häkiga kuulutati see PHP 7.2-s eemaldamisele minevaks ning alates PHP8-st kustutati see üldse maha.

Mis omakorda tähendas seda, et kui PHP-s kirjutatud tarkvara kasutas seda funktsiooni tervitab selle kasutajat pärast uuendamist järgmine veateade: Uncaught Error: Call to undefined function create_function() in <fail>. Kuna pahatihti kasutasid seda WordPressi kujunduste ja moodulite kirjutajad tähendas see seda, et pärast PHP versiooni vahetamist loobus nii mõnigi veebisait koostööst. Eriti siis kui tegemist oli pikemat aega toiminud leheküljega ja vaatamata sellele, et platvorm ise oli viimase versiooni peal.

Õnneks on seda probleemi suhteliselt hõlbus parandada. Panen siia ülesse ühe näite. Kõigepeal näide mis PHP8-s EI tööta:

$function = create_function('$a,$b','return $a . \' \' . $b;');
echo $function('Hello', 'World!');

Ja nüüd näide mis töötab:

$function = function($a, $b) {return $a . ' ' . $b;};
echo $function('Hello', 'World!');

Nagu näha on teine näide loetavam, elegantsem ja võtab vähem ressursse. Ning selle juurutamine ei ole üldse keeruline.

Ehk on abiks.

Upgrading to Magento 1.9.4.0, PHP 7.2 compatibility problem

Magento
Magento

Magento 1.9.4.0 should support PHP 7.2 and fortunately it mostly does. However there’s an upgrade script from older Magento versions which, lets say, has room for improvements.

When your original Magento is old enough (I tested it on Magento 1.7.0.2) the process will throw following error message:

Fatal error: Uncaught Error: [] operator not supported for strings in /magento-path/app/code/core/Mage/Usa/sql/usa_setup/upgrade-1.6.0.1-1.6.0.2.php on line 93
( ! ) Error: [] operator not supported for strings in /magento-path/app/code/core/Mage/Usa/sql/usa_setup/upgrade-1.6.0.1-1.6.0.2.php on line 93

The culprit of the message above is here:

    $newValue = '';
    if (stripos($oldValue['path'], 'free_method') && isset($oldToNewMethodCodesMap[$oldValue['value']])) {
        $newValue = $oldToNewMethodCodesMap[$oldValue['value']];
    } else if (stripos($oldValue['path'], 'allowed_methods')) {
        foreach (explode(',', $oldValue['value']) as $shippingMethod) {
            if (isset($oldToNewMethodCodesMap[$shippingMethod])) {
                $newValue[] = $oldToNewMethodCodesMap[$shippingMethod];
            }
        }
        $newValue = implode($newValue, ',');
    } else {
        continue;
    }

As you can see $newValue is declared as a string and almost immediately expected to be an array (provided that conditions are right). No good. Simplest way to resolve it is to redeclare it as an array when it happens:

    $newValue = '';
    if (stripos($oldValue['path'], 'free_method') && isset($oldToNewMethodCodesMap[$oldValue['value']])) {
        $newValue = $oldToNewMethodCodesMap[$oldValue['value']];
    } else if (stripos($oldValue['path'], 'allowed_methods')) {
        $newValue = [];
        foreach (explode(',', $oldValue['value']) as $shippingMethod) {
            if (isset($oldToNewMethodCodesMap[$shippingMethod])) {
                $newValue[] = $oldToNewMethodCodesMap[$shippingMethod];
            }
        }
        $newValue = implode($newValue, ',');
    } else {
        continue;
    }

Intervjuu

Eelmise aasta lõpus tegi Andres Kütt minuga intervjuu teemal Eesti infotehnoloogiamaastiku ajalugu enne ja pärast taasiseseisvumist. See on nüüd SoundCloudis üleval ja paar korda asukohta vahetanud.

Ma soovitan asjale kõrva peale visata.

Panen siia igaks juhuks ka lingi: https://soundcloud.com/memcpy_podcast/memcpy-1-pronto/

Pages:123