PHP Master | Opérateurs de tableaux en php: intéressant mais moins parlé

Explication détaillée de l'opérateur de tableau PHP: Tips peu connus

Les opérateurs

PHP peuvent être divisés en sept catégories: arithmétique, affectation, opération de bits, comparaison, contrôle d'erreur, exécution, incrément / diminution, logique, chaîne, tableau et opérateur de type. Cet article se concentre sur les opérateurs de matrices et couvre le comportement de certains autres opérateurs lorsqu'il est utilisé en conjonction avec des tableaux.

points clés

• Les opérateurs de réseaux PHP incluent l'union, l'égalité, l'identité, les inégalités et la non-identité. -identique.
• L'opérateur syndical () fusionne deux tableaux selon les clés, ignorant les clés qui existent déjà dans le premier tableau du deuxième tableau. Cependant, il est souvent mal compris que les syndicats sont basés sur les valeurs du tableau, mais en fait, ils sont basés sur des clés de tableau.
• L'opérateur d'identité (===) vérifie si les deux tableaux sont les mêmes en termes de nombre d'éléments, de paires de valeurs clés, d'ordre d'élément et de types de données pour toutes les valeurs correspondantes. Mais pour les clés du tableau, si la clé est un entier, et qu'il y a une représentation de chaîne entière similaire en tant que clé dans un autre tableau, elle fera une correspondance lâche.
• PHP se comporte différemment lors de l'application d'opérateurs autres que les opérateurs de réseau à un tableau. Par exemple, lors de l'application d'un opérateur arithmétique à un tableau, PHP émet une erreur fatale; L'opérateur d'incrément / décrément n'a aucun effet sur le tableau.

Opérateur de tableau

La documentation officielle ne décrit que brièvement chaque opérateur de tableau, ce qui rend parfois difficile pour les gens de comprendre les résultats attendus de chaque opérateur. Examinons de plus près chaque opérateur de tableau pour mieux comprendre leur fonctionnalité. Tous ces opérateurs sont binaires, ce qui signifie que chaque opérateur agit précisément sur deux tableaux.

Union Array

d'abord est l'opérateur syndical (), qui donne l'union de deux tableaux selon les clés du tableau. Il effectue une correspondance des clés lâches, et si la clé équivalente du deuxième tableau existe déjà dans le premier tableau, toutes les clés du deuxième tableau sont ignorées. Les clés restantes du deuxième tableau (et les valeurs correspondantes) sont ajoutées au premier tableau.

<?php
$array1 = array('a', 'b', 'c');
$array2 = array('d', 'e', 'f', 'g', 'h', 'i');
print_r($array1 + $array2);
print_r($array2 + $array1);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => g
    [4] => h
    [5] => i
)
Array
(
    [0] => d
    [1] => e
    [2] => f
    [3] => g
    [4] => h
    [5] => i
)</code>

Pour le premier print_r (), les trois premiers éléments de $ array2 ont des clés qui existent déjà dans $ array1, donc 'd', 'e' et 'f' sont ignorés dans le tableau de résultat. Pour le deuxième print_r (), toutes les clés de $ array1 existent déjà dans $ array2, donc tous ses éléments sont ignorés. Le comportement de correspondance lâche peut vous donner des résultats totalement inattendus, mais offre également des opportunités passionnantes d'optimisation et de codage lâche.

<?php
$array1 = array('0' => 'a', '1' => 'b', '2' => 'c', '3' => 'd');
$array2 = array(false => 'e', 1 => 'f', 2 => 'g', 3 => 'h', 4 => 'i');
print_r($array1 + $array2);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => i
)</code>

Les gens comprennent souvent que les syndicats sont basés sur les valeurs du tableau, mais en fait, cet opérateur implémente des syndicats de clés de tableau. Pour un syndicat basé sur la valeur, vous pouvez utiliser Array_merge () et Array_Unique () en combinaison:

<?php
$array1 = array('a', 'b', 'c');
$array2 = array('d', 'e', 'f', 'g', 'h', 'i');
print_r($array1 + $array2);
print_r($array2 + $array1);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => g
    [4] => h
    [5] => i
)
Array
(
    [0] => d
    [1] => e
    [2] => f
    [3] => g
    [4] => h
    [5] => i
)</code>

Égalité du tableau

L'opérateur d'égalité (==) vérifie si les deux tableaux sont similaires. Si toutes les paires de valeurs clés dans le premier tableau ont des paires de valeurs clés équivalentes dans le deuxième tableau, l'opérateur renvoie true. Il correspond librement aux valeurs et aux clés et ignore l'ordre des éléments.

<?php
$array1 = array('0' => 'a', '1' => 'b', '2' => 'c', '3' => 'd');
$array2 = array(false => 'e', 1 => 'f', 2 => 'g', 3 => 'h', 4 => 'i');
print_r($array1 + $array2);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => i
)</code>

