javascript基础/数组/字符串/正则表达式

一， 数组

1.1 概述
数组：有序的数据集合。array
数组字面量： [ ]
数据每一项之间用逗号隔开，最后一项不要书写逗号。
数组中数据可以是相同数据类型，也可以是不同数据类型

1	// 数组可以是相同数据类型
2	var arr1 = [1,2,3,4,5,6,7,8,8];
3	// 还可以是不同的数据类型
4	var arr2 = [10,"你好",undefined,true,"false",function(){console.log(1)}];
5	
6	console.log(arr1);
7	console.log(arr2);

读取：通过索引值index,索引值从0开始

1	arr[index]
2	arr2[0]

设置：=

1	arr1[0] = "我是开头值";

1.2 length属性
数组保存数据的总个数。
数据类型：object

1. object.length
   数组最后一项对应的索引值可以使用length表示

1	arr.length - 1

数组可以通过Length将数组强制拉长，中间没有赋值，数据是undefined

1	arr2.length = 10;

数组可以通过索引值强制拉长，没有赋值仍然是undefined

1	// 索引值也可以赋值，将数组拉长
2	arr2[20] = 20;
3	console.log(arr2.length);
4	console.log(arr2[18]);
5	console.log(arr2);

1.3 数组遍历

1	// 遍历索引值从0开始到arr.length - 1
2	for (var i = 0; i <= arr.length - 1; i ++) {
3		console.log(arr[i]);
4	}

⦁ 1.4数组方法
数组首尾操作的方法
push(): 在数组结尾添加数据
参数：添加的数据，可以有多项，用逗号隔开
返回值：新数组长

	console.log(arr.push(2,3));

pop(): 删除数组最后一项。
参数：不用
返回值：数组最后一项对应的值

	var arr = [1,2,3];
	arr.pop();
	console.log(arr);//输出[1，2]

unshift(): 在数组开头添加数据
参数：添加的数据
返回值：新数组长度

	var arr = [1,2,3];
	//arr.pop();
	arr.unshift(0);
	console.log(arr);//输出[0,1,2,3]

shift(): 删除数组第一项
参数：不用
返回值：删除项

	var arr = [1,2,3];
	arr.shift();
	console.log(arr);//输出[2,3]

⦁ 数组合并方法
concat(): 用于数组合并
参数：变量，字面量
返回值：合并后新数组
原数组不改变

	var arr1 = [1,2,3,4];
	var arr2 = [5,6,7,8];
	console.log(arr1.concat(arr2));//输出[1,2,3,4,5,6,7,8]

⦁ 数组截取方法
slice(start,end): 用于数组截取
参数：第一个参数start,第二个参数end（包括start不包括end）
返回值：截取到的新数组
注：原数组不改变

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

参数：还可以使用负数，表示倒数，从-1开始，从小索引值到大索引值

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

可以省略第二个参数，表示截取到最后

	var arr = [1,2,3,4,5,6];
	console.log(arr.slice(2));//[3,4,5,6]
	console.log(arr);//[1,2,3,4,5,6]

⦁ 数组删除，插入，替换方法
方法：splice(index, howmany, elements):
参数：
index:删除项对应的索引值
howmany:删除元素的个数
elements:插入的数据，替换的元素
返回值：删除项组成的新数组，没有删返回空数组
注：原数组改变

删除功能：index，howmany不能是0都必须书写，elements省略

	var arr1 = [1,2,3,4];
	document.write(arr1.splice(1,2));//输出值为删除项 2,3
	document.write(arr1);//显示新数组 1,4

插入功能：index插入项索引值，howmany必须是0都必须书写，elements书写要插入数据

	var arr1 = [1,2,3,4];
	document.write(arr1.splice(1,0,5));
	document.write(arr1);//输出新数组1,5,2,3,4

替换功能：index，howmany必须不是0，elements书写要替换数据

	var arr1 = [1,2,3,4];
	document.write(arr1.splice(1,1,5));
	document.write(arr1);//输出新数组1,5,3,4

⦁ 倒序方法
reverse(): 倒序，只能将数组前后顺序进行颠倒，第一项变为最后一项。
参数：不用
返回值：倒序之后新数组
原数组改变

	var arr1 = [1,2,3,4];
	document.write(arr1.reverse());//输出值为4,3，2,1

