PHP
연산자

소개

비고

문자열 연산자 (. 및. =)

단 두 개의 문자열 연산자가 있습니다.

• 두 문자열의 연결 (점) :

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• 연결 할당 (도트 =) :

  $a = "a";
  $a .= "b"; // $a => "ab"
  

기본 할당 (=)

$a = "some string";

$a 는 값을 some string $a 갖습니다.

할당 표현식의 결과는 할당되는 값입니다. 단 하나의 등호 = 는 비교를위한 것이 아닙니다!

$a = 3;
$b = ($a = 5);

다음을 수행합니다.

1. 1 행은 3 을 $a 지정 $a .
2. 2 번 줄은 $a 5 를 지정 $a . 이 식에서도 값 5 산출됩니다.
3. 2 번 줄은 괄호 ( 5 )의 표현식 결과를 $b 할당합니다.

따라서 $a 와 $b 는 모두 값 5 집니다.

결합 된 과제 (+ = 등)

결합 된 대입 연산자는 일부 변수에 대한 연산을위한 바로 가기이며이 후이 새 값을 해당 변수에 할당합니다.

산수:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

여러 배열을 함께 처리하기

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

결합 된 결합 및 문자열 할당 :

$a = "a";
$a .= "b"; // $a => "ab"

결합 된 2 진 비트 할당 연산자 :

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

연산자 우선 순위 변경 (괄호 사용)

연산자가 평가되는 순서는 연산자 우선 순위에 의해 결정됩니다 (비고 절 참조).

에서

$a = 2 * 3 + 4;

2 * 3 이 먼저 평가되기 때문에 (곱하기가 더하기보다 우선 순위가 더 높음) 하위 결과가 6 + 4 10과 같음)이기 때문에 $a 의 값은 10이됩니다.

우선 순위는 괄호를 사용하여 변경할 수 있습니다.

$a = 2 * (3 + 4);

$a (3 + 4) 은 (3 + 4) 가 먼저 평가되기 때문에 14의 값을 얻습니다.

협회

좌회

두 연산자의 우선 순위가 같으면 연관성에 따라 그룹화가 결정됩니다 (비고 섹션 참조).

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* 와 % 는 동일한 우선 순위와 왼쪽 연관성을가집니다. 곱하기가 처음 발생하기 때문에 (왼쪽), 그룹화됩니다.

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

이제 모듈러스 연산자가 먼저 발생하고 (왼쪽) 따라서 그룹화됩니다.

권리 연결

$a = 1;
$b = 1;
$a = $b += 1;

모두 $a 그리고 $b 현재의 값이 2 때문 $b += 1 (그 결과를 그룹화하고 $b 되는 2 )에 할당 $a .

비교 연산자

평등

기본 항등 테스트의 경우, 등호 연산자 == 가 사용됩니다. 보다 포괄적 인 검사를 위해서는 동일한 연산자 === 사용하십시오.

동일한 연산자는 equal 연산자와 동일하게 작동하며 피연산자의 값이 같아야하지만 동일한 데이터 형식을 필요로합니다.

예를 들어, 아래의 샘플은 'a와 b가 동일합니다'를 표시하지만 'a와 b는 동일하지 않습니다.'를 표시합니다.

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

등호 연산자를 사용하면 숫자 문자열이 정수로 형 변환됩니다.

객체의 비교