Les éléments des deux tableaux sont dans un ordre différent, mais les mêmes valeurs sont liées à des clés similaires dans chaque tableau. Cependant, les deux suivants ne sont pas égaux, car les deux tableaux ont des paires de valeurs clés différentes:

<?php
$union = array_unique(array_merge($array1, $array2));
print_r($union);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => e
    [5] => f
    [6] => g
    [7] => h
    [8] => i
)</code>

L'opérateur inégal (! = Ou & lt; & gt;) vérifie si les deux tableaux ne sont pas similaires et sont des antonymes parfaits pour l'opérateur égal. L'opérateur d'égalité renvoie tout ce qui est faux, cet opérateur renvoie True et vice versa.

<?php
$array1 = array('1' => 1, '2' => 2, '3' => 3, '0' => 0);
$array2 = array(false => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 == $array2);
?>

<code>bool(true)</code>

Identité du tableau

L'opérateur d'identité (===) vérifie si les deux tableaux sont les mêmes. Deux tableaux sont les mêmes s'ils remplissent les conditions suivantes:

• ont le même nombre d'éléments
• a la même paire de valeurs de clé
• ont le même ordre d'élément
• Le type de données de toutes les valeurs correspondantes est la même

Cependant, pour les clés du tableau, si la clé est un entier, et il y a une représentation de chaîne entier similaire comme clé dans un autre tableau, l'opérateur d'identité fait une correspondance lâche. Cet opérateur correspondra strictement au numéro de point flottant à la touche de chaîne. Le manuel PHP n'indique pas cette différence.

<?php
$array1 = array(1, 2);
$array2 = array(2, 1);
var_dump($array1 == $array2);
?>

<code>bool(false)</code>

<?php
$array1 = array('1' => 1, '2' => 2, '3' => 3, '0' => 0);
$array2 = array(false => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 != $array2);
?>

<code>bool(false)</code>

<?php
// 数组几乎相同，但键的类型不同
$array1 = array('0' => '0', '1' => '1', '2' => '2', '3' => '3');
$array2 = array(0 => '0', 1 => '1', 2 => '2', 3 => '3');
var_dump($array1 === $array2);
?>

<code>bool(true)</code>

L'opérateur de non-identité (! ==) Vérifie si les deux tableaux sont différents. Encore une fois, cet opérateur est exactement l'opposé de l'opérateur d'identité, ce qui signifie que si les deux tableaux sont les mêmes, cet opérateur renvoie faux.

<?php
// 两个数组中的元素顺序不同
$array1 = array('0' => '0', '1' => '1', '2' => '2', '3' => '3');
$array2 = array(1 => '1', 2 => '2', 3 => '3', 0 => '0');
var_dump($array1 === $array2);
?>

<code>bool(false)</code>

Utilisez d'autres opérateurs et tableaux

Le comportement PHP diffère lors de l'application d'opérateurs autres que les opérateurs ci-dessus à un tableau. Voici une liste de ces opérateurs et comment ils se comportent lorsqu'ils sont appliqués à un tableau.

Erreur mortelle: type d'opérande inattendu

PHP émettra une erreur mortelle lorsque l'opérateur suivant est appliqué au tableau:

• Bit Opération non opérateur (~)
• Opérateur négatif arithmétique (-)
• Opérateur de soustraction arithmétique (-)
• Opérateur de multiplication arithmétique (*)
• Opérateur de division arithmétique (/)

Traitez les tableaux comme des entiers

Lorsqu'il est utilisé avec les opérateurs suivants, un tableau est traité comme un entier. Un tableau vide (aucun éléments) est considéré comme int (0), et un tableau non vide est considéré comme int (1).

• Logical Non (!) Renvoie True pour les tableaux vides, et faux lorsque le tableau d'opérande a un ou plusieurs éléments.
• Bits et (&&) Retour 1 Si les deux opérandes sont non vides;
• bit ou (|) Renvoie 0 si les deux opérandes sont vides;
• Bit exclusif (^) Renvoie 0 si les deux tableaux sont vides ou non vides. Si l'un des tableaux est vide, retournez 1.
• Utilisez l'opérateur de changement de gauche (& lt; & lt;) pour déplacer le tableau vers les étapes de gauche.
• L'opérateur de shift de droite (& gt; & gt;) se comporte de manière similaire au changement de gauche, sauf qu'il se déplace vers la droite.
Le module
• (%) renvoie True si les deux tableaux ne sont pas vides. Si le deuxième tableau est vide, une erreur "divisée par zéro" est émise. Si le premier tableau est vide, 0 (résultat de 0% 1) est retourné.
• Logistic vs (&& et et) renvoie false si un tableau est vide. Retour True si les deux tableaux ne sont pas vides.
• logique ou (|| et ou) renvoie True si un tableau d'opérande n'est pas vide. Si les deux tableaux sont vides, false est renvoyé.
• Si les deux tableaux sont vides ou non vides, le XOR logique (XOR) renvoie faux. Sinon, si l'un des tableaux est vide, renvoie vrai.
• Capt le tableau à bool, renvoyez false si le tableau est vide, sinon renvoie vrai.

