函数与作用链

2017-03-15 本文已影响0人 Komolei

函数声明和函数表达式有什么区别
区别：~~函数声明就是了一个函数，而函数表达式就是得到一个值。~~函数声明就是使用关键字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

函数与作用链

猜你喜欢

热点阅读