JS基础-03（数组、call、apply、arguments、Date、Math、包装类、String、正则表达式）

1. 数组

定义：var arr = new Array();
三个对象属性：constructor(构造函数的引用)，length(数组长度)，prototype(原型对象的引用)；
使用：
可以使用： 数组[数组.length] = 值;来方便地向数组最后一位添加内容可以；通过修改数组长度来限制数组长短，删除一些数据；访问不存在的数据为undefined；

	var arr = []; 
	var arr = [0, 1, 2, 3]; 
	var arr1 = new Array(0, 1, 2, 3);
	var arr = [10]; // 创建一个第一个值为10的数组
	var arr1 = new Array(10); // 创建一个长度为10的数组

常用方法：

1. push：向数组最后添加一个或多个元素并将数组长度返回；
2. pop：删除数组最后一个元素并将该元素返回；
3. unshift：向数组开头添加一个或多个元素并将数组长度返回；
4. shift：删除数组开头的元素并将该元素返回；
5. forEach: array1.forEach(function(value, index, arr){ });
   顺序遍历，它会在回调函数（由自己创建但不由自己调用的函数）中以实参的形式传递3个参数：1. 当前循环中的元素；2. 当前循环中的索引；3. 调用forEach函数的数组；

	// 不支持 continue，可以用 return false 或 return true 代替。
	//1. 
	var arr = [1, 2, 3, 4, 5];
	arr.forEach(function (item) {
	    if (item === 3) {
	        return; //跳过3 元素
	    }
	    console.log(item); // 1 2 4 5
	});
	//2. 
	var arr = [1,2,3,4,5];
	var num = 3;
	arr.some(function(v){
	    if(v == num) {
	        return;
	    }
	    console.log(v);
	});
	
	// 不支持 break，用 try catch/every/some 代替：
	// 1. try catch
	try {
	    var array = ["first","second","third","fourth"]; 
	    // 执行到第3次，结束循环;
	    array.forEach(function(item,index){
	        if (item == "third") {
	            throw new Error("EndIterative");
	        }
	        alert(item);// first,sencond
	    }); 
	} catch(e) { 
	    if(e.message!="EndIterative") throw e; 
	};
	
	// 2. every
	var arr = [1, 2, 3, 4, 5];
	arr.every(function (item) {
	        console.log(item); // 1 2 3
	        // !== 要求类型以及值都相同
	        return item !== 3; // 返回 false，跳出
	});

6. slice：array1.slice(start, end); // 前闭后开
   从一个数组中截取特定范围的元素并将这些元素以数组的形式返回，不改变原数组；
   规则：如果数值都为正数则从前往后取，反之为负数则从后往前计算index并取值；

	var arr = [0,1,2,3,4,5];
	var arr1 = arr.slice(-3,-1);
	console.log(arr1); // 结果为3,4

7. splice：array1.splice(start, number, [元素1, 元素2...]);
   删除或者添加元素，直接改变原数组,返回值为删除的元素；
   规则：第一个参数为从哪个索引开始删除元素；第二个参数为删除几个元素；从第三个参数开始的参数都是是在第一个参数的索引之前添加这些元素；

	var arr = [0,1,2,3,4,5];
	arr.splice(0,1,7,8,9); // 从0下标开始删除1位数字（即删除0），随后在0开始添加 7，8，9
	console.log(arr); // 结果为7,8,9,1,2,3,4,5

8. concat：array1.concat(array2, array3, ..., arrayX);
   可以将两个或者多个数组连接成一个数组，不会改变原数组；

	var arr = [1,2,3,4];
    var result = arr.concat([5,6,7,8],1,"a", false, null, undefined, {});
    console.log(result);
    // 1,2,3,4,5,6,7,8,1,"a",false,null,undefined,{}


	/************************分割************************/
	//一道面试题：传递两个参数m，n，返回长度为m，所有元素都为n的数组，要求不能用循环。
	//1. 使用递归，但是数值太大，内存小的时候可能导致栈溢出
	function fn(m, n) {
		  return m ? fn(m - 1, n).concat(n) : [];
	}
	// 2. 
	function fun(m,n) { 
    	return Array.from({length: m}, () => n) 
	}

9. join：array.join(separator)
   join() 方法用于把数组中的所有元素转换一个字符串。元素之间通过指定的分隔符进行分隔的，无参数时为逗号。
10. reverse：array.reverse()
    reverse() 方法用于颠倒数组中元素的顺序。
11. sort：array.sort(sortfunction)
    sort() 方法用于对数组的元素进行排序。排序顺序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序。

	// join
	var fruits = ["Banana", "Orange", "Apple", "Mango"];
	var energy = fruits.join(" and ");
	console.log(energy); // Banana and Orange and Apple and Mango

	//reverse
	var fruits = ["Banana", "Orange", "Apple", "Mango"];
	fruits.reverse();
	console.log(fruits); // Mango,Apple,Orange,Banana

	//sort
	var points = [40,100,1,5,25,10];
	// 数字升序 1,5,10,25,40,100
	points.sort(function(a,b){return a-b});
	// 数字降序 100,40,25,10,5,1
	points.sort(function(a,b){return b-a});
	// 字母和降序:
	var fruits = ["Banana", "Orange", "Apple", "Mango"];
	fruits.sort();
	fruits.reverse();

2. call和apply

函数对象都具有这两个方法，可以向这两个方法中的第一个参数传入一个对象用来修改这个方法的this对象；

1. call方法中第二个参数开始依次输入要传递给函数对象的实参
2. apply将需要传递的实参封装成一个数组作为的第二个参数将实参传递给函数对象

	fun(1, 2); // window
    fun.call(obj, 1, 2); // object 
    fun.apply(obj, [1, 2]); //object

