PHP Arrays

De MediaWiki
Saltar a: navegación, buscar

Introdución

  • Un array é un tipo estrutura de datos. Dita estrutura se caracteriza por ter un número de elementos variable no que cada valor a gardar está relacionado cun índice que 'apunta' á posición do elemento dentro do array.
  • Podemos identificar un array como unha cómoda con caixóns no que cada caixón se pode identificar có índice do array e dentro de cada caixón teremos gardada a información.
Cabe sinalar que dentro dun caixón poderíamos ter outra cómoda con máis caixóns a súa vez.


Un array pódese crear có construtor da linguaxe array() desta forma:

  1. <?php  
  2.  array(
  3.     clave  => valor,
  4.     clave2 => valor2,
  5.     clave3 => valor3,
  6.     ...
  7.     )
  8. ?>

Vexamos un exemplo de parte dos ingredientes dunha receita:

  1. <?php  
  2. $ingredientes = array(
  3.     0 => "améndoa",
  4.     1 => "fresas",
  5. );
  6.  
  7. // a partires de PHP 5.4
  8. $ingredientes = [  // Leva corchetes e sen a palabra array
  9.     0 => "améndoa",
  10.     1 => "fresas",
  11. ];
  12. ?>
  • Como vemos a estrutura que mellor se adapta a gardar información sobre os ingredientes dunha receita é un Array. Non ten sentido ter unha variable por cada un dos ingredientes da receita.
  • Vexamos un exemplo no que as claves sexan cadeas de caracteres:
  1. <?php  
  2.           $persoa = ['nome' => 'Juan Francisco',
  3.                      'direccion' => 'C/ Rúa de alá nº5',
  4.                      'telefono' =>'981121212'];
  5.  
  6. ?>
  • A este tipo de array chámase array asociativo.

Accedendos aos valores gardados no array (para programadores)

  • Existe unha función que devolve toda a estructura do array en forma de volcado coa que podemos ver o número de elementos, claves e valores.
Nota:Pódese empregar para outros tipos de variables.
  • Vexamos un exemplo:
  1. <?php
  2. $array = array("un", "dous", "tres", "catro");
  3. printf("<br>");
  4. var_dump($array);
  5. printf("<br>");
  6. print_r($array);
  7. ?>
O resultado:
array(4) { [0]=> string(2) "un" [1]=> string(4) "dous" [2]=> string(4) "tres" [3]=> string(5) "catro" }   // RESULTADO var_dump
Array ( [0] => un [1] => dous [2] => tres [3] => catro )                                                  // RESULTADO print_r


Accedendos aos valores gardados no array (1ª forma)

  • Unha das formas para acceder aos valores do array é:
  • $variable_array[clave]
ou
  • $variable_array{clave}
Pódense utilizar corchetes ou chaves indistintamente.
No exemplo anterior:
  1. <?php  
  2. $ingredientes = [  // Leva corchetes e sen a palabra array
  3.     0 => "améndoa",
  4.     1 => "fresas",
  5. ];
  6.  
  7. printf("O primeiro ingrediente do array é: %s<br/>", $ingredientes[0]);
  8. printf("O segundo ingrediente do array é: %s<br/>", $ingredientes[1]);
  9.  
  10. ?>


  • No caso anterior no que o array tiña como clave unha cadea:
  1. <?php  
  2.          $persoa = ['nome' => 'Juan Francisco',
  3.                      'direccion' => 'C/ Rúa de alá nº5',
  4.                      'telefono' =>'981121212'];
  5.           printf("Datos da persoa:<br/>Nome:%s<br/>Dirección:%s<br/>Teléfono:%s",$persoa['nome'],$persoa['direccion'],$persoa['telefono']);
  6. ?>

Declaración dun array: valores claves

  • Como dixemos anteriormente o array ten unha clave coa que facemos referencia aos valores gardados no array.
  • Dita clave pode ser numérica ou cadea e os valores que podemos gardar poden ser de calquera tipo.
  • Se usamos como clave un tipo de dato diferente, PHP fará un 'cast' a o tipo de dato integer ou string (como indicamos antes).
