PHP Guide: handling arrays

Arrays, as mentioned in previous posts, are nothing but containers containing various pairs of keys => values. PHP provides us with some native functions to manage, sort, remove items and so on.

count($array, [ $mode = COUNT_NORMAL ])

La funzione count ci permetterà di contare gli elementi all’interno di un array. Il conteggio inizierà da 1 (e non da 0). Analizziamo questo esempio:

$array = array("libri", "penne", "matite");
echo count($array); // Restituirà il risultato "3"

Un array, come potete benissimo immaginare, possono essere anche nidificati e PHP ci mette a disposizione il secondo parametro per effettuare il conteggio ricorsivo.

$array = array(
   0 => "libri",
   1 => "penne",
   2 => array(
     0 => "matite",
     1 => "carta",
     3 => "pennarelli"
   )
);

echo count($array, COUNT_RECURSIVE); // Restituirà 6, in quanto conterà anche gli elementi nidificati
                                     // all'interno dell'array con chiave "2".
                                     // Da notare che questo tipo di array è anche detto 'multidimensionale'

array_reverse($array, [bool $mantienichiavi])

La funzione array_reverse ci invertire l’ordine degli array, il secondo parametro servirà in caso ci sia bisogno di mantenere le stesse chiavi di origine. Vediamo un piccolo esempio per capire meglio:

$array = array(
   0 => "libri",
   1 => "penne",
   2 => "matite"
);
var_dump(array_reverse($array));

L’esempio sopracitato restituirà il risultato:

Array(
   0 => "matite",
   1 => "penne",
   2 => "libri"
)

Se invece viene specificato il 2o parametro:

$array = array(
   0 => "libri",
   1 => "penne",
   2 => "matite"
);
var_dump(array_reverse($array, true));

Il risultato sarà:

Array(
  2 => "matite",
  1 => "penne",
  0 => "libri"
)

sort($array, [ int $sort_flags])

Sort ci permette di ordinare un determinato array in base ad una flag prestabilita (specificata nel parametro $sort_flags). Se il secondo parametro non viene fornito, l’ordinamento avviene in modalità alfabetica incrementale.

$array = array(
   0 => "libri",
   1 => "penne",
   2 => "matite"
);
sort($array);
var_dump($array);

Che restituirà:

Array(
   0 => "libri",
   1 => "matite",
   2 => "penne"
)

rsort($array, [int $sort_flags])

Analoga alla funzione sort() con la differenza che l’array verrà ordinato in ordine DECRESCENTE.

asort($array, [int $sort_flags])

Anche questa funzione è simile a sort() ma manterrà le chiavi dell’array fornito. Vediamo un esempio:

$array = array(
   0 => "libri",
   1 => "penne",
   2 => "matite"
);
asort($array);
var_dump($array);

L’esempio sopra riportato stamperà:

Array(
  0 => "libri",
  2 => "matite",
  1 => "penne"
)

arsort($array)

Analogo ad rsort (ordina in modo decrescente) ma mantiene le stesse chiavi dell’array.

in_array(mixed $needle, array $haystack, [bool $strict = FALSE])

in_array è una funzione molto utile quando si vuole cercare un valore ($needle) all’interno di un array ($haystack). Analizziamo questo esempio:

$array = array(
   0 => "libri",
   1 => "matite",
   2 => "penne"
);
if (in_array("libri", $array)) {
   echo "L'array contiene il valore: libri!";
}

Il risultato ovviamente sarà “L’array contiene il valore: libri!”, ma se specifichiamo il terzo parametro (STRICT_MODE) dovremmo ricordarci che la ricerca sarà case sensitive.

$array = array(
   0 => "libri",
   1 => "matite",
   2 => "penne"
);
if (in_array("Libri", $array, true)) {
   echo "L'array contiene il valore: Libri!";
} else {
   echo "L'array NON contiene il valore: Libri!";
}

Se eseguite l’esempio sopra riportato il risultato sarà sempre “L’array NON contiene il valore: Libri!” e questo perchè avete specificato una ricerca case sensitive, quindi con distinzione tra maiuscole e minuscole.

array_key_exists(mixed $key, $array)

Questa funzione, come si può immaginare, ci servirà per ricerca una determinata chiave fornita nel primo parametro $key, all’interno del secondo parametro $array.

$array = array(
   0 => "libri",
   1 => "matite",
   2 => "penne"
);
if (array_key_exists(2, $array))
  echo "La chiave numero 2 esiste!";

array_search(mixed $needle, $array, [bool STRICT_MODE = FALSE])

La funzione ci permette di cercare un determinato valore all’interno di un array, e ci restituirà la sua relativa chiave di appartenenza.

$array = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);6

$key = array_search("penne", $array);

var_dump($key);

L’esempio restituirà il risultato “2”, che sarà la chiave di appartenenza al valore “penne”. Specificando il 3° parametro (Strict mode) la ricerca sarà case sensitive.

array_merge(array $array1, $array2, $array3…)

