要注意的一个重要点是:

让我们有两个功能:

sum(1,2);

const sum = function(first, second) {
  return first + second;
}

在上述情況下,它會導致錯誤,金額不被定義,但

sum(1,2);

function sum(first, second) {
  return first + second;
}

此函数不会有任何错误,因为在这种情况下会发生 Hoisting。

1、功能表达

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

函数表达式定义一个函数作为一个更大的表达式合成的一部分(通常是一个变量任务)。函数表达式通过函数表达式定义的函数可以被命名或匿名。

二、职能宣言

function functionTwo() {
    // Some code
}

这是在JavaScript中召唤函数的正常方式,这个函数可以被召唤之前你甚至宣布它,因为在JavaScript中,所有函数都被收集,但如果你有“严格使用”这个函数不会像预期那样收集,这是一个很好的方式召唤所有正常函数,这些函数不大,也不是一个构建函数。

此外,如果您需要更多关于如何在JavaScript中工作的信息,请参阅下面的链接:

var add = undefined; try { console.log(“成功:”,添加(1, 1)); } catch(e) { console.log(“错误:” + e); } add = function(a, b){ return a + b; }

尝试 { console.log(“成功:”,添加(1, 1)); } catch(e) { console.log(“错误:” + e); } var add=function add(a, b){ return a + b; }

名称(名称)

函数函数的名称 thefuncname(){} 是函数名称,当它以这种方式宣布时。

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

变量可变性

什么是“最接近的区块”

正常是 add=function(){}

正常功能添加({})

功能

Arrow 函数与 var add=函数()

Arrow 函数 与函数添加()

函数One = 函数() {} 定义在运行时间,函数Two() {} 定义在部分时间。

// Run-Time function declaration 
functionOne(); // Calling functionOne function here will give an Error
var functionOne = function () {
  // Some code
};

// Parse-Time function declaration 
functionTwo(); // Calling functionTwo function will not give an Error
function functionTwo() {
  // Some code...
}

此分類上一篇: Run-time vs Parse-time javascript run-time vs parse-time

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

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

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

"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)

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

名称函数表达式

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

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

配件功能启动器(ES5+)

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"

您还可以使用 Object.defineProperty、Object.defineProperties 和 Object.create 更不熟悉的第二个论点创建附件功能。

Arrow 功能表达式(ES2015+)

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

看到 n => n * 2 隐藏在地图() 呼叫? 这是一个函数。

关于箭头功能的一些事情:

他們沒有自己的這一點. 相反,他們關閉了他們所定義的背景的這一點. (他們也關閉了論點,在相關的情況下,超級.) 這意味著他們內在的這一點是相同的這一點,在那裡他們是創造的,並且不能改變。

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

如果您正在做一个单一表达式以上,请使用 {} 和一个明确的回报(如果您需要返回值),如正常:

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));

对象初步化方法宣言(ES2015+)

var o = {
    foo() {
    }
};

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

ES2015为我们提供类合成,包括声明的建筑师和方法:

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

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

对格雷格的答案有更好的解释

functionTwo();
function functionTwo() {
}

為什麼沒有錯誤?我們總是被教導,表達從上到底(??)

因为:

函数声明和变量声明总是由JavaScript翻译器无视地移动到其内容范围的顶部。

这就是这样的代码:

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

请注意,提交声明的部分未被提交;只有名称被提交。

但是,在函数声明的情况下,整个函数身体也将被包围:

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