이것은 !! (not not) JavaScript의 연산자?

질문자 :Hexagon Theory

다음과 같이 두 개의 느낌표 형태로 내가 인식하지 못하는 연산자를 사용하는 것으로 보이는 코드를 보았습니다. !! . 이 연산자가 무엇을 하는지 알려주실 수 있나요?

내가 본 맥락은,

 this.vertical = vertical !== undefined ? !!vertical : this.vertical;

Object 를 boolean 변환합니다. 거짓이면(예: 0 , null , undefined 등) false 이고 그렇지 않으면 true 입니다.

 !oObject // inverted boolean !!oObject // non inverted boolean so true boolean representation

그래서 !! 연산자가 아니라 그냥 ! 연산자 두 번.

실제 예제 "IE 버전 테스트":

 const isIE8 = !! navigator.userAgent.match(/MSIE 8.0/); console.log(isIE8); // returns true or false

⇒

 console.log(navigator.userAgent.match(/MSIE 8.0/)); // returns either an Array or null

하지만 ⇒

 console.log(!!navigator.userAgent.match(/MSIE 8.0/)); // returns either true or false

stevehipwell

유형 변환을 수행하는 끔찍하게 모호한 방법입니다.

! 은(는) 아닙니다 . 따라서 !true 는 false 이고 !false 는 true 입니다. !0 은 true 이고 !1 은 false 입니다.

따라서 값을 부울로 변환한 다음 반전한 다음 다시 반전합니다.

 // Maximum Obscurity: val.enabled = !!userId; // Partial Obscurity: val.enabled = (userId != 0) ? true : false; // And finally, much easier to understand: val.enabled = (userId != 0);

Tom Ritter

!!expr (두 개의 ! 연산자 다음에 표현식)은 표현식 의 진실성 에 true 또는 false )을 반환합니다. 부울이 아닌 유형에 사용할 때 더 의미가 있습니다. 다음 예, 특히 세 번째 예 이상을 고려하십시오.

 !!false === false !!true === true !!0 === false !!parseInt("foo") === false // NaN is falsy !!1 === true !!-1 === true // -1 is truthy !!(1/0) === true // Infinity is truthy !!"" === false // empty string is falsy !!"foo" === true // non-empty string is truthy !!"false" === true // ...even if it contains a falsy value !!window.foo === false // undefined value is falsy !!undefined === false // undefined primitive is falsy !!null === false // null is falsy !!{} === true // an (empty) object is truthy !![] === true // an (empty) array is truthy; PHP programmers beware!

Salman A

차를 끓이세요:

!! 운영자가 아닙니다. 의 이중 사용입니다 ! -- 논리적 "not" 연산자입니다.

---

이론에 의하면:

! 값이 아닌 것의 "진실"을 결정합니다.

• 진실은 false true 이 아니라는 것입니다(이것이 !false 결과가 true 이유입니다)

• 진실은 true false 가 아니라는 것입니다 !true 가 false 가 되는 이유입니다)

---

!! 값이 아닌 것의 "진실"을 결정합니다.

• 사실은 true 가 true가 아니라는 것 true !!true 가 되는 이유 true )

• 진실은 즉 false 없는없는 false (의 그 이유 !!false 결과 false )

---

우리가 비교에서 결정하고자 하는 것은 참조 값 자체가 아니라 참조 값에 대한 "진실"입니다. false (또는 false)일 것으로 예상하거나 값이 typeof boolean 아닐 것으로 예상하더라도 값에 대한 진실을 알고 싶어하는 사용 사례가 있습니다.

---

실제로:

동적 타이핑 (일명 "덕 타이핑")을 통해 기능 기능(이 경우 플랫폼 호환성)을 감지하는 간결한 함수를 고려하십시오. 사용자의 브라우저가 HTML5 <audio> true 를 반환하는 함수를 작성하고 <audio> 가 정의되지 않은 경우 함수에서 오류가 발생하는 것을 원하지 않습니다. 그리고 가능한 오류를 처리 try ... catch 를 사용하고 싶지 않습니다. 또한 우리는 지속적으로 (예를 들어 기능에 대한 진실을 공개하지 않습니다 함수 내에서 수표를 사용하지 않는다 document.createElement('audio') 여전히이라는 요소를 만듭니다 <audio> 도 HTML5 경우 <audio> 는 지원되지 않습니다).

