PHP 5.4.32 Released

Les tableaux

Un tableau en PHP est en fait une carte ordonnée. Une carte est un type qui associe des valeurs en clés. Ce type est optimisé pour différentes utilisations ; il peut être considéré comme un tableau, une liste, une table de hashage, un dictionnaire, une collection, une pile, une file d'attente et probablement plus. On peut avoir, comme valeur d'un tableau, d'autres tableaux, multidimensionnels ou non.

La structure de ces données dépasse l'objet de ce manuel, mais vous trouverez au moins un exemple pour chacun des cas évoqués. Pour plus d'informations, reportez-vous aux différentes explications sur le sujet que l'on trouve sur le web.

Syntaxe

Syntaxe d'un tableau

Un tableau peut être créé en utilisant la structure de langage array(). Il prend un nombre illimité de paramètres, chacun séparé par une virgule, sous la forme d'une paire key => value.

array(
    key  => value,
    key2 => value2,
    key3 => value3,
    ...
)

La virgule après le dernier élément d'un tableau est optionnelle et peut ne pas être ajoutée. C'est généralement ce qui est fait pour les tableaux sur une seule ligne, i.e. array(1, 2) est préféré à array(1, 2, ). Pour les tableaux sur plusieurs lignes, la virgule finale est généralement utilisée, car elle permet d'ajouter plus facilement de nouveaux éléments à la fin.

Depuis PHP 5.4, vous pouvez également utiliser la syntaxe courte, qui remplace array() par [].

Exemple #1 Un tableau simple

<?php
$array 
= array(
    
"foo" => "bar",
    
"bar" => "foo",
);

// depuis PHP 5.4
$array = [
    
"foo" => "bar",
    
"bar" => "foo",
];
?>

La clé key peut être soit un integer, soit une chaîne de caractères. La valeur value peut être de n'importe quel type.

De plus, les modifications de type pour la clé key peuvent survenir :

  • Les chaînes de caractères contenant un entier valide seront modifiées en un type entier. I.e. la clé "8" sera actuellement stockée comme l'entier 8. D'un autre côté, "08" se sera pas modifié, sachant que ce n'est pas un entier décimal valide.
  • Les nombres à virgule flottante seront aussi modifiés en entier, ce qui signifie que la partie après la virgule sera tronquée. I.e. la clé 8.7 sera stockée sous l'entier 8.
  • Les booléens seront modifiés en entier également, i.e. la clé true sera stockée sous l'entier 1 et la clé false sous l'entier 0.
  • La valeur Null sera modifiée en une chaîne vide, i.e. la clé null sera stockée sous la chaîne de caractère "".
  • Les tableaux et les objets ne peuvent pas être utilisés comme clé. Si vous le tentez, l'alerte suivante sera émise : Illegal offset type.

Si plusieurs éléments dans la déclaration d'un tableau utilise la même clé, seule la dernière sera utilisée, écrasant ainsi toutes les précédentes.

Exemple #2 Exemple sur la modification de type et l'écrasement

<?php
$array 
= array(
    
1    => "a",
    
"1"  => "b",
    
1.5  => "c",
    
true => "d",
);
var_dump($array);
?>

L'exemple ci-dessus va afficher :

array(1) {
  [1]=>
  string(1) "d"
}

Vu que toutes les clés de l'exemple ci-dessus sont modifiées en l'entier 1, la valeur sera écrasée sur chaque nouvel élément, et seul le dernier dont la valeur assignée est "d" sera conservé.

Les tableaux PHP peuvent contenir des clés de type integer et string en même temps, vu que PHP ne distingue pas les tableaux indexés et les tableaux associatifs.

Exemple #3 Exemple avec des clés de type integer et string

<?php
$array 
= array(
    
"foo" => "bar",
    
"bar" => "foo",
    
100   => -100,
    -
100  => 100,
);
var_dump($array);
?>

L'exemple ci-dessus va afficher :

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

La clé key est optionnelle. Si elle n'est pas spécifiée, PHP utilisera un incrément de la dernière clé entière utilisée.

