PHP tömbfüggvények

Háromféle tömb létezik:
1. Indexelt tömbök – Numerikus (Számozott) indexű tömbök.
2. Asszociatív tömbök – String (Betű vagy szó) kulcsokkal rendelkező tömbök.
3. Többdimenziós tömbök – egy vagy több tömböt tartalmazó tömbök.

Számokkal indexelt tömbelemek:
<?php
$auto=array("Volvo","BMW","Toyota");

// Létrehozható így is:
  $auto[0]="Volvo";
  $auto[1]="BNW";
  $auto[2]="Toyota";

echo "Tömb tartalma:<br> " . $auto[0] . ", " . $auto[1] . ", " . $auto[2] . ".";
?>

Eredmény:
Tömb tartalma:
Volvo, BMW, Toyota.

---

Asszociatív tömb: (Indexelés, ékezet nélküli betűvel vagy szavakkal.)
<?php
$eletkor=array("Peter"=>"35","Feri"=>"37","Jani"=>"43");

// Létrehozható így is:
  $eletkor["Peter"]=35;
  $eletkor["Feri"]=37;
  $eletkor["Jani"]=43;
  
echo "Peter életkora = " . $eletkor['Peter'] . " éves.";
?>

Eredmény:
Peter életkora = 35 éves.

Nagybetűre módosítsa, a összes  tömbelem kulcsát,  (CASE_UPPER):
<?php
$korok=array("eva"=>"35","adam"=>"37","bela"=>"55","janos"=>"43");
$korok=array_change_key_case($korok,CASE_UPPER);     // Módosítás nagybetűre.
        echo'<pre>';
                print_r($korok);
        echo'</pre>';
// Kulcsok nagybetűre módosúltak, lekérdezésnél is, nagybetűvel kérdezhetjük le.
echo '<p>Egyedi lekérdezések, nagybetűvel:<br>';
echo '$korok["EVA"] = ' .$korok["EVA"]. '<br>';
echo '$korok["ADAM"] = ' .$korok["ADAM"]. '<br>';
echo '</p>';
?>

Eredmény:

Array
(
    [EVA] => 35
    [ADAM] => 37
    [BELA] => 55
    [JANOS] => 43
)

Egyedi lekérdezések, nagybetűvel:
$korok["EVA"] = 35
$korok["ADAM"] = 37

---

Kisbetűre módosítsa, az összes tömbelem kulcsát, (CASE_LOWER):

<?php
$korok=array("EVA"=>"35","ADAM"=>"37","BELA"=>"55","JANOS"=>"43");
$korok=array_change_key_case($korok,CASE_LOWER);     // Módosítás kisbetűre.
        echo'<pre>';
             print_r($korok);
        echo'</pre>';
// Kulcsok kisbetűre módosúltak, lekérdezésnél is, kisbetűvel kérdezhetjük le.
echo '<p>Egyedi lekérdezések, kisbetűvel:<br>';
echo '$korok["eva"] = '.$korok["eva"].'<br>';
echo '$korok["adam"] = '.$korok["adam"].'<br>';
?>

Eredmény:

Array
(
    [eva] => 35
    [adam] => 37
    [bela] => 55
    [janos] => 43
)

Egyedi lekérdezések, kisbetűvel:
$korok["eva"] = 35
$korok["adam"] = 37

Egy tömb felosztása két, azaz, kettes részekre:
<?php
$jarmuvek=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
$felosztas2=array_chunk($jarmuvek,2);
        echo'<pre>';
                print_r($felosztas2);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => Array
        (
            [0] => Volvo
            [1] => BMW
        )

    [1] => Array
        (
            [0] => Toyota
            [1] => Honda
        )

    [2] => Array
        (
            [0] => Mercedes
            [1] => Opel
        )

)

---

Osszon fel egy tömböt három részre, és őrizze meg az eredeti kulcsokat:
<?php
$jarmuvek=array("Volvo","BMW","Toyota","Honda","Mercedes","Opel");
$felosztas3=array_chunk($jarmuvek,3,true);
echo'<pre>';
       print_r($felosztas3);
echo'</pre>';
?>

Eredmény:

Array
(
    [0] => Array
        (
            [0] => Volvo
            [1] => BMW
            [2] => Toyota
        )

    [1] => Array
        (
            [3] => Honda
            [4] => Mercedes
            [5] => Opel
        )

)

Egy adatbázisból visszaadott lehetséges rekordhalmazt reprezentáló tömb.
<?php
$a = array(
  array(
    'id' => 5698,
    'first_name' => 'Peter',
    'last_name' => 'Jakab',
  ),
  array(
    'id' => 4767,
    'first_name' => 'Pál',
    'last_name' => 'Smith',
  ),
  array(
    'id' => 3809,
    'first_name' => 'János',
    'last_name' => 'Kovács',
  )
);

$last_names = array_column($a, 'last_name');
        echo'<pre>';
                   print_r($last_names);
        echo'</pre>';
?>

Eredmény:

Array
(
  [0] => Jakab
  [1] => Smith
  [2] => Kovács
)

Hozzon létre egy tömböt egy "keys" tömb és egy "values" tömb elemeinek felhasználásával:
<?php
$fname=array("Peter","Feri","Jani");     // keys, azaz, kulcsok.
$age=array("35","37","43");                   // values, azaz, adatok, értékek.
         $combi=array_combine($fname,$age);
    echo'<pre>';
           print_r($combi);
    echo'</pre>';
?>

Eredmény:

Array
(
    [Peter] => 35
    [Feri] => 37
    [Jani] => 43
)

Számolja meg egy tömb, összes kulcsának előfordulását:
<?php
$a=array("A","Cat","Dog","A","Dog","é","É");
            $kulcsokszama = array_count_values($a);
        echo'<pre>';
                print_r($kulcsokszama);
        echo'</pre>';
?>

Eredmény:

Array
(
    [A] => 2
    [Cat] => 1
    [Dog] => 2
    [é] => 1
    [É] => 1
)

Hasonlítsa össze két tömb értékét , és adja vissza a különbségeket,
Összehasonlítás: 1-es tömb a 2-es tömbbel.
Van olyan az 1-es tömbben, mely nincs a 2-es tömbben?
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue","h"=>"black");
            $difftomb1=array_diff($a1,$a2);
        echo'<pre>';
             print_r($difftomb1);
        echo'</pre>';
