我想知道这是什么意思:
(function () {
})();
这是在说document。onload吗?
当前回答
不，这个构造只是为命名创建了一个作用域。如果你把它分成几部分，你可以看到你有一个外部
(...)();
这是一个函数调用。括号内是:
function() {}
这是一个匿名函数。在构造中使用var声明的所有内容将只在同一构造中可见，并且不会污染全局名称空间。
其他回答
它是一个函数表达式，它代表立即调用函数表达式(IIFE)。IIFE只是一个在创建后立即执行的函数。因此，函数不必等到调用它才能执行，而是立即执行IIFE。让我们通过示例来构造IIFE。假设我们有一个add函数，它接受两个整数作为参数并返回和 让我们把add函数放到IIFE中，
步骤1:定义函数
function add (a, b){
return a+b;
}
add(5,5);
Step2:通过将整个函数声明包装到圆括号中来调用函数
(function add (a, b){
return a+b;
})
//add(5,5);
步骤3:要立即调用函数，只需从调用中删除'add'文本。
(function add (a, b){
return a+b;
})(5,5);
使用IFFE的主要原因是在函数中保留私有作用域。在javascript代码中，你要确保你没有覆盖任何全局变量。有时您可能会意外地定义一个覆盖全局变量的变量。让我们举个例子。假设我们有一个名为iffe.html的HTML文件，body标签内的代码是-
<body>
<div id = 'demo'></div>
<script>
document.getElementById("demo").innerHTML = "Hello JavaScript!";
</script>
</body>
好吧，上面的代码将毫无疑问地执行，现在假设您意外或有意地声明了一个名为document的变量。
<body>
<div id = 'demo'></div>
<script>
document.getElementById("demo").innerHTML = "Hello JavaScript!";
const document = "hi there";
console.log(document);
</script>
</body>
你将会看到一个SyntaxError:重新声明不可配置的全局属性文档。
但是如果你想要声明一个名为documentmet的变量，你可以使用IFFE来实现。
<body>
<div id = 'demo'></div>
<script>
(function(){
const document = "hi there";
this.document.getElementById("demo").innerHTML = "Hello JavaScript!";
console.log(document);
})();
document.getElementById("demo").innerHTML = "Hello JavaScript!";
</script>
</body>
输出:
让我们尝试另一个例子，假设我们有一个计算器对象像bellow-
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
console.log(calculator.add(5,10));
</script>
</body>
这很神奇，如果我们不小心重新赋值了计算器对象的值。
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
console.log(calculator.add(5,10));
calculator = "scientific calculator";
console.log(calculator.mul(5,5));
</script>
</body>
是的，你将结束一个TypeError:计算器。Mul不是if .html的函数
但是在IFFE的帮助下，我们可以创建一个私有作用域，在那里我们可以创建另一个变量名计算器并使用它;
<body>
<script>
var calculator = {
add:function(a,b){
return a+b;
},
mul:function(a,b){
return a*b;
}
}
var cal = (function(){
var calculator = {
sub:function(a,b){
return a-b;
},
div:function(a,b){
return a/b;
}
}
console.log(this.calculator.mul(5,10));
console.log(calculator.sub(10,5));
return calculator;
})();
console.log(calculator.add(5,10));
console.log(cal.div(10,5));
</script>
</body>
输出:
该构造称为立即调用函数表达式(IIFE)，这意味着它将立即执行。可以把它看作是解释器到达该函数时自动调用的函数。
最常见的用例:
它最常见的用例之一是限制通过var创建的变量的作用域。通过var创建的变量的作用域仅限于一个函数，因此这个构造(这是一个围绕某些代码的函数包装器)将确保你的变量作用域不会泄漏到该函数中。
在下面的例子中，count在立即调用的函数之外是不可用的，即count的作用域不会泄漏到函数之外。您应该得到一个ReferenceError，如果您尝试在立即调用的函数之外访问它。
(function () {
var count = 10;
})();
console.log(count); // Reference Error: count is not defined
ES6备选方案(推荐)
在ES6中，我们现在可以通过let和const创建变量。它们都是块范围的(不像var是函数范围的)。
因此，对于上面提到的用例，您不必使用IIFE的复杂构造，现在可以编写更简单的代码，以确保变量的作用域不会泄漏到所需的块中。
{
let count = 10;
}
console.log(count); // ReferenceError: count is not defined
在本例中，我们使用let定义count变量，使count限制在我们用花括号{…}创建的代码块中。
我称之为“卷毛监狱”。
立即调用的函数表达式(IIFE)立即调用函数。这仅仅意味着函数在定义完成后立即执行。
更常见的三个词:
// Crockford's preference - parens on the inside
(function() {
console.log('Welcome to the Internet. Please follow me.');
}());
//The OPs example, parentheses on the outside
(function() {
console.log('Welcome to the Internet. Please follow me.');
})();
//Using the exclamation mark operator
//https://stackoverflow.com/a/5654929/1175496
!function() {
console.log('Welcome to the Internet. Please follow me.');
}();
如果对它的返回值没有特殊要求，那么我们可以这样写:
!function(){}(); // => true
~function(){}(); // => -1
+function(){}(); // => NaN
-function(){}(); // => NaN
或者，它可以是:
~(function(){})();
void function(){}();
true && function(){ /* code */ }();
15.0, function(){ /* code */ }();
你甚至可以这样写:
new function(){ /* code */ }
31.new function(){ /* code */ }() //If no parameters, the last () is not required
TL;DR:表达式可以括在圆括号中，如果函数的表达式和块形式组合在一起，则会与函数调用冲突。
我喜欢反例，因为它们描绘了一幅伟大的逻辑图景，而其他人没有列出任何反例。你可能会问，“为什么浏览器不能看到function(){}()，而只是假设它是一个表达式?”让我们用三个例子来比较这个问题。
var x; //这里fibonacci是一个block函数 函数fibonacci(x) { Var值= x < 2 ?X: fibonacci(X -1) + fibonacci(X -2); if (x === 9) console.log("The " + x + "th fibonacci is: " + value); 返回值; ｝ (x = 9); console.log(" x的值:" + x); Console.log ("fibonacci is a(n) ")+ typeof fibonacci);
当我们将函数转换为表达式时，观察事情是如何变化的。
var x; //这里fibonacci是一个函数表达式 函数fibonacci(x) { Var值= x < 2 ?X: fibonacci(X -1) + fibonacci(X -2); if (x === 9) console.log("The " + x + "th fibonacci is: " + value); 返回值; }) (x = 9); console.log(" x的值:" + x); Console.log ("fibonacci is a(n) ")+ typeof fibonacci);
当你使用not-operator而不是圆括号时，也会发生同样的事情，因为这两个操作符都将语句转换为表达式:
var x; //这里fibonacci是一个函数表达式 ！ 函数fibonacci(x) { Var值= x < 2 ?X: fibonacci(X -1) + fibonacci(X -2); if (x === 9) console.log("The " + x + "th fibonacci is: " + value); 返回值; ｝ (x = 9); console.log(" x的值:" + x); Console.log ("fibonacci is a(n) ")+ typeof fibonacci);
通过将函数转换为表达式，它由它下面的两行(x = 9)执行。由于表达式函数和块函数的行为是分开的，所以这两个例子都运行得很好，没有歧义(规范方面)。
名字的作用域
另一个重要的观察是，命名块函数对整个作用域可见，而函数表达式只对其本身可见。换句话说，fibonacci只对第一个示例中的最后一个console.log是块时可见。在这三个例子中，fibonacci对自身是可见的，允许fibonacci调用自身，这是递归。
箭头功能
逻辑的另一个方面是箭头函数。如果块函数和表达式函数的定义合并在一起，规范将不得不包括箭头函数的任意规则和例外:
函数hello() {console.log(" hello World")} (x) => console.log("hello " + x) console.log("如果你正在阅读，没有发生错误");
虽然函数块工作正常，但函数表达式后面跟着箭头函数会产生语法错误:
！ 函数hello() {console.log(" hello World")} (x) => console.log("hello " + x) console.log("如果你正在阅读，没有发生错误");
这里，第二行的(x)是调用前一行的函数还是箭头函数的函数参数是不明确的。
请注意，箭头函数多年来确实符合ECMAScript标准，在语言的初始设计中并不是一个因素;我的观点是，表达式函数和块函数之间的区别有助于JavaScript语法更有逻辑性和连贯性。
以下代码:
(function () {
})();
称为立即调用函数表达式(IIFE)。
它之所以被称为函数表达式，是因为Javascript中的(yourcode)操作符将其强制转换为表达式。函数表达式和函数声明的区别如下:
// declaration:
function declaredFunction () {}
// expressions:
// storing function into variable
const expressedFunction = function () {}
// Using () operator, which transforms the function into an expression
(function () {})
表达式只是一组可以求值为单个值的代码。对于上面例子中的表达式，这个值是一个单独的函数对象。
在得到表达式后，计算结果为函数对象，然后可以立即使用()操作符调用函数对象。例如:
(函数(){ Const foo = 10;//这里的所有变量都是函数块的作用域 console.log (foo); }) (); console.log (foo);// referenceError foo的作用域是IIFE
为什么这个有用?
当我们处理大型代码库和/或导入各种库时，命名冲突的几率会增加。当我们在IIFE中编写相关(因此使用相同的变量)的代码的某些部分时，所有的变量和函数名都被限定在IIFE的函数括号内。这减少了命名冲突的可能性，让你在命名时更粗心(例如，你不必在它们前面加上前缀)。