Así:
  • Float: será convertido a un integer quitando a parte decimal.
  • String: se o string é un número válido (por exemplo "8") será convertido a integer.
  • Boolean: será convertido a integer (true = 1; false = 0)
  • null: será convertido a cadea valeira.
  • Se non poñemos clave dará o valor seguinte a última numérica instroducida.


  • Vexamos uns exemplos:
  1. <?php  
  2.           $disco = [
  3.             1 => '32454KAS12',
  4.             'capacidad' => '500GB',
  5.             '3500rpm',
  6.             'marca' => 'seagate',
  7.             3.5 => 'SATA'  
  8.           ];
  9.  
  10.           printf("<br>");
  11.           printf("O primeiro dato é o número de serie=> \$disco[1]:%s => A clave numérica é 1<br/>",$disco[1]);
  12.           printf("O segundo dato=> \$disco['capacidad']:%s<br/>",$disco['capacidad']);
  13.           printf("O terceiro dato (velocidade) non leva clave polo que dalle a seguine numérica=> \$disco[2]:%s => A clave numérica é 2<br/>",$disco[2]);
  14.           printf("O cuarto dato é a marca=> \$disco['marca']:%s<br/>",$disco['marca']);
  15.           printf("O quinto dato (tipo conector) a clave convírtese de float a integer=> \$disco[3]:%s A clave numérica é 3<br/>",$disco[3]);
  16.  
  17. ?>
O resultado:
O primeiro dato é o número de serie=> $disco[1]:32454KAS12 => A clave numérica é 1
O segundo dato=> $disco['capacidad']:500GB
O terceiro dato (velocidade) non leva clave polo que dalle a seguine numérica=> $disco[2]:3500rpm => A clave numérica é 2
O cuarto dato é a marca=> $disco['marca']:seagate
O quinto dato (tipo conector) a clave convírtese de float a integer=> $disco[3]:SATA A clave numérica é 3
Como podemos comprobar no exemplo anterior é posible ter un array con claves mixtas (cadea e numérica)
  • Outro exemplo:
  1. <?php
  2. $array = array("un", "dous", "tres", "catro");
  3. printf("%s-%s-%s-%s",$array[0],$array[1],$array[2],$array[3]);
  4. ?>
Neste exemplo non asociamos ningunha clave e PHP irá, dende 0, incrementando a clave asociada a cada valor dentro do array.


Eliminando, modificando ou engadindo valores a un array

Eliminar un elemento do Array

  • Para eliminar un elemento do array temos que facer uso da función unset.
  1. unset($array[clave]);
Nota: unset pódese utilizar para eliminar calquera variable que teñamos definida.
  • Vexamos un exemplo:
  1.     <?php
  2.         $ingredientes = ["améndoa","fresas","azucre","fariña"];
  3.         print_r($ingredientes);
  4.         unset($ingredientes[2]);
  5.         echo '<br />Despois de eliminar o número 2 (empeza en 0):';
  6.         print_r($ingredientes);
  7.        
  8.      ?>
Dará como resultado:
Array ( [0] => améndoa
        [1] => fresas
        [2] => azucre
        [3] => fariña )
Despois de eliminar o dato con clave 2:
Array ( [0] => améndoa
        [1] => fresas
        [3] => fariña )

Índices do Array

  • Hai que ter coidado cando eliminamos un elemento dun array, xa que os índices non se actualizan.
Así:
  1. <?php
  2. $a = array(1 => 'uno', 2 => 'dos', 3 => 'tres');
  3. unset($a[2]);
  4. /* producirá un array con estes índices
  5.    $a = array(1 => 'uno', 3 => 'tres');
  6. */
  7. ?>
Se queremos que os índices se actualicen teremos que facer uso da función array-values.
No exemplo anterior:
  1. <?php
  2. $a = array(1 => 'uno', 2 => 'dos', 3 => 'tres');
  3. unset($a[2]);
  4. $a = array_values($a);
  5. /* producirá un array con estes índices
  6.    $a = array(1 => 'uno', 2 => 'tres');
  7. */
  8. ?>

