PHP : tableaux. Comment ajouter un autre tableau à un tableau en PHP

Dans ce chapitre :

Un tableau est un type spécial de variable qui stocke de nombreux éléments de données. Un tableau vous permet d'accéder séparément à chacun de ses éléments constitutifs (puisqu'ils sont stockés séparément à l'intérieur du tableau), et il est également possible de copier ou de traiter l'intégralité du tableau.

Les tableaux PHP ne sont pas typés, ce qui signifie que les éléments du tableau peuvent être de n'importe quel type et que différents éléments du tableau peuvent avoir des types différents. De plus, les tableaux PHP sont dynamiques, ce qui signifie qu'il n'est pas nécessaire de déclarer une taille fixe et que de nouveaux éléments peuvent être ajoutés à tout moment.

Notions de base sur les tableaux

Pour travailler avec des tableaux, vous devez apprendre deux nouveaux concepts : les éléments et les indices. Les éléments sont des valeurs stockées dans un tableau ; les valeurs peuvent être de n'importe quel type. Chaque élément est accessible par son index unique. L'index peut être un entier ou une chaîne.

Les tableaux peuvent être divisés en deux types : index, dans lequel seul un entier est utilisé comme valeur d'index, et associatif, où la valeur d'index peut être une chaîne ou un nombre. Souvent, dans les tableaux associatifs, l'index est appelé : « clé ».

Les tableaux d'index sont généralement appelés simplement « tableaux » et les tableaux associatifs sont appelés « hachages », « associatifs » ou « dictionnaires ».

Création d'un tableau

Il existe trois façons de créer des tableaux en PHP. La première consiste à le créer à l’aide de la fonction spéciale array(). La fonction prend comme arguments n'importe quel nombre de paires clé => valeur séparées par des virgules ou simplement des valeurs, également séparées par des virgules. Il renvoie un tableau qui peut être affecté à une variable.

Puisque vous n'avez pas besoin de spécifier de clé, des valeurs peuvent être ajoutées au tableau sans en spécifier une. Si aucune clé n'est spécifiée, PHP utilisera des index numériques. Par défaut, les éléments seront numérotés à partir de zéro. Les tableaux avec des index numériques vous permettent d'ajouter simplement un élément, et PHP utilisera automatiquement la valeur de clé entière la plus grande précédente incrémentée de 1.

Vous pouvez également spécifier une clé pour des éléments individuels :

"c", "d");

var_dump ($ mon_array); ?> 8 . Cela est dû au fait que la plus grande valeur de la clé de type entier avant d'être 7 .

Voyons maintenant créer un tableau associatif à l'aide de la fonction array(). Un tableau associatif s'écrit un peu différemment : pour ajouter un élément, le format clé => valeur est utilisé.

"30", "Février" => "28/29 (le 29 arrive tous les quatre ans)", "Mars" => "31", "Avril" => "30", "Mai" => "31", " Juin" => "30", "Juillet" => "31", "Août" => "31", "Septembre" => "30", "Octobre" => "31", "Novembre" => " 30", "Décembre" => "31"); ?>

Avec l'indentation que vous voyez dans cet exemple, il est plus facile d'ajouter des éléments au tableau que lorsqu'ils sont écrits sur une seule ligne.

Examinons maintenant la deuxième façon de créer un tableau : en utilisant des crochets, au lieu de la fonction spéciale array() :

"bar", "bar" => "foo");

// une autre façon de créer un tableau $my_array = ["foo" => "bar", "bar" => "foo"]; ?>

Il n'y a aucune différence entre ces tableaux, à l'exception de la différence d'orthographe.

Veuillez noter qu'en PHP, les tableaux peuvent contenir simultanément des clés de types int et string, c'est-à-dire PHP ne fait pas de différence entre les tableaux indexés et associatifs.

"lumineux", "roue" => "rond", 10 => "maison", -5 => 290]; ?>

Remarque : Lorsque vous choisissez un nom pour un tableau, veillez à ne pas utiliser un nom identique à celui d'une autre variable, car elles partagent un espace de noms commun. La création d'une variable portant le même nom qu'un tableau existant supprimera le tableau sans produire d'avertissement.

La troisième façon de créer des tableaux sera abordée dans la section « Ajout et suppression d'éléments de tableau ».

