PHP 평등 (== double equals)과 ID (=== triple equals) 비교 연산자는 어떻게 다른가요?

==와 ===의 차이점은 무엇입니까?

유용한 예가 무엇입니까?

해결법

==============================
1.느슨하게 == 등호 연산자와 엄격한 == 동일한 연산자의 차이점은 설명서에서 정확하게 설명합니다.

느슨하게 == 등호 연산자와 엄격한 == 동일한 연산자의 차이점은 설명서에서 정확하게 설명합니다.

== 연산자 또는! =, <> 또는 ==와 같은 느슨한 비교를 사용하는 다른 비교 연산자를 사용하는 경우 항상 무엇이, 어디서, 무엇이 왜 변환되는지를 확인하기 위해 상황을 관찰해야합니다 진행되고있다.

참조 및 예로서 매뉴얼에서 비교 테이블을 볼 수 있습니다.

=== 연산자 또는! == 또는 ===와 같은 엄격한 비교를 사용하는 다른 비교 연산자를 사용하는 경우 변환이 없으므로 유형이 마술처럼 바뀌지 않을 것이라는 것을 항상 확신 할 수 있습니다 계속. 엄격한 비교를 통해 유형과 값은 값뿐만 아니라 동일해야합니다.

참조 및 예로서 매뉴얼에서 비교 테이블을 볼 수 있습니다.
==============================
2.== 연산자는 'typesafe comparison'을 수행하는 반면, 연산자는 == 연산자가 다르면 두 개의 다른 유형간에 변환을 수행합니다. 즉, 두 피연산자가 동일한 유형 및 동일한 값을 갖는 경우에만 true를 반환합니다.

== 연산자는 'typesafe comparison'을 수행하는 반면, 연산자는 == 연산자가 다르면 두 개의 다른 유형간에 변환을 수행합니다. 즉, 두 피연산자가 동일한 유형 및 동일한 값을 갖는 경우에만 true를 반환합니다.

예 :
```
1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value
```
경고 : 동등한 멤버가있는 동일한 클래스의 두 인스턴스가 === 연산자와 일치하지 않습니다. 예:
```
$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
```
==============================
3.그림은 천 단어의 가치가있다 :

그림은 천 단어의 가치가있다 :

이러한 이미지를 생성하는 소스 코드 :

https://github.com/sentientmachine/php_equality_charts

그들의 정신을 지키려는 사람들은 더 이상 읽을 수 없습니다.

PHP를 사용하는 경우, 두 번 등호 연산자를 사용하지 말고 항상 트리플 등호를 사용하십시오.
==============================
4.JavaScript와 관련하여 :

JavaScript와 관련하여 :

=== 연산자는 == 연산자와 동일하게 작동하지만 피연산자의 값이 같을뿐만 아니라 동일한 데이터 형식도 필요합니다.

예를 들어, 아래의 샘플은 'x와 y는 동일'을 표시하지만 'x와 y는 동일하지 않습니다.'
```
var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}
```
==============================
5.객체 비교와 관련된 다른 답변에 추가 된 사항은 다음과 같습니다.

객체 비교와 관련된 다른 답변에 추가 된 사항은 다음과 같습니다.

== 객체의 이름과 값을 사용하여 객체를 비교합니다. 두 객체의 유형이 같고 멤버 값이 같은 경우 $ a == $ b가 true를 반환합니다.

=== 오브젝트의 내부 오브젝트 ID를 비교합니다. 멤버가 동일하더라도 $ a! == $ b는 똑같은 객체가 아닙니다.
```
class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object
```
==============================
6.가장 간단한 용어로 :

가장 간단한 용어로 :

== 동일하면 (값만)

=== 같은 (값 && 타입) 동등 대 동일 : 유추

1 + 1 = 2 + 0 (등가)

1 + 1 = 1 + 1 (동일) PHP의 경우 :

true == 1 (true - 값이 동일)

