立即执行函数表达式是什么？有什么作用
(function (){})()
作用：
- 令函数中声明的变量绕过变量声明前置规则
- 避免新变量被解释成全局变量或函数名占用全局变量名的情况
- 在禁止访问函数内变量声明的情况下允许外部对函数的调用
// 写法一
var tmp = newData;
processData(tmp);
storeData(tmp);
// 写法二
(function (){
var tmp = newData;
processData(tmp);
storeData(tmp);
}());
上面代码中，写法二比写法一更好，因为完全避免了污染全局变量。
求n!，用递归来实现
function fact(n){
if(n == 1){ return 1
}
return n*fact(n-1)
}
console.log(fact(n))
此方法写法简单，逻辑清晰，但效率低。
以下代码输出什么？
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:男 (3)["饥人谷",2,"男"] name valley
getInfo('小谷', 3); //name:小谷 age:3 sex:undifined (2)["小谷",3] name valley
getInfo('男'); //name:男 age:undifined sex:undifined (1)["男"] name valley
写一个函数，返回参数的平方和？
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);
var a = 1;
console.log(b);
输出undifined和报错。因为变量a声明提升并初始化为undefined，此时打印a为undefined。变量b没有声明故报错。
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name); //hello world
}
var sayAge = function(age){
console.log(age); //报错：sayAge is not a function
};
因为sayName函数声明提升；因为sayAge是函数表达式，使用前必须赋值，而函数声明放在了调用的后面，此时函数还不存在，所以会报错
如下代码输出什么? 为什么
var x = 10
bar() //10
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
输出10。
1.首先foo()和bar()函数的声明会被提前，因此bar()可以正常执行
2.接着bar()调用了foo()，而foo()输出了个x
- foo函数未执行时要得到x的值，首先在自身作用域中查找有无x变量，没有则向外层作用域，本例中即全局作用域中查找，既为10。
如下代码输出什么? 为什么
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出30。调用foo函数时，foo函数先在自身作用域中查找变量x，没有找到于是依次向外层查找，在bar函数中找到了x值为30，找到了就不再继续向外查找，控制台打印30。
如下代码输出什么? 为什么
var a = 1
function fn1(){
function fn2(){
console.log(a)
}
function fn3(){
var a = 4
fn2()
}
var a = 2
return fn3
}
var fn = fn1()
fn() //输出多少
输出2。原因：fn1运行后返回fn3，fn3运行时调用fn2，fn2中要打印变量a，所以要查找变量a，但fn2中没有定义该变量所以向外层fn1查找，找到了变量a的值为2，打印2。
如下代码输出什么? 为什么
var a = 1
function fn1(){
function fn3(){
var a = 4
fn2()
}
var a = 2
return fn3
}
function fn2(){
console.log(a)
}
var fn = fn1()
fn() //输出多少
输出1。原因：函数最终结果与在哪执行无关，只与初始所在环境有关，在fn3中调用函数fn2，fn2首先会在自身作用域中查找变量a，没找到于是在全局中查找，找到了var a=1，打印1。
如下代码输出什么? 为什么
var a = 1
function fn1(){
function fn3(){
function fn2(){
console.log(a)
}
fn2()
var a = 4
}
var a = 2
return fn3
}
var fn = fn1()
fn() //输出多少
输出undifined。原因：调用函数fn1，返回函数fn3，接下来调用fn3执行函数体，首先声明函数fn2，变量声明提前，a初始化为undefined，运行函数fn2，fn2首先会在自身作用域中查找变量a，没找到于是向外层fn3中查找，找到a值为undefined，打印undefined。如果var a=4在函数fn2调用之前打印结果就是4。
如下代码输出什么? 为什么
var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2); //false
console.log(obj1 = obj2); //{a:1,b:2}
console.log(obj1 == obj2); //true
对象的相等，当且仅当他们的引用指向内存中的相同区域时才相等，即他们在栈内存中的引用地址相同
obj1和obj2分别是两个不同的对象引用，里面存放的地址是不同的，即他们指向的区域是不同的，即使区域中的内容是一样的也不相等
而把通过obj1=obj2，将obj2中存放的地址赋给了obj1之后，obj1和obj2指向了同一块区域，所以最后两者相等了.
如下代码输出什么? 为什么
var a = 1
var c = { name: 'jirengu', age: 2 }
function f1(n){
++n
}
function f2(obj){
++obj.age
}
f1(a)
f2(c)
f1(c.age)
console.log(a) //1
console.log(c) //{name:'jirengu',age:3}
原因：首先a 是 非引用类型， 进入函数后，相当于在函数里， var n = a，赋值给了 n，已经和最初的 a 没有关联了。 所以 输出 1
但是 由于 c 是对象， 是引用类型，所以最后引起了 c.age 的变化。
写一个深拷贝函数
var obj = {
name: 'ruoyu',
sex: 'male',
age: 30,
friend: {
name: 'hello',
age: 100
}
}
function deepCopy(oldobj){
var newobj = {};
for(var key in oldobj ){
if(typeof oldobj[key] === 'object'){
newobj[key] = deepCopy(oldobj[key]);
}else {newobj[key] = oldobj[key];}
}
return newobj;
}
var obj2 = deepCopy(obj1)
console.log(obj2)
通过下面的方法，可以为函数的参数设置默认值。
function f(a) {
(a !== undefined && a !== null) ? a = a : a = 1;
return a;
}
f() // 1
f('') // ""
f(0) // 0