=== 두 객체가 정확히 같은 인스턴스 인지 검사하여 두 객체를 비교 합니다 . 즉, new stdClass() === new stdClass() 는 동일한 방법으로 생성되고 (정확히 동일한 값을 가짐 new stdClass() === new stdClass() false로 해석됩니다.

== 두 객체가 동일한 지 ( deep equals ) 재귀 적으로 비교하여 두 객체를 비교합니다. 즉 $a == $b 에 대해 $a 와 $b 가 다음과 같은 경우 :

1. 같은 학급의
2. 동적 속성을 포함하여 동일한 속성이 설정되어 있어야합니다.
3. 각 속성 $property 집합에 대해 $a->property == $b->property 이 참 (따라서 재귀 적으로 검사 됨)입니다.

기타 일반적으로 사용되는 연산자

그들은 다음을 포함합니다 :

1. 보다 큼 ( > )
2. 보다 작음 ( < )
3. 보다 크거나 같음 ( >= )
4. 보다 작거나 같음 ( <= )
5. 같지 않음 ( != )
6. 동일하지 않음 ( !== )

1. 보다 큼 : $a > $b 반환 true 경우 $a 의 값의보다 큰 $b 그렇지 않은 경우는 false를 돌려줍니다.

예 :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. :보다 적은 $a < $b 반환 true 경우 $a 의 값이의 작은 $b , 그렇지 않은 경우는 false를 돌려줍니다.

예 :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. 같거나보다 큰 : $a >= $b 반환 true 경우 $a 의 값이 하나의보다 큰 $b 또는 동일한 $b , 그렇지 않으면 반환 false .

예 :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. 거나 같음보다 작 : $a <= $b 반환 true 경우 $a 의 값이 하나의보다 작은 $b 또는 동일한 $b , 그렇지 않으면 반환 false .

예 :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6. 같지 않음 / 동일 함 : 앞의 예제에서 동등성을 다시 나타 내기 위해 아래 예제에서는 'a와 b가 동일하지 않음'을 표시하지만 'a와 b는 같지 않음'을 표시하지 않습니다.

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

우주선 운영자 (<=>)

PHP 7은 표현을 비교하는 데 사용할 수있는 새로운 종류의 연산자를 도입했습니다. 이 연산자는 첫 번째 표현식이 두 번째 표현식보다 작거나 같거나 큰 경우 -1, 0 또는 1을 반환합니다.

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

객체는 비교할 수 없으므로 그렇게하지 않으면 정의되지 않은 동작이 발생합니다.

이 연산자는 특히 usort , uasort 또는 uksort 사용하여 사용자 정의 비교 함수를 작성할 때 유용합니다. 예를 들어 weight 속성으로 정렬 할 객체의 배열이 주어지면 익명 함수는 <=> 를 사용하여 정렬 함수에서 예상 한 값을 반환 할 수 있습니다.

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

PHP 5에서는 좀 더 정교한 표현이 필요했습니다.

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

Null 통합 연산자 (??)

널 통합은 PHP 7에서 소개 된 새로운 연산자입니다.이 연산자는 NULL 아닌 첫 번째 피연산자를 반환 NULL . 그렇지 않으면 두 번째 피연산자가 반환됩니다.

다음 예는 다음과 같습니다.

$name = $_POST['name'] ?? 'nobody';

둘 다 같습니다.

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

과:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

이 연 산자는 (연상 연관 의미론으로) 연결될 수 있습니다.

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

이는 다음과 같습니다.

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

노트 :
문자열 연결에 합체 연산자를 사용할 때 괄호 () 를 사용하는 것을 잊지 마십시오.

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

그러면 John 만 출력되고 $ firstName이 null이고 $ lastName이 Doe 이면 Unknown Doe 가 출력됩니다. John Doe 를 출력하려면 이처럼 괄호를 사용해야합니다.

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

이 출력됩니다 John Doe 대신 John 에만.

instanceof (유형 연산자)

어떤 객체가 특정 클래스인지 확인하기 위해 PHP 버전 5부터 (binary) instanceof 연산자를 사용할 수 있습니다.

첫 번째 (왼쪽) 매개 변수는 테스트 할 객체입니다. 이 변수가 객체가 아니면 instanceof 항상 false 반환합니다. 상수 표현식이 사용되면 오류가 발생합니다.

두 번째 (오른쪽) 매개 변수는 비교할 클래스입니다. 클래스는 클래스 이름 자체, 클래스 이름 (문자열 상수가 아닌!) 또는 해당 클래스의 객체를 포함하는 문자열 변수로 제공 될 수 있습니다.

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof 는 또한 객체가 다른 클래스를 확장하거나 어떤 인터페이스를 구현하는 어떤 클래스인지 여부를 검사하는 데 사용할 수 있습니다.

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

(객체가 어떤 클래스의 여부를 확인하기 위해, not 연산자는 ! ) 사용할 수 있습니다 :

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

instanceof 는 ! 보다 우선 순위가 높기 때문에 $o instanceof MyClass 주변의 괄호는 필요하지 않습니다 ! 그것은 괄호 코드를 더 읽기 쉽게 만들 수도있다.

주의 사항

클래스가 존재하지 않으면 클래스를 정의하기 위해 등록 된 자동로드 함수가 호출됩니다 (이 부분은 문서의이 부분에서 다루지 않습니다). 5.1.0 이전의 PHP 버전에서는 instanceof 연산자가 이러한 호출을 트리거하여 실제로 클래스를 정의합니다 (클래스를 정의 할 수없는 경우 치명적인 오류가 발생합니다). 이것을 피하려면 문자열을 사용하십시오.

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

PHP 버전 5.1.0부터 등록 된 오토로더는 이러한 상황에서 더 이상 호출되지 않습니다.

이전 버전의 PHP (5.0 이전)

이전 버전의 PHP (5.0 이전)에서는 is_a 함수를 사용하여 객체가 어떤 클래스인지 판단 할 수있었습니다. 이 함수는 PHP 버전 5에서는 사용되지 않으며 PHP 버전 5.3.0에서는 사용되지 않습니다.

삼항 연산자 (? :)

삼항 연산자는 인라인 if 문으로 생각할 수 있습니다. 그것은 세 부분으로 구성됩니다. operator 와 두 가지 결과. 구문은 다음과 같습니다.

$value = <operator> ? <true value> : <false value>

operator 가 true 로 평가되면 첫 번째 블록의 값이 반환되고 ( <true value> ) 그렇지 않으면 두 번째 블록의 값이 반환됩니다 ( <false value> ). 우리는 삼항 연산자의 결과에 $value 를 설정하기 때문에 반환 된 값을 저장합니다.

예:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

empty($_POST['action']) 경우 empty($_POST['action']) true로 평가되면 $action 'default' 문자열이 포함됩니다. 그렇지 않으면 $_POST['action'] 의 값을 포함하게됩니다.

표현식 (expr1) ? (expr2) : (expr3) 은 expr1 이 true 평가되면 expr2 평가되고 expr1 이 false 평가되면 expr3 평가됩니다.

삼항 연산자의 중간 부분을 생략 할 수 있습니다. 표현식 expr1 ?: expr3 은 expr1 이 TRUE이면 expr1 을, 그렇지 않으면 expr3 반환합니다. ?: 는 종종 Elvis 연산자라고합니다.

이것은 Null Coalescing 연산자 처럼 동작 합니까 ?? , 제외하고 ?? 왼쪽 피연산자가 정확히 null 것을 요구하는 반면 ?: 는 왼쪽 피연산자를 부울로 해석하고 부울 false 해석되는지 확인하려고 시도합니다.

예:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

이 예제에서 setWidth 는 width 매개 변수 또는 기본값 0을 사용하여 너비 세션 값을 변경합니다. boolean false로 해석되는 $width 가 0 인 경우 ( $width 가 제공되지 않으면) getDefaultWidth() 값이 대신 사용됩니다. $width 가 부울 false로 해석되지 않으면 getDefaultWidth() 함수가 호출되지 않습니다.

변수를 부울로 변환하는 방법에 대한 자세한 내용은 유형 을 참조하십시오.

증가 연산자 (++) 및 감소 연산자 (-)

변수는 ++ 또는 -- 로 각각 1 씩 증가 또는 감소 할 수 있습니다. 아래에서 볼 수 있듯이 변수는 앞이나 뒤에 변수를 포함 할 수 있으며 의미 상 약간 다를 수 있습니다.

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

연산자 증가 및 감소에 대한 자세한 내용은 공식 문서 에서 확인할 수 있습니다.

실행 연산자 (``)

PHP 실행 연산자는 역 따옴표 (``)로 구성되며 쉘 명령을 실행하는 데 사용됩니다. 명령의 출력이 리턴되며, 따라서 변수에 저장 될 수 있습니다.

// List files
$output = `ls`;
echo "<pre>$output</pre>";

execute 연산자와 shell_exec() 는 동일한 결과를 제공합니다.

논리 연산자 (&& AND AND || / OR)

PHP에는 논리적 AND 및 OR 연산자의 두 가지 버전이 있습니다.

&& 및 || opererators는 and 와 or 보다 우선 순위 가 높습니다. 아래 표를 참조하십시오.

이 때문에 && 와 || 를 사용하는 것이 더 안전합니다. and 와 or 대신.

비트 연산자

접두어 비트 연산자

비트 단위 연산자는 논리 연산자와 비슷하지만 부울 값이 아닌 비트 단위로 실행됩니다.

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

비트 마스크 - 비트 마스크 연산자

비트 AND & : 비트가 두 피연산자 모두에 설정된 경우에만 비트가 설정됩니다.

printf("%'06b", 0b110101 & 0b011001); // 010001

비트 OR | : 비트가 하나 또는 양쪽 피연산자에 설정되면 비트가 설정됩니다.

printf("%'06b", 0b110101 | 0b011001); // 111101

비트 XOR ^ : 하나의 피연산자에 설정되어 있고 다른 피연산자에 설정되어 있지 않은 경우, 즉 해당 피연산자가 두 피연산자의 다른 상태에있는 경우에만 비트가 설정됩니다

printf("%'06b", 0b110101 ^ 0b011001); // 101100

비트 마스크의 사용 예

이 연산자를 사용하여 비트 마스크를 조작 할 수 있습니다. 예 :

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

여기, | 연산자는 두 비트 마스크를 결합하는 데 사용됩니다. + 가 동일한 효과를 가지지 만 | 두 개의 정상 스칼라 정수를 추가하지 않고 비트 마스크를 결합한다고 강조합니다.

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

이 예제는 ( $option 항상 오직 하나의 비트만을 포함한다고 가정 할 때) 다음을 사용합니다 :

• ^ 연산자를 사용하여 비트 마스크를 편리하게 전환 할 수 있습니다.
• | 연산자는 원래 상태 또는 다른 비트를 무시한 비트를 설정합니다.
• ~ 연산자는 1 비트 만 설정된 정수를 정수로 변환합니다. 단 하나의 비트 만 설정되지 않습니다.
• & 연산자는 이러한 특성을 이용하여 비트를 설정 해제 & :
  • &= (1 & 1) === 1 , &= (1 & 1) === 1 , (0 & 1) === 0 )을 설정 비트가 설정되지 않은 정수로 설정하면 비트 만 설정 해제됩니다. 다른 비트에는 영향을 미치지 않습니다.
  • &= 비트가 설정되지 않으면 ( (1 & 0) === 0 , (0 & 0) === 0 )
