martes, 8 de mayo de 2012

Uso array-Tipos declaraciones-Funciones de Arrays


CREACION DE ARRAYS

Crear un array en PHP es muy sencillo ya que no necesitamos declarar el tipo de datos que almacenará nuestro array, veamos algunos ejemplos de creación de arrays en PHP.

<?php  
  
    /* Declaracion de arrays */  
      
    // declaracion con asignacion directa  
    $telefono['t1'] = 7599665;  
    $telefono['t2'] = 7599666;  
      
    // Arrays de una dimension [n]  
      
    // declaracion usando array()  
    $nombres = array();   
      
    $nombres[0] = 'Juan Perez';  
    $nombres[1] = 'Juan Rocas';  
    $nombres[2] = 'Juan Medina';  
      
    // declaracion usando array   
    // y declaracion directa  
    $direccion = array(1=>'calle1',2 => 'calle2', 3 => 'calle3');  
  
 
<?php
 
 /* Declaracion de arrays */
 
 // declaracion con asignacion directa
 $telefono['t1'] = 7599665;
 $telefono['t2'] = 7599666;
 
 // Arrays de una dimension [n]
 
 // declaracion usando array()
 $nombres = array(); 
 
 $nombres[0] = 'Juan Perez';
 $nombres[1] = 'Juan Rocas';
 $nombres[2] = 'Juan Medina';
 
 // declaracion usando array 
 // y declaracion directa
 $direccion = array(1=>'calle1',2 => 'calle2', 3 => 'calle3');
 
Para poder acceder a los valores de nuestro array debemos hacerlo a través de los índices o keys (el valor entre corchetes). Aca unos ejemplos prácticos.

<?php  
/* Declaracion de arrays */  
/* 
    Codigo anterior 
*/  
 /* Acceder a los valores del array*/  
      
echo $nombres[1];     // Juan Rocas  
echo $telefono['t1']; //    7599665   
echo $direccion[2];  //calle2     
  
<?php
/* Declaracion de arrays */
/*
 Codigo anterior
*/
 /* Acceder a los valores del array*/
 
echo $nombres[1];     // Juan Rocas
echo $telefono['t1']; // 7599665 
echo $direccion[2];  //calle2 
 
Por otro lado los arrays pueden ser multidimensionales, es decir que pueden tener más de un índice o key, lo cual permite almacenar más valores.
Entendámoslo con un ejemplo:
<?php  
    /* Array multidimensionales */  
      
    $fruta = array(); // defino mi array  
      
    $fruta['color'][0] = 'verde';  
    $fruta['nombre'][0] = 'pera';  
    $fruta['peso'][0] = '100gr';  
      
    $fruta['color'][1] = 'rojo';  
    $fruta['nombre'][1] = 'manzana';  
    $fruta['peso'][1] = '110gr';  
      
    $fruta['color'][2] = 'naranja';  
    $fruta['nombre'][2] = 'naranja';  
    $fruta['peso'][2] = '120gr';  
      
    $fruta['color'][3] = 'amarillo';  
    $fruta['nombre'][3] = 'platano';  
    $fruta['peso'][3] = '150gr';  
      
    // Acceder a los datos de frutas  
    echo $fruta['color'][0]; //verde  
    echo $fruta['nombre'][2]; //naranja  
    echo $fruta['peso'][3]; //150gr   
<?php
  /* Array multidimensionales */
 
 $fruta = array(); // defino mi array
 
 $fruta['color'][0] = 'verde';
 $fruta['nombre'][0] = 'pera';
 $fruta['peso'][0] = '100gr';
 
    $fruta['color'][1] = 'rojo';
 $fruta['nombre'][1] = 'manzana';
 $fruta['peso'][1] = '110gr';
 
 $fruta['color'][2] = 'naranja';
 $fruta['nombre'][2] = 'naranja';
 $fruta['peso'][2] = '120gr';
 
 $fruta['color'][3] = 'amarillo';
 $fruta['nombre'][3] = 'platano';
 $fruta['peso'][3] = '150gr';
 
 // Acceder a los datos de frutas
 echo $fruta['color'][0]; //verde
 echo $fruta['nombre'][2]; //naranja
 echo $fruta['peso'][3]; //150gr
 
