javascript - true - 자바 스크립트 스트링




JavaScript 비교에서 연산자와 같음(== vs===)을 사용해야합니까? (20)

ID ( === ) 연산자는 유형 변환이 수행되지 않는 경우를 제외하고 항등 ( == ) 연산자와 동일하게 작동하며 형식은 동일해야한다고 간주해야합니다.

참고 항목 : Javascript 자습서 : 비교 연산자

== 연산자는 필요한 형식 변환을 한 후에 동등 함 비교합니다. === 연산자는 변환을 수행하지 않으므로 두 값이 같은 유형이 아닌 경우 === 단순히 false 를 반환합니다. 둘 다 똑같이 빠릅니다.

Douglas Crockford의 탁월한 JavaScript : The Good Parts ,

JavaScript에는 두 가지 세트의 항등 연산자가 있습니다. ===!== , 악성 쌍둥이 ==!= 입니다. 좋은 것들은 당신이 기대하는대로 작동합니다. 두 피연산자가 같은 유형이고 동일한 값을 갖는 경우 ===true 생성하고 !==false 생성합니다. 사악한 쌍둥이는 피연산자가 같은 유형 일 때 올바른 일을하지만, 유형이 다르면 값을 강요하려고 시도합니다. 그들이하는 규칙은 복잡하고 비판적입니다. 다음은 흥미로운 사례입니다.

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

과도기의 부족은 놀랍습니다. 나의 충고는 사악한 쌍둥이를 결코 사용하지 않는 것입니다. 대신 항상 ===!== . 방금 표시된 모든 비교는 === 연산자로 false 를 생성합니다.

최신 정보:

좋은 점은 @Casebash 와 주석에서 @Phillipe Laybaert의 answer 유형에 관한 answer 이었습니다 . 참조 유형 ===== 대해 서로 일관되게 작용합니다 (특별한 경우 제외).

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

특수한 경우는 toString 또는 valueOf 메소드로 인해 동일한 리터럴로 평가되는 객체와 리터럴을 비교하는 경우입니다. 예를 들어 문자열 리터럴과 String 생성자가 만든 문자열 객체를 비교해보십시오.

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

여기에 == 연산자가 두 객체의 값을 검사하고 true 반환하지만 === 는 동일한 유형이 아니고 false 반환하는 false 봅니다. 어느 것이 옳은가요? 그것은 정말로 당신이 비교하려고하는 것에 달려 있습니다. 내 충고는 질문을 완전히 무시하고 String 객체를 생성하기 위해 String 생성자를 사용하지 않는 것이다.

참고
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

JavaScript를 통해 JSLint 를 사용하고 있는데, idSele_UNVEHtype.value.length == 0 와 비교하는 것과 같은 일을 할 때 == (두 개의 등호) === 성명서.

===== 로 바꾸면 성능 이점이 있습니까?

많은 비교 연산자가 존재하기 때문에 어떤 성능 향상도 환영 할 것입니다.

형식 변환이 수행되지 않으면 == 보다 성능이 향상됩니까?


JSLint는 때때로 당신에게 물건을 수정하는 비현실적인 이유를 제공합니다. === 유형이 이미 동일하면 == 와 정확히 동일한 성능을 갖습니다.

유형이 같지 않을 때만 더 빠르며, 유형을 변환하려고 시도하지 않고 직접 false를 반환합니다.

따라서 IMHO, JSLint는 새로운 코드를 작성하는 데 사용할 수 있지만 쓸데없는 과도한 최적화를 피해야합니다.

의미는 == to ===if (a == 'test') 와 같은 검사에서 변경할 수있는 이유가 없다는 것을 알 때, a는 String 일뿐입니다.

많은 코드를 수정하면 개발자와 검토 자의 시간이 낭비되고 아무 것도 달성 할 수 없습니다.


JavaScript에서는 동일한 값과 유형을 의미합니다.

예를 들어,

4 == "4" // will return true

그러나

4 === "4" // will return false 

PHP와 JavaScript에서는 완전 항등 연산자입니다. 즉, 형식과 값을 비교합니다.


같은면의 값이 같은지 검사 합니다 .

예:

'1' === 1 // will return "false" because `string` is not a `number`

일반적인 예 :

0 == ''  // will be "true", but it's very common to want this check to be "false"

또 다른 일반적인 예 :

null == undefined // returns "true", but in most cases a distinction is necessary