Exemple #4 Tableaux indexés sans clé

<?php
$array 
= array("foo""bar""hello""world");
var_dump($array);
?>

L'exemple ci-dessus va afficher :

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

Il est possible de spécifier la clé seulement pour quelques éléments et ne pas la fournir pour d'autres :

Exemple #5 Exemple avec des clés seulement pour quelques éléments

<?php
$array 
= array(
         
"a",
         
"b",
    
=> "c",
         
"d",
);
var_dump($array);
?>

L'exemple ci-dessus va afficher :

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Comme vous pouvez le voir, la dernière valeur "d" a été assignée à la clé 7. Ceci est du au fait que le dernier entier le plus grand utilisé auparavant était 6.

Accès aux éléments d'un tableau en utilisant la syntaxe à base de crochets

Les éléments d'un tableau peuvent être accédés en utilisant la syntaxe array[key].

Exemple #6 Accès aux éléments d'un tableau

<?php
$array 
= array(
    
"foo" => "bar",
    
42    => 24,
    
"multi" => array(
         
"dimensional" => array(
             
"array" => "foo"
         
)
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>

L'exemple ci-dessus va afficher :

string(3) "bar"
int(24)
string(3) "foo"

Note:

Les parenthèses et les crochets peuvent être utilisés pour accéder aux éléments d'un tableau (i.e. $array[42] et $array{42} feront exactement la même chose dans l'exemple ci-dessus).

Depuis PHP 5.4, il est possible de faire référence à un tableau résultant d'une fonction ou d'une méthode directement. Avant, cela n'était possible qu'en utilisant une variable temporaire.

Depuis PHP 5.5, il est possible de déférencer un tableau littéral.

Exemple #7 Faire référence à un tableau à la sortie d'une fonction ou d'une méthode

<?php
function getArray() {
    return array(
123);
}

// Depuis PHP 5.4
$secondElement getArray()[1];

// Avant PHP 5.4
$tmp getArray();
$secondElement $tmp[1];

// ou
list(, $secondElement) = getArray();
?>

Note:

Une tentative d'accès à une clé d'un tableau qui n'a pas été définie revient à tenter d'accès à une variable non définie : une alerte de niveau E_NOTICE sera émise, et le résultat vaudra NULL.

Création/modification avec des crochets

Un tableau existant peut être modifié en y assignant explicitement des valeurs.

L'assignation d'une valeur dans un tableau est effectué en spécifiant la clé, entre crochets. La clé peut également ne pas être renseignée, sous la forme : [].

$arr[clé] = valeur;
$arr[] = valeur;
// clé peut être un entier ou une chaîne de caractères
// valeur peut être n'importe quel type

Si $arr n'existe pas lors de l'assignation, il sera créé ; c'est ainsi une façon détournée de créer un tableau. Cette pratique est cependant découragée car si $arr contient déjà quelques valeurs (i.e. string depuis la variable demandée) alors cette valeur restera en place et [] peut attendre un opérateur d'accès sur une chaîne. C'est toujours un meilleur choix que d'initialiser une variable par assignement direct.

Pour modifier une valeur en particulier, il convient d'assigner une valeur en spécifiant sa clé. Pour effacer une paire clé/valeur, il convient d'appeler la fonction unset() sur la clé désirée.

<?php
$arr 
= array(=> 112 => 2);

$arr[] = 56;    // Identique à $arr[13] = 56;
                // à cet endroit du script

$arr["x"] = 42// Ceci ajoute un nouvel élément au
                // tableau avec la clé "x"

unset($arr[5]); // Ceci efface l'élément du tableau

unset($arr);    // Ceci efface complètement le tableau
?>

Note:

Comme dit plus haut, si aucune clé n'est spécifiée, l'indice maximal existant est repris, et la nouvelle clé sera ce nombre, plus 1 (mais au moins 0). Si aucun indice entier n'existe, la clé sera 0 (zéro).

Notez que la clé entière maximale pour cette opération n'a pas besoin d'exister dans le tableau au moment de la manipulation. Elle doit seulement avoir existé dans le tableau à un moment ou un autre depuis la dernière fois où le tableau a été ré-indexé. Voici un exemple qui illustre ce principe :

<?php
// Création d'un tableau simple.
$array = array(12345);
print_r($array);

// Maintennant, on efface tous les éléments, mais on conserve le tableau :
foreach ($array as $i => $value) {
    unset(
$array[$i]);
}
print_r($array);

// Ajout d'un élément (notez que la nouvelle clé est 5, et non 0).
$array[] = 6;
print_r($array);

// Ré-indexation :
$array array_values($array);
$array[] = 7;
print_r($array);
?>

L'exemple ci-dessus va afficher :

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Fonctions utiles

Il y a beaucoup de fonctions utiles pour travailler avec les tableaux. Nous vous invitons à lire la section de ce manuel sur les fonctions en rapport avec les tableaux.

Note:

La fonction unset() permet d'effacer les clés d'un tableau. Soyez attentif sur le fait que le tableau ne sera pas ré-indexé. Si vous voulez réaliser un effacement complet et une ré-indexation de votre tableau, vous devez utiliser la fonction array_values().

<?php
$a 
= array(=> 'one'=> 'two'=> 'three');
unset(
$a[2]);
/* produira un tableau comme ceci
   $a = array(1 => 'one', 3 => 'three');
   et NON un tableau comme ceci
   $a = array(1 => 'one', 2 =>'three');
*/

$b array_values($a);
// Maintenant, $b vaut array(0 => 'one', 1 =>'three')
?>

La structure de contrôle foreach existe tout spécialement pour les tableaux. Elle fournit une manière pratique de parcourir un tableau.

Ce qu'il est possible de faire ou non avec un tableau

Pourquoi $foo[bar] est incorrect ?

Utiliser toujours des guillemets autour d'un index littéral. Par exemple, $foo['bar'] est correct, alors que $foo[bar] ne l'est pas. Mais pourquoi ? il est courant de rencontrer ce genre de syntaxe dans d'ancien script :

<?php
$foo
[bar] = 'enemy';
echo 
$foo[bar];
// etc
?>

C'est incorrect, mais ça fonctionne. La raison est que ce code a une constante indéfinie (bar) plutôt qu'une chaîne ('bar' - noter les guillemets). PHP peut définir plus loin une constante portant le même nom. Cela fonctionne car PHP convertit automatiquement une chaîne nue (une chaîne sans guillemets qui ne correspond à aucun symbole connu) en une chaîne qui la contient. Actuellement, s'il n'y a aucune constante nommée bar, alors PHP substituera 'bar' dans la chaîne et l'utilisera.

Note: Ceci ne signifie pas qu'il faut toujours mettre la clé entre guillemets. N'utilisez pas de guillemets avec les clés qui sont des constantes ou des variables, car cela empêcherait PHP de les interpréter.

<?php
error_reporting
(E_ALL);
ini_set('display_errors'true);
ini_set('html_errors'false);
// Tableau simple :
$array = array(12);
$count count($array);
for (
$i 0$i $count$i++) {
    echo 
"\nVérification de $i : \n";
    echo 
"Mauvais : " $array['$i'] . "\n";
    echo 
"Bon : " $array[$i] . "\n";
    echo 
"Mauvais : {$array['$i']}\n";
    echo 
"Bon : {$array[$i]}\n";
}
?>

L'exemple ci-dessus va afficher :

Vérification de 0 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mauvais :
Bon : 1
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mauvais :
Bon : 1

Vérification de 1 :
Notice: Undefined index:  $i in /path/to/script.html on line 9
Mauvais :
Bon : 2
Notice: Undefined index:  $i in /path/to/script.html on line 11
Mauvais :
Bon : 2

Plus d'exemples pour expliquer ce comportement :

<?php
// Affichons toutes les erreurs
error_reporting(E_ALL);

$arr = array('fruit' => 'apple''veggie' => 'carrot');

// Correct
print $arr['fruit'];  // apple
print $arr['veggie']; // carrot

// Incorrect.  Ceci fonctionne mais PHP émettera une erreur de type E_NOTICE car
// on utilise la constante nommée fruit qui est indéfinie
// 
// Notice: Use of undefined constant fruit - assumed 'fruit' in...
print $arr[fruit];    // apple

// Ceci définit une constante pour expliquer ce qu'il ne va pas. La valeur 'veggie'
// est assignée à la constante nommée fruit.
define('fruit''veggie');

// Noter la différence maintenant
print $arr['fruit'];  // apple
print $arr[fruit];    // carrot

// Ce qui squit est correct, car c'est dans une chaîne. Les constantes ne sont pas recherchées
// dans les chaînes, et donc, aucune alerte E_NOTICE ne sera émise
print "Hello $arr[fruit]";      // Hello apple

// Avec une exception : les parenthèses autour d'un tableau dans une chaîne permettent
// aux constantes d'être interprétées
print "Hello {$arr[fruit]}";    // Hello carrot
print "Hello {$arr['fruit']}";  // Hello apple

// Ceci ne fonctionnera pas, et en résultera une erreur d'analyse, comme ceci :
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Ceci arrive lors de l'utilisation d'une supergloables dans les chaînes
print "Hello $arr['fruit']";
print 
"Hello $_GET['foo']";

// La concaténation est une autre solution
print "Hello " $arr['fruit']; // Hello apple
?>

Lorsque error_reporting est défini afin de montrer les erreurs de type E_NOTICE (en le définissant à E_ALL, par exemple), une telle pratique devient immédiatement visible. Par défaut, error_reporting n'est pas défini pour afficher toutes les alertes.

Comme vu dans la section "syntaxe", ce qui se trouve entre crochets ('[' et ']') doit être une expression. Ceci signifie que le code ci-dessous fonctionne :

<?php
echo $arr[somefunc($bar)];
?>

C'est un exemple d'utilisation d'une fonction retournant une valeur qui sera la clé du tableau. PHP comprend également les constantes :

<?php
$error_descriptions
[E_ERROR]   = "A fatal error has occured";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE]  = "This is just an informal notice";
?>