Los arrays en PHP son muy útiles al momento de programar, su versatilidad en PHP nos permite guardar múltiples tipos de datos en un solo array.
A continuación un ejemplo hipotético:

<?php  
  
    //Array Versatil  
      
    $numeros = array();  
      
    $numeros[1] = 100;  
    $numeros[2] = 200;  
    $numeros[3] = 300;  
    $numeros[4] = 400;  
      
    $letras = array();  
      
    $letras['min'][1] = 'a';  
    $letras['may'][1] = 'A';  
      
    $letras['min'][2] = 'b';  
    $letras['may'][2] = 'B';  
      
    $letras['min'][3] = 'c';  
    $letras['may'][3] = 'C';  
      
    $letras['min'][4] = 'd';  
    $letras['may'][4] = 'D';  
      
      
    $versatil = array  
                (  
                  'numeros' => $numeros,  
                  'letras'  => $letras,  
                  'estado'  => true,  
                   0        => false  
                );        
      
    var_dump($versatil['numeros']);  
      
    var_dump($versatil[0]);   
<?php
 
 //Array Versatil
 
 $numeros = array();
 
 $numeros[1] = 100;
 $numeros[2] = 200;
 $numeros[3] = 300;
 $numeros[4] = 400;
 
 $letras = array();
 
 $letras['min'][1] = 'a';
 $letras['may'][1] = 'A';
 
 $letras['min'][2] = 'b';
 $letras['may'][2] = 'B';
 
 $letras['min'][3] = 'c';
 $letras['may'][3] = 'C';
 
 $letras['min'][4] = 'd';
 $letras['may'][4] = 'D';
 
 
 $versatil = array
             (
        'numeros' => $numeros,
        'letras'  => $letras,
        'estado'  => true,
         0        => false
      );   
 
 var_dump($versatil['numeros']);
 
 var_dump($versatil[0]);
 
Recuerda siempre que los índices de un array solo pueden ser numéricos ó cadenas.

INTERACCION CON ARRAYS

La interacción con arrays y sus valores es útil cuando queremos evaluar alguna condición en función de los valores encontrados.
Por otra parte en el tutorial de estructuras de control de flujo no tocamos el uso de la estructura de foreach , así que este es un buen momento para ver su funcionamiento con ejemplo práctico.

<?php  
  
    //Array   
      
    $animales = array  
                (  
                  1 => 'oso',  
                  2 => 'perro',  
                  3 => 'gato',  
                  4 => 'leon',  
                  5 => 'alcon',  
                  6 => 'burro',  
                  7 => 'mono',  
                    
                );  
                  
    //Interaccion con foreach  
      
    foreach($animales as $animal)  
    {  
        echo $animal;  
    }  
    
<?php
 
  //Array 
  
  $animales = array
      (
        1 => 'oso',
        2 => 'perro',
        3 => 'gato',
        4 => 'leon',
        5 => 'alcon',
        6 => 'burro',
        7 => 'mono',
        
      );
      
  //Interaccion con foreach
  
  foreach($animales as $animal)
  {
   echo $animal;
  }
Otra forma muy usada de recorrer un array es por medio de un while

<?php 
 
    //Array  
     
    $animales = array 
                ( 
                  1 => 'oso', 
                  2 => 'perro', 
                  3 => 'gato', 
                  4 => 'leon', 
                  5 => 'alcon', 
                  6 => 'burro', 
                  7 => 'mono', 
                   
                ); 
                 
    //Interaccion con while 
     
    while($animal = current($animales)) 
    { 
        echo $animal; 
        next($animales); // siguiente array 
    } 
       
<?php
 
  //Array 
  
  $animales = array
      (
        1 => 'oso',
        2 => 'perro',
        3 => 'gato',
        4 => 'leon',
        5 => 'alcon',
        6 => 'burro',
        7 => 'mono',
        
      );
      
  //Interaccion con while
  
  while($animal = current($animales))
  {
   echo $animal;
   next($animales); // siguiente array
  }
   
Obviamente la primera forma es más práctica, esto sin menos preciar la segunda.

FUNCIONES CON ARRAYS

Existen muchas funciones que nos permiten trabajar de una manera sencilla con los arrays, en esta oportunidad solo haré referencia a las más usadas.
Función count($array) devuelve el número de elementos que posee un array.