⦁ 排序
sort():
参数：不用
返回值：排序之后新数组，原数组改变
排序原理：将数组每一项转为字符串，按照字符编码进行排序。
数字，大写字母，小写字母

1	var arr2 = [23,8,"black",true,false,undefined,"B"];
2	// 排序
3	console.log(arr2.sort());
4	console.log(arr2);//23, 8, "B", "black", false, true, undefined

案例：参数：自定义匿名函数（比较函数）
形参a,b表示两个要比较的数字

https://blog.csdn.net/erdaidai/article/details/78054447

自定义升序排序：
如果a>b，返回值是正数。排序之后a应该在b后面
如果a ===b，返回值是0.排序之后a，b不区分前后
如果a<b,返回值负数。排序之后a应该在b前面

1	var arr = [10,20,45,8,9,55,45];
2	// 自定义升序排序
3	arr.sort(function (a,b) {
4		if (a > b) {
5			return 3;
6		}else if (a === b) {
7			return 0;
8		}else {
9			return -2;
10		}
11	});
12	
13	// 原数组改变
14	console.log(arr);

⦁ 1.5数组方法
⦁ join()
将数组转为字符串方法
参数：省略（数据默认以逗号连接）
返回值：字符串

参数：连接字符

1. // 参数：连接符
2. var str = arr.join("_");
3. console.log(str);

二，字符串

⦁ length属性
字符串中包含字符总个数（字母，数字，汉字，标点，空格等）

	
		var str = "1234";
		console.log(str.length);

⦁ charAt()
得到指定位置（索引值）的字符
参数：索引值
返回值：字符

1.	for (var i = 0 ; i < str.length; i ++) {
2.		console.log(str.charAt(i));
3.	}

⦁ indexOf()
得到指定字符首次出现的位置。
参数：字符
返回值：索引值

1.	// 没有该字符，返回值-1
2.	console.log(str.indexOf("阳光"));

⦁ concat()
用于字符串合并
参数：合并的字符串，字面量，变量等
返回值：合并后的新字符串

1.	var newStr = str.concat("希望天气暖和");

⦁ slice()
字符串的截取方法
参数：start,end 从start开始截取到end，不包括end
返回值：截取的新字符串

1.	// 参数都是正值
2.	var str2 = "今天有微风，气温10°C";
3.	console.log(str2.slice(3,6));
4.	// 参数：负数 -1开始
5.	console.log(str2.slice(-6,-4));
6.	// 参数：省略end表示截取到最后
7.	console.log(str2.slice(2));

⦁ substr()
用于字符串截取
参数：第一个参数index 第二个参数howmany 截取字符串个数
返回值：截取到的新字符串

1.	var str = "今天有微风，气温10°C有。";
2.	// substr(index,howmany)
3.	console.log(str.substr(2,4));
4.	// index也可以使用负数 表示倒数
5.	console.log(str.substr(-8,6));
6.	// 省略howmany表示截取到最后
7.	console.log(str.substr(-8));

⦁ substring()
用于字符串截取
参数：start,end （区别start，end不区分大小） 表示从小索引值截取到大索引值，不包括大索引值
不能使用负数
返回值：截取到新的字符串

8.	// substring() 从小索引值截取到大索引值，不包括大索引值
9.	console.log(str.substring(2,5));
10.	console.log(str.substring(5,2));

⦁ split()
⦁
将字符串转为数组方法
参数：切割字符
返回值：新数组

11.	// split()字符串转为数组方法
12.	var str2 = "天气a晴朗a微风a阴天 。"
13.	var arr = str2.split("a");//切割a
14.   document.write(arr);	

⦁ toUpperCase()
转为大写字母
参数：省略
返回值：新字符串

⦁ toLowerCase()
转为小写字母
参数：省略
返回值：新字符串

案例：
将“everything is good in its season”，转为每个单词的首字母大写。
即“Everything Is Good In Its Season”

1.	/*	
2.	将“everything is good in its season”，转为每个单词的首字母大写。
3.	即“Everything Is Good In Its Season”
4.	
5.	1 “everything is good in its season” 的到每一个单词（数组中每一项）
6.	2 数组中每一项重新赋值  = 第一个字母大写 + 每一个单词除了第一个字母后面所有的字符
7.	3 将数组转为字符串
8.	*/
9.	
10.	var str = "everything is good in its season";
11.	// 1的到每一个单词  字符串转为数组方法
12.	var arr = str.split(" ");
13.	
14.	// 2数组每一项重新赋值
15.	for (var i = 0; i <= arr.length - 1; i ++) {
16.		// console.log(arr[i]);
17.		arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].slice(1);
18.	
19.	}
20.	// 3将数组转为字符串
21.	str = arr.join(" ");
22.	console.log(str);