Noter que E_ERROR est également un identifiant valide, tout comme bar dans le premier exemple. Mais le dernier exemple est finalement le même que celui-ci :

<?php
$error_descriptions
[1] = "A fatal error has occured";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>

car E_ERROR vaut 1, etc.

Alors, pourquoi est-ce une mauvaise pratique ?

Dans le futur, les développeurs PHP peuvent vouloir ajouter une autre constante ou un autre mot clé, ou bien une constante dans une autre partie du code qui peut interférer. Par exemple, il est toujours incorrect d'utiliser le mot empty et default, sachant que ce sont des mots réservés.

Note: Pour être plus clair, dans une chaîne entourée de guillemets doubles, il est valide de ne pas entourer les indexes d'un tableau avec des guillemets, et donc, "$foo[bar]" est valide. Voir les exemples ci-dessous pour plus détails mais aussi la section sur l'analyse des variables dans les chaînes.

Conversion en un tableau

Pour tous les types : entier, nombre décimal, chaîne de caractères, booléen et ressource, le fait de convertir une valeur en un tableau résulte en un tableau contenant un seul élément dont l'indexe vaut zéro et la valeur, une valeur scalaire convertie. En d'autres termes, (array)$scalarValue est exactement la même chose que array($scalarValue).

Si un objet est converti en un tableau, le résultat sera un tableau dont les éléments sont les propriétés de l'objet. Les clés sont les noms des membres, avec une légère exception : les variables ayant un nom sous forme d'entier sont inaccessible; les variables privées auront le nom de la classe ajouté au nom de la variable ; les variables protégées auront un '*' ajouté au nom de la variable. Ce comportement peut amener à des résultats inattendus :