<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  3 => 'tres',  
                  4 => 'cuatro',  
                  5 => 'cinco',  
                  6 => 'seis',  
                  7 => 'siete',  
                    
                );  
                  
   echo count($numeros); // 7  
                   
<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       3 => 'tres',
       4 => 'cuatro',
       5 => 'cinco',
       6 => 'seis',
       7 => 'siete',
      
     );
     
   echo count($numeros); // 7
    
Función in_array($valor,$array) buscar un valor dentro de un array y devuelve true o false según sea el caso.

<?php 
 
    //Array  
     
    $numeros = array 
                ( 
                  1 => 'uno', 
                  2 => 'dos', 
                  3 => 'tres', 
                  4 => 'cuatro', 
                  5 => 'cinco', 
                  6 => 'seis', 
                  7 => 'siete', 
                   
                ); 
                 
   echo in_array('tres',$numeros); // true (1)  
   echo in_array('cien',$numeros); //false (0) 

<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       3 => 'tres',
       4 => 'cuatro',
       5 => 'cinco',
       6 => 'seis',
       7 => 'siete',
       
     );
     
   echo in_array('tres',$numeros); // true (1)
   echo in_array('cien',$numeros); //false (0)
Función array_flip($array) intercambia los valores por índices y los índices por valores.
<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  3 => 'tres',  
                  4 => 'cuatro',  
                  5 => 'cinco',  
                  6 => 'seis',  
                  7 => 'siete',  
                    
                );  
          
   var_dump($numeros);  
     
  
     
   /* 
           array(7) { 
          [1]=> 
          string(3) "uno" 
          [2]=> 
          string(3) "dos" 
          [3]=> 
          string(4) "tres" 
          [4]=> 
          string(6) "cuatro" 
          [5]=> 
          string(5) "cinco" 
          [6]=> 
          string(4) "seis" 
          [7]=> 
          string(5) "siete" 
        } 
            
   */  
     
  // nuevo numeros  
   $numeros = array_flip($numeros);  
      
   var_dump($numeros);    
     
   /* 
    
           array(7) { 
          ["uno"]=> 
          int(1) 
          ["dos"]=> 
          int(2) 
          ["tres"]=> 
          int(3) 
          ["cuatro"]=> 
          int(4) 
          ["cinco"]=> 
          int(5) 
          ["seis"]=> 
          int(6) 
          ["siete"]=> 
          int(7) 
        } 
   */  
     
    
<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       3 => 'tres',
       4 => 'cuatro',
       5 => 'cinco',
       6 => 'seis',
       7 => 'siete',
       
     );
  
   var_dump($numeros);
   
 
   
   /*
     array(7) {
    [1]=>
    string(3) "uno"
    [2]=>
    string(3) "dos"
    [3]=>
    string(4) "tres"
    [4]=>
    string(6) "cuatro"
    [5]=>
    string(5) "cinco"
    [6]=>
    string(4) "seis"
    [7]=>
    string(5) "siete"
  }
     
   */
   
  // nuevo numeros
   $numeros = array_flip($numeros);
    
   var_dump($numeros); 
   
   /*
   
     array(7) {
    ["uno"]=>
    int(1)
    ["dos"]=>
    int(2)
    ["tres"]=>
    int(3)
    ["cuatro"]=>
    int(4)
    ["cinco"]=>
    int(5)
    ["seis"]=>
    int(6)
    ["siete"]=>
    int(7)
  }
   */
   
 
Función arra_push($array,$mix) agregar los valores a nuestro a un array
<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  3 => 'tres',  
                  4 => 'cuatro',  
                  5 => 'cinco',  
                  6 => 'seis',  
                  7 => 'siete',  
                    
                );  
                  
   // $numeros antes :                
   var_dump($numeros);  
     
   /* 
       array(7) { 
      [1]=> 
      string(3) "uno" 
      [2]=> 
      string(3) "dos" 
      [3]=> 
      string(4) "tres" 
      [4]=> 
      string(6) "cuatro" 
      [5]=> 
      string(5) "cinco" 
      [6]=> 
      string(4) "seis" 
      [7]=> 
      string(5) "siete" 
    } 
   */  
  
     
   array_push($numeros,'ocho','nueve','diez');  
     
   // $numeros despues :  
   var_dump($numeros);  
      
