函數(shù)聲明和函數(shù)表達(dá)式有什么區(qū)別
- 函數(shù)聲明: 函數(shù)聲明通過關(guān)鍵字function來聲明, 關(guān)鍵詞后面是函數(shù)名, 名稱后面有個小括號, 括號里面放的是函數(shù)的參數(shù), 最后是一對花括號,包括函數(shù)的代碼塊
- 函數(shù)表達(dá)式
- 區(qū)別:
- 函數(shù)聲明是以function關(guān)鍵詞開始, 如果不是,那么就是函數(shù)表達(dá)式
- 函數(shù)聲明最后一般不寫分號, 而函數(shù)表達(dá)式有分號
- 函數(shù)聲明和變量聲明都有聲明提前的特點(diǎn), 函數(shù)聲明是函數(shù)名稱和函數(shù)體均提前聲明了, 可以在聲明之前調(diào)用它;
- 函數(shù)表達(dá)式的規(guī)則與變量聲明提前一樣,只是函數(shù)聲明變量提前了, 但是它的賦值仍在原來的位置, 不能在函數(shù)表達(dá)式之前調(diào)用
什么是變量的聲明前置？什么是函數(shù)的聲明前置
- 變量聲明前置是指把變量的聲明提前到當(dāng)前作用域的最前面, 但變量的賦值仍然按照原來的順序執(zhí)行, 如果變量聲明但未被賦值, 變量自動賦值為undefined
- 函數(shù)的聲明前置有兩種情況, 一個是使用函數(shù)聲明, 則整個聲明都前置, 而且會被前置到變量聲明的后面; 另一個是使用函數(shù)表達(dá)式, 那么規(guī)則和變量的聲明前置一樣
var a = 1;
function main() {
console.log(a);
var a = 2;
}
main()//輸出undefined
解析如下：
var a = 1;
function main() {
var a; //這時的a是undefined
console.log(a);
a = 2;
}
arguments 是什么
- arguments是一個類數(shù)組對象, 代表傳給一個function的參數(shù)列表, 只在函數(shù)內(nèi)部起作用; arguments的值與函數(shù)傳入?yún)?shù)有關(guān), 與定義參數(shù)無關(guān)
- 在函數(shù)內(nèi)部可以使用arguments對象獲取到該函數(shù)的所有傳入?yún)?shù), 這個對象為傳遞給函數(shù)的每個參數(shù)建立一個條目, 條目的索引號 從0 開始
- 使用arguments能夠給實(shí)參重新復(fù)制
- 可以用arguments能夠檢測函數(shù)的參數(shù)個數(shù) arguments.length
- 類似數(shù)組但不是數(shù)組的對象, 其具備數(shù)組相同的訪問性質(zhì)及方式, 能夠由arguments[n]來訪問對應(yīng)參數(shù)的值
函數(shù)的"重載"怎樣實(shí)現(xiàn)
- 重載是很多面向?qū)ο笳Z言實(shí)現(xiàn)多態(tài)的手段之一, 相同名字的函數(shù)參數(shù)個數(shù)不同, 或者順序不同, 都被認(rèn)為是不同的函數(shù)
- 在JavaScript中沒有函數(shù)重載的概念, 函數(shù)通過名字確定唯一性, 參數(shù)不同也被認(rèn)為是相同的函數(shù), 后面的覆蓋前面的
- JavaScript可以通過自身屬性模擬函數(shù)重載, 可以用arguments來實(shí)現(xiàn)函數(shù)的重載
function printPeopleInfo(name, age, sex){
if(name){
console.log(name);
}
if(age){
console.log(age);
}
if(sex){
console.log(sex);
}
}
printPeopleInfo('Byron', 26);
printPeopleInfo('Byron', 26, 'male');
立即執(zhí)行函數(shù)表達(dá)式是什么？有什么作用
- 在JavaScript中, 一對圓括號()是一種運(yùn)算符, 跟在函數(shù)明后, 表示調(diào)用該函數(shù); 有時我們希望在定義函數(shù)之后, 立即調(diào)用該函數(shù); 這時, 不能再函數(shù)的定義之后加圓括號, 會產(chǎn)生語法錯誤; 因?yàn)閒unction這個關(guān)鍵字既可以當(dāng)做語句, 也可當(dāng)做表達(dá)式; 為了避免解析上的歧義, JavaScript引擎看到行首是function關(guān)鍵字之后, 認(rèn)為這一段都是函數(shù)的定義 , 不應(yīng)該以圓括號結(jié)尾, 所以報錯;
- 解決方法就是不要讓function出現(xiàn)在行首, 讓引擎將其理解外一個表達(dá)式, 最簡單的方式, 是將其放在圓括號內(nèi)
//正確的寫法：
( function(){ /* code */ }() );
// 或者
( function(){ /* code */ } )();
- 上述寫法都是以圓括號開頭, 引擎就會認(rèn)為后面跟的是表達(dá)式, 而不是函數(shù)定義語句, 避免了錯誤; 這就是 立即執(zhí)行函數(shù)表達(dá)式
- 上面寫法最后的分號都是必須的; 如果省略分號, 遇到連續(xù)的兩個立即執(zhí)行表達(dá)式, 可能會報錯
- 立即執(zhí)行函數(shù)表達(dá)式一般不需要給函數(shù)命名, 如果要命名, 一般是用于遞歸函數(shù)
- 中括號, 逗號, 取反運(yùn)算符也能達(dá)到類似效果
[function fn(){var a=3}]()
,function fn(){var a=3}()
!function fn(){var a=3}()
- 作用: 將全局變量與局部變量分隔開, 保證全局變量不受污染
求n!，用遞歸來實(shí)現(xiàn)
function recursion(n) {
if (n === 1 || n === 0) {
return 1;
}
else if (n<0) {
return console.log("minus has no recursion");
}
return n*recursion(n-1);
}
console.log(recursion(8));
以下代碼輸出什么？
function getInfo(name, age, sex){
console.log('name:',name);
console.log('age:', age);
console.log('sex:', sex);
console.log(arguments);
arguments[0] = 'valley';
console.log('name', name);
}
getInfo('饑人谷', 2, '男');
/*name: "饑人谷"
age: 2
sex: "男"
Arguments["饑人谷", 2, "男"]
name: ”valley“
*/
getInfo('小谷', 3);
/*name: "小谷"
age: 3
sex: undefined
Arguments["小骨", 3]
name: ”valley“
*/
getInfo('男');
/*name: "男"
age: undefined
sex: undefined
Arguments["男"]
name: ”valley“
*/
寫一個函數(shù)黑界，返回參數(shù)的平方和？
function sumOfSquares(){
var result= 0;
for (var i=0; i<arguments.length; i++) {
result+= arguments[i]* arguments[i];
}
return result;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result2) //10
如下代碼的輸出？為什么
console.log(a); //undefined, 變量聲明會前置哗总，并賦值undefined
var a = 1;
console.log(b); //報錯, b未聲明
如下代碼的輸出？為什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
}; //輸出hello world倍试，同時報錯sayAge is not a function讯屈。因?yàn)檫@是一個函數(shù)表達(dá)式，聲明必須放到調(diào)用的前面县习，而這里聲明放在了后面涮母。
如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
} //輸出 10
/*
globalContent= {
A0 {
x: 10
foo: function
bar: function
}
scope: null
}
foo[[scope]] = globalContent.A0
bar[[scope]] = globalContent.A0
barContent= {
A0 {
x: 30
}
scope: globalContent.A0
}
fooContent= {
A0 {}
scope: globalContent.A0
}
*/
如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
} // 輸出30
/*
globalContent= {
A0 {
x: 10
}
scope: null
}
bar[[scope]] = globalContent.A0
barContent= {
A0 {
x: 30
foo: function
}
scope: globalContent.A0
}
fooContent[[scope]] = barContent.A0
fooContent = {
A0 {}
scope :barContent.A0
}
*/
以下代碼輸出什么? 寫出作用域鏈的查找過程偽代碼
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
} //輸出30
/*
globalContent = {
A0 {
x: 10
bar: function
}
scope: null
}
bar[[scope]] = globalContent.A0
barContent = {
A0 {
x: 30
function()
}
scope: globalContent.A0
}
function()[[scope]] = barContext.AO
functionContent = {
A0 {}
scope: barContext.AO
}
*/
以下代碼輸出什么？ 寫出作用域鏈查找過程偽代碼
var a = 1;
function fn(){
console.log(a)
var a = 5
console.log(a)
a++
var a
fn3()
fn2()
console.log(a)
function fn2(){
console.log(a)
a = 20
}
}
function fn3(){
console.log(a)
a = 200
}
fn()
console.log(a) // 輸出: undefined 5 1 6 20 200
/*
1. globalContext = {
A0 {
a: 1
fn: function
fn3: function
}
scope: null
}
fn[[scope]] = globalContext.A0
fn3[[scope]] = globalContext.A0
2. fnContent = {
A0 {
a: undefined, 5, 6
fn2: function
}
scope: globalContext.A0
}
fn2[[scope]] = fnContext.A0
3. fn2Content = {
A0 {}
scope: fnContext.A0
}
4. fn3Content = {
A0 {}
scope: globalContext.A0
}
*/
