js函数

函数声明和函数表达式有什么区别

函数声明:

function name(params) {
    console.log("say hello~");
}

函数表达式:

var sayHello = function(params) {
    console.log("say hello~");
}

JavaScript 解释器中存在一种变量声明被提升的机制，也就是说函数声明会被提升到作用域的最前面，即使写代码的时候是写在最后面，也还是会被提升至最前面。
而用函数表达式创建的函数是在运行时进行赋值，且要等到表达式赋值完成后才能调用

什么是变量的声明前置？什么是函数的声明前置

变量的前置声明:JavaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，然后给他初始值undefined，然后才逐句执行程序，这就叫做“变量提升”，也即“变量的声明前置”。
函数的声明前置JavaScript引擎将函数名视同变量名，所以采用function声明函数时，整个函数会像var声明变量一样，被提升到代码头部

arguments 是什么

arguments是一个类数组对象, 代表传给一个function的参数列表, 只在函数内部起作用; arguments的值与函数传入参数有关, 与定义参数无关。
可以使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数的条目，第一个条目的索引从0开始。例如，如果一个函数传递了三个参数，你可以以如下方式引用他们：

arguments[0]
arguments[1]
arguments[2]

参数也可以被设置：
arguments[1] = 'new value';

arguments对象不是一个 Array 。它类似于Array，但除了长度之外没有任何Array属性

arguments.callee指向当前执行的函数。
arguments.caller指向调用当前函数的函数。
arguments.length指向传递给当前函数的参数数量。
arguments[@@iterator]返回一个新的Array迭代器对象，该对象包含参数中每个索引的值。

函数的"重载"怎样实现

根据函数内建变量arguments的length属性来实现:

function overLoading() {
　　// 根据arguments.length，对不同的值进行不同的操作
　　switch(arguments.length) {
　　　　case 0:
　　　　　　/*操作1的代码写在这里*/
　　　　　　break;
　　　　case 1:
　　　　　　/*操作2的代码写在这里*/
　　　　　　break;
　　　　case 2:
　　　　　　/*操作3的代码写在这里*/　　　　　　
　　//后面还有很多的case......
}
}

立即执行函数表达式是什么？有什么作用

在定义函数之后，立即调用该函数, 为了避免function出现在行首, 引起JS解析错误, 让JS引擎将其理解成一个表达式,这就叫做"立即执行的函数表达式
常见的实现如下:

(function name() {
    do something;
})();

(function wahah() {
    console.log('wahahah');
}());

var aa = function() {
    console.log("wahha");
}();

主要用于隔绝作用域。因为其创建了一个新的函数作用域，从而不去污染全局命名空间。

求n!，用递归来实现

function n(x) {
    if(x < 2){
        return 1;
    }else if(x < 0){
        return
    }
    else {
        return x * arguments.callee(x - 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: 男
{ '0': '饥人谷', '1': 2, '2': '男' }
name valley

getInfo('小谷', 3);
name: 小谷
age: 3
sex: undefined
{ '0': '小谷', '1': 3 }
name valley

getInfo('男');
name: 男
age: undefined
sex: undefined
{ '0': '男' }
name valley

写一个函数实现返回参数的平方和

function sumOfSquares() {
    var res = 0;
    for (var i = 0; i < arguments.length; i++) {
        res += arguments[i] * arguments[i];        
    }
    return res;
}
var sum = sumOfSquares(1,2);
console.log(sum);

如下代码的输出？为什么

console.log(a); //undefined, 变量声明会前置，并赋值undefined
var a = 1;
console.log(b); //报错, b未声明

如下代码的输出？为什么

sayName('world');
sayAge(10);
function sayName(name){
    console.log('hello ', name);
}
var sayAge = function(age){
    console.log(age);
};

输出显示:
hello world
报错:sayAge is not a function
第二行报错是因为sayAge是函数表达式，而函数表达式要先声明后调用

如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10
bar() 
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
  foo()
}

输出: x = 10
作用域链查找伪代码:

globalContext = {
    ActiveObject:{
        x:10
        foo:function
        bar:fucntion
    }
    scope: null
}
声明foo: foo.[[scope]] = globalContext.ActiveObject
声明bar: bar.[[scope]] = globalContext.ActiveObject

barContext = {
    ActiveObject:{
        x:30
        foo:function
    }
    scope: globalContext.ActiveObject
}
fooContext = {
    ActiveObject: {

    }
    scope: globalContext.ActiveObject
}

如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}   

输出: x = 30
作用域链查找:

globalContext = {
    ActiveObject:{
        x:10
        bar:function
    }
    scope: null
}
barContext = {
    ActiveObject:{
        x:30
        foo:function
    }
    scope:globalContext.ActiveObject
}
fooContext = {
    ActiveObject:{

    }
    scope: barContext.ActiveObject
}

以下代码输出什么? 写出作用域链的查找过程伪代码

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}

输出: x = 30
作用域链查找:

globalContext = {
        AO: {
            x: 10
            bar:function
        }
        scope: null
}
bar.[[scope]] = globalContext.AO
barContext = {
        AO: {
            x: 30
            function
        }
        scope = globalContext.AO
}
function.[[scope]] = barContext.AO
functionContext = {
        AO: {}
        scope = barContext.AO
 }

以下代码输出什么？ 写出作用域链查找过程伪代码

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)

输出: undefind 5 1 6 20 200
作用域链查找:

globalContext = {
    ActiveObject:{
        a: 200
        fn:function(){}
        fn3:function(){}
    }
    scope: null
}
fn.[[scope]] = globalContext.ActiveObject
fn3.[[scope]] = globalContext.ActiveObject

fnContext = {
    ActiveObject:{
        a: 20
        fn2: function(){}
    }
    scope: globalContext.ActiveObject
}
fn2.[[scope]] = fnContext.ActiveObject

fn3Context = {
    ActiveObject：{}
    scope: globalContext.ActiveObject
}
fn2Context = {
    ActiveObject:{}
    scope: fnContext.ActiveObject
}