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

!! просто оператор НЕ дважды. чистый эффект - просто преобразовать что-либо, чтобы обеспечить логический тип данных. например

!!undefined равно false !!0 ложно !!ноль является ложным !!любой объект верен !!правда правда !!false ложно !0 верно !1 ложно

В принципе, не используйте этот синтаксис. Это отправит людей в Google и, возможно, сюда. Вместо этого напишите описательный код.

Не пишите головокружительный код.

!! не оператор, а просто оператор! оператор дважды

Но с javascript примените !! для преобразования объекта в логическое значение в большинстве случаев является избыточным и подробным, потому что:

Любой объект, значение которого не является неопределенным или нулевым, включая Логический объект, значение которого ложно, принимает значение true при передаче в условный оператор

Пример: if ({}) { console.log("{} is true")} // logs: "{} is true"

Важно помнить оценки для true и false в JavaScript :

• Все, что имеет значение «Value» - это true (а именно правда ), например:

  • 101,
  • 3.1415,
  • -11,
  • "Lucky Brain",
  • new Object()
  • и, конечно же, true

• Все без «значения» - это false (а именно ложь ), например:

  • 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; назначает точный объект value, даже если он не boolean, следовательно, value2 не обязательно будет boolean.
• value2 = !!value; назначает гарантированный boolean как результат двойного отрицания операнда value, и он эквивалентен следующему, но намного короче и читабельнее:

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

const foo = 'bar';
console.log(!!foo); // Boolean: true

! инвертирует (инвертирует) значение И всегда возвращает / производит логическое значение. Итак! 'Bar' вернет false (потому что 'bar' истинно => negated + boolean = false). С дополнительным! оператор, значение снова инвертируется, поэтому false становится истинным.

Чтобы преобразовать переменные JavaScript в логическое значение,

var firstname = "test";
//type of firstname is string
var firstNameNotEmpty = !!firstname;
//type of firstNameNotEmpty is boolean

javascript false для "", 0, undefined и null

javascript истина для числа, отличного от нуля, а не пустых строк, {}, [] и новой даты () Итак,

!!("test") /*is true*/
!!("") /*is false*/

На этот вопрос дан довольно подробный ответ, но я хотел бы добавить ответ, который, я надеюсь, будет максимально упрощен и имеет смысл !! настолько просто, насколько это возможно.

Поскольку javascript имеет так называемые «истинные» и «ложные» значения, существуют выражения, которые при вычислении в других выражениях приведут к истинному или ложному условию, даже если проверяемое значение или выражение на самом деле не true или false.

Например:

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

Если этот элемент действительно существует, выражение будет оценено как истинное, и блок кода будет выполнен.

Однако:

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

... НЕ приведет к истинному состоянию, и блок кода не будет выполнен, даже если элемент действительно существует.

Почему? Поскольку document.getElementById() является «правдивым» выражением, которое будет оцениваться как истинное в этом операторе if(), но это не фактическое логическое значение true.

Двойное «не» в данном случае довольно простое. Это просто два not подряд.

Первый просто «инвертирует» истинное или ложное значение, в результате чего получается фактический логический тип, а затем второй «инвертирует» его обратно в исходное состояние, но теперь в фактическое логическое значение. Таким образом, у вас будет последовательность:

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

и

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

ОБА вернет истину, как и ожидалось.

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

hasMajor(){return this.major}//it return "(users major is)Science" 

но ответ для нас не важен, мы просто хотим проверить, есть ли у него основное или нет, и нам нужно логическое значение (истина или ложь), как мы его получаем:

вот так:

hasMajor(){ return !(!this.major)}

или аналогично

hasMajor(){return !!this.major)}

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

Он заставляет все использовать логическое значение.

Например:

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

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

Вместо этого можно использовать класс 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

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

Сначала место, которое у вас есть:

var zero = 0;

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

!zero; //true

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

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

Это похоже на использование функции Boolean в javascript, но простой и более короткий способ преобразовать значение в логическое значение:

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

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

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's 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

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>

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

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

Я просто хотел добавить, что

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 не определен, он вернет undefined и пропустит оператор b.foo.bar, и мы не получим ошибки.

