AllinToyou

这个屌丝很懒，什么也没留下！

热门标签

2021-08-05function函数基础2_"(function (n) { i(\"f205\"); a(i(\"66fd\")); var

作者：AllinToyou | 2024-03-21 13:27:00

踩

"(function (n) { i(\"f205\"); a(i(\"66fd\")); var e = a(i(\"11d5\"));"

3.函数的返回值

如果函数中没有写return关键字,那么函数默认返回undefined

<script>
    function f1(){
		var a = 1;
		var b = 2;
	}
	var a = f1();
	console.log(a);
</script>
1
2
3
4
5
6
7
8

如果函数中有return关键字,那么返回的是return后面的值

<script>
	function f1(){
		return'华子';
	}
	var a = f1();
	console.log(a);
</script>
1
2
3
4
5
6
7

如果函数中有return关键字,但是关键字后面没有值,那么返回的是undefined

<script>
	function f3(){
		return;
    }
	var a = f3();
	console.log(a);
</script>
1
2
3
4
5
6
7

如果函数有return,那么return后面的代码不会执行

<script>
	 function f4(){
   	 	return'黄鹤楼';
		console.log(324234);
	}
	var a = f4();
	console.log(a);
</script>
1
2
3
4
5
6
7
8

如果return后面返回多个值,那么返回最后一个数据/值

<script>
	function f5(){
		return 1,2,3,4,5,6;
	}
	var a = f5();
	console.log(a);
</script>
1
2
3
4
5
6
7

案例练习

计算2和3的和

<script>
	function sum(){
		var a = 2;
		var b = 3;
		var c = a + b;
		console.log(c);
	}
	sum();
</script>
1
2
3
4
5
6
7
8
9

输入两个数，返回两个数字的和

<script>
	var num1 = +prompt('输入num1');
	var num2 = +prompt('输入num2');
	function sum(num1,num2){
		return num1 + num2;
	}
	var a = sum(num1,num2);
	console.log(a); 
</script>
1
2
3
4
5
6
7
8
9

返回n到m之间所有数字的和

<script>
	function sum(n,m){
		var a = 0;
		for(i = n; i <= m; i++){
			a += i;
		}
		return a;
	}
	var s = sum(1,100);
	console.log(s);
</script>
1
2
3
4
5
6
7
8
9
10
11

输入两个数,返回两个数中的最大值

<script>
	var num1 = prompt('输入num1');
	var num2 = prompt('输入num2');
	function max(num1,num2){
		return num1 > num2 ? num1 : num2;
	}
	var a = max(num1,num2);
	console.log(a);
</script>
1
2
3
4
5
6
7
8
9

输入三个数,返回三个数中的最大值

<script>
	var num1 = prompt('输入num1');
	var num2 = prompt('输入num2');
	var num3 = prompt('输入num3');
	function max(num1,num2,num3){
		return num1 > num2 ? num1 > num3 ? num1 : num3 : num2 > num3 ? num2 : num3;
	}
	var a = max(num1,num2,num3);
	console.log(a);
</script>
1
2
3
4
5
6
7
8
9
10

输入一个数组,返回数组中所有元素的和

<script>
	var arr = [1,2,3,4,5,6,7];
	function sum(arr){
		var sumArr = 0;   
		for(var i = 0; i < arr.length; i++){
			sumArr += arr[i];
		}
		return sumArr;
	}
	var a = sum(arr);
	console.log(a);
</script>
1
2
3
4
5
6
7
8
9
10
11
12

4.Javascript函数的作用域

1.变量的作用域

变量在程序中可以访问的有效范围,分为全局变量和局部变量

全局变量:在整个页面中都是可见的,可以被自由访问的,在函数外定义的变量
局部变量:技能在声明的函数内部可见,函数外部是不允许访问的.在函数内部定义的变量

2.Javascript局部变量

在函数内部声明的变量,只能在函数内部访问

<script>
    function f1(){
		var a = 1;
		console.log(a);
	}
	f1();
	// a is not defined
	console.log(a);
</script>
1
2
3
4
5
6
7
8
9

3.Javascript全局变量

在函数外部声明的变量,可以在任意位置使用

<script>
	var a = 1;
	console.log(a);			
	function f1(){
		console.log(a);
	}			
	f1();
</script>
1
2
3
4
5
6
7
8

注意:

在函数内部定义的变量,是局部变量,但是如果不加var,那就是全局变量

<script>
    function(){
    	// 声明a,没有加var,a是全局变量
    	a = 1;
	}
	f1();
</script>
1
2
3
4
5
6
7

如果函数内的变量在定义的时候没有加var,但是出现在了形参中,那还是局部变量