<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       3 => 'tres',
       4 => 'cuatro',
       5 => 'cinco',
       6 => 'seis',
       7 => 'siete',
       
     );
     
   // $numeros antes :     
   var_dump($numeros);
   
   /*
    array(7) {
   [1]=>
   string(3) "uno"
   [2]=>
   string(3) "dos"
   [3]=>
   string(4) "tres"
   [4]=>
   string(6) "cuatro"
   [5]=>
   string(5) "cinco"
   [6]=>
   string(4) "seis"
   [7]=>
   string(5) "siete"
 }
   */
 
   
   array_push($numeros,'ocho','nueve','diez');
   
   // $numeros despues :
   var_dump($numeros);
  

ORDENAMIENTO CON ARRAYS

PHP nos brinda un conjunto de funciones que no permiten ordenar arrays.

Función asort ($array) 
 ordena un array en forma ascendente en función a los valores.

<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  4 => 'cuatro',  
                  3 => 'tres',  
                  6 => 'seis',  
                  5 => 'cinco',  
                  7 => 'siete',  
                    
                );  
                  
  asort($numeros);   
  var_dump($numeros);  
    /* 
          Salida: 
          array(7) { 
          [5]=> 
          string(5) "cinco" 
          [4]=> 
          string(6) "cuatro" 
          [2]=> 
          string(3) "dos" 
          [6]=> 
          string(4) "seis" 
          [7]=> 
          string(5) "siete" 
          [3]=> 
          string(4) "tres" 
          [1]=> 
          string(3) "uno" 
        }    
     
    */  
       
<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       4 => 'cuatro',
       3 => 'tres',
       6 => 'seis',
       5 => 'cinco',
       7 => 'siete',
       
     );
     
  asort($numeros); 
  var_dump($numeros);
 /*
    Salida:
    array(7) {
    [5]=>
    string(5) "cinco"
    [4]=>
    string(6) "cuatro"
    [2]=>
    string(3) "dos"
    [6]=>
    string(4) "seis"
    [7]=>
    string(5) "siete"
    [3]=>
    string(4) "tres"
    [1]=>
    string(3) "uno"
  } 
 
 */
   
Función arsort ($array) 
ordena un array en forma descendente en función a los valores.

<?php 
 
    //Array  
     
    $numeros = array 
                ( 
                  1 => 'uno', 
                  2 => 'dos', 
                  4 => 'cuatro', 
                  3 => 'tres', 
                  6 => 'seis', 
                  5 => 'cinco', 
                  7 => 'siete', 
                   
                ); 
                 
  arsort($numeros);  
  var_dump($numeros); 
    /*
          Salida:
        
         array(7) {
      [1]=>
      string(3) "uno"
      [3]=>
      string(4) "tres"
      [7]=>
      string(5) "siete"
      [6]=>
      string(4) "seis"
      [2]=>
      string(3) "dos"
      [4]=>
      string(6) "cuatro"
      [5]=>
      string(5) "cinco"
    }
    
    */ 
      
<?php

 

 //Array 

 

 $numeros = array

     (

       1 => 'uno',

       2 => 'dos',

       4 => 'cuatro',

       3 => 'tres',

       6 => 'seis',

       5 => 'cinco',

       7 => 'siete',

       

     );

     

  arsort($numeros); 

  var_dump($numeros);

 /*

    Salida:

  

   array(7) {

   [1]=>

   string(3) "uno"

   [3]=>

   string(4) "tres"

   [7]=>

   string(5) "siete"

   [6]=>

   string(4) "seis"

   [2]=>

   string(3) "dos"

   [4]=>

   string(6) "cuatro"

   [5]=>

   string(5) "cinco"

 }

 

 */

   

Función ksort ($array) ordena un array en forma ascendente en función a los índices.
view plainprint?
<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  4 => 'cuatro',  
                  3 => 'tres',  
                  5 => 'cinco',  
                  7 => 'siete',  
                  6 => 'seis',  
            
                );                
  ksort($numeros);   
  var_dump($numeros);  
    /* 
          Salida: 
         
        array(7) { 
      [1]=> 
      string(3) "uno" 
      [2]=> 
      string(3) "dos" 
      [3]=> 
      string(4) "tres" 
      [4]=> 
      string(6) "cuatro" 
      [5]=> 
      string(5) "cinco" 
      [6]=> 
      string(4) "seis" 
      [7]=> 
      string(5) "siete" 
    } 
     
    */  
     
    