Modificar un elemento do array

  • Teremos que saber cal é a súa clave asociada: $array[clave]=novo_valor
  • Vexamos un exemplo:
  1.     <?php
  2.         $ingredientes = ["améndoa","fresas","azucre","fariña"];
  3.         print_r($ingredientes);
  4.         $ingredientes[2]='mel';
  5.         echo '<br />Despois de modificar o dato con clave 2:<br />';
  6.         print_r($ingredientes);
  7.      ?>
Dará como resultado:
Array ( [0] => améndoa [1] => fresas [2] => azucre [3] => fariña )

Despois de modificar o dato con clave 2:
Array ( [0] => améndoa [1] => fresas [2] => mel [3] => fariña )


Engadir novos elementos ao array

  • Para engadir un novo elemento só temos que facer uso dunha clave que non exista no array ou ben usar os corchetes baleiros para que asigne o seguinte valor numérico de clave.
  • Sería:
  • $array[nova_clave]=novo_valor;
  • $array[]=novo_valor;
A primeira forma permite facer uso de claves numéricas ou de cadea e a segunda forma sempre vai engadir unha clave numérica.
  • Vexamos un exemplo:
  1.     <?php
  2.         $ingredientes = ["améndoa","fresas","azucre","fariña"];
  3.         print_r($ingredientes);
  4.         $ingredientes[]='ovos';
  5.         echo '<br />Despois de engadir un novo ingrediente con clave 4:<br />';
  6.         print_r($ingredientes);
  7.      ?>
Dará como resultado:
Array ( [0] => améndoa [1] => fresas [2] => azucre [3] => fariña )

Despois de engadir un novo ingrediente con clave 4:
Array ( [0] => améndoa [1] => fresas [2] => azucre [3] => fariña [4] => ovos )
  • Outro exemplo:
  1.     <?php
  2.          $persoa = ['nome' => 'Juan Francisco',
  3.                      'direccion' => 'C/ Rúa de alá nº5',
  4.                      'telefono' =>'981121212'];
  5.          print_r($persoa);
  6.          echo '<br />Despois de engadir un novo dato:<br />';
  7.          $persoa['idade']=52;
  8.          print_r($persoa);
  9.      ?>
Dará como resultado:
Array ( [nome] => Juan Francisco [direccion] => C/ Rúa de alá nº5 [telefono] => 981121212 )

Despois de engadir un novo dato:
Array ( [nome] => Juan Francisco [direccion] => C/ Rúa de alá nº5 [telefono] => 981121212 [idade] => 52 )

Accedendo aos valores gardados no array (2ª forma)

  • Podemos facer uso da función count que devolve o número de elementos do array.
Vexamos un exemplo:
  1. <?php
  2.         $datos = ['casa','can','amigo'];
  3.         for ($cont=0; $cont<count($datos); $cont++){
  4.             printf("Dato:%s<br />",$datos[$cont]);
  5.         }
  6. ?>
Loxicamente esta forma de percorrer o array soamente funcionará cando os valores clave sexan de tipo numérico.
  • Nota: Hai que ter en conta que dita función devolve 0 se o array non está inicializado ou se o array está baleiro. Para distinguir os dous casos podemos facer uso da función isset vista anteriormente.
En caso de que non se poida contar (por exemplo se non é un array) devolve 1. Para saber se é un array lembrar que dispoñemos da función is_array.

Eliminando elementos do array

  • Non deberíamos eliminar un elemento do array mentres o estamos a percorrer desta forma se queremos continuar có resto de elementos.
  • Por exemplo:
  1. <?php
  2.         $datos = ['casa','can','amigo','coche'];
  3.         for ($cont=0; $cont<count($datos); $cont++){
  4.             if ($cont==1){
  5.                 unset($datos[$cont]);
  6.             }  else {
  7.                 printf("Dato:%s<br />",$datos[$cont]);
  8.             }
  9.         }
  10. ?>
Neste exemplo estamos a eliminar o elemento do array coa clave 1 que se corresponde có dato 'can'.
Php matrices 1.jpg
Como se pode comprobar nunca amosa o dato 'coche' xa que ao eliminar un elemento a función count se decrementa.

Accedendo aos valores gardados no array (3ª forma)

  • Cando percorremos un array podemos facer uso dun 'punteiro' que vai pasando de posición dun ao seguinte.
  • A función each permite movernos dun elemento do array ao seguinte.