<script>
    function(a){
    	// 声明a,没有加var,但是a是形参,a还是局部变量
    	a = 1;
	}
	f1();
</script>
1
2
3
4
5
6
7

总结:
- 如果函数内部出现不带var的变量,先找形参,如果形参有,那就是局部变量
- 如果不带var,形参也没有,那就是全局变量

4.window对象

在js中,默认情况下var声明的全局变量和function声明的全局函数都挂载在window下
在js中,调用window下的属性和方法,可以不写window

如果函数内声明的变量没写var(全局变量),会把其当做window的一个属性

<script>
	// 全局变量
	var a = 1;
	
	//全局函数
	function(){
        //函数里的变量没加var,默认为window的属性
		a = 2;   
	}
</script>
1
2
3
4
5
6
7
8
9
10

5.作用域链

作用域链:js中数据的查找规则

作用域链VS作用域:

作用域是变量生效的区域和范围

作用域链描述的是程序在寻找变量的过程

程序在查找变量的时候,先从自己的作用域找,找到了就使用这个变量,没找到就往上一级找,再没找到就再往上找,直到找到全局作用域,找到就使用,找不到就报错

<script>
	var a = 0;
	function fn1() {
        var a = 1;
		function fn2() {
			var a = 2;
			function fn3() {
				// var a = 3;
				console.log(a);
			}
			fn3();//在自己的作用域内找变量,此时输出3,如果自己的作用域没有变量,则往上一级找
		}
		fn2();//找到上一级作用域,此时输出2,如果上一级作用域没有变量,就再往上找
	}
	fn1();//找到上上一级作用域,此时输出1,如果这一级作用域也没有变量,则在全局作用域找
	//找到全局作用域,此时输出0
</script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6.闭包

局部作用域下可以使用全局变量,但是函数却无法读取函数内部的变量

<script>
    //作用域链找上一级的变量
	var a = 996;
	function f1(){
    	console.log(a);
	}
	f1();
	
	//在函数的外面却无法读取函数内部的变量
	function f2(){
    	var a = 996;
	}
	f1();
	console.log(a);
</script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在函数的内部定义变量不加var,把变量设置成全局变量,就可以从函数的外部访问函数内部的变量
```
<script>
	function f2(){
    	a = 996;
	}
	f1();
	console.log(a);
</script>
1
2
3
4
5
6
7
```

如何从外部读取函数内的局部变量

在函数的内部嵌套一个函数

<script>
	function f1(){
        var a = 996;
        function f2(){
            return a;
        }
	}
</script>
1
2
3
4
5
6
7
8

内部函数引用外部函数的变量;f2被包含在f1中,此时f2是可以访问到f1中的变量的(作用域链向上一级)寻找变量

外部函数返回内部函数的方法体;既然f2读取了f1中的局部变量,那么只要把f2作为返回值就可以在f1的外部读取变量

<script>
	function f1(){
        var a = 996;
        function f2(){
            //读取f1中的局部变量
            return a;
        }
        return f2;//返回f2的方法体/不加括号
	}
</script>
1
2
3
4
5
6
7
8
9
10

外部函数和内部函数都要执行

<script>
	function f1(){
        var a = 996;
        function f2(){
            //读取f1中的局部变量
            return a;
        }
        return f2;//返回f2的方法体/不加括号
	}
	f1();//调用的f1是return的f2的方法体
	f1()();//方法体后面加个括号就会执行这个方法体
</script>
1
2
3
4
5
6
7
8
9
10
11
12

方法总结
1. 两个函数嵌套
2. 内部函数必须引用外部函数的局部变量(作用域链)
3. 外部函数要返回内部函数的方法体(函数名不加括号)
4. 外部函数和内部函数都要执行(方法体后面加括号)
```
<script>
    function f1(){
    	var a = 996;
    	function f2(){
        	return a;
    	}
    	return f2;
	}
	var b = f1()();
	console.log(b);
</script>
1
2
3
4
5
6
7
8
9
10
11
```

闭包的概念

在上面的代码中,f2函数就是闭包,可以理解为闭包就是函数嵌套,可以读取其他函数内部变量的函数
如何产生闭包?
1. 函数嵌套
2. 内部函数引用外部函数的局部变量
3. 外部函数返回内部函数的方法体
4. 外部函数和内部函数都要执行
闭包到底是什么?
- 理解一:闭包是嵌套的内部函数
- 理解二:包含被引用(外部函数)变量的对象
- 理解三:所谓闭包是一个引用关系,该引用关系存在于内部函数中, 引用的是外部函数的变量的对象

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/281374