<?php
 
 //Array 
 
 $numeros = array
     (
       1 => 'uno',
       2 => 'dos',
       4 => 'cuatro',
       3 => 'tres',
       5 => 'cinco',
       7 => 'siete',
       6 => 'seis',
    
     );     
  ksort($numeros); 
  var_dump($numeros);
 /*
    Salida:
  
  array(7) {
   [1]=>
   string(3) "uno"
   [2]=>
   string(3) "dos"
   [3]=>
   string(4) "tres"
   [4]=>
   string(6) "cuatro"
   [5]=>
   string(5) "cinco"
   [6]=>
   string(4) "seis"
   [7]=>
   string(5) "siete"
 }
 
 */
    
 
Función krsort ($array)
ordena un array en forma descendente en función a los índices.
<?php  
  
    //Array   
      
    $numeros = array  
                (  
                  1 => 'uno',  
                  2 => 'dos',  
                  4 => 'cuatro',  
                  3 => 'tres',  
                  5 => 'cinco',  
                  7 => 'siete',  
                  6 => 'seis',  
            
                );                
  krsort($numeros);   
  var_dump($numeros);  
    /* 
          Salida: 
         
        array(7) { 
      [7]=> 
      string(5) "siete" 
      [6]=> 
      string(4) "seis" 
      [5]=> 
      string(5) "cinco" 
      [4]=> 
      string(6) "cuatro" 
      [3]=> 
      string(4) "tres" 
      [2]=> 
      string(3) "dos" 
      [1]=> 
      string(3) "uno" 
    } 
     
    */ 
      

MODIFICAR ELEMENTOS DE UN ARRAY

Ahora vamos a ver varios ejemplos mediante los cuales nuestros arrays pueden aumentar o reducir el número de casillas disponibles.

Reducir el tamaño de un array

array_slice()
Para disminuir el número de casillas de un arreglo tenemos varias funciones. Entre ellas, array_slice() la utilizamos cuando queremos recortar algunas casillas del arreglo, sabiendo los índices de las casillas que deseamos conservar.
Recibe tres parámetros. El array, el índice del primer elemento y el número de elementos a tomar, siendo este último parámetro opcional.
En el ejemplo siguiente tenemos un array con cuatro nombres propios. En la primera ejecución de array_slice() estamos indicando que deseamos tomar todos los elementos desde el índice 0 (el principio) hasta un número total de 3 elementos.
El segundo array_slice() indica que se tomen todos los elementos a partir del índice 1 (segunda casilla).

<?
$entrada = array ("Miguel", "Pepe", "Juan", "Julio", "Pablo");

//modifico el tamaño
$salida = array_slice ($entrada, 0, 3);
//muestro el array
foreach ($salida as $actual)
    echo $actual . "<br>";
echo "<p>";
//modifico otra vez
$salida = array_slice ($salida, 1);
//muestro el array
foreach ($salida as $actual)
    echo $actual . "<br>";
?>
Tendrá como salida:
Miguel
Pepe
Juan
Pepe
Juan 

array_shift()
Esta función extrae el el primer elemento del array y lo devuelve. Además, acorta la longitud del array eliminando el elemento que estaba en la primera casilla. Siempre hace lo mismo, por tanto, no recibirá más que el array al que se desea eliminar la primera posición.
En el código siguiente se tiene el mismo vector con nombres propios y se ejecuta dos veces la función array_shift() eliminando un elemento en cada ocasión. Se imprimen los valores que devuelve la función y los elementos del array resultante de eliminar la primera casilla.

<?
$entrada = array ("Miguel", "Pepe", "Juan", "Julio", "Pablo");
//quito la primera casilla
$salida = array_shift ($entrada);
//muestro el array
echo "La función devuelve: " . $salida . "<br>";
foreach ($entrada as $actual)
    echo $actual . "<br>";
echo "<p>";
//quito la primera casilla, que ahora sería la segunda del array original
$salida = array_shift ($entrada);
echo "La función devuelve: " . $salida . "<br>";
//muestro el array
foreach ($entrada as $actual)
    echo $actual . "<br>";