?>

Eredmény:

Array
(
    [d] => yellow
)

---

2. Példa: 2-es tömb az 1-es tömbbel:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("e"=>"red","f"=>"green","g"=>"blue","h"=>"black");
               $difftomb2=array_diff($a2,$a1);
        echo'<pre>';
               print_r($difftomb2);
        echo'</pre>';
?>

Eredmény:

Array
(
    [h] => black
)

---

3. Példa: Hasonlítsa össze három tömb értékét , és adja vissza a különbségeket:
<?php
$a1=array("a"=>"piros","b"=>"zöld","c"=>"kék","d"=>"sárga");
$a2=array("e"=>"piros","f"=>"fekete","g"=>"lila");
$a3=array("a"=>"piros","b"=>"fekete","h"=>"sárga");
             $diff3tomb=array_diff($a1,$a2,$a3);
        echo'<pre>';
             print_r($diff3tomb);
        echo'</pre>';
?>

Eredmény:

Array
(
    [b] => zöld
    [c] => kék
)

Hasonlítsa össze két tömb kulcsait és értékeit , és adja vissza a különbségeket:
<?php
$a1=array("a"=>"piros","b"=>"zöld","c"=>"kék","d"=>"sárga");
$a2=array("a"=>"piros","b"=>"zöld","c"=>"kék");
             $keyvalue=array_diff_assoc($a1,$a2);
        echo'<pre>';
               print_r($keyvalue);
        echo'</pre>';
?>

Eredmény:

Array
(
    [d] => sárga
)

---

Hasonlítsa össze három tömb kulcsait és értékeit , és adja vissza a különbségeket:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow","e"=>"white");
$a2=array("a"=>"red","f"=>"green","g"=>"blue","d"=>"black");
$a3=array("h"=>"red","b"=>"green","g"=>"blue");
               $keyvalue3=array_diff_assoc($a1,$a2,$a3);
        echo'<pre>';
            print_r($keyvalue3);
        echo'</pre>';
?>

Eredmény:

Array
(
    [c] => blue
    [d] => yellow
    [e] => white
)

Hasonlítsa össze két tömb kulcsait , és adja vissza a különbségeket:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
         $diffkey = array_diff_key($a1,$a2);
        echo'<pre>';
                print_r($diffkey);
        echo'</pre>';
?>

Eredmény:

Array
(
    [b] => green
)

Hasonlítsa össze két tömb kulcsait és értékeit (használjon egy felhasználó által definiált
 függvényt a kulcsok összehasonlításához), és adja vissza a különbségeket:
<?php
function sajatfunction($a,$b)
 {  
      if ($a===$b) { return 0; }
         return ($a>$b)?1:-1;
 }

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("d"=>"red","b"=>"green","e"=>"blue");
         $result=array_diff_uassoc($a1,$a2,"sajatfunction");
           // Három tömb esetén:
                 // $result=array_diff_uassoc($a1,$a2,$a3,"sajatfunction");
echo'<pre>';
          print_r($result);
echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [c] => blue
)

Hasonlítsa össze két tömb kulcsait (egy felhasználó által definiált kulcs-összehasonlító
 függvény segítségével), és adja vissza a különbségeket:
<?php
function diffukey_function($a,$b)
{
   if ($a===$b) {  return 0;  }
      return ($a>$b)?1:-1;
}

$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"blue","b"=>"black","e"=>"blue");
             $diffukeytomb=array_diff_ukey($a1,$a2,"diffukey_function");
        echo'<pre>';
              print_r($diffukeytomb);
        echo'</pre>';
?>

Eredmény:

Array
(
    [c] => blue
)

Egy tömb kitöltése értékekkel:
<?php
$tomb=array_fill(3,4,"kék");
echo'<pre>';
          print_r($tomb);
echo'</pre>';
?>

Eredmény:

Array
(
    [3] => kék
    [4] => kék
    [5] => kék
    [6] => kék
)

Töltsön meg egy tömböt értékekkel a kulcsok megadásával:
<?php
$keys=array("a","b","c","d");       // Tömbelemek kulcsai, indexei.
$tomb=array_fill_keys($keys,"piros");    // Betöltési érték = piros.
echo'<pre>';
          print_r($tomb);
echo'</pre>';
?>

Eredmény:

Array
(
    [a] => piros
    [b] => piros
    [c] => piros
    [d] => piros
)

Egy tömb értékeinek szűrése, visszahívási függvény segítségével.
Páratlanok kiszűrése:
<?php
function teszt_paratlan($var)
  {
  return($var & 1);
  }

$a1=array(1,3,2,3,4,5,6);
            $filter1=array_filter($a1,"teszt_paratlan");
        echo'<pre>';
              print_r($filter1);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => 1
    [1] => 3
    [3] => 3
    [5] => 5
)

Fordítsa meg az összes kulcsot, a hozzájuk tartozó értékekkel egy tömbben.
   Az elm adata lesz, az indexe.    Az elm indexe lesz, az adata.
<?php
$atomb=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
          $flips = array_flip($atomb);
        echo'<pre>';
                print_r($flips);
        echo'</pre>';
?>

Eredmény:

Array
(
    [red] => a
    [green] => b
    [blue] => c
    [yellow] => d
)

Hasonlítsa össze két tömb értékét, és adja vissza $tomb1 adataival egyezőket:
<?php
$tomb1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$tomb2=array("e"=>"red","f"=>"green","g"=>"blue");
            $tomb_intersect=array_intersect($tomb1,$tomb2);
        echo'<pre>';
                   print_r($tomb_intersect);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [b] => green
    [c] => blue
)

---

Hasonlítsa össze három tömb értékét, és adja vissza $tomb1 adataival egyezőket:
<?php
$tomb1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$tomb2=array("e"=>"red","f"=>"black","g"=>"purple");
$tomb3=array("a"=>"red","b"=>"black","h"=>"yellow");
             $intersect3=array_intersect($tomb1,$tomb2,$tomb3);
        echo'<pre>';
                  print_r($intersect3);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
)

Hasonlítsa össze két tömb kulcsait és értékeit , és adja vissza $a1-el való egyezéseket:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","c"=>"blue");
             $keyvalue=array_intersect_assoc($a1,$a2);
        echo'<pre>';
                  print_r($keyvalue);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [b] => green
    [c] => blue
)

---