Вышеупомянутый возврат не определен, но если у вас есть пустая строка, false, null, 0, undefined, эти значения вернутся, и как только мы встретим их в цепочке - [] и {} оба являются «правдивыми» и мы продолжим вниз по так называемой «цепочке &&» к следующему значению справа.

PS Другой способ сделать то же самое - (b || {}).foo, потому что если b не определено, то b || {} будет {}, и вы получите доступ к значению в пустом объекте ( нет ошибки) вместо попытки получить доступ к значению в "undefined" (вызывает ошибку). Итак, (b || {}).foo то же самое, что b && b.foo, а ((b || {}).foo || {}).bar то же самое, что b && b.foo && b.foo.bar.

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

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

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

Операторы if и while и оператор ? используют значения истинности, чтобы определить, какую ветвь кода выполнить. Например, числа 0 и NaN и пустая строка являются ложными, но другие числа и строки верны. Объекты верны, но неопределенное значение и 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, или неопределенное значение, например обнаружение функции браузера.

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

• 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 выполняет логическое И (истинно, если обе стороны верны), а a & b выполняет побитовое И. a || b выполняет логическое ИЛИ (истинно, если хотя бы одно из них истинно), а a | b выполняет побитовое ИЛИ. Существует побитовое XOR (исключающее ИЛИ) как a ^ b, но нет встроенного оператора для логического XOR (истинно, если истинна ровно одна сторона). Например, вы можете разрешить пользователю вводить текст ровно в одно из двух полей. Что вы можете сделать, так это преобразовать каждое в значение истинности и сравнить их: !!x !== !!y.

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

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

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

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

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

!!x // Same as Boolean(x). Note double exclamation mark

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

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

Простое преобразование :(

То есть ...

• 0 === false - это false.
• !!0 === false - это true.

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

См. "== and! =" Из направлений JSLint (примечание: Крокфорд немного перемещает свой сайт; эта ссылка может умереть в какой-то момент), чтобы немного узнать, почему:

Операторы == и! = Перед сравнением выполняют приведение типов. Это плохо, потому что приводит к истинному значению '\ t \ r \ n' == 0. Это может замаскировать типовые ошибки. JSLint не может надежно определить, правильно ли используется ==, поэтому лучше вообще не использовать == и! = И всегда использовать вместо них более надежные операторы === и! ==.

Если вас беспокоит только то, что значение является правдивым или ложным, используйте краткую форму. Вместо
(foo != 0)

просто скажите
(foo)

и вместо
(foo == 0)

сказать
(!foo)

Обратите внимание, что есть некоторые неинтуитивные случаи, когда логическое значение будет приведено к числу (true приведено к 1 и false к 0) при сравнении логического значения с числом. В этом случае !! может быть полезен в умственном отношении. Хотя, опять же, , это случаи, когда вы сравниваете не логическое значение с жестко типизированным логическим, что, я думаю, является серьезной ошибкой.

╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               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
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

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

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

вот фрагмент кода из 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 будет false и еще один! из этого было бы правдой

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

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.

Здесь масса отличных ответов, но если вы дочитали до этого места, это помогло мне «понять». Откройте консоль в Chrome (и т. Д.) И начните вводить:

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

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

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

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

Заварить чай:

!! не оператор. Это двойное использование ! - логического оператора «не».

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

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

• На самом деле false не является true (поэтому !false результаты в true )

• На самом деле true не является false (поэтому !true результаты в false )

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

• На самом деле true не не true (поэтому !!true приводит к true <12577118438>true <12577118438>true <12577118438>true <12577118438>

• На самом деле false не не false (поэтому !!false приводит к false <12475778411>

// 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

// 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

!!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!

Это действительно удобный способ проверить наличие undefined, "undefined", null, "null", ""

if (!!var1 && !!var2 && !!var3 && !!var4 ){
   //... some code here
}

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

​​Двойное логическое отрицание. Часто используется для проверки, не является ли значение неопределенным.

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

val.enabled = !(!enable);

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

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

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

! является логическим «не», которое, по сути, приводит значение «enable» к его логической противоположности. Второй ! переворачивает это значение. Итак, !!enable означает «не включить», что дает вам значение enable как логическое.

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

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

! - это НЕ . Итак, !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);

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

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

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

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

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

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true

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

true === !!10

false === !!0