欧美激情精品久久久久久,亚洲精品成人av在线

<!DOCTYPE html><html lang="en"><body><script>

	var addNumbersA = new Function('num1', 'num2', 'return num1 + num2');

	console.log(addNumbersA(2, 2)); // Logs 4.

	// Could also be written the literal way, which is much more common.
	var addNumbersB = function (num1, num2) { return num1 + num2; };

	console.log(addNumbersB(2, 2)); // Logs 4.

</script></body></html>

函數(shù)可用於傳回值、建構(gòu)物件或作為簡單運行程式碼的機制。 JavaScript 對函數(shù)有多種用途，但就其最基本的形式而言，函數(shù)只是可執(zhí)行語句的唯一範圍。

`函數(shù)()` 參數(shù)

Function() 建構(gòu)子採用無限數(shù)量的參數(shù)，但 Function() 建構(gòu)子期望的最後一個參數(shù)是一個字串，其中包含構(gòu)成函數(shù)體的語句。在最後一個之前傳遞給建構(gòu)函數(shù)的任何參數(shù)都可用於正在建立的函數(shù)。也可以以逗號分隔的字串形式傳送多個參數(shù)。

在下面的程式碼中，我將 Function() 建構(gòu)函數(shù)的用法與實例化函數(shù)物件的更常見模式進行了對比。

範例：sample77.html

<!DOCTYPE html><html lang="en"><body><script>

	var addFunction = new Function('num1', 'num2', 'return num1 + num2');

	/* Alternately, a single comma-separated string with arguments can be 
	the first parameter of the constructor, with the function body following. */
	var timesFunction = new Function('num1,num2', 'return num1 * num2');

	console.log(addFunction(2, 2), timesFunction(2, 2)); // Logs '4 4'

	// Versus the more common patterns for instantiating a function:
	var addFunction = function (num1, num2) { return num1 + num2; }; // Expression form.
	function addFunction(num1, num2) { return num1 + num2; } // Statement form.

</script></body></html>

不建議或通常不直接利用 Function() 建構(gòu)函數(shù)，因為 JavaScript 將使用 eval() 來解析包含函數(shù)邏輯的字串。許多人認為 eval() 是不必要的開銷。如果使用它，則程式碼設(shè)計中很可能存在缺陷。

使用Function() 建構(gòu)子而不使用new 關(guān)鍵字與僅使用建構(gòu)子建立函數(shù)物件具有相同的效果（new Function('x', 'return x') 與函數(shù)(('x','返回x'))。

直接呼叫 Function() 建構(gòu)子時不會建立閉包。

`Function()` 屬性與方法

函數(shù)物件具有以下屬性（不包括繼承的屬性和方法）：

屬性（Function.prototype;）：

原型

函數(shù)物件實例屬性與方法

函數(shù)物件實例具有以下屬性和方法（不包括繼承的屬性和方法）：

實例屬性 (var myFunction = function(x, y, z) {}; myFunction.length;):

參數(shù)
建構(gòu)子
長度

實例方法 (var myFunction = function(x, y, z) {}; myFunction.toString();):

apply()
#call()
#toString()

#函數(shù)總是傳回一個值

雖然可以建立一個函數(shù)來簡單地執(zhí)行程式碼語句，但函數(shù)傳回一個值也很常見。在以下範例中，我們從 sayHi 函數(shù)傳回字串。

範例：sample78.html

<!DOCTYPE html><html lang="en"><body><script>

	var sayHi = function () {
		return 'Hi';
	};

	console.log(sayHi()); // Logs "Hi".

</script></body></html>

如果函數(shù)沒有指定回傳值，則傳回 undefined。在以下範例中，我們呼叫 yelp 函數(shù)，該函數(shù)將字串「yelp」記錄到控制臺，而不明確傳回值。

範例：sample79.html

<!DOCTYPE html><html lang="en"><body><script>

	var yelp = function () {
		console.log('I am yelping!');
		// Functions return undefined even if we don't.
	}

	/* Logs true because a value is always returned, even if we don't specifically return one. */
	console.log(yelp() === undefined);

</script></body></html>

這裡要記住的概念是，即使您沒有明確提供要傳回的值，所有函數(shù)都會傳回一個值。如果不指定傳回值，則傳回值為 undefined。

