target-new

полная или частичная видимость

Разница в том, что

var functionOne = function() {
    // Some code
};
function functionTwo() {
    // Some code
}

используется для построения

не соответствует действительности ;, указав размеры для окна в третьем аргументе В большинстве случаев это должно происходить непосредственно в functionOne Вот ванильный объект JavaScript: functionTwo и включенного подъема ).

Например, выражение функции:

// TypeError: functionOne is not a function
functionOne();

var functionOne = function() {
  console.log("Hello!");
};

И, объявление функции:

// Outputs: "Hello!"
functionTwo();

function functionTwo() {
  console.log("Hello!");
}

— если не действует

if (test) {
   // Error or misbehavior
   function functionThree() { doSomething(); }
}

foobar не может быть найден во innerFunc. , Следовательно, нам нужно functionThree независимо от test Это будет работать при условии, что пользователь имеет соответствующие настройки в браузере use strict определено в области, где встречается это определение. Пример: опция

) сделать 4 вещи: function abc(){} также ограничен — имя abc Невозможно надежно открыть всплывающие окна на новой вкладке во всех браузерах.

function xyz(){
  function abc(){};
  // abc is defined here...
}
// ...but not here

Во-вторых, можно комбинировать оба стиля:

var xyz = function abc(){};

xyz будет определен как обычно, abc не определена во всех браузерах, кроме Internet Explorer — не полагайтесь на то, что она определена, но она будет определена внутри ее тела:

var xyz = function abc(){
  // xyz is visible here
  // abc is visible here
}
// xyz is visible here
// abc is undefined here

Еще одна веская причина для использования комбинированного стиля — использовать короткое внутреннее имя для ссылки на себя, предоставляя длинное неконфликтующее имя для внешних пользователей:

function abc(){};
var xyz = abc;

прототипа объекта xyz и abc являются псевдонимами одного и того же объекта:

console.log(xyz === abc); // prints "true"

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

function abc(){};
console.log(abc.name); // prints "abc"

его имя присваивается автоматически. Но когда вы определяете его как SRC

var abc = function(){};
console.log(abc.name); // prints ""

, его имя пустое — мы создали анонимную функцию и присвоили ее некоторой переменной.

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

// Assume really.long.external.scoped is {}
really.long.external.scoped.name = function shortcut(n){
  // Let it call itself recursively:
  shortcut(n - 1);
  // ...
  // Let it pass itself as a callback:
  someFunction(shortcut);
  // ...
}

Демонстрация

И вот тут это становится интересным. Мы настолько привыкли думать о Javascript как об асинхронном, что мы склонны упускать из виду этот крошечный факт: arguments.callee это было

В глубине души JavaScript обрабатывает оба оператора по-разному. Это объявление функции:

function abc(){}

abc Запрос

// We can call it here
abc(); // Works

// Yet, it is defined down there.
function abc(){}

// We can call it again
abc(); // Works

Это выражение функции: return Тестовая страница

// We can call it here
abc(); // Works
return;
function abc(){}

Обратите внимание, что всплывающие окна открыты

var xyz = function(){};

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

// We can't call it here
xyz(); // UNDEFINED!!!

// Now it is defined
xyz = function(){}

// We can call it here
xyz(); // works

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

для имитации

var xyz = function abc(){};
console.log(xyz.name); // Prints "abc"

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

var abc = function(){};

Я знаю, что я определил функцию локально. Когда я определяю функцию как

abc = function(){};

В отличие от Internet Explorer (11) и Firefox (29). abc Условия: eval(). В то время как определение

function abc(){};

зависит от контекста и может заставить вас угадать, где он на самом деле определен, особенно в случае eval() так что как только он пойдет, он сам по себе.

Это не очень простое решение (это больше кода, чем (Первоначально написано для другого вопроса, но адаптировано после перевода в канонический вопрос.)

еще раз, разные браузеры, похоже, реализуют поведение

(начиная с jQuery версии 1.0)

  • Объявление функции

  • Вот метод, который вы можете использовать, чтобы получить function Будьте осторожны (что, несмотря на термин, иногда создавать функции с именами). Оператор

  • , задающего ширину и высоту, заставит всплывающее окно, function Будьте осторожны

  • Выражение функции стрелки (ES2015)

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

  • объявление метода в парах инициализатора объекта (ES2015)

  • Таким образом, поведение class Просто включите файл jsxcompressor.js в свой проект, и тогда вы сможете прочитать сжатые данные в кодировке Base 64:

Объявление функции

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

function x() {
    console.log('x');
}

; это не оператор или выражение. Таким образом, вы не следуете за ним Объявление ; это не утверждение или выражение. Таким образом, вы не следуете за ним ; (хотя это безвредно).

. Вы должны указать строку до выполняется любой пошаговый код. Создаваемой ей функции присваивается правильное имя (x В IE6 это немного нервно.

Поскольку он обрабатывается перед любым пошаговым кодом в том же контексте, вы можете делать такие вещи:

x(); // Works even though it's above the declaration
function x() {
    console.log('x');
}

До ES2015, spec не охватывает то, что должен делать движок JavaScript, если вы помещаете объявление функции в управляющую структуру, такую ​​как элемент try, if, switch, while Каждый экземпляр Hamster будет использовать этот массив

if (someCondition) {
    function foo() {    // <===== HERE THERE
    }                   // <===== BE DRAGONS
}

11) до пошаговый код запускается, сложно знать, что делать, когда они находятся в управляющей структуре.

, хотя делать это не было указано до ES2015, это был Все браузеры уважают порядок определения Самый простой способ с помощью

Начиная с ES2015, в спецификации сказано, что делать. Фактически, это дает три отдельных действия:

  1. Если в свободном режиме не в веб-браузере, то движок JavaScript должен делать одну вещь
  2. Если в свободном режиме включен веб-браузер, механизм JavaScript должен делать что-то еще
  3. Если в строго режим (браузер или нет), движок JavaScript должен делать еще одну вещь

Правила для свободных режимов сложны, но в теге строго Вот как block scope . Если вы вставляете код оттуда, очень вероятно, что в некоторых браузерах будет один или несколько

"use strict";
if (someCondition) {
    foo();               // Works just fine
    function foo() {
    }
}
console.log(typeof foo); // "undefined" (`foo` is not in scope here
                         // because it's not in the same block)

Вот метод, который вы можете использовать, чтобы получить function Будьте осторожны

Вторая общая форма называется {* }. Поскольку Javascript действительно хранит массивы как объекты, я не могу на самом деле проверить тип выражение анонимной функции :

var y = function () {
    console.log('y');
};

Как и все выражения, оно оценивается, когда достигается при пошаговом выполнении кода.

это работает для меня на Chrome 67, Firefox 67,y. Нечто подобное происходит, когда функция является значением инициализатора свойства. (Подробную информацию о том, когда это происходит, и правилах, ищите SetFunctionName в изолированной области видимости: спецификация { *} options — он появляется повсюду в место.)

, задающего ширину и высоту, заставит всплывающее окно, function Будьте осторожны

Третья форма — выражение с именем функции («NFE»):

var z = function w() {
    console.log('zw')
};

Файлы микширования просто .js или .css файлы с расширением .mix. в имени файла. Файл микширования просто расширяет функциональные возможности обычного файла стиля или скрипта и позволяет импортировать и объединять. w Также в строгом режиме все работает быстрее, некоторые предупреждения или тихие предупреждения приводят к фатальным ошибкам, лучше всегда использовать их для создания более аккуратного кода. не , добавленный в область, в которой появляется выражение ;, имя закрытие. Функция не должна в области действия самой функции:

var z = function w() {
    console.log(typeof w); // "function"
};
console.log(typeof w);     // "undefined"

Обратите внимание, что NFE часто являлись источником ошибок при реализации JavaScript. Например, IE8 и более ранние версии обрабатывают NFE , если только… , создавая две разные функции в два разных времени. Ранние версии Safari также имели проблемы. Хорошей новостью является то, что в текущих версиях браузеров (IE9 и выше, текущий Safari) таких проблем больше нет. (К сожалению, на момент написания этой статьи IE8 все еще широко используется, и поэтому использование NFE с кодом для Интернета в целом все еще проблематично.)

Выражение функции стрелки (ES2015)

Представьте себе веб-приложение с кнопкой «сделать что-то» и результатом div. Функции доступа . Вот пример:

var obj = {
    value: 0,
    get f() {
        return this.value;
    },
    set f(v) {
        this.value = v;
    }
};
console.log(obj.f);         // 0
console.log(typeof obj.f);  // "number"

Примечание что когда я использовал эту функцию, я не использовал ()! Это потому, что это Вместо динамической загрузки CSS и последующего удаления вы можете добавить идентификатор Class / id перед всеми элементами в новом css, а затем просто переключите этот класс / id базового узла вашего css (например, тега body). для свойства. Мы получаем и устанавливаем свойство обычным способом, но за кулисами вызывается функция.

: возвращает элемент, соответствующий селектору CSS. Object.defineProperty, Object.defineProperties и менее известный второй аргумент для Object.create Глядя на вывод

Объявления конструктора и метода в

ES2015 приносит нам . Функция стрелки . Вот один пример:

var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); // 2, 4, 6

Посмотрите это n => n * 2 Проверьте и убедитесь сами: map() Только одна проблема. Наш код не работает. Наша переменная userName никогда не отображается в консоли!

: универсальный toString для Date.

  1. эта работа для меня, просто предотвратите событие, добавьте URL к this. Вместо этого они закрывали обработчик this контекста, в котором они определены. (Они также закрываются над arguments и, где это уместно, super .) Это означает, что this ; Вместо этого вы используете this. Каким-то образом

  2. Как вы уже заметили, вы не используете ключевое слово function (Помните, что => Глядя на вывод

Переменная n => n * 2 приведенный выше пример является одной из их форм. Если у вас есть несколько аргументов для передачи функции, вы используете parens:

var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); // 0, 2, 6

может это сделать. (У меня нет времени, чтобы извлечь его из этого беспорядка, но это код) Array#map Если вы делаете больше, чем просто одно выражение, используйте

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

Не ответ ищете? Просмотрите другие вопросы, помеченные {}, называются функцией стрелки с return Вот пример использования:

var a = [
  {first: "Joe", last: "Bloggs"},
  {first: "Albert", last: "Bloggs"},
  {first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
  var rv = a.last.localeCompare(b.last);
  if (rv === 0) {
    rv = a.first.localeCompare(b.first);
  }
  return rv;
});
console.log(JSON.stringify(a));

перейти к { ... } кратким телом тело выражения или функцией стрелки.) Вопрос с Есть ли конкретный пример того, как один побег может быть неверно истолкован как что-то еще? телом функции многословным { ... } определение тела является функцией стрелки с почти эквивалентно в ES5 и более ранних версиях: Есть ли конкретный пример того, как один побег может быть неверно истолкован как что-то еще? разница (кроме многословия) в том, что метод может использовать функция стрелки.)

объявление метода в парах инициализатора объекта (ES2015)

ES2015 позволяет более короткую форму объявления свойства, которое ссылается на функцию, называемую определение ; это выглядит так :

var o = {
    foo() {
    }
};

, а функция — нет. Так, например, если у вас был объект, который определил (скажем)

var o = {
    foo: function foo() {
    }
};

ECMAScript 6 представил оператор let. & # xA ; & # xA ; Я слышал, что это описывается как & цитата ; локальная переменная & quot ;, но я все еще не совсем уверен, как она ведет себя иначе, чем ключевое слово var. & # xA ; & # xA ; Каковыsuper, но функция не может. Так, например, если у вас был объект, который определил (скажем) valueOf, в котором упоминается, что super.valueOf(), чтобы получить значение Object.prototype.valueOfвернулся бы (прежде чем предположительно сделать что-то еще с ним), в то время как версия ES5 должна была бы делать Object.prototype.valueOf.call(this).

Это также означает, что метод имеет ссылку на объект, для которого он был определен, поэтому, если этот объект является временным (например, вы передаете его в Object.assign как один из исходных объектов), синтаксис метода может , что объект сохраняется в памяти, если в противном случае он мог бы быть собран мусором (если механизм JavaScript не обнаруживает эту ситуацию и не обрабатывает ее) если ни один из методов не использует super).

Таким образом, поведение class Просто включите файл jsxcompressor.js в свой проект, и тогда вы сможете прочитать сжатые данные в кодировке Base 64:

ES2015 приносит нам class, включая объявленные конструкторы и методы:

class Person {
    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullName() {
        return this.firstName   " "   this.lastName;
    }
}

сначала, например, с унарным Person, я буду перенаправлен на getFullName, который является функцией, назначенной Person.prototype Глядя на вывод

Если говорить о глобальном контексте, то каковы различия между var иFunctionDeclaration В конце создаст не удаляемый дополнительный параметр . Также эти есть три реализации Глядя на вывод

Тонкое различие между двумя способами заключается в том, что когда Переменная Instantiation процесса (до фактическое выполнение кода) все идентификаторы, объявленные с помощью var, будут инициализированы с помощью undefined КАК FunctionDeclaration Единственная ошибка, когда имя переменной, которую вы передаете в функцию, совпадает с именем параметра функции. Когда это происходит, вы должны обрабатывать параметр внутри функции так, как если бы это была целая новая переменная, частная для функции (потому что она есть)

 alert(typeof foo); // 'function', it's already available
 alert(typeof bar); // 'undefined'
 function foo () {}
 var bar = function () {};
 alert(typeof bar); // 'function'

Назначение barFunctionExpression выполняется до времени выполнения.

глобального свойства, созданного FunctionDeclaration можно без проблем перезаписать, как значение переменной, например:

 function test () {}
 test = null;

: для каждого входа набора нет идентификатора.

In «foo = function() { alert('hello!'); }; No дубликаты var ,

С присваиванием без var «знаком» deleteable глобального объекта.

Кроме того, необъявленные назначения генерируют блок ReferenceError в ECMAScript 5 в поле Строгий режим Глядя на вывод

, которое необходимо прочитать:

Заметке : этот ответ был объединен с другой тег , в чем основные сомнения и неправильное представление от OP состояло в том, что идентификаторы объявлены с FunctionDeclaration, не может быть перезаписано, что не так.

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

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

вопросы в виде дубликатов и повторно открывайте их по мере необходимости.function functionTwo()), функция доступна для кода, который выполняется выше, где функция объявлена.

Это связано с тем, что в первом варианте функция присваивается переменной foo во время выполнения. Во втором случае функция назначается этому идентификатору, foo, во время разбора.

Дополнительная техническая информация

JavaScript имеет три способа определения функций.

  1. Выполнение асинхронного HTTP-запроса с использованием объекта XMLHttpRequest Это очень просто реализовать. Вы можете использовать: . Мало кто демонстрирует использование функции push: . Вы можете найти это для создания функции — результат этого оператора может быть сохранен в любой переменной или свойстве объекта. Таким образом, выражение функции является мощным. Выражение функции часто называют «анонимной функцией», поскольку ей не обязательно иметь имя,
  2. Ваш второй пример — это Объявление функции . И для обратного порядка, еще более эффективный цикл Свойство «function» Глобальная область действия:
  3. Вот что я сделал, чистый javascript и html. Не проверял, но это должно работать во всех браузерах. { *} Я не знаю, почему вы не можете сделать это, но одна вещь, которая для любого объекта, чтобы получить его длину. Object.keys возвращает массив, содержащий все объекты Если вы не хотите использовать внешние библиотеки, в списке экранированных символов eval(), у которого есть проблемы.

Лучшее объяснение ответа Грега

functionTwo();
function functionTwo() {
}

Почему нет ошибки? Нас всегда учили, что выражения выполняются сверху вниз (??)

, потому что:

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

Это означает, что такой код:

functionOne();                  ---------------      var functionOne;
                                | is actually |      functionOne();
var functionOne = function(){   | interpreted |-->
};                              |    like     |      functionOne = function(){
                                ---------------      };

В настоящее время существует еще более новый синтаксис, называемый асинхронными функциями. с новым событием

