函数与作用域

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

函数声明和函数表达式都是声明函数的方式

  • 区别1 写法：
    函数声明 ： function 函数名(){}
    函数表达式： var 变量名 = function(){}
  • 区别2 声明、调用顺序：
    函数声明: 没有前后区别 ，声明不必放在调用前面
    函数表达式：　声明必须放在调用前面
  • 区别３　声明前置
    函数声明：var 声明的变量和function声明的函数会提前
    函数表达式： 不需要声明提前，函数表达式和 var 变量 没有什么区别，先有再用。
    函数表达式必须在表达式执行完后，函数才存在并可以被调用。
2. 什么是变量的声明前置？什么是函数的声明前置
声明前置 就是在一个作用域中，前置到当前作用域的头部
  • 变量的声明前置： 在一个作用域中，所有的变量的声明放在当前作用域的头部位置
  • 函数的声明前置： 在一个作用域中，函数的声明会被放在当前作用域的头部位置处先执行。而函数内部的声明前置则指的是在执行该函数里面的语句的时候，声明会被首先执行。
3. arguments 是什么

在函数的内部使用arguments对象，获取到函数的所有传入参数
可以通过arguments[ 数组下标]求属性值 ，数组长度 arguments.length

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

c和c++ 语言中的函数的重载，可有相同重复的函数名，函数名为不同数据类型，不被覆盖。
调用时不同参数会自动匹配对应函数，如参数都为整数，传对应的整型函数中

  • js中没有重载，多个相同函数名的函数会被覆盖
    但可以模仿重载的功能
  • 在一个函数体内，针对不同的参数调用执行相应的逻辑

function fn(name,age,sex){//在fn函数体中， if语句为执行的不同的逻辑
if(name){
console.log(name);
}
if(age){
console.log(age);
}
if(sex){
console.log(sex);
}
}
fn('juan',34);//不同的参数
fn('yuekai',24,'女');

5. 立即执行函数表达式是什么？有什么作用
  • 立即执行函数表达式: 定义的（匿名）函数立即执行

*普通定义的函数只能在调用时 才执行，而立即执行函数表达式可以让这个函数立即执行，不需要等待调用

  • 生成一个独立的作用域，这个作用域里的变量函数外访问不到
6. 求n!，用递归来实现
递归的终止条件是n===1,但是也要考虑到 n===0的情况 ，万一n为0。因为1!====0!,所以这两种也特殊情况，1！又是终止条件

function fn(n){
if(n>=0){
if(n===0 || n===1){
return 1;
}
}
return n* fn(n-1);
}
fn(5);

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, '男');
依次输出：

name: 饥人谷

age： 2
sex： 男
["饥人谷", 2, "男", callee: function, Symbol(Symbol.iterator): function]
name valley
没有return，函数默认返回 underfined

getInfo('小谷', 3);

name: 小谷
age: 3
sex: undefined
["小谷", 3, callee: function, Symbol(Symbol.iterator): function]
name valley
undefined（同上）

getInfo('男');

name: 男

age: undefined
sex: undefined
["男", callee: function, Symbol(Symbol.iterator): function]
name valley
undefined

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

function sumOfSquares(a,b,c){
var sum=0;
for(var i=0 ; i<arguments.length; i++){
sum += arguments[i]*arguments[i];
}
console.log(sum);
}
var result = sumOfSquares(2,3,4);

var result2 = sumOfSquares(1,3);
console.log(result) //29
console.log(result2) //10

9. 如下代码的输出？为什么
>console.log(a);  // underfined      var a变量声明前置
var a = 1;   
console.log(b);  // b is not defined   没有这个b变量
10. 如下代码的输出？为什么
>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   
};
  1. 如下代码输出什么? 写出作用域链查找过程伪代码
    var x = 10
    bar()
    function foo() {
    console.log(x) // 输出10
    }
    function bar(){
    var x = 30
    foo()
    }