Dita función devolve noutro array o valor do primeiro elemento do array e a clave asociada a ese valor. Ao mesmo tempo pasa ao seguinte elemento do array.
Pódese repetir dita operación ata chegar ao final do array. Nese intro a 'función each' devolve false.
  • O array de información que devolve a función é:
  • [1] ou ['value']: Devolve o valor do elemento do array.
  • [0] ou ['key']: Devolve a key asociada ao valor do elemento do array.
  • Por exemplo:
  1. <?php
  2.         $datos = ['casa','can','amigo','coche'];
  3.         $valor=each($datos);    // Le e pasa ao seguinte
  4.         printf("<br />Valor con \$valor[1]:%s",$valor[1]);
  5.         printf("<br />Valor con \$valor['value']:%s",$valor['value']);
  6.         printf("<br />Clave con \$valor[0]:%s",$valor[0]);
  7.         printf("<br />Clave con \$valor['key']:%s",$valor['key']);
  8.        
  9.         echo "<br />Lendo outro novo dato do array...<br />";
  10.        
  11.         $valor=each($datos); // Le e paso ao seguinte
  12.         printf("<br />Valor con \$valor[1]:%s",$valor[1]);
  13.         printf("<br />Valor con \$valor['value']:%s",$valor['value']);
  14.         printf("<br />Clave con \$valor[0]:%s",$valor[0]);
  15.         printf("<br />Clave con \$valor['key']:%s",$valor['key']);
  16.  
  17. ?>
Dará como resultado:
Valor con $valor[1]:casa
Valor con $valor['value']:casa
Clave con $valor[0]:0
Clave con $valor['key']:0
Lendo outro novo dato do array...

Valor con $valor[1]:can
Valor con $valor['value']:can
Clave con $valor[0]:1
Clave con $valor['key']:1
Nota: Lembrar que se estamos a percorrer o array antes de chegar a este código pode ser necesario 'resetear' o punteiro á posición inicial coa función reset().
  • Podemos utilizar unha estrutura de bucle para repetir a operación ata que chegue ao final:
  1. <?php
  2.         $datos = ['casa','can','amigo','coche'];
  3.         echo "Dentro dun bucle...<br />";
  4.         while($valor=each($datos)){
  5.             printf("<br />Valor con \$valor['value']:%s",$valor['value']);
  6.             printf("<br />Clave con \$valor['key']:%s",$valor['key']);
  7.         }
  8.         echo "<br />Acabou o bucle<br />";
  9. ?>
Dará como resultado:
Dentro dun bucle...

Valor con $valor['value']:casa
Clave con $valor['key']:0
Valor con $valor['value']:can
Clave con $valor['key']:1
Valor con $valor['value']:amigo
Clave con $valor['key']:2
Valor con $valor['value']:coche
Clave con $valor['key']:3
Acabou o bucle
Nota: Lembrar que se estamos a percorrer o array antes de chegar a este código pode ser necesario 'resetear' o punteiro á posición inicial coa función reset().


  • Relacionada coa función 'each' temos as seguintes funcións que modifican a posición do punteiro dentro do array:
  • función reset(): Establece o punteiro do array ao primeiro elemento.
  • función current(): Devolve o elemento actual ao que estar a apuntar o punteiro do array.
  • función next(): Avanza o punteiro unha posición cara adiante e devolve o elemento.
  • función prev(): Rebobina o punteiro unha posición cara atrás e devolve o elemento.

Eliminando elementos do array

  • Desta forma podemos eliminar os elementos do array dentro do bucle sen que pase nada.
Por exemplo:
  1. <?php
  2.         echo "Dentro dun bucle...<br />";
  3.         while($valor=each($datos)){
  4.             if ($valor['key']==1){
  5.                 unset($valor['key']);
  6.             }
  7.             else {
  8.                 printf("<br />Valor con \$valor['value']:%s",$valor['value']);
  9.                 printf("<br />Clave con \$valor['key']:%s",$valor['key']);
  10.             }
  11.         }
  12.         echo "<br />Acabou o bucle<br />";
  13. ?>
Dará como resultado:
Dentro dun bucle...

