Что это!! (не) оператор в JavaScript?

Я видел код, который, как представляется, использует оператор, который я не распознаю в виде двух восклицательных знаков, например: !!. Может кто-нибудь, пожалуйста, скажите мне, что делает этот оператор?

Контекст, в котором я видел это, был

this.vertical = vertical !== undefined ? !!vertical : this.vertical;
2455
задан 24 апр. '09 в 11:13
источник поделиться
33 ответов
  • 1
  • 2

Подтверждает oObject значение boolean. Если он был ложным (например, 0, null, undefined и т.д.), Он будет false, в противном случае true.

!oObject  //Inverted boolean
!!oObject //Non inverted boolean so true boolean representation

Итак, !! не является оператором, это просто оператор ! дважды.

Пример реального мира "Версия тестового IE":

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

Если вы ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns null  

но если вы ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false
2193
ответ дан 24 апр. '09 в 11:18
источник

Это ужасно неясный способ сделать преобразование типа.

! НЕ. Итак, !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);
755
ответ дан 10 сент. '09 в 20:28
источник

!!expr возвращает логическое значение (true или false) в зависимости от правдоподобия выражения. Это имеет смысл при использовании в небулевых типах. Рассмотрим эти примеры, особенно третий пример и далее:

          !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 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 is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!
393
ответ дан 15 мая '12 в 12:06
источник

Brew некоторый чай:

!! не является оператором. Это двойное использование ! - это логический оператор "не".


Теоретически:

! определяет истинность того, что не является значением:

  • Истина заключается в том, что false не true (поэтому результаты !false в true)

  • Истина заключается в том, что true не false (что почему !true результаты в false)


!! определяет "истину" того, чего нет:

  • Истина заключается в том, что true не является true (поэтому !!true приводит к true)

  • Истина заключается в том, что false не является false (поэтому !!false приводит к false)


То, что мы хотим определить при сравнении, - это "правда" о значении ссылки, а не значение самой ссылки. Существует прецедент, где нам может понадобиться знать правду о значении, даже если мы ожидаем, что значение будет false (или falsey), или если мы ожидаем, что значение не будет typeof boolean.


На практике:

Рассмотрим краткую функцию, которая обнаруживает функциональные возможности (и в этом случае совместимость с платформой) с помощью динамического ввода (он же "утка" ). Мы хотим написать функцию, которая возвращает true, если браузер пользователя поддерживает элемент HTML5 <audio>, но мы не хотим, чтобы функция выдавала ошибку, если <audio> - undefined; и мы не хотим использовать 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 из небулевого значения, возможно undefined, действительно, используют !!. Надеюсь, это смехотворно очистит его.

135
ответ дан 23 февр. '13 в 2:45
источник

!! преобразует значение справа от него в эквивалентное булево значение. (Подумайте, что у него плохой способ "литья" ). Его намерение, как правило, донести до читателя, что код не заботится о том, какое значение находится в переменной, но что это "true" value.

89
ответ дан 10 сент. '09 в 20:26
источник

!!foo дважды применяет оператор унарного оператора и используется для приведения к логическому типу, аналогичного использованию унарного плюса +foo, для приведения в число и объединения пустой строки ''+foo для перевода в строку.

Вместо этих хаков вы также можете использовать функции-конструкторы, соответствующие примитивным типам (без использования new) для явного значения значений, т.е.

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo
61
ответ дан 11 сент. '09 в 0:15
источник

Так много ответов выполняют половину работы. Да, !!X можно прочитать как "правду X (представленную как логическое)". Но !!, по сути, не так важен для выяснения того, является ли одна переменная (или даже если многие переменные) правдивыми или ложными. !!myVar === true совпадает с просто myVar. Сравнение !!X с "реальным" булевым не очень полезно.

То, что вы получаете с помощью !!, - это возможность проверить правдоподобие нескольких переменных друг против друга в повторяемом, стандартизованном (и удобном для JSL) способе.

Простое литье: (

То есть...

  • 0 === false - false.
  • !!0 === false - true.

Вышеприведенное не очень полезно. if (!0) дает те же результаты, что и if (!!0 === false). Я не могу думать о хорошем случае для приведения переменной в boolean, а затем сравнения с "истинным" логическим.

См. "== и! =" из направления 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, который выведет -1 в окне сообщения! Попробуйте в командной строке cmd.exe и посмотрите! Но WScript.echo(-1 == test()) по-прежнему дает вам 0 или WScript false. Осмотрите. Это отвратительно.

Сравнение правдоподобия:)

Но что, если у меня есть два значения, мне нужно проверить равную правду/фальсификацию?

Предположим, что myVar1 = 0; и myVar2 = undefined;.

  • myVar1 === myVar2 0 === undefined и, очевидно, неверно.
  • !!myVar1 === !!myVar2 есть !!0 === !!undefined и верно! Та же правдивость! (В этом случае обе "имеют правдоподобие ложности".)

