函数声明和函数表达式有什么区别
- 函数声明使用function来进行声明，必须有函数名，函数声明会提升，所以不必放在执行前声明。
- 函数表达式其实就是创建一个匿名的函数声明并赋值给一个变量，函数的执行必须放在创建之后才可以
什么是变量的声明前置？什么是函数的声明前置
变量的声明前置
console.log(a);// undefined，因为a已经声明了，等同于在console.log(a)之前有一句 var a =undefined
var a = 1;
console.log(a); // 1,因为a已经等于1了，所以此时会输出1。
arguments 是什么
arguments是函数内部的一个类数组对象，它存储了函数的所有参数
对于函数
function foo(a1,a2,a3,a4...){}，可以通过
for(var i=0;i<arguments.length;i++){
console.log(arguments[i])输出该函数的所有参数
}
函数的"重载"怎样实现
可以通过判断arguments的长度来实现
function reload(){
var arguLen = arguments.length;
switch(arguLen){
case 0:
do something;
return something;
break;
case 1:
do something;
return something;
break;
case 2:
do something;
return something;
break;
case 3:
do something;
return something;
break;
case ...//可能还能很多情况去判断
}；
}
立即执行函数表达式是什么？有什么作用
- 立即执行函数的表达式
(function foo(){console.log(1)})()
!function foo(){console.log(1)}()
[function foo(){console.log(1)}()]
通常情况下，只对匿名函数使用这种“立即执行的函数表达式”。它的目的有两个：一是不必为函数命名，避免了污染全局变量；二是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。
求n!，用递归来实现
function factor(n){
if(n === 1){
return 1
}
return n*factor(n-1)
}
以下代码输出什么？
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: 男,["饥人谷", 2, "男"],name valley
getInfo('小谷', 3);
// 输出: name:小谷、age:3、undefined、['小谷', 3]、name vally;
getInfo('男');
// 输出: name:男、undefined、undefined、['男']、name vally;
写一个函数，返回参数的平方和？
function sumOfSquares(){
var res = 0;
for(var i = 0;i<arguments.length;i++){
res += Math.pow(arguments[i],2)
}
return res;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result) //10
如下代码的输出？为什么
console.log(a);// 输出undefined，因为变量a的声明提升，相当于在当前代码前面声明了变量a等于undefined
var a = 1;
console.log(b); 会报错，因为变量b未声明，ReferenceError: b is not defined
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
// sayName('world')会输出 hello world
// sayAge(10)会报错：Uncaught TypeError: sayAge is not a function
因为函数声明会提升，不必放到执行之前，但是函数表达式相当于创建了一个匿名函数并且赋值给了一个变量sayAge,它的执行必须放到函数表达式之后才可以
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
输出 10
// 伪代码
/*
globalContext = {
AO: {
x: 10
foo: function
bar: function
}
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
},
scope: globalContext.AO
}
fooContext = {
AO: {},
scope: globalContext.AO
}
*/
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出 30
伪代码：
globalContext = {
AO: {
x: 10
bar: function
},
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
foo: function
},
scope: globalContext.AO
}
foo.[[scope]] = barContext.AO
fooContext = {
AO: {},
scope: barContext.AO
}
以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
输出 30
伪代码：
globalContext = {
AO: {
x: 10
bar: function
}
}
bar.[[scope]] = globalContext.AO
barContext = {
AO: {
x: 30
IIFE: function
},
scope: globalContext.AO
}
IIFE.[[scope]] = barContext.AO
IIFEContext = {
AO: {},
scope: barContext.AO
}
以下代码输出什么？ 写出作用域链查找过程伪代码
var a = 1;
function fn(){
console.log(a) // 会输出undefined，因为变量声明提升，但并未赋值（first）
var a = 5
console.log(a) //会输出 5，变量被赋值5(second)
a++ // 变量自增1，下次调用时会变为6
var a // 重复声明已经存在的变量，其值不变，还是6
fn3()
fn2()
console.log(a) // 会输出20，因为执行完fn2()后，已经把该作用域中的变量a更改为20(fifth)
function fn2(){
console.log(a)// 会输出6，因为他自身的作用域中没有声明变量a，只能从它的上一级作用域中查找，是6(fourth)
a = 20//此时，它上一级作用域中的变量a会变为20，因为他自身的作用域中没有申明变量a，所以只能从它的上一级作用域中查找和更改
}
}
function fn3(){
console.log(a) // 会输出1，因为他的作用域中没有变量a，会从全局作用域中查找，是1(third)
a = 200 //此时，全局作用域中的a会变为200，因为它自身的作用域中没有变量a，只能从它的上一级作用域中查找
}
fn()
console.log(a) // 会输出200，因为fn3()的执行已经把全局作用域中的变量a更改为200（sixth）
所以最终的输出结果依次是:undefined,5,1,6,20,200