Valor con $valor['value']:casa
Clave con $valor['key']:0
Valor con $valor['value']:amigo
Clave con $valor['key']:2
Valor con $valor['value']:coche
Clave con $valor['key']:3
Acabou o bucle
Como vemos o elemento con valor de clave 1 foi eliminado dentro do bucle.

Accedendo aos valores gardados no array (4ª forma)

  • A sintaxe é a seguinte:
  1. foreach (expresión_array as $valor) {
  2.     sentencias
  3. }
  4.  
  5. OU
  6.  
  7. foreach (expresión_array as $clave => $valor) {
  8.     sentencias
  9. }
Na primeira forma recuperamos o valor de cada elemento do array en cada iteración do bucle for.
Na segunda forma recuperamos o valor e a clave de cada elemento do array en cada iteración do bucle for.
Vexamos un exemplo:
  1. <?php
  2.         $datos = ['casa','can','amigo','coche'];
  3.        
  4.         foreach($datos as $valor){
  5.             printf("O valor é:%s<br />",$valor);
  6.         }
  7. ?>
Dará como resultado:
O valor é:casa
O valor é:can
O valor é:amigo
O valor é:coche


  • Outro exemplo empregando a segunda forma:
  1. <?php
  2.         $datos = ['casa','can','amigo','coche'];
  3.        
  4.         foreach($datos as $clave => $valor){
  5.             printf("O valor da clave é: %s<br />",$clave);
  6.             printf("O valor é: %s<br />",$valor);
  7.         }
  8. ?>
Dará como resultado:
O valor da clave é: 0
O valor é: casa
O valor da clave é: 1
O valor é: can
O valor da clave é: 2
O valor é: amigo
O valor da clave é: 3
O valor é: coche


  • O bucle 'foreach' ten o seu propio punteiro interno e polo tanto non podemos utilizar a función 'current'.


Eliminando elementos do array

  • Desta forma podemos eliminar os elementos do array dentro do bucle sen que pase nada.
Por exemplo:
  1. <?php
  2.  
  3.         $datos = ['casa','can','amigo','coche'];
  4.        
  5.         foreach($datos as $clave => $valor){
  6.             if ($clave==1){
  7.                 unset($datos[$clave]);
  8.             }
  9.             else{
  10.                 printf("O valor da clave é: %s<br />",$clave);
  11.                 printf("O valor é: %s<br />",$valor);
  12.             }
  13.         }
  14. ?>
Dará como resultado:
O valor da clave é: 0
O valor é: casa
O valor da clave é: 2
O valor é: amigo
O valor da clave é: 3
O valor é: coche

Funcións predefinidas relacionadas cos Arrays

Algunha delas son:

Función array_keys

Por exemplo:
  1. <?php
  2. $array = array("un", "dous", "tres", "catro");
  3. foreach (array_keys($array) as $k) {
  4.   echo $k . '-';
  5. }
  6. ?>
Devolverá:
0-1-2-3-

Función list

A idea é que partindo dun array poidamos asociar a variables os valores gardados no array dunha forma rápida.
  • Importante: Só funciona con arrays que teñan claves de tipo numérico.
Por exemplo:
  1. <?php
  2. $array = array("un", "dous", "tres", "catro");
  3.  
  4. ?>
Se eu quero gardar cada elemento do array nunha variable tería que facer:
  1. <?php
  2.           $array = array("un", "dous", "tres", "catro");
  3.  
  4.           $var1=$array[0];
  5.           $var2=$array[1];
  6.           $var3=$array[2];
  7.           $var4=$array[3];
  8.  
  9. ?>
Pero usando list se pode facer:
  1. <?php
  2.           $array = array("un", "dous", "tres", "catro");
  3.           list($var1,$var2,$var3,$var4)=$array;
  4. ?>
Incluso se poden 'saltar' elementos do array:
  1. <?php
  2.           $array = array("un", "dous", "tres", "catro");
  3.           list(,$var2,,$var4)=$array;
  4. ?>

Función explode

O conxunto de valores virán nunha única variable separados por algún carácter (espazo en branco, coma,...)
Será necesario indicar na chamada á función o carácter de separación.
  • Por exemplo:
  1. <?php
  2.         $datos= "un | dous | tres | catro";
  3.         $array=  explode('|', $datos);
  4.         print_r($array);
  5. ?>