---

다음은 세 가지 접근 방식입니다.

 // this won't tell us anything about HTML5 `<audio>` as a feature var foo = function(tag, atr) { return document.createElement(tag)[atr]; } // this won't return true if the feature is detected (although it works just fine) var bar = function(tag, atr) { return !document.createElement(tag)[atr]; } // this is the concise, feature-detecting solution we want var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; } foo('audio', 'preload'); // returns "auto" bar('audio', 'preload'); // returns false baz('audio', 'preload'); // returns true

각 함수는 검색할 <tag> 및 attribute 에 대한 인수를 허용하지만 비교 결과에 따라 각각 다른 값을 반환합니다.

하지만 더 많은 것이 있습니다!

여러분 중 일부는 이 특정 예에서 문제의 객체에 속성 이 있는지 확인하는 약간 더 성능이 좋은 수단을 사용하여 속성을 간단히 확인할 수 있다는 것을 알아차렸을 것입니다. 두 가지 방법이 있습니다.

 // the native `hasOwnProperty` method var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); } // the `in` operator var quux = function(tag, atr) { return atr in document.createElement(tag); } qux('audio', 'preload'); // returns true quux('audio', 'preload'); // returns true

우리는 탈선...

이러한 상황은 드물지만 가장 간결하고 성능이 뛰어나고 부울이 아닌, 정의되지 않은 값에서 true !! . 이것이 어리석게도 해결되기를 바랍니다.

Benny

!! 오른쪽에 있는 값을 동등한 부울 값으로 변환합니다. (가난한 사람의 "타입 캐스팅" 방식을 생각해 보세요). 그 의도 는 일반적으로 코드가 변수에 있는 값이 무엇인지 신경 쓰지 않고 "진실" 값 이 무엇인지 독자에게 전달하는 것입니다.

Crescent Fresh

!!foo 는 단항 not 연산자를 두 번 적용하고 단항 더하기 +foo 를 사용하여 숫자로 캐스팅하고 빈 문자열 ''+foo 를 연결하여 문자열로 캐스팅하는 것과 유사한 부울 유형으로 캐스팅하는 데 사용됩니다.

이러한 해킹 대신 기본 유형에 해당하는 생성자 함수( new 를 사용 하지 않고 )를 사용하여 명시적으로 값을 캐스팅할 수도 있습니다.

 Boolean(foo) === !!foo Number(foo) === +foo String(foo) === ''+foo

Christoph

작업의 절반을 수행하는 많은 답변. 예, !!X 는 "X[부울로 표시됨]의 진실성"으로 읽을 수 있습니다. 하지만 !! 실제로 말해서, 단일 변수가 참인지 거짓인지(또는 많은 변수가 있더라도) 알아내는 데 그렇게 중요하지 않습니다. !!myVar === true 그냥 동일 myVar . !!X 를 "실제" 부울과 비교하는 것은 실제로 유용하지 않습니다.

얻을 수 있는 유일한 것 !! 반복 가능하고 표준화된(JSLint 친화적인) 방식으로 서로에 대해 여러 변수의 진실성을 확인하는 기능입니다.