Conversion d'indice

• Comme mentionné au tout début du chapitre, une clé peut être de deux types : chaîne ou entier. Par conséquent, les clés qui ne correspondent pas à l’un de ces types seront converties :
• Si la clé est une chaîne contenant un nombre, elle sera convertie en type entier. Toutefois, si le nombre est un nombre entier décimal non valide, tel que « 09 », il ne sera pas converti en nombre entier.
• Un nombre réel (flotteur) sera également converti en nombre entier - la partie fractionnaire dans ce cas est ignorée. Par exemple, si la valeur de la clé est 5,4, elle sera interprétée comme 5.
• Le type booléen (bool) sera également converti en entier. Par exemple, si la valeur de la clé est vraie, elle sera convertie en 1 et la clé avec la valeur false sera convertie en 0 en conséquence.
• Si le type null est utilisé, il sera converti en chaîne vide.

Si plusieurs éléments d'une déclaration de tableau utilisent la même clé, alors seul le dernier sera utilisé et tous les autres seront écrasés.

"a", "1" => "b", // les clés sont converties en nombre 1 1.5 => "c", true => "d");

var_dump ($ mon_array); ?>

Dans l'exemple donné, toutes les clés seront converties en une, sur cette base, le tableau ne contiendra qu'un seul élément, dont le contenu sera écrasé 3 fois, par conséquent, sa valeur deviendra "d".

Accéder aux éléments du tableau Les éléments du tableau sont accessibles à l'aide de crochets qui indiquent l'index/la clé :.

tableau
"lait", 2 => "foo"); echo $my_array["Chocolat"], "

"; echo $mon_array; ?>

Une autre façon d’accéder aux éléments du tableau consiste à utiliser le déréférencement direct du tableau.

Bonjour le monde! ?>

Cet exemple montre que vous pouvez accéder à l'index d'un tableau renvoyé à la suite d'un appel de fonction ou de méthode.

Ajout et suppression d'éléments de tableau

Maintenant que vous connaissez les concepts de base des tableaux, examinons les moyens d'écrire des valeurs dans un tableau. Un tableau existant peut être modifié en y définissant explicitement des valeurs. Cela se fait en attribuant des valeurs à un tableau.

L'opération d'attribution d'une valeur à un élément du tableau est la même que l'opération d'attribution d'une valeur à une variable, à l'exception des crochets () qui sont ajoutés après le nom de la variable du tableau. L'index/clé de l'élément est indiqué entre crochets. Si aucun index/clé n'est spécifié, PHP sélectionnera automatiquement le plus petit index numérique inoccupé.
"zéro", 1 => "un");

$my_arr = "deux" ;

$my_arr = "trois" ;

var_dump ($ mon_arr); // affectation sans spécifier l'index/la clé $my_arr = "four";, cela peut être dû à la suppression d'éléments du tableau. Une fois les éléments supprimés, le tableau n'est pas réindexé. Prenons l'exemple suivant pour que ce soit plus clair :

"; print_r($my_arr); // Ajoute l'élément (notez que la nouvelle clé sera 3 au lieu de 0). $my_arr = 6; echo "
"; print_r($my_arr); // Réindexer : $my_arr = array_values($my_arr); $my_arr = 7; echo "
"; print_r($mon_arr); ?>

Cet exemple utilisait deux nouvelles fonctions, print_r() et array_values(). La fonction array_values() renvoie un tableau indexé (réindexe le tableau renvoyé avec des indices numériques) et la fonction print_r fonctionne comme var_dump, mais génère les tableaux sous une forme plus lisible.

Nous pouvons maintenant examiner la troisième façon de créer des tableaux :

L'exemple montre une troisième façon de créer un tableau. Si le tableau $weekdays n'a pas encore été créé, il le sera. Cependant, ce type de création de tableau n'est pas recommandé car si la variable $weekdays a déjà été créée et contient une valeur, cela peut entraîner des résultats inattendus de la part du script.

Si vous avez des doutes quant à savoir si une variable est un tableau, utilisez la fonction est_array. Par exemple, le contrôle peut être effectué comme suit :

"; $no = "chaîne régulière"; echo is_array($no) ? "Array" : "Pas un tableau"; ?>

Parcourir un tableau