?>
Da como resultado:
La función devuelve: Miguel
Pepe
Juan
Julio
Pablo
La función devuelve: Pepe
Juan
Julio
Pablo 

unset()
Se utiliza para destruir una variable dada. En el caso de los arreglos, se puede utilizar para eliminar una casilla de un array asociativo (los que no tienen índices numéricos sino que su índice es una cadena de caracteres).
Veamos el siguiente código para conocer cómo definir un array asociativo y eliminar luego una de sus casillas.

<?
$estadios_futbol = array("Barcelona"=> "Nou Camp","Real Madrid" => "Santiago Bernabeu","Valencia" => "Mestalla","Real Sociedad" => "Anoeta");
//mostramos los estadios
foreach ($estadios_futbol as $indice=>$actual)
    echo $indice . " -- " . $actual . "<br>";
echo "<p>";
//eliminamos el estadio asociado al real madrid
unset ($estadios_futbol["Real Madrid"]);
//mostramos los estadios otra vez
foreach ($estadios_futbol as $indice=>$actual)
echo $indice . " -- " . $actual . "<br>";
?>
La salida será la siguiente:
Barcelona -- Nou Camp
Real Madrid -- Santiago Bernabeu
Valencia -- Mestalla
Real Sociedad -- Anoeta
Barcelona -- Nou Camp
Valencia -- Mestalla
Real Sociedad -- Anoeta

AUMENTAR TAMAÑO ARRAY

Tenemos también a nuestra disposición varias funciones que nos pueden ayudar a aumentar el número de casillas de un arreglo. 

array_push()
Inserta al final del array una serie de casillas que se le indiquen por parámetro. Por tanto, el número de casillas del array aumentará en tantos elementos como se hayan indicado en el parámetro de la función. Devuelve el número de casillas del array resultante.
Veamos este código donde se crea un arreglo y se añaden luego tres nuevos valores.

<?
$tabla = array ("Lagartija", "Araña", "Perro", "Gato", "Ratón");
//aumentamos el tamaño del array
array_push($tabla, "Gorrión", "Paloma", "Oso");
foreach ($tabla as $actual)
    echo $actual . "<br>";
?>
Da como resultado esta salida:
Lagartija
Araña
Perro
Gato
Ratón
Gorrión
Paloma
Oso 

array_merge()
Ahora vamos a ver cómo unir dos arrays utilizando la función array_merge(). A ésta se le pasan dos o más arrays por parámetro y devuelve un arreglo con todos los campos de los vectores pasados.
En este código de ejemplo creamos tres arrays y luego los unimos con la función array_merge()

<?
$tabla = array ("Lagartija", "Araña", "Perro", "Gato", "Ratón");
$tabla2 = array ("12","34","45","52","12");
$tabla3 = array ("Sauce","Pino","Naranjo","Chopo","Perro","34");
//aumentamos el tamaño del array
$resultado = array_merge($tabla, $tabla2, $tabla3);
foreach ($resultado as $actual)
    echo $actual . "<br>";
?>
Da como resultado:
Lagartija
Araña
Perro
Gato
Ratón
12
34
45
52
12
Sauce
Pino
Naranjo
Chopo
Perro
34 

Una última cosa. También pueden introducirse nuevas casillas en un arreglo por los métodos habituales de asignar las nuevas posiciones en el array a las casillas que necesitemos.
En arrays normales se haría así:

$tabla = array ("Sauce","Pino","Naranjo");
$tabla[3]="Algarrobo"; 

En arrays asociativos:

$estadios_futbol = array("Valencia" => "Mestalla","Real Sociedad" => "Anoeta");
$estadios_futbol["Barcelona"]= "Nou Camp"; 

Veremos más adelante otras posibilidades del trabajo con arrays.




