Ce qui ne l' “=&” et “&=” opérateurs en PHP veux dire?

=&

$a =& $b tourne $a dans un alias pour $b. Si la valeur de référence ou de $a est modifié, la valeur de référence ou de $b sera modifié en conséquence.

Cela diffère de la "les deux pointant vers le même endroit" quand il s'agit d'objets: j'ai pu faire $c = $d = new AnObject(), et les deux variables pointent vers le même endroit; toutefois, la modification de l'emplacement de l'un des points ne changerait pas où les autres points. C'est, $c = null ne ferait pas $d = null. Dans le cas de $a =& $b, cependant, $a = null ferait $b = null.

Remarque: Officiellement, les alias sont en fait appelées références. La terminologie officielle est un peu un abus de langage et est certainement l'ambigu, j'ai donc choisi d'utiliser le terme "alias" à la place. Pour en savoir plus, consultez php.net.

Utilisations et les effets

Avec des valeurs scalaires, =& est un peu comme emballage de la valeur à un objet, de sorte que vous pouvez changer la valeur universellement entre plusieurs variables. Avec des types qui sont normalement passés par référence (objets de), =& fournit une référence à une référence.

J'ai tendance à utiliser =& quand je travaille avec des tableaux associatifs. Plutôt que de réécrire $foo['bar']['foobar'] à plusieurs reprises, je peux créer un alias: $foobar =& $foo['bar']['foobar']. Ces fonctionne même si l'index n'existe pas encore. Si $foo['bar']['foobar'] n'existe pas, alors isset($foobar) sera fausse. C'est mieux que d'utiliser un simple vieux variable, parce que je peux créer l'alias avant de tester l'existence de la clé sans déclencher d'erreur.

Juste être sûr de unset (unset($foobar)) l'alias lorsque vous avez terminé. Sinon, si vous réutilisez le nom de la variable plus tard, vous finirez par l'écrasement quelle que soit l'alias a été pointant vers.

Vous pouvez utiliser des alias dans d'autres façons, trop--ils ne sont pas limités à des affectations. Ils travaillent:

• les boucles foreach: foreach ($a as &$b) de l'Affectation à $b va remplacer la valeur correspondante dans $a. Unset $b lorsque vous avez terminé, ou vous pourrez rencontrer des problèmes bizarres!
• fonction/paramètres de la méthode: function foobar(&$a) de l'Affectation à $a dans foobar va changer quelle que soit la variable de l'appelant transmis comme $a.
• fonction/méthode, les valeurs de retour: function &foobar() tout ce qui est retournée peuvent être modifiés par l'appelant; c'est utile pour passer des alias. Il est également facile à des abus.
• tableaux: $a = array(&$b) Toute modification de $a[0] affectent maintenant les $b, y compris les affectations.
• call_user_func_array: call_user_func('foobar', array(&$a)) en Supposant foobar prend un seul paramètre alias, foobar pouvez maintenant modifier $a. Cela vous permet d'appeler des fonctions/méthodes avec alias paramètres à l'aide de call_user_func_array.

Exemples

Scalaires

$original = 1;
$copy = $original;
$reference =& $original;
//All three variables == 1.

$reference = 2;
//$original == 2, $reference == 2, $copy == 1

$original = 3;
//$original == 3, $reference == 3, $copy == 1

$copy = 4;
//$original == 3, $reference == 3, $copy == 4

Objets

