js-函数与作用域

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

• 函数声明:定义一个具有指定参数的函数,函数声明最重要的特征就是函数声明提升，意思是在执行代码之前就会读取函数声明.

sayHi();
function sayHi(){
    alert("hi world");
}
//不会报错，因为函数声明在sayHi()在函数sayHi()之前已经读取

name :函数名
param:要传递给函数的参数的名称。不同引擎中的最大参数数量不同。一个函数最多有255个参数
statements:包含函数体的语句。
描述:
一个被函数声明创建的函数是一个 Function 对象，具有 Function 对象的所有属性、方法和行为。
参考

• 函数表达式
  用函数表达式定义的函数在使用之前必须先赋值

sayHi();
var sayHi = function() {
    alert("hi wrold");
}
//报错，函数sayHi()调用之前并未赋值

• 区别
  1 函数表达式定义的函数在使用之前必须先赋值,而函数声明不必.
  2 函数表达式与函数声明的最主要区别是函数名称（function name），在函数表达式中可忽略它，从而创建匿名函数.

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

• 变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明

1 var a = 1;
2 function main() {
3     console.log(a);//1
4 }
5 main();//输出1

1 var a = 1;
2 function main() {
3     console.log(a);
4     var a = 2;
5 }
6 main()//输出undefined

为什么输出undefined,因为脚本在执行的时候会自动将变量声明前置

参考

• 函数的声明前置:在一个作用域下，同var 声明的变量一样，function 声明的函数也会前置。函数的声明前置优先级高于变量的声明前置。

var a = 3;
console.log(a); //3
sayHello();
function sayHello(){
  console.log('hello');//hello
}

执行时语句顺序如下：
var a
function sayHello(){}
console.log(a);//undefined
a=3
console.log(a); //3
sayHello();

3 arguments 是什么?

• arguments对象是所有函数中可用的局部变量,你可以使用arguments对象在函数中引用函数的参数。此对象包含传递给函数的每个参数的条目，第一个条目的索引从0开始。例如，如果一个函数传递了三个参数，你可以参考它们如下：

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

参数也可以被设置:
arguments[1] = 'new value';
arguments对象不是一个 Array它类似于数组

4 函数的"重载"怎样实现?

• Javascript中，先定义的函数，可以被后定义的函数覆盖。因此Javascript不支持函数的重载。比如下面的例子：

<script type="text/javascript">  
       function p(a, b, c) {  
           alert(a+b+c);  
       }  
 
       function p(a, b) {  
           alert(a+b);  
       }  
       p(1,2,3);//alert 3;  
   </script>  

虽然有函数p(a, b, c)，但是由于语言的特性，该函数被后面的p(a,b)所覆盖

• 但是利用js的arguments，可以实现JavaScript的重载。

    function showMessage(){
         if(arguments.length==1){
             console.log(arguments[0]);
         }else if( arguments.length==2){
             console.log(arguments[0]+"说:"+arguments[1]);
         }else{
             return false;
         }
     }
    showMessage("Hi!");
    showMessage("张三","Hi 你好"); 

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

• 我们需要在定义函数之后，立即调用该函数.这时不能在函数的定义之后加上圆括号，这会产生语法错误.

function(){ /* code */ }();
// SyntaxError: Unexpected token 

产生这个错误的原因是，function这个关键字即可以当作语句，也可以当作表达式。

// 语句
function f() {}
// 表达式
var f = function f() {}

为了避免解析上的歧义，JavaScript引擎规定，如果function关键字出现在行首，一律解释成语句。因此，JavaScript引擎看到行首是function关键字之后，认为这一段都是函数的定义，不应该以圆括号结尾，所以就报错了。
解决方法就是不要让function出现在行首，让引擎将其理解成一个表达式。最简单的处理，就是将其放在一个圆括号里面。

• 通常情况下，只对匿名函数使用这种“立即执行的函数表达式”。
  它的目的有两个：一是不必为函数命名，避免了污染全局变量；二是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。

// 写法一
var tmp = newData;
processData(tmp);
storeData(tmp);