true === 1 (false - 값 && type과 같지 않음)
==============================
7.그것은 모두 데이터 유형에 관한 것입니다. BOOL (true 또는 false)을 예로 들어 보겠습니다.

그것은 모두 데이터 유형에 관한 것입니다. BOOL (true 또는 false)을 예로 들어 보겠습니다.

true도 1과 같고 false도 0과 같습니다.

==는 비교할 때 데이터 유형에 상관하지 않습니다. 변수가 1 인 경우 (true 일 수도 있음) :

$ = 1이었다;

그리고 ==와 비교하십시오 :
```
if ($var == true)
{
    echo"var is true";
}
```
하지만 $ var는 실제로 사실과 같지 않습니다. 그렇습니까? 대신 int 값이 1이고, 차례로 true와 같습니다.

===를 사용하여 두 변수 / 객체 /가 동일한 유형을 사용하는지 확인하기 위해 데이터 유형을 검사합니다.

그래서 내가 그랬다면
```
if ($var === true)
{
    echo "var is true";
}
```
그 조건은 사실이 아닐 것입니다. $ var! == true 그것은 단지 == true입니다.

왜 이걸 필요할까요?

간단한 - PHP 함수 중 하나를 살펴 보겠습니다 : array_search () :

array_search () 함수는 단순히 배열의 값을 검색하고 값이 발견 된 요소의 키를 반환합니다. 배열에서 값을 찾을 수 없으면 false를 반환합니다. 그러나 배열의 첫 번째 요소 (배열 키가 0)에 저장된 값에 대해 array_search ()를 수행하면 array_search () 함수가 0을 반환합니다. 거짓과 같음 ..

그렇게 한 경우 :
```
$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}
```
이제 어떻게 이것이 문제가 될 수 있는지 보시겠습니까?

대부분의 사람들은 함수가 거짓을 반환하는지 검사 할 때 == false를 사용하지 않습니다. 대신!를 사용합니다. 그러나 실제로 이것은 == false를 사용하는 것과 정확히 동일합니다. 그렇게했다면 :
```
$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)
```
이런 식으로 대신 ===를 사용하면 데이터 형식이 검사됩니다.

==============================

8.한 가지 예는 데이터베이스 속성이 null 또는 ""일 수 있다는 것입니다.

한 가지 예는 데이터베이스 속성이 null 또는 ""일 수 있다는 것입니다.

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true

==============================
9.주어진 x = 5

주어진 x = 5

1) 연산자 : ==는 "같음"입니다. x == 8은 거짓입니다. 2) 연산자 : ===는 "정확히 같음"(값 및 유형)입니다. x === 5는 true이고, x === "5"는 false입니다.

==============================

10.

$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

그래도 조심해. 여기에 악명 높은 문제가 있습니다.

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

대

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}

==============================
11.즉, ===는 대부분의 다른 프로그래밍 언어에서 ==가하는 것과 같은 방식으로 작동합니다.

즉, ===는 대부분의 다른 프로그래밍 언어에서 ==가하는 것과 같은 방식으로 작동합니다.

PHP를 사용하면 실제로는 이해할 수없는 비교를 할 수 있습니다. 예:
```
$y = "wauv";
$x = false;
if ($x == $y)
    ...
```
이것은 몇 가지 재미있는 "단축키"를 허용하지만 숫자가 아닌 "오류"와 같은 어떤 것을 반환하는 함수가 잡히지 않아 어떤 일이 일어 났는지 궁금하게 남을 것입니다.

PHP에서 ==는 값을 비교하고 필요한 경우 유형 변환을 수행합니다 (예 : 문자열 "12343sdfjskfjds"는 정수 비교에서 "12343"이됩니다). === 값 AND 유형을 비교하고 유형이 동일하지 않으면 false를 리턴합니다.