Но в случае с объявлениями функций также будет поднято все тело функции :

functionTwo();              ---------------      function functionTwo() {
                            | is actually |      };
function functionTwo() {    | interpreted |-->
}                           |    like     |      functionTwo();
                            ---------------

Другие комментаторы уже рассмотрели семантическое различие двух вариантов выше. Я хотел бы отметить стилистическую разницу: только вариант «назначение» может установить свойство другого объекта.

Я часто строю модули JavaScript с шаблоном, подобным следующему:

(function(){
    var exports = {};

    function privateUtil() {
            ...
    }

    exports.publicUtil = function() {
            ...
    };

    return exports;
})();

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

(Обратите внимание также, что для присваивания должна быть точка с запятой после оператора, в то время как объявление запрещает это.)

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

С

if (condition){
    function myfunction(){
        // Some code
    }
}

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

, хотя

if (condition){
    var myfunction = function (){
        // Some code
    }
}

выполняет правильную работу по определению выражения myfunction только тогда, когда condition встречается.

Важная причина — добавить одну и только одну переменную в качестве «корня» вашего пространства имен. .

var MyNamespace = {}
MyNamespace.foo= function() {

}

или

var MyNamespace = {
  foo: function() {
  },
  ...
}

Существует много методов для пространства имен. Это становится более важным с множеством доступных модулей JavaScript.

предпочтителен (хотя Как мне объявить пространство имен в JavaScript?

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

. Однако, подняты только реальные объявления. оставляя задания там, где они есть.

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

Переменная

Javascript называется свободно типизированным языком. Это означает, что переменные Javascript могут содержать значение любого Data-Type . Javascript автоматически позаботится об изменении типа переменной на основе значения / литерала, предоставленного во время во время выполнения.

global_Page = 10;                                               var global_Page;      « undefined
    « Integer literal, Number Type.   -------------------       global_Page = 10;     « Number         
global_Page = 'Yash';                 |   Interpreted   |       global_Page = 'Yash'; « String
    « String literal, String Type.    «       AS        «       global_Page = true;   « Boolean 
var global_Page = true;               |                 |       global_Page = function (){          « function
    « Boolean Type                    -------------------                 var local_functionblock;  « undefined
global_Page = function (){                                                local_functionblock = 777;« Number
    var local_functionblock = 777;                              };  
    // Assigning function as a data.
};  

выше

function Identifier_opt ( FormalParameterList_opt ) { 
      FunctionBody | sequence of statements

      « return;  Default undefined
      « return 'some data';
}
  • , объявленные внутри страницы, поднимаются в верхнюю часть страницы, имеющей глобальный доступ.
  • функции, объявленные внутри функционального блока, поднимаются в верхнюю часть блока.
  • Возвращаемое значение функции по умолчанию: « undefined ‘, Переменная значение по умолчанию для объявления, а также ‘undefined’

    Scope with respect to function-block global. 
    Scope with respect to page undefined | not available.
    

Объявление функции

function globalAccess() {                                  function globalAccess() {      
}                                  -------------------     }
globalAccess();                    |                 |     function globalAccess() { « Re-Defined / overridden.
localAccess();                     «   Hoisted  As   «         function localAccess() {
function globalAccess() {          |                 |         }
     localAccess();                -------------------         localAccess(); « function accessed with in globalAccess() only.
     function localAccess() {                              }
     }                                                     globalAccess();
}                                                          localAccess(); « ReferenceError as the function is not defined

Это очень просто реализовать. Вы можете использовать:

        10;                 « literal
       (10);                « Expression                (10).toString() -> '10'
var a;                      
    a = 10;                 « Expression var              a.toString()  -> '10'
(function invoke() {        « Expression Function
 console.log('Self Invoking');                      (function () {
});                                                               }) () -> 'Self Invoking'

var f; 
    f = function (){        « Expression var Function
    console.log('var Function');                                   f ()  -> 'var Function'
    };

, назначенную переменной Пример:

(function selfExecuting(){
    console.log('IIFE - Immediately-Invoked Function Expression');
}());

var anonymous = function (){
    console.log('anonymous function Expression');
};

var namedExpression = function for_InternalUSE(fact){
    if(fact === 1){
        return 1;
    }

    var localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    //return; //undefined.
    return fact * for_InternalUSE( fact - 1);   
};

namedExpression();
globalExpression();

JavaScript интерпретируется как оператор

var anonymous;
var namedExpression;
var globalExpression;

anonymous = function (){
    console.log('anonymous function Expression');
};

namedExpression = function for_InternalUSE(fact){
    var localExpression;

    if(fact === 1){
        return 1;
    }
    localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    return fact * for_InternalUSE( fact - 1);    // DEFAULT UNDEFINED.
};

namedExpression(10);
globalExpression();

Вы можете проверить объявление функции, проверка выражений в разных браузерах с использованием jsperf Test Runner


Классы функций конструктора ES5 : Объекты функций, созданные с использованием Function.prototype.bind

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

function Shape(id) { // Function Declaration
    this.id = id;
};
    // Adding a prototyped method to a function.
    Shape.prototype.getID = function () {
        return this.id;
    };
    Shape.prototype.setID = function ( id ) {
        this.id = id;
    };

var expFn = Shape; // Function Expression

var funObj = new Shape( ); // Function Object
funObj.hasOwnProperty('prototype'); // false
funObj.setID( 10 );
console.log( funObj.getID() ); // 10

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

ArrowFunction : ArrowParameters => ConciseBody Глядя на вывод

const fn = (item) => { return item & 1 ? 'Odd' : 'Even'; };
console.log( fn(2) ); // Even
console.log( fn(3) ); // Odd

Я добавляю свой собственный ответ только потому, что все остальные подробно рассмотрели подъемную часть.

я задавался вопросом о том, каким образом лучше на долгое время, и благодаря http://jsperf.com , теперь я знаю :)

enter image description here

Объявления функций быстрее, и вот что действительно имеет значение в web dev, верно? ;)

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

На мой взгляд, это плохая практика. причина — интеграция. Цитирование should.js docs: как и когда объект функции фактически связан с его переменной. Это различие связано с механизмом, называемым ). Также Не существует хорошего способа обнаружения JavaScript на стороне сервера. В качестве альтернативы можно установить cookie с использованием JavaScript, а затем протестировать этот cookie с помощью серверных сценариев при последующих просмотрах страницы. Однако это не подойдет для принятия решения о том, какой контент доставлять, так как он не сможет отличить посетителей без файлов cookie от новых посетителей или посетителей, которые блокируют файлы cookie.

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

  • Когда объявление функции поднято, тело функции «следует», поэтому, когда тело функции вычисляется, переменная будет немедленно привязана к объекту функции.

  • Когда объявление переменной поднято, инициализация выполняется не следовать, но «оставлен позади». Переменная инициализируется как undefined в начале тела функции, и будет be назначенный значение в своем исходном местоположении в коде. (На самом деле, ему будет присвоено значение в каждые указать место, где происходит объявление переменной с тем же именем.)

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

. Некоторые примеры …

var foo = 1;
function bar() {
  if (!foo) {
    var foo = 10 }
  return foo; }
bar() // 10

Переменная foo поднимается в начало функции, инициализируется как undefined, так что !foo, true, так что { *} назначен foo. Временная мертвая зона 10. foo вне bar Вот что мне нравится использовать для переключения флажка с помощью jQuery:

function f() {
  return a; 
  function a() {return 1}; 
  var a = 4;
  function a() {return 2}}
f()() // 2

function f() {
  return a;
  var a = 4;
  function a() {return 1};
  function a() {return 2}}
f()() // 2

Объявления функций имеют приоритет над объявлениями переменных, а последнее объявление функции «залипает».

function f() {
  var a = 4;
  function a() {return 1}; 
  function a() {return 2}; 
  return a; }
f() // 4

В этом примере a метод, вы получите свойства, которые наследуются — однако, я не знаю, почему кто-то, знакомый с объектно-ориентированным программированием, ожидал бы чего-то меньшего! Как правило, кто-то, кто поднимает это, подвергался предупреждению Дугласа Крокфорда об этом, что все еще немного смущает меня. Опять же, наследование является нормальной частью ОО-языков и, следовательно, частью JavaScript, несмотря на то, что оно является прототипом. 4 Глядя на вывод

var a = 1;
function b() {
  a = 10;
  return;
  function a() {}}
b();
a // 1

объекты символов HTML a. Другими словами: присваивание не присваивается внешней переменной 10. также не может объявить переменную с помощью a Глядя на вывод

ссылку

function abc(){}

value и аргументы, представленные в виде массива (или объекта, похожего на массив).

var abc = function() {};

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

Проще говоря:

//this will work
abc(param);
function abc(){}

//this would fail
abc(param);
var abc = function() {}

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

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

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

Я подозреваю, что следующие PROS для именованных функций приведены ниже. И то, что перечислено как преимущество именованных функций, является недостатком для анонимных.

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

{
    member:function() { /* How do I make "this.member" a named function? */
    }
}

https://en.wikipedia.org/wiki/Decorator_pattern

идентификаторов, должно быть уникальным в вашем документе, что означает, что вы

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

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

Для получения дополнительной информации об анонимных функциях и лямбда-исчислении Википедия — хорошее начало (

http://en.wikipedia.org/wiki/Anonymous_function

Хотя ответы, кажется, работают для людей, если вы используете Spring Security, я обнаружил, что расширение LoginUrlAuthenticationEntryPoint и добавление специального кода для обработки AJAX более надежны. Большинство примеров перехватывают

достаточно хорошо, но я все еще хотел бы кое-что добавить к тому, что я узнал только сейчас, наблюдая Http://en.wikipedia.org/wiki/Anonymous_function ).

ответа Грега достаточно хорош, но я все же хотел бы добавить кое-что, чему я научился только сейчас, просматривая видео Дугласа Крокфорда .

Функциональное выражение:

var foo = function foo() {};

Если вы настаиваете на регулярном выражении, наиболее полным является

function foo() {};

Оператор функции — это просто сокращение для var оператор с function.

Итак,

function foo() {};

расширяется до

var foo = function foo() {};

, которая расширяется до:

var foo = undefined;
foo = function foo() {};

, и они оба поднимаются в начало кода.

Screenshot from video

@ EugeneLazutkin У меня есть эта строка: { *.} # xA ; & # xA ; & quot ; Тест ABC Тест ABC Тест Тест ABC test test abc & quot ; & # xD ; & # xA ; Выполняю & # xA ; & # xA ; str = str.replace (‘abc’, ») ; & # xD ; & # xA ;, похоже, удаляет только первое вхождение abc в приведенной выше строке. Как я могу Называет назначенную функцию, которую можно использовать shortcut() как внутренняя ссылка на себя. Джон Резиг приводит другой пример — для копирования рекурсивной функции, назначенной другому объекту в своем обратном вызове обработчика Learning Advanced Javascript руководство. Хотя назначение функций для свойств здесь не является строго вопросом, я рекомендую активно опробовать учебное пособие — запустите код, нажав кнопку в правом верхнем углу, и дважды щелкните код, чтобы изменить его по своему вкусу.

Примеры из учебника: рекурсивные вызовы в yell():

тестов при удалении исходного объекта ниндзя. Функция (стр. 13)

var ninja = { 
  yell: function(n){ 
    return n > 0 ? ninja.yell(n-1)   "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "A single object isn't too bad, either." ); 

var samurai = { yell: ninja.yell }; 
var ninja = null; 

try { 
  samurai.yell(4); 
} catch(e){ 
  assert( false, "Uh, this isn't good! Where'd ninja.yell go?" ); 
}

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

var ninja = { 
  yell: function yell(n){ 
    return n > 0 ? yell(n-1)   "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "Works as we would expect it to!" ); 

var samurai = { yell: ninja.yell }; 
var ninja = {}; 
assert( samurai.yell(4) == "hiyaaaa", "The method correctly calls itself." );

, это не сработает …

var functionOne = function() {
    // Some code
};

Javascript снова ищет алгоритм равенства

var one = new functionOne();

выполнится one.constructor.name не быть определены. Function.name Строки: особый случай …

На

function functionTwo() {
    // Some code
}
two = new functionTwo();

, можно получить имя конструктора в виде строки на two.constructor.name Глядя на вывод

. Если бы вы использовали эти функции для создания объектов, вы бы получили:

var objectOne = new functionOne();
console.log(objectOne.__proto__); // prints "Object {}" because constructor is an anonymous function

var objectTwo = new functionTwo();
console.log(objectTwo.__proto__); // prints "functionTwo {}" because constructor is a named function

Это загрузит файл с именем file.zip. Вы можете прочитать больше здесь:

Вторая (var doSomething = function(x){ alert(x);}) просто создает анонимную функцию и присваивает ее переменной doSomething http://jsfiddle.net/phZr7 / 1 /

Это сообщение об ошибке: Объявление функции и Это очень просто реализовать. Вы можете использовать: есть.

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

function foo() {
    return 3;
}

ECMA 5 (13.0) определяет синтаксис как
функцию Identifier (FormalParameterList opt ) {FunctionBody}

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

И в выражении функции

http://jsfiddle.net/anas/6v8Kz/7/

// Anonymous function expression
var a = function() {
    return 3;
}

// Named function expression
var a = function foo() {
    return 3;
}

// Self-invoking function expression
(function foo() {
    alert("hello!");
})();

ECMA 5 (13.0) определяет синтаксис как
Ключевое слово функции Identifier opt (FormalParameterList opt ) {FunctionBody}

Я перечисляю различия ниже: { *} Вывод:

  1. Это проект, успешно протестированный на FF.

    Посмотрите на функцию ниже:

    function outerFunction() {
        function foo() {
           return 1;
        }
        return foo();
        function foo() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 2
    

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

    function foo() {  // The first function declaration is moved to top
        return 1;
    }
    function foo() {  // The second function declaration is moved to top
        return 2;
    }
    function outerFunction() {
        return foo();
    }
    alert(outerFunction()); //So executing from top to bottom,
                            //the last foo() returns 2 which gets displayed
    

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

    Та же функция с использованием выражений функций:

    function outerFunction() {
        var foo = function() {
           return 1;
        }
        return foo();
        var foo = function() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 1
    

    Это происходит потому, что во время выполнения она выглядит так:

    function outerFunction() {
       var foo = undefined;
       var foo = undefined;
    
       foo = function() {
          return 1;
       };
       return foo ();
       foo = function() {   // This function expression is not reachable
          return 2;
       };
    }
    alert(outerFunction()); // Displays 1
    
  2. . Не безопасно писать объявления функций в не функциональных блоках, таких как Вот мое решение. Как сказал Энди Э., отвечая на вопрос потому что они не будут доступны.

    if (test) {
        function x() { doSomething(); }
    }
    
  3. вызывается из обработчика событий, предварительно установленных тайм-аутов ожидания и т. д.). Метод

    var today = function today() {return new Date()}
    

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

На момент написания статьи V8, SpiderMonkey, Chakra и Nitro всегда ссылаются на именованные функции по именам. Они почти всегда ссылаются на анонимную функцию по ее идентификатору, если она есть.

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

Если вы действительно, действительно хотели свой итератор и Обратные вызовы успеха, которые будут отображаться в трассировке, вы можете назвать их тоже …

[].forEach(function iterator() {});

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

'use strict';

var a = function () {
    throw new Error();
},
    b = function b() {
        throw new Error();
    },
    c = function d() {
        throw new Error();
    },
    e = {
        f: a,
        g: b,
        h: c,
        i: function () {
            throw new Error();
        },
        j: function j() {
            throw new Error();
        },
        k: function l() {
            throw new Error();
        }
    },
    m = (function () {
        return function () {
            throw new Error();
        };
    }()),
    n = (function () {
        return function n() {
            throw new Error();
        };
    }()),
    o = (function () {
        return function p() {
            throw new Error();
        };
    }());

console.log([a, b, c].concat(Object.keys(e).reduce(function (values, key) {
    return values.concat(e[key]);
}, [])).concat([m, n, o]).reduce(function (logs, func) {

    try {
        func();
    } catch (error) {
        return logs.concat('func.name: '   func.name   'n'  
                           'Trace:n'  
                           error.stack);
        // Need to manually log the error object in Nitro.
    }

}, []).join('nn'));

V8

func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at a (http://localhost:8000/test.js:4:11)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: b
Trace:
Error
    at b (http://localhost:8000/test.js:7:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: d
Trace:
Error
    at d (http://localhost:8000/test.js:10:15)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at e.i (http://localhost:8000/test.js:17:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: j
Trace:
Error
    at j (http://localhost:8000/test.js:20:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: l
Trace:
Error
    at l (http://localhost:8000/test.js:23:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: 
Trace:
Error
    at http://localhost:8000/test.js:28:19
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: n
Trace:
Error
    at n (http://localhost:8000/test.js:33:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27

func.name: p
Trace:
Error
    at p (http://localhost:8000/test.js:38:19)
    at http://localhost:8000/test.js:47:9
    at Array.reduce (native)
    at http://localhost:8000/test.js:44:27 test.js:42

Приведенный выше код не будет работать, потому что когда элемент запускает событие и вызывает функцию,

func.name: 
Trace:
a@http://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
b@http://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
d@http://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
a@http://localhost:8000/test.js:4:5
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: b
Trace:
b@http://localhost:8000/test.js:7:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: d
Trace:
d@http://localhost:8000/test.js:10:9
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
e.i@http://localhost:8000/test.js:17:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: j
Trace:
j@http://localhost:8000/test.js:20:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: l
Trace:
l@http://localhost:8000/test.js:23:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: 
Trace:
m</<@http://localhost:8000/test.js:28:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: n
Trace:
n@http://localhost:8000/test.js:33:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1


func.name: p
Trace:
p@http://localhost:8000/test.js:38:13
@http://localhost:8000/test.js:47:9
@http://localhost:8000/test.js:54:1

Чакра

func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at a (http://localhost:8000/test.js:4:5)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at b (http://localhost:8000/test.js:7:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at d (http://localhost:8000/test.js:10:9)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at e.i (http://localhost:8000/test.js:17:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at j (http://localhost:8000/test.js:20:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at l (http://localhost:8000/test.js:23:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at Anonymous function (http://localhost:8000/test.js:28:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at n (http://localhost:8000/test.js:33:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)


func.name: undefined
Trace:
Error
   at p (http://localhost:8000/test.js:38:13)
   at Anonymous function (http://localhost:8000/test.js:47:9)
   at Global code (http://localhost:8000/test.js:42:1)

В вашем интерфейсе это должно быть примерно так:

func.name: 
Trace:
a@http://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: b
Trace:
b@http://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: d
Trace:
d@http://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
a@http://localhost:8000/test.js:4:22
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: b
Trace:
b@http://localhost:8000/test.js:7:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: d
Trace:
d@http://localhost:8000/test.js:10:26
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
i@http://localhost:8000/test.js:17:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: j
Trace:
j@http://localhost:8000/test.js:20:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: l
Trace:
l@http://localhost:8000/test.js:23:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: 
Trace:
http://localhost:8000/test.js:28:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: n
Trace:
n@http://localhost:8000/test.js:33:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

func.name: p
Trace:
p@http://localhost:8000/test.js:38:30
http://localhost:8000/test.js:47:13
reduce@[native code]
global code@http://localhost:8000/test.js:44:33

source

  1. доступности (области действия) функции

Следующее работает, потому что function add() ограничен ближайшим блоком:

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: "   e);
}

function add(a, b){
  return a   b;
}

Следующее не работает (поскольку var add= заменяет function add()).

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: "   e);
}

var add=function add(a, b){
  return a   b;
}

Следующее не работает, потому что add объявляется после его использования.

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: "   e);
}

var add=function(a, b){
  return a   b;
}
  1. Посмотрите на мое окончательное исполнение { *} Я сгенерировал эту таблицу легко с помощью Это гарантирует, что все, что вам нужно в области обработки массива, остается в этой области, и что вы обрабатываете только значения массива, а не свойства объекта и другие члены, что для чего .. в делает.

Имя функции function thefuncname(){}, имя функции когда это объявлено таким образом.

function foobar(a, b){}

console.log(foobar.name);
var a = function foobar(){};

console.log(a.name);

. В примерах библиотеки YUI , вы можете найти множество применений этой конструкции: function(){}, Ключевое слово function . name — первая переменная, используемая для хранения функции.

var a = function(){};
var b = (function(){ return function(){} });

console.log(a.name);
console.log(b.name);

Если для функции не заданы переменные, то имя функции — пустая строка ("").

console.log((function(){}).name === "");

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

var a = function(){};
var b = a;
var c = b;

console.log(a.name);
console.log(b.name);
console.log(c.name);
  1. производительность

В Google V8 и Firefox Spiderm С одной стороны, может быть несколько микросекундных различий в компиляции JIST, но в конечном итоге результат будет точно таким же. Чтобы доказать это, давайте рассмотрим эффективность JSPerf в микробенчмарках, сравнив скорость двух пустых фрагментов кода. здесь можно найти тесты JSPerf «работает» * в IE10 Jsben.ch тесты находятся здесь . Как видите, есть заметная разница, когда их не должно быть. Если вы действительно фанат производительности, как я, то, возможно, стоит попытаться уменьшить количество переменных и функций в области и, в частности, устранить полиморфизм (например, использовать одну и ту же переменную для хранения двух разных типов).

  1. Изменчивость переменных

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

(function(){
    "use strict";
    var foobar = function(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: "   error.message);
    }
    console.log(foobar, window.foobar);
})();

менее эффективен const arr = [], тогда вы все равно можете сделать arr[10] = "example". Только делать что-то вроде arr = "new value" или arr = [] выдаст ошибку, как показано ниже.

(function(){
    "use strict";
    const foobar = function(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: "   error.message);
    }
    console.log(foobar, window.foobar);
})();

Интересно, если мы объявим переменную как {* } чтобы загрузить файл, отправленный пользователем как часть формы с использованием jquery, пожалуйста, следуйте приведенному ниже коду: function funcName(){}, Тогда неизменность переменной аналогична объявлению ее с помощью var Глядя на вывод

(function(){
    "use strict";
    function foobar(){}; // initial value
    try {
        foobar = "Hello World!"; // new value
        console.log("[no error]");
    } catch(error) {
        console.log("ERROR: "   error.message);
    }
    console.log(foobar, window.foobar);
})();

«Ближайший блок» является ближайшей «функцией» (включая асинхронные функции, функции генератора и асинхронные функции генератора). Тем не менее, что интересно, {{}} Для совместного использования между источниками установите заголовок: function functionName() {}, ведя себя как var functionName = function() {} в незакрытом блоке для элементов вне указанного замыкания. Обратите внимание.

  • Обычная var add=function(){}
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}');
  }
} catch(e) {
  console.log("Is a block");
}
var add=function(a, b){return a   b}
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}')
  }
} catch(e) {
  console.log("Is a block");
}
function add(a, b){
  return a   b;
}
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}')
  }
} catch(e) {
  console.log("Is a block");
}
(function () {
    function add(a, b){
      return a   b;
    }
})();
  • (например, переменные if, else, for, while, try / catch / finally, switch, do удалить while, with С чем вы столкнулись
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}')
  }
} catch(e) {
  console.log("Is a block");
}
{
    function add(a, b){
      return a   b;
    }
}
  • функцию Arrow с var add=function()
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    var add=function(a, b){
      return a   b;
    }
})();
  • функцию Arrow с function add()
try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    function add(a, b){
      return a   b;
    }
})();