Dará como resultado:
Array ( [0] => un
        [1] => dous
        [2] => tres
        [3] => catro
      )


Función implode

  • Función implode: Fai o proceso contrario á función anterior. Converte un array a unha variable de cadea no que o seu valor é o conxunto de valores do array unidos cun carácter que ven indicado na función.
  • Por exemplo:
  1. <?php
  2.         $array = ['casa','can','amigo'];
  3.         $cadea=  implode('|', $array);
  4.         echo $cadea;
  5. ?>
Dará como resultado:
casa|can|amigo

Función asort

  • A función asort permite ordenar un array mantendo a asociación de índices. Quere isto dicir que se ordena o dato, pero non a clave asociada ao dato.
Devolve true en caso de éxito e false se houbo algún erro.
  • Por exemplo:
  1. <?php
  2.         $array = [1 => 'casa',2 => 'can',3 => 'amigo'];
  3.         if (asort($array)){
  4.             foreach ($array as $key => $valor){
  5.                printf("Clave:%d-----Valor:%s<br />",$key,$valor);  
  6.             }
  7.         }
  8.         else {
  9.           echo "Houbo un erro ao ordenar...";
  10.         }
  11. ?>
Dará como resultado:
Clave:3-----Valor:amigo
Clave:2-----Valor:can
Clave:1-----Valor:casa


  • Normalmente este tipo de ordenación se fai con arrays asociativos (de tipo 'key => value' na súa definición) no que non queremos perder a asociación das claves cos seus valores.
En caso de que non nos importe o valor da clave podemos ordenar o array coa función sort


Outras funcións relacionadas:

Verificando os datos dun formulario

  • Unha forma rápida de verificar que certos datos dun formulario teñan información sería:
  1. <?php  
  2. // Campos obrigatorios
  3. $campos_obrigatorios = array('txtNome', 'txtEmail');
  4.  
  5. // Comprobamos que os campos obrigatorios teñan datos
  6. $erro = false;
  7. foreach ($campos_obrigatorios as $campo) {
  8.   if (empty($_POST[$campo])) $erro = true;
  9. }
  10.  
  11. if ($erro) {
  12.   // Non existe algún dos campos obrigatorios
  13. }

Creando arrays cos datos dun formulario

  • Algunhas veces, cando xeramos formularios dinamicamente, teremos que asignar un nome a cada campo do formulario. Pero neste tipo de formularios dinámicos non sabemos cantos 'nomes' imos xerar.
  • Imaxinemos unha páxina na que queremos xerar dinamicamente un formulario de alta de novos exemplares dun libro determinado.
Así temos un libros cos seus datos (titulo, isbn,...)
Dispoñemos de exemplares no que queremos gardar: estado (bo, mal, normal).
Cando eu dea de alta o libro vou dar os seus datos máis o número de exemplares. Imaxinemos que poño que do libro 'A illa do tesouro' teño 3 exemplares.
Este dato pode variar dun libro a outro e non sei de antemán cantos exemplares vou ter.
Se creo agora o formulario para eses 3 exemplares tería que crear algo así:
  1. <input type='text' name='txtEstado1' />
  2. <input type='text' name='txtEstado2' />
  3. <input type='text' name='txtEstado3' />

Cando eu preme o 'action' do formulario os datos pasará á seguinte páxina e eu tería que saber cantos 'txtEstado?' se envían.

  • Unha forma moito máis sinxela de facelo é a seguinte:
  • Definimos o campo que vai levar o estado có seguinte nome: txtEstado[ ]
Creamos cada input desta forma:
  1. for($cont=0;$cont<$numExemplares;$cont++){
  2. <input type='text' name='txtEstado[]' />
  3. }
  • Cando estes datos cheguen á seguinte páxina o dato: $_POST['txtEstado'] vai ser un array cos datos de todos os exemplares e xa podemos traballar con el como ata o de agora.

Arrays multidimensionais

  • Os arrays vistos ata o de agora teñen unha dimensión.
Un array multidimensional é un array que a súa vez pode ter outros arrays para cada un dos elementos do array.