函數(shù)是一等公民（不只是文法，還有值）

在 JavaScript 中，函數(shù)就是物件。這意味著函數(shù)可以儲存在變數(shù)、陣列或物件中。此外，函數(shù)可以傳遞給函數(shù)或從函數(shù)返回。函數(shù)具有屬性，因為它是一個物件。所有這些因素使得函數(shù)成為 JavaScript 中的一等公民。

範例：sample80.html

<!DOCTYPE html><html lang="en"><body><script>

	// Functions can be stored in variables (funcA), arrays (funcB), and objects (funcC).
	var funcA = function () { }; // Called like so: funcA()
	var funcB = [function () { } ]; // Called like so: funcB[0]()
	var funcC = { method: function () { } }; // too.method() or funcC['method']()

	// Functions can be sent to and sent back from functions.
	var funcD = function (func) {
		return func
	};

	var runFuncPassedToFuncD = funcD(function () { console.log('Hi'); });

	runFuncPassedToFuncD();

	// Functions are objects, which means they can have properties.
	var funcE = function () { };
	funcE.answer = 'yup'; // Instance property.
	console.log(funcE.answer); // Logs 'yup'.

</script></body></html>

認識到函數(shù)是一個對象，因此也是一個值，這一點至關(guān)重要。它可以像 JavaScript 中的任何其他表達式一樣傳遞或增強。

將參數(shù)傳遞給函數(shù)

參數(shù)是呼叫函數(shù)時將值傳遞到函數(shù)作用域的工具。在下面的範例中，我們呼叫 addFunction()。由於我們已預(yù)先定義它採用兩個參數(shù)，因此在其範圍內(nèi)可以使用兩個附加價值。

範例：sample81.html

<!DOCTYPE html><html lang="en"><body><script>

	var addFunction = function (number1, number2) {
		var sum = number1 + number2;
		return sum;
	}

	console.log(addFunction(3, 3)); // Logs 6.

</script></body></html>

與其他一些程式語言相比，在 JavaScript 中省略參數(shù)是完全合法的，即使函數(shù)已被定義為接受這些參數(shù)。缺少的參數(shù)僅被賦予值 undefined。當然，如果省略參數(shù)值，則函數(shù)可能無法正常運作。

如果向函數(shù)傳遞意外參數(shù)（建立函數(shù)時未定義的參數(shù)），則不會發(fā)生錯誤。並且可以從 arguments 物件存取這些參數(shù)，該物件可用於所有函數(shù)。

`this` 和 `arguments` 值可用于所有函數(shù)

在所有函數(shù)的范圍和主體內(nèi)，this 和 arguments 值可用。

arguments 對象是一個類似數(shù)組的對象，包含傳遞給函數(shù)的所有參數(shù)。在下面的代碼中，即使我們在定義函數(shù)時放棄指定參數(shù)，我們也可以依賴傳遞給函數(shù)的 arguments 數(shù)組來訪問在調(diào)用時發(fā)送的參數(shù)。

示例：sample82.html

<!DOCTYPE html><html lang="en"><body><script>

	var add = function () {
		return arguments[0] + arguments[1];
	};

	console.log(add(4, 4)); // Returns 8.

</script></body></html>

this 關(guān)鍵字，傳遞給所有函數(shù)，是對包含該函數(shù)的對象的引用。正如您所期望的，對象中包含的作為屬性（方法）的函數(shù)可以使用 this 來獲取對父對象的引用。當函數(shù)定義在全局作用域時，this 的值為全局對象。查看以下代碼并確保您了解 this 返回的內(nèi)容。

示例：sample83.html

<!DOCTYPE html><html lang="en"><body><script>

	var myObject1 = {
		name: 'myObject1',
		myMethod: function () { console.log(this); }
	};

	myObject1.myMethod(); // Logs 'myObject1'.

	var myObject2 = function () { console.log(this); };

	myObject2(); // Logs window.

</script></body></html>

`arguments.callee` 屬性

arguments 對象有一個名為 callee 的屬性，它是對當前正在執(zhí)行的函數(shù)的引用。此屬性可用于從函數(shù)范圍內(nèi)引用該函數(shù) (arguments.callee)a 自引用。在下面的代碼中，我們使用此屬性來獲取對調(diào)用函數(shù)的引用。