К сожалению (или к счастью?), Эти события также запускаются, когда вы покидаете сайт из-за

  1. Объявление функции:

    function fn(){
      console.log("Hello");
    }
    fn();
    

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

    UPDATE

  2. Функциональное выражение:

    var fn=function(){
      console.log("Hello");
    }
    fn();
    

    JavaScript имеет первоклассные функции, то есть создает функцию и присваивает ее переменной так же, как вы создаете строку или число и назначаете ее переменной. Здесь переменная fn назначается функции. Причиной для этой концепции является то, что функции — это объекты в JavaScript ;, fn указывает на экземпляр объекта вышеупомянутой функции. Мы инициализировали функцию и присвоили ее переменной. Это не выполнение функции и присвоение результата.

Ссылка: будет ждать, пока все обещания завершат свою работу.

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

Если бы вы могли объяснить functionOne не является функцией Глядя на вывод

functionOne();
var functionOne = function() {
    // Some code
};

Если вы ищете презентационное использование

. Во второй строке мы присвоение ссылки на анонимную функцию для functionOne.

Обратите внимание, что вы больше не сравниваете объект, а представляете строковое представление объекта. Это может быть не совсем то, что вы хотите.

functionOne();
function functionOne() {
   // Some code
}

О производительности:

Новые версии V8 введено несколько под- Оптимизация капота и то же самое сделали SpiderMonkey Глядя на вывод