Traitez les tableaux comme des chaînes

Lors de la concaténation de deux tableaux, l'opérateur de concaténation de chaîne (.) Traite chaque tableau comme un "tableau" de chaîne et concaténe ces chaînes.

<?php
$array1 = array('a', 'b', 'c');
$array2 = array('d', 'e', 'f', 'g', 'h', 'i');
print_r($array1 + $array2);
print_r($array2 + $array1);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => g
    [4] => h
    [5] => i
)
Array
(
    [0] => d
    [1] => e
    [2] => f
    [3] => g
    [4] => h
    [5] => i
)</code>

invalide

Les opérateurs d'incrément / décrément (et -) n'ont aucun effet sur le tableau.

<?php
$array1 = array('0' => 'a', '1' => 'b', '2' => 'c', '3' => 'd');
$array2 = array(false => 'e', 1 => 'f', 2 => 'g', 3 => 'h', 4 => 'i');
print_r($array1 + $array2);
?>

<code>Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
    [4] => i
)</code>

Conclusion

Il y a peu de documentation réelle sur les opérateurs PHP lorsqu'ils sont utilisés avec les tableaux, mais pour en savoir plus, vous pouvez afficher les commentaires soumis à l'utilisateur sur la page des opérateurs de tableaux. Vos questions et commentaires sont les bienvenus ici et je serai heureux d'expliquer davantage.

Images de Fotolia

FAQ de l'opérateur de tableau PHP (FAQ)

Quels sont les différents types d'opérateurs de tableau en PHP?

PHP prend en charge plusieurs types d'opérateurs de tableaux, notamment Union (), l'égalité (==), l'identité (===), l'inégalité (! = Ou & lt; & gt;) et l'égalité non constante (! ==). Chacun de ces opérateurs remplit une fonction différente. Par exemple, l'opérateur Union () combine un tableau, l'opérateur d'égalité (==) vérifie si les deux tableaux sont égaux, et l'opérateur d'identité (===) vérifie si les deux tableaux sont les mêmes.

Comment fonctionne l'opérateur Union () en PHP?

L'opérateur Union () en PHP combine deux nombres en un. Il faut une union de tableaux, ce qui signifie qu'il renvoie un tableau contenant tous les éléments en deux tableaux. Si le tableau a la même clé de chaîne, la valeur du premier tableau sera utilisée et la valeur de la touche correspondante dans le deuxième tableau sera ignorée.

Quelle est la différence entre les opérateurs d'égalité (==) et d'identité (===)?

L'opérateur

Equality (==) vérifie si deux tableaux ont les mêmes paires de clés / valeur, quel que soit leur type de commande ou de données. D'un autre côté, l'opérateur d'identité (===) vérifie si deux tableaux ont les mêmes paires de clés / valeur du même ordre et du même type de données.

Comment fonctionne l'opérateur d'inégalité (! = Ou & lt; & gt;) en PHP?

L'opérateur inégal dans PHP est représenté par! = Ou & lt; & gt; pour vérifier si les deux tableaux ne sont pas égaux. Retour True si le tableau n'est pas égal et faux si le tableau est égal.

Quel est le rôle de l'opérateur de non-identité (! ==) dans PHP?

L'opérateur de non-identité (! ==) en PHP vérifie si les deux tableaux sont différents. Retour Vrai si le tableau n'est pas le même; Faux si le tableau est le même.

Les opérateurs de réseau peuvent-ils être combinés en PHP?

Oui, vous pouvez combiner des opérateurs de tableau en PHP pour effectuer des opérations plus complexes. Cependant, soyez prudent lorsque vous faites cela pour éviter des résultats inattendus. Assurez-vous toujours que les opérateurs combinés ont une signification logique dans le contexte du code.

Comment vérifier si un tableau contient une valeur spécifique à l'aide de l'opérateur de tableau?

Vous pouvez utiliser la fonction in_Array () dans PHP pour vérifier si un tableau contient une valeur spécifique. Si la valeur est trouvée dans le tableau, cette fonction renvoie True;

Comment supprimer une valeur spécifique d'un tableau PHP?

Vous pouvez utiliser la fonction Array_Diff () dans PHP pour supprimer une valeur spécifique d'un tableau. Cette fonction compare les valeurs du tableau avec les valeurs dans un autre tableau et renvoie la différence.

Comment trier les tableaux en php?

PHP fournit plusieurs fonctions pour trier les tableaux, y compris Sort (), Asort (), Ksort () et Usort (). Chacune de ces fonctions trie le tableau d'une manière différente, vous devez donc choisir celui qui convient le mieux à vos besoins.

Comment inverser l'ordre des tableaux en PHP?

Vous pouvez utiliser la fonction array_reverse () dans PHP pour inverser l'ordre du tableau. Cette fonction renvoie un nouveau tableau d'éléments dans l'ordre inverse.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!