PHP 매뉴얼을 보면 함수가 실패하면 많은 함수가 "false"를 반환하지만 성공한 시나리오에서는 0을 반환 할 수 있다는 것을 알 수 있습니다. 따라서 "if (function ()! == 거짓) "실수를 피하십시오.

==============================

12.몇 가지 예

몇 가지 예

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

추신

대

==============================
13.===를 사용하여 함수 또는 변수가 false (0 또는 빈 문자열)와 같지 않은지 여부를 테스트 할 수 있습니다.

===를 사용하여 함수 또는 변수가 false (0 또는 빈 문자열)와 같지 않은지 여부를 테스트 할 수 있습니다.
```
$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}
```
이 경우 strpos는 테스트에서 false와 같을 0을 반환합니다.
```
if ($pos == false)
```
또는
```
if (!$pos)
```
그건 네가 여기서 원하는게 아니야.
==============================
14.하나를 다른 것 이상으로 사용할 때는 PHP에서 fwrite () 함수를 예로들 수 있습니다.

하나를 다른 것 이상으로 사용할 때는 PHP에서 fwrite () 함수를 예로들 수 있습니다.

이 함수는 내용을 파일 스트림에 씁니다. PHP에 따르면 "fwrite ()는 쓰여진 바이트 수를 반환하고 에러시에는 거짓을 반환합니다." 함수 호출이 성공했는지 테스트하려면이 메서드에 결함이 있습니다.
```
if (!fwrite(stuff))
{
    log('error!');
}
```
0을 반환 할 수 있으며 성공한 것으로 간주되며 여전히 상태가 트리거됩니다. 올바른 방법은 다음과 같습니다.
```
if (fwrite(stuff) === FALSE)
{
    log('error!');
}
```
==============================
15.PHP는 느슨하게 입력 된 언어입니다. 이중 등호 연산자를 사용하면 변수를 느슨하게 검사 할 수 있습니다.

PHP는 느슨하게 입력 된 언어입니다. 이중 등호 연산자를 사용하면 변수를 느슨하게 검사 할 수 있습니다.

값을 느슨하게 검사하면 유사하지만 동일하지 않은 값이 동일하게 일치 할 수 있습니다.

이 모든 값은 double equal 연산자를 사용하여 동일하게 간주됩니다.
==============================
16.변수에는 유형과 값이 있습니다.

변수에는 유형과 값이 있습니다.

PHP에서 이러한 변수를 사용할 때 가끔 좋은 유형이 없습니다. 예를 들어,
```
if ($var == 1) {... do something ...}
```
PHP는 $ var를 정수로 변환해야합니다. 이 경우, "$ var == 1"은 비어 있지 않은 문자열이 1로 형 변환되기 때문에 참입니다.

===를 사용할 때, AND와 TYPE이 같은지 확인하므로 "$ var === 1"은 false입니다.

예를 들어 false (오류시)와 0 (result)을 반환 할 수있는 함수가있는 경우 유용합니다.
```
if(myFunction() == false) { ... error on myFunction ... }
```
이 코드는 myFunction ()이 0을 반환하는 것처럼 잘못되었으며, false로 캐스팅되고 오류가있는 것 같습니다. 올바른 코드는 다음과 같습니다.
```
if(myFunction() === false) { ... error on myFunction ... }
```
테스트는 반환 값이 "부울이며 false"이며 "false로 캐스팅 될 수 없습니다"때문입니다.
==============================
17.=== 연산자는 정확한 내용 동등성을 비교하는 반면, == 연산자는 의미 평등을 비교합니다. 특히 문자열을 숫자로 강제 변환합니다.

=== 연산자는 정확한 내용 동등성을 비교하는 반면, == 연산자는 의미 평등을 비교합니다. 특히 문자열을 숫자로 강제 변환합니다.

평등은 광대 한 주제입니다. 평등에 관한 Wikipedia 기사를 참조하십시오.

==============================

18.

<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>

