Оператор Javascript() вызывает функцию

Question

Я использую javascript какое-то время и начинаю понимать, насколько сильно я использую этот язык. Некоторые более продвинутые аспекты этого процесса выходят на свет, такие как замыкания, шаблон модуля и т. Д.

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

как в:

var myFunct = function() { 
    alert("here");   
}(); 

The() в конце будет немедленно вызвать функцию.

Answer 1

Функция - это объект. Использование function_name относится к фактическому объекту функции. И function_name() относится к результату функции. Например:

function foo() { 
    return 2; 
} 

typeof foo() 
= "number" 

typeof foo 
= "function" 

Answer 2

Конструкция() означает «вызов функции». Дело в том, что JavaScript отличается от некоторых других языков тем, что идентификаторы - это не единственное, что вы можете назвать функцией. Так что из С, что-то подобное может выглядеть знакомым:

fnName(); 

Но в JavaScript, любое выражение может оценить к функции, которая означает, что он может быть вызван как вызов функции. Как так:

(function() {/*do something*/})(); 

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

Answer 3

Это просто синтаксис для вызова функции:

function foo() { alert('Purple is a nice colour') } 
foo(); // Invokes the 'foo' function 

Аналогично, так как в функции JavaScript-объекты первого класса, можно сделать следующее:

var foo = function() { alert('I like camels') }; 
foo(); // Invokes the function that the variable 'foo' has a reference to 

Это даже может быть выражено без использования промежуточная переменная (поскольку функция является объектом):

(function() { alert('Ponies are cool') })(); // Creates a function object, then invokes it 

Answer 4

Если() не было в voke функцию, тогда некоторый другой синтаксис должен был бы. Это просто выбор синтаксиса для вызова функции, выбранного для его знакомства со многими более ранними языками. Аргументы, если они есть, входят в круглые скобки.

Трудно понять, как вы могли что-либо сделать в Javascript, не встречая вызовов функций.

Answer 5

Я предполагаю, что вы имеете в виду в anonumous функцию, которая выполняется сразу же (и в соответствии с вашими редактирования, мое предположение было правильным):

(function(){...})(); 

Это работает для любого значения, которое ссылается на функцию, например:

var x = function(){}; 
x(); 

function y(){} 
var z = y; 
z(); 

Или даже функция, которая возвращает функцию ссылки:

function a() { 
    return function(){}; 
} 
a()(); 

Answer 6

Функции Javascript - это объекты первого класса. Они могут храниться, передаваться и возвращаться. Поскольку они являются функциями, их также можно вызвать.

Таким образом, вы можете написать это:

var f = function(message) { 
    window.alert(message); 
} 

f("Hello, world!"); 

Это создает анонимный объект функции и сохраняет его в f. Затем он называет его f().

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

(function(message) { 
    window.alert(message); 
})("Hello, world!"); 

Answer 7

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

Таким образом, давайте сломаем ваше заявление, которое:

var myFunct = function() { 
    alert("here");   
}(); 

Во-первых, необходимо определить функцию, так что давайте «рефакторинг» это так, что часть становится яснее.

var myFunctionDeclaration = function() { 
    alert("here");   
}; 
var myFunct = myFunctionDeclaration(); 

Теперь должно быть проще видеть, что вы вызываете функцию в своем коде.

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

Так в основном ваш код был такой:

var myFunct = (expression that produces function object)(); 
                 ^^ 
                 +--- invoke the function 

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

Например:

var myFunct = function() { 
    alert("here"); 
    return function() { 
     return 10; 
    }; 
}()(); 
^^
| +-- calls the inner function, that was returned when calling the outer 
|  function 
| 
+---- calls the outer function, which returns a new function object 
// myFunct ends up being 10 

Answer 8

Это не так много, что функция в настоящее время вызывается (хотя на практике это), но, что аргументы передается функции и функция оценивается.

В случае самозапуска я признаю, что это запутывает. Но вот прорыв того, что происходит. Скажем, я делаю анонимную функцию, назначенную переменной.

var myFunction1 = function() { 
console.log("function assigned to variable object myFunction1"); 
}; 

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

По существу у нас есть var myFunction1, переписанный global = {myFunction1: (function() {return 1 + 2;})(); }

Мне не нужно указывать функцию в том же шаблоне кодирования, что и для функции, не назначенной переменной, потому что я могу вызвать ее через имя переменной, поскольку переменная является объектом. Это важно, поскольку мы полагаемся на концепцию, что почти все в JS - это объект, который определяется как множество типов объектов (например, функции, имена переменных, логические значения, числа, символы и т. Д.).