示例：sample84.html

<!DOCTYPE html><html lang="en"><body><script>

	var foo = function foo() {
		console.log(arguments.callee); // Logs foo()
		// callee could be used to invoke recursively the foo function (arguments.callee())
	} ();

</script></body></html>

當需要遞歸調(diào)用函數(shù)時，這非常有用。

函數(shù)實例 `length` 屬性和 `arguments.length`

arguments 對象具有唯一的 length 屬性。雖然您可能認為這個 length 屬性將為您提供已定義參數(shù)的數(shù)量，但它實際上提供了在調(diào)用期間發(fā)送到函數(shù)的參數(shù)數(shù)量。

示例：sample85.html

<!DOCTYPE html><html lang="en"><body><script>

	var myFunction = function (z, s, d) {
		return arguments.length;
	};

	console.log(myFunction()); // Logs 0 because no parameters were passed to the function.

</script></body></html>

使用所有 Function() 實例的 length 屬性，我們實際上可以獲取函數(shù)期望的參數(shù)總數(shù)。

示例：sample86.html

<!DOCTYPE html><html lang="en"><body><script>

	var myFunction = function (z, s, d, e, r, m, q) {
		return myFunction.length;
	};

	console.log(myFunction()); // Logs 7.

</script></body></html>

arguments.length 屬性在 JavaScript 1.4 中已棄用，但可以從函數(shù)對象的 length 屬性訪問發(fā)送到函數(shù)的參數(shù)數(shù)量。接下來，您可以通過利用 callee 屬性來首先獲取對正在調(diào)用的函數(shù)的引用 (arguments.callee.length) 來獲取長度值。

重新定義函數(shù)參數(shù)

函數(shù)參數(shù)可以直接在函數(shù)內(nèi)部重新定義，也可以使用 arguments 數(shù)組?？匆幌逻@段代碼：

示例：sample87.html

<!DOCTYPE html><html lang="en"><body><script>

	var foo = false;
	var bar = false;

	var myFunction = function (foo, bar) {
		arguments[0] = true;
		bar = true;
		console.log(arguments[0], bar); // Logs true true.
	}

	myFunction();

</script></body></html>

請注意，我可以使用 arguments 索引或直接為參數(shù)重新分配新值來重新定義 bar 參數(shù)的值。

在函數(shù)完成之前返回函數(shù)（取消函數(shù)執(zhí)行）

通過使用帶或不帶值的 return 關(guān)鍵字，可以在調(diào)用期間隨時取消函數(shù)。在下面的示例中，如果參數(shù)未定義或不是數(shù)字，我們將取消 add 函數(shù)。

示例：sample88.html

<!DOCTYPE html><html lang="en"><body><script>

	var add = function (x, y) {
		// If the parameters are not numbers, return error.
		if (typeof x !== 'number' || typeof y !== 'number') { return 'pass in numbers'; }
		return x + y;
	}
	console.log(add(3, 3)); // Logs 6.
	console.log(add('2', '2')); // Logs 'pass in numbers'.

</script></body></html>

這里要講的概念是，您可以在函數(shù)執(zhí)行過程中的任何時刻使用 return 關(guān)鍵字來取消函數(shù)的執(zhí)行。

定義函數(shù)（語句、表達式或構(gòu)造函數(shù)）

函數(shù)可以用三種不同的方式定義：函數(shù)構(gòu)造函數(shù)、函數(shù)語句或函數(shù)表達式。在下面的示例中，我演示了每種變體。

示例：sample89.html

<!DOCTYPE html><html lang="en"><body><script>

	/* Function constructor: The last parameter is the function logic, 
	everything before it is a parameter. */
	var addConstructor = new Function('x', 'y', 'return x + y');

	// Function statement.
	function addStatement(x, y) {
		return x + y;
	}

	// Function expression.
	var addExpression = function (x, y) {
		return x + y;
	};

	console.log(addConstructor(2, 2), addStatement(2, 2), addExpression(2, 2)); // Logs '4 4 4'.

</script></body></html>

有人說函數(shù)還有第四種類型的定義，稱為“命名函數(shù)表達式”。命名函數(shù)表達式只是一個包含名稱的函數(shù)表達式（例如， var add = function add(x, y) {return x+y}）。