그것은 엄격한 체크 테스트입니다.

특히 0과 false 및 null 사이를 확인하는 것이 좋습니다.

예를 들어 다음과 같은 경우 :

$a = 0;

그때:

$a==0; 
$a==NULL;
$a==false;

모두는 진실을 반환하고 당신은 이것을 원하지 않을 수도 있습니다. 배열의 0 번째 인덱스를 반환 할 수있는 함수가 있다고 가정 해 보겠습니다. 실패하면 false를 반환합니다. "=="false로 체크하면 혼란스러운 결과를 얻을 수 있습니다.

위와 똑같은 점을 제외하고는 엄격한 테스트가 필요합니다.

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

엄격한 평등 / 비교를위한 자바 스크립트 실행 흐름도 '==='

비 엄격한 평등 / 비교를위한 자바 스크립트 실행 흐름도 '=='


여기에 대한 답은 평등 한 의미에 대해 읽지 않았습니다. 어떤 사람들은 === 동등하고 동일한 유형 이라는 것을 말할 것입니다.하지만 그건 사실이 아닙니다. 실제로는 두 피연산자가 동일한 객체를 참조 하거나 값 유형의 경우 동일한 값을 가짐을 의미 합니다.

이제 다음 코드를 살펴 보겠습니다.

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

같은 여기 :

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

또는:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

이 동작은 항상 명확하지 않습니다. 평등하고 동일한 유형이되는 것보다 이야기에 더 많은 것이 있습니다.

규칙은 다음과 같습니다.

값 유형 (숫자) :
a === bab 가 같은 값을 갖고 동일한 유형 인 경우 true를 반환합니다.

참조 유형 :
a === bab 똑같은 객체를 참조하면 true를 반환합니다.

문자열의 경우 :
a === bab 가 모두 문자열이고 정확하게 동일한 문자를 포함하면 true를 반환합니다.

문자열 : 특별한 경우 ...

문자열은 값 유형이 아니지만 Javascript에서는 값 유형과 동일하게 동작하므로 문자열의 문자가 같고 길이가 같은 경우 (세 번째 규칙에서 설명)

이제 그것은 흥미로워진다.

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

하지만 이건 어때? :

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

문자열이 값 유형처럼 동작한다고 생각 했습니까? 글쎄, 누가 묻 느냐에 따라 다르다.이 경우 a와 b는 같은 타입이 아니다. aObject 유형이고 bstring 유형입니다. String 생성자를 사용하여 문자열 객체를 만드는 것은 대부분의 경우 문자열로 동작하는 Object 유형의 것을 만듭니다.


이 권고를 덧붙이 자.

의심 스럽다면 specification 읽어보십시오!

ECMA-262는 JavaScript가 방언 인 스크립팅 언어의 사양입니다. 물론 실제로는 중요한 브라우저가 어떻게 처리되어야하는지에 대한 비전있는 정의보다 어떻게 작동하는지 더 중요합니다. 그러나 왜 새로운 String ( "a")! == "a" 인지 이해하는 것이 도움이됩니다.

이 질문을 명확히하기 위해 사양을 읽는 방법을 설명하겠습니다. 나는이 아주 오래된 주제에서 아무도 아주 이상한 결과에 대한 해답을 얻지 못했다는 것을 알았다. 따라서 사양을 읽을 수 있으면 전문 분야에서 큰 도움이 될 것입니다. 그것은 획득 한 기술입니다. 자, 계속하겠습니다.

PDF 파일을 검색하면 사양의 56 페이지로 이동합니다. 11.9.4. Strict Equals Operator (===) , 그리고 내가 찾은 specificationalese를 넘어서서 :

