学习JavaScript的笔记（二）

函数

函数定义语法：function 函数名(){}，小括号内部时传递参数的
调用：函数名()

函数参数

			//此时a,b都为参数
			function pri(a,b){
				console.log(a,b);
			}
			pri(10,30);

arguments:arguments是函数自带属性，是由实参组成的类数组对象
例：

			function demo(a,b){
				console.log(arguments);
			}
			demo(2,3,4,5,6)

1. 实参可以传递任意数据类型的参数
2. 实参的数据类型会影响形参的数据类型
   拓展：数据类型：

typeof   123　　 					 //Number

typeof   'abc'　　	 		  		//String

typeof    true     	  			    //Boolean

typeof    undefined      	        //Undefined

typeof    null                      //Object

typeof    { }                      //Object

typeof    [ ]                     //Object

typeof    console.log()           //Function

return

return作用：接受参数返回一个值，return不会输出，得使用输出语句来进行输出。函数内部遇见return，会立即返回
优点：可以将一个函数作为返回值，传递给另外一个参数。

function demo(num){
				console.log(1);
				console.log(2);
				console.log(3);
				return 100;
				console.log(4);
				console.log(5);
				console.log(6);
			}
			console.log('demo函数运行的结果为：',demo());

//return可以将一个函数的返回值传递给另外一个函数
function print(sum){
				console.log('a+b的值为：',sum);
			}
			function add(num1,num2){
				return num1 + num2;
			}
			print(add(2,3));

注：

1. return是给函数用的
2. continue和break是给循环语句用的

模块化编程

优点：增强了代码的可读性

函数表达式

1. 函数声明除了可以使用function，还可以使用函数表达式
2. 语法：var fun = function(){}
3. 简单数据类型赋值的是值，引用数据类型赋值的是地址

简单数据类型：

1. 变量可以进行赋值，且可以接受任何类型的数据
2. 变量与变量之间进行赋值时，只是在原来的变量上复制一份，本身数据不会收到影响

引用数据类型：

1. 赋值是将变量的地址赋值给了另外一个变量，两个变量指向了同一个地址，其中一个变量发生改变时，另外一个变量也会受到影响

函数声明提升

1. 函数执行的一瞬间，会产生一个 Active Object（活动对象/容器，简称AO）
2. 函数声明的形参，形成AO的属性，默认值为undefined，随后接收实参，给刚才形成AO的形参赋值
3. var声明的变量：如var demo
   如果AO上还没有demo属性，则添加上demo
   如AO上已经有了demo属性，则不做任何操作
4. 分析函数声明：如function demo(){}
   AO上没有demo，则直接将函数赋给AO.demo
   AO上如果有demo属性，则直接覆盖掉

注：函数表达式的提升与变量的提升是一样的，若都是在后定义变量且赋值，只能访问到变量而不能访问到值（出现undefined的情况）

//例题：
function pri(num) {
				console.log(num);//函数2222
				var num = 111;
				function num() {
					console.log(2222);
				}
				console.log(num);//111
				var num = function() {
					console.log(3333);
				}
			}
			pri(88);

局部变量和全局变量

顾名思义
局部：定义在函数内部，外部无法访问
全局：定义在函数外部，函数内都可访问

递归函数

定义：在函数内部调用自身。一般会设置一个临界值，当达到这个临界值，停止调用这个函数

			function add(num) {
				if(num <= 0) {
					return 0;
				}
				return num + add(num - 1);
			}
			console.log(add(10));

作用域

循环语句中的变量是可以在外部被引用的，但函数中的变量在外部是不能被直接引用的

闭包（closure）

定义：闭包是指有权访问另外一个函数作用域中的变量的函数。内部函数将它自己内部的语句，和它声明时所处的作用域封装成了一个密闭的环境，我们称之为“闭包”

注：

1. 闭包函数每次执行，外部的环境可能会变化
2. 多次执行闭包函数，都会产生一个全新的内部环境与外部环境
3. 闭包无法被js垃圾回收机制自动回收
4. 由于闭包函数本身拥有一个作用域，因此闭包中变量与外部函数命名发生冲突的时候，会优先使用闭包中的数据（举例如下）

			function add(x,y){
				return function(x){    //优先选择闭包中的x
					console.log(x + y);
				} 
			}
			var add1 = add(5,10);
			add1(6);  //6+10
			add1(7);  //7+10
			add1(8);  //8+10

作用：外部环境可以起到一个封闭空间，存储数据的作用，供闭包使用

IIFE函数

即时调用函数表达式
调用方法：