TIPOS DE ARRAYS

  • array_change_key_case — Cambia todas las claves en un array
  • array_chunk — Divide un array en fragmentos
  • array_combine — Crea un nuevo array, usando una matriz para las claves y otra para sus valores
  • array_count_values — Cuenta todos los valores de un array
  • array_diff_assoc — Calcula la diferencia entre arrays con un chequeo adicional de índices
  • array_diff_key — Calcula la diferencia entre arrays usando las keys para la comparación
  • array_diff_uassoc — Calcula la diferencia entre arrays con un chequeo adicional de índices que se realiza por una función de devolución de llamada suministrada por el usuario
  • array_diff_ukey — Calcula la diferencia entre arrays usando una función de devolución de llamada en las keys para comparación
  • array_diff — Calcula la diferencia entre arrays
  • array_fill_keys — Llena un array con valores, especificando las keys
  • array_fill — Llena un array con valores
  • array_filter — Filtra elementos de un array usando una función de devolución de llamada
  • array_flip — Intercambia todas las keys con sus valores asociados en un array
  • array_intersect_assoc — Calcula la intersección de arrays con un chequeo adicional de índices
  • array_intersect_key — Calcula la intersección de arrays usando las keys para la comparación
  • array_intersect_uassoc — Calcula la intersección de arrays con un chequeo adicional de índices que se realiza por una función de devolución de llamada
  • array_intersect_ukey — Calcula la intersección de arrays usando una función de devolución de llamada en las keys para la comparación
  • array_intersect — Calcula la intersección de arrays
  • array_key_exists — Verifica si el índice o clave dada existe en el array
  • array_keys — Devuelve todas las claves de un array o un subconjunto de claves de un array
  • array_map — Aplica la llamada de retorno especificada a los elementos de los dados
  • array_merge_recursive — Une dos o más arrays recursivamente
  • array_merge — Combina dos o más arrays
  • array_multisort — Ordena múltiples arrays, o arrays multi-dimensionales
  • array_pad — Rellena un array a la longitud especificada con un valor
  • array_pop — Extrae el último elemento del final del array
  • array_product — Calcula el producto de los valores en el array
  • array_push — Inserta uno o más elementos al final de un array
  • array_rand — Selecciona una o más entradas aleatorias de un array
  • array_reduce — Reduce iterativamente una matriz a un solo valor usando una función llamada de retorno
  • array_replace_recursive — Reemplaza los elementos de los arrays pasados al primer array de forma recursiva
  • array_replace — Remplaza los elementos de los arrays pasados en el primer array
  • array_reverse — Devuelve un array con los elementos en orden inverso
  • array_search — Busca un valor determinado en un array y devuelve la clave correspondiente en caso de éxito
  • array_shift — Quita un elemento del principio del array
  • array_slice — Extrae una parte de un array
  • array_splice — Elimina una porción del array y la reemplaza con algo
  • array_sum — Calcula la suma de los valores en un array
  • array_udiff_assoc — Computa la diferencia entre arrays con una comprobación de indices adicional, compara la información mediante una función de llamada de retorno
  • array_udiff_uassoc — Computa la diferencia entre arrays con una verificación de índices adicional, compara la información y los índices mediante una función de llamada de retorno
  • array_udiff — Computa la diferencia entre arrays, usando una llamada de retorno para la comparación de datos
  • array_uintersect_assoc — Computa la intersección de arrays con una comprobación de índices adicional, compara la información mediante una función de llamada de retorno
  • array_uintersect_uassoc — Computa la intersección de arrays con una comprobación de índices adicional, compara la información y los índices mediante funciones de llamada de retorno
  • array_uintersect — Computa una intersección de arrays, compara la información mediante una función de llamada de retorno
  • array_unique — Elimina valores duplicados de un array
  • array_unshift — Añadir al inicio de un array uno a más elementos
  • array_values — Devuelve todos los valores de un array
  • array_walk_recursive — Aplicar una función de usuario recursivamente a cada miembro de un array
  • array_walk — Aplicar una función de usuario a cada miembro de un array
  • array — Crea un array
  • arsort — Ordena un array en orden inverso y mantiene la asociación de índices
  • asort — Ordena un array y mantiene la asociación de índices
  • compact — Crear un array que contiene variables y sus valores
  • count — Cuenta todos los elementos de un array o en un objecto
  • current — Devuelve el elemento actual en un array
  • each — Devolver el par clave/valor actual de un array y avanzar el cursor del array
  • end — Establece el puntero intero de un array a su último elemento
  • extract — Importar variables a la tabla de símbolos actual desde un array
  • in_array — Comprueba si un valor existe en un array usando comparación flexible
  • key — Obtiene una clave de un array
  • krsort — Ordena un array por clave en orden inverso
  • ksort — Ordena un array por clave
  • list — Asigna variables como si fuera un array
  • natcasesort — Ordenar un array usando un algoritmo de "orden natural" insensible a mayúsculas-minúsculas
  • natsort — Ordena un array usando un algoritmo de "orden natural"
  • next — Avanza el puntero interno de un array
  • pos — Alias de current
  • prev — Rebobina el puntero interno del array
  • range — Crear un array que contiene un rango de elementos
  • reset — Establece el puntero interno de un array a su primer elemento
  • rsort — Ordena un array en orden inverso
  • shuffle — Mezcla un array
  • sizeof — Alias de count
  • sort — Ordena un array
  • uasort — Ordena un array con una función de comparación definida por el usuario y mantiene la asociación de índices
  • uksort — Ordena un array según sus claves usando una función de comparación definida por el usuario
  • usort — Ordena un array según sus valores usando una función de comparación definida por el usuario