L'opérateur de boucle foreach parcourt séquentiellement tous les éléments d'un tableau. Il ne fonctionne qu'avec des tableaux et des objets, et s'il est utilisé avec des variables d'autres types ou des variables non initialisées, une erreur sera générée. Il existe deux types de syntaxe pour cette boucle. Le premier type de syntaxe ressemble à ceci :

Foreach ($tableau en tant que $value) (instructions)

La boucle parcourra le tableau donné - $array (le nom du tableau remplace $array). A chaque itération, la valeur de l'élément courant est affectée à la variable $value (vous pouvez spécifier n'importe quel autre nom de variable). L'opérateur de boucle foreach est très pratique car il parcourt et lit lui-même tous les éléments du tableau jusqu'à ce que le dernier soit atteint. Cela vous permet d'éviter de vous rappeler constamment que l'indexation du tableau commence à partir de zéro et ne dépasse jamais le tableau, ce qui rend la construction de la boucle très pratique et permet d'éviter les erreurs courantes. Voyons comment cela fonctionne avec un exemple :

Le deuxième type de syntaxe foreach ressemble à ceci :

Foreach ($array as $key => $value) (instructions)

Lors de l'utilisation de cette forme de syntaxe, à chaque itération, la valeur de la clé actuelle est en outre affectée à la variable $key (vous pouvez spécifier n'importe quel autre nom de variable) :

$value) (​echo "[$key] => ", $value, "
"; } ?>

Pour pouvoir modifier directement les éléments du tableau dans une boucle, vous devez utiliser une référence. Dans ce cas, la valeur sera attribuée par référence.

Remarque : La référence au dernier élément du tableau reste même une fois l'instruction foreach terminée. Par conséquent, il est recommandé de le supprimer à l’aide de la fonction unset() comme indiqué dans l’exemple ci-dessus. Voyons ce qui se passe si nous n'utilisons pas unset() :"; foreach ($numbers as &$num) ( echo $num, " "; ) ?> Une chose à noter est que la référence ne peut être utilisée que si le tableau itéré est une variable. Le code suivant ne fonctionnera pas :

Voyons comment écrire des valeurs dans un tableau. Un tableau existant peut être modifié en y définissant explicitement des valeurs. Cela se fait en attribuant des valeurs à un tableau.

Maintenant que vous connaissez les concepts de base des tableaux, examinons les moyens d'écrire des valeurs dans un tableau. Un tableau existant peut être modifié en y définissant explicitement des valeurs. Cela se fait en attribuant des valeurs à un tableau.

L'opération d'attribution d'une valeur à un élément du tableau est la même que l'opération d'attribution d'une valeur à une variable, à l'exception des crochets () qui sont ajoutés après le nom de la variable du tableau. L'index/clé de l'élément est indiqué entre crochets. Si aucun index/clé n'est spécifié, PHP sélectionnera automatiquement le plus petit index numérique inoccupé.
"zéro", 1 => "un");

Pour modifier une valeur spécifique, vous attribuez simplement une nouvelle valeur à un élément existant. Pour supprimer n'importe quel élément d'un tableau avec son index/clé ou supprimer complètement le tableau lui-même, utilisez la fonction unset() :

Remarque : Comme mentionné ci-dessus, si un élément est ajouté à un tableau sans spécifier de clé, PHP utilisera automatiquement la valeur de clé entière la plus grande précédente augmentée de 1. S'il n'y a pas encore d'index entier dans le tableau, alors la clé sera 0. (zéro).

var_dump ($ mon_arr); // affectation sans spécifier l'index/la clé $my_arr = "four";, cela peut être dû à la suppression d'éléments du tableau. Une fois les éléments supprimés, le tableau n'est pas réindexé. Prenons l'exemple suivant pour que ce soit plus clair :

"; print_r($my_arr); // Ajoute l'élément (notez que la nouvelle clé sera 3 au lieu de 0). $my_arr = 6; echo "
"; print_r($my_arr); // Réindexer : $my_arr = array_values($my_arr); $my_arr = 7; echo "
"; print_r($mon_arr); ?>

Cet exemple utilisait deux nouvelles fonctions, print_r() et array_values(). La fonction array_values() renvoie un tableau indexé (réindexe le tableau renvoyé avec des indices numériques), et la fonction print_r fonctionne comme var_dump mais génère des tableaux sous une forme plus lisible.