二，正则表达式

2.1 概述
正则表达式（regular expression）。简写RegExp。
创建正则：使用正则字面量。/表达式/
正则的数据类型是引用数据类型object。
var reg = /abc/
正则表达式：是被用来匹配字符串中的字符组合的模式,是一种最简单的验证字符串方法。常用来做表单验证

2.2 字符串的方法
配合正则表达式使用的方法有字符串方法和正则表达式的方法。
2.2.1 split()
split()方法根据匹配字符串切割父字符串，返回切割后的数组。

1.	"ajbbbbbdsbbfkbjfbbbbbbbbbbbbbbbbbbbbk".split(/b+/)
 

2.2.2 match()
使用正则表达式与字符串相比较，返回一个包含匹配结果的数组。
参数：可以是字符串

1.	"axyzbccc".match("xyz")  //也可以写成"axyzbccc".match(/xyz/)

match匹配时，不书写g只会输出匹配到的第一个字符串。
参数：还可以是正则表达式
match还可以进行全局匹配；返回所有匹配到的字符串组成的数组。g是全局匹配

1.	"abccbbbbczbbbbbbbz".match(/b+/g)
 

2.2.3 search
search() 对正则表达式或指定字符串进行搜索，返回第一个出现的匹配项的索引值。
参数：字符串

1.	// search:搜索 查找首次出现字符串所在的索引值
2.	// 参数：字符串
3.	console.log("abccbbbbczbbbbbbbz".search("b"));
4.	// 参数：正则 search没有全局搜索 只能将首次位置返回
5.	console.log("abccbbbbczbbbbbbbz".search(/b+/));
6.	// 没有要搜索字符串 返回值-1
7.	console.log("abccbbbbczbbbbbbbz".search(/xyz/));

2.2.4 replace
替换：用新字符串替换匹配字符串。
参数：第一个参数匹配字符串（字符串，正则） 第二个参数：要替换的字符串
返回值：替换后新字符串

1.	// replace(a,b)替换 用b替换a a形式可以是字符串 正则
2.	console.log("www.baidu.com".replace("baidu","jjjjj"));
3.	console.log("www.baidu.com".replace(/baidu/,"kkkkk"));
 

2.3 正则方法
2.3.1 exec()
查找，将匹配的字符串用数组方式返回(匹配一次，在全局的作用下会返回匹配到的字符串，不过需要循环输出)。
参数：字符串
返回值：数组

1.	console.log(/\d{3}/.exec("010-12abc789"));

1.	// 没有匹配结果
2.	console.log(/a{3}/.exec("010-12abc789"));
 

2.3.2 test()
test(): 检测字符串中是否含有正则匹配字符串
参数：检测字符串
返回值：布尔值 含有true 不含有false

1.	console.log(/a{2}/.test("abchdsjdaa"));
2.	console.log(/a{3}/.test("abchdsjdaa"));

2.4正则表达式的术语和操作符
正则表达式的组成：由普通字符和特殊字符（元字符）组成。
普通字符包括：字母，或者是数字等
特殊字符：() {} [] \ | ^ $ ? + .
正则中匹配特殊字符必须使用转义字符\

2.5 精确匹配
精确匹配：正则表达式只含有普通字符
/abc/: 匹配的字符串：只含有a,b,c三个字符 顺序只能是abc

1.	"abcjacb".match(/abc/g);

2.6预定义特殊字符
\n:换行
\t：制表符