단순히 캐스팅 :(

그건...

• 0 === false 는 false 입니다.
• !!0 === false 은 true 입니다.

위의 내용은 그다지 유용하지 않습니다. if (!0) if (!!0 === false) 와 동일한 결과를 제공합니다. 변수를 부울로 캐스팅한 다음 "진정한" 부울과 비교하는 좋은 경우를 생각할 수 없습니다.

JSLint의 지시 에서 "== 및 !="를 참조하십시오(참고: Crockford는 사이트를 약간 옮기고 있습니다. 해당 링크는 어느 시점에서 죽을 수 있음). 이유는 다음과 같습니다.

== 및 != 연산자는 비교하기 전에 유형 강제 변환을 수행합니다. 이것은 ' \t\r\n' == 0이 참이 되기 때문에 좋지 않습니다. 이것은 유형 오류를 마스킹할 수 있습니다. JSLint는 ==가 올바르게 사용되고 있는지 확실하게 결정할 수 없으므로 == 및 !=를 전혀 사용하지 않고 항상 보다 안정적인 === 및 !== 연산자를 대신 사용하는 것이 가장 좋습니다.

값이 참인지 거짓인지에만 관심이 있다면 짧은 형식을 사용하세요. 대신에
(foo != 0)

그냥 말해
(foo)

그리고 대신
(foo == 0)

말하다
(!foo)

부울을 숫자와 비교할 때 부울이 숫자로 캐스팅되는 직관적이지 않은 경우 true 1 false 는 0 이 경우, !! 정신적으로 유용할 수 있습니다. 다시 말하지만, 이것은 비 부울을 하드 유형 부울과 비교하는 경우입니다. 이는 심각한 실수입니다. if (-1) 이 여전히 여기로 가는 길이라면.

 ╔═══════════════════════════════════════╦═══════════════════╦═══════════╗ ║ Original ║ Equivalent ║ Result ║ ╠═══════════════════════════════════════╬═══════════════════╬═══════════╣ ║ if (-1 == true) console.log("spam") ║ if (-1 == 1) ║ undefined ║ ║ if (-1 == false) console.log("spam") ║ if (-1 == 0) ║ undefined ║ ║ Order doesn't matter... ║ ║ ║ ║ if (true == -1) console.log("spam") ║ if (1 == -1) ║ undefined ║ ╠═══════════════════════════════════════╬═══════════════════╬═══════════╣ ║ if (!!-1 == true) console.log("spam") ║ if (true == true) ║ spam ║ better ╠═══════════════════════════════════════╬═══════════════════╬═══════════╣ ║ if (-1) console.log("spam") ║ if (truthy) ║ spam ║ still best ╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

그리고 당신의 엔진에 따라 상황이 더 이상해질 수 있습니다. 예를 들어 WScript가 상을 받았습니다.

 function test() { return (1 === 1); } WScript.echo(test());

일부 역사적인 Windows jive 때문에 메시지 상자에 -1이 출력됩니다! cmd.exe 프롬프트에서 시도하고 확인하십시오! 그러나 WScript.echo(-1 == test()) 여전히 0 또는 WScript의 false 합니다. 멀리 봐. 끔찍하다.

진정성을 비교해보세요 :)

그러나 동일한 참/거짓을 확인해야 하는 두 개의 값이 있는 경우에는 어떻게 됩니까?

myVar1 = 0; 그리고 myVar2 = undefined; .

• myVar1 === myVar2 는 0 === undefined 으며 분명히 거짓입니다.
• !!myVar1 === !!myVar2 는 !!0 === !!undefined 이고 true입니다! 같은 진정성! (이 경우 둘 다 "거짓의 진실성을 갖는다".)

따라서 "부울 캐스팅 변수"를 실제로 사용해야 하는 유일한 장소는 두 변수가 동일한 사실성을 갖고 있는지 확인하는 상황이 있는 경우입니다. 그렇죠? 즉 사용 !! 두 바르가 truthy 모두 또는 falsy (여부) 모두 있는지 확인해야하는 경우, 그 같음 (여부) truthiness의입니다.

나는 그것에 대한 훌륭하고 인위적이지 않은 사용 사례를 생각할 수 없습니다. 양식에 "연결된" 필드가 있습니까?

 if (!!customerInput.spouseName !== !!customerInput.spouseAge ) { errorObjects.spouse = "Please either enter a valid name AND age " + "for your spouse or leave all spouse fields blank."; }