Hasonlítsa össze három tömb kulcsait és értékeit , és adja vissza $a1-el való egyezéseket:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
$a2=array("a"=>"red","b"=>"green","g"=>"blue");
$a3=array("a"=>"red","b"=>"green","g"=>"blue");
              $keyvalue3=array_intersect_assoc($a1,$a2,$a3);
        echo'<pre>';
                  print_r($keyvalue3);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [b] => green
)

Hasonlítsa össze két tömb kulcsait , és adja vissza az egyezéseket:
<?php
$a1=array("a"=>"red","b"=>"green","c"=>"blue");
$a2=array("a"=>"red","c"=>"blue","d"=>"pink");
          $intersectkey=array_intersect_key($a1,$a2);
        echo'<pre>';
                    print_r($intersectkey);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [c] => blue
)

Hasonlítsa össze két tömb kulcsait és értékeit , és adja vissza az egyezéseket
 (a felhasználó által definiált kulcs-összehasonlító függvény segítségével):
<?php
function ItUa_function($a,$b)
{
  if ($a===$b) { return 0; }
     return ($a>$b)?1:-1;
}

$a1tomb=array("a"=>"red","b"=>"green","c"=>"blue");
$a2tomb=array("d"=>"red","b"=>"green","e"=>"blue");
              $tombkeyvalue=array_intersect_uassoc($a1tomb,$a2tomb,"ItUa_function");
        echo'<pre>';
                   print_r($tombkeyvalue);
        echo'</pre>';
?>

Eredmény:

Array
(
    [b] => green
)

Hasonlítsa össze két tömb kulcsait (egy felhasználó által definiált kulcs-összehasonlító 
függvény segítségével), és adja vissza az egyezéseket:
<?php
function ItUk_function($a,$b)
{
  if ($a===$b) { return 0; }
    return ($a>$b)?1:-1;
}

$tomb1=array("a"=>"red","b"=>"green","c"=>"blue");
$tomb2=array("a"=>"blue","b"=>"black","e"=>"blue");
            $ukeyintersect=array_intersect_ukey($tomb1,$tomb2,"ItUk_function");
        echo'<pre>';
                 print_r($ukeyintersect);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => red
    [b] => green
)

Ellenőrizze, hogy a "Volvo" kulcs létezik-e egy tömbben:
<?php
$ax=array("Volvo"=>"XC90","BMW"=>"X5");

   if (array_key_exists("Volvo",$ax))  {  echo "A keresett kulcs, létezik!";  }
    else { echo "A keresett kulcs, nem létezik!";  }
?>

Eredmény:

A keresett kulcs, létezik!

A kulcsokat tartalmazó tömbből, kulcsok visszaadása:
<?php
$ab=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
           $kulcsok=array_keys($ab);
        echo'<pre>';
                    print_r($kulcsok);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => Volvo
    [1] => BMW
    [2] => Toyota
)

Küldje el egy tömb minden értékét egy függvénynek,
    szorozza meg mindegyik értéket önmagával,
    és adjon vissza egy tömböt, az új értékekkel:
<?php
function Szor_function($v)
{
  return($v*$v);       // Lehet:  *    /     +     -   
               // Továbbá lehet: Bármelyik Matematikai függvény.
                       // return(sqrt($v));    //  Négyzetgyök.
}

$asz=array(1,2,3,4,5);
            $Ujtomb = array_map("Szor_function",$asz);
        echo'<pre>';
                 print_r($Ujtomb);
        echo'</pre>';
?>

Eredmény:

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

Két tömb összevonása, egy tömbbe:
<?php
$xa1=array("red","green");
$xa2=array("red","blue","yellow");
             $merge = array_merge($xa1,$xa2);
        echo'<pre>';
                print_r($merge);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => red
    [1] => green
    [2] => red
    [3] => blue
    [4] => yellow
)

Két tömb összevonása, egy tömbbe:
<?php
$ra1=array("a"=>"red","b"=>"green");
$ra2=array("a"=>"blue","c"=>"blue","b"=>"yellow");
            $recursivmerge = array_merge_recursive($ra1,$ra2);
        echo'<pre>';
                 print_r($recursivmerge);
        echo'</pre>';
?>

Eredmény:

Array
(
    [a] => Array
        (
            [0] => red
            [1] => blue
        )

    [b] => Array
        (
            [0] => green
            [1] => yellow
        )

    [c] => blue
)

Rendezett tömb visszaadása, növekvő abc sorrendben:
<?php
$ma=array("Kutya","Cica","Lo","Medve","Zebra");
               array_multisort($ma);
        echo'<pre>';
                 print_r($ma);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => Cica
    [1] => Kutya
    [2] => Lo
    [3] => Medve
    [4] => Zebra
)

---

Egyesítsen két tömböt, és rendezze őket számokként, csökkenő sorrendben:
<?php
$ma1=array(1,30,15,7,25);
$ma2=array(4,30,20,41,66);
        $num=array_merge($ma1,$ma2);                               // Egyesítés.
array_multisort($num,SORT_DESC,SORT_NUMERIC);   // Rendezés.
echo'<pre>';
           print_r($num);
echo'</pre>';
?>

Eredmény:

Array
(
    [0] => 66
    [1] => 41
    [2] => 30
    [3] => 30
    [4] => 25
    [5] => 20
    [6] => 15
    [7] => 7
    [8] => 4
    [9] => 1
)

Adjon vissza 5 elemet, és szúrjon be egy "kék" értéket a tömb új elemeihez:
<?php
$color=array("piros","zöld");
            $color=array_pad($color,5,"kék");
        echo'<pre>';
                 print_r($color);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => piros
    [1] => zöld
    [2] => kék
    [3] => kék
    [4] => kék
)

Törölje a tömb utolsó elemét:
<?php
$szinek=array("piros","zöld","kék");
           array_pop($szinek);
        echo'<pre>';
                  print_r($szinek);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => piros
    [1] => zöld
)

Számítsa ki és adja vissza egy tömb szorzatát:
<?php
$as=array(5,5);
       $szorzat = array_product($as);
  echo 'Szorzat eredménye = '.$szorzat;
?>

Eredmény:

Szorzat eredménye = 25

Szúrja be a "kék" és a "sárga" szót a tömb végére:
<?php
$szin=array("piros","zöld");
              array_push($szin,"kék","sárga");
        echo'<pre>';
                print_r($szin);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => piros
    [1] => zöld
    [2] => kék
    [3] => sárga
)