1.	console.log("ah
2.		c".match(/\n/g));

 
1.	console.log(`ah
2.			c`.match(/\n/g));

2.7 字符集
[ ]:把所有匹配的可能性都书写在中括号内，用于匹配一个字符。

简单类：直接书写所有的可能性。
范围类：表示一类可能性。[0-9],[a-z],[A-Z]
组合类：表示不同类型的范围组合。[0-9a-z],[a-zA-Z];
负向类：表示不包含后面书写匹配字符的可能性。书写在[^]左中括号的后面

2.8修饰符
g：表示全局匹配。表示在匹配到一个满足条件的字符串并没有停止而是将所有的匹配进行查找。
语法：//g。

i:表示不区分大小写（对大小写不敏感）。
语法：//i。
修饰符可以同时使用。

console.log("ABCgABC".match(/abc/ig));

2.9 边界
^：书写在正则表达式的最左侧。表示开头匹配，表示能够匹配后面所有字符作为开头。

//  /^/开头匹配
	console.log("abchabc".match(/^abc/g));//只是匹配开头abc

$:结尾。表示必须以$前面的字符作为字符串的结尾。

1.	var str = "abcicjabcegkgagc";
2.	console.log(str.match(/agc$/g));//只匹配结尾agc

. 代表任意一个字符串 除了换行符

\b:单词边界，用于查找位于单词的开头或结尾的匹配。

// \b单词边界  开头，结束位置
	console.log("hello icketang".match(/[a-z]/g));//h,e,l,l,o, i,c,k,e,t,a,n,g
	console.log("hello icketang".match(/\b[a-z]/g));//h,i
	console.log("hello icketang".match(/[a-z]\b/g));//o,g
	console.log("hello icketang".match(/\b[a-z]+/g));//hello icketang

\B： 非单词边界，用于查找不处在单词的开头或结尾的匹配。

// \B 非单词的边界
	console.log("hello icketang".match(/\B[a-z]/g));//e，l，l，o， i，c，k，e，t，a，n，g
	console.log("hello icketang".match(/\B[a-z]\B/g));//"e,l,l,o,c,k,e,t,a,n
	console.log("hello icketang".match(/\B[a-z]+/g));//ello,cketang
	console.log("hello icketang".match(/\B[a-z]+\s/g));//ello

2.10量词
量词：一般用于处理一排紧密相连的同类的字符。
语法：{ }
{n} 硬性量词。表示出现n次

{n,m} 软性量词。表示至少出现n次不能超过m次。

{n,} 软性量词。表示至少出现n次。
？ :表示出现0或者1次。
+加号 :表示出现1次或者多次。{1,}
*乘号 ：表示出现0次或者多次。{0,}

2.11分组匹配
用于匹配连续多个字符，小括号表示整体

console.log("abcabc12".match(/(abc){2}/g);

2.12预定义类
js提前给我们定义好的，一些特殊字符。表示一类字符，是一些特殊字符集的简写。
. 表示除了换行和回车之外的任意字符。
\d [0-9] 表示数字字符。
\D [^0-9] 表示非数字字符。
\s [ \t\n\x0B\f\r] 表示空白字符。
\S [^ \t\n\x0B\f\r] 表示非空白字符
\w [a-zA-Z_0-9] 表示单词字符(所有的字母/数字/下划线)。
\W [^a-zA-Z_0-9] 表示非单词字符

2.13 或匹配
字符1 | 字符2 可以是字符1或者是字符2

1.	"abcbc".match(/(ab)|(bc)/g)

2.14 分组反向引用
分组反向引用：正则表达式匹配的字符串组再次使用。
每一个分组对应一个唯一的编码，按照自然数编码从1开始，1,2,3,4

1在正则表达式里面再次使用 \编码，再次使用哪一个匹配组书写对应的编码
返回数组的第0个元素存储的是匹配字符串，第1个元素存放的是第一个引用型分组(子表达式)匹配的字符串，第2个元素存放的是第二个引用型分组(子表达式)匹配的字符串，依次类推。

1.	console.log("abcxyzxyzxyz1212abcabc12xyzabc".match(/(\d{2})\1(abc)\2\1/g));

2还可以在正则表达式外面使用 $编码代表分组的组号

1.	console.log("abc12".replace(/([a-z]{3})(12)/,"$2"));

replace()第二个参数还可以书写为match函数，
形式参数第一个参数必须是match，其他参数依次书写编码，每一个小括号的编码必须书写
但是形参可以不使用

1.	var str2 = "456*678";
2.		str2 = str2.replace(/(\d{3})\*(\d{3})/,function (match,$1,$2) {
3.				return $2 + "*" + $1;
4.			});
5.	
6.		console.log(str2);

2.15中文
匹配中文：[\u4e00-\u9fa5]
是一个固定用法，中文只能在正则表达式里这样表示。

1.	console.log("中文*匹配".match(/[\u4e00-\u9fa5]+/g));