<?php

class {
    private 
$A// Ceci devient '\0A\0A'
}

class 
extends {
    private 
$A// Ceci devient '\0B\0A'
    
public $AA// Ceci devient 'AA'
}

var_dump((array) new B());
?>

Ici, on pourrait penser qu'il y a 2 clés nommées 'AA', alors qu'une est actuellement nommée '\0A\0A'.

La conversion de NULL en un tableau résultat en un tableau vide.

Comparaison

Il est possible de comparer plusieurs tableaux avec la fonction array_diff() ainsi qu'avec les opérateurs de tableaux.

Exemples

Le type tableau en PHP est vraiment versatile. Voici quelques exemples :

<?php
// This
$a = array( 'color' => 'red',
            
'taste' => 'sweet',
            
'shape' => 'round',
            
'name'  => 'apple',
             
4        // la clé sera 0
          
);

// est strictement équivalent à
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // la clé sera 0

$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Après exécution du code ci-dessus, $a sera le tableau
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round', 
// 'name' => 'apple', 0 => 4), et $b sera le tableau
// array(0 => 'a', 1 => 'b', 2 => 'c'), ou simplement array('a', 'b', 'c').
?>

Exemple #8 Utilisation de array()

<?php
// Tableau comme carte de propriétés
$map = array( 'version'    => 4,
              
'OS'         => 'Linux',
              
'lang'       => 'english',
              
'short_tags' => true
            
);

