javascript вызов - Что делает восклицательный знак перед функцией?




проверка все (10)

!function () {}();

Answers

Хороший момент для использования ! для вызова функции, помеченного в airbnb Руководство JavaScript

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

!function abc(){}()
!function bca(){}();

Будет работать так же, как

!function abc(){}()
;(function bca(){})();

но сохраняет два символа и выглядит неплохо.

И, кстати, любой из операторов + , - , ~ , void имеет одинаковый эффект, с точки зрения вызывающей функции, если вы используете что-то для возврата из этой функции, они будут действовать по-другому.

abcval = !function abc(){return true;}() // abcval equals false
bcaval = +function bca(){return true;}() // bcaval equals 1
zyxval = -function zyx(){return true;}() // zyxval equals -1
xyzval = ~function xyz(){return true;}() // your guess?

но если вы используете шаблоны IIFE для одного файла, разделите код модуля и используйте инструмент concat для оптимизации (что делает однострочное однострочное задание), чем построение

!function abc(/*no returns*/) {}()
+function bca() {/*no returns*/}()

Выполняет безопасное выполнение кода, так же как и самый первый пример кода.

Это вызовет ошибку, вызвавшую ошибку JavaScript. ASI не сможет выполнить свою работу.

!function abc(/*no returns*/) {}()
(function bca() {/*no returns*/})()

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

Это работает:

!function abc(/*no returns*/) {}()
^function bca() {/*no returns*/}()

Это не:

^function abc(/*no returns*/) {}()
!function bca() {/*no returns*/}()

! Символ показывает, что это выражение, вызванное немедленно вызовом.

Восклицательный знак не будет ссылаться только на эту функцию; вы можете положить () в конец:

!function foo() {}()
() has higher precedence than ! and instantly calls the function.
() имеет более высокий приоритет, чем! и мгновенно вызывает функцию.

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

(function(){})();

! позволяет выражению возвращать true. Это связано с тем, что по умолчанию все немедленно вызываемые выражения функции возвращаются undefined, поэтому мы остались! undefined, что верно.


! будет отрицать (наоборот) то, что вы ожидаете в результате, т.е. если у вас есть

var boy = true;
undefined
boy
true
!boy
false

когда вы вызываете boy , ваш результат будет true , но в тот момент, когда вы добавите ! при вызове boy , т. е. !boy , ваш результат будет false . Иными словами, вы имеете в виду NotBoy , но на этот раз это в основном логический результат, как true и false .

Это то же самое, что происходит с !function () {}(); expression, running only function () {}(); сообщит вам об ошибке, но добавляет ! прямо перед вашей function () {}(); выражение, делает его противоположным function () {}(); который должен вернуть вас true . Пример можно увидеть ниже:

function () {}();
SyntaxError: function statement requires a name
!function () {}();
true

Давайте сохраним еще несколько байтов!

(() => {})()

пример:

(() => {return "yeah"})()

И вот что я понял из консоли. Как упоминалось ранее, восклицательный знак возвращает функцию boolean.

Для последнего синтаксиса:

( function my_function() {} )()

Мы можем сделать что-то вроде:

(function add_them(a,b) { return a+b;} )(9,4)

Как одновременное определение функции и вызов.

Редактировать:
Теперь вы спросите, в чем польза '!' определение функции типа. Давайте рассмотрим следующее:

!function a_would_be_function() { alert("Do some junk but inside a function"); }()

вы хотели бы выполнить такую ​​функцию, как выше, но без '!' будет генерировать ошибку. Надеюсь, я поняла.


Синтаксис JavaScript 101. Вот объявление функции :

function foo() {}

Обратите внимание, что нет точки с запятой: это просто объявление функции. Вам понадобится вызов, foo() , чтобы фактически запустить функцию.

Теперь, когда мы добавляем, казалось бы, безобидный восклицательный знак !function foo() {} он превращает его в выражение . Теперь это выражение функции .

! один не вызывает функцию, конечно, но мы можем теперь положить () в конец !function foo() {}() которая имеет более высокий приоритет, чем ! и мгновенно вызывает функцию.

Так что автор делает сохранение байта на выражение функции; более читаемым способом написания будет следующее:

(function(){})();

Наконец ! возвращает выражение true. Это связано с тем, что по умолчанию все возвраты IIFE undefined , что оставляет нас с !undefined что true . Не особенно полезно.


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

Хотя вы можете обойти круглые скобки вызываемой функции, используя функцию BANG (!) Перед функцией, она все равно инвертирует возврат, который может быть не таким, каким вы хотели. Как и в случае с IEFE, он возвращает неопределенные значения , которые при инверсии становятся логическими.

Вместо этого используйте закрывающую скобку и BANG ( ! ), Если это необходимо.

// I'm going to leave the closing () in all examples as invoking the function with just ! and () takes away from what's happening.

(function(){ return false; }());
=> false

!(function(){ return false; }());
=> true

!!(function(){ return false; }());
=> false

!!!(function(){ return false; }());
=> true

Другие операторы, которые работают ...

+(function(){ return false; }());
=> 0

-(function(){ return false; }());
=> -0

~(function(){ return false; }());
=> -1

Комбинированные операторы ...

+!(function(){ return false; }());
=> 1

-!(function(){ return false; }());
=> -1

!+(function(){ return false; }());
=> true

!-(function(){ return false; }());
=> true

~!(function(){ return false; }());
=> -2

~!!(function(){ return false; }());
=> -1

+~(function(){ return false; }());
+> -1

Его еще один способ записи IIFE (выражение, вызываемое сразу же).

Его другой способ письма -

(function( args ) {})()

такой же как

!function ( args ) {}();

Функция:

function () {}

не возвращает ничего (или не определено).

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

function () {}()

но в результате получается SyntaxError .

Использование ! оператор перед тем, как функция заставляет его рассматривать как выражение, поэтому мы можем назвать его:

!function () {}()

Это также вернет логическое значение, противоположное возвращаемому значению функции, в этом случае true , потому что !undefined true . Если вы хотите, чтобы фактическое возвращаемое значение было результатом вызова, попробуйте сделать это следующим образом:

(function () {})()

Википедия о закрытии :

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

Технически, в JavaScript , каждая функция является замыканием . Он всегда имеет доступ к переменным, определенным в окружении.

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

Закрытие часто используется для создания функций с некоторыми скрытыми личными данными (но это не всегда так).

var db = (function() {
    // Create a hidden object, which will hold the data
    // it's inaccessible from the outside.
    var data = {};

    // Make a function, which will provide some access to the data.
    return function(key, val) {
        if (val === undefined) { return data[key] } // Get
        else { return data[key] = val } // Set
    }
    // We are calling the anonymous surrounding function,
    // returning the above inner function, which is a closure.
})();

db('x')    // -> undefined
db('x', 1) // Set x to 1
db('x')    // -> 1
// It's impossible to access the data object itself.
// We are able to get or set individual it.

Эмс

В приведенном выше примере используется анонимная функция, которая была выполнена один раз. Но этого не должно быть. Его можно назвать (например mkdb) и выполнить позже, генерируя функцию базы данных каждый раз при ее вызове. Каждая сгенерированная функция будет иметь свой собственный скрытый объект базы данных. Другой пример использования замыканий - это когда мы не возвращаем функцию, а объект, содержащий несколько функций для разных целей, каждая из которых имеет доступ к тем же данным.





javascript function