Nous pouvons maintenant examiner la troisième façon de créer des tableaux :

L'exemple montre une troisième façon de créer un tableau. Si le tableau $weekdays n'a pas encore été créé, il le sera. Cependant, ce type de création de tableau n'est pas recommandé car si la variable $weekdays a déjà été créée et contient une valeur, cela peut entraîner des résultats inattendus de la part du script.

Si vous ne savez pas si une variable est un tableau, utilisez la fonction is_array. Par exemple, le contrôle peut être effectué comme suit :

"; $no = "chaîne régulière"; echo is_array($no) ? "Array" : "Pas un tableau"; ?>

Date: 2010-07-09

Tout d’abord, créons un tableau. Soit un tableau de cartes individuelles de la même couleur (pique = s). Appelons-le cartes var.

Cartes Var = ["8s","9s","Ts","Js","Qs"]; // 5 éléments (cartes de la même couleur du 8 à la reine)

Comme vous pouvez le voir, il y a 5 éléments dans notre tableau, chacun ayant son propre index unique. Rappelons encore une fois que l'indexation des éléments du tableau commence à 0, ne l'oubliez pas, c'est-à-dire dans notre exemple, le premier élément du tableau ("8s") est 0, le dernier ("Qs") est 4.

Ajouter un élément à la fin d'un tableau

Sachant que dans notre tableau cartes var il n'y a que 5 éléments et le dernier index se termine par 4, alors on peut ajouter un nouvel élément au tableau comme ceci :

Cartes Var = ["8s","9s","Ts","Js","Qs"]; // 5 éléments (cartes de la même couleur du 8 à la reine) cartes = "Ks" ; //ajout d'un nouvel élément à la fin du tableau, il y a maintenant 6 éléments dans le tableau

La difficulté de cette approche est que si le tableau contient de nombreux éléments, les compter peut être très gênant. Pour de tels cas, il existe une solution plus simple : la propriété array longueur, qui détermine la longueur du tableau, c'est-à-dire nombre d'éléments dans le tableau. Voyons un exemple :

Lancement! var cartes = ["8s", "9s", "Ts", "Js", "Qs"]; // 5 éléments (cartes de la même couleur du 8 à la reine) cartes = "Ks" ; /* ajoute un nouvel élément au tableau en utilisant la propriété length */ for(i = 0; i

À la ligne 4 de notre code, nous avons ajouté une entrée dans le formulaire cartes;. Ce code est identique cartes;, puisque la propriété longueur, comme mentionné ci-dessus, détermine le nombre de tous les éléments du tableau. En d’autres termes, nous n’avons pas besoin de compter les éléments, mais nous écrivons le tableau lui-même, mettons un point et utilisons le mot-clé longueur. À la ligne 7, nous appliquons également la propriété longueur- nous déterminons d'abord le début du compteur à partir de 0, puis il y a une condition dans laquelle nous écrivons que si la valeur du compteur est inférieure à la longueur du tableau, alors nous augmentons le compteur de un et exécutons le code entre accolades ( dans le corps de la boucle), où nous affichons les éléments du tableau à l'aide de la commande alert() ), vous pouvez utiliser document.write(). Autrement dit, tout ressemble à ceci :
0 est inférieur à 6 ? Oui, moins. On augmente le compteur de 1 et on exécute le code dans le corps de la boucle
1 est inférieur à 6 ? Oui, moins. On augmente le compteur de 1 et on exécute le code dans le corps de la boucle
2 est inférieur à 6 ? Oui, moins. On augmente le compteur de 1 et on exécute le code dans le corps de la boucle
.....................................................
Est-ce que 6 est inférieur à 6 ? Non. Le cycle s'arrête.

méthode push()

En plus des méthodes décrites ci-dessus, il existe également une méthode pousser(), avec lequel nous pouvons ajouter n'importe quel type de données, et même une variable, à la fin du tableau. Dans ce cas, il peut y avoir plusieurs éléments à la fois, qui sont écrits séparés par des virgules entre parenthèses. Regardons un exemple :

Lancement! var cartes = ["8s", "9s", "Ts", "Js", "Qs"]; // 5 éléments (cartes de la même couleur du 8 à la reine) cards.push("Ks","As"); /* ajoute de nouveaux éléments au tableau en utilisant la méthode push() */ for(i = 0; i