function() { 
    console.log("function assigned to variable object myFunction1"); 
}; 

Это не будет выполняться, потому что выражение не назначается как выражение. Теперь он объявляется, потому что вы начали с функции ключевого слова, сообщающей интерпретатору, я объявляю эту функцию. Но вы должны указать имя во всем объявлении функции для ссылки на интерпретатор. So(); когда бежать нечего было уходить. Нет никакого объекта или параметров для оценки, вы не назвали функцию так, чтобы не было ссылки, это просто призрак. Подумайте об этом в виде синтаксиса точек, где вы можете получить доступ к свойствам объекта через объект. свойство

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

(function (a){})(a); 
//Opening the initial parameter which is a function and then internally accessing the function params. 

(1+2); 
//Will evaluate to 
3 
(1+2)(); 
//Will not run because I've not only accessed the param of the expression but I've now told it to evaluate the internal expression in that param and there is none 

(function() { return 1+2; })(); 
//Will run because I've accessed the initial param, which is a function and asked it to execute it's internal expression in the braces return 1+2 

В сущности интерпретатор работает булевым. Вопросы: 1) существует ли параметр? Да 2) Есть ли внутреннее выражение? Нет, потому что это не функция

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

! function() { console.log("This is true and ran the expression" }(); 
//Is it not a function? True 
//Evaluate the expression since it is not a function 

function() { console.log("This will never log because it is not true" }(); 
//Is it a function? False 
//Do not evaluate the expression since it is false 

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

При указании параметров/аргументов функции, которую вы используете().

function myFunction2 (a,b) { sum = a+b; console.log(sum) }; 

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

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

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

Теперь давайте посмотрим на анонимную функцию:

(
    function() { console.log("My anonymous function is not assigned to a variable"); 
    } 
) 
(); 

Что мы сделали здесь? Ну, это просто, по сути, функция wrapped in(), которую мы теперь знаем, имеет право как объявлять, так и вызывать, а затем присваивать значения аргументу. Итак, у нас есть 2 параметра этой функции. Первая - это функция, анонимная, поэтому нет имени, которое мы можем использовать для вызова или вызова этой функции. Затем мы имеем() после словарной функции, которая не содержит параметров (которые вы можете добавить, если захотите).

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

1 + 2 = 3; //This is an expression 
function (b) { b = 1+2; console.log(b) }(); //This is the expression of 1+2 which is 3 and then that value is assigned to b 

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

(функция anonFunction (b) {b = 1 + 2; console.log (b)})(); anonFunction();

В результате получится 3 и anonFunction не определен. Это связано с тем, что эта функция была просто выражением самовыражения, предназначенным только для выражения значения для этого экземпляра. Интерпретатор не регистрирует эту функцию как объект. Для этого вам нужно назначить выражение переменной, которая, в свою очередь, превращает переменную в объект, содержащий выражение anonFunction.

var myDefinedFunction = function (b) { b = 1+2; console.log(b) }; 
myDefinedFunction(); 

Вы заметите, что наружная и конечная скобки удалены. Они не нужны и вызовут ошибку, потому что мы не хотим, чтобы функция была просто самозапускающимся выражением. Мы хотим, чтобы функция была назначена объекту. В реальном мире наиболее эффективным способом является назначение функции с именем. На самом деле они производят одинаковое значение объекта. Как var, так и функция содержат выражение функции:

(b) { b = 1+2; console.log(b) }; 

Основное отличие здесь - обзор и подъем. Давайте сначала обсудим подъем. Перед запуском любого кода все функции поднимаются вверх. Затем любые переменные, которые ссылаются на до их определения, но находятся в коде, подняты, но определенные значения не указаны. Значение присваивается только при обнаружении. Таким образом, создание именованной функции имеет приоритет над любой другой функцией, включая выражения функций, которые не являются анонимными.

myFunExpression; 
myHelloFun(); 
var myFunExpression = function() { console.log("hello") }; 
function myHelloFun() { console.log('Hello from function') } 

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

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

Итак, суммируем это исчерпывающее объяснение. Оператор() является держателем параметра/аргумента и оператором оценки/выполнения, зависящим от шаблона кодирования. Он не просто используется для вызова.

При использовании анонимных функций:

(function (a) { return a; }) (2 + " hello"); 
//The value "2 hello" string is passed for evaluation return the value 

(function (a,b) { return b; }) (2 + " hello", "my b value"); 
//The value "my b value" is passed to the 2nd parameter for evaluation 

(function (a,b) { return b; })(); 
//undefined because the evaluation of return has no passed arguments