따라서 이제 배우자 이름과 나이 모두에 대해 진실이 있거나 둘 다 거짓이 있으면 계속할 수 있습니다. 그렇지 않으면 값이 있는 필드가 하나만 있고(또는 매우 일찍 정렬된 결혼) errorObjects 컬렉션에 추가 오류를 생성해야 합니다.

이 경우에도 !! 정말 불필요합니다. 하나 ! 부울로 캐스팅하기에 충분했으며 평등을 확인하고 있습니다.

---

2017년 10월 24일 편집, 2월 19일 6:

명시적 부울 값을 기대하는 타사 라이브러리

재미있는 사례가 있습니다... !! 타사 라이브러리가 명시적 부울 값을 예상할 때 유용할 수 있습니다.

반응

예를 들어, JSX(React)에서 False는 단순한 거짓에 대해 트리거되지 않는 특별한 의미를 갖습니다. JSX에서 다음과 같은 것을 반환하려고 시도한 경우 messageCount int가 필요합니다 ...

{messageCount && <div>You have messages!</div>}

... 메시지가 없을 때 0 렌더링하는 것을 보고 놀랄 수 있습니다. JSX가 렌더링되지 않도록 하려면 명시적으로 false를 반환해야 합니다. 위의 명령문은 0 반환하며, JSX는 정상적으로 렌더링됩니다. Count: {messageCount} 가 없다고 말할 수는 없습니다.

• 0 을 !!0 으로 강제하는 bangbang과 관련이 있습니다. 이는 false .
  {!!messageCount && <div>You have messages!</div>}

• JSX' 문서는 더 명시적이며 자체 주석 코드를 작성하고 비교를 사용하여 강제로 부울을 사용하도록 제안합니다.
  {messageCount > 0 && <div>You have messages!</div>}

• 나는 삼항법으로 거짓을 다루는 것이 더 편하다.
  {messageCount ? <div>You have messages!</div> : false}

타이프스크립트

Typescript에서도 마찬가지입니다. 부울을 반환하는 함수가 있는 경우(또는 부울 변수에 값을 할당하는 경우) [보통] 부울 값을 반환/할당할 수 없습니다. 강력한 형식의 부울이어야 합니다. 즉, myObject 가 강력한 형식 이면 return !myObject; 부울을 반환하는 함수에 대해 작동하지만 return myObject; 하지 않습니다. return !!myObject 를 반환해야 합니다(또는 다른 방법으로 적절한 부울 값으로 캐스트).

Typescript의 예외? myObject 가 any 인 경우 JavaScript의 Wild West로 돌아가서 !! , 반환 유형이 부울인 경우에도 마찬가지입니다.

이것들은 JavaScript 고유의 것이 아니라 JSX 및 Typescript 규약임을 명심하십시오.

0 이 표시되면 느슨한 거짓 관리를 생각하십시오.

ruffin

그것은 단지 논리적 NOT 연산자이며, 두 번 - 무언가를 부울로 변환하는 데 사용됩니다. 예:

 true === !!10 false === !!0

Greg

접미사를 부울 값으로 변환합니다.

Paul McMillan

이중 작업이 not 첫 번째 ! 값을 부울로 변환하고 논리값을 반전시킵니다. 두 번째 ! 논리값을 역으로 반전시킵니다.

Bill the Lizard

인 것 같습니다 !! 연산자는 이중 부정을 초래합니다.

 var foo = "Hello World!"; !foo // Result: false !!foo // Result: true

Steve Harrison

Boolean() 캐스팅 함수의 동작을 시뮬레이션합니다. 첫 번째 NOT 은 주어진 피연산자에 관계없이 부울 값을 반환합니다. 두 번째 NOT 해당 Boolean 값을 true 부울 값을 제공합니다. 최종 결과는 값에 Boolean() 함수를 사용하는 것과 같습니다.

Prakash

! 본질적으로 "enable"의 값을 반대 부울로 유형 변환하는 "boolean not"입니다. 두번째 ! 이 값을 뒤집습니다. 그래서 !!enable ", 사용하지 없습니다"라는 뜻을 당신에게 가치 제공 enable 부울합니다.

