是一个描述字符模式的对象.
1.创建方式
1) 正则表达式直接量
var pattern = /s$/;
2) RegExp()构造函数
var pattern = new RegExp("s$");
2. 直接量字符
正则表达式中所有字母和数字都是按照字面含义进行匹配的。
字符 匹配
-----------------------
字母和数字 自身
\t 制表符
\n 换行符
\v 垂直制表符
\f 换页符
\r 回车符
\xnn 由十六进制数nn指定的拉丁字符 \x0A => \n
\uxxxx 由十六进制xxxx指定的Unicode字符，例如 \u0009 => \t
\cX 控制字符 ^X,例如 \cJ 等价于换页符 \n
3. 字符类
将直接量字符单独放在方括号内就组成了字符类。一个字符类可以匹配它所有包含的任意字符。
[...] 方括号内的任意字符 返回值为 方括号内的每一个字符 单独打印出来
[^...] 不在方括号内的任意字符 返回值为 不是方括号内的每一个字符
特殊字符类
. 除换行符和其他Unicode行 终止符 之外的任意字符
\w 任何ASCII字符，等价于[a-z A-Z 0-9] 包括下划线_也可以打印（属于一个字符）
\W 任何非ASCII字符组成的，等价于[^a-zA-Z0-9_]
\s 任何Unicode空白符：空格，制表符，回车
\S 任何非Unicode空白符的字符
\d 任何ASCII数字，等价于 [0-9]
\D 任何非ASCII数字之外的任意字符，等价于 [^0-9]
[\b] 匹配一个单词边界，也就是单词和空格之间的位置 不匹配任何字符 退格直接量（特例）
4. 重复 一定要用在子表达式之后
{n,m} 匹配前一项至少n次，但是不超过m次
{n,} 匹配前一项n次或者更多次
{n} 匹配前一项n次
? 匹配前一项0次或者1次，等价于{0,1}
+ 匹配前一项1次或者多次，等价于{1,}
* 匹配前一项0次或者多次，等价于{0,} 包括空格
^ 与字符串开始的地方匹配，不匹配任何字符
$ 与字符串结束的地方开始匹配，不匹配任何字符
\b 匹配一个单词边界，也就是单词和空格之间的位置，不匹配任何字符
例如：
/[abc]/ 匹配"a" "b" "c"中任意一个字符
/[^abc]/ 匹配"a" "b" "c"之外的任意一个字符
/\d{2,4}/ 匹配2~4个数字
/\w{3}\d?/ 匹配三个字符或和一个可选的数字
/\s+java\s+/ 匹配前后带有一个或多个空格的字符串"java"
5. 重复方式
贪婪重复
匹配重复字符时是尽可能多地匹配
非贪婪重复
在待匹配的字符后跟随一个问号即可： ?? +? *? {1,5}?
例如：
/a+/ 可以匹配一个或者多个连续的字母a, 当使用"aaa"作为匹配字符串时正则表达式会匹配它的三个字符
/a+?/ 可以匹配一个或者多个连续的字母a, 但是尽可能少地匹配。只能匹配第一个a
6. 选择
使用字符 "|" 分割供选择的字符。选择项的尝试匹配次序是从左到右，直到发现了匹配项，如果左边的选择项匹配，就忽略右边的匹配项，即使它产生更好的匹配。/ab|cd|ef/ 可以匹配 "ab"或者"cd"或者"ef"
//test() 执行检测 返回Boolean
exec(); 执行检查 执行完 就返回 维护一个起始索引 0 index input
/【ab|cd|ef】/ 匹配成单个 a b c d e f
7. 分组
"()"作用：
1) 把单独的项组合成子表达式
以便可以像处理一个单元那样用"|""*""+""?"对单元内的项进行处理
/java(script)?/ 可以匹配字符串java,后面的script可以有也可以没有
/(ab|cd)+|ef/ 可以匹配"ef",也可以匹配"ab""cd"一次或者多次
2) 在完整的模式中定义子模式
当一个正则表达式成功地和目标字符串相匹配时，可以从目标串中抽出和圆括号中的子模式相匹配的部分。
/[a-z]+\d+/ 一个或者多个小写字母后跟随一个或者多个数字
(/[a-z]+(\d+)/) 可以抽出每个匹配末尾的数字
3) 在同一正则表达式后面引用前面的子表达式。
\1 引用第一个带圆括号的子表达式
/([Jj]ava([Ss]cript)?)\sis\s(fun\w*)/ \2 引用 ([Ss]cript)
对正则表达式中前一个子表达式的引用，并不是指对子表达式模式的引用，而是对与那个模式相匹配的文本的引用
例如：
/['"][^'"]*['"]/ 匹配单引号或者双引号内的0个或者多个字符,但是它并不要求左侧和右侧的引号匹配
/(['"])[^'"]*\1/ 匹配单引号或者双引号内的0个或者多个字符,但是它要求左侧和右侧的引号匹配
8. 指定匹配位置
^ 匹配字符串的开头，在多行检索中，匹配一行的开头
$ 匹配字符串的结尾，在多行检索中，匹配一行的结尾
\b 匹配一个单词的边界，即位于字符\w和\W之间的位置，或者位于字符\w和字符串的开头或结尾之间的位置。
\B 匹配非单词边界的位置
(?=p) 零宽正向先行断言，要求接下来的字符都与p匹配，但不能包括匹配p的那些字符
(?!p) 零宽负向先行断言，要求接下来的字符不与p匹配
9. 修饰符
不是出现在两条斜线之间，而是出现在第二条斜线之后。
new RegExp("","igm")
i 说明匹配模式匹配是不区分大小写
g 说明模式匹配应该是全局的
m 用以在多行模式中执行匹配。
/java$/im 可以匹配"java",也可以匹配"java\nis fun"
2. Javascript中 String对正则表达式的支持
1. search()
参数为一个正则表达式。如果参数不为正则表达式，则先通过RegExp将其转换为构造函数。不支持全局检索，返回第一个与之匹配的子串的位置，如果找不到匹配的子串，返回-1。
"JavaScript".search(/script/i); //返回4
2. replace()
用以执行检索和替换操作。第一个参数是正则表达式，第二个参数是要替换的字符串。
text.replace(/javascript/gi,"JavaScript"); //不区分大小写将所有javascript转换为JavaScript
3. match()
最常用的正则表达式方法，参数为正则表达式。返回由匹配结果组成的数组。
当正则表达式中没有g修饰符的时候，就不是全局匹配。这时，数组的第一个元素就为匹配的字符串，剩余的元素则是由正则表达式中用圆括号括起来的子表达式。如果该正则表达式设置为修饰符g,则该方法返回的数组包含字符串中所有匹配结果。
"1 plus 2 equals 3".match(/\d+/g) //返回["1","2","3"]
var url = /(\w+):\/\/([\w.]+)\/(\S*)/;
var text = "visit my blog at http://www.briup.com/~ee";
var result = text.match(url);
if(result!=null){
var fullurl = result[0];
var protocol = result[1];
var host = result[2];
var path = result[3];
}
4. split()
参数可以为正则表达式
"1, 2, 3, 4, 5".split(/\s*,\s*/); //["1","2","3","4","5"] 允许分隔符左右两边留有空白
3. Javascript中RegExp
1. 构造函数
第一个参数包括正则表达式的主体部分，即正则表达式直接量中两条斜线之间的文本
第二个参数指定正则表达式的修饰符。只能传入g ,i,m或者其组合，可以省略
var zipcode = new RegExp("\\d{5}","g");
2. 属性
source 包含正则表达式文本
global 布尔值，表明这个正则表达式是否带有修饰符g
ignoreCase 布尔值，表明这个正则表达式是否带有修饰符i
multiline 布尔值，表明这个正则表达式是否带有修饰符m
lastIndex 如果匹配模式带有g，这个属性存储在整个字符串中下一次检索的开始位置，这个属性会被exec(), test()方法调用到
3.方法
1) exec()
与match类似。参数为字符串。对一个指定的字符串执行一个正则表达式在一个字符串中执行匹配检索，如果没有找到任何匹配，返回null,如果找到了匹配，返回一个数组。这个数组元素中的第一个元素包含与正则表达式相匹配的子字符串，剩余的元素是圆括号内的子表达式相匹配的子串。当调用的正则表达式对象具有修饰符g时，它将把当前正则表达式对象的lastIndex属性设置为紧挨着匹配子串的字符位置，当同一个正则表达式第二次调用exec()时，它将从lastIndex属性所指的字符处开始检索。如果没有匹配到任何结果将lastIndex重置为0.
var pattern = /Java/ig;
var text = "JavaScript is more fun than java_is good";
var result;
while((result = pattern.exec(text))!=null){
console.log(result[0]+" at "+result.index);
}
2) test()
参数为字符串。用test()对某个字符串进行检测，如果包含正则表达式的一个匹配结果，返回true.调用test()和调用exec()行为等价，test()会从lastIndex指定位置处开始检索某个字符串，如果它找到了一个匹配结果，立即设置lastIndex为当前匹配字符串的结束位置。
var pattern = /Java/ig;
var text = "JavaScript is more fun than java_is good";
var pattern.test(text); //结果 true
与test() exec()不同，String方法search() replace() match()并不会用到lastIndex属性
4. 基本包装类型
1)为了便于操作基本类型值，ECMAScript提供了3个特殊的引用类Boolean, Number, String
每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型对象，从而可以使我们调用一些方法操作这些数据。
var s = "briup";
s.substring(2);
后台会自动完成以下操作：
a.创建String类型的一个实例
b.在实例上调用指定的方法
c.销毁这个实例
2)基本包装类型的实例调用typeof返回"object",从而所有基本包装类型对象都会被转换为布尔类型的true.
Object构造函数会像工厂方法一些，根据传入的值的类型返回相应基本包装类型的实例
var obj = new Object("briup"); //obj 类型为String包装类型
console.log(obj instanceof String);
使用new调用基本包装类型的构造函数，与直接调用同名的转换函数不一样
var s = "11";
var s1 = Number(s); //转型函数 number类型
var s2 = new Number(s); //构造函数 object类型
3) Boolean,Number,不建议直接使用这两种类型
4) String
length
属性，获取字符串的字符数量
charAt(i)
返回给定位置的字符
charCodeAt()
返回给定位置的字符的字符编码
var s = "helloworld";
s.charAt(1); //e
s.charCodeAt(1); //101
concat()
将一个或多个字符串拼接起来，返回拼接得到的新字符串，但是大多使用"+"拼接
slice()
（开始位置，返回字符后一个字符位置）
substr()
（开始位置，返回字符个数）
substring()
（开始位置，返回字符后一个字符位置）
var s = "helloworld";
s.slice(3,7); //lowo
s.substr(3,7); //loworld
s.substring(3,7);//lowo
s //helloworld 不改变原值大小
indexOf();
从前往后查找指定字符所在位置
lastIndexOf();
从后往前查找字符串所在位置，可以有第二个参数，代表从字符串中哪个位置开始查找。
trim();
删除前置以及后置中的所有空格，返回结果
var s = " hello world ";
console.log("|"+s.trim()+"|"); //|hello world|
toLowerCase() :转换为小写
toUpperCase() :转换为大写
5. Math对象
1)常用方法
1.比较方法
Math.min() 求一组数中的最小值
Math.max() 求一组数中的最大值
Math.min(1,2,19,8,6); //1
2.将小数值舍入为整数的几个方法：
Math.ceil() 向上舍入
Math.floor() 向下舍入
Math.round() 四舍五入
console.log(Math.ceil(12.41)); //13
console.log(Math.floor(12.41)); //12
console.log(Math.round(12.3)); //12
console.log(Math.round(12.5)); //13
3.随机数
Math.random() 返回大于0小于1的一个随机数
2)其他方法：(了解即可，即用即查)
abs(num) 返回num绝对值
exp(num) 返回Math.E的num次幂
log(num) 返回num的自然对数
pow(num,power) 返回num的power次幂
sqrt(num) 返回num的平方根
scos(x) 返回x的反余弦值
asin(x) 返回x的反正弦值
atan(x) 返回x的反正切值
atan2(y,x) 返回y/x的反正切值
cos(x) 返回x的余弦值
sin(x) 返回x的正弦值
tan(x) 返回x的正切值
6. Date对象
将一个字符串转换为Date对象的写法：
var str = "2012-12-12";
var date = new Date(str); //字符串转换为Date对象
document.write(date.getFullYear()); //然后就可以使用Date对象的方法输出年份了
Date.getDate()
返回是日期对象中月份中的几号。
var date = new Date(); //2012-12-19
document.write(date.getDate()); //返回 19 是19号
Date.getDay()
返回日期中的星期几 星期天0-星期6
var date = new Date();
document.write(date.getDay()); //3 星期3
Date.getFulYead()
返回年份 如2012。
var date = new Date();
document.write(date.getFullYear()); //返回2012,2012年
Date.getHours()
返回日期中的小时，几点了，0-23
var date = new Date();
document.write(date.getHours()); //返回23，晚上11点
Date.getMilliseconds()
返回日期中的毫秒数
var date = new Date();
document.write(date.getMilliseconds()); //返回27 当前是xx年，xx月，xx点，xx分，xx秒，xx毫秒的毫秒
Date.getMinutes()
返回日期中的分钟数 0-59
var date = new Date();
document.write(date.getMinutes()); //2012-12-19 23:22 返回22，12点22分
Date.getMonth()
返回日期中的月份数，返回值0(1月)-11(12月)
var date = new Date();
document.write(date.getMonth()); //2012-12-19 此处返回11，注意此处与通常理解有些偏差，1月份返回是0,12月返回是11
Date.getSeconds()
返回一个日期的描述
var date = new Date();
document.write(date.getSeconds());·//返回34，2012-12-19 23:27:34 27分34秒
Date.getTime()
将一个日期对象以毫秒形式返回
var date = new Date();
document.write(date.getTime()); //返回1355930928466 返回值是1970-01-01 午夜到当前时间的毫秒数。
Date.getTimezoneOffset()
GMT时间与本地时间差，用分钟表示
var date = new Date();
document.write(date.getTimezoneOffset()); //返回-480 实际上这个函数获取的是javascript运行于哪个时区。单位是分钟。
Date.getUTCDate()
返回Date对象中的日期值，(全球时间)
var date = new Date();
document.write(date.getUTCDate()); //返回19 19号
Date.getUTCDay()
返回Date对象中的星期几,(全球时间)
var date = new Date();
document.write(date.getUTCDay()); //返回3 星期3
Date.getUTCFullYear()
返回Date中的年份，4位，如2012，(全球时间)
var date = new Date();
document.write(date.getUTCFullYear()); //返回2012
Date.getUTCHours()
返回Date对象中的小时数，就是现在是几点，终于有一个跟getHours()不同了，应该是时差关系，返回的是全球时间里的。
var date = new Date();
document.write(date.getUTCHours()); //现在北京时间是2012-12-19 23:44，但是返回的是15，也就是全球时间中的小时数。
Date.getUTCMilliserconds()
返回Date对象中的毫秒数，(全球时间)
var date = new Date();
document.write(date.getMilliseconds()); //返回全球时间中的毫秒数
Date.getUTCMinutes()
返回Date对象中的分钟数，(全球时间)
var date = new Date();
document.write(date.getMinutes()); //2012-12-19 23:49 返回49，注意是全球时间，其实全球时间应该就小时不同而已吧。
Date.getUTCMonth()
返回Date对象中月份值，(全球时间)
var date = new Date();
document.write(date.getMonth()); //2012-12-19 返回11，0(1月份)-11(12月份)
Date.getUTCSeconds()
返回Date对象中的秒数值
var date = new Date();
document.write(date.getSeconds()); //返回秒数值 返回33
Date.getYear()
返回Date对象中的年份值减去1900
var date = new Date();
document.write(date.getYear()); //2012-12-19 返回112 (2012-1900)
Date.now()
静态方法 //返回1970-01-01午夜到现在的时间间隔，用毫秒表述
document.write(Date.now()); //静态方法，返回当前时间与1970-01-01的时间间隔，毫秒单位。
Date.parse()
解析一个日期时间字符串，返回1970-01-01午夜到给定日期之间的毫秒数
var date = "2012-12-19";
document.write(Date.parse(date)); //返回 1355875200000
var da = new Date(date);
document.write("<br/>" + da.getFullYear() + "-" + da.getMonth() + "-" + da.getDate()); //输出2012-11-19 //注意月份是从0-11
Date.setDate()
设置一个Date对象中的日期值，返回值用调整后的日期的毫秒表示
var date = new Date();
document.write(date.setDate(11));
var da = new Date(date);
document.write("<br/>" + da.getFullYear() + "-" + da.getMonth() + "-" + da.getDate()); //输出2012-11-11 //注意月份是从0-11,设置的时候要注意
Date.setFullYear()
设置一个Date对象中的年份，返回值用调整后的日期的毫秒表示。
var date = new Date(); 今天是2012-12-20
document.write(date.setFullYear(1989)); //返回630167981030
var da = new Date(date);
document.write("<br/>" + da.getFullYear() + "-" + da.getMonth() + "-" + da.getDate()); //输出1989-11-20
Date.setHours() /
设置一个Date对象中的小事数，返回值用调整后的日期的毫秒表示。
var date = new Date(); //现在是2012-12-52 22:52
document.write(date.setHours(5)); //返回1355954000882
var da = new Date(date);
document.write("<br/>" + da.getHours()); //输出05
Date.setMilliseconds()
设置一个日期的毫秒数
var date = new Date(); //现在是2012-12-20
document.write(date.setMilliseconds(22)); //返回1356015393022 注意最后两位，无论如何刷新都是22
Date.setMinutes()
设置一个日期的分钟数
var date = new Date(); //现在是2012-12-52 22:52
document.write(date.setMinutes(1)); //返回1356012067105
var da = new Date(date);
document.write("<br/>" + da.getMinutes()); //输出1
Date.setMonth()
设置一个日期的月份数
var date = new Date(); //现在是2012-12-20
document.write(date.setMonth(2)); //返回1332255597722
var da = new Date(date);
document.write("<br/>" + da.getMonth()); //输出2
Date.setSeconds()
设置一个日期的描述
语法：
date.setSeconds(seconds)
date.setSeconds(seconds,millis)
var date = new Date(); //现在是2012-12-20
document.write(date.setSeconds(3)); //返回1356015783872
var da = new Date(date);
document.write("<br/>" + da.getSeconds()); //输出3
Date.setTime()
使用毫秒数设置一个时间
var date = new Date(); //现在是2012-12-20
document.write(date.setTime(1356015783872)); //返回1356015783872
var da = new Date(date);
document.write("<br/>" + da.getDate()); //输出20
Date.setUTCDate()
设置一个Date对象中对应月的日期值，就是几号(全球时间)
语法：
date.setUTCDate(day-of-month)
var date = new Date(); //现在是2012-12-20
document.write(date.setUTCDate(12)); //返回1355324952003
var da = new Date(date);
document.write("<br/>" + da.getDate()); //输出12
Date.setUTCFullYear()
设置一个Date对象中对应的年份，全球时间
语法：
date.setUTCFullYear(year)
date.setUTCFullYear(year,month)
date.setUTCFullYear(year,month,day)
var date = new Date();
document.write(date.setUTCFullYear(1999));
var da = new Date(date);
document.write("<br/>" + da.getFullYear()); //输出1999
Date.setUTCHours()
设置一个Date对象中对应的小时数，(全球时间)
语法：
date.setUTCHours(hours)
date.setUTCHours(hours,minutes)
date.setUTCHours(hours,minutes,seconds)
date.setUTCHours(hours,minutes,seconds,millis)
var date = new Date();
document.write(date.setUTCHours(05));
var da = new Date(date);
document.write("<br/>" + da.getUTCHours());
Date.setUTCMilliseconds()
设置一个Date对象中对应的毫秒数，(全球时间)
var date = new Date();
document.write(date.setMilliseconds(05)); //注意此处无论如何刷新都是05结尾
Date.setUTCMinutes()
设置一个Date对象的分钟、秒钟、以及毫秒值。
语法：
date.setUTCMinutes(minutes)
date.setUTCMinutes(minutes,seconds)
date.setUTCMinutes(minutes,seconds,millis)
var date = new Date(); //现在是2012-12-20
document.write(date.setUTCMinutes(25)); //返回1356017146549
var da = new Date(date);
document.write("<br/>" + da.getUTCMinutes()); //输出5
Date.setUTCMonth()
设置一个Date对象的月份值及日期值
var date = new Date(); //现在是2012-12-20
document.write(date.setMonth(01)); //返回1329751527983
var da = new Date(date);
document.write("<br/>" + da.getUTCMonth()); //输出1
Date.setUTCSeconds()
设置一个Date的秒钟及毫秒值
var date = new Date(); //现在是2012-12-20
document.write(date.setUTCSeconds(01)); //返回1356017281976
var da = new Date(date);
document.write("<br/>" + da.getUTCSeconds()); //输出1
Date.setYears()
设置一个Date对象的年份值，如果给的参数在0-99之间，它将会加上1900以便把它当中1900-1999之间的年份处理。如果输入4位数,则把它当成FullYear设置
var date = new Date(); //现在是2012-12-20
document.write(date.setYear(22)); //返回1356017281976
var da = new Date(date);
document.write("<br/>" + da.getFullYear()); //输出1922
var date = new Date(); //现在是2012-12-20
document.write(date.setYear(2011)); //返回1324395113386
var da = new Date(date);
document.write("<br/>" + da.getFullYear()); //输出2011
Date.toDateString()
以字符串的形式返回一个Date的日期部分
var date = new Date();
document.write(date.toDateString("yyyy-MM-dd"));
Date.toTimeString()
以字符串的形式返回一个Date的时间部分
var date = new Date();
document.write(date.toTimeString("yyyy-MM-dd"));
Date.toISOString()
将一个Date对象转换为ISO-8601格式的字符串,返回的字符串格式为yyyy-mm-ddThh:mm:ssZ
var date = new Date();
document.write(date.toISOString());
Date.toJSON
//JSON序列化一个对象
var date = new Date();
document.write(date.toJSON());
Date.toLocaleDateString()
以本地格式的字符串返回一个Date的日期部分,返回一个本地人可读的日期格式，日期部分
var date = new Date();
document.write(date.toLocaleDateString());
Date.toLocaleString()
将一个Date转化难为一个本地格式的字符串
var date = new Date();
document.write(date.toLocaleString());
Date.toLocaleTimeString()
将一个Date转化为本地的格式的时间部分
var date = new Date();
document.write(date.toLocaleTimeString());
Date.toString()
将一个Date转换为一个字符串
var date = new Date(); //现在是2012-12-22
document.write(date.toString());//返回Sat Dec 22 2012 19:59:17 GMT+0800
Date.toTimeString()
以字符串的形式返回一个Date对象的时间部分
var date = new Date();
document.write(date.toString());
Date.toUTCString()
将一个Date对象转换为字符串（全球时间）
var date = new Date();
document.write(date.toUTCString());
Date.UTC()
将一个Date对象转换毫秒的形式 静态方法
语法：Date.UTC(year,month,day,hours,minutes,seconds,ms)
document.write(Date.UTC(2011, 11, 11, 11, 11, 11));
Date.valueOf()
如果是一个Date对象，将一个Date对象转为毫秒的形式，否则不显示
var date = "";
document.write(date.valueOf()); //不是Date对象，不输出
var date1 = new Date();
document.write(date1.valueOf()); //输出1356180400916
**********************************************note****************************************
数组的使用
1) 数组的定义
1. 构造函数 Array
var arr = new Array(); //[]
arr[0]= "terry";
arr[1] = null;
2. 数组字面量
var arr = [
1,
"terry",
key,
{age:1},
[1,2,3],
function(){
}];
var stus = [{
},{
}]
2) 数组元素的访问
数组名[索引]
索引从0开始，(jdbc 替换占位符1)
arr[1000]
3) 数组的长度
拥有元素的个数
可读可写
arr.length 获取arr数组的长度
var arr = [1,2,3,4];
//arr.length = 2;
arr[8] = 10;
4) 数组的变量
for(var key in arr){
//key 索引
var val= arr[key]
}
5)API
1.检测数组
Array.isArray(arr);
2.转换为字符串
var result = arr.toString();
arr中元素使用,连接
arr.join("||");
arr中元素使用||连接
JSON.stringify(arr);
将arr转换为JSON格式的字符串
3.栈方法
arr.push();
将元素追加到数组的末尾
arr.pop();
将元素从数组的末尾删除
4.队列方法
arr.shift();
将元素从数组的开头删除
arr.unshift();
将元素插入大数组的开头
5.数组连接
arr.concat(arr2);
将多个数组组合成一个数组，【不改变原值】，返回值为组合后的数组
6.排序
arr.reverse(); //反转数组项的顺序
arr.sort(); //会调用每个数组项的toString() 转型方法，然后排序（将数组元素转换成字符串，按字符串的大小排序）
7.获取子数组
arr.slice();
返回值：子数组
【不改变原值】
arr.splice();
返回值：删除元素组成的子数组
8.数组中的迭代方法 迭代遍历
1)arr.forEach(function(item,index){
console.log(item);
});
参数：
function(item,index){
}
该匿名函数会被forEach调用，forEach在调用的时候会传实参，item为正遍历的元素，index为item所在的索引，arr中有几个元素，forEach会被调用几次
2)arr.every(function(item,index){
});
该匿名函数的返回值如果都为true，every返回值就为true
3)arr.some(function(item,index){
});
该匿名函数的返回值如果有true,结束some调用，直接返回true,都过都为false,返回false
4)arr.filter(function(item,index){
});
filter返回值为数组。匿名函数的返回值如果是true,将item加入到返回值数组中。
5)arr.map(function(item,index){
});
map返回值为数组。匿名函数的返回值会直接push到map的返回值中
正则表达式
1. 正则表达式对象的创建
1)构造函数
var pattern = new RegExp("正则表达式"，"修饰符");
2)正则表达式字面量
var pattern = /javascript/修饰符;
2. String match
str.match()
字符串匹配正表达式
参数：正则表达式
返回值：
1)类数组对象
数组:返回匹配的内容
index:匹配内容在str中起始位置
input:str
2)数组 //g;
如果正则是全局匹配
3. 修饰符
var p1 = /正则/修饰符; . 在正则当中表示：匹配除换行回车 空格 的任意字符
不是出现在两条斜线之间，而是出现在第二条斜线之后。
new RegExp("正则","修饰符")
i 说明匹配模式匹配是不区分大小写
g 说明模式匹配应该是全局的
m 用以在多行模式中执行匹配。
/java$/im 可以匹配"java",也可以匹配"java\nis fun"
4.直接量
/abc/i 匹配abc ABC abC...
/a/ 匹配a
/\n/ 匹配换行回车
/\./ 匹配点 但是要加反斜杠（点为特殊的字符）
5.字符类
[直接量]
匹配中括号中任意直接量
6.特殊字符类
\w 匹配任意字符,数字[0-9 a-z A-Z]
\W Words /[^ a-z A-Z 0-9]/ 除a-z A-Z 0-9以外的
\d 匹配任意数字[0-9]
\D
\s 匹配任意空白字符[[\n\t ]]
\S
7.重复
正则(子)表达式{}
{n,m} n到m 包括n,m
{n,} n到任意多次
{n} n次
? {0,1}
+ {1,}
* {0,}
8.重复方式
贪婪
尽可能多（默认）
\w{1,4} 匹配4,3,2,1次
{1，} 匹配多次
{1} 匹配一次
非贪婪
重复方式
? 0-1
?? 非贪婪匹配 尽量出现0次
+? 1-多
*? 0-多
尽可能少匹配
//------------------
JS内置函数/对象
Object
Function
Array
Date
RegExp