С помощью !! в выражениях JS [дубликат]

Невозможность связывания с соответствующими библиотеками / объектными файлами или компиляция файлов реализации

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

В разделе gcc вы должны указать все объектные файлы, которые должны быть связаны вместе в командной строке, или скомпилировать файлы реализации вместе.

g++ -o test objectFile1.o objectFile2.o -lLibraryName

Здесь libraryName - это просто имя библиотеки, без добавления к платформе. Так, например, в файлах библиотеки Linux обычно называют libfoo.so, но вы должны писать только -lfoo. В Windows этот же файл можно назвать foo.lib, но вы будете использовать тот же аргумент. Возможно, вам придется добавить каталог, в котором эти файлы можно найти, используя -L‹directory›. Обязательно не записывайте пробел после -l или -L.

Для XCode: добавьте пути поиска заголовка пользователя -> добавьте путь поиска библиотеки -> перетащите фактическую ссылку библиотеки в

В MSVS файлы, добавленные в проект, автоматически связывают их объектные файлы, и будет создан файл lib (в общем использовании). Чтобы использовать символы в отдельном проекте, вам нужно будет добавить файлы lib в параметры проекта. Это делается в разделе Linker свойств проекта в Input -> Additional Dependencies. (путь к файлу lib должен быть добавлен в Linker -> General -> Additional Library Directories). При использовании сторонней библиотеки, которая предоставляется с файлом lib, отказ в этом обычно приводит к ошибке.

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

В программировании Windows контрольный знак, который вы не связывали необходимая библиотека состоит в том, что имя неразрешенного символа начинается с __imp_. Посмотрите имя функции в документации, и она должна сказать, какую библиотеку вам нужно использовать. Например, MSDN помещает информацию в поле внизу каждой функции в разделе «Библиотека».

2380
задан mc10 13 August 2013 в 22:20
поделиться

30 ответов

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

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

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

Real World Пример «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 null  

но если вы ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false
2121
ответ дан Uwe Keim 4 September 2018 в 09:07
поделиться

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

2
ответ дан Abhay Dixit 4 September 2018 в 09:07
поделиться

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

Поначалу у вас есть:

var zero = 0;

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

!zero; //true

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

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

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

var zero = 0;
!!zero; //false
5
ответ дан Alireza 4 September 2018 в 09:07
поделиться

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

17
ответ дан Annika Backstrom 4 September 2018 в 09:07
поделиться

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

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


В теории:

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

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

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

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

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


На практике:

Рассмотрим краткую функцию, которая обнаруживает функциональность функциональности (и в этом случае совместимость с платформой) посредством динамического ввода ( aka «утиная печать»). Мы хотим написать функцию, которая возвращает true, если браузер пользователя поддерживает элемент HTML5 <audio>, но мы не хотим, чтобы функция выдавала ошибку, если <audio> не определено; и мы не хотим использовать try ... catch для обработки любых возможных ошибок (потому что они валовые); , а также мы не хотим использовать проверку внутри функции, которая не будет постоянно показывать правду об этой функции (например, document.createElement('audio') все равно будет создавать элемент с именем <audio>, даже если HTML5 <audio> не поддерживается).


Вот три подхода:

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

Каждая функция принимает аргумент для поиска <tag> и attribute для поиска, но каждый из них возвращает разные значения, основанные на том, что определяют сравнения.

Но подождите, есть еще!

Некоторые из вас, вероятно, заметили, что в этом конкретном примере можно просто проверить свойство с помощью немного более совершенного средство проверки того, имеет ли объект, о котором идет речь свойство . Есть два способа сделать это:

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

Мы отвлекаемся ...

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

133
ответ дан Benny Schmidt 4 September 2018 в 09:07
поделиться

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

23
ответ дан Bill the Lizard 4 September 2018 в 09:07
поделиться

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

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

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo
61
ответ дан Christoph 4 September 2018 в 09:07
поделиться

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

88
ответ дан Crescent Fresh 4 September 2018 в 09:07
поделиться

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

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

8
ответ дан Damian Yerrick 4 September 2018 в 09:07
поделиться

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

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

8
ответ дан Darren Clark 4 September 2018 в 09:07
поделиться

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

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

3
ответ дан efkan 4 September 2018 в 09:07
поделиться

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

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

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

!!x // Same as Boolean(x). Note double exclamation mark
3
ответ дан GibboK 4 September 2018 в 09:07
поделиться

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

true === !!10

false === !!0
45
ответ дан Greg 4 September 2018 в 09:07
поделиться

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

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

7
ответ дан Greg0 4 September 2018 в 09:07
поделиться

Я думаю, стоит упомянуть, что условие в сочетании с логическим И / ИЛИ не вернет логическое значение, а последний успех или первый сбой в случае & amp; & 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
15
ответ дан GreQ 4 September 2018 в 09:07
поделиться

здесь находится фрагмент кода из углового 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
ответ дан JeevanReddy Avanaganti 4 September 2018 в 09:07
поделиться

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

val.enabled = !(!enable);
11
ответ дан Justin Johnson 4 September 2018 в 09:07
поделиться

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

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true
739
ответ дан Lightness Races in Orbit 4 September 2018 в 09:07
поделиться

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

29
ответ дан Paul McMillan 4 September 2018 в 09:07
поделиться

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

21
ответ дан Prakash 4 September 2018 в 09:07
поделиться

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

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

То есть ...

  • 0 === false - [

    ]

    f11].

  • !!0 === false is true.

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

См. «== и! =» из направления JSLint (примечание : Crockford немного перемещает свой сайт, эта ссылка может умереть в какой-то момент) для немного о том, почему:

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

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

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

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

скажите (!foo)

Обратите внимание, что есть некоторые неинтуитивные случаи , где булев будет отбрасываться на число (true передается в 1 и false в 0) при сравнении булевых с a номер. В этом случае !! может быть умственно полезным. Хотя, опять же, это случаи, когда вы сравниваете небулевое значение с жестким типизированным логическим выражением, которое является imo серьезной ошибкой. 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 Oct 2017:

Сторонние библиотеки, ожидающие явных булевых значений

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

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

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

... вы можете быть удивлены, увидев, что React render 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 s в вашем обработанном JSX, подумайте об управлении слабым фальшивом.

52
ответ дан ruffin 4 September 2018 в 09:07
поделиться

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

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

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

1
ответ дан Ryan Taylor 4 September 2018 в 09:07
поделиться

!!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!
381
ответ дан Salman A 4 September 2018 в 09:07
поделиться

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

7
ответ дан Sergey Ilinsky 4 September 2018 в 09:07
поделиться
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
ответ дан user3698272 4 September 2018 в 09:07
поделиться

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

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

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

7
ответ дан Warren Davis 4 September 2018 в 09:07
поделиться

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

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

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

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


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

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

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

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

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

Запустите это пример и возиться с вертикальным значением на входе. Посмотрите, к чему приводит результат, чтобы вы могли полностью понять код вашего контекста. На вкладке введите любое допустимое значение 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
ответ дан WEB_UI 4 September 2018 в 09:07
поделиться

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

public isAuthenticated(): boolean {
   return !!this.getToken();
}
2
ответ дан Wouter Vanherck 4 September 2018 в 09:07
поделиться

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

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

13
ответ дан Xufox 4 September 2018 в 09:07
поделиться

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

! - 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);
739
ответ дан Lightness Races in Orbit 4 September 2018 в 09:07
поделиться
Другие вопросы по тегам:

Похожие вопросы: