O recuncho do PHP

Mar 05

E máis funcións de arrays

05-03-2009 by Carlos Vázquez PHP No Comments »

range: devolve un array con todos os valores entre dous límites dados, que poden ser numéricos, ou letras. Tamén se pode por un terceiro parámetro, que é o salto entre cada dous valores consecutivos. (http://es.php.net/manual/es/function.range.php)

var_export(range(2,6)); //Devolve array(2,3,4,5,6)

explode: converte unha cadea en un array, cortando a cadea en elementos por un elementos separador indicado

var_export(explode("|","un|dous|tres")); // Devolve array("un","dous","tres");

implode: converte un array en unha cadea, separando os elementos un doutro por un caracter separador indicado

var_export(implode("#",array("un","dous","tres"))); // Devolve a cadea "un#dous#tres"

array_merge: Combina os elementos de varias matrices. Os índices numéricos son recalculados (a diferenza do operador + que non cambiaba os índices). Se un índice se repite, obtense só o derradeiro dos valores (a diferenza tamén do operador + que obtiña o primeiro) (http://es.php.net/manual/es/function.array-merge.php)

array_pad: Completa un array ara que teña o número de elementos indicado no segundo parámetro, enchendo para elo cos elementos indicados no terceiro parámetro. (http://es.php.net/manual/es/function.array-pad.php)

array_fill: Crea un array que comenza no índice indicado no primeiro parámetro, co número de elementos indicado no segundo parámetro e co valor en todos eles indicado no terceiro parámetro. (http://es.php.net/manual/es/function.array-fill.php)

array_splice: Sustitue ou elimina unha porción do array indicando, indicándolle onde empezar a sustituir, cantos elementos sustituir, e o elementos polo que se sustitue (se non se indica ningún elimínase en troques de sustituir) (http://es.php.net/manual/es/function.array-splice.php)

array_slice: Extrae unha porción do array indicado, indicándolle onde empezar, e cantos elementos extraer. (http://es.php.net/manual/es/function.array-slice.php)

compact: Obtén un array a partires dun conxunto de variables. Os parámetros pasados a compact, deben ser unha lista de cadeas, contendo cada una delas, o nome dunha variable. Crearase un array que teña como índices os nomes das variables e como valores os contidos destas. (http://es.php.net/manual/es/function.compact.php)

extract: Obtén unha serie de variables a partires dun array asociativo, onde os nomes das variables son os índices do array e os valores das variables os valores do array. (http://es.php.net/manual/es/function.extract.php)

array_count_values Conta cantas veces aparece cada valor no array orixinal (http://es.php.net/manual/es/function.array-count-values.php)

array_keys: Obtén os índices do array orixinal eliminando os valores e devolve este índices como valores (http://es.php.net/manual/es/function.array-keys.php)

array_values: Obten os valores do array orixinal eliminando os índices existentes (http://es.php.net/manual/es/function.array-values.php)

Mar 04

Para manexar arrays, unha chea de funcións:

04-03-2009 by Carlos Vázquez PHP No Comments »

Hai unha morea de funcións para o manexo de arrays, algunha delas son:

list: permite asiganar valores dun array a variables individuais (http://es.php.net/manual/es/function.list.php)

list($un,$dous,$tres)=array(1,2,3);

array_key_exists: permite saber se no array existe un elemento co índice indicado (http://es.php.net/manual/es/function.array-key-exists.php)

echo array_key_exists('a',$matriz);

in_array: permite saber se no array existe un elemento co valor indicado (http://es.php.net/manual/es/function.in-array.php)

echo in_array(2,$matriz);

aray_flip: intercambia os índices polos valores e os valores polos índices (http://es.php.net/manual/es/function.array-flip.php)

$a = array('a','b','c');
var_dump(array_flip($a)); // Devolve array("a"=>0,"b"=>1,"c"=>2,)

array_reverse: intercambia a orde dos valores do array (o derradeito pasa a ser o primeiro) sustituíndo os índices numéricos por uns novos e mantendo os de texto (http://es.php.net/manual/es/function.array-reverse.php)

$a = array('x'=>'a',10=>'b','c');
var_dump(array_reverse($a)); // Devolve array(0=>"c",1=>"b","x"=>"a")

array_rand; devuelve al azar un número de claves de un array (http://es.php.net/manual/es/function.array-rand.php)

$claves = array_rand($matriz,2); // $claves será un array con dúas claves da matriz obtidas de forma aleatoria

array_walk: Aplícalle unha función a cada un dos elementos dun array (http://es.php.net/manual/es/function.array-walk.php)

o operador == Devolve VERDADEIRO se os dous arrays teñen o mesmo número de elementos, cos menos pares índice valor, aínda que sexa en orde distinto

$a=array(1,2,3);
$b=array( 1=>2, 2=>3, 0=>1);
var_dump($a==$b) //Devolve VERDADEIRO

o operador === Devolve VERDADEIRO se os dous arrays teñen o mesmo número de elementos, cos menos pares índice valor, e no mesmo orde

var_dump($a===$b) //Devolve FALSO

Mar 03

Amosar de xeito sinxelo o contido dun array

03-03-2009 by Carlos Vázquez PHP No Comments »

Temos tres funcións para amosar de forma sinxela o contido dun array (e de variables doutros tipos):

print_r: É como print, pero recursivo para poder amosar o contido dos arrays. Pode amosalo por pantalla (comportamento por defecto) ou devolvelo nun array (se o segundo parámetro e TRUE)

$matriz1 = array(1=>1, 2=>2, 3=>3,)
print_r($matriz1);
// Amosa Array([1]=>1, [2]=>2, [3]=>3)
$salida = print_r($matriz1,TRUE);
recho $salida; // Imprime Array([1]=>1, [2]=>2, [3]=>3)

var_dump: Amosa o contido do array, indicando o número de elementos e o tipo de cada un dos elementos. Pode amosar o contido de varias variables ao mesmo tempo

var_dump($matriz1);
// Amosa array(3){[1]=>int(1), [2]=>int(2), [3]=>int(3)}

var_export: Similar a var_dump, pero devolvendo código PHP válido

var_export($matriz1);
// Amosa array(1=>1, 2=>2, 3=>3)

Mar 02

Argallando cos arrays

02-03-2009 by Carlos Vázquez PHP No Comments »

Algunhas das cousas a ter en conta ao traballar cos arrays son:

Se nun array definimos dous elementos co mesmo indíce, so se garda no array o derradeiro

$c = array('0'=>1,1=>2,0=>5);
$c[]=10;
var_export($c);  // Amosa array ( 0 => 5, 1 => 2, 2 => 10, )

Se se engade o array un elemento sen índice numérico definido, asignaralle de xeito automático un numérico que será o seguinte numero enteiro ao maior índice numérico existente no array. Se non hai ningún asignalle 0, e se o maior é negativo asignalle cero tamén.

$a = array(6=>1);
$a[]=10;
var_export($a);  // Amosa array ( 6 => 1, 7 => 10, )
b = array(-6=>1);
$b[]=10;
var_export($b);  // Amosa array ( -6 => 1, 0 => 10, )
$c = array('a'=>1);
$c[]=10;
var_export($c);  // Amosa array ( 'a' => 1, 0 => 10, )

Os índices expresados en octal (un cero a esquerda do número) ou en hexadecimal (0x a esquerda) nunha cadea manteñense como índices alfanuméricos (e non se converten a numéricos).

$a = array('0x10'=>1);
$a[]=10;
var_export($a);    // Amosa array ( '0x10' => 1, 0 => 10, )

Os índices expresados en octal (un cero a esquerda do número) ou en hexadecimal (0x a esquerda) como números convértense a números enteiros.

$a = array(0x10=>1);
$a[]=10;
var_export($a);   // Amosa array ( 16 => 1, 17 => 10, )

Feb 26

Quero quitar un elemento do array

26-02-2009 by Carlos Vázquez PHP No Comments »

En PHP é posible eliminar un elemento situado en calquera posición dunha matriz, sen ter que recorrela, nen mover elementos. So fai falla, empregar a función unset (que elimina unha variable de memoria) para eliminar o elemento desexado.

$matriz1 = array(1 => 1, 2 => 2, 3 => 3);
unset($matriz1[2]); // Elimina o elemento con índice 2
var_export($matriz1); // Devolve aray(1=>1,3=>3,)

Se queremos eliminar todo o array, so fai falla facer unset da variable que contén o array.

$matriz1 = array(1 => 1, 2 => 2, 3 => 3);
unset($matriz1); // Elimina toda a matriz
var_export($matriz1); // Devolve un notice e NULL

Feb 25

Simulando conxuntos con arrays

25-02-2009 by Carlos Vázquez PHP No Comments »

Se simulamos un conxunto mediante un array, en PHP dispoñemos de varias funcións para simular operacións entre conxuntos:

Unión de conxuntos +: Devolve os elementos do primeiro array e tamén os do segundo. Isto non é propiamente unha unión de conxuntos, pois os elementos con valor repetido e distinto índice aparecen repetidos no array resultante, e os elementos con valor distinto, pero índice repetido so aparece a primeira das aparicións.

$matriz1 = array(1 => 1, 2 => 2, 3 => 3);
$matriz2 = array(4 => 4, 2 => 5, 6 => 3);
var_export($matriz1+$matriz2);
// Devolve array(1 => 1, 2 => 2, 3 => 3, 4 => 4, 6 =>3)
// O valor 3 aparece repetido pois ten índices distintos nos dous array
// O valor 5 non aparece pois o índice 2 está repetido, e a primeira
// aparición é a do valor 2

Diferenza de conxuntos – array_diff: Devolve un array cos elementos que están no primeiro array pero non no segundo (so tendo en conta os valores, sen ter en conta os índices para ver se os elementos son iguais ou non, pero mantendo a asociación índice-valor. Se se quere ter en conta as parellas valor-índice débese empregar a función array_diff_assoc, e se se quere a diferenza en lugar dos conxuntos de elementos, dos conxuntos dos índices débese empregar a función array_diff_key ).

$matriz1 = array (1, 2, 3);
$matriz2 = array (3, 4, 5);
$matriz3 = array_diff($matriz1, $matriz2);
var_export($matriz3); // Devolve array ( 0 => 1, 1 => 2, )

Intersección de conxuntos – array_intersect: Devolve un array cos elementos que están no primeiro array e no segundo (so tendo en conta os valores, sen ter en conta os índices para ver se os elementos son iguais ou non, pero mantendo a asociación índice-valor. Se se quere ter en conta as parellas valor-índice débese empregar a función array_intersect_assoc, e se se quere a interseción en lugar dos conxuntos de elementos, dos conxuntos dos índices débese empregar a función array_intersect_key )

$matriz1 = array (1, 2, 3);
$matriz2 = array (3, 4, 5);
$matriz3 = array_intersect($matriz1, $matriz2);
var_export($matriz3); // Devolve array ( 2 => 3, )

Feb 24

Simulando colas con arrays

24-02-2009 by Carlos Vázquez PHP No Comments »

Unha cola é unha estrutura FIFO (First In First Out – O primeiro en chegar, o primeiro en irse), que se pode simular mediante un array, con estos dous pares de instrucións PHP.

array_push: engade un elemento á cola (engade elementos polo final do array)

array_shift: saca un elemento da cola (elimina un elemento polo principio do array)

$matriz=array();
array_push($matriz,1); // $matriz vale array ( 0 => 1,)
array_push($matriz,2); // $matriz vale array ( 0 => 1, 1 => 2,)
array_push($matriz,3,4); // $matriz vale array ( 0 => 1, 1 => 2, 2 => 3, 3 => 4,)
var_export($matriz);

$elemento = array_shift($matriz); // O elemento a quitar é o primeiro que chegou
echo $elemento;                       // que é 1
var_export($matriz);                  // $matriz vale array ( 1 => 2, 2 => 3, 3 => 4,)
$elemento = array_shift($matriz); // O elemento a quitar é o segundo que chegou
echo $elemento;                       // que é 2
var_export($matriz);                  // $matriz vale array ( 2 => 3, 3 => 4,)

array_unshift: engade un elemento á cola (engade elementos polo comezo do array)

array_pop: saca un elemento da cola (elimina un elemento polo final do array)

$matriz=array();
array_unshift($matriz,1); // $matriz vale array ( 0 => 1,)
array_unshift($matriz,2); // $matriz vale array ( 0 => 2, 1 => 1,)
array_unshift($matriz,4,3); // $matriz vale array ( 0 => 4, 1 => 3, 2 => 2, 3 => 1,)
var_export($matriz);

$elemento = array_pop($matriz); // O elemento a quitar é o primeiro que chegou
echo $elemento;                       // que é 1
var_export($matriz);                  // $matriz vale array ( 0 => 4, 1 => 3, 2 => 2,)
$elemento = array_pop($matriz); // O elemento a quitar é o segundo que chegou
echo $elemento;                       // que é 2
var_export($matriz);                  // $matriz vale array ( 0 => 4, 1 => 3,)

Feb 23

Simulando pilas con arrays

23-02-2009 by Carlos Vázquez PHP No Comments »

Unha pila é unha estrutura LIFO (Last In First Out – Derradeiro en chegar, primeiro en irse), que se pode simular mediante un array, con dúas instrucións PHP.

array_push: engade un elemento á pila (engade elementos polo final do array)

array_pop: saca un elemento da pila (elimina un elemento polo final do array)

$matriz=array(); // Defínese que $matriz é un array
array_push($matriz,1);   // Engádese á pila un elemento
array_push($matriz,2);   // Engádese á pila un elemento
array_push($matriz,3,4);   // Engádense á pila dous elementos
var_export($matriz); // Devolve array ( 0 => 1, 1 => 2, 2 => 3, 3 => 4, )

$elemento = array_pop($matriz); // Quitase un elemento
echo $elemento;                      // Este elemento é 4, o último que se engadiu
var_export($matriz);                 // Devolve array ( 0 => 1, 1 => 2, 2 => 3, )
$elemento = array_pop($matriz);  // Quitase un elemento
echo $elemento;                      // Este elemento é 3, o que anteriormente se engadiu
var_export($matriz);                  // Devolve array ( 0 => 1, 1 => 2, )

Se se emprega array_push para engadir só un elemento a matriz, e mellor empregar a sintase $matriz[]=$ele; dado que produce unha menor carga o sistema porque non ten que facer unha chamada a unha función.

Feb 19

Ordenando arrays

19-02-2009 by Carlos Vázquez PHP No Comments »

En PHP temos unha chea de funcións para ordenar arrays segundo distintos criterios. Dada o seguinte array:

$matriz = array("doUs" => '2', "vinte" => "20", '10',
		       30 => "30", "carlos", "coche", "VINTEUN" => "21",'D');

sort: ordena de menor a maior os valores, sen gardar os índices. Pódese empregar un segundo parámetro para indicar como debe ser a ordenación SORT_REGULAR (o valor por defecto, fai unha ordenación natural, primeiro os valores numéricos ordenados de xeito numérico e despois os valores alfanuméricos ordenados pola táboa de caracteres), SORT_NUMERIC (fai unha ordenación despois de convertir os valores a numéricos), SORT_STRING (fai unha ordenación pola táboa de caracteres)

sort($matriz);
var_export($matriz);
// Devolve array ( 0 => '2', 1 => '10', 2 => '20', 3 => '21', 4 => '30', 5 => 'D', 6 => 'carlos', 7 => 'coche', )
sort($matriz.SORT_REGULAR);
var_export($matriz);
// Devolve array ( 0 => '2', 1 => '10', 2 => '20', 3 => '21', 4 => '30', 5 => 'D', 6 => 'carlos', 7 => 'coche', )
sort($matriz,SORT_NUMERIC);
var_export($matriz);
// Devolve array ( 0 => 'coche',  1 => 'D', 2 => 'carlos', 3 => '2', 4 => '10', 5 => '20', 6 => '21', 7 => '30',  )
sort($matriz,SORT_STRING);
var_export($matriz);
// Devolve array ( 0 => '10', 1 => '2', 2 => '20', 3 => '21', 4 => '30', 5 => 'D', 6 => 'carlos', 7 => 'coche', )

rsort: ordena de maior a menos os valores, sen gardar os índices

rsort($matriz);
var_export($matriz);
// Devolve array ( 0 => 'coche', 1 => 'carlos', 2 => 'D', 3 => '30', 4 => '21', 5 => '20', 6 => '10', 7 => '2', )

asort: ordena de menor a maior os valores, mantendo a asociación cos índices

asort($matriz);
var_export($matriz);
// Devolve array ( 'doUs' => '2', 0 => '10', 'vinte' => '20', 'VINTEUN' => '21', 30 => '30', 33 => 'D', 31 => 'carlos', 32 => 'coche', )

arsort: ordena de maior a menor os valores, mantendo a asociación cos índices

arsort($matriz);
var_export($matriz);
// Devolve array ( 32 => 'coche', 31 => 'carlos', 33 => 'D', 30 => '30', 'VINTEUN' => '21', 'vinte' => '20', 0 => '10', 'doUs' => '2', )

ksort: ordena de menor a maior os índices, mantendo a asociación cos valores

ksort($matriz);
var_export($matriz);
// Devolve array ( 'VINTEUN' => '21', 'doUs' => '2', 'vinte' => '20', 0 => '10', 30 => '30', 31 => 'carlos', 32 => 'coche', 33 => 'D')

krsort: ordena de maior a menor os índices, mantendo a asociación cos valores

krsort($matriz);
var_export($matriz);
// Devolve array ( 33 => 'D', 32 => 'coche', 31 => 'carlos', 30 => '30', 'vinte' => '20', 'VINTEUN' => '21', 0 => '10', 'doUs' => '2', )

natsort: ordena de menor a maior os valores empregando un método natural, mantendo a asociación cos índices

natsort($matriz);
var_export($matriz);
// Devolve array ( 'doUs' => '2', 0 => '10', 'vinte' => '20', 'VINTEUN' => '21', 30 => '30', 33 => 'D', 31 => 'carlos', 32 => 'coche', )

natcasesort: ordena de menor a maior os valores empregando un método natural e insensible ás maiúsculas (e dicir a ordenación é como se todas as letras estivesen en maiúsuculas), mantendo a asociación cos índices

natcasesort($matriz);
var_export($matriz);
// Devolve array ( 'doUs' => '2', 0 => '10', 'vinte' => '20', 'VINTEUN' => '21', 30 => '30', 31 => 'carlos', 32 => 'coche', 33 => 'D',)

usort:ordena os valores mediante unha función definida polo usuario, que establece cando un elemento e maior, menor ou igual que outro, sen gardar os índices

// ORDENA DE MENOR A MAIOR LONXITUDE DA CADEA
// EN CASO DE IGUALDADE COMPARA NORMALMENTE
function miOrdenacion($izq,$der) {
	$diff = strlen($izq)-strlen($der);
	if (!$diff)
		return strcmp ($izq,$der);
	else
		return $diff;
}

usort($matriz,'miOrdenacion');
var_export($matriz);
// Devolve array ( 0 => '2', 1 => 'D', 2 => '21', 3 => '20', 4 => '21', 5 => '30', 6 => 'coche', 7 => 'carlos', )

uksort:ordena os índices mediante unha función definida polo usuario, que establece cando un elemento e maior, menor ou igual que outro, mantendo a asociación cos valores

uksort($matriz,'miOrdenacion');
var_export($matriz);
// Devolve array ( 0 => '10', 30 => '30', 31 => 'carlos', 32 => 'coche', 33 => 'D', 'doUs' => '2', 'vinte' => '20', 'VINTEUN' => '21', )

uasort:ordena os valores mediante unha función definida polo usuario, que establece cando un elemento e maior, menor ou igual que outro, mantendo a asociación cos valores

uasort($matriz,'miOrdenacion');
var_export($matriz);
// Devolve array ( 'doUs' => '2', 33 => 'D', 0 => '10', 'vinte' => '20',  'VINTEUN' => '21', 30 => '30', 32 => 'coche', 31 => 'carlos', )

Algunhas para desordearlos

shuffle: desordena os valores (baralla), sen gardar os índices

shuffle($matriz);
var_export($matriz);
// Devolve array ( 0 => 'carlos', 1 => '2', 2 => '20', 3 => '30', 4 => '21', 5 => '10', 6 => 'coche', )

array_keys: devolve un array onde os valores son os índices do array orixinal. Esta función pemite posteriormente con shuffle desordenar estos valores (os índices do array orixinal) e acceder mediante estes valores desordenados os elementos do array orixinal co que xa mantemos a asociación entre índices e valores do array orixinal, pero tendo os elementos desordenados.

$indices = array_keys($matriz);
shuffle($indices);
foreach ($indices as $v)
	$matriz2[$v]=$matriz[$v];
var_export($matriz2);
// Devolve  array ( 'vinte' => '20', 0 => '10', 'doUs' => '2', 31 => 'carlos', 32 => 'coche', 'VINTEUN' => '21', 30 => '30', )

Feb 18

Percorrendo un array

18-02-2009 by Carlos Vázquez PHP No Comments »

Dado que en PHP, os arrays poden ter índices non numéricos, ou índices numéricos con valores non consecutivos, as técnicas empregadas noutras linguaxes para percorrer os elementos dun array poden non ser válidas en PHP. Temos dous xeitos validos de percorrer os elementos dun array en PHP:

Hai unha serie de funcións para determinar o número de elementos dun array ( count() ), posicionar o punteiro para percorrer o array ao comezo deste ( reset() ), ou ao final ( end() ) , mover o punteiro ao seguinte elemento ( next() ) ou ao anterior elemento ( prev() ), devolver o valor do elemento apuntado actualmente polo punteiro ( current() ) ou do seu índice ( key() ).
Asi a forma de percorrer un array podería ser:

for($i=0,reset($a);$i<count($a);$i++,next($a))
	echo "Clave: ".key($a)." Valor: ".current($a);

ou con outra instrucción de control de fluxo:

reset($a)
while(key($a)!==NULL) {
	echo "Clave: ".key($a)." Valor: ".current($a);
        next($a);
}

Outra forma é empregar a instrución foreach que en cada iteración devolve un elemento do array co seu índice (que se pode recuperar ou non, segundo se desexe) http://es.php.net/manual/es/control-structures.foreach.php

foreach($a as $clave => $valor)
	echo "Clave: $clave  Valor: $valor";