// clés numériques strictes
$array = array( 7,
                
8,
                
0,
                
156,
                -
10
              
);
// est identique à array(0 => 7, 1 => 8, ...)

$switching = array(         10// clé = 0
                    
5    =>  6,
                    
3    =>  7
                    
'a'  =>  4,
                            
11// clé = 6 (l'indice entier maximal est 5)
                    
'8'  =>  2// clé = 8 (intier !)
                    
'02' => 77// clé = '02'
                    
0    => 12  // la valeur 10 sera écrasée par la valeur 12
                  
);

// empty array
$empty = array();
?>

Exemple #9 Collection

<?php
$colors 
= array('rouge''bleu''verte''jaune');

foreach (
$colors as $color) {
    echo 
"Aimez-vous la couleur $color ?\n";
}

?>

L'exemple ci-dessus va afficher :

Aimez-vous la couleur rouge ?
Aimez-vous la couleur bleu ?
Aimez-vous la couleur verte ?
Aimez-vous la couleur jaune ?

La modification directe de valeurs d'un tableau est possible depuis PHP 5 en le passant par référence. Avant cette version, nous devions utiliser l'astuce suivante :

Exemple #10 Modification d'un élément dans la boucle

<?php
// PHP 5
foreach ($colors as &$color) {
    
$color strtoupper($color);
}
unset(
$color); /* On s'assure que les écritures suivantes
sur $color ne modifie pas le dernier élément du tableau */

// Astuce pour les anciennes versions
foreach ($colors as $key => $color) {
    
$colors[$key] = strtoupper($color);
}

print_r($colors);
?>

L'exemple ci-dessus va afficher :

Array
(
    [0] => ROUGE
    [1] => BLEU
    [2] => VERTE
    [3] => JAUNE
)

Cet exemple crée un tableau, dont l'indexation commence à 1.

Exemple #11 Indexation commençant à 1

<?php
$firstquarter  
= array(=> 'Janvier''Février''Mars');
print_r($firstquarter);
?>

L'exemple ci-dessus va afficher :

Array 
(
    [1] => 'Janvier'
    [2] => 'Février'
    [3] => 'Mars'
)

Exemple #12 Remplissage d'un tableau

<?php
// Remplit un tableau avec tous les éléments d'un dossier
$handle opendir('.');
while (
false !== ($file readdir($handle))) {
    
$files[] = $file;
}
closedir($handle); 
?>

Les tableaux sont ordonnés. L'ordre peut être modifié en utilisant plusieurs fonctions. Voir la section sur les fonctions sur les tableaux pour plus d'informations. La fonction count() peut être utilisée pour compter le nombre d'éléments d'un tableau.

Exemple #13 Tri d'un tableau

<?php
sort
($files);
print_r($files);
?>

Sachant que la valeur d'une tableau peut être n'importe quoi, elle peut aussi être un autre tableau. Ceci permet la création de tableaux récursifs et de tableaux multidimensionnels.