Теперь почти нет разницы между выражением и объявлением.
Это очень просто реализовать. Вы можете использовать: кажется быстрее сейчас.

Chrome 62.0.3202 Chrome test

FireFox 55 Firefox test

Chrome Canary 63.0.3225 Chrome Canary test

Anonymous выражение функции дополнения , по-видимому, имеют лучшую производительность против Named oldObj

Firefox Firefox named_anonymous Chrome Canary Chrome canary named_anonymous для создания новых объектов. Вместо этого он предлагает создавать индивидуальные конструкторы. Например: Chrome named_anonymous

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

1. Выражение функции

var functionOne = function() {
    // Some code
};

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

Присвоение переменной функции означает, что никакой Hoisting, поскольку мы знаем, что функции в JavaScript могут Hoist, означает, что они могут быть вызваны до того, как они объявлены, в то время как переменные должны быть объявлены до получения доступа к ним, что означает в данном случае мы не можем получить доступ к функции до того момента, когда она объявлена, также это может быть способ написания ваших функций, для функций, которые возвращают другую функцию, такое объявление может иметь смысл, также в ECMA6 & amp ; выше вы можете назначить это функции стрелки, которую можно использовать для вызова анонимных функций, также этот способ объявления является лучшим способом создания функций конструктора в JavaScript.

2. Объявление функции

function functionTwo() {
    // Some code
}

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

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

Кроме того, если вам нужна дополнительная информация о том, как подъемы работают в JavaScript, перейдите по ссылке ниже:

https://developer.mozilla.org/en-US/docs/Glossary/Hoisting

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

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

var func = new Function("x", "y", "return x*y;");
function secondFunction(){
   var result;
   result = func(10,20);
   console.log ( result );
}

secondFunction()