11.9.6 엄격한 평등 비교 알고리즘
비교 x === y, 여기서 x와 y는 값이며 true 또는 false를 생성 합니다 . 이러한 비교는 다음과 같이 수행됩니다.
1. Type (x)이 Type (y)과 다른 경우 false를 반환합니다.
2. Type (x)가 Undefined 인 경우 true를 반환 합니다 .
3. Type (x)이 Null 이면 true를 반환 합니다 .
4. Type (x)이 Number가 아니면 11 단계로 이동하십시오.
5. x가 NaN 이면 false를 반환합니다.
6. y가 NaN 이면 false를 반환합니다.
7. x가 y와 동일한 숫자 값 이면 true를 반환 합니다 .
8. x가 +0이고 y가 -0 이면 true를 반환 합니다 .
9. x가 -0이고 y가 +0 이면 true를 반환 합니다 .
10. false를 반환합니다.
11. Type (x)가 String 인 경우 x와 y가 정확히 동일한 문자 순서 (해당 위치에서 길이가 같고 동일한 문자) 인 경우 true 를 반환 합니다 . 그렇지 않은 경우는 false를 리턴합니다.
12. Type (x)가 Boolean이면 x와 y가 모두 true 이거나 둘 다 false 이면 true를 반환하고 그렇지 않으면 false를 반환 합니다 . 그렇지 않은 경우는 false를 리턴합니다.
13. x와 y가 같은 객체를 참조하거나 서로 조인 된 객체를 참조하는 경우 true를 반환 합니다 (13.1.2 참조). 그렇지 않은 경우는 false를 리턴합니다.

재미있는 것은 11 단계입니다. 예, 문자열은 값 유형으로 처리됩니다. 그러나 이것이 왜 새로운 String ( "a")! == "a" 인지 설명하지 못합니다. ECMA-262를 준수하지 않는 브라우저가 있습니까?

그렇게 빨리!

피연산자의 유형을 확인해 봅시다. 그것들을 typeof () 에 랩핑하여 직접 사용해보십시오. 새 String ( "a") 이 객체이고 1 단계가 사용 된 것으로 나타났습니다. 유형이 다른 경우 false를 반환합니다.

새로운 String ( "a") 이 문자열을 반환하지 않는 이유가 궁금하다면, 스펙을 읽는 운동에 대해 어떨까요? 재미있어!

Aidiakapi는 아래의 주석에 이것을 적었습니다 :

사양에서

11.2.2 새로운 연산자 :

Type (생성자)이 Object가 아니면 TypeError 예외를 throw합니다.

즉, String이 Object 유형이 아니면 new 연산자와 함께 사용할 수 없습니다.

new는 항상 String 생성자에 대해서도 Object를 반환합니다. 그리고 아아! 문자열의 값 의미 (11 단계 참조)가 손실됩니다.

그리고 이것은 결국 새로운 문자열 ( "a")을 의미합니다! == "a" .


이것은 타입 강제 변환 타입 변환이 없는 동등 함을 의미합니다. JavaScript는 자동으로 다른 데이터 타입을 문자열 데이터 타입으로 변환하지 않습니다.

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 

파이어 폭스에서 다음과 같은 코드를 사용하여 Firebug 를 테스트했습니다.

console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

내 결과 (각 5 회 테스트하고 평균) :

==: 115.2
===: 114.4

그래서 나는 미미한 차이 (이것은 100000 번 이상의 반복이다)는 무시할 만하다고 말한다. 성과 해야 할 이유 가 아닙니다 . 유형 안전성 (자바 스크립트에서 얻을 수있는 안전함) 및 코드 품질은 안전합니다.


평등 비교 :

운영자 ==

두 피연산자가 같은 경우 true를 반환합니다. 피연산자는 비교되기 전에 동일한 유형으로 변환됩니다.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

평등 및 유형 비교 :

운영자 ===

두 피연산자가 같고 같은 유형 인 경우 true를 반환합니다. 이런 식으로 비교하면 일반적으로 더 좋고 안전합니다. 왜냐하면 비하인드 유형 변환이 없기 때문입니다.

>>> 1 === '1'
false
>>> 1 === 1
true

===== 사이의 평등 비교에 대한 흥미로운 그림 표현.

출처 : dorey.github.io/JavaScript-Equality-Table

var1 === var2

자바 스크립트 동등성 테스트에 === 를 사용하면 모든 것이 그대로입니다. 평가되기 전에 변환 된 것은 없습니다.

var1 == var2

JavaScript 동등성 테스트에 == 를 사용하면 일부 펑키 변환이 발생합니다.

이야기의 교훈:

=== 사용하여 발생하는 전환을 완전히 이해하지 않으면 === 사용하십시오.


등호 비교 연산자 ==는 혼란스럽고 피해야합니다.

당신이 그걸 가지고 살아야한다면, 다음 세 가지를 기억하십시오 :

  1. 전이 적이 지 않습니다. (a == b)(b == c)(a == c)
  2. 부정의 의미는 상호 배타적입니다 : (a == b)(a! = b)는 항상 a와 b가 모두 반대 인 부울 값을 유지합니다.
  3. 의심의 여지가있는 경우 다음 진리 표를 마음으로 배우십시오.