#!/usr/bin/env php
<?php
class Object
{
private $properties;
public function __construct(array $properties = array())
{
$this->properties = $properties;
}
public function __isset($key)
{
return isset($this->properties[$key]);
}
public function __unset($key)
{
unset($this->properties[$key]);
}
public function __get($key)
{
return isset($this->$key) ? $this->properties[$key] : null;
}
public function __set($key, $value)
{
$this->properties[$key] = $value;
}
public function __toString()
{
return print_r($this->properties, true);
}
}
function print_vars()
{
global $original, $ref, $refref;
echo
'$original: ', $original,
'$ref: ', $ref,
'$refref: ', $refref,
PHP_EOL;
}
$original = new Object(array('a' => 1, 'b' => 2, 'c' => 3));
$ref = $original;
$refref =& $original;
print_vars();
/*
$original: Array
(
[a] => 1
[b] => 2
[c] => 3
)
$ref: Array
(
[a] => 1
[b] => 2
[c] => 3
)
$refref: Array
(
[a] => 1
[b] => 2
[c] => 3
)
*/
$original->a = 'duck';
$ref->b = 'moose';
$refref->c = 'cow';
print_vars();
/*
$original: Array
(
[a] => duck
[b] => moose
[c] => cow
)
$ref: Array
(
[a] => duck
[b] => moose
[c] => cow
)
$refref: Array
(
[a] => duck
[b] => moose
[c] => cow
)
*/
//This carries over to $refref, but not $ref.
$original = new Object(array('x' => 1, 'y' => 2, 'z' => 3));
print_vars();
/*
$original: Array
(
[x] => 1
[y] => 2
[z] => 3
)
$ref: Array
(
[a] => duck
[b] => moose
[c] => cow
)
$refref: Array
(
[x] => 1
[y] => 2
[z] => 3
)
*/
//This does *not* carry over to $original or $ref.
$ref = new Object(array('o' => 42, 'm' => 123, 'n' => 1337));
print_vars();
/*
$original: Array
(
[x] => 1
[y] => 2
[z] => 3
)
$ref: Array
(
[o] => 42
[m] => 123
[n] => 1337
)
$refref: Array
(
[x] => 1
[y] => 2
[z] => 3
)
*/
//This *does* carry over to $original, but not $ref.
$refref = new Object(array('alpha' => 10, 'beta' => 20, 'gamma' => 30));
print_vars();
/*
$original: Array
(
[alpha] => 10
[beta] => 20
[gamma] => 30
)
$ref: Array
(
[o] => 42
[m] => 123
[n] => 1337
)
$refref: Array
(
[alpha] => 10
[beta] => 20
[gamma] => 30
)
*/
?>

&=

&= est pas lié à la =&. Il s'agit d'un ensemble d'opérations d'affectation. Voici quelques-uns:

• +=
• -=
• *=
• /=

Voir la tendance ici?

Opérateurs arithmétiques binaires ont généralement affectation homologues. Disons @ étaient un opérateur arithmétique (ce n'est pas que de l'écriture), de sorte que $a @ $b offre généralement un certain nombre quand $a et $b sont des nombres. (Pense: Addition, multiplication, division, etc.) Combien de fois avez-vous besoin de faire quelque chose comme cela?

$a = $a @ $b;

Assez souvent. Il ne semble pas un peu inutile de les répéter $a? De nombreuses langues, y compris PHP, résoudre cela avec un tableau d'affectation des opérateurs:

$a @= $b;

Beaucoup plus simple, et pour un programmeur habitué à cette notation, peut-être plus concis et descriptif en un clin d'œil. (Certes, je le trouve plus facile à lire, puisque je suis tellement habitué à elle.) Donc pour double d'une variable:

$a *= 2;

Rapide, facile, et relativement descriptive. Certains langages de programmation, y compris PHP, extension de cette fonctionnalité au-delà de l'arithmétique pour un supplément de fonctionnement ou deux. Notamment:

$a = $a . 'Appended text';
//Is the same as:
$a .= 'Appended text';

Très utile.

&= chutes chez ces opérateurs d'assignation, parce que & représente un bit-à-bit de l'arithmétique ET de l'exploitation. Il y a quelques autres personnes mentionnées dans la documentation PHP (voir le lien ci-dessus), qui sont communs à de nombreux langages de programmation.

Cela signifie que $a &= $b est le même que $a = $a & $b.