1. 函数表达式中，在函数结尾中括号后加上()
2. 函数定义式中，不能直接加()，需要转换成函数表达式，可以在函数前加上一元运算符（如+、-、!等），再在结尾中括号后加上()
3. 工作中，常用小括号将函数定义式包装起来，再在其后加上小括号
   例：

			(function add() {
				console.log(5 + 6);
			})();

4. IIFE能管住函数的作用域，在IIFE外部任何地方都不能访问
5. IIFE本身相当于一个表达式，如果内部有return，返回的数据可以参与其他运算
   拓展：函数表达式不能直接被访问，可以通过存储在变量中，然后进行访问

数组（array）

定义：一系列有序数据的结合
创建：[]

length属性

表示包含数据的总个数

			var arr = [10,20,30];
			console.log(arr);
			console.log(arr[2]);
			arr[arr.length] = 40;
			console.log(arr[arr.length - 1]);

数组方法

pop()：删除数组的最后一项
push()：在数组最后添加数据
shift()：删除数组的第一项
unshift()：给数组的第一项添加数据

堆栈与队列

堆栈：push - pop(后进先出)

			arr.push('冬');
			console.log(arr);
			arr.pop();
			console.log(arr);

队列：push - shift(先进先出)

			var arr = ['春', '夏', '秋'];
			arr.push('冬');
			console.log(arr);
			arr.shift();
			console.log(arr);

数组的合并和拆分

合并：用于合并多个数组
concat()

var arr1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
			 arr2 = [11, 12, 13]
			var arr = arr1.concat(arr2);
			console.log(arr);

拆分：用于截取数组中的某一段
slice(start, end)

			var arr1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
			// var arr = arr1.slice(2, 5);
			var arr = arr1.slice(-4, -2);
			console.log(arr);

start表示开始的索引值（包括start），end表示结束的索引值（不包括end）
注：都不会改变原数组

数组的删除、插入、替换

splice(index, howmany, elements1, elements2)
index：删除的第一项索引值（必填）
howmany：删除的个数（必填）
elements：替换的数据（非必填），不能写数组，不然此数组将会被整体插入
注：原数组会受到影响

var arr = [1, 2, 3, 4, 5];
			var arr1 = arr.splice(0, 4, 7, 8, 9);
			console.log(arr,arr1);

数组的排序

倒序：reverse()，原数组顺序颠倒

		var arr = [2, 3, 6, 3, 6, 2, 3, 7];
		var arr1 = arr.reverse();
		console.log(arr1, arr);

排序：sort()，内部不传递参数时，将从小到大进行排序（按照字符编码顺序：数字，大写字母，小写字母）

		var arr = [2, 3, 6, 3, 6, 2, 3, 7];
		var result = arr.sort(function(){
			return Math.random() > 0.5 ? 1 : -1;
		});
		console.log(arr);

数组转字符串

join()：不传递参数，字符串之间以逗号链接，传递空字符串则直接相连

			var arr = ['春', '夏', '秋', '冬'];
			var arr1 = arr.join('');
			console.log(arr1, arr);

数组与闭包

书写一个6项的数组，每一项保存一个函数，函数中打印for循环的索引值：

			var arr = [];
			for(var i = 1; i < 6; i++){
				arr[i] = (function(i){
					return function(){
						console.log(i);
					}
				})(i)
			}
			arr[5]();

类数组对象

使用方法类似于数组的一类对象
arguments：

1. 函数内部自带数组对象。保存函数执行时传递的实际参数
2. 可以使用length属性
3. 可以通过索引值访问对象
4. 类数组中保存的每一个数据都是元素对象
   应用：
5. 其他后端语言都有函数重载的现象
6. js没有函数重载

对象

			var student = {
				name : '张三',
				class : '三班',
			}
			console.log('姓名', student.name);
			console.log('班级', student.class);

json

由于函数在不同语言中语法是不同的，因此json不能储存函数
undefined、NaN、Infinity会转换成null
json字符串与对象之间的转换方法：
JSON.stringfy(对象名)
JSON.parse()
注：json对于语法要求很严格

			var json = '{"name": "李四","class": "四班" }'
			console.log(JSON.stringify(json));

			var json = '{"name": "李四","class": "四班" }'
			console.log(JSON.parse(json));

this

this和arguments一样，是函数内部的一种特殊变量
arguments表示函数的参数
this表示上下文对象（调用者），是在函数执行的时候确定的
注：

1. this通常在函数内部使用
2. this在全局时使用指向的是windows
3. 全局定义的函数，this也指向的是windows

			var demo = {
				str : 'class',
				getClass(){
					console.log(this, this.str);
				}
			}
			demo.getClass();

注：该篇博客为自己视频学习时记录下的笔记，部分内容来源于学习视频