Exemple #14 Tableaux récursifs et multidimensionnels

<?php
$fruits 
= array ( "fruits"  => array ( "a" => "orange",
                                       
"b" => "banana",
                                       
"c" => "apple"
                                     
),
                  
"numbers" => array ( 1,
                                       
2,
                                       
3,
                                       
4,
                                       
5,
                                       
6
                                     
),
                  
"holes"   => array (      "first",
                                       
=> "second",
                                            
"third"
                                     
)
                );

// Quelques exemples pour retrouver les valeurs dans le tableau ci-dessus 
echo $fruits["holes"][5];    // affiche "second"
echo $fruits["fruits"]["a"]; // affiche "orange"
unset($fruits["holes"][0]);  // efface "first"

// Création d'un tableau multidimensionnel
$juices["apple"]["green"] = "good"
?>

L'assignation d'un tableau induit toujours la copie des valeurs. Utilisez l'opérateur de référence pour copier un tableau par référence.

<?php
$arr1 
= array(23);
$arr2 $arr1;
$arr2[] = 4// $arr2 est modifié,
             // $arr1 vaut toujours array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4// maintenant, $arr1 et $arr3 sont identiques
?>
add a note add a note

User Contributed Notes 21 notes

up
67
mlvljr
3 years ago
please note that when arrays are copied, the "reference status" of their members is preserved (http://www.php.net/manual/en/language.references.whatdo.php).
up
33
chris at ocportal dot com
1 year ago
Note that array value buckets are reference-safe, even through serialization.

<?php
$x
='initial';
$test=array('A'=>&$x,'B'=>&$x);
$test=unserialize(serialize($test));
$test['A']='changed';
echo
$test['B']; // Outputs "changed"
?>

This can be useful in some cases, for example saving RAM within complex structures.
up
45
ken underscore yap atsign email dot com
6 years ago
"If you convert a NULL value to an array, you get an empty array."

This turns out to be a useful property. Say you have a search function that returns an array of values on success or NULL if nothing found.

<?php $values = search(...); ?>

Now you want to merge the array with another array. What do we do if $values is NULL? No problem:

<?php $combined = array_merge((array)$values, $other); ?>

Voila.
up
42
jeff splat codedread splot com
9 years ago
Beware that if you're using strings as indices in the $_POST array, that periods are transformed into underscores:

<html>
<body>
<?php
    printf
("POST: "); print_r($_POST); printf("<br/>");
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>">
    <input type="hidden" name="Windows3.1" value="Sux">
    <input type="submit" value="Click" />
</form>
</body>
</html>

Once you click on the button, the page displays the following:

POST: Array ( [Windows3_1] => Sux )
up
17
ivegner at yandex dot ru
11 months ago
Note that objects of classes extending ArrayObject SPL class are treated as arrays, and not as objects when converting to array.

<?php
class ArrayObjectExtended extends ArrayObject
{
    private
$private = 'private';
    public
$hello = 'world';
}

$object = new ArrayObjectExtended();
$array = (array) $object;

// This will not expose $private and $hello properties of $object,
// but return an empty array instead.
var_export($array);
?>
up
33
ia [AT] zoznam [DOT] sk
8 years ago
Regarding the previous comment, beware of the fact that reference to the last value of the array remains stored in $value after the foreach:

<?php
foreach ( $arr as $key => &$value )
{
   
$value = 1;
}

// without next line you can get bad results...
//unset( $value );

$value = 159;
?>

Now the last element of $arr has the value of '159'. If we remove the comment in the unset() line, everything works as expected ($arr has all values of '1').

Bad results can also appear in nested foreach loops (the same reason as above).

So either unset $value after each foreach or better use the longer form:

<?php
foreach ( $arr as $key => $value )
{
   
$arr[ $key ] = 1;
}
?>
up
32
lars-phpcomments at ukmix dot net
9 years ago
Used to creating arrays like this in Perl?

@array = ("All", "A".."Z");

Looks like we need the range() function in PHP:

<?php
$array
= array_merge(array('All'), range('A', 'Z'));
?>

You don't need to array_merge if it's just one range:

<?php
$array
= range('A', 'Z');
?>
up
2
note dot php dot lorriman at spamgourmet dot org
7 months ago
There is another kind of array (php>=  5.3.0) produced by

$array = new SplFixedArray(5);

Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation.

Supposing a large string-keyed array

$arr=['string1'=>$data1, 'string2'=>$data2 etc....]

when getting the keyed data with

$data=$arr['string1'];

php does *not* have to search through the array comparing each key string to the given key ('string1') one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it's all hidden away.

However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :

http://uk3.php.net/SplFixedArray

Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It's also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).
up
25
caifara aaaat im dooaat be
8 years ago
[Editor's note: You can achieve what you're looking for by referencing $single, rather than copying it by value in your foreach statement. See http://php.net/foreach for more details.]

Don't know if this is known or not, but it did eat some of my time and maybe it won't eat your time now...

I tried to add something to a multidimensional array, but that didn't work at first, look at the code below to see what I mean:

<?php

$a1
= array( "a" => 0, "b" => 1 );
$a2 = array( "aa" => 00, "bb" => 11 );

$together = array( $a1, $a2 );

foreach(
$together as $single ) {
   
$single[ "c" ] = 3 ;
}

print_r( $together );
/* nothing changed result is:
Array
(
    [0] => Array
        (
            [a] => 0
            [b] => 1
        )
    [1] => Array
        (
            [aa] => 0
            [bb] => 11
        )
) */

foreach( $together as $key => $value ) {
   
$together[$key]["c"] = 3 ;
}

print_r( $together );

/* now it works, this prints
Array
(
    [0] => Array
        (
            [a] => 0
            [b] => 1
            [c] => 3
        )
    [1] => Array
        (
            [aa] => 0
            [bb] => 11
            [c] => 3
        )
)
*/

?>
up
1
Ray.Paseur often uses Gmail
1 month ago
Array-to-String conversion by assignment or by using an array in a string context gives a string of data that contains only the word, 'Array' and this data substitution often occurs silently.  This happens because the standard PHP installation suppresses Notice-level messages, and the array-to-string conversion, even though it causes data loss, is only considered a Notice condition.  Here is how to discern what PHP is doing.
http://php.net/manual/en/language.types.array.php
http://php.net/manual/en/language.types.string.php#language.types.string.casting

<?php // demo/array_to_string.php
/**
* Starting with the default standard error-level of E_ALL ~ E_NOTICE
* OUTPUTS:
* Array
*/
$xyz = array('X', 'Y', 'Z');
echo
$xyz;

/**
* Setting the error-level of E_ALL causes Notice messages to appear
* OUTPUTS:
* Notice: Array to string conversion in /path/to/demo/array_to_string.php on line XXX
* Array
*/
error_reporting(E_ALL);
$xyz = array('X', 'Y', 'Z');
echo
$xyz;
up
1
martijntje at martijnotto dot nl
2 years ago
Please note that adding the magic __toString() method to your objects will not allow you to seek an array with it, it still throws an Illegal Offset warning.

The solution is to cast it to a string first, like this

$array[(string) $stringableObject]
up
-5
cromney at pointslope dot com
1 year ago
One thing to be careful of is making any assumptions about the underlying implementation with respect to performance. For example, the documentation talks about hash-maps, which might lead you to expect O(1) key lookups.

<?php

function find_val($n) {
 
$t = array();
 
$last = null;
 
  for (
$x = 0; $x < $n; $x++) {
   
$last = "" . $x;
   
$t[] = $last;
  }
 
 
var_dump(in_array($last, $t));


 
function
find_key($n) {
 
$t = array();
 
$last = null;
 
  for (
$x = 0; $x < $n; $x++) {
   
$last = "" . $x;
   
$t[$last] = true;
  }
 
 
var_dump(array_key_exists($last, $t));


$n = 1600000;

find_val($n);
// Time taken: 1123ms

find_key($n);
// Time taken: 803

/*

Additional Timings:

n        find_val(ms)  find_key(ms)
100000   99             82
200000   169            130
400000   301            217
800000   570            416
1600000  1123           803

*/
?>

In my tests, both in_array and array_key_exists exhibited the same order of growth.
up
-4
Anonymous
7 years ago
This page should include details about how associative arrays are implemened inside PHP; e.g. using hash-maps or b-trees.

This has important implictions on the permance characteristics of associative arrays and how they should be used; e.g. b-tree are slow to insert but handle collisions better than hashmaps.  Hashmaps are faster if there are no collisions, but are slower to retrieve when there are collisions.  These factors have implictions on how associative arrays should be used.
up
-5
Spudley
7 years ago
On array recursion...

Given the following code:

<?php
$myarray
= array('test',123);
$myarray[] = &$myarray;
print_r($myarray);
?>

The print_r() will display *RECURSION* when it gets to the third element of the array.

There doesn't appear to be any other way to scan an array for recursive references, so if you need to check for them, you'll have to use print_r() with its second parameter to capture the output and look for the word *RECURSION*.

It's not an elegant solution, but it's the only one I've found, so I hope it helps someone.
up
-8
harry at ddtechnologies dot com
1 year ago
PHP array_diff_assoc() Function

You can compare the keys and values of two arrays, and return the differences:

<?php
$a1
=array("red","green","blue","yellow");
$a2=array("red","green","blue");

$result=array_diff_assoc($a1,$a2);
print_r($result);
?>

http://www.show-ip.org
up
-16
Walter Tross
4 years ago
It is true that "array assignment always involves value copying", but the copy is a "lazy copy". This means that the data of the two variables occupy the same memory as long as no array element changes.

E.g., if you have to pass an array to a function that only needs to read it, there is no advantage at all in passing it by reference.
up
-19
gtisza at gmail dot com
1 year ago
Be very careful when using a result as an array. <?php echo $a['foo']['bar']['baz'] ?> will throw an error if $a is an object, and throw a warning if $a is an array but does not have the right keys, but it will silently return true if $a is null or boolean or int, and if $a is a string, it will return its first character. (This is true even with E_STRICT set.) This can be a major gotcha with functions which return null or false if they are unsuccessful.
up
-4
brta dot akos at gmail dot com
7 months ago
Why not to user one-based arrays:

<?php
$a 
= array(1 => 'a', 'b', 'd');
print_r($a);
array_splice($a,2,0,'c');
print_r($a);
?>

output:
Array ( [1] => a [2] => b [3] => d ) Array ( [0] => a [1] => b [2] => c [3] => d )
up
-8
ffe
6 months ago
<?php

error_reporting
(E_ALL);

$res=42;

echo(
"+".$res[0]."+".$res[10]."+");

$res[0]=1;

?>

The last line correctly states "Warning: Cannot use a scalar value as an array", but the echo produces +++ as output with no warning. This seems strange to me.
up
-58
carl at linkleaf dot com
6 years ago
Its worth noting that there does not appear to be any functional limitations on the length or content of string indexes. The string indexes for your arrays can contain any characters, including new line characters, and can be of any length:

<?php

$key
= "XXXXX";
$test = array($key => "test5");

for (
$x = 0; $x < 500; $x++) {
 
$key .= "X";
 
$value = "test" . strlen($key);
 
$test[$key] = $value;
}

echo
"<pre>";
print_r($test);
echo
"</pre>";

?>

Keep in mind that using extremely long array indexes is not a good practice and could cost you lots of extra CPU time. However, if you have to use a long string as an array index you won't have to worry about the length or content.
up
-38
azuleta at eycambiental dot com
11 months ago
I think there's a mistake in the las example:
...'<?php
$arr1
= array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 ha cambiado,
             // $arr1 sigue siendo array(2, 3)
           
$arr3 = &$arr1;
$arr3[] = 4; // ahora $arr1 y $arr3 son iguales
?>'

I think it should be: ...'ahora $arr2 y $arr3 son iguales'...

Thanks.
To Top