Итак, единственное место, где вам нужно было бы использовать "логические переменные", было бы, если бы у вас была ситуация, когда вы проверяете, имеют ли обе переменные одинаковые права, верно? То есть используйте !!, если вам нужно убедиться, что два vars являются правдивыми или ложными (или нет), то есть равными (или нет) правдой.

Я не могу придумать отличный, непринужденный случай использования для этого. Возможно, у вас есть "связанные" поля в форме?

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.


EDIT 24 Окт 2017:

Сторонние библиотеки, которые ожидают явные логические значения

Здесь интересный случай... !! может быть полезен, когда сторонние библиотеки ожидают явные булевские значения.

Например, False в JSX (React) имеет особое значение, которое не срабатывает при простой ложности. Если вы попытались вернуть что-то вроде следующего в вашем JSX, ожидая int в messageCount...

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

... вы можете быть удивлены, увидев, что React сделает a 0, когда у вас есть нулевые сообщения. Вы должны явно вернуть false для JSX не для рендеринга. Вышеприведенный оператор возвращает 0, который JSX счастливо отображает, как и должно быть. Он не может сказать, что у вас не было Count: {messageCount && <div>Get your count to zero!</div>} (или что-то менее надуманное).

  • Одно исправление включает в себя bangbang, который принуждает 0 к !!0, который равен false:
    {!!messageCount && <div>You have messages!</div>}

  • Документы JSX предлагают вам быть более явными, писать самокомментирующий код и использовать сравнение для принудительной булевой обработки. {messageCount > 0 && <div>You have messages!</div>}

  • Мне удобнее манипулировать фальшивкой с тройной -
    {messageCount ? <div>You have messages!</div> : false}

Имейте в виду, что это соглашение JSX, а не одно свойство JavaScript.

Но если вы видите странный 0 в вашем обработанном JSX, подумайте о свободном управлении фальшивкой.

52
ответ дан 29 апр. '15 в 21:14
источник

Это просто логический оператор NOT, дважды - он используется для преобразования чего-то в boolean, например:

true === !!10

false === !!0
47
ответ дан 24 апр. '09 в 11:18
источник

Он преобразует суффикс в булево значение.

29
ответ дан 10 сент. '09 в 20:27
источник

Это двойная операция not. Первый ! преобразует значение в boolean и инвертирует его логическое значение. Второй ! инвертирует возвращаемое логическое значение.

23
ответ дан 10 сент. '09 в 20:28
источник

Он моделирует поведение функции Boolean() casting. Первый NOT возвращает логическое значение независимо от того, какой операнд ему задан. Второй NOT отрицает значение Boolean, и поэтому дает true логическое значение переменной. Конечный результат такой же, как при использовании функции Boolean() для значения.

21
ответ дан 23 марта '11 в 14:53
источник

Кажется, что оператор !! приводит к двойному отрицанию.

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true
20
ответ дан 24 апр. '09 в 11:20
источник

! "boolean not", который, по существу, выводит значение "enable" в его логическую противоположность. Второй! переворачивает это значение. Таким образом, !!enable означает "не включить", что дает значение enable как логическое.

17
ответ дан 10 сент. '09 в 20:29
источник

Я думаю, стоит упомянуть, что условие, объединенное с логическим И/ИЛИ, не будет возвращать логическое значение, но последний успех или первый сбой в случае && а также первый успех или последний провал в случае || цепи условий.

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
16
ответ дан 25 мая '16 в 13:18
источник

Конструкция !! - это простой способ превратить любое выражение JavaScript в его булевский эквивалент.

Например: !!"he shot me down" === true и !!0 === false.

13
ответ дан 09 апр. '14 в 7:29
источник

Это не один оператор, это два. Это эквивалентно следующему и является быстрым способом приведения значения в значение boolean.

val.enabled = !(!enable);
11
ответ дан 11 сент. '09 в 0:19
источник

Я подозреваю, что это осталось от С++, где люди переопределяют! оператора, но не оператора bool.

Итак, чтобы получить отрицательный (или положительный) ответ, в этом случае вам сначала нужно будет использовать! оператор, чтобы получить логическое значение, но если вы хотите проверить положительный случай, используйте!!.

9
ответ дан 24 апр. '09 в 11:33
источник

Операторы if и while и оператор ? используют значения истинности, чтобы определить, какую ветвь кода запускать. Например, номера нулей и NaN и пустая строка являются ложными, но другие числа и строки являются истинными. Объекты истинны, но значение undefined и null являются ложными.

Оператор двойного отрицания !! вычисляет значение истинности значения. Это фактически два оператора, где !!x означает !(!x) и ведет себя следующим образом:

  • Если x является ложным значением, !x - true, а !!x - false.
  • Если x - истинное значение, !x - false, а !!x - true.