Ajouter un élément au début d'un tableau

Méthode unshift()

Si vous devez ajouter des éléments au tout début du tableau, utilisez la méthode annuler le décalage. Elle fonctionne sur le même principe que la méthode push().

Lancement! var cartes = ["8s", "9s", "Ts", "Js", "Qs"]; // 5 éléments (cartes de la même couleur du 8 à la reine) cards.unshift("5s","6s","7s"); /* ajoute de nouveaux éléments au tableau en utilisant la méthode unshift() */ for(i = 0; i

tableau_pad

Ajoute plusieurs éléments au tableau.
Syntaxe:

Tableau array_pad (entrée du tableau, int pad_size, pad_value mixte)

La fonction array_pad() renvoie une copie du tableau d'entrée auquel des éléments avec pad_values ​​​​ont été ajoutés, de sorte que le nombre d'éléments dans le tableau résultant soit pad_size.
Si pad_size>0, alors les éléments seront ajoutés à la fin du tableau, et si<0 - то в начало.
Si la valeur de pad_size est inférieure aux éléments du tableau d'entrée d'origine, aucun ajout ne se produira et la fonction renverra le tableau d'entrée d'origine.
Exemple d'utilisation de la fonction array_pad() :

$arr = tableau(12, 10, 4);
$result = array_pad($arr, 5, 0);
// $résultat = tableau(12, 10, 4, 0, 0);
$result = array_pad($arr, -7, -1);
// $résultat = tableau(-1, -1, -1, -1, 12, 10, 4)
$result = array_pad($arr, 2, "noop");
// n'ajoutera pas

tableau_map

Appliquez une fonction personnalisée à tous les éléments des tableaux spécifiés.
Syntaxe:

Tableau array_map (rappel mixte, tableau arr1 [, tableau ...])

La fonction array_map() renvoie un tableau qui contient les éléments de tous les tableaux spécifiés après traitement par la fonction de rappel utilisateur.
Le nombre de paramètres transmis à la fonction définie par l'utilisateur doit correspondre au nombre de tableaux transmis à array_map().

Exemple d'utilisation de la fonction array_map() : Traitement d'un seul tableau

retourner $n*$n*$n ;
}
$a = tableau(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
?>

Tableau(
=> 1
=> 8
=> 27
=> 64
=> 125
)

Exemple d'utilisation de la fonction array_map() : Traitement de plusieurs tableaux

return "Le nombre $n en espagnol est $m";
}
fonction map_Spanish($n, $m) (
tableau de retour ($n => $m);
}

$a = tableau(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$c = array_map("show_Spanish", $a, $b);
print_r($c);

$d = array_map("map_Spanish", $a , $b);
print_r($d);
?>

L'exemple donné affichera ce qui suit :

// impression de $cArray(
=> Numéro 1 en espagnol - uno
=> Numéro 2 en espagnol - dos
=> Numéro 3 en espagnol - tres
=> Numéro 4 en espagnol - cuatro
=> Numéro 5 en espagnol - cinco
)

// impression de $dArray(
=> Tableau
=> uno
)

=> Tableau
=> faire
)

=> Tableau
=> très
)

=> Tableau
=> quatre
)

=> Tableau
=> cinq
)

Généralement, la fonction array_map() est utilisée sur des tableaux de même taille. Si les tableaux ont des longueurs différentes, les plus petits sont complétés par des éléments avec des valeurs vides.
Il convient de noter que si vous spécifiez null au lieu du nom de la fonction de traitement, un tableau de tableaux sera créé.
Exemple d'utilisation de la fonction array_map() : Création d'un tableau de tableaux

$b = array("un", "deux", "trois", "quatre", "cinq");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>

L'exemple donné affichera ce qui suit :

Tableau(
=> Tableau
=> 1
=> un
=> uno
)

=> Tableau
=> 2
=> deux
=> faire
)

=> Tableau
=> 3
=> trois
=> très
)

=> Tableau
=> 4
=> quatre
=> quatre
)

=> Tableau
=> 5
=> cinq
=> cinq
)

Fonction supportée par PHP 4 >= 4.0.6, PHP 5

tableau_pop