输出10

  1. globalcontext = {
    AO:{
    x: 10;
    foo: function(){}
    bar: function(){} }
    }
    foo.[[scope]] = globalcontext.AO;
    bar.[[scope]] = globalcontext.AO;
  2. barcontext = {
    AO:{
    x: 30;
    },
    scope: globalcontext.AO;
    }
  3. foocontext = {
    AO: {}
    scope: globalcontext.AO;
    }
  1. 如下代码输出什么? 写出作用域链查找过程伪代码
    var x = 10;
    bar()
    function bar(){
    var x = 30;
    function foo(){
    console.log(x)
    }
    foo();
    }

输出 30

  1. globalcontext= {
    AO:{
    x: 10;
    bar: function(){}
    }
    }
    bar[[scope]] =globalcontext.AO;

  2. barcontext = {
    AO:{
    x:30；
    foo： function(){}
    }
    scope: bar.[[scope]]=globalcontext.AO;
    }
    foo[[scope]] = barcontext.AO;

  3. foorcontext= {
    AO:{}
    scope: foo.[[scope]]=barcontext.AO;
    }

  1. 以下代码输出什么? 写出作用域链的查找过程伪代码
    var x = 10;
    bar()
    function bar(){
    var x = 30;
    (function (){
    console.log(x)
    })()
    }
    输出 30
    1.globalcontext= {
    AO:{
    x: 10;
    bar: fiunction(){}
    }
    scope:
    }
    bar.[[scope]] = globalcontext.AO;
    2.barcontext = {
    AO:{
    x: 30;
    function：function(){}
    }

}
function.[[scope]] =globalcontext.AO;

  1. functioncontext= {
    AO:{}
    scope: function.[[scope]]=barcontext.AO;
    }
  1. 以下代码输出什么？ 写出作用域链查找过程伪代码
    var a = 1;
    function fn(){
    console.log(a) // underfined
    var a = 5
    console.log(a) // 5
    a++
    var a
    fn3()
    fn2()
    console.log(a)
    function fn2(){
    console.log(a) //6
    a = 20 // a:20
    }
    }
    function fn3(){
    console.log(a) //1
    a = 200 //a:200
    }
    fn()
    console.log(a)
  1. globalcontext= {
    AO:{
    a: 1;
    fn: function(){};
    fn3: function(){};

}
}
fn.[[scope]]=globalcontext.AO;
fn3.[[scope]]= globalcontext.AO;

  1. fncontext= {
    AO:{
    a: underfined;// 5 6
    fn2: function(){};
    }
    scope: globalcontext.AO;
    }
    fn2.[[scope]]= fncontext.AO;

  2. fn3comtext= {
    AO:{}
    scope: globalcontext.AO;
    }

  3. fn2context={
    AO:{}
    scope: fncontext.AO;
    }
    输出
    underfined
    5
    6
    1
    20
    200

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 函数与作用域
    1. 函数声明和函数表达式有什么区别 使用function关键字声明一个函数时，声明不必放到调用的前面。//函数声...
    _李祺阅读 281评论 0赞 0
  • 函数与作用域
    1，函数声明和函数表达式有什么区别 1、背景介绍 定义函数的方法主要有三种： 1：函数声明(Function De...
    进击的前端_风笑影阅读 453评论 0赞 0
  • 进阶任务3（主线任务）：函数与作用域
    任务 函数声明和函数表达式有什么区别答：函数声明：function functionName(){}  函数表达式...
    mhy_web阅读 422评论 0赞 0
  • 函数与作用域
    1.函数声明和函数表达式有什么区别。 函数声明使用function来进行声明，函数声明提升，所以不论执行语句的位置...
    Rising_suns阅读 307评论 0赞 0
  • JS-函数与作用域
    JavaScript中的函数运行在它们被定义的作用域里，而不是它们被执行的作用域里。 函数声明和函数表达式有什么区...
    毕子歌阅读 419评论 0赞 0