6. diel - Knižnica ArrayUtils pre prácu s poľami v PHP

V minulej lekcii, Dokončenie knižnice StringUtils v PHP , sme dokončili knižnicu StringUtils, ktorá poskytovala pomocné metódy pre prácu s textovými reťazcami. Ďalšou dôležitou dátovou štruktúrou v PHP sú okrem reťazcov polia. Asi vás neprekvapí, že aj pre nich sa nájde niekoľko užitočných funkcií, ktoré si dnes zabalíme do triedy ArrayUtils.

ArrayUtils

Najprv si založíme našu triedu:

class ArrayUtils
{
}

Filtrovanie poľa podľa kľúčov

Často sa nám stáva, že potrebujeme prefiltrovať poľa tak, aby obsahovalo len niektoré kľúče. Ak používate miestnej databázový wrapper nad PDO, iste viete, že pomocou neho môžeme napr. Jednoducho vložiť nový riadok do tabuľky "uzivatel" týmto spôsobom:

$uzivatel = array(
    'jmeno' => 'Jan',
    'prijmeni' => 'Novak',
    'email' => '[email protected]',
);
Db::insert('uzivatel', $uzivatel);

Kód výška by sa mohol využiť napr. Pre nejakú registráciu. Ak odovzdáme dáta z formulára, bude síce fungovať, ale vystavujeme sa nebezpečnému riziku a to síce, že užívateľ si môže nejaká formulárové polia pridať a tá sa potom vloží do dotazu (napr. "Admin" = 1):

// Tento kód není bezpečný
Db::insert('uzivatel', $_POST);

Hodilo by sa nám poľa $ _POST prefiltrovať tak, aby obsahovalo len určitý výpočet kľúčov. Uvedený postup sa samozrejme neviaže len na pole $ _POST, ale využijeme ho aj v ďalších prípadoch.

Do triedy pridáme nasledujúce metódu:

public static function filterKeys(array $input, array $keys)
{
    return array_intersect_key($input, array_flip($keys));
}

Metóda filterKeys () prijíma v argumentoch vstupné pole a ďalej polia kľúčov, ktoré chceme ponechať. Čo sa týka kódu, pomocou array_flip () získame pole, ktoré má ako kľúče tie kľúče, ktoré chceme ponechať. Pomocou array_intersect_key () následne prevedieme prienik kľúčov dvoch polí a vrátime výsledok.

Ukážme si využitie v pôvodnom príklade, kde zabezpečíme získanie dát z $ _POST:

$klice = array('jmeno', 'prijmeni', 'email');
Db::insert('uzivatel', ArrayUtils::filterKeys($_POST, $klice));

Keď je kľúčov viac, je výhodné dať im nejaký prefix (predponu) a filtrovať podľa neho.

public static function filterKeysPrefix($prefix, array $input)
{
    $output = array();
    foreach ($input as $key => $value)
    {
        if (mb_strpos($key, $prefix) === 0)
            $output[$key] = $value;
    }
    return $output;
}

Funkcia filterKeysPrefix () prijíma prefix a vstupné polia. Vo výslednom poli zostanú len tie kľúče, ktoré začínajú reťazcom $ prefix. Kód by mal byť zrozumiteľný.

Mapovanie párov kľúč-hodnota a hodnôt

Keď vyberáme dáta z databázy, prídu nám vždy ako pole polí, napr. Takto:

Array
(
    [0] => Array
        (
            [uzivatel_id] => 1
            [jmeno] => Jan Novák
            [email] => [email protected]
        )

    [1] => Array
        (
            [uzivatel_id] => 2
            [jmeno] => Jana Nováková
            [email] => [email protected]
        )

    [2] => Array
        (
            [uzivatel_id] => 3
            [jmeno] => Josef Nový
            [email] => [email protected]
        )
)

Mapovanie párov

Teraz si predstavte, že budeme v aplikácii chcieť pridať formulár s výberom používateľa pomocou HTML selectu (popisok bude meno používateľa a hodnota odosielané na server bude jeho ID). Ak pre to použijeme nejaký formulárový framework, je veľmi pravdepodobné, že bude chcieť dáta vo formáte kľúč-hodnota:

Array
(
    [Jan Novák] => 1
    [Jana Nováková] => 2
    [Josef Nový] => 3
)

Pre mapovanie výsledku databázového dopytu na takéto asociatívne pole pridajme do našej triedy metódu mapPairs ():

public static function mapPairs(array $rows, $keyKey, $valueKey)
{
    $pairs = array();
    foreach ($rows as $row)
    {
        $key = $row[$keyKey];
        // Kontrola kolizí klíče
        if (isset($pairs[$key]))
        {
            $i = 1;
            while (isset($pairs[$key . ' (' . $i . ')']))
            {
                $i++;
            }
            $key .= ' (' . $i . ')';
        }
        $pairs[$key] = $row[$valueKey];
    }
    return $pairs;
}

Metóde odovzdáme poľa a potom 2 názvy kľúčov. Prvý kľúč sa stane vo výslednom poli kľúčom a druhý hodnotou.

Vyššie spomenuté polia teda získame týmto spôsobom:

$uzivatele = Db::queryAll('SELECT jmeno, uzivatel_id FROM uzivatel');
$polozky = ArrayUtils::mapPairs($uzivatele, 'jmeno', 'uzivatel_id');

Všimnite si, že metóda rieši aj prípad, keď sa 2 užívatelia volajú rovnako. V takom prípade začne položky číslovať.

Mapovanie hodnôt

Podobne budeme občas potrebovať získať pole nejakých hodnôt, napr. Emailov všetkých používateľov, ktorým pošleme newsletter. Budeme chcieť získať nasledujúce polia:

Array
(
    [0] => [email protected]
    [1] => [email protected]
    [2] => [email protected]
)

Metóda mapSingles () nie je nijako zložitá:

public static function mapSingles(array $rows, $singleKey)
{
    $singles = array();
    foreach ($rows as $row)
    {
        $singles[] = $row[$singleKey];
    }
    return $singles;
}

A použitia:

$emaily = ArrayUtils::mapSingles(Db::queryAll('SELECT email FROM uzivatel'), 'email');

V budúcej lekcii, Dokončenie knižnice ArrayUtils v PHP , sa zameriame na prácu s prefixy, konverziu notáciou a prevod polia do XML a naopak. Knižnicu tým dokončíme.