Accedendo ao array

  • A dimensión dun array indica o número de índices que se necesitan para acceder a un elemento do array.
  • Un array bidimensional necesita dous índices para acceder.
  • Un array tridimensional necesita tres índices para acceder.
  • Vexamos un exemplo:
  1. <?php
  2. $coches = array
  3.   (
  4.   array("Volvo",1990,'33500 euros'),
  5.   array("BMW",1980,'43000 euros'),
  6.   array("Opel",1995,'15000 euros'),
  7.   array("Peugot",1997,'13200 euros')
  8.   );
  9.  
  10. echo "Marca:" . $coches[0][0].": ano saída: ".$coches[0][1].", prezo: ".$coches[0][2].".<br>";
  11. echo "Marca:" . $coches[1][0].": ano saída: ".$coches[1][1].", prezo: ".$coches[1][2].".<br>";
  12. echo "Marca:" . $coches[2][0].": ano saída: ".$coches[2][1].", prezo: ".$coches[2][2].".<br>";
  13. echo "Marca:" . $coches[3][0].": ano saída: ".$coches[3][1].", prezo: ".$coches[3][2].".<br>";
  14. ?>
Produce de saída:
  1. Marca:Volvo: ano saída: 1990, prezo: 33500 euros.
  2. Marca:BMW: ano saída: 1980, prezo: 43000 euros.
  3. Marca:Opel: ano saída: 1995, prezo: 15000 euros.
  4. Marca:Peugot: ano saída: 1997, prezo: 13200 euros.
  • Podemos facer uso das formas anteriores para percorrer o array multidimensional, tendo en conta agora, que cada elemento do array ven ser outro array.
Vexamos isto aplicado ao exemplo anterior:
  1. foreach($coches as $coche){
  2.     echo "Un novo coche:<br />";
  3.     foreach ($coche as $valor){
  4.         printf("%s -",$valor);
  5.     }
  6.     echo "<br />";
  7. }
Produce de saída:
  1. Un novo coche:
  2. Volvo -1990 -33500 euros -
  3. Un novo coche:
  4. BMW -1980 -43000 euros -
  5. Un novo coche:
  6. Opel -1995 -15000 euros -
  7. Un novo coche:
  8. Peugot -1997 -13200 euros -


  • Podemos facer unha modificación ao exercicio anterior e engadir un campo clave de tipo cadea:
  1. $coches = array
  2.   (
  3.   array("Marca" => "Volvo","Ano saída" => 1990,"Prezo"=>'33500 euros'),
  4.   array("Marca" => "BMW","Ano saída" => 1980,"Prezo"=>'43000 euros'),
  5.   array("Marca" => "Opel","Ano saída" => 1995,"Prezo"=>'15000 euros'),
  6.   array("Marca" => "Peugot","Ano saída" => 1997,"Prezo"=>'13200 euros')
  7.   );
  8.  
  9. foreach($coches as $coche){
  10.     echo "Un novo coche:<br />";
  11.     foreach ($coche as $clave=>$valor){
  12.         printf("; %s : %s",$clave,$valor);
  13.     }
  14.     echo "<br />";
  15. }


Produce de saída:
  1. Un novo coche:
  2. ; Marca : Volvo; Ano saída : 1990; Prezo : 33500 euros
  3. Un novo coche:
  4. ; Marca : BMW; Ano saída : 1980; Prezo : 43000 euros
  5. Un novo coche:
  6. ; Marca : Opel; Ano saída : 1995; Prezo : 15000 euros
  7. Un novo coche:
  8. ; Marca : Peugot; Ano saída : 1997; Prezo : 13200 euros


Borrando datos do array

  • Este é un exemplo utilizando a forma foreach para percorrer o array.