調(diào)用函數(shù)（函數(shù)、方法、構(gòu)造函數(shù)或 `call()` 和 `apply()`)

使用四種不同的場景或模式調(diào)用函數(shù)。

作為函數(shù)
作為一種方法
作為構(gòu)造函數(shù)
使用 apply() 或 call()

在下面的示例中，我們將檢查每種調(diào)用模式。

示例：sample90.html

<!DOCTYPE html><html lang="en"><body><script>

	// Function pattern.
	var myFunction = function () { return 'foo' };
	console.log(myFunction()); // Logs 'foo'.

	// Method pattern.
	var myObject = { myFunction: function () { return 'bar'; } }
	console.log(myObject.myFunction()); // Logs 'bar'.

	// Constructor pattern.
	var Cody = function () {
		this.living = true;
		this.age = 33;
		this.gender = 'male';
		this.getGender = function () { return this.gender; };
	}
	var cody = new Cody(); // Invoke via the Cody constructor.
	console.log(cody); // Logs the cody object and properties.

	// apply() and call() pattern.
	var greet = {
		runGreet: function () {
			console.log(this.name, arguments[0], arguments[1]);
		}
	}

	var cody = { name: 'cody' };
	var lisa = { name: 'lisa' };

	// Invoke the runGreet function as if it were inside of the cody object.
	greet.runGreet.call(cody, 'foo', 'bar'); // Logs 'cody foo bar'.

	// Invoke the runGreet function as if it were inside of the lisa object.
	greet.runGreet.apply(lisa, ['foo', 'bar']); // Logs 'lisa foo bar'.

	/* Notice the difference between call() and apply() in how parameters are sent to the function being invoked. */

</script></body></html>

確保您了解所有四種調(diào)用模式，因為您將遇到的代碼可能包含其中任何一種。

匿名函數(shù)

匿名函數(shù)是沒有給出標識符的函數(shù)。匿名函數(shù)主要用于將函數(shù)作為參數(shù)傳遞給另一個函數(shù)。

示例：sample91.html

<!DOCTYPE html><html lang="en"><body><script>

	// function(){console.log('hi');}; // Anonymous function, but no way to invoke it.

	// Create a function that can invoke our anonymous function.
	var sayHi = function (f) {
		f(); // Invoke the anonymous function.
	}

	// Pass an anonymous function as a parameter.
	sayHi(function () { console.log('hi'); }); // Logs 'hi'.

</script></body></html>

自調(diào)用函數(shù)表達式

函數(shù)表達式（實際上是除從 Function() 構(gòu)造函數(shù)創(chuàng)建的函數(shù)之外的任何函數(shù)）可以在定義后使用括號運算符立即調(diào)用。在以下示例中，我們創(chuàng)建 sayWord() 函數(shù)表達式，然后立即調(diào)用該函數(shù)。這被認為是一個自調(diào)用函數(shù)。

示例：sample92.html

<!DOCTYPE html><html lang="en"><body><script>

	var sayWord = function () { console.log('Word 2 yo mo!'); } (); // Logs 'Word 2 yo mo!'

</script></body></html>

自調(diào)用匿名函數(shù)語句

可以創(chuàng)建自調(diào)用的匿名函數(shù)語句。這稱為自調(diào)用匿名函數(shù)。在下面的示例中，我們創(chuàng)建了幾個立即調(diào)用的匿名函數(shù)。

示例：sample93.html

<!DOCTYPE html><html lang="en"><body><script>

	// Most commonly used/seen in the wild.
	(function (msg) {
		console.log(msg);
	})('Hi');

	// Slightly different, but achieving the same thing:
	(function (msg) {
		console.log(msg)
	} ('Hi'));

	// The shortest possible solution.
	!function sayHi(msg) { console.log(msg); } ('Hi');

	// FYI, this does NOT work!
	// function sayHi() {console.log('hi');}();

</script></body></html>

根據(jù) ECMAScript 標準，如果要立即調(diào)用函數(shù)，則需要在函數(shù)兩邊加上括號（或?qū)⒑瘮?shù)轉(zhuǎn)換為表達式的任何內(nèi)容）。

函數(shù)可以嵌套