Récupère et supprime les derniers éléments d'un tableau.
Syntaxe:

array_pop mixte (array arr);

La fonction array_pop() extrait le dernier élément du tableau arr et le renvoie, le supprimant ensuite. Avec cette fonction, nous pouvons construire des structures de type pile. Si le tableau arr était vide ou s'il ne s'agit pas d'un tableau, la fonction renvoie la chaîne vide NULL.

Après avoir utilisé la fonction array_pop(), le curseur du tableau est placé au début.
Exemple d'utilisation de la fonction array_pop() :

$fruits = array_pop($stack);
print_r($pile);
print_r($fruits);
?>

L'exemple affichera ce qui suit :

Tableau(
=> orange
=> banane
=> pomme
)

Fonction supportée par PHP 4, PHP 5

tableau_push

Ajoute un ou plusieurs éléments à la fin du tableau.
Syntaxe:

Int array_push (array arr, mixte var1 [, mixte var2, ..])

La fonction array_push() ajoute les éléments var1, var2, etc. au tableau arr. Il leur attribue des index numériques - exactement comme il le fait pour le standard .
Si vous n'avez besoin d'ajouter qu'un seul élément, il peut être plus simple d'utiliser cet opérateur :

Array_push($Arr,1000); // appelle la fonction$Arr=100; // la même chose, mais plus courte

Exemple d'utilisation de la fonction array_push() :

array_push($stack, "pomme", "framboise");
print_r($pile);
?>

L'exemple affichera ce qui suit :

Tableau(
=> orange
=> banane
=> pomme
=> framboise
)

Veuillez noter que la fonction array_push() traite le tableau comme une pile et ajoute toujours des éléments à la fin.
Fonction supportée par PHP 4, PHP 5

tableau_shift

Récupère et supprime le premier élément d'un tableau.
Syntaxe:

array_shift mixte (array arr)

La fonction array_shift() prend le premier élément du tableau arr et le renvoie. C'est très similaire à array_pop(),
mais il ne reçoit que l'élément initial, pas l'élément final, et produit également un « bouleversement » assez fort de l'ensemble du tableau : après tout, lors de l'extraction du premier élément, vous devez ajuster tous les indices numériques de tous les éléments restants, parce que tous les éléments suivants du tableau sont décalés d’une position vers l’avant. Les clés du tableau de chaînes ne changent pas.
Si arr est vide ou n'est pas un tableau, la fonction renvoie NULL.

Après avoir utilisé cette fonction, le pointeur du tableau est déplacé au début.
Exemple d'utilisation de la fonction array_shift() :

$fruit = array_shift($stack);
print_r($pile);
?>

Cet exemple produira ce qui suit :

Tableau(
=> banane
=> pomme
=> framboise
)

et la variable $fruit aura la valeur "orange"

Fonction supportée par PHP 4, PHP 5

array_unshift

Ajoute une ou plusieurs valeurs au début du tableau.
Syntaxe:

Int array_unshift (list arr, var1 mixte [, var2 mixte, ...])

La fonction array_unshift() ajoute les valeurs var transmises au début du tableau arr. L'ordre des nouveaux éléments dans le tableau est conservé. Tous les index numériques du tableau seront modifiés pour qu'il reparte de zéro. Tous les index de chaîne du tableau sont inchangés.
La fonction renvoie le nouveau nombre d'éléments dans le tableau.
Exemple d'utilisation de la fonction array_unshift() :

array_unshift ($queue, "pomme", "framboise");
?>

Maintenant, la variable $queue aura les éléments suivants :

Tableau(
=> pomme
=> framboise
=> orange
=> banane
)

Fonction supportée par PHP 4, PHP 5

tableau_unique

Supprime les valeurs en double dans un tableau.
Syntaxe:

Tableau array_unique (tableau arr)

La fonction array_unique() renvoie un tableau composé de toutes les valeurs uniques du tableau arr ainsi que leurs clés, en supprimant toutes les valeurs en double. Les premières paires clé=>valeur rencontrées sont placées dans le tableau résultant. Les index sont conservés.
Un exemple d'utilisation de la fonction array_unique() :

"vert", "rouge", "b" =>
"vert", "bleu", "rouge");

print_r($résultat);
?>

L'exemple affichera ce qui suit :

Tableau(
[a] => vert
=> rouge
=> bleu
)