Podería facerse doutras formas.
  • Neste exemplo temos un array cos seguintes datos:
            $coches = array
              (
               array("Volvo",1990,'33500 euros'),
               array("BMW",1980,'43000 euros'),
               array("Opel",1995,'15000 euros'),
               array("Peugot",1997,'13200 euros')
              );
  • O que imos facer no exemplo é borrar o coche con clave 1 (o coche BMW) e imos borrar o dato do ano de lanzamento de todos os arrays (datos 1990,1980,1995,1997)
  1. <?php
  2.             $coches = array
  3.               (
  4.                array("Volvo",1990,'33500 euros'),
  5.                array("BMW",1980,'43000 euros'),
  6.                array("Opel",1995,'15000 euros'),
  7.                array("Peugot",1997,'13200 euros')
  8.               );
  9.  
  10.             // Amosamos os datos
  11.             foreach($coches as $key=>$value){
  12.                 echo "<br />Coche num.:" . $key . "<br />";
  13.                 foreach($value as $key_datos => $value_datos){
  14.                     echo ' ' . $key_datos . "---->" . $value_datos;
  15.                 }
  16.  
  17.             }
  18.  
  19.  
  20.             echo "<br /><br />";
  21.  
  22.             // Borramos o coche2
  23.             foreach($coches as $key=>$value){
  24.                 if ($key==1) {  // Borramos o coche2
  25.                     unset($coches[$key]); // Borramos a fila 1 (empeza en 0)
  26.                }
  27.                 else {
  28.                     foreach($value as $key_datos => $value_datos){
  29.                         if ($key_datos==1) { // Borra o ano de lanzamento
  30.                             unset($coches[$key][$key_datos]); // Borramos a columna ano de lanzamento
  31.                         }
  32.                     }
  33.                 }
  34.  
  35.             }
  36.  
  37.             foreach($coches as $key=>$value){
  38.                 echo "<br />Coche num.:" . $key . "<br />";
  39.                 foreach($value as $key_datos => $value_datos){
  40.                     echo ' ' . $key_datos . "---->" . $value_datos;
  41.                 }
  42.  
  43.             }
  44. ?>
  • Liña 25: Nesta liña borra o coche con clave 1 (o segundo coche). Fixarse como para borrar un elemento do array temos que facelo usando o nome do array e a clave asociada ao elemento.
  • Liña 30: unset($coches[$key][$key_datos]);
Nesta liña borramos o dato 'ano de lanzamento' de cada coche.
$value => é o array cos datos. Por exemplo, no coche con índice 0 ten de valor: array("Volvo",1990,'33500 euros')
O que facemos no segundo bucle foreach é percorrer dito array ,polo tanto as variables $key_datos e $value_datos van ter de valor:
0 => "Volvo"; 1 => 1990; 2 => '33500 euros'
Fixarse como para eliminar un elemento do array dentro doutro array temos que facer a referencia dende o array pai ($coches).
Non vale poñer: unset($value[$key_datos]);
  • Lembrar que o bucle 'foreach' ten o seu propio punteiro interno e polo tanto non podemos utilizar a función 'current'.


Dará como resultado:
Coche num.:0
0---->Volvo 1---->1990 2---->33500 euros
Coche num.:1
0---->BMW 1---->1980 2---->43000 euros
Coche num.:2
0---->Opel 1---->1995 2---->15000 euros
Coche num.:3
0---->Peugot 1---->1997 2---->13200 euros


Borramos o coche número 1 e o dato 'ano de lanzamento' de todos.

Coche num.:0
0---->Volvo 2---->33500 euros
Coche num.:2
0---->Opel 2---->15000 euros
Coche num.:3
0---->Peugot 2---->13200 euros

Engadido datos ao array

  • Imaxinemos que queremos engadir o seguinte dato ao array anterior:
"Lancia", 1998, '10212 euros'
  • Partindo do exemplo anterior:
  1.             $dato_novo = array("Lancia",1998,"10212 euros");
  2.             $coches[]=$dato_novo;


  • Outra forma é utilizando a función array_push, pero é máis rápida a forma anterior (non hai que chamar a unha función).
  1.             $dato_novo = array("Lancia",1998,"10212 euros");
  2.             array_push($coches, $dato_novo);


En ambos casos dará como resultado:
Coche num.:0
0---->Volvo 2---->33500 euros
Coche num.:2
0---->Opel 2---->15000 euros
Coche num.:3
0---->Peugot 2---->13200 euros
Coche num.:4
0---->Lancia 1---->1998 2---->10212 euros



-- Ángel D. Fernández González -- (2016).