立即执行函数表达式是什么？有什么作用？
立即执行函数表达式
即执行函数(Immediate Functions)
立即执行函数模式是一种语法，可以让你的函数在定义后立即被执行，这种模式本质上就是函数表达式(命名的或者匿名的)，在创建后立即执行
立即执行函数表达式的作用
Javascript中没有私有作用域的概念，如果在多人开发的项目上，你在全局或局部作用域中声明了一些变量，可能会被其他人不小心用同名的变量给覆盖掉
根据javascript函数作用域链的特性，可以使用这种方式可以模仿一个私有作用域，用匿名函数作为一个“容器”，“容器”内部可以访问外部的变量，而外部环境不能访问“容器”内部的变量，所以( function(){…} )()内部定义的变量不会和外部的变量发生冲突，俗称“匿名包裹器”或“命名空间”。
求n!，用递归来实现
function factorial(n){
if(n === 1 || n === 0){
return 1
}
else{
return n * factorial(n - 1)
}
}
factorial(n)输出即可
// 鉴于'0! === 1' ,所以if中加入了'n === 0'的条件以应对当输入参数为0的时候
以下代码输出什么？
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:undefined
['小谷', 3]
name 'valley'
getInfo('男');输出结果如下
name:'男'
age:undefined
sex:undefined
['男']
name 'valley'
写一个函数，返回参数的平方和？
function sumOfSquares(){
var sum = 0
for(var i = 0; i < arguments.length; i++){
sum += arguments[i]*arguments[i]
}
return sum
}
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);
由于声明提前，实际上的执行顺序是
var a
console.log(a);
a = 1;
console.log(b);
输出结果为
undefined //提前声明了a，但并没有赋值
"error" //没有声明b变量
"ReferenceError: b is not defined
如下代码的输出？为什么
sayName('world');
sayAge(10);
function sayName(name){
console.log('hello ', name); //输出"hello world"，因为sayName函数声明提前，可以正常调用
}
var sayAge = function(age){
console.log(age); //输出"error" "TypeError: sayAge is not a function，因为在调用sayAge时，他还不是函数，还未将函数表达式赋值给sayAge
};
如下代码输出什么? 为什么
var x = 10
bar()
function foo() {
console.log(x)
}
function bar(){
var x = 30
foo()
}
console.log(x)的输出结果应为10
因为执行的是foo函数中的内容，所以这个x会现在foo的函数作用域中寻找x，寻找未果，向上一层作用域寻找，即找到了x=10，所以输出结果为10
如下代码输出什么? 为什么
var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出结果为30.理由同上，从foo作用域找到bar作用域找到x=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，理由同上，console.log(a)在fn2作用域找a未果，去fn1作用域找到了
如下代码输出什么? 为什么
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，同上，console.log(a)先从fn2里面找a未果，去上一层找，全局变量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()
输出为undefined，因为console.log(a)从fn2中找a无果，从fn3中找，fn3中变量声明提前，a首先被初始化成undefined，所以输出为undefined
如下代码输出什么？为什么
var obj1 = {a:1, b:2};
var obj2 = {a:1, b:2};
console.log(obj1 == obj2); //false 虽然看似相同，但是在对象声明的时候，obj12分别指向堆内存中不同的地址，所以不同
console.log(obj1 = obj2); // 将obj2赋值给obj1，也就是此后obj1、2指向堆内存中同一个地址
console.log(obj1 == obj2); //true 由上得出应为true
如下代码输出什么? 为什么
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 因为没有赋值操作，++a只是在f1函数作用域内自增，不会影响到外部的全局变量a
console.log(c) // name: 'jirengu', age: 3 因为f2中的c是引用类型，会对c中的age进行自增，而f1(c.age)中的age是几本类型，不会影响外层c
写一个深拷贝函数
函数体：
// 其实是照葫芦画瓢..自己理解的还很有限
function deepClone(oldObj) {
var newObj = {}
for(var key in oldObj) {
if(typeof oldObj[key] === 'object') {
newObj[key] = deepClone(oldObj[key])
}else{
newObj[key] = oldObj[key]
}
}
return newObj
}
var a = {
name: 'NinthG',
sex: 'male',
age: 26,
wife: {
name: 'baobao',
age: 26
}
}
var b = deepClone(a)
console.log(a === b)
a.wife.age = 25
console.log(a)
console.log(b)
输出结果
false //深拷贝成功，即a !== b
[object Object] {
age: 26,
name: "NinthG",
sex: "male",
wife: [object Object] {
age: 25, //将25赋值给a.wife.age来改变a
name: "baobao"
}
}
[object Object] {
age: 26,
name: "NinthG",
sex: "male",
wife: [object Object] {
age: 26, //b没有受到a.wife.age重新赋值的影响，拷贝成功
name: "baobao"
}
}