При использовании на верхнем уровне булевого контекста (if, while или ?) оператор !! поведенчески не работает. Например, if (x) и if (!!x) означают одно и то же.

Практическое использование

Однако он имеет несколько практических применений.

Одно использование заключается в том, чтобы с легкостью сжать объект до его значения истинности, чтобы ваш код не содержал ссылку на большой объект и сохранял его. Присвоение переменной !!some_big_object вместо some_big_object позволяет перейти к сборщику мусора. Это полезно для случаев, которые создают либо объект, либо ложное значение, такое как null или значение undefined, например обнаружение функции браузера.

Другое использование, о котором я упомянул в ответе о C-соответствующем операторе !!, - это инструменты "lint", которые ищут общие опечатки и диагностику печати. Например, как в C, так и в JavaScript несколько общих опечаток для булевых операций производят другие поведения, выход которых не совсем как Boolean:

  • if (a = b) - это присвоение, за которым следует использование значения истины b; if (a == b) - сравнение равенства.
  • if (a & b) является поразрядным И; if (a && b) является логическим И. 2 & 5 - 0 (ложное значение); 2 && 5 истинно.

Оператор !! заверяет инструмент lint, что то, что вы написали, означает то, что вы имели в виду: выполните эту операцию, затем возьмите истинное значение результата.

Третье использование - создание логического XOR и логического XNOR. В C и JavaScript a && b выполняет логическое И (true, если обе стороны истинны), а a & b выполняет побитовое И. a || b выполняет логическое ИЛИ (true, если хотя бы один из них истинно), а a | b выполняет побитовое ИЛИ. Там побитовое XOR (исключающее ИЛИ) как a ^ b, но нет встроенного оператора для логического XOR (true, если точно одна сторона является истиной). Например, вы можете разрешить пользователю вводить текст только в одном из двух полей. Что вы можете сделать, так это преобразовать их в значение истины и сравнить их: !!x !== !!y.

8
ответ дан 06 марта '16 в 17:46
источник

Двойное булево отрицание. Часто используется для проверки значения undefined.

7
ответ дан 02 дек. '10 в 23:21
источник

!!x является сокращением для Boolean(x)

Первый удар заставляет js-двигатель запускать Boolean(x), но также имеет побочный эффект инвертирования значения. Таким образом, второй удар отменяет побочный эффект.

7
ответ дан 04 дек. '15 в 15:50
источник

Тонны замечательных ответов здесь, но если вы зачитали это далеко, это помогло мне "получить". Откройте консоль в Chrome (и т.д.) И начните вводить:

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

Естественно, это все равно, что просто набирать!! someThing, но добавленные скобки могут помочь сделать его более понятным.

7
ответ дан 24 апр. '14 в 16:05
источник

!! он использует NOT операцию дважды вместе ! преобразовать значение в boolean и перевернуть его, вот простой пример, чтобы увидеть, как !! работает:

Сначала у вас есть:

var zero = 0;

Тогда вы делаете !0, он будет преобразован в boolean и будет оценен как true, потому что 0 является falsy, поэтому вы получаете обратное значение и преобразовываете в логическое значение, поэтому оно получает значение true.

!zero; //true

но нам не нужна обратная логическая версия значения, поэтому мы можем отменить ее снова, чтобы получить наш результат! Вот почему мы используем другое ! ,

В принципе, !! убедитесь, что значение, которое мы получаем, является логическим, а не фальшивым, правдивым или строковым и т.д....

Таким образом, это похоже на использование функции Boolean в javascript, но простой и более короткий способ преобразования значения в boolean:

var zero = 0;
!!zero; //false
5
ответ дан 24 июня '17 в 7:16
источник

вот фрагмент кода из angular js

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

 var rafSupported = !!requestAnimationFrame;

их намерение состоит в том, чтобы установить rafSupported в true или false на основе доступности функции в requestAnimationFrame

это может быть достигнуто путем проверки следующим образом:

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

можно использовать короткий путь!!

rafSupported = !!requestAnimationFrame ;

поэтому, если requestAnimationFrame была назначена функция  тогда ! requestAnimationFrame будет ложным и еще одним! из этого было бы верно

если requestAnimationFrame был оценен undefined, тогда ! requestAnimationFrame будет правдой и еще одним! из этого будет ложь

4
ответ дан 04 марта '15 в 11:25
источник

Некоторые операторы в JavaScript выполняют неявные преобразования типов и иногда используется для преобразования типов.

Унарный оператор ! преобразует свой операнд в булев и отрицает его.

Этот факт приводит к следующей идиоме, которую вы можете увидеть в своем исходном коде:

!!x // Same as Boolean(x). Note double exclamation mark
3
ответ дан 01 июля '15 в 10:29
источник

Возвращает логическое значение переменной.