// 写法二
(function (){
  var tmp = newData;
  processData(tmp);
  storeData(tmp);
}());
上面代码中，写法二比写法一更好，因为完全避免了污染全局变量。

6 求n!，用递归来实现

function jiechen(n) {
      if(n === 1){
      return 1;
    }
    return  n * jiechen(n-1);
}
 jiechen(4);//24

7 以下代码输出什么？

    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, '男');
getInfo('小谷', 3);
getInfo('男');

输出:

name: 饥人谷
age: 2
sex: 男
["饥人谷", 2, "男"]
name valley

name: 小谷
age: 3
sex: undefined
["小谷", 3]
name valley

name: 男
age: undefined
sex: undefined
["男"]
name valley
undefined

8 写一个函数，返回参数的平方和？

  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

9 如下代码的输出？为什么

    console.log(a);
    var a = 1;
    console.log(b);

输出:
undefined //原因:变量声明前置var a; 
"error" //没有声明变量b

10 如下代码的输出？为什么

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

输出:
"hello  world"

"error"  //报错原因:函数表达式定义的函数在使用之前必须先赋值.
改为如下:
var sayAge = function(age){
        console.log(age);
    };
sayAge(10);

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

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


原因:
全局作用域: {
   可使用变量:   x : 10
   可使用的函数:  foo() , bar() 
}

foo()作用域: {
  可使用变量:   x : 10
}
bar()作用域: {
 可使用变量:   x : 30
 可使用的函数:  foo()
}
运行逻辑:
先申明全局变量 x = 10;
执行bar()函数;
申明一个仅在bar()作用域内访问的局部变量x=30;
执行foo()函数,执行console.log(x)方法;
但没在当前作用域下找到�x变量,但全局作用域的x=10可以使用,完成输出;

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

var x = 10;
bar();
function bar(){
  var x = 30;
  function foo(){
    console.log(x);//此处输出30
  }
  foo();
}   
输出:30


原因:
全局作用域: {
   可使用变量:   x : 10
   可使用的函数:   bar() 
}

foo()作用域: {
  可使用变量:   x : 10
}
bar()作用域: {
 可使用变量:   x : 30
 可使用的函数:  foo()
}
运行逻辑:
运行bar()-->运行 foo(), 找到可使用的局部变量x=30,输出x=30;

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

var x = 10;
bar(); 
function bar(){
  var x = 30;
  (function (){
    console.log(x);
  })();
}
输出:30
原因:
因为是立即调用函数所以上面代码等价于下面的:
var x = 10;
bar(); 
function bar(){
  var x = 30;
  function fn(){
    console.log(x);
  };
  fn();
}
全局作用域{
可用变量:x=10 ;
函数:bar()
}
bar()作用域{
可用变量 x=30
函数:fn()
}

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

var a = 1;

function fn(){
  console.log(a);//第一次输出:undefined:因为下面  var a = 5;所以提前申明了var a ;找不到a报错.
  var a = 5;
  console.log(a);//第二次输出5:因为在当前作用域下找到了a=5;
  a++;//a=6
  var a;
  fn3();
  fn2();
  console.log(a);//第五次输出:20,因为a的值已经在调用fn2()时被修改.

  function fn2(){
    console.log(a);//第四次输出:6,因为这作用域里没有var a 申明 ,去上一级即fn()里作用域找,此时a++后,a=6.所以输出6.
    a = 20;//  给fn()里的变量a赋值为20.并保存在内存里
  }
}

function fn3(){
  console.log(a);// 第三次输出:1,因为fn3()属于全局函数,这里没var a,就去全局找到var a =1
  a = 200; //找到了全局a ,在这一步给全局变量a 赋值为200.并保存在内存里.
}

fn();
console.log(a);//第六次输出:200,因为去全局找,而a的值已经在调用fn3()时被修改.

输出:
undefined
5
1
6
20
200

原因:
全局作用域{
  可用变量: a = 1
  可用函数: fn() ; fn3(); ;
}
fn()作用域内{
  可用变量: a =5; 
  可用函数:fn2()
}
fn2()作用域内{
  可用变量: a =20
}
fn3()作用域内{
  可用变量: a=200
}
运行逻辑:
代码//后内容:为解释