Различные методы определения общей функции в JavaScript

В этой статье подробно описываются различные методы определения общей функции в JavaScript и передаются вам для вашей ссылки. Конкретный анализ заключается в следующем:

Во -первых, давайте посмотрим на четыре наиболее распространенные определения функций в JavaScript:

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

 var multiply = новая функция ('x', 'y', 'return x * y;');

Объявление функции, этот метод также является наиболее распространенным:

 функция умножьте (x, y) {return x * y;}

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

 var multiply = function (x, y) {return x * y;}

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

 var multiply = function multi (x, y) {return x * y;}

Во -первых, давайте сравним имя функции и прямые отношения между переменной функции, присвоенной функции. Это действительно немного ... быть более интуитивно понятным, из примера 4 прямо сейчас, это взаимосвязь между функциональной переменной, и имя функции Multi:

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

 умножить = function (x, y) {return x + y;}

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

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

 var foo = function bar () {alert ('hello');} foo (); // Подсказка «Hello» String Bar (); // выполнить ошибку, полоса не определена

И, очевидно, балка здесь действительно является именем функции, но ее действительно нельзя назвать внешне. В настоящее время, безусловно, будет детская обувь, спрашивая, почему этот пример все еще выглядит так хорошо себя в себе, как пример 4, почему бы не использовать метод примера 2? Хороший вопрос, позвольте мне разбить его медленно.

Продолжая примером 4, мы можем видеть, что имя функции (мульти) и переменная функции (умножна), не одинаковы, но на самом деле они вообще не имеют никаких отношений, поэтому нет необходимости поддерживать последовательность. Говоря об этом, я думаю, что вышеупомянутые четыре примера должны быть уменьшены до 3, а пример 2 и пример 4 должны быть по существу последовательными. Что, не верите? Хе -хе, я должен держать это в тишине ~ Продолжайте читать ~~

Мы обнаружили, что по сравнению с примером 2 и примером 4 только меньше переменных функции VAR, в то время как по сравнению с примером 3 только имя этой функции. С точки зрения явления, сущность примера 2 и примера 4 одинакова, и доказательства следующие:

 функция foo () {} alert (foo); // подсказывает имя функции, содержащее «foo» var bar = foo; alert (bar); // подсказывает имя функции по -прежнему содержит только «foo» и не имеет отношения с баром

Это действительно железный Это способ написать приведенный выше код, аналогичный примеру 2 в сочетании с кодами в примере 4? Правильно, это то, что я только что сказал, что они должны быть по существу одинаковыми. Однако при определении функции в случае 2 двигатель JS помог нам что -то сделать, например, объявление функции с помощью имени функции, и тихо определение переменной, также называемой умножением, а затем присвоение ее этой переменной, два точно одинаковых имена. Мы думали, что при использовании имени функции умножению мы на самом деле использовали умножную переменную функции, поэтому, честно говоря, мы были головокружительными, я также был головокружительным ~, когда мы позвонили, мы на самом деле называли переменную функции, и имя функции не могло вызвать функцию извне, поэтому у меня был вышеуказанный вывод.

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

 foo (); // наконечник foofunction foo () {alert ('foo');} bar (); // приятель, это действительно отличается от вышеизложенного, так что не показывайтесь. Разве это не ошибка? Парень с приглашения не определена var bar = function () {alert ('bar');}

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

 function foo () {var hi = 'hello'; // return function () {// alert (hi); //}; возврат функции ('return hi;');} foo () (); // для эффекта выполнения, пожалуйста, запустите и посмотрите самостоятельно

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

Другой момент заключается в том, что люди часто говорят, что функции, объявленные в режиме конструктора, неэффективны. Почему это? Сегодня я узнал из документа, что функции, объявленные другими тремя способами, будут анализироваться только один раз. Фактически, они существуют в закрытии, но это связано только с цепочкой объемов, и корпус функции будет проанализирован только один раз. Но метод конструктора заключается в том, что каждый раз, когда выполняется функция, ее тело функции будет проанализировано один раз. Мы можем думать, что функция, объявленная таким образом, является объектом, который хранит параметры и корпус функции. Каждый раз, когда он выполняется, он должен быть проанализирован один раз, а параметры и корпус функции будут выполняться, что неизбежно будет неэффективным. Не знаете, как провести конкретный эксперимент?

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

Когда это становится частью выражения, это как пример 3 и пример 4.

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

 var x = 0; // исходный элемент if (x == 0) {// Исходный элемент x = 10; // не исходный элемент, потому что он вложен в функцию оператора if boo () {} // не исходный элемент, потому что она вложена в функцию оператора if} foo () {// Исходный элемент var y = 20; // BAR FUNCTION FUNCTION ELEMPT () {} // Исходный элемент while (y == 10) {// Функция источника элемента blah () {} // не исходный элемент, потому что он вложен в оператор WHINE Y ++; // не исходный элемент, потому что он вложен в оператор while}}

Я примерно понял концепцию элементов источника. Я продолжу объявление о функции, которую я только что упомянул. Пожалуйста, смотрите:

 // Функция функции Функции foo () {} // Функция Expression (function bar () {}) // Функция выражения x = function hello () {} if (x) {// function expression function world () {}} // Функция функции функции a () {// Функция функции b () {} if (0) {// Функция Функции C () {)}}}}}}

Наконец, позвольте мне поговорить о моем собственном понимании. Причиной различения объявления функции и нефункционального объявления состоит в том, что, на мой взгляд, определение функции метода объявления функции будет объявлено заранее, когда его выполняет двигатель JS. То есть, как мы только что сказали выше, его можно использовать до определения функции. На самом деле, двигатель разбора проанализировал его, прежде чем мы его используем. Тем не менее, нефункциональный декларатив, подобный объявлению функции экспрессии, двигатель диапазона JS будет только определять переменную, объявленную VAR. В настоящее время значение переменной не определена, и реальное назначение этой переменной находится в фактическом месте кода. Следовательно, вышеупомянутые ошибки не являются неопределенными. Фактическая переменная была определена, но она еще не была назначена. Двигатель диапазона JS не знает, что это функция.

Я считаю, что описание в этой статье имеет определенную справочную ценность для дизайна веб -программирования JavaScript.