Вместо этого может использоваться класс 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 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 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
3
ответ дан 11 июля '17 в 10:03
источник

!! аналогичен использованию логического конструктора или, скорее, больше похож на Логическая функция.

console.log(Boolean(null)); // Preffered over the Boolean object

console.log(new Boolean(null).valueOf()); // Not recommended for coverting non-boolean values

console.log(!!null); // A hacky way to omit calling the Boolean function, but essentially does the same thing. 


// The context you saw earlier (your example)
var vertical;

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical; 
        // Let break it down: If vertical is strictly not undefined, return the boolean value of vertical and set it to this.vertical. If not, don't set a value for this.vertical (just ignore it and set it back to what it was before; in this case, nothing).   

        return this.vertical;
}

console.log( "\n---------------------" )

// vertical is currently undefined

console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = 12.5; // set vertical to 12.5, a truthy value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be true anyway
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = -0; // set vertical to -0, a falsey value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be false either way
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

Значения Falsey в javascript принуждение к ложным и правным значениям принуждение к true. Ложные и правдивые значения также могут использоваться в операциях if и по существу "сопоставляются" с их соответствующим логическим значением. Тем не менее, вы, вероятно, не обнаружите, что вам нужно часто использовать правильные логические значения, так как они в основном отличаются выходом (возвращаемые значения).

Хотя это может показаться похожим на кастинг, реалистично это, скорее всего, простое совпадение и не "построено" или специально создано для и как булевский литье. Поэтому не будем называть это.


Почему и как это работает

Чтобы быть кратким, он выглядит примерно так: ! ( !null ). Если null falsey, значит !null будет true. Тогда !true будет false, и он по существу будет инвертироваться назад к тому, что было раньше, за исключением этого времени как правильного логического значения (или даже наоборот с правными значениями, например {} или 1).


Возвращаясь к вашему примеру

В целом контекст, который вы видели, просто настраивает this.vertical в зависимости от того, определена или нет vertical, и если да; он будет установлен на результирующее логическое значение вертикали, иначе оно не изменится. Другими словами, если vertical определено; this.vertical будет иметь значение boolean, в противном случае оно останется неизменным. Я думаю, это само по себе является примером того, как вы будете использовать !!, и что он делает.


Пример вертикального ввода-вывода

Запустите этот пример и закрутите вертикальное значение на входе. Посмотрите, к чему приводит результат, чтобы вы могли полностью понять свой контекстный код. На вкладке введите любое допустимое значение javascript. Не забудьте включить цитаты, если вы тестируете строку. Не слишком сильно напоминайте CSS и HTML-код, просто запустите этот фрагмент и поиграйте с ним. Однако, возможно, вам стоит взглянуть на javascript-код, не связанный с DOM (использование конструктора Example и вертикальной переменной).

var vertical = document.getElementById("vertical");
var p = document.getElementById("result");

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical;   

        return this.vertical;
}

document.getElementById("run").onclick = function()
{

  p.innerHTML = !!( new Example(eval(vertical.value)).vertical );
  
}
input
{
  text-align: center;
  width: 5em;
} 

button 
{
  margin: 15.5px;
  width: 14em;
  height: 3.4em;
  color: blue;
}

var 
{
  color: purple;
}

p {
  margin: 15px;
}

span.comment {
  color: brown;
}
<!--Vertical I/O Example-->
<h4>Vertical Example</h4>
<code id="code"><var class="var">var</var> vertical = <input type="text" id="vertical" maxlength="9" />; <span class="comment">// enter any valid javascript value</span></code>
<br />
<button id="run">Run</button>
<p id="result">...</p>
2
ответ дан 17 апр. '17 в 17:47
источник
a = 1;
alert(!a) // -> false : a is not not defined
alert(!!a) // -> true : a is not not defined

Для !a он проверяет, существует ли a НЕ, а !!a проверяет, определена ли переменная.

!!a совпадает с !(!a). Если a определено, a - true, !a - false, а !!a - true.

2
ответ дан 28 июня '14 в 6:35
источник

Это заставляет все вещи булевать.

Например:

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
2
ответ дан 25 июля '18 в 6:52
источник

После просмотра всех этих замечательных ответов я хотел бы добавить еще одну причину использования !!. Currenty Я работаю в Angular 2-4 (TypeScript), и я хочу вернуть логическое значение false, когда мой пользователь не аутентифицирован. Если он не аутентифицирован, токена-строка будет null или "". Я могу сделать это, используя следующий блок кода:

public isAuthenticated(): boolean {
   return !!this.getToken();
}
2
ответ дан 29 марта '17 в 10:15
источник

Использовать логический неоператор два раза
это означает! true = false
 и!! true = true

2
ответ дан 15 июля '16 в 13:25
источник
  • 1
  • 2

Другие вопросы по меткам или Задайте вопрос