• & 연산자를 다른 비트 마스크와 함께 사용하면 해당 비트 마스크에 설정되지 않은 다른 모든 비트가 필터링됩니다.
  • 출력에 비트가 설정되어 있으면 옵션 중 하나가 사용 가능하다는 의미입니다.
  • 출력에 비트 마스크 세트의 모든 비트가 있으면 비트 마스크의 모든 옵션이 사용 가능하다는 의미입니다.

명심 이들 비교 연산자 ( < > <= >= == === != !== <> <=> )이 비트 마스크 - 비트 마스크 연산자보다 우선 순위가 있습니다 ( | ^ & ). 비트 비교 결과는 종종 이러한 비교 연산자를 사용하여 비교되기 때문에이 사실을 알고 있어야하는 일반적인 함정입니다.

비트 시프트 연산자

비트 왼쪽 시프트 << : 모든 비트를 주어진 단계 수만큼 왼쪽 (더 중요한)으로 시프트하고 int 크기를 초과하는 비트를 버립니다

<< $x 높은 설정 해제에 해당 $x 의해 비트와 승산 $x 2 승

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

비트 오른쪽 시프트 >> : 가장 낮은 시프트를 무시하고 나머지 비트를 오른쪽으로 이동합니다 (덜 중요 함).

>> $x 는 2의 $x 승으로 나누고 비 정수 부분을 버리는 것과 같습니다.

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