Exemple d'utilisation de la fonction array_unique() : Comparaison des types de données

$result = array_unique($input);
var_dump ($ résultat);
?>

L'exemple affichera ce qui suit :

Tableau(2) (
=> int(4)
=> chaîne(1) "3"
}

Fonction supportée par PHP 4 >= 4.0.1, PHP 5

tableau_chunk

La fonction divise le tableau en parties.
Syntaxe:

Tableau array_chunk (array arr, int size [, bool préservation_keys])

La fonction array_chunk() divise le tableau d'origine arr en plusieurs tableaux, dont la longueur est spécifiée par la taille du nombre. Si la dimension du tableau d'origine n'est pas divisible exactement par la taille des parties, alors le tableau final aura une dimension plus petite.
La fonction array_chunk() renvoie un tableau multidimensionnel dont les indices commencent de 0 au nombre de tableaux résultants, et les valeurs sont les tableaux obtenus à la suite du fractionnement.
Le paramètre facultatif préserver_keys spécifie si les clés du tableau d'origine doivent être conservées ou non. Si ce paramètre est faux (valeur par défaut), alors les indices des tableaux résultants seront spécifiés par des nombres commençant à zéro. Si le paramètre est vrai, alors les clés du tableau d'origine sont conservées.
Exemple d'utilisation de la fonction array_chunk() :

$array = array("1er élément",
"2ème élément"
"3ème élément"
"4ème élément"
"5ème élément");
print_r(array_chunk($array, 2));
print_r(array_chunk($array, 2, TRUE));

L'exemple affichera ce qui suit :

Tableau(
=> Tableau
=> 1er élément
=> 2ème élément
)

=> Tableau
=> 3ème élément
=> 4ème élément
)

=> Tableau
=> 5ème élément
)

)
Tableau(
=> Tableau
=> 1er élément
=> 2ème élément
)

=> Tableau
=> 3ème élément
=> 4ème élément
)

=> Tableau
=> 5ème élément
)

Fonction supportée par PHP 4 >= 4.2.0, PHP 5

tableau_remplissage

La fonction remplit le tableau avec des valeurs spécifiques.
Syntaxe:

Array array_fill (int start_index, int num, valeur mixte)

La fonction array_fill() renvoie un tableau contenant les valeurs spécifiées dans le paramètre value de taille num, en commençant par l'élément spécifié dans le paramètre start_index.
Exemple d'utilisation de array_diff_uassoc() :

print_r($a);
?>

L'exemple affichera ce qui suit :

Tableau(
=> banane
=> banane
=> banane
=> banane
=> banane
=> banane
)

Fonction supportée par PHP 4 >= 4.2.0, PHP 5

tableau_filtre

La fonction applique un filtre à un tableau à l'aide d'une fonction personnalisée.
Syntaxe:

Tableau array_filter (entrée du tableau [, rappel de rappel])

La fonction array_filter() renvoie un tableau qui contient les valeurs trouvées dans le tableau d'entrée, filtrées en fonction des résultats de la fonction de rappel définie par l'utilisateur.
Si le tableau d'entrée est un tableau associatif, les indices sont conservés dans le tableau résultant.
Exemple d'utilisation de la fonction array_filter() :

return ($var % 2 == 1);
}

fonction paire ($var) (
return ($var % 2 == 0);
}

$array1 = array("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$tableau2 = tableau(6, 7, 8, 9, 10, 11, 12);
echo "Odd:n" ;
print_r(array_filter($array1, "impair"));
echo "Pair : n" ;
t_r(array_filter($array2, "pair"));
?>

L'exemple affichera ce qui suit :

Impair : Tableau (
[une] => 1
[c] => 3
[e] => 5
Même:Tableau(
=> 6
=> 8
=> 10
=> 12
)

Il convient de noter qu'au lieu du nom de la fonction de filtrage, vous pouvez spécifier un tableau contenant une référence à l'objet et le nom de la méthode.
Il convient également de noter que lors du traitement d'un tableau avec la fonction array_filter(), il ne peut pas être modifié : ajout, suppression d'éléments ou réinitialisation du tableau, car cela peut entraîner un fonctionnement incorrect de la fonction.
Fonction supportée par PHP 4 >= 4.0.6, PHP 5