==============================
19.지금까지 모든 답변은 위험한 문제를 무시했습니다. 전달할 때 강조되었지만 강조되지 않은 정수와 double은 다른 유형이므로 다음 코드를 참조하십시오.

지금까지 모든 답변은 위험한 문제를 무시했습니다. 전달할 때 강조되었지만 강조되지 않은 정수와 double은 다른 유형이므로 다음 코드를 참조하십시오.
```
$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );
```
제공 :
```
 equal
 not equal
```
이것은 "반올림 오류"의 경우가 아닙니다. 두 숫자는 정확히 마지막 비트까지 동일하지만 유형이 다릅니다.

이것은 ===를 사용하는 프로그램이 모든 숫자가 충분히 작 으면 수년간 행복하게 운영 할 수 있기 때문에 문제가됩니다 (여기서 "충분히 작은"은 실행중인 하드웨어와 OS에 따라 다릅니다). 그러나 우연히 정수가 double 값으로 변환 될만큼 충분히 커지면 후속 연산 또는 많은 연산이 값을 작은 정수로 다시 가져올지라도 형식이 "영원히"변경됩니다. 그리고, 그것은 더 나 빠지게됩니다. 확산 될 수 있습니다 - 이중성 감염은 접촉하는 모든 것에 전달 될 수 있습니다. 한 번에 하나씩 계산됩니다.

실제로는 2038 년 이후의 날짜를 처리하는 프로그램에서 문제가 될 수 있습니다. 현재 UNIX 타임 스탬프 (1970-01-01 00:00:00 UTC 이후 초 수)는 32 비트 이상을 필요로하기 때문에 일부 시스템에서는 그 표현이 "마술처럼"전환됩니다. 따라서 두 시간의 차이를 계산할 경우 몇 초 만에 끝나야하지만, 2017 년에 발생한 정수 결과가 아닌 두 배로 끝납니다.

미묘하기 때문에 이것은 문자열과 숫자 사이의 변환보다 훨씬 더 나쁜 것으로 생각합니다. 나는 문자열이 무엇인지, 숫자인지 추적하는 것이 쉽다는 것을 알았지 만, 숫자의 비트 수를 추적하는 것은 저를 넘어선 것입니다.

따라서 위의 대답에는 멋진 테이블이 있지만 정수 (1)와 1 (미묘한 이중) 및 1.0 (명백한 이중)의 구분이 없습니다. 또한 === 및 never ==를 항상 사용해야한다는 조언은 훌륭하지 않습니다. 왜냐하면 ==가 제대로 작동하는 곳에서 ===가 때때로 실패하기 때문입니다. 또한 자바 스크립트는 숫자 형식이 하나뿐이기 때문에 이와 관련이 없습니다 (내부적으로 비트 단위 표현이 다를 수 있지만 ===에 문제가 발생하지는 않습니다).

나의 조언 - 둘 다 사용하지 마십시오. 이 혼란을 실제로 수정하려면 자체 비교 함수를 작성해야합니다.

==============================

20.PHP 배열과 객체에는 ==와 ===의 두 가지 차이점이 있습니다. 여기서는 언급하지 않았습니다. 배열과 객체를 정렬 할 때.

PHP 배열과 객체에는 ==와 ===의 두 가지 차이점이 있습니다. 여기서는 언급하지 않았습니다. 배열과 객체를 정렬 할 때.

예제를 따라 차이점을 확인하십시오.

$arr = [];
$arr[1] = true;
$arr[0] = false;

// Saving original array
$originalArr = $arr;

// Sorting array
sort($arr);

그럼, 보자 :

var_dump($originalArr);
/*
array(2) {
  [1]=>
  bool(true)
  [0]=>
  bool(false)
}
*/
var_dump($arr);
/*
array(2) {
  [0]=>
  bool(false)
  [1]=>
  bool(true)
}
*/

echo json_encode($originalArr == $arr); // true
echo json_encode($originalArr === $arr); // false

그러나 정확히 같은 두 배열은 항상 같습니다.

