函数声明和函数表达式有什么区别
//函数声明
function test1(){}
//函数表达式
var test2 = function(){}
函数声明可以在在代码中任意位置调用，但是函数表达式只能在表达式语句后面调用
什么是变量的声明前置？什么是函数的声明前置
声明变量后，变量提升到其所处作用域的顶部
console.log(a)//undefined 其实a已经前置了，只不过还没有赋值
var a = 5
函数的声明前置，提升到其所处作用域的顶部
fn()//调用虽然在前面，但是函数声明的方法已经提升到顶部了，就能让调用正常运行
function fn() {}
如果用了函数表达式，那就不能在随意位置调用了
fn()//报错！
var fn = function() {}//此时的fn身份只是一个变量值，这个时候在它之前调用就会报错啦
arguments 是什么
是一个类数组对象，它包含了函数中的所有实际参数。
function foo(a,b) {
console.log(arguments);
}
foo(1,2);//[1, 2]
函数的"重载"怎样实现
其他语言能实现的“重载”写法在js这儿是行不通的，因为同名的函数会被覆盖掉，但是也不是一点儿办法也没有，我们可以通过对函数传入的参数进行判断，来实现同一方法的，不同处理，得到不同的结果，达到重载的目的。
//举个栗子
function animals(dog,cat,pig){
if(dog){
console.log(' This is a dog ')
}
if(cat){
console.log(' This is a cat ')
}
if(pig){
console.log(' This is a pig ')
}
}
立即执行函数表达式是什么？有什么作用
作用：隔离作用域，避免变量污染全局，将函数按表达式的方法写，也可达到这个效果
(function fn1(){}) ()
求n!，用递归来实现
//递归，写个方法，自己调用自己，就叫递归
function recursion(n){
if(typeof n !='number'){
console.log('请输入数字')
return
}
else if(n===0){
console.log('不能输入0的啊')
return
}
else if(n===1){
return 1
}
else{
return n * recursion(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,'sex'] name valley
getInfo('小谷', 3); //name:小谷、age:3、undefined、['小谷', 3]、name vally;
getInfo('男'); //name:男、undefined、undefined、['男']、name vally;
写一个函数，返回参数的平方和？
function sumOfSquare(){
result = 0
for(var i =0;i<arguments.length;i++){
result = result + arguments[i]*arguments[i]
}
return result
}
console.clear()
console.log(sumOfSquare(5,5))//50
如下代码的输出？为什么
console.log(a);//变量提升的原因，读到了代码，但是输出早了没来得及给值，所以是undefined
var a = 1;
console.log(b);//这个b压根儿就不存在，所以就是b is not defined
如下代码的输出？为什么
sayName('world');//hello,world,变量提升，随意调用，都可得值
sayAge(10);//sayAge is not a function，表达式的写法，使这个方法只能以“值”的形式存在，没有“提升”的特权，所以此时的调用就报错
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
}
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
//输出10
伪代码展示
// 变量提升，激活上下文之后等同于：
var x = 10
function foo() {
console.log(x)
}
bar()
// 最后输出10
我的想法：这两个方法是没有包含和被包含关系的，都是一旦被激活，先找自己方法内的小范围，如果找不到就顺延着去全局找去，不要因为foo方法在bar范围内激活的就认为这两个方法有包含从属关系
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
//输出30
伪代码展示
// 变量提升，激活上下文之后等同于：
var x = 30;
function foo(){
console.log(x)
}
我的想法：上面一题那种写法，两个方法是没有 从属包含 关系的，但是这一题的写法是有 从属包含关系的，主要的不同点在与foo方法的循迹范围出现了变化 它找东西的过程是这样的 先找自己范围内的，若没有，找bar方法有没有，若bar方法没有，马上就去全局去找去，这个是与上一题最大的不同
以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
//输出30
伪代码展示
// 变量提升，激活上下文之后等同于：
var x = 30;
(function (){
console.log(x)
})()
以下代码输出什么？ 写出作用域链查找过程伪代码
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
全局范围内浏览器读码读到了什么
a = 1
名为 fn 的方法
名为 fn3 的方法
当读到fn()时会激活fn方法 开始fn函数的上下文，fn里面读到了什么
a = undefined
名为 fn2 的方法
console.log(a) // 第一次输出undefined
a = 5
console.log(a) //第二次输出 5
a++ //此时在fn方法中a为6
当读到fn3()时激活fn3的上下文，看看fn3里面有点儿啥
浏览器第一遍读码会发现这个里面没有可提升的东西，
第二遍读码，如果要输出a就得去全局中去找a,此时全局中的a
为1 所以第三次输出1，读到a = 200时，就把全局中的a=1
改成a=200，此时全局的a值由开始时的1变成了200啦
读完fn3之后，会激活fn2方法的上下文，然后看看fn2里面，能读到什么
浏览器进入fn2后第一遍读码发现没有可提升的东西，接着第二遍读码，输出a，fn2的范围里没有a，便去fn里面找a去，此时fn方法里面的a为6然后第四次输出6，读到a = 20时，就把fn方法里面的a=6改成a=20
把fn2里面的东西都读完了，就该接着读fn2()下面的代码了，读到console.log(a)，此时fn里面的a值已经是20啦，所以现在第五次输出20，到这一步，fn里面的东西都已经读完了，也代表着全局里面的fn()方法折腾完了。
接着读fn()方法后面的代码console.log(a)，接着就得输出全局中的a此时a的值为200 所以 第六次输出就是200啦
