js的函数定义详解编程语言

1.函数

　　1.1函数定义

注意：

函数只能返回一个值，如果要返回多个值，只能将其放在数组或对象中返回。

　　function foo(a, b) { //function是函数定义关键字，foo是函数名

　　　　console.log(a);

　　　　console.log(b);

　　　　return a+b;

　　}

// 普通函数定义 
function f1() { 
  console.log("Hello world!"); 
} 
 
// 带参数的函数 
function f2(a, b) { 
  console.log(arguments);  // 内置的arguments对象 
  console.log(arguments.length); 
  console.log(a, b); 
} 
 
// 带返回值的函数 
function sum(a, b){ 
  return a + b; 
} 
sum(1, 2);  // 调用函数 
 
// 匿名函数方式 
var sum = function(a, b){ 
  return a + b; 
} 
sum(1, 2); 
 
// 立即执行函数 
(function(a, b){ 
  return a + b; 
})(1, 2);

　　1.2函数调用

　　var ret = foo(11, 22);

2.匿名函数

var func = function(a, b) { 
     console.log("a: ", a); 
     console.log("b: ", b); 
     return a+b;     
};
// 调用
func(11, 22);

3.立即执行函数

先写下两个（function (a,b) {…}）（实参1，实参2）

(function (a, b) {

console.log(“立即执行函数”)；

console.log(a+b);

}) (11, 22);

4.函数的形参

func(11, 22)

arguments –> [11, 22] arguments[0] arguments[1]

function add(a,b){ 
  console.log(a+b); 
  console.log(arguments.length) 
} 
 
add(1,2) 
 
输出： 
3 
2

补充：

ES6中允许使用“箭头”（=>）定义函数。

var f = v => v; 
// 等同于 
var f = function(v){ 
  return v; 
}

如果箭头函数不需要参数或需要多个参数，就是用圆括号代表参数部分：

var f = () => 5; 
// 等同于 
var f = function(){return 5}; 
 
var sum = (num1, num2) => num1 + num2; 
// 等同于 
var sum = function(num1, num2){ 
  return num1 + num2; 
}

5. 作用域

函数的全局变量和局部变量

局部变量：

在JavaScript函数内部声明的变量（使用 var）是局部变量，所以只能在函数内部访问它（该变量的作用域是函数内部）。只要函数运行完毕，本地变量就会被删除。

全局变量：

在函数外声明的变量是全局变量，网页上的所有脚本和函数都能访问它。

变量生存周期：

JavaScript变量的生命期从它们被声明的时间开始。

局部变量会在函数运行以后被删除。

全局变量会在页面关闭后被删除。

作用域

1. 函数的调用要往回找函数的定义阶段
2. 首先在函数内部找 -> 内部找不到就往外找,直到找到全局为止

几个例子：

var city = "BeiJing"; 
function f() { 
  var city = "ShangHai"; 
  function inner(){ 
    var city = "ShenZhen"; 
    console.log(city); 
  } 
  inner(); 
} 
 
f();  //输出结果是ShenZhen

var city = "BeiJing"; 
function Bar() { 
  console.log(city); 
} 
function f() { 
  var city = "ShangHai"; 
  return Bar; 
} 
var ret = f(); 
ret();  // 打印结果是BeiJing

3.闭包

var city = "BeiJing"; 
function f(){ 
    var city = "ShangHai"; 
    function inner(){ 
        console.log(city); 
    } 
    return inner; 
} 
var ret = f(); 
ret(); //ShangHai

6.函数的词性分析

JavaScript中在调用函数的那一瞬间，会先进行词法分析。

词法分析的过程：

当函数调用的前一瞬间，会先形成一个激活对象：Avtive Object（AO），并会分析以下3个方面：

1:函数参数，如果有，则将此参数赋值给AO，且值为undefined。如果没有，则不做任何操作。
2:函数局部变量，如果AO上有同名的值，则不做任何操作。如果没有，则将此变量赋值给AO，并且值为undefined。
3:函数声明，如果AO上有，则会将AO上的对象覆盖。如果没有，则不做任何操作。

函数内部无论是使用参数还是使用局部变量都到AO上找。

看两个例子：

6.1. 分析(分析的函数内部变量定义过程)
　　6.1.1. 先看参数
　　6.1.2. 看有没有局部变量
　　6.1.3. 看有没有函数定义
6.2. 执行(实际执行代码)

var age = 18;     
// 函数调用前的词法分析 
function foo(){   //第一步，先看参数，无 
     console.log(age); 
     var age = 22;  // 第二步，看有没有局部变量，AO.age=undefined 
     console.log(age);    // 第三步，看有没有函数定义 
} 
foo(); // 先打印出undefined 再打印出22

var age=18; 
function foo() { 
   console.log(age); 
   var age=22; 
   console.log(age); 
   function age() { 
      console.log("呵呵")； 
}   
   console.log(age); 
} 
 
foo();     // 执行后的结果是

//ƒ age(){
//console.log(“呵呵”);
//}
//22
//22

// 1.先分析，给AO赋值
// var age = 22; ---> AO.age=undefined;
// function age() { console.log("呵呵");} ---> AO.age=function() {...};

// 2. 真正执行阶段,就去AO上找
//function() {...}
//22
//22

词法分析过程： 
1、分析参数，有一个参数，形成一个 AO.age=undefine; 
2、分析变量声明，有一个 var age, 发现 AO 上面已经有一个 AO.age，因此不做任何处理 
3、分析函数声明，有一个 function age(){...} 声明， 则把原有的 age 覆盖成 AO.age=function(){...}; 
 
最终，AO上的属性只有一个age，并且值为一个函数声明 
 
执行过程： 
注意：执行过程中所有的值都是从AO对象上去寻找 
 
1、执行第一个 console.log(age) 时，此时的 AO.age 是一个函数，所以第一个输出的一个函数 
2、这句 var age=22; 是对 AO.age 的属性赋值， 此时AO.age=22 ，所以在第二个输出的是 2 
3、同理第三个输出的还是22, 因为中间再没有改变age值的语句了

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/18173.html

js的函数定义详解编程语言

函数的全局变量和局部变量

作用域

相关推荐

发表回复