O recuncho do PHP

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

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

$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

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

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

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.

$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,)

$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,)

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.

$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.

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

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

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

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

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

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

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

// 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($matriz,'miOrdenacion');
var_export($matriz);
// Devolve array ( 0 => '10', 30 => '30', 31 => 'carlos', 32 => 'coche', 33 => 'D', 'doUs' => '2', 'vinte' => '20', 'VINTEUN' => '21', )

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($matriz);
var_export($matriz);
// Devolve array ( 0 => 'carlos', 1 => '2', 2 => '20', 3 => '30', 4 => '21', 5 => '10', 6 => 'coche', )

$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', )

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:

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

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

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

Para crear un array dispoñemos de dúas posibilidades:

• Mediante o construtor array: Este método consiste en indicarlle nunha soa instrución todos os elementos e os seus índices (dos elementos dos que se desexe indicalo de xeito explícito). Para elo hai que asignar a unha variable unha construción que comeza polo construtor array que leva entre parénteses unha lista de elementos (separados por comas), sendo cada elemento ben o propio elemento (unha cadea, un número, un obxeto ou outra estrutura array) ou unha dupla formada por índice e elemento, sendo o índice ou unha cadea (índice asociativo), ou un número enteiro (índice numérico) e estando separado do elemento polos símbolos =>.

  $a=array(10 => "Primeiro", "uno" => "Segundo", "Terceiro");
  var_export($a);
  //Amosa array ( 10 => 'Primeiro', 'uno' => 'Segundo', 11 => 'Terceiro', )
  

• Elemento a elementos: Este método consiste en indicarlle cal é o valor de cada un dos elementos do array de forma individual, ben indicando en que posición se garda ou ben deixando que PHP lle asigne posición de xeito automático. Para elo so hay que por o nome da variable e a continuación entre corchetes o índice numérico ou de texto do elemento (se non se quere indicar índice e se desexa que PHP o poña de xeito automático, non se pon nada dentro dos corchetes) e asignarlle un valor.

  $a[10]="Primeiro";
  $a["uno"]="Segundo";
  $a[]="Terceiro";
  var_export($a);
  //Amosa array ( 10 => 'Primeiro', 'uno' => 'Segundo', 11 => 'Terceiro', )
  

Máis información na axuda oficial: http://www.php.net/manual/es/language.types.array.php

O tipo de datos composto máis util de PHP é o array (vector, matriz, …). É un tipo que permite simular case calquera estructura de datos que usemos noutra linguaxe. As súas características son:

• Non hai que declaralo previamente, é dicir, non hai que dicir antes de empregalo cal é o seu tamaño nen o tipo dos seus elementos
• Pode ser de calquer tamaño, e de calquer número de dimensións
• Os seus elementos poden ser de tipos distintos (entre esos tipos están os array, polo que se pode ter un array de arrays)
• Para acceder os seus elementos podemos empregar índices numéricos ou alfanuméricos (texto) ou ámbolos dous
• Se o índice é numérico os elementos non teñen por que ter índices consecutivos
• Se se define un elemento sen índice, PHP asignaralle automáticamente un índice numérico libre

As función en PHP sempre devolven algo (sexa un valor dun tipo de datos básico, composto ou o valor NULL). Para devolver algo, só fai falla por dentro do código da función a instrución return seguida do valor a devolver.

Hai que ter en conta que a instrución return, además de devolver un valor ten outra función, que é a de sair da execución da función, polo tanto, a execución do código da función remata cando se executa unha instrución return aínda que na secuencia de instrucións da función queden outras sentencias posteriores sen executar.

function devolver_10() {
  $a = 10;
  return $a;
  echo "Non me escribo nunca";  // Non se executa nunca
}

$valor_retornado = devolver_10(); // $valor_retornado tera o valor 10

Podense devolver arrays:

function devolver_array() {
  return array(10,20);
  echo "Non me escribo nunca";  // Non se executa nunca
}

$array_retornado = devolver_array(); // $array_retornado tera o valor 10
list($valor1,$valor2) = $array_retornado;

Se queremos asignar a variables individuais os elementos do array devolto pola función podémolo facer empregando a función list na parte esquerda dunha asignación, de xeito que o primeiro valor do array asígnase o primeiro parámetro da función list (neste caso $valor1), o segundo do array o segundo parámetro (neste caso $valor2), e así sucesivamente.

PHP acepta que ás funcións se lles pase un número indeterminado de parámetros (sempre igual ou superior o número de parámetros obrigatorios indicados na definición da función).

Para elo na definición da función, non se define o nome dos parámetros; e no código da función empreganse unha serie de funcións predefinidas para coñecer o número e contido dos parámetros pasados. Estas funcións son:

• func_num_args() : Devolve o número de argumentos pasados a función ao chamala
• func_get_arg(indice) : Devolve o valor do argumento cuxa posición na lista de argumentos é a indicada polo índice, tendo en conta que o primeiro argumento está na posición 0 e o argumento n na posición n-1
• func_get_args() : Devolve un array con todos os valores dos argumentos pasados

function sumar() {
   $sumador = 0;
   for($i=0;$i<func_num_args();$i++)
       $sumador += func_get_arg($i);
   return $sumador;
} 

echo sumar(2,3);       //Imprime 5
echo sumar(1);         //Imprime 1
echo sumar(10,4,2);    //Imprime 16
echo sumar(10,4,2,7);  //Imprime 23