3. arguments

在调用函数时，浏览器还会隐式传递一个参数arguments，它是一个类数组对象，不是数组对象；用法：

1. 使用索引（类似数组下标）来查询调用函数时传入的参数；
2. 拥有length属性来表示传入参数的数量；
3. 拥有callee属性表示当前指向的函数引用（函数本身内容），可以用来编写递归函数；

4. Date对象

	var date = new Date();      //执行这行代码时的时间
    var date = new Date("12/11/2016 0:0:0");  //指定时间，按照mm/dd/yyyy h:m:s的格式输入
    // 其中yyyy 如2016，如果只写16的话，部分浏览器可能解析为2016，部分可能为1916...不严谨

常用方法：

1. getDate()：获取时间的日；
2. getDay()：获取时间的星期，值为0-6，从周日计算；
3. getMonth()：获取时间的月份，值为0-11，从1月计算；
4. getFullYear()：获取时间的年份；
5. getTime()：获取时间的时间戳，为格林尼治标准时间1970/1/1 0:0:0开始到特定世界为止经过的毫秒；
6. Date.now()：执行这行代码时的时间戳‘；

5. Math

语法：Math.方法();
常用：

1. Math.E：自然对数的底数，常量e；
2. Math.PI：圆周率；
3. Math.ceil()：向上取整；
4. Math.floor()：向下取整；
5. Math.round()：四舍五入；
6. Math.random(); 获取0-1之间的随机数，当想获取x-y之间的随机数时有公式Math.random()*(y-x)+x
7. Math.max()/ Math.min();
8. Math.sqrt();
9. Math.pow(a, b);

6. 包装类

3个包装类将3种基本数据类型转换成基本数据类型对象，但是在日常开发中不要使用这种方式，因为在转换后进行比较时会产生预期外的结果。包括：String，Number，Boolen；

var num = new Number(1);
var str = new String("a");
var bool = new Boolean(true);
console.log(typeof bool); // object

//当对这三种基本数据类型操作包装类中的方法或者属性时，浏览器会临时创建一个基本数据类型对象再调用这些方法，然后再将其转换成基本数据类型
var a = 1;
a.toString();
console.log(typeof a); // string
//执行这两行代码时不会报错，因为实际在对临时创建的基本数据类型对象进行属性赋值操作，语句执行完毕后临时对象就被销毁，因此第二次执行时结果为undefined
a.name = "a";
console.log(a.name); // undefined

7. String

Javascript 参考手册-String

底层为字符数组，所以数组可以使用的方法很多也可以在字符串中使用。

1. length：表示字符串的长度；
2. charAt(a)：返回指定位置a的字符，与用索引表示相同；
3. charCodeAt()：返回指定位置的字符unicode编码;
4. fromCharCode(a, b)：返回指定unicode编码对应的字符，其中a, b为unicode值;
5. concat()：连接，与使用‘+’连接相同；
6. indexOf()：返回指定字符在字符串中第一次出现的索引，当没有时返回-1；
   indexOf() 方法区分大小写；
   可以有1个或者两个参数：
   6.1 第一个参数：需要查找的字符；
   6.2 第二个参数：从第几个索引开始进行查找；
7. lastIndexOf(): 与indexOf相似，但是它返回的是字符在字符串中最后一次出现的索引，没有时返回-1；使用方法相同；
8. toUpperCase()：全部字符转为大写；
9. toLowerCase()：全部字符转为小写；
10. slice()；截取，与数组中的类似；参数可以为负数；
11. subString()：与slice相似，但是参数为负数时默认输入是0，且当第一个参数大于第二个参数时会交换两个参数的位置；
12. split()：拆分，与数组的join方法相反，将字符串以特定方式转换成数组；

var str = "abtcdtef";
var result = str.split("t");
// 将字符串以哪个字符进行拆分充当新数组的元素
console.log(result); // 结果为ab,cd,ef
// 当参数为空串时，将每个字符都拆分成一个元素存入新数组；

8. 正则表达式

JS正则表达式教程

语法：var reg = new RegExp("正则表达式", "匹配模式");
匹配模式可以是：“i”-忽略大小写；“g”-全局匹配；
如：
方法：test()：测试指定字符串是否满足正则的匹配要求，满足返回true，否则返回false

var patt = /e/;
patt.test("The best things in life are free!");

/e/.test("The best things in life are free!")

// split() 将字符串以正则表达式作为间断符号拆分成数组；
var str = "1a2s3d4f5g6h7jk8";
console.log(str.split(/[1-9]/)); // 结果为a,s,d,f,g,h,jk

// search() 查询正则表达式中的字符位置，不存在则返回-1，与indexOf相似
var str = "1a2s3d4f5g6h7jk8";
console.log(str.search(/[a-z]/)); // 0

// match() 返回满足正则表达式匹配的字符
var str = "1a2s3d4f5g6h7jk8";
console.log(str.match(/[a-z]/)); // a
console.log(str.match(/[a-z]/g)); // a,s,d,f,g,h,j,k （g-全局匹配）

// replace() 将正则表达式匹配到的字符串用新字符串代替；
// 第一个参数：需要被替换的原字符串，可以用正则表达式；
// 第二个参数：需要替换的新字符串，可以是空串；
var str = "1a2s3d4f5g6h7jk8";
console.log(str.replace(/[a-z]/, "!")); // "1!2s3d4f5g6h7jk8"
console.log(str.replace(/[a-z]/g, "!")); // "1!2!3!4!5!6!7!!8"