echo json_encode([] == []); // true
echo json_encode([] === []); // true

두 개의 서로 다른 객체가 엄격하게 동일하지는 않습니다 (예 : === 사용).

$object1 = new stdClass();
$object2 = new stdClass();
$object3 = clone $object1;

// Comparing
echo json_encode($object1 == $object2); // true
echo json_encode($object1 === $object2); // false
echo json_encode($object1 == $object3); // true
echo json_encode($object1 === $object3); // false

참고 : 개체를 다른 변수에 할당해도 복사본이 생성되지 않고 개체와 동일한 메모리 위치에 대한 참조가 만들어집니다. 여기를 보아라.

from https://stackoverflow.com/questions/589549/php-vs-operator by cc-by-sa and MIT license

'PHP' 카테고리의 다른 글

각 사용자에 대해 자동으로 하위 도메인을 만들도록 PHP를 설정하는 방법은 무엇입니까? (0)	2018.09.12
PHP 7.2에서 Mcrypt 제거 준비 (0)	2018.09.11
하이픈으로 연결된 이름을 가진 SimpleXML 노드 읽기 (0)	2018.09.11
method = "post"enctype = "text / plain"은 호환되지 않습니까? (0)	2018.09.11
경고 : mysql_fetch_array ()는 매개 변수 1이 resource이고 boolean이 [duplicate] 인 것으로 가정합니다. (0)	2018.09.11

복붙노트

PHP 평등 (== double equals)과 ID (=== triple equals) 비교 연산자는 어떻게 다른가요?

PHP 평등 (== double equals)과 ID (=== triple equals) 비교 연산자는 어떻게 다른가요?

해결법

1.느슨하게 == 등호 연산자와 엄격한 == 동일한 연산자의 차이점은 설명서에서 정확하게 설명합니다.

2.== 연산자는 'typesafe comparison'을 수행하는 반면, 연산자는 == 연산자가 다르면 두 개의 다른 유형간에 변환을 수행합니다. 즉, 두 피연산자가 동일한 유형 및 동일한 값을 갖는 경우에만 true를 반환합니다.

3.그림은 천 단어의 가치가있다 :

4.JavaScript와 관련하여 :

5.객체 비교와 관련된 다른 답변에 추가 된 사항은 다음과 같습니다.

6.가장 간단한 용어로 :

7.그것은 모두 데이터 유형에 관한 것입니다. BOOL (true 또는 false)을 예로 들어 보겠습니다.

8.한 가지 예는 데이터베이스 속성이 null 또는 ""일 수 있다는 것입니다.

9.주어진 x = 5

10.

11.즉, ===는 대부분의 다른 프로그래밍 언어에서 ==가하는 것과 같은 방식으로 작동합니다.

12.몇 가지 예

13.===를 사용하여 함수 또는 변수가 false (0 또는 빈 문자열)와 같지 않은지 여부를 테스트 할 수 있습니다.

14.하나를 다른 것 이상으로 사용할 때는 PHP에서 fwrite () 함수를 예로들 수 있습니다.

15.PHP는 느슨하게 입력 된 언어입니다. 이중 등호 연산자를 사용하면 변수를 느슨하게 검사 할 수 있습니다.

16.변수에는 유형과 값이 있습니다.

17.=== 연산자는 정확한 내용 동등성을 비교하는 반면, == 연산자는 의미 평등을 비교합니다. 특히 문자열을 숫자로 강제 변환합니다.

18.

19.지금까지 모든 답변은 위험한 문제를 무시했습니다. 전달할 때 강조되었지만 강조되지 않은 정수와 double은 다른 유형이므로 다음 코드를 참조하십시오.

20.PHP 배열과 객체에는 ==와 ===의 두 가지 차이점이 있습니다. 여기서는 언급하지 않았습니다. 배열과 객체를 정렬 할 때.

'PHP' 카테고리의 다른 글

티스토리툴바