Három (3) véletlenszerű kulcsok, tömbjének visszaadása:
<?php
$va=array("piros","zöld","kék","sárga","barna");
                  $veletlen=array_rand($va,3);
echo $va[$veletlen[0]]."<br>";
echo $va[$veletlen[1]]."<br>";
echo $va[$veletlen[2]];
?>

Eredmény:

piros
sárga
barna

Küldje el az értékeket egy tömbben, egy felhasználó által definiált függvénynek,
     és adjon vissza egy karakterláncot:
<?php
function Reduce_function($v1,$v2)  { return $v1 . " - " . $v2;  }
$rt=array("Kutya","Cica","Ló");
              $karakterlanc = array_reduce($rt,"Reduce_function");
        echo'<pre>';
           print_r($karakterlanc);
        echo'</pre>';
?>

Eredmény:

 - Kutya - Cica - Ló

---

A kezdeti paraméterrel:
<?php
function Kp_function($v1,$v2)   { return $v1 . "-" . $v2; }
$ka=array("Kutya","Cica","Ló");
         $stringkp = array_reduce($ka,"Kp_function",5);
     print_r($stringkp);
?>

Eredmény:

5-Kutya-Cica-Ló

---

Egy összeg visszaadása, kezdeti paraméterrel:
<?php
function Kpo_function($v1,$v2)   { return $v1+$v2;  }
$voa=array(10,15,20);
           $osszegkp = array_reduce($voa,"Kpo_function",5);
     print_r($osszegkp);
                 // Kezdeti érték = 5;   Eredmény = 5+10+15+20
?>

Eredmény:

50

Cserélje le az elsőnek megadott tömb ($ta1) értékeit,
       a másodiknak megadott tömb ($ta2) értékeire:
<?php
$ta1=array("piros","zöld");
$ta2=array("kék","sárga");
               $ta1=array_replace($ta1,$ta2);       //  Elsőt lecseréli, a másodikra.
               // $ta2=array_replace($ta2,$ta1);     // Másodikat lecseréli, az elsőre.
        echo'<pre>';
              print_r($ta1);
        echo'</pre>';
?>

Eredmény:

Array
(
    [0] => kék
    [1] => sárga
)

---

Három tömb használatával,
        az utolsó tömb ($fa3) felülírja az előzőeket ($fa1 és $fa2):
<?php
$fa1=array("piros","zöld");
$fa2=array("kék","sárga");
$fa3=array("fekete","barna");
echo'<pre>';
          print_r(array_replace($fa1,$fa2,$fa3));
echo'</pre>';
?>

Eredmény:

Array
(
    [0] => fekete
    [1] => barna
)

---

Numerikus kulcsok használata,
    – Ha a kulcs a num2-ben létezik, és a num1-ben nem:
<?php
$num1=array("piros","zöld","kék","sárga");       // Kulcsok:   0;    1;    2;    3;
$num2=array(0=>"lila",3=>"barna");                  // Kulcsok:   0;    3;
echo'<pre>';
          print_r(array_replace($num1,$num2));
echo'</pre>';
?>

Eredmény:

Array
(
    [0] => lila
    [1] => zöld
    [2] => kék
    [3] => barna
)

Cserélje le az első tömb értékeit a második tömb értékeire rekurzív módon:
<?php
$rep1=array("a"=>array("piros"),"b"=>array("zöld","kék") , );
$rep2=array("a"=>array("sárga"),"b"=>array("fekete"));
echo'<pre>';
          print_r(array_replace_recursive($rep1,$rep2));
echo'</pre>';
?>

Eredmény:

Array
(
    [a] => Array
        (
            [0] => sárga
        )

    [b] => Array
        (
            [0] => fekete
            [1] => kék
        )

)

<?php
$autok=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
               $forditva = array_reverse($autok);
        echo '<pre>Fordítva:<br>';
                      print_r($forditva);
        echo 'Eredeti tömb:<br>';
                      print_r($autok);
        echo '</pre>';
?>

Eredmény:

Fordítva, eredeti indexekkel:
Array
(
    [c] => Toyota
    [b] => BMW
    [a] => Volvo
)
Eredeti tömb:
Array
(
    [a] => Volvo
    [b] => BMW
    [c] => Toyota
)

1. Keresse egy tömbben, a "piros" értéket, és adja vissza a kulcsát:
2. Keresse egy tömbben, az 5-ös értéket,(nem stringet), 
                  és adja vissza a kulcsát (figyelje meg, a "" jelet):

<?php
$szinek=array("a"=>"piros","b"=>"zöld","c"=>"kék","d"=>"red");
          echo 'Színeknél a kulcs = '.array_search("piros",$szinek);
echo'<br>';
$szamok=array("a"=>"5","b"=>5,"c"=>"5");
          echo 'Számoknál a kulcs = '.array_search(5,$szamok,true);
?>

Eredmény:
Színeknél a piros kulcsa = a
Számoknál az 5-ös kulcsa = b

Távolítsa el az első elemet (piros) a tömbből, és adja vissza az eltávolított elem értékét:
<?php
$sh=array("a"=>"piros","b"=>"zöld","c"=>"kék");
       echo 'Eltávolított = '.array_shift($sh);
       echo '<pre> Maradt:<br>';
                        print_r ($sh);
       echo '</pre>';
?>

Eredmény:

Tömbből eltávolított = piros

Tömbben maradt:
Array
(
    [b] => zöld
    [c] => kék
)

---

Számozott elemidexek használatakor. 
Távolítsa el az első elemet (piros) a tömbből,
             és adja vissza az eltávolított elem értékét:
<?php
$sz=array(0=>"piros",1=>"zöld",2=>"kék");           // Sorszámozott elemek.  0;   1;   2;
         echo 'Tömbből eltávolított = '.array_shift($sz);
         echo '<pre> Tömbben maradt:';
                            print_r ($sz);
         echo '</pre>';
?>

Eredmény:

Tömbből eltávolított = piros

Tömbben maradtak, de indexük megváltozott:
Array
(
    [0] => zöld
    [1] => kék
)

Indítsa el a szeletet a második tömbelem után,
       és adja vissza a tömb, többi elemét, új indexeléssel:
<?php
$szet=array("piros","zöld","kék","sárga","barna");    // Kulcsok:  0;   1;   2;   3;   4;
           $valasztottak = array_slice($szet,2);
        echo '<pre>Kiválasztott elemek:<br>';
                     print_r($valasztottak);
        echo 'Eredeti tömb tartalma:<br>';
                     print_r($szet);
        echo '</pre>';
?>

Eredmény:

Kiválasztott elemek:
Array
(
    [0] => kék
    [1] => sárga
    [2] => barna
)
Eredeti tömb tartalma:
Array
(
    [0] => piros
    [1] => zöld
    [2] => kék
    [3] => sárga
    [4] => barna
)

---

Indítsa el a szeletet a második tömbelemtől, és csak két elemet ad vissza:
<?php
$xy=array("piros","zöld","kék","sárga","barna");    // Kulcsok:  0;   1;   2;   3;   4;
             $valasztott = array_slice($xy,1,2);  
        echo '<pre>';
             print_r($valasztott);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => zöld
    [1] => kék
)

Távolítson el elemeket egy tömbből, és cserélje ki új elemekkel,
         az új elemek, számozott indexelést kapnak:
<?php
$x1=array("a"=>"piros","b"=>"zöld","c"=>"kék","d"=>"sárga");
$x2=array("a"=>"lila","b"=>"narancs","c"=>"keki");
              array_splice($x1,0,2,$x2);
        echo '<pre>';
                 print_r($x1);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => lila
    [1] => narancs
    [2] => keki
    [c] => kék
    [d] => sárga
)

<?php
$sum=array(5,15,25);
echo array_sum($sum);
?>

Eredmény:
45

Hasonlítsa össze két tömb értékeit (használjon egy felhasználó által definiált függvényt
 az értékek összehasonlításához), és adja vissza a különbségeket:
 ( Első tömbben létezők közül, melyek nem léteznek a második tömbben.)
<?php
function H2t_function($a,$b)
{
  if ($a===$b) { return 0; }
    return ($a>$b)?1:-1;
}

$a1=array("a"=>"piros","b"=>"zöld","c"=>"kék");
$a2=array("a"=>"kék","b"=>"fekete","e"=>"kék");
             $elteres=array_udiff($a1,$a2,"H2t_function");
        echo '<pre>Második tömbben, nincs:<br>';
                     print_r($elteres);
        echo '</pre>';
?>

Eredmény:

Második tömbben, nincs:
Array
(
    [a] => piros
    [b] => zöld
)

---

Hasonlítsa össze három tömb értékeit:
 ( Első tömbben létezők közül, melyek nem léteznek a második és harmadik tömbben.)
<?php
function H3t_function($a,$b)
{
   if ($a===$b) { return 0; }
     return ($a>$b)?1:-1;
}
    $a1=array("a"=>"piros","b"=>"zöld","c"=>"kék","sárga");
    $a2=array("A"=>"piros","b"=>"ZÖLD","sárga","fekete");
    $a3=array("a"=>"zöld","b"=>"piros","sárga","fekete");
            $elteres3nal=array_udiff($a1,$a2,$a3,"H3t_function");
        echo '<pre>';
               print_r($elteres3nal);
        echo '</pre>';
?>

Eredmény:

Array
(
    [c] => kék
)

Hasonlítsa össze két tömb kulcsait és értékeit, és adja vissza a különbségeket:
<?php
function udifasc_function($a,$b)
{
   if ($a===$b) { return 0; }
    return ($a>$b)?1:-1;
}
  $a1=array("a"=>"piros","b"=>"zöld","c"=>"kek");
  $a2=array("a"=>"piros","b"=>"kék","c"=>"zöld");
               $keyval_elteres=array_udiff_assoc($a1,$a2,"udifasc_function");
         echo '<pre>';
                  print_r($keyval_elteres);
         echo '</pre>';
?>

Eredmény:

Array
(
    [b] => zöld
    [c] => kek
)

Hasonlítsa össze két tömb kulcsait és értékeit,(két függvényt használva)
   és adja vissza a különbségeket:
<?php
function myfunction_key($a,$b)
{
   if ($a===$b) { return 0; }
    return ($a>$b)?1:-1;
}

function myfunction_value($a,$b)
{
   if ($a===$b) { return 0; }
     return ($a>$b)?1:-1;
}

$a1=array("a"=>"piros","b"=>"zöld","c"=>"kék");
$a2=array("a"=>"piros","b"=>"zöld","c"=>"zöld");
          $kettonelkv=array_udiff_uassoc($a1,$a2,"myfunction_value","myfunction_key");
        echo '<pre>';
          print_r($kettonelkv);
        echo '</pre>';
?>

Eredmény:

Array
(
    [c] => kék
)

Hasonlítsa össze két tömb értékét, és adja vissza az egyezéseket:
<?php
function uinter_function($a,$b)
{
  if ($a===$b)  { return 0; }
    return ($a>$b)?1:-1;
}

$ui1=array("a"=>"piros","b"=>"zöld","c"=>"kék");
$ui2=array("a"=>"kék","b"=>"fekete","e"=>"kék");
           $adategyezes=array_uintersect($ui1,$ui2,"uinter_function");
        echo '<pre>';
                print_r($adategyezes);
        echo '</pre>';
?>

Eredmény:

Array
(
    [c] => kék
)

Hasonlítsa össze két tömb kulcsait és értékeit, és adja vissza az egyezéseket:
<?php
function uiassoc_function($a,$b)
{
    if ($a===$b) { return 0; }
      return ($a>$b)?1:-1;
}
  $a1=array("a"=>"piros","b"=>"zöld","c"=>"kék");
  $a2=array("a"=>"piros","b"=>"kék","c"=>"zöld");
           $key_adat=array_uintersect_assoc($a1,$a2,"uiassoc_function");
        echo '<pre>Egyezés:<br>';
                    print_r($key_adat);
        echo '</pre>';
?>

Eredmény:

Egyezés:
Array
(
    [a] => piros
)

Hasonlítsa össze két tömb kulcsait és értékeit (kettő függvényt használva), 
   és adja vissza az egyezéseket:
<?php
function myfunction_adat($a,$b) {
  if ($a===$b) { return 0; }
  return ($a>$b)?1:-1;
}
function myfunction_kulcs($a,$b) {
  if ($a===$b) { return 0; }
  return ($a>$b)?1:-1;
}
  $a1=array("a"=>"piros","b"=>"zöld","c"=>"kék");
  $a2=array("a"=>"piros","b"=>"zöld","c"=>"zöld");
          $adat_key=array_uintersect_uassoc($a1,$a2,"myfunction_adat","myfunction_kulcs");
        echo '<pre>Egyezések:<br>';
                        print_r($adat_key);
        echo '</pre>';
?>

Eredmény:

Egyezések:
Array
(
    [a] => piros
    [b] => zöld
)

Az ismétlődő értékek eltávolítása egy tömbből:
<?php
$adatok=array("a"=>"piros","b"=>"zöld","c"=>"piros");
               $maradt_adatok=array_unique($adatok);
         echo '<pre>Maradt adatok:<br>';
                          print_r($maradt_adatok);
         echo '</pre>';
?>

Eredmény:

Maradt adatok:
Array
(
    [a] => piros
    [b] => zöld
)

Illessze be a  "kék"  és  "fehér"  elemet, egy tömbbe:
<?php
$ue=array("a"=>"piros","b"=>"zöld");
             array_unshift($ue,"kék","fehér");
        echo '<pre>';
                   print_r($ue);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => kék
    [1] => fehér
    [a] => piros
    [b] => zöld
)

---

A számozott indexű elemk használatánál:
<?php
$usz=array(0=>"piros",1=>"zöld");
           array_unshift($usz,"kék","fehér");
echo '<pre>';
          print_r($usz);
echo '</pre>';
?>

Eredmény:

Array
(
    [0] => kék
    [1] => fehér
    [2] => piros
    [3] => zöld
)

Egy tömb összes értékét adja vissza (nem a kulcsokat):
<?php
$adat=array("Neve"=>"Péter","Kora"=>"41","Ország"=>"HU");
               $tombadatok=array_values($adat);
        echo '<pre>';
                      print_r($tombadatok);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => Péter
    [1] => 41
    [2] => HU
)

Futtassa az egyes tömbelemeket egy felhasználó által meghatározott függvényben,
                 és adja vissza a tömb tartalmát:
<?php
function elemek_function($value,$key)
{  echo $key. ' = ' .$value.'<br>';  }

$te=array("a"=>"red","b"=>"green","c"=>"blue");
     array_walk($te,"elemek_function");
?>

Eredmény:

a = red
b = green
c = blue

Futtassa az egyes tömbelemeket egy felhasználó által meghatározott függvényben,
            és adja vissza a tömbök tartalmát:
<?php
function Rekurziv_function($value,$key)
{ echo $key. ' = ' .$value.'<br>'; }

$f1=array("a"=>"red","b"=>"green");
$f2=array($f1,"1"=>"blue","2"=>"yellow");       // Tömbön belüli tömb.  ( Összevonás. )
       array_walk_recursive($f2,"Rekurziv_function");
?>

Eredmény:

a = red
b = green
1 = blue
2 = yellow

Csökkenő sorrendbe rendezzen egy asszociatív tömböt, az érték szerint:
<?php
$eletkorok=array("Péter"=>"35","Bence"=>"37","János"=>"43");
             arsort($eletkorok);
         echo '<pre>';
                     print_r($eletkorok);
         echo '</pre>';
?>

Eredmény:

Array
(
    [János] => 43
    [Bence] => 37
    [Péter] => 35
)

Növekvő sorrendbe rendezzen egy asszociatív tömböt, az érték szerint:
<?php
$kor2=array("Péter"=>"35","Bence"=>"37","János"=>"43");
          asort($kor2);
echo '<pre>';
      print_r($kor2);
echo '</pre>';
?>

Eredmény:

Array
(
    [Péter] => 35
    [Bence] => 37
    [János] => 43
)

Hozzon létre egy tömböt, a változókból és értékeikből:
<?php
$firstname = "Péter";
$lastname = "Gurubi";
$kora = "41";
               $vtomb = compact("firstname", "lastname", "kora");
        echo '<pre>';
                  print_r($vtomb);
        echo '</pre>';
?>

Eredmény:

Array
(
    [firstname] => Péter
    [lastname] => Gurubi
    [kora] => 41
)

Egy tömb elemeinek számát adja vissza:
<?php
$jarmuvek=array("Volvo","BMW","Toyota");
       echo 'Elemek száma = '.count($jarmuvek);
?>

Eredmény:

Elemek száma = 3

---

Számolja meg a tömböt rekurzívan:
<?php
$tcars=array
  (
  "Volvo"=>array
  (
  "XC60",
  "XC90"
  ),
  "BMW"=>array
  (
  "X3",
  "X5"
  ),
  "Toyota"=>array
  (
  "Highlander"
  )
  );

echo "Normal count: " . count($tcars)."<br>";
echo "Recursive count: " . count($tcars,1);
?>

Eredmény:

Normal count: 3
Recursive count: 8

Adja ki a jelenlegi, azaz, aktuális elem értékét egy tömbből:
<?php
$dolgozok = array("Péter", "Jani", "Gábor", "Ferenc");
           echo current($dolgozok) . "<br>";
?>

Eredmény:

Péter

---

Az összes kapcsolódó módszer bemutatása:
<?php
$dolgozok2 = array("Péter", "Jani", "Gábor", "Ferenc");

echo "current = ".current($dolgozok2) . "<br>"; // A jelenlegi elem, Péter
echo "next = ".next($dolgozok2) . "<br>";          // Péter következő eleme, Jani
echo "current = ".current($dolgozok2) . "<br>"; // Most az aktuális elem, Jani
echo "prev = ".prev($dolgozok2) . "<br>";         // Jani előző eleme, Peter
echo "end = ".end($dolgozok2) . "<br>";            // Az utolsó elem, Ferenc
echo "prev = ".prev($dolgozok2) . "<br>";         // Ferenc előző eleme, Gábor
echo "current = ".current($dolgozok2) . "<br>";  // Most a jelenlegi elem, Gábor
echo "reset = ".reset($dolgozok2) . "<br>";      // A belső mutatót a tömb első elemére mozgatja, ami Péter
echo "next = ".next($dolgozok2) . "<br>";         // Péter következő eleme, Jani

// Visszaadja az aktuális elem kulcsát és értékét (jelenleg Jani), és előre mozgatja a belső mutatót.
        echo '<pre>Aktuális elem kulcsa, és értéke:<br>';
                       print_r (each($dolgozok2));
        echo '</pre>';