函數(shù)可以無限期地嵌套在其他函數(shù)中。在下面的代碼示例中，我們將 goo 函數(shù)封裝在 bar 函數(shù)內(nèi)部，該函數(shù)位于 foo 函數(shù)內(nèi)部。

示例：sample94.html

<!DOCTYPE html><html lang="en"><body><script>

	var foo = function () {
		var bar = function () {
			var goo = function () {
				console.log(this); // Logs reference to head window object.
			} ();
		} ();
	} ();

</script></body></html>

這里的簡單概念是函數(shù)可以嵌套，并且嵌套的深度沒有限制。

請記住，嵌套函數(shù)的 this 的值將是 JavaScript 1.5、ECMA-262 第 3 版中的頭對象（Web 瀏覽器中的 window 對象）。

將函數(shù)傳遞給函數(shù)以及從函數(shù)返回函數(shù)

如前所述，函數(shù)是 JavaScript 中的一等公民。由于函數(shù)是一個值，并且函數(shù)可以傳遞任何類型的值，因此函數(shù)可以傳遞給函數(shù)。接受和/或返回其他函數(shù)的函數(shù)有時稱為“高階函數(shù)”。

在下面的代碼中，我們將一個匿名函數(shù)傳遞給 foo 函數(shù)，然后立即從 foo 函數(shù)返回。變量 bar 所指向的正是這個匿名函數(shù)，因為 foo 接受并返回匿名函數(shù)。

示例：sample95.html

<!DOCTYPE html><html lang="en"><body><script>

	// Functions can be sent to, and sent back from, functions.
	var foo = function (f) {
		return f;
	}

	var bar = foo(function () { console.log('Hi'); });

	bar(); // Logs 'Hi'.

</script></body></html>

因此，當調(diào)用 bar 時，它會調(diào)用傳遞給 foo() 函數(shù)的匿名函數(shù)，然后從 foo() 函數(shù)傳回并從 bar 引用多變的。所有這些都是為了展示函數(shù)可以像任何其他值一樣傳遞的事實。

在定義函數(shù)語句之前調(diào)用函數(shù)語句（又名函數(shù)提升）

函數(shù)語句可以在執(zhí)行期間在其實際定義之前調(diào)用。這有點奇怪，但您應(yīng)該意識到這一點，以便您可以利用它，或者至少知道當您遇到它時會發(fā)生什么。在下面的示例中，我在定義 sayYo() 和 sum() 函數(shù)語句之前調(diào)用它們。

示例：sample96.html

<!DOCTYPE html><html lang="en"><body><script>

	// Example 1
	var speak = function () {
		sayYo(); // sayYo() has not been defined yet, but it can still be invoked, logs 'yo'.
		function sayYo() { console.log('Yo'); }
	} (); // Invoke

	// Example 2
	console.log(sum(2, 2)); // Invoke sum(), which is not defined yet, but can still be invoked.
	function sum(x, y) { return x + y; }

</script></body></html>

發(fā)生這種情況是因為在代碼運行之前，函數(shù)語句被解釋并添加到執(zhí)行堆棧/上下文中。確保您在使用函數(shù)語句時意識到這一點。

定義為函數(shù)表達式的函數(shù)不會被提升。僅提升函數(shù)語句。

函數(shù)可以調(diào)用自身（又名遞歸）

函數(shù)調(diào)用自身是完全合法的。事實上，這經(jīng)常被用在眾所周知的編碼模式中。在下面的代碼中，我們啟動 countDownFrom 函數(shù)，然后該函數(shù)通過函數(shù)名稱 countDownFrom 調(diào)用自身。本質(zhì)上，這會創(chuàng)建一個從 5 倒數(shù)到 0 的循環(huán)。

示例：sample97.html

<!DOCTYPE html><html lang="en"><body><script>

	var countDownFrom = function countDownFrom(num) {
		console.log(num);
		num--; // Change the parameter value.
		if (num < 0) { return false; } // If num < 0 return function with no recursion.
		// Could have also done arguments.callee(num) if it was an anonymous function.
		countDownFrom(num);
	};

	countDownFrom(5); // Kick off the function, which logs separately 5, 4, 3, 2, 1, 0.

</script></body></html>

您應(yīng)該意識到，函數(shù)調(diào)用自身（也稱為遞歸）或重復(fù)執(zhí)行此操作是很自然的。