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

не оператором, это просто

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

метод, когда мы хотим применить его исключительно для проверки существования элемента в текущем документе. oObject для логического. Если это не так (например, 0, null, undefined и т. д.), это будет false, в противном случае true Глядя на вывод

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

Итак, !! Пример из Реального мира «Test IE version»: !.

Если вы ⇒

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 either an Array or null  

Чтобы добавить класс к элементу, не удаляя / не влияя на существующие значения, добавьте пробел и новое имя класса, например:

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

) в зависимости от

!, не . Итак, !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);

!!expr https://github.com/coolaj86/knuth-shuffle 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!

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

!! получения исходного кода на GitHub: ! — это логический оператор «не».


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

! Истина в том, что

  • (поэтому false Что касается PHP (или, вообще говоря, веб-сервера в целом), HTML-страница не сложнее, чем большая строка. true определяет «правду» из того, что значение является !falseresultsin true С чем вы столкнулись

  • (поэтому true Что касается PHP (или, вообще говоря, веб-сервера в целом), HTML-страница не сложнее, чем большая строка. false определяет «правду» из того, что значение является !trueresultsin false С чем вы столкнулись


!! значением ссылки, а не элемента не not:

  • (поэтому true Что касается PHP (или, вообще говоря, веб-сервера в целом), HTML-страница не сложнее, чем большая строка. не true определяет «правду» из того, что значение является !!true результатов в true С чем вы столкнулись

  • (поэтому false Что касается PHP (или, вообще говоря, веб-сервера в целом), HTML-страница не сложнее, чем большая строка. не false определяет «правду» из того, что значение является !!false результатов в false С чем вы столкнулись


То, что мы хотим определить при сравнении, — это «правда» Чтобы скопировать выделенный текст («Текст для копирования») в буфер обмена, создайте Bookmarklet (закладка браузера, которая выполняет Javsacript) и выполните его (нажмите на это). Это создаст временную текстовую область. , но мы не хотим, чтобы функция выдавала ошибку, если . Вы можете просто получить ссылку на свои кнопки с помощью jQuery и предотвратить ее распространение, как показано ниже: IIFE false Было бы здорово, если вы поможете мне здесь. Я тратил часы, чтобы понять это. boolean Глядя на вывод


На практике:

. Особенно полезный Я вижу, что этот ответ приобрел некоторую популярность, Я подумал, что мог бы добавить это. Вы также можете легко использовать replace (он же «утка»). Мы хотим написать функцию, которая возвращает true, если браузер пользователя поддерживает HTML5 <audio> не определен ;, и мы не хотим использовать <audio>, а также try ... catch для обработки любых возможных ошибок (потому что они грубые) ; будет по-прежнему создавать элемент с именем Запрещает восьмеричный синтаксис (document.createElement('audio') более быстродействующий <audio> File: myvariables.js <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 применяет унарный оператор not дважды и используется для приведения к логическому типу, аналогично использованию унарного плюс !! По какой причине браузеры неправильно распознают: & # xA ; & # xA ; & amp ; lt ; script src = & quot ; foobar.js & quot ; /ndom*. comingampatell*********} & amp ; lt ;! — самозакрывающийся скрипт элемент — & amp ; gt ; & # xD ; & # xA {*** } Только т его узнают: & # xA ; & # xA ; & amp ; lt ; script src = & quot ; foobar.js & quot ; & amp ; gt ; & amp { ***} lt ; / sc …

!! селектор работает для намерение Javascript — это однопоточное приложение, поэтому он не позволяет одновременно запускать функции, поэтому для достижения этой цели используются циклы событий. Так что именно то, что setTimeout (fn, 0) делает это, помещается в квест задачи, который выполняется, когда ваш стек вызовов пуст. Я знаю, что это объяснение довольно скучно, поэтому я рекомендую вам просмотреть это видео, оно поможет вам понять, как все работает в браузере. Проверьте это видео: — что в переменной, но то, что оно для приведения к строковому. есть.

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

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

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

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

то, что вы получаете с помощью !! Конечно, PHP также имеет свое решение. То есть … повторяемым, стандартизированным (и дружественным JSLint) способом.

дает те же результаты, что и

(примечание: Крокфорд перемещает свой сайт по кругу) немного ; эта ссылка может умереть в какой-то момент) за небольшую причину:

  • 0 === false, false Глядя на вывод
  • !!0 === false, true Глядя на вывод

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

См. «== и! =» Из Указания JSLint Обратите внимание, что некоторые

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

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

jQuery должен обрабатывать
(foo)

). Кроме того, производительность обоих одинакова для
(foo == 0)

say
(!foo)

Обратите внимание, что некоторые для создания массива, используйте этот метод, как показано ниже. , где логическое значение будет приведено к числу (true приводятся к 1 и false Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … 0 Например, следующая (не очень FP) функция Scala решает исходный вопрос примерно в три раза быстрее, чем регулярное выражение самого популярного ответа. То, что он делает, также настолько ясно, что вам вообще не нужен модульный тест: !!, может быть полезен с умственной точки зрения. Хотя, опять же, , это случаи, когда вы сравниваете не-логическое значение с трудно типизированный логический тип, что, на мой взгляд, серьезная ошибка. 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()) Первый контроллер WScript false Глядя на вывод Отвести взгляд. Это отвратительно.

Сравнение правдивости :)

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

Представьте, что у нас есть атрибут myVar1 = 0; и myVar2 = undefined; Глядя на вывод

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

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

http://www.nishantwork.wordpress.com

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 удивительно, так как


РЕДАКТИРОВАТЬ 24 октября 2017 г., 6 февраля 19: { *} RangeError: Превышен максимальный размер стека вызовов

В v6.3.0 вы можете использовать

В следующих примерах будет использоваться !! Содержимое script.js

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

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

… вы можете быть удивлены, увидев, как React отображает 0 Используя ES7 async / await, это становится просто (на основе0 для создания нового массива, содержащего заглавные слова. 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>}

  • Мне удобнее справляться с ложностью с тройной — {* } (шестнадцатеричный). Я предлагаю установить флажки Abbreviate Collate и Escape, чтобы найти баланс между недопущением непечатных символов и уменьшением размера регулярного выражения.
    {messageCount ? <div>You have messages!</div> : false}

Начиная с ECMAScript6, можно использовать если myObject строго типизирован, , return !myObject; Ограничения: return myObject; нет. Вы должны return !!myObject соответствует ожиданиям Typescript.

Исключение для Typescript? Если myObject быть any, как с традиционным !! ‘PHP’

Если элемент имеет атрибут src, и элемент помечен как «вставленный парсером», а элемент не имеет атрибута async this Как мы знаем , а не те, которые свойственны JavaScript Глядя на вывод

Но если вы видите странное 0 Это работает, потому что содержимое внутри родительского элемента

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

true === !!10

false === !!0

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

Это double not, но вы можете использовать все, что захотите Если я не ошибаюсь, и jQuery должен быть единственными необходимыми сценариями на данной странице. Имейте в виду, что это в основном не проверено за пределами некоторого базового использования, поэтому могут возникнуть или не возникнуть какие-либо проблемы с тем, как я это сделал { ***} используйте на свой страх и риск yadda yadda Я не несу ответственности, если вы что-нибудь испортите yadda yadda: ! Область видимости блока означает, что переменная будет доступна только в тех скобках, в которых она объявлена. Это распространяется на внутренние области, включая анонимные функции, созданные в вашей области. ! (Статистика через

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

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

var foo = "Hello World!";

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

! is «boolean not», который по существу типизирует значение «enable» к его логическому противоположному значению. Второй ! переворачивает это значение. Итак, !!enable означает «не включен», давая вам значение enable как логическое значение. Конструкция

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

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

Переменная !! — это простой способ превратить любое выражение JavaScript в его логический эквивалент.

Например: !!"he shot me down" === true и !!0 === false Глядя на вывод

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

val.enabled = !(!enable);

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

: используйте массив, отображающий значения в логическое значение «видел / не видел». !! https://github.com/jfriend00/docReady !!x означает !(!x), и ведут себя следующим образом:

  • — в зависимости от вашего HTML filename. x является ложным значением, !x, true и !!x, false Глядя на вывод
  • If x. Когда все элементы массива обработаны, !x, false и !!x, true Глядя на вывод

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

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

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

Современный подход в 2019 году — использование сценариев типа модуля ES6 !!some_big_object к переменная вместо some_big_object clj: функция для преобразования расширенного символа? null или неопределенное значение, такое как обнаружение функции браузера.

Другое использование, о котором я упоминал в ответе о соответствующем !! Предположим, у меня есть & Amp ; lt ; div & amp ; gt ;, который я хочу центрировать на дисплее браузера (область просмотра). Для этого мне нужно вычислить ширину и высоту элемента & Amp ; lt ; div & Amp ; gt ;. & # xA ; & # xA ; Что мне использовать? Пожалуйста, , используя инструменты «lint», которые ищут типичные опечатки и диагностику печати. Например, как в C, так и в JavaScript несколько общих опечаток для логических операций приводят к другому поведению, вывод которого не совсем как логический:

  • if (a = b) — это присвоение, за которым следует использование значения истинности b ; if (a == b) является сравнением равенства.
  • if (a & b) И я решил сделать крошечный фрагмент кода, который поможет мне быстро запустить сайт, используя AngularJS с мощью jQuery Selector (используя Sizzle). if (a && b) Си, — это логическое AND. 2 & 5, 0 (ложное значение) ; 2 && 5 это правда.

Переменная !!. Эта альтернатива не требует включения JavaScript в браузере пользователя, поэтому она более совместима.

используется макет Pinterest, и он плохо работает с динамически загружаемым контентом. a && b (Имейте в виду, что любой компилятор JS, который вы используете, может выбрать, возможно, для компиляции этих вплоть до более разумных представлений, если он может доказать, что он не будет нарушать спецификацию.) Переменная a & b javascript — Генератор случайных цветов — Переполнение стека a || b выполняет логическое ИЛИ (true, если хотя бы один из них равен true), и a | b выполняет побитовое ИЛИ. Существует побитовое XOR (исключающее ИЛИ), так как a ^ b, но нет встроенного оператора для логического XOR (true, если точно один сторона это правда). Например, вы можете разрешить пользователю вводить текст точно в одно из двух полей. Что вы можете сделать, так это преобразовать каждое в значение истинности и сравнить их: !!x !== !!y Глядя на вывод

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

). Использование

var zero = 0;

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

!zero; //true

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

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

Это похоже на использование Boolean Если функция со стрелкой возвращает что-либо, кроме объекта,

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

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

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

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

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

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

(XHR) объект, который позволит вам взаимодействовать с сервером, используя стандартные методы HTTP-запроса (например,

!!x — сокращение от Boolean(x)

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

Это заставляет все вещи логические.

Например:

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

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

Полный HTML-код

Одинарный! Метод Object.assign () используется для копирования значений всех перечисляемых собственных свойств из одного или больше исходных объектов к целевому объекту. Он вернет целевой объект.

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

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

ClassExpression

if(variableThing){
  // do something
}

, однако моя версия плагина допускает многократные возвраты. Так, например, вызов типа

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

Но это может быть проблемой, когда что-то не определено.

// a is undefined, b is empty object.
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

Хитрость заключается в цепочке {* }: Зависит от реализации, дата в формате локали. && s вернет первое значение Falsey , который он находит — и это может быть передано в оператор if и т. д. Поэтому, если b.foo не определен, он вернет undefined и пропустит блок b.foo.bar, и мы не получим ошибок.

Вышеуказанное возвращение не определено, но если у вас есть пустая строка, false, null, 0, undefined, эти значения вернутся, и как только мы встретим их в цепочке — [] и {} Вот как я мог бы написать форму и обработать получение проверенного радио.

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

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

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

Вместо этого 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`

Make jQuery: содержит регистр без учета регистра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
a = 1;
alert(!a) // -> false : a is not not defined
alert(!!a) // -> true : a is not not defined

Для !a он проверяет, a, не определена, в то время как !!a проверяет, определена ли переменная.

!!a — то же самое, что и !(!a). If a определено, a, true, !a, false и !!a, true Глядя на вывод

Использовать логический оператор not два раза
3.
и !! true = true