?>

Eredmény:

current = Péter
next = Jani
current = Jani
prev = Péter
end = Ferenc
prev = Gábor
current = Gábor
reset = Péter
next = Jani

each: Aktuális elem kulcsa, és értéke, és a belső mutató pozíciója:
Array
(
    [1] => Jani
    [value] => Jani
    [0] => 1
    [key] => 1
)

Adja vissza az aktuális elem kulcsát és értékét, és mozgassa előre a belső mutatót:
<?php
$emberek = array("Peter", "Jani", "Gabor", "Ferenc");
echo '<pre>';
         print_r (each($emberek));
echo '</pre>';
?>

Eredmény:

Array
(
    [1] => Peter
    [value] => Peter
    [0] => 0
    [key] => 0
)

Adja ki egy tömb aktuális és utolsó elemének értékét:
<?php
$name = array("Peter", "Jani", "Gabor", "Ferenc");
   echo "Aktuális = ".current($name) . "<br>";
     echo "Utolsó = ".end($name);
?>

Eredmény:

Aktuális = Peter
Utolsó = Ferenc

Rendelje hozzá a "Cica", "Kutya" és "Ló" értékeket az $a, $b és $c változókhoz:
<?php
$a = "Eredeti";    // Ez a változó, tömbbön kívül van.
$adat_tomb = array("a" => "Cica","b" => "Kutya", "c" => "Ló");
     extract($adat_tomb);
echo "\$a = $a; \$b = $b; \$c = $c";
?>

Eredmény:

$a = Cica; $b = Kutya; $c = Ló

Keresse meg a "Gabor" értéket egy tömbben, és írjon ki szöveget:
<?php
$nevek = array("Peter", "Jani", "Gabor", "Ferenc");
  if (in_array("Gabor", $nevek)) { echo "Talált egyezést!";  }
  else  { echo "Egyezés nem található!"; }
?>

Eredmény:

Talált egyezést!

---

Az összes paraméter használatával:
<?php
$nevek2 = array("Peter", "Jani", "Gabor", "Ferenc", 23);

if (in_array("23", $nevek2, TRUE))           // Itt a 23 = string.
      { echo "1. Talált egyezést!<br>"; }
else { echo "1. Egyezés nem található!<br>"; }

if (in_array("Gabor",$nevek2, TRUE))
      { echo "2. Talált egyezést!<br>"; }
else { echo "2. Egyezés nem található!<br>"; }

if (in_array(23,$nevek2, TRUE))              // Itt a 23 = number.
      { echo "3. Talált egyezést!<br>"; }
else { echo "3. Egyezés nem található!<br>"; }
?>

Eredmény:

1. Egyezés nem található!
2. Talált egyezést!
3. Talált egyezést!

Az elemkulcs lekérése, az aktuális belső mutató helyéről:
<?php
$nev=array("Peter", "Jani", "Gabor", "Ferenc");
           echo "Kulcs jelenlegi pozíciója: " . key($nev);
?>

Eredmény:

Kulcs jelenlegi pozíciója: 0

Csökkenő sorrendbe rendezzen egy asszociatív tömböt, az elem kulcsa szerint:
<?php
$csage=array("Peter"=>"35","Bence"=>"37","Jani"=>"43");
       krsort($csage);
echo '<pre>';
print_r ($csage);
echo '</pre>';
?>

Eredmény: (Fordított abc rendezés.)

Array
(
    [Peter] => 35
    [Jani] => 43
    [Bence] => 37
)

Növekvő sorrendbe rendezzen egy asszociatív tömböt, az elem kulcsa szerint:
<?php
$nage=array("Peter"=>"35","Bence"=>"37","Jani"=>"43");
        ksort($nage);
echo '<pre>';
print_r ($nage);
echo '</pre>';
?>

Eredmény:

Array
(
    [Bence] => 37
    [Jani] => 43
    [Peter] => 35
)

A változókat úgy rendelje az adatokhoz, mintha egy tömb lenne:
<?php
$teszt = array("Kutya","Cica","Ló");
                 list($a, $b, $c) = $teszt;
        echo "A list változók adatai, a $a, a $b és a $c.";
?>

Eredmény:

A list változók adatai, a Kutya, a Cica és a Ló.

Tömb rendezése a natsort() és natcasesort() használatával:
<?php
$ideiglenes_files = array("temp15.txt","Temp10.txt","temp1.txt","Temp22.txt","temp2.txt");
                   natsort($ideiglenes_files);
        echo "A natsort természetes sorrend: ";
        echo '<pre>';
                       print_r($ideiglenes_files);
       echo '</pre>';
echo "<br>";
                   natcasesort($ideiglenes_files);
        echo "A natcasesort természetes sorrend, nem érzékeny a kis- és nagybetűkre: ";
        echo '<pre>';
                      print_r($ideiglenes_files);
        echo '</pre>';
?>

Eredmény:

A natsort természetes sorrend:

Array
(
    [1] => Temp10.txt
    [3] => Temp22.txt
    [2] => temp1.txt
    [4] => temp2.txt
    [0] => temp15.txt
)

A natcasesort természetes sorrend, nem érzékeny a kis- és nagybetűkre:

Array
(
    [2] => temp1.txt
    [4] => temp2.txt
    [1] => Temp10.txt
    [0] => temp15.txt
    [3] => Temp22.txt
)

Tömb rendezése:  sort és natsort
<?php
$files = array("temp15.txt","temp10.txt","temp1.txt","temp22.txt","temp2.txt");

         sort($files);
echo "A sort, szabványos rendezés: ";
        echo '<pre>';
                print_r($files);
        echo '</pre>';
echo "<br>";

         natsort($files);
echo "A natsort, természetes rendezés: ";
        echo '<pre>';
               print_r($files);
        echo '</pre>';
?>

Eredmény:

A sort, szabványos rendezés:

Array
(
    [0] => temp1.txt
    [1] => temp10.txt
    [2] => temp15.txt
    [3] => temp2.txt
    [4] => temp22.txt
)

A natsort, természetes rendezés:

Array
(
    [0] => temp1.txt
    [3] => temp2.txt
    [1] => temp10.txt
    [2] => temp15.txt
    [4] => temp22.txt
)

