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

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

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

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

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

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

Так !!что не оператор, это просто !оператор дважды.

Пример из реальной жизни "Test IE version":

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

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

!это НЕ . Так !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возвращает логическое значение ( trueили false) в зависимости от достоверности выражения. Это имеет больше смысла при использовании не-булевых типов. Рассмотрим эти примеры, особенно 3-й пример и далее:

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

Заварите немного чая:

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

В теории:

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

• Правда в том, что falseэто не так true(вот почему и !falseприводит к true)

• Правда в том, что trueэто не так false(вот почему и !trueприводит к false)

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

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

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

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

На практике:

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

Каждая функция принимает аргументы для поиска a <tag>и an 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небулева, возможно, неопределенного значения действительно является использование !!. Надеюсь, это смехотворно проясняет.

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

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

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

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

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

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

Просто кастинг :(

Это...

• 0 === falseесть false.
• !!0 === falseесть true.

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

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

Операторы == и! = Выполняют приведение типов перед сравнением. Это плохо, потому что это заставляет '\ 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и есть правда! Та же самая правдивость! (В этом случае оба «имеют ложную правду».)

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

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

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:

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

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

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

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

... вы можете быть удивлены, увидев, что React рендерит, 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}

То же самое в Typescript: если у вас есть функция, которая возвращает логическое значение (или вы присваиваете значение логической переменной), вы [обычно] не можете вернуть / присвоить логическое значение-y; это должен быть строго типизированный логический тип. Это означает, что если myObjectон строго типизирован , return !myObject;работает для функции, возвращающей логическое значение, но return myObject;не работает. Вы должны return !!myObjectсоответствовать ожиданиям Typescript.

Исключение для Typescript? Если myObjectбыл any, вы вернулись в JavaScript Дикого Запада и может вернуть его без !!, даже если ваш тип возвращаемого значения является логическим.

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

Но если вы видите странные 0s в вашем рендеринге JSX, подумайте о ложном управлении.

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

true === !!10

false === !!0

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

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

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

var foo = "Hello World!";

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

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

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

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

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

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

Во-первых, место у вас есть:

var zero = 0;

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

!zero; //true

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

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

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

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

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

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

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

val.enabled = !(!enable);

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

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

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

Оператор двойного отрицания !!вычисляет истинное значение значения. Это на самом деле два оператора, где !!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или неопределенное значение, например обнаружение функций браузера.

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

Однако:

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

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

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

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

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

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

а также

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

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

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

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

Хитрость здесь в том, что цепочка &&s вернет первое найденное значение Falsey - и это может быть передано в оператор if и т. Д. Поэтому, если b.foo не определен, он вернет undefined и пропуститb.foo.bar оператор, и мы не получим ошибка.

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

PS Еще один способ сделать то же самое (b || {}).foo, потому что, если b не определено, то b || {}будет {}, и вы будете получать доступ к значению в пустом объекте (без ошибок) вместо того, чтобы пытаться получить доступ к значению в пределах «неопределенного» (вызывает ошибку ). Итак, так (b || {}).fooже, как b && b.fooи так ((b || {}).foo || {}).barже, как b && b.foo && b.foo.bar.

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

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

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

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

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

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

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

Используйте логический оператор not два раза,
это значит! True = false
и !! true = 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