Annika Backstrom

!! NOT 연산을 두 번 함께 사용하고 있습니다 ! 값을 boolean 로 변환하고 역으로 바꾸십시오. 방법을 볼 수 있는 간단한 예가 있습니다 !! 공장:

처음에는 다음과 같은 장소가 있습니다.

 var zero = 0;

그런 다음 !0 하면 boolean 으로 변환되고 true 로 평가됩니다. 0 은 falsy 이므로 반대 값을 얻고 boolean으로 변환하여 true 평가됩니다.

 !zero; //true

그러나 우리는 값의 역 부울 버전 을 원하지 않으므로 결과를 얻기 위해 다시 역전할 수 있습니다! 그것이 우리가 다른 것을 사용하는 이유입니다 ! .

기본적으로 !! 우리가 얻는 값이 거짓, 진실 또는 문자열 등이 아닌 부울인지 확인하십시오.

Boolean 함수를 사용하는 것과 같지만 값을 부울로 변환하는 쉽고 짧은 방법은 다음과 같습니다.

 var zero = 0; !!zero; //false

Alireza

언급할 가치가 있다고 생각합니다. 논리적 AND/OR와 결합된 조건은 부울 값을 반환하지 않지만 &&의 경우 마지막 성공 또는 첫 번째 실패 및 ||의 경우 첫 번째 성공 또는 마지막 실패를 반환합니다. 조건 체인의.

 res = (1 && 2); // res is 2 res = (true && alert) // res is function alert() res = ('foo' || alert) // res is 'foo'

조건을 참 부울 리터럴로 변환하기 위해 이중 부정을 사용할 수 있습니다.

 res = !!(1 && 2); // res is true res = !!(true && alert) // res is true res = !!('foo' || alert) // res is true

GreQ

운영자가 한 명이 아니라 두 명입니다. 다음과 동일하며 값을 부울로 캐스팅하는 빠른 방법입니다.

 val.enabled = !(!enable);

Justin Johnson

!! 구성은 모든 JavaScript 표현식을 해당 부울로 변환하는 간단한 방법입니다.

예: !!"he shot me down" === true 및 !!0 === false .

Navin Rauniyar

나는 이것이 사람들이 재정의하는 C++의 잔재라고 생각합니다! 연산자이지만 bool 연산자는 아닙니다.

따라서 이 경우 부정적인(또는 긍정적인) 답변을 얻으려면 먼저 ! 연산자는 부울을 가져오지만 긍정적인 경우를 확인하려면 !!를 사용합니다.

Darren Clark

이 질문에 대한 답은 꽤 많이 나왔는데, 최대한 간략하게 답을 추가해서 !!의 의미를 만들어 보겠습니다. 최대한 이해하기 쉽습니다.

자바스크립트에는 "truthy" 및 "falsey" 값이 있기 때문에 조사되는 값이나 표현식이 실제로 true 또는 false 가 아니더라도 다른 표현식에서 평가될 때 true 또는 false 조건이 되는 표현식이 있습니다.