ELEMENTOS DE UN ARRAY

Podemos imaginar un array como una tabla de datos que está formada por celdas. Cada elemento del array corresponde al contenido de cada una de las celdas.
Si declaramos un array con la siguiente sentencia:

 //Para declarar una variable como array y ponerle elementos     
 $a = array("Maiz","Arroz","Pan","Frijoles","Azúcar");

Tendremos que en la primera celda contendrá la cadena "Maiz", la segunda tendrá "Arroz" y así sucesivamente.
Para acceder a los elementos de un array utilizaremos el nombre del array y luego entre corchetes (paréntesis cuadrados) el identificador o numero del elemento que queremos.
Por ejemplo, si quiero imprimir el primer elemento del arreglo anterior utilizaré la sentencia:



  //imprimir el primer elemento de un array
  echo $a[0];
Nótese que el primer elmento del array tiene el subindice cero. Algunos lenguajes utilizan el subindice uno para el primer elemento, aunque los basados en el lenguaje C generalmente empiezan en 0. No obstante, PHP nos dá la la libertad de que si ya estamos acostumbrados a utilizar el subindice 1, lo podemos hacer por medio de la siguiente declaración:


 //Para declarar una variable como array y ponerle elementos     
 $a = array(1=>"Maiz","Arroz","Pan","Frijoles","Azúcar");

En este caso le estamos indicando con la instrucción 1=> que comience en 1. También podemos iniciarlo en 2 o en el valor que querramos aunque no tiene mucha utilidad.
Si mostramos el contenido del array con la función var_dump() con el siguiente código
echo "<pre>";
var_dump($a);
echo "</pre>";
tendríamos la siguiente salida:
Salida del programa: 


array(5) {

  [1]=>

  string(4) "Maiz"

  [2]=>

  string(5) "Arroz"

  [3]=>

  string(3) "Pan"

  [4]=>

  string(8) "Frijoles"

  [5]=>

  string(6) "Azúcar"

}

TIPOS DE ARRAY

PHP utiliza dos tipos de array los cuales conocemos como arrays escalares y arrays asociativos.
los arrays escalares son aquellos que tienen como subindice un número consecutivo, por ejemplo $a[0],$a[1],$a[2]...$a[n] y los asociativos utilizan como subindice una cadena o un número arbitrario. Por ejemplo: $a["grano"], $a["fruta"], $a["otro"]
Como podrán notar, los arrays asociativos no se pueden recorrer por medio de un ciclo for sino que se tiene que utilizar un foreach en caso de que querramos recorrer todos los elementos.
Aunque los arrays asociativos pudieran parecer confusos, en realidad son tremendamente útiles, ya que simplifican varias tareas como por ejemplo, el manejo de registros de una base de datos se hace por medio de un array y es más facil acceder a un campo por medio de la instrucción $registro["titulo"] que por $registro[4] ya que si cambiamos la sentencia podría ser que el Título ya no esté en la posición 4.
Un ejemplo de declaración de un array asociativo sería:



 //Para declarar un array del tipo asociativo
 $a=array("nombre"=>"José", "apellido"=>"nabor", "telefono"=>"312-123456");


Si lo analizamos con la función var_dump veremos:
Salida del programa: 

array(3) {

  ["nombre"]=>

  string(4) "José"

  ["apellido"]=>

  string(5) "nabor"

  ["telefono"]=>

  string(10) "312-123456"

}
Publicado por en
Etiquetas:

No hay comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)