Adja ki az aktuális és a következő elem értékét a tömbből:
<?php
$tagok = array("Peter", "Jani", "Gabor", "Ferenc");
      echo "current = ".current($tagok) . "<br>";
           echo "next = ".next($tagok);
?>

Eredmény:

current (aktuális) = Peter
next (következő) = Jani

Adja ki az aktuális elem értékét (adatát), egy tömbből:
<?php
$tagok = array("Peter", "Jani", "Gabor", "Ferenc");
          echo pos($tagok) . "<br>";
?>

Eredmény:

Peter

Adja ki a tömb aktuális, következő és előző elemének értékét:
<?php
$tagok = array("Peter", "Jani", "Gabor", "Ferenc");
   echo "current = ".current($tagok) . "<br>";
   echo "next = ".next($tagok) . "<br>";
         echo "prev = ".prev($tagok);
?>

Eredmény:

current = Peter
next = Jani
prev = Peter

Hozzon létre egy tömböt, amely "0" és "5" közötti elemeket tartalmaz:
<?php
$numbertomb = range(0,5);
        echo '<pre>';
                      print_r ($numbertomb);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => 0
    [1] => 1
    [2] => 2
    [3] => 3
    [4] => 4
    [5] => 5
)

---

Betűk használata - egy elemtömb visszaadása "a"-tól "d"-ig
<?php
$letter = range("a","d");
        echo '<pre>';
                    print_r ($letter);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
)

Adja ki a tömb aktuális és következő elemének értékét, 
     majd állítsa vissza a tömb belső mutatóját a tömb első elemére:
<?php
$tag = array("Peter", "Jani", "Gabor", "Ferenc");
   echo "current = ".current($tag) . "<br>";
        echo "next = ".next($tag) . "<br>";
        echo "reset = ".reset($tag);
?>

Eredmény:

current = Peter
next = Jani
reset = Peter

Rendezd a tömb elemeinek adatait, csökkenő abc sorrendbe:
              Azért abc és nem ábécé, mert ékezetnélküli betűkre érvényes.
<?php
$autok=array("Audi","Volvo","BMW","Toyota","Opel");
            rsort($autok);
        echo '<pre>Ékezet nélküli szavak:<br>';
                    print_r ($autok);
        echo '</pre>';
		
$ekezetesek=array("Alom","Birka","Álom","Ügyes","Orvos","Éva","Őz");
             rsort($ekezetesek);
        echo '<pre>Ékezetes szavak:<br>';
                    print_r ($ekezetesek);
        echo '</pre>';
?>

Eredmény:

Ékezet nélküli szavak:
Array
(
    [0] => Volvo
    [1] => Toyota
    [2] => Opel
    [3] => BMW
    [4] => Audi
)

Ékezetes szavak:
Array
(
    [0] => Őz
    [1] => Ügyes
    [2] => Éva
    [3] => Álom
    [4] => Orvos
    [5] => Birka
    [6] => Alom
)

---

Rendezd a numbers tömb elemeinek adatait, csökkenő számsorrendbe:
<?php
$numbers=array(4,6,2,22,11);
      rsort($numbers);
echo '<pre>';
      print_r ($numbers);
echo '</pre>';
?>

Eredmény:

Array
(
    [0] => 22
    [1] => 11
    [2] => 6
    [3] => 4
    [4] => 2
)

---

Hasonlítsa össze az elemek indexeit számszerűen,
            és rendezze a tömb elemeit, csökkenő sorrendbe:
<?php
$auto=array("Audi","Volvo","BMW","Toyota","Opel");
      rsort($auto,SORT_NUMERIC);
echo '<pre>';
      print_r ($auto);
echo '</pre>';
?>

Eredmény:

Array
(
    [0] => Audi
    [1] => Volvo
    [2] => BMW
    [3] => Toyota
    [4] => Opel
)

Véletlenszerűsítse a tömb elemeinek sorrendjét:
<?php
$veletlen = array("red","green","blue","yellow","purple");
             shuffle($veletlen);
        echo '<pre>';
                print_r($veletlen);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => red
    [1] => purple
    [2] => yellow
    [3] => blue
    [4] => green
)

Egy tömb elemeinek számát adja vissza:
<?php
$veletlen = array("red","green","blue","yellow","purple");
   echo "sizeof = ".sizeof($veletlen)."<br>";
   echo "count = ".count($veletlen);
?>

Eredmény:

sizeof = 5
count = 5

Rendezd a tömb elemek adatait, növekvő ábécé sorrendbe:
<?php
$rendezni = array("piros","zöld","kék","sárga","lila");
              sort($rendezni);
        echo '<pre>';
                   print_r($rendezni);
        echo '</pre>';
?>

Eredmény:

Array
(
    [0] => kék
    [1] => lila
    [2] => piros
    [3] => sárga
    [4] => zöld
)

Rendezze egy tömb elemeit értékek szerint (fenntartja az indextársítást):
<?php
function ua_sort($a, $b) {
  if ($a == $b) return 0;
  return ($a < $b) ? -1 : 1;
}

$arr = array("a"=>4, "b"=>2, "c"=>8, "d"=>6);
        uasort($arr, "ua_sort");

foreach($arr as $key => $value) {
  echo "[" . $key . "] => " . $value;
  echo "<br>";
}
?>

Eredmény:

[b] => 2
[a] => 4
[d] => 6
[c] => 8

Rendezze egy tömb elemeit, kulcsok szerint:
<?php
function uk_function($a, $b) {
  if ($a == $b) return 0;
  return ($a < $b) ? -1 : 1;
}

$arr2 = array("a"=>4, "b"=>2, "c"=>8, "d"=>6);
          uksort($arr2, "uk_function");

foreach($arr2 as $key => $value) {
  echo "[" . $key . "] => " . $value;
  echo "<br>";
}
?>

Eredmény:

[a] => 4
[b] => 2
[c] => 8
[d] => 6

Rendezze egy tömb elemeit értékek szerint:
<?php
function usort_function($a, $b) {
  if ($a == $b) return 0;
  return ($a < $b) ? -1 : 1;
}

$us = array(4, 2, 8, 6);
          usort($us, "usort_function");

foreach($us as $key => $value) {
  echo "[" . $key . "] => " . $value;
  echo "<br>";
}
?>

Eredmény:

[0] => 2
[1] => 4
[2] => 6
[3] => 8