函数声明和函数表达式有什么区别
区别：函数声明就是了一个函数，而函数表达式就是得到一个值。函数声明就是使用关键字function进行声明，同时其在调用时，不用考虑声明的位置。同时不管其的位置在哪里，将会被js解释器提升到最前端进行解析。
函数表达式：var a =function () {},将函数赋值给变量。可以省略函数名，其的变量名会前置，但是表达式并不会前置，什么是变量的声明前置？什么是函数的声明前置
就是在代码解析过程中var会提前放置，放在程序的最前端。
函数的声明会提前放置。arguments 是什么
在函数重载中，可以获取函数中的所有值的函数。其是函数内置的一个属性，具有数组的性质，但又不是数组。函数的"重载"怎样实现
通过在函数中添加判断语句进行重载。立即执行函数表达式是什么？有什么作用
通过小括号（）大括号{}、中括号[ ]、非！、逗号，；包裹的函数表达式，能够立即执行
作用：需要立即得到函数的值时使用隔离作用域，防止污染全局变量。-
求n!，用递归来实现
function fn(n) {
for(i=0;i<=n;i++) {
var a=1;
a=(i+1)*a;
}
console.log('a')
return a;
}
是使用递归：
function clc（n） {
if(n==1) return n;
else {return n*clc(n-1)}
}
update 📌 2017.11.13
let clc=n=>{
return n>1?n*clc(n-1):1
}
clc(7) //5040
-
以下代码输出什么？
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 sex: 小谷 3 name:valley getInfo('男'); name: age: sex:男 男 name:valley 写一个函数，返回参数的平方和？
function sumOfSquares(a,b,c) {
if(!!a){a=aa;}
else
{if(!!b){b=bb; console.log(a+b)}
else{if(!!c){c=c*c; console.log(a+b+c)}
}
function sumOfSquares( ){
var result=0;
for(i=0;i<arguments.length;i++){
result=result+arguments[i]*arguments[i];
}
return result;
}
var result = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result) //29
console.log(result) //10如下代码的输出？为什么
console.log(a);
var a = 1;
console.log(b);
undefined
underfined
报错
因为变量声明提前，所以a为undefined；而b没有进行过声明，直接报错js解释器直接返回值为undefined如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name);
}
var sayAge = function(age){
console.log(age);
};
hello world
10函数的表达式声明必须放在调用的前面。香蕉皮
函数的调用-
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
过程：
1. global context： {
AO: {x:10;
foo: function;
bar: function;
}
scope: null;
}
foo[scope]: global context:AO
bar[scope]:global context:AO
2. barcontext: {
AO: { x: 30;} scope:global context:AO }
结果： 10
-
如下代码输出什么? 写出作用域链查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
解释：1.global context ={ AO: {x:10; bar(); } scope:null; } bar[scope]:global context.AO; 2. barcontext: { AO:{ x: 30; foo:function;} barscope=global context.AO; 3. foofunction: { AO: { {} scope:fooscope=barcontext.AO; }
结果：
30
13 . 以下代码输出什么? 写出作用域链的查找过程伪代码
var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
解释：
1.global context: {
AO:{ x:10;
bar:function;
}
scope:null
}
bar.[[scope]]=globalcontext.AO;
2.barfunction: {
AO:{
x:30;
}
bar.[[scope]]=globalcontext:AO;
结果：30
-
以下代码输出什么？ 写出作用域链查找过程伪代码
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)
过程：
global context={
AO: { a:1;
fn:function;
fn3:function;
},
scope: null;
}
fn.[[scope]]=globalcontext.AO;
fn3.[[scope]]=globalcontext.AO;
2.fncontext={
AO: { a：undefined;
fn2:function;
},
scope:fn.[[scope]];
}
fn2.[[scope]]=fncontext.AO;
3. fn2context={
AO: { {} },
scope:fn2.[[scope]]
}
4.fn3context={
AO: { {} },
scope:fn3.[[scope]]
}
结果：
undefined
5
1
6
20
200