비트 시프 팅의 예 ​​:

(16)에 의해 빠른 부문 (보다 더 나은 성능 /= 16 )

$x >>= 4;

32 비트 시스템에서 이것은 정수의 모든 비트를 버리고 값을 0으로 설정합니다. 64 비트 시스템에서이 옵션은 최상위 32 비트를 설정 해제하지 않고 최소한으로 유지합니다

$x = $x << 32 >> 32;

중요한 32 비트는 $x & 0xFFFFFFFF 와 같습니다.

주 :이 예에서는 printf("%'06b") 가 사용됩니다. 값을 6 진수로 출력합니다.

객체와 클래스 연산자

객체 또는 클래스의 멤버는 객체 연산자 ( -> ) 및 클래스 연산자 ( :: :)를 사용하여 액세스 할 수 있습니다.

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

오브젝트 연산자 다음에 $ 를 써서는 안됩니다 ( $object->a 대신 $object->a $object->$a ). 클래스 연산자의 경우에는 그렇지 않으며 $ 가 필요합니다. 클래스에 정의 된 상수의 경우 $ 는 사용되지 않습니다.

또한 var_dump(MyClass::d()); 함수 d() 가 객체를 참조하지 않는 경우에만 허용됩니다.

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

이로 인해 'PHP 치명적 오류 : 캐치되지 않은 오류 : 객체 컨텍스트에없는 경우 $ this 사용'

이 연산자는 연관성을 남겨두고 '연결'에 사용할 수 있습니다.

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

이러한 연산자는 우선 순위가 가장 높으며 (설명서에서도 언급하지 않음) clone 더 높습니다. 그러므로:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

개체가 복제 되기 전에 $o1 값이 추가됩니다!

우선 순위에 영향을주기 위해 괄호를 사용하는 것은 PHP 버전 5 이상에서는 작동하지 않습니다 (PHP 7에서 작동 함).

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7