JAVASCRIPT의 등식 연산자 진리표

  • 테이블의 각 행은 3 개의 상호 "동등한"값의 집합입니다. 즉, 두 개의 값이 같음 == 부호 *

** STRANGE : 첫 번째 열의 두 값은 같은 의미가 아닙니다. **

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

예! 중요하다.

=== 연산자 는 값뿐만 아니라 값을 검사합니다. == 연산자 는 값을 확인 합니다 (필요한 경우 유형 변환을 수행합니다) .

당신은 쉽게 그것을 테스트 할 수 있습니다. 다음 코드를 HTML 파일에 붙여넣고 브라우저에서 엽니 다.

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

당신은 경고에서 ' 거짓 '을 얻을 것입니다. 이제 onPageLoad() 메소드를 수정하여 alert(x == 5); 너는 사실 이 될 것이다.


== 예측할 수없는 이유는 무엇입니까?

빈 문자열 "" 을 숫자 0과 비교할 때 무엇을 얻습니까?

true

네, 맞습니다 == 빈 문자열과 숫자 0은 같은 시간입니다.

그리고 거기에서 끝나지 않습니다. 또 다른 것이 있습니다 :

'0' == false // true

배열로 정말 상황이 이상해집니다.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

그 다음 문자열로 더 이상한

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

점점 더 심해집니다.

동등하지 않은 경우는 언제입니까?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

다시 말해 볼게요.

(A == B) && (B == C) // true
(A == C) // **FALSE**

그리고 이것은 당신이 프리미티브로 얻는 미친 것들입니다.

== 를 객체와 함께 사용할 때 완전히 새로운 수준의 미친 것입니다.

이 시점에서 아마 궁금해 할 ...

왜 이런 일이 생길까요?

그것은 두 값이 같은지 확인하는 "triple equals"( === )와는 다르기 때문입니다.

== 다른 많은 것들을 합니다.

그것은 함수를위한 특별한 핸들링, 널, undefined, 문자열을위한 특별한 핸들링을 가지고 있습니다.

꽤 엉뚱한 짓이야.

사실, 당신이 == 무엇을하는 함수를 작성하려고하면 다음과 같이 보일 것입니다 :

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

그렇다면이게 무슨 뜻입니까?

그것은 == 가 복잡 == 것을 의미합니다.

복잡하기 때문에 당신이 그것을 사용할 때 일어날 일을 아는 것은 어렵습니다.

그 말은 당신이 벌레로 끝날 수 있다는 뜻이야.

그 이야기의 도덕은 ...

삶을 덜 복잡하게 만듭니다.

== 대신 === 를 사용하십시오.

끝.


간단한 예는 다음과 같습니다.

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

문제는 JavaScript가 암시 적 변환의 의미가 많기 때문에 쉽게 문제가 될 수 있다는 것입니다.

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

꽤 곧 문제가됩니다. 암시 적 변환이 "악의"인 이유의 가장 좋은 샘플은 MFC / C ++ 에서이 코드에서 가져올 수 있습니다. 실제로 CString에서 HANDLE 로의 암시 적 변환으로 컴파일됩니다. 이는 포인터 유형 typedef 유형입니다.

CString x;
delete x;

어느 분명히 런타임 동안 수행 매우 정의되지 않은 일을 ...

C ++과 STL 암시 적 변환에 대한 Google, 일부 인수를 얻으려고 ...



엄지 손가락의 규칙으로, 나는 ===대신에 ==( !==대신에 !=) 대신에 사용할 것이다 .

이유는 위의 답변에서 설명하고 Douglas Crockford도 이에 대해 매우 명확합니다 ( JavaScript : The Good Parts ).

그러나 하나의 예외가 있습니다 : == null'null 또는 undefined'를 확인하는 효율적인 방법입니다 :

if( value == null ){
    // value is either null or undefined
}

예를 들어, jQuery 1.9.1은이 패턴을 43 번 사용하며 JSHint 구문 검사기eqnull이러한 이유로 편안한 옵션을 제공합니다 .

로부터 의 jQuery 스타일 가이드 :

엄격한 평등 점검 (===)은 ==를 위해 사용되어야합니다. 유일한 예외는 정의되지 않은 null을 null로 검사 할 때입니다.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;




identity-operator