Array_merge ci permette di unire due o più array insieme. Da notare che se uno degli array forniti come “sostituti” contenesse una chiave già esistente nell’$array1, quest’ultima verrà sovrascritta con la nuova.

$ufficio = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);

$frutta = array(
  3 => "banane",
  4 => "fragole",
  5 => "ciliegie"
);

$risultato = array_merge($ufficio, $frutta);

var_dump($risultato);

L’esempio restituirà come risultato:

Array(
  0 => "libri",
  1 => "matite",
  2 => "penne",
  3 => "banane",
  4 => "fragole",
  5 => "ciliegie"
)

Ma analizziamo invece il seguente esempio:

$ufficio = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);

$frutta = array(
  0 => "banane",
  1 => "fragole",
  2 => "ciliegie"
);
$result = array_merge($ufficio, $frutta);
var_dump($result);

Il risultato sarà:

Array(
  0 => "banane",
  1 => "fragole",
  2 => "ciliegie",
)

Questo perchè le chiavi 0, 1 e 2 sono state sovrascritte dal 2° array fornito!

array_pop($array)

Array_pop è usata quando si vuole rimuovere un elemento alla fine di un array, conservandone il valore in una variabile. Esempio:

$ufficio = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);
$penne = array_pop($ufficio); // Questa variabile conterrà la stringa "penne"
var_dump($ufficio);

Il risultato sarà:

Array(
  0 => "libri",
  1 => "matite"
)

array_push(array $array, mixed $param1,[ mixed $param2…])

Array_push ci permette di inserire nuovi elementi all’array fornito nel primo parametro.

$array = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);
array_push($array, "computer");
var_dump($array);

Il risultato sarà:

Array(
  0 => "libri",
  1 => "matite",
  2 => "penne",
  3 => "computer"
)

array_shift($array)

array_shift è analoga ad array_pop ma ci permette di estrarre il PRIMO elemento dell’array.

array_unshift(array $array, var $var1, var $var2…)

array_unshift è analoga ad array_push ma ci permette di inserire degli elementi all’inizio dell’array. Vediamo un esempio:

$ufficio = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);
array_unshift($ufficio, "computer", "pennarello");
var_dump($ufficio);

Il risultato sarà:

Array(
   0 => "computer",
   1 => "pennarello",
   2 => "libri",
   3 => "matite",
   4 => "penne"
)

Da notare che dopo l’utilizzo di questa funzione le chiavi degli array vengono resettate e riassegnate per permettere agli elementi nuovi di essere posizionati correttamente.

implode(string $glue, array $array)

implode è una funzione molto utilizzata e serve per trasformare ogni elemento di un array in una stringa, separata dal primo parametro fornito ($glue). Esempio:

$ufficio = array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
);
$result = implode(",",$ufficio); // Produrrà il risultato "libri,matite,penne" la virgola è il separatore
                                 // fornito nel primo parametro della funzione

explode(string $delimitatore, string $stringa)

explode è la funzione inversa di implode e ci permette di unire una stringa separata da un determinato delimitatore e trasformarla in un array.

$ufficio = "libri,matite,penne";
$array = explode(",",$ufficio);
var_dump($array);

Produrrà:

Array(
  0 => "libri",
  1 => "matite",
  2 => "penne"
)

Anche per oggi abbiamo terminato la nostra piccola lezione, nella prossima parleremo della gestione della date. Alla prossima!

count($array [$mode = COUNT_NORMAL])

The count will allow us to count the elements in an array. The count starts from 1(not at 0). Let’s analyze this example:

$array = array("books", "pens", "pencils");
echo count($array) // return the result "3"

An array, as you can well imagine, can also be nested, and PHP provides us with the second parameter to count recursively.

$array = array(
   0 => "books",
   1 => "pens"
   2 => array(
     0 => "pencils"
     1 => "paper",
     3 => "markers"
   )
);

echo count($array, COUNT_RECURSIVE) // will return 6, will also count as nested elements
                                     // The array with key "2".
                                     // Note that this type of array is also called 'multidimensional'

array_reverse($array [bool $keeypkeys])

The function array_reverse we reverse the order of the array, the second parameter will be used in case we need to keep the same keys of origin. We see a small example to better understand:

$array = array(
   0 => "books",
   1 => "pens"
   2 => "pencils"
);
var_dump(array_reverse($array));

The example mentioned above will return the result:

Array(
   0 => "pencils"
   1 => "pens"
   2 => "books"
)

However, if you specify the second parameter:

$array = array(
   0 => "books",
   1 => "pens"
   2 => "pencils"
);
var_dump(array_reverse($array, true));

The result will be:

Array(
  2 => "pencils"
  1 => "pens"
  0 => "books"
)

sort(array $array,[int $sort_flags])

Sort allows us to order a given array according to a predetermined flag(specified in the parameter $sort_flags). If the second parameter is not supplied, alphabetic sorting mode is incremental.

$array = array(
   0 => "books",
   1 => "pens"
   2 => "pencils"
);
sort($array);
var_dump($array);