예를 들어:

 if (document.getElementById('myElement')) { // code block }

해당 요소가 실제로 존재하는 경우 표현식은 true로 평가되고 코드 블록이 실행됩니다.

하지만:

 if (document.getElementById('myElement') == true) { // code block }

... 참 조건이 되지 않으며 요소가 존재하더라도 코드 블록이 실행되지 않습니다.

왜요? document.getElementById() if() 문에서 true로 평가되는 "truthy" 표현식 true 의 실제 부울 값이 아니기 때문입니다.

이 경우 이중 "not"은 매우 간단합니다. 그것은 단순히 두 개의 연속 not 입니다.

첫 번째 것은 단순히 참 또는 거짓 값을 "반전"하여 실제 부울 유형을 생성하고 두 번째 것은 다시 원래 상태로 "반전"하지만 이제는 실제 부울 값입니다. 그렇게하면 일관성이 있습니다.

 if (!!document.getElementById('myElement')) {}

그리고

 if (!!document.getElementById('myElement') == true) {}

예상대로 둘 다 true를 반환합니다.

Kirby L. Wallace

if 및 while 문과 ? 연산자는 진리값을 사용하여 실행할 코드 분기를 결정합니다. 예를 들어 0과 NaN 숫자와 빈 문자열은 거짓이지만 다른 숫자와 문자열은 참입니다. 개체는 true이지만 정의되지 않은 값과 null 은 모두 false입니다.

이중 부정 연산자 !! 값의 진리값을 계산합니다. 실제로 두 개의 연산자입니다. 여기서 !!x 는 !(!x) 의미하며 다음과 같이 동작합니다.

• x 가 false 값이면 !x 는 true 이고 !!x 는 false 입니다.
• x 가 참 값이면 !x 는 false 이고 !!x 는 true 입니다.

if , while 또는 ? )의 최상위 수준에서 사용되는 !! 오퍼레이터는 행동이 금지되어 있습니다. 예를 들어 if (x) 와 if (!!x) 는 같은 의미입니다.

실용적인 용도

그러나 몇 가지 실용적인 용도가 있습니다.

한 가지 용도는 개체를 진리값으로 손실 압축하여 코드가 큰 개체에 대한 참조를 보유하지 않고 활성 상태로 유지하는 것입니다. 할당 !!some_big_object 대신 변수에 some_big_object 가비지 컬렉터를 위해 그것을 갈 수 있습니다. null 과 같은 false 값 또는 브라우저 기능 감지와 같은 정의되지 않은 값을 생성하는 경우에 유용합니다.

C 에 대한 답변에서 언급한 또 다른 용도 !! operator 는 일반적인 오타 및 인쇄 진단을 찾는 "보풀" 도구를 사용합니다. 예를 들어, C와 JavaScript 모두에서 부울 연산에 대한 몇 가지 일반적인 오타는 출력이 부울과 같지 않은 다른 동작을 생성합니다.

• if (a = b) b 의 진리값을 사용하는 경우 ; if (a == b) 는 동등 비교입니다.
• if (a & b) 가 비트 AND이면; if (a && b) 가 논리적 AND인 경우. 2 & 5 는 0 (거짓 값)입니다. 2 && 5 는 참입니다.

!! operator는 당신이 작성한 내용이 의미하는 바임을 Lint 도구를 안심시켜줍니다. 이 작업을 수행한 다음 결과의 진실 값을 취합니다.

세 번째 용도는 논리적 XOR 및 논리적 XNOR를 생성하는 것입니다. C와 JavaScript 모두에서 a && b 는 논리적 AND(양쪽이 모두 참이면 참)를 a & b 는 비트 AND를 수행합니다. a || b 는 논리적 OR(적어도 하나가 참이면 참)을 수행하고 a | b 는 비트 OR을 수행합니다. a ^ b 와 같은 비트별 XOR(배타적 OR)이 있지만 논리 XOR에 대한 기본 제공 연산자는 없습니다(정확히 한 쪽이 참이면 참). 예를 들어 사용자가 정확히 두 필드 중 하나에 텍스트를 입력하도록 허용할 수 있습니다. 당신이 할 수 있는 일은 각각을 진리값으로 변환하고 비교하는 것입니다: !!x !== !!y .

Damian Yerrick

이중 부울 부정. 값이 정의되지 않았는지 확인하는 데 자주 사용됩니다.

Sergey Ilinsky

!!x Boolean(x) 약어입니다.

첫 번째 강타는 js 엔진이 Boolean(x) 을 실행하도록 강제하지만 값을 반전시키는 부작용도 있습니다. 따라서 두 번째 강타는 부작용을 취소합니다.

Greg Gum

모든 것을 부울로 만듭니다.

예를 들어:

 console.log(undefined); // -> undefined console.log(!undefined); // -> true console.log(!!undefined); // -> false console.log('abc'); // -> abc console.log(!'abc'); // -> false console.log(!!'abc'); // -> true console.log(0 === false); // -> undefined console.log(!0 === false); // -> false console.log(!!0 === false); // -> true

appiconhero.co

여기에 많은 훌륭한 답변이 있지만 여기까지 읽었다면 '이해하는' 데 도움이 되었습니다. Chrome(등)에서 콘솔을 열고 다음을 입력합니다.

 !(!(1)) !(!(0)) !(!('truthy')) !(!(null)) !(!('')) !(!(undefined)) !(!(new Object()) !(!({})) woo = 'hoo' !(!(woo)) ...etc, etc, until the light goes on ;)

당연히 !!someThing을 입력하는 것과 같지만 괄호를 추가하면 이해하기 쉬워집니다.

Warren Davis

나는 단지 그것을 추가하고 싶었습니다

 if(variableThing){ // do something }

와 같다

 if(!!variableThing){ // do something }

그러나 이것은 무언가가 정의되지 않은 경우 문제가 될 수 있습니다.

 // a === undefined, b is an empty object (eg. b.asdf === undefined) var a, b = {}; // Both of these give error a.foo is not defined etc. // you'd see the same behavior for !!a.foo and !!b.foo.bar a.foo b.foo.bar // This works -- these return undefined a && a.foo b.foo && b.foo.bar b && b.foo && b.foo.bar

여기서 트릭은 && 의 체인이 찾은 첫 번째 잘못된 값을 반환한다는 것입니다. 이것은 if 문 등에 제공될 수 있습니다. 따라서 b.foo가 정의되지 않은 경우 정의되지 않은 값을 반환하고 b.foo.bar 문이며 오류가 발생하지 않습니다.

위는 undefined를 반환하지만 빈 문자열, false, null, 0, undefined가 있는 경우 해당 값이 반환되고 체인에서 해당 값이 발생하는 즉시 -- [] 및 {} 가 모두 "사실"이며 아래로 계속 진행합니다. 소위 "&& 체인"을 오른쪽 다음 값으로 이동합니다.

PS 같은 일을 하는 또 다른 방법은 (b || {}).foo . 왜냐하면 b가 정의되지 않은 경우 b || {} 는 {} 이고 "undefined"(오류 발생) 내의 값에 액세스하려고 시도하는 대신 빈 객체(오류 없음)의 값에 액세스하게 됩니다. 따라서 (b || {}).foo 는 b && b.foo 와 ((b || {}).foo || {}).bar b && b.foo && b.foo.bar 와 동일합니다. b && b.foo && b.foo.bar .바 .

Ryan Taylor

이 모든 훌륭한 답변을 본 후에 나는 사용하는 또 다른 이유를 추가하고 싶습니다 !! . 현재 저는 Angular 2-4(TypeScript)에서 작업 중이며 사용자가 인증되지 않은 경우 false 인증되지 않은 경우 토큰 문자열은 null 또는 "" 입니다. 다음 코드 블록을 사용하여 이 작업을 수행할 수 있습니다.

 public isAuthenticated(): boolean { return !!this.getToken(); }

Wouter Vanherck

다음은 Angular js의 코드입니다.

 var requestAnimationFrame = $window.requestAnimationFrame || $window.webkitRequestAnimationFrame || $window.mozRequestAnimationFrame; var rafSupported = !!requestAnimationFrame;

그들의 의도는 requestAnimationFrame의 기능 가용성에 따라 rafSupported를 true 또는 false로 설정하는 것입니다.

일반적으로 다음과 같은 방법으로 확인하여 달성할 수 있습니다.

 if(typeof requestAnimationFrame === 'function') rafSupported =true; else rafSupported =false;

짧은 방법을 사용할 수 있습니다 !!

 rafSupported = !!requestAnimationFrame ;

따라서 requestAnimationFrame에 함수가 할당된 경우 !requestAnimationFrame은 false가 되고 하나 더 ! 그것의 사실 일 것입니다

requestAnimationFrame이 정의되지 않은 상태로 할당된 경우 !requestAnimationFrame은 true이고 하나 더 ! 그것의 거짓 것입니다

JeevanReddy Avanaganti

변수의 부울 값을 반환합니다.

대신 Boolean 클래스를 사용할 수 있습니다.

(코드 설명을 읽으십시오)

 var X = "test"; // X value is "test" as a String value var booleanX = !!X // booleanX is `true` as a Boolean value beacuse non-empty strings evaluates as `true` in boolean var whatIsXValueInBoolean = Boolean(X) // whatIsXValueInBoolean is `true` again console.log(Boolean(X) === !!X) // writes `true`

즉, Boolean(X) = !!X 사용 중입니다.

아래에서 코드 스니펫을 확인하세요 ↓

 let a = 0 console.log("a: ", a) // writes a value in its kind console.log("!a: ", !a) // writes '0 is NOT true in boolean' value as boolean - So that's true.In boolean 0 means false and 1 means true. console.log("!!a: ", !!a) // writes 0 value in boolean. 0 means false. console.log("Boolean(a): ", Boolean(a)) // equals to `!!a` console.log("\n") // newline a = 1 console.log("a: ", a) console.log("!a: ", !a) console.log("!!a: ", !!a) // writes 1 value in boolean console.log("\n") // newline a = "" console.log("a: ", a) console.log("!a: ", !a) // writes '"" is NOT true in boolean' value as boolean - So that's true.In boolean empty strings, null and undefined values mean false and if there is a string it means true. console.log("!!a: ", !!a) // writes "" value in boolean console.log("\n") // newline a = "test" console.log("a: ", a) // writes a value in its kind console.log("!a: ", !a) console.log("!!a: ", !!a) // writes "test" value in boolean console.log("Boolean(a) === !!a: ", Boolean(a) === !!a) // writes true

efkan

논리 연산자가 아닌 연산자를 두 번 사용
!true = false 및 !!true = true 의미합니다.

Abhay Dixit

JavaScript 에서 true 및 false 에 대한 평가를 기억하는 것이 중요합니다.

• "값"이 있는 모든 것은 true (즉, truthy )입니다. 예를 들면 다음과 같습니다.

  • 101 ,
  • 3.1415 ,
  • -11 ,
  • "Lucky Brain" ,
  • new Object()
  • 그리고 물론 true

• "값"이 없는 모든 것은 false (즉, falsy )입니다. 예를 들면 다음과 같습니다.

  • 0 ,
  • -0 ,
  • "" (빈 문자열),
  • undefined ,
  • null ,
  • NaN (숫자가 아님)
  • 그리고 물론, false

"논리적 아님 " 연산자( ! )를 적용하면 피연산자를 평가하여 boolean 로 변환한 다음 무효화합니다. 두 번 적용하면 부정이 무효화되어 효과적으로 값을 boolean 변환합니다. 연산자를 적용하지 않으면 정확한 값이 정기적으로 할당됩니다. 예:

 var value = 23; // number var valueAsNegatedBoolean = !value; // boolean falsy (because 23 is truthy) var valueAsBoolean = !!value; // boolean truthy var copyOfValue = value; // number 23 var value2 = 0; var value2AsNegatedBoolean = !value2; // boolean truthy (because 0 is falsy) var value2AsBoolean = !!value2; // boolean falsy var copyOfValue2 = value2; // number 0

• value2 = value; boolean 이 아니더라도 정확한 객체 value 할당하므로 value2 boolean 이 되는 것은 아닙니다.
• value2 = !!value; value 의 이중 부정의 결과로 보장된 boolean 을 할당하고 다음과 동일하지만 훨씬 짧고 읽기 쉽습니다.

 if (value) { value2 = true; } else { value2 = false; }

Lucky Brain

출처 : 여기를 클릭하세요

출처 : http:www.stackoverflow.com/questions/784929/what-is-the-not-not-operator-in-javascript