PHP에서 "= &"및 "& ="연산자는 무엇을 의미합니까?

PHP에서 "= &"및 "& ="연산자는 무엇을 의미합니까?

---

PHP에서 "= &"/ "& ="연산자는 무엇을 의미합니까? 그들에 대한 정보는 어디서 읽을 수 있습니까?

Google 검색은 도움이되지 않습니다.

---

$a &= $bbitwise-and 연산자 $a = $a & $b의 약자입니다 .

$a =& $b$ a를 $ b에 대한 참조 로 할당합니다 .

---

= &

$a =& $b$a의 별칭 으로 바뀝니다 $b. 의 값 또는 참조 $a가 변경되면 $b그에 따라 의 값 또는 참조 가 변경됩니다.

이것은 객체와 관련하여 "둘 다 같은 장소를 가리키는 것"과 다릅니다 : 할 수 있습니다. $c = $d = new AnObject() 두 변수 모두 같은 장소를 가리 킵니다. 그러나 한 지점을 변경해도 다른 지점은 변경되지 않습니다. 즉, $c = null하지 것이다 $d = null. 의 경우에는 $a =& $b, 그러나, $a = null만들 것입니다 $b = null.

참고 : 공식적으로 별칭은 실제로 참조라고합니다. 공식 용어는 약간 잘못된 이름이고 확실히 모호하므로 대신 "별칭"이라는 용어를 사용하기로 선택했습니다. 설명서는 php.net을 참조하십시오 .

용도 및 효과

스칼라 값을 사용하면 =&객체의 값을 래핑하는 것과 유사하므로 여러 변수간에 값을 보편적으로 변경할 수 있습니다. 일반적으로 참조 (객체)로 전달되는 유형을 사용 =&하여 참조에 대한 참조를 제공합니다.

=&연관 배열로 작업 할 때 사용하는 경향이 있습니다 . $foo['bar']['foobar']여러 번 다시 작성하는 대신 별칭을 만들 수 있습니다 $foobar =& $foo['bar']['foobar'].. 색인이 아직 존재하지 않아도 작동합니다. 경우 $foo['bar']['foobar']존재하지 않는, 다음 isset($foobar)잘못된 것입니다. 오류를 발생시키지 않고 키의 존재를 테스트하기 전에 별칭을 만들 수 있기 때문에 일반 이전 변수를 사용하는 것보다 낫습니다.

unset($foobar)완료되면 별칭 을 설정 해제 ( )하십시오. 그렇지 않으면 나중에 변수 이름을 다시 사용하면 별칭이 가리키는 모든 것을 덮어 쓰게됩니다.

다른 방법으로도 별칭을 사용할 수 있습니다. 할당에만 국한되지 않습니다. 그들은 다음과 함께 작동합니다.

• foreach 루프 :에 foreach ($a as &$b)할당하면에 $b있는 해당 값을 덮어 씁니다 $a. $b완료되면 설정 하지 않으면 이상한 문제가 발생합니다!
• 기능 / 방법 파라미터 : function foobar(&$a)를 할당 $a에서 foobar호출자로 전달 뜻대로 가변 변화 $a.
• 함수 / 메소드 반환 값 : function &foobar()반환되는 것은 무엇이든 호출자가 수정할 수 있습니다. 이것은 별칭을 전달하는 데 유용합니다. 남용하기도 쉽습니다.
• 배열 : 이제 할당을 포함하여에 대한 $a = array(&$b)모든 변경 사항 $a[0]이에 영향을 미칩니다 $b.
• call_user_func_array : 단일 별칭 매개 변수를 사용 call_user_func('foobar', array(&$a))한다고 가정하면 이제 . 이를 통해를 사용하여 별칭 매개 변수로 함수 / 메소드를 호출 할 수 있습니다 .foobarfoobar$acall_user_func_array

예

스칼라

$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

사물

#!/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
)
*/
?>

& =

&=와 관련이 없습니다 =&. 일련의 할당 작업에서 비롯됩니다. 다음은 몇 가지입니다.

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

여기에서 트렌드가 보이십니까?

이진 산술 연산자에는 일반적으로 대응하는 할당이 있습니다. 하자 말은 @(이 글을 쓰는이 아니다)하도록 산술 연산자를했다 $a @ $b일반적으로 다수의 산출 $a및 $b숫자입니다. (생각 : 덧셈, 곱셈, 나눗셈 등) 이런 일을 얼마나 자주해야합니까?

$a = $a @ $b;

Pretty often. Doesn't it seem a bit unnecessary to repeat $a? Many languages, including PHP, solve this with an array of assignment operators:

$a @= $b;

Much simpler, and to a programmer accustomed to this notation, perhaps more concise and descriptive at a glance. (I certainly find it easier to read, since I'm so used to it.) So to double a variable:

$a *= 2;

Quick, easy, and relatively descriptive. Some languages, including PHP, extend this feature beyond arithmetic for an extra operation or two. Notably:

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

Very useful.

&= falls among these assignment operators, because & represents a bitwise arithmetic AND operation. There are a few others listed in the PHP documentation (see aforementioned link), all of which are common to many programming languages.

This means that $a &= $b is the same as $a = $a & $b.

참고URL : https://stackoverflow.com/questions/1367454/what-do-the-and-operators-in-php-mean