That will return:

Array(
   0 => "books",
   1 => "pencils"
   2 => "pens"
)

rsort($array ,[$sort_flags int])

Similar to the sort() function except that the array will be sorted in descending order.

asort($array ,[$sort_flags int])

This function is also similar to the sort() but will keep the keys of the array provided. Here’s an example:

$array = array(
   0 => "books",
   1 => "pens"
   2 => "pencils"
);
asort($array);
var_dump($array);

The above example will print:

Array(
  0 => "books",
  2 => "pencils"
  1 => "pens"
)

arsort($array)

Rsort Same as(in descending order), but maintains the same keys of the array.

in_array(mixed $needle, array $haystack, [bool $strict = FALSE])

in_array is a very useful feature when you want to search for a value($needle) in an array($haystack). Let’s analyze this example:

$array = array(
   0 => "books",
   1 => "pencils"
   2 => "pens"
);
if(in_array("books",$array)) {
   echo "The array contains the value of books!"
}

The result of course will be “The array contains the value: books”, but if we specify the third parameter(STRICT_MODE) we should remember that the search will be case sensitive.

$array = array(
   0 => "books",
   1 => "pencils"
   2 => "pens"
);
if(in_array("Books",$array, true)) {
   echo "The array contains the value: Books!"
else {
   echo "The array contains the value NO: Books!"
}

If you run the above example the result will always be “The array contains the value NO: Books!” and that’s because you specified a search case sensitive, so this is case sensitive.

array_key_exists(mixed $key,$array)

This feature, as you can imagine, we will search for a specific key provided in the first parameter $key, $array within the second parameter.

$array = array(
   0 => "books",
   1 => "pencils"
   2 => "pens"
);
if(array_key_exists(2,$array))
  echo "The key number 2 exists!"

array_search(mixed $needle,$array [STRICT_MODE bool = FALSE])

The function allows us to search for a particular value within an array, and we will return the key belonging to his relative.

$array = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);

$key = array_search("pens",$array);

var_dump($key);

The example returns the result “2”, which will be the key to the value of belonging “pens”. By specifying the 3 rd parameter(Strict mode) the search will be case sensitive.

array_merge(array $array1,$array2,$array3 …)

Array_merge allows us to combine two or more arrays together. Note that if one of the arrays provided as “substitutes” contain a key that already exists in ‘$array1, it will be overwritten with the new.

$office = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);

$fruits = array(
  3 => "banana",
  4 => "strawberry",
  5 => "cherry"
);

$result = array_merge($office,$fruits);

var_dump($result);

The example will return as a result:

Array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
  3 => "banana",
  4 => "strawberry",
  5 => "cherry"
)

But instead we analyze the following example:

$office = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);

$fruits = array(
  0 => "banana",
  1 => "strawberry",
  2 => "cherry"
);
$result = array_merge($office,$fruits);
var_dump($result);

The result will be:

Array(
  0 => "banana",
  1 => "strawberry",
  2 => "cherry"
)

This is because the keys 0, 1 and 2 were overridden by the 2 nd array provided!

array_pop($array)

Array_pop is used when you want to remove an item at the end of an array, preserving the value in a variable. Example:

$office = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);
$pen = array_pop($office); // This variable will contain the string "pens"
var_dump($department);

The result will be:

Array(
  0 => "books",
  1 => "pencils"
)

array_push($array array, mixed$param1, [mixed$param2 …])

Array_push allows us to add new elements to the array provided in the first parameter.

$array = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);
array_push($array, "Computer");
var_dump($array);

The result will be:

Array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
  3 => "computer"
)

array_shift($array)

array_shift is similar to array_pop, but allows us to extract the first element of the array.

array_unshift(array $array,$var1, $var2…)

array_unshift is similar to array_push but it allows us to insert elements at the beginning of the array. Here’s an example:

$office = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);
array_unshift($office "computer", "marker");
var_dump($department);

The result will be:

Array(
   0 => "computer",
   1 => "marker"
   2 => "books",
   3 => "pencils"
   4 => "pens"
)

Note that after using this function array keys will be reset and reallocated to allow new elements to be positioned correctly.

implode(string $glue,array $array)

implodes is a very used and serves to transform each element of an array into a string, separated by the first parameter supplied($glue). Example:

$office = array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
);
$result = implode(",",$office); // will produce the result "books, pencils, pens," the comma is the separator
                                 // Supplied in the first parameter of the function

explode(string$delimiter, string$string)

is the inverse function of explode implode and allows us to combine a string separated by a specified delimiter, and turn it into an array.

$office = "books, pencils, pens";
$array = explode(",",$office);
var_dump($array);

Will produce:

Array(
  0 => "books",
  1 => "pencils"
  2 => "pens"
)

Even today we have finished our little lesson, in the next ones we will discuss about date strings. See you next tutorial!

BGDS, guida php, php, php tutorial

WarDrome Blog

Lascia agli altri le cose semplici: Gioca a Wardrome.