内建对象
宿主对象
自定义对象
数组Array 也是一个对象,和普通对象功能类似,也是用来存储一些值的,不同的是普通对象是使用字符串作为属性名的,而数组是使用数字来作为索引操作元素
索引从0开始的整数就是索引
数组的存储性能比普通对象要好,在开发中我们经常使用数组来存储一些数据
向数组中添加元素
语法: 数组 [ 索引 ] = 值 ;
读取数组中的元素
语法: 数组 [ 索引 ]
如果读取不存在的索引,不会报错,而是返回undefined
获取数组的长度,可以用length属性来获取数组的长度(元素的个数)
语法:数组 . lenth
对于连续的数组,使用length可以获取到数组的长度(元素的个数)
对于非连续的数组,使用length会获取到数组最大的索引+1,尽量不要创建非连续数组
修改length
如果修改的length大于原长度,则多出部分会空出来
如果修改的length小于原长度,则多出的元素会被删除
向数组的最后一个位置添加元素
语法:数组 [ 数组 . length ] =值 ;
var arr =new Array(); //创建数组对象
console.log(arr); //输出""
console.log(typeof arr); //输出object
arr[0]=10;
arr[1]=22;
console.log(arr); //输出"10,22"
console.log(arr[0]); //输出"10"
console.log(arr[3]); //输出undefined
//第一种情况
console.log(arr.length); //输出"2"
arr[5]=7;
arr[11]=99;
console.log(arr); //输出"10,22,,,,7,,,,,,99"
//第二种情况
arr.length=10;
console.log(arr.length); //输出"10"
conaole.log(arr); //输出"10,22,,,,,,,,"
arr.length=1;
console.log(arr.length); //输出"1"
conaole.log(arr); //输出"10"
//第三种情况
arr[arr.length] = 33;
arr[arr.length] = 44; //向数组最后一位置后添加元素
console.log(arr); //输出"10,22,33,44"
使用字面量创建数组
语法 :[ ];
使用字面量创建数组时,可以在创建时就指定数组中的元素
使用构造函数创建数组时,也可以同时添加元素,将要添加的元素作为构造函数的参数传递
元素之间使用逗号(,)隔开
var arr2 = new Array (10); //创建一个数组,长度为10,值都为空
var arr2 = new Array (10,22,33,44); //创建一个数组,长度为4,值分别为10,22,33,44
var arr =[1,2,3,4,10];
console.log(arr); //输出"1,2,3,4,10"
arr =[10]; //创建一个数组,数组中只有一个元素10
var arr2 = new Array(10); //创建一个长为10的数组
console.log(arr); //输出"10"
console.log(arr2); //输出",,,,,,,,,"
console.log(arr2.length); //输出10
数组中的元素可以是任意的数据类型,也可以是对象,也可以是一个函数
数组中也可以放数组(称为二维数组)
var arr = ["hello",1,true,null,undefined];
var obj ={name:"孙悟空"};
arr[arr.length]=obj; //添加对象
var arr2 =[{name:"孙悟空"},{name:"猪八戒"},{name:"沙和尚"}];
var arr3 = [function(){alert(1)},function(){alert(2)}};
arr[0](); //调用arr中的函数
var arr4 = [[1,2,3],[4,5,6],[7,8,9]};
console.log(arr); //输出"1,2,3,4,5,6,7,8,9"
console.log(arr[0]); //输出"1,2,3"
数组的方法
push()
可以向数组的末尾添加一个或多个元素,并返回数组的新长度,可以将要添加的元素作为方法的参数传递,这样这些元素将会自动添加到数组的末尾
该方法会将数组新的长度作为返回值返回
比length更方便,可以添加多个
pop()
可以删除数组的最后一个元素,并将被删除的元素作为返回值返回
unshift()
向数组开头添加一个或多个元素,并返回新的数组长度
向前面插入元素后,其他元素的索引会依次调整
shift()
可以删除数组的第一个元素,并将被删除的元素作为返回值返回
var arr = ["孙悟空","猪八戒","沙和尚"];
var result = arr.push("唐僧","蜘蛛精");
console.log(result); //输出5
//第一种情况
arr.pop();
console.long(arr); //输出"孙悟空,猪八戒,沙和尚,唐僧"
result = arr.pop();
console.log("result="result); //输出唐僧
//第二种情况
arr.unshift("牛魔王","二郎神");
console.log(arr); //输出"牛魔王,二郎神,孙悟空,猪八戒,沙和尚,唐僧,蜘蛛精"
result = arr.shift();
console.log(result); //输出牛魔王
slice()
可以用来从数组提取指定元素
该方法不会改变原数组,而是将截取到的元素封装到一个新数组中返回
参数:
第一个,截取开始位置的索引 ,包含开始索引
第二个,截取结束位置的索引,不包含结束索引。第二个参数可以省略不写,此时会截取开始索引往后的所有元素
索引可以传递一个负值,如果传递一个负值,则从后往前计算 -1 倒数第一个,-2倒数第二个
splice()
可以用于删除数组中的指定元素
使用splice()会影响到原数组,会将指定元素从原数组中删除,并将被删除的元素作为返回值返回
参数:
第一个,表示开始位置的索引
第二个,表示删除的数量
第三个及以后,可以传递一些新的元素,这些元素将会自动插入到开始位置索引前面
var arr=["孙悟空","猪八戒","沙和尚","唐僧","白骨精"];
var result = arr.slice(0,2);
console.log(result); //输出"孙悟空,猪八戒"
result = arr.slice(1,-2);
console.log(result); //输出"猪八戒,沙和尚"
var result = arr.splice(0,2);
console.log(arr); //输出"沙和尚,唐僧,白骨精"
console.log(result); //输出"孙悟空,猪八戒"
var result = arr.splice(1,2);
console.log(result); //输出"猪八戒,沙和尚"
。。
var result = arr.splice(0,1,"牛魔王");
console.log(arr); //输出"牛魔王,猪八戒,沙和尚,唐僧,白骨精"
var result = arr.splice(,1,"牛魔王");
console.log(arr); //输出"牛魔王,孙悟空,猪八戒,沙和尚,唐僧,白骨精" 会在开始位置索引的前面插入
var arr=[1,2,3,2,1,3,4,2,5];
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[j]==arr[i]){
arr.splice(j,1);
}
}
}
console.log(arr);
没有考虑两个相同的数连续的情况
如果出现了两个连续相同的数,如 [ 1,2,3,2,2],则会输出 [1,2,3,2 ]
因为删除了j所在的元素后,后面的元素自动补位,此时不会再比较这个元素,所以我们需要再比较一次j所在位置的元素,使j自减
var arr=[1,2,3,2,1,3,4,2,5];
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[j]==arr[i]){
arr.splice(j,1);
j--;
}
}
}
console.log(arr);
concat()
可以连接两个或多个数组,并将新的数组返回
该方法不会对原数组产生影响
join()
该方法可以将数组转换为一个字符串
该方法不会对原数组产生影响,而是将转换后的字符串作为结果返回
在join()中可以指定一个字符串作为参数,这个字符串将会成为数组中元素的连接符。如果不知道链接符,则默认使用逗号(,)作为连接符
reverse()
该方法用来反转数组(前面的去后面,后面的去前面)
该方法会直接修改原数组
var arr = ["孙悟空","猪八戒"];
var arr2 = ["沙和尚","唐僧"];
//测试 concat()
var result = arr.concat(arr2);
var arr3 = ["白龙马"];
result = arr.concat(arr2,arr3,"牛魔王");
//测试 join()
var result = arr.join();
console.log(typeof arr); //输出object
console.log(typeof result); //输出string
result = arr.join("hello");
console.log(result); //输出"孙悟空hello猪八戒"
result = arr.join("-");
console.log(result); //输出"孙悟空-猪八戒"
//测试reverse()
arr.reverse();
console.log(arr); //输出"猪八戒,孙悟空"
sort()
可以用来对数组中的元素进行排序
会影响原数组,默认按照Unicode编码进行排序
即使对于纯数字的数组,使用sort()排序时,也会按照Unicode编码排序,所以对数字排序时,可能会得到错误的结果
我们可以自己来指定排序的规则,可以在sort()中添加一个回调函数,来指定排序规则
回调函数需要定义两个形参,浏览器将会分别使用数组中的元素作为实参去调用回调函数,使用哪个元素调用不确定,但是肯定的是数组中a一定在b前面
浏览器会根据回调函数的返回值来决定元素的顺序
如果返回一个大于0的值,则元素会交换位置
如果返回小于0的值,则元素位置不变
如果返回0,则认为两个元素相等,也不交换位置
如果需要升序排序,则返回a-b
如果需要降序排序,则返回b-a
var arr = ["b","d","e","a","c"];
arr.sort();
console.log(arr); //输出"a,b,c,d,e"
arr = [5,4,8,3,7,1,6,2];
arr.sort(function(a,b){
return a-b;
}
console.log(arr); //输出1,2,3,4,5,6,7,8
数组的遍历就是将数组中的所有元素都取出来
var arr = ["孙悟空","猪八戒","沙和尚"];
for(var i=0;i<arr.length;i++){
console.log(arr[i]);
}
练习
function Person(){
var name=this.name;
var age=this.age;
}
Person.prototype.toString() {
console.log("name="+name+",age="+age);
}
var per = new Person("孙悟空",18);
var per2 = new Person("猪八戒",28);
var per3 = new Person("红孩儿",8);
var per4 = new Person("蜘蛛精",16);
var per5 = new Person("沙和尚",38);
console.log(per);
出现的一些问题
1、构造函数未写形参
2、构造函数中赋值错误
3、添加toString方法错误,Person.prototype.toString()是调用toString()方法,应该是Person.prototype.toString=function(){},且toString没有()
<script type="text/javascript">
function Person(name,age){
this.name=name;
this.age=age;
}
Person.prototype.toString =function() {
console.log("name="+name+",age="+age);
}
var per = new Person("孙悟空",18);
var per2 = new Person("猪八戒",28);
var per3 = new Person("红孩儿",8);
var per4 = new Person("蜘蛛精",16);
var per5 = new Person("沙和尚",38);
//将这些person对象放入一个数组中
var perArr = [per,per2,per3,per4,per5];
console.log(perArr);
var adult =[];
function getAdult(){
for(var i=0;i<perArr.length;i++){
if(perArr[i].age>=18){
//adult[adult.length]=perArr[i];
adult.push(perArr[i]);
}
}
}
getAdult();
console.log(adult);
如果想调用别的类中的成年人,此函数就不可使用。所以应该有个形参
function getAdult(arr){
var adult =[];
for(var i=0;i<arr.length;i++){
if(arr[i].age>=18){
//adult[adult.length]=arr[i];
adult.push(arr[i]);
}
}
return adult;
}
var result=getAdult(perArr);
console.log(result);
forEach()
一般我们都是使用for循环去遍历数组,JS中还为我们提供了一个方法用来遍历数组
这个方法对于IE只支持IE8以上的浏览器,IE8及以下的浏览器不支持该方法,所以如果需要兼容IE8,不要使用forEach()方法
forEach()方法需要一个函数作为参数,像这种由我们创建但是不由我们调用的,我们称为回调函数
数组中有几个元素,函数就会执行几次,每次执行时,浏览器会将遍历到的元素以实参的形式传递进来,我们可以定义形参,来读取这些内容
浏览器会在回调函数中传递三个参数:
第一个参数,就是当前正在遍历的元素(value)
第二个参数,就是当前正在遍历的元素的索引(index)
第三个参数,就是正在遍历的数组(obj)
var arr = ["孙悟空","猪八戒","沙和尚","唐僧"];
arr.forEach(function(value,index,obj){
console.log(value);
console.log(index);
console.log(obj);
});
function Person (name,age){
this.name=name;
this.age=age;
}
Person.prototype.toString = function() {
console.log("name:"+name+",age:"+age);
};
var per = new Person("孙悟空",18);
console.log(per); //第一题
var per2 = new Person("猪八戒",28);
var per3 = new Person("沙和尚",38);
var arr = [per,per2,per3];
console.log(arr); //第二题
arr.forEach(function (value) {
console.log(value); //第三题
})
第四题:
push()向数组最后添加元素
pop()删除数组最后一个元素
unshift()向数组最前添加元素
shift()删除数组最前一个元素
var arr =[1,2,3,3,4,5,2,2,2,6,7];
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[i]==arr[j]){
arr.splice(j,1);
j--;
}
}
}
console.log(arr); //第五题
函数的方法
call()和apply()
这两个方法都是函数对象的方法,需要通过函数对象来调用
对函数调用call()和apply()都会调用函数执行
在调用call()和apply()可以将一个对象指定为第一个参数,此时这个对象将会成为函数执行时的this
区别:
call()方法可以将实参在对象指定为第一个参数
apply()方法需要将实参封装到一个数组中统一传递
this的情况:
1、以函数形式调用时,this永远都是window
2、以方法的形式调用时,this是调用方法的对象
3、以构造函数的形式调用时,this是新创建的那个对象
4、使用apply和call调用时,this是指定的那个对象
function fun(){
alert("我是fun函数");
}
//第一种情况
fun.call(); //立即弹出alert
fun.apply(); //立即弹出alert
fun(); //三个效果相同
function fun(){
alert(this);
}
var obj={};
fun.call(obj); //弹出object,this为obj
fun.apply(obj); //弹出object
fun(obj); //弹出window
var obj={name:"obj",sayName:function(){alert(this.name);}};
var obj2={name:"obj2"};
obj.sayName(); //弹出obj
obj.sayName.apply(obj2); //弹出obj2
function fun(a,b){
console.log(a);
console.log(b);
}
var obj={};
fun.call(obj); //输出undefined,undefined
fun.call(obj,2,3); //输出2,3
fun.apply(obj,2,3); //报错
fun.apply(obj,[2,3]); //输出2,3
arguments
在调用函数时,浏览器每次都会传递两个隐含的参数:
1、函数的上下文对象 this
2、封装实参的对象arguments
arguments是一个类数组对象,它也可以通过索引来操作数据,也可以获取长度
在调用函数时,我们所传递的实参都会在arguments中保存
arguments.length可以用来获取实参的长度
即使不定义形参,也可以通过arguments来使用实参,只不过比较麻烦
arguments [ 0 ] 表示第一个实参
arguments [ 1 ] 表示第二个实参…
它有一个属性叫做callee,这个属性对应一个函数对象,就是当前正在指向的函数对象
function fun(){
console.log(arguments); //输出[object Arguments]
console.log(argument instanceof Array); //输出false
console.log(Array.isArray(arguments)); //输出false
console.log(arguments.length); //输出0
}
fun();
fun(hello);
function fun(){
console.log(arguments.length); //输出1
console.log(arguments[0]); //输出hello
console.log(arguments.callee); //输出此函数
console.log(arguments.callee==fun); //输出true
}
fun(hello);
Array.isArray(arguments)
Date对象
在JS使用Date对象表示一个时间
如果直接使用构造函数创建一个Date对象,则会封装为当前代码执行的时间
创建一个指定的时间对象,需要在构造函数中传递一个表示时间的字符串作为参数
日期的格式: 月份/日/年 时:分:秒
getDate() 获取当前日期对象是几日(1~31)
getDay() 获取当前日期对象是周几(0~6)0表示周日
getMonth() 获取当前时间对象的月份(0~11)0表示1月,1表示2月,11表示12月
getFullYear() 获取当前日期的年份
getHours() 获取Date对象的小时(0~23)
getMinutes() 获取Date对象的分钟(0~59)
getSeconds() 获取Date对象的秒数(0~59)
getMilliseconds() 获取对象的毫秒(0~999)
getTime() 获取当前日期对象的时间戳
时间戳值得是格林威治标准时间(1970年1月1日,0时0分0秒)到当前日期所花费的毫秒数(1秒=1000毫秒)
计算机底层在保存时间时使用的都是时间戳
var 变量 = Date.now();获取当前的时间戳,变量的值就是执行此行代码的时间戳
可以利用时间戳来测试代码的执行性能,分别在代码前后获取时间戳,做减法
var d = new Date();
var d2 = new Date("03/28/2020 21:48:20");
console.log(d); //输出时间
console.log(d2); //输出指定时间
var date = d2.getDate(); //28
var day = d2.getDay(); //6
var month = d2.getMonth(); //2
var year = d2.getFullYear(); //2020
。。
var d3 = new Date("1/1/1970 0:0:0");
time = d3.getTime();
console.log(time); //输出-28800000 这里设置的1970年是北京时间,与标准时间有时间差
Math
Math和其他对象不同,它不是一个构造函数,它属于一个工具类,不用创建对象,它里面封装了数学运算相关的属性和方法,如:Math.PI 表示圆周率
Math.abs() 可以用来计算一个数的绝对值
Math.ceil() 可以对一个数进行向上取整,小数位只要有值就自动进1
Math.floor() 可以对一个数进行向下取整,小数部分会被舍掉
Math.round() 可以对一个数进行四舍五入取整
Math.random() 可以生成一个0~1之间的随机数,不包含0,1
生成一个0~10的随机数
Math.round ( Math.random() * 10 )
生成一个0~x间的随机数
Math.round ( Math.random() * x )
生成一个 [ 1~10 ) 的随机数
Math.round ( Math.random() *9 +1)
生成一个x~y之间的随机数
Math.round (Math.random() *( y-x ) + x )
Math.max() 可以获取多个数中的最大值
Math.min() 可以获取多个数中的最小值
Math.pow ( x , y ) 返回x的y次幂
Math.sqrt() 求值的平方根
console.log(Date); //输出本地函数
console.log(Math); //输出 [object Math]
console.log(Math.abs(-2)); //输出2
var max=Math.max(10,45,66);
console.log(max); //输出66
console.log(Math.pow ( 2 , 3 )); //输出8
包装类
基本数据类型 Srting Number Boolean Null Undefined
引用数据类型 Object
在JS中为我们提供了三个包装类,通过这三个包装类可以将基本数据类型转换为对象
String() 可以将基本数据类型字符串转换为String对象
Number() 可以将基本数据类型数字转换为Number对象
Boolean() 可以将基本数据类型字符串转换为Boolean对象
但是注意,我们在实际应用中不会使用基本数据类型的对象,如果上基本数据类型的对象,在做一些比较时可能会带来一些不可预期的结果
方法和属性只能添加给对象,不能添加给基本数据类型
当我们对一些基本数据类型的值去调用属性和方法时,浏览器会临时使用包装类将其转换为对象,然后再调用对象的属性和方法,调用完以后再将其转换为基本数据类型
var num = new Number(3);
console.log(num); //输出3
console.log(typeof num); //输出object
num.hello="moring";
console.log(num.hello); //输出moring,num为一个对象,所以可以添加属性
var bool = new Boolean(true);
var bool2 = true;
console.log(bool \== bool2); //输出true,自动转换类型
console.log(bool \=== bool2); //输出false
。。
var b = new Boolean(false);
if(b){ //对象转为布尔值都为true
alert("我运行了"); //弹出我运行了
}
。。
var s = 123 ;
s.hello = "你好" ;
console.log(s.hello); //输出undefined。s在添加hello属性时被临时转换为对象,添加完hello属性后该对象就被销毁,s类型回到数字。此处调用s.hello时,重新将s临时转换为对象,这个对象与添加属性的对象并不是同一个,所以它没有hello属性,故输出undefined
字符串的相关方法
咋底层字符串是以字符数组的形式保存的 [ “H” , “e” , " l " … ] (空格也算一个元素)
length属性 可以获取字符串的长度
charAt() 可以返回字符串中指定位置的字符,根据索引获取指定的字符
charCodeAt() 获取指定位置字符的字符编码(Unicode编码)
String . fromCharCode() 可以根据字符编码去获取字符 (与变量无关)输入的字符编码默认是10进制,如果输入的是16进制,需要添加0x
concat() 可以连接两个或多个字符串,作用和+一样
indexOf() 可以检索一个字符串中是否含有指定内容,如果字符串中含有该内容,则会返回其第一次出现的索引。如果没有找到指定的内容,则返回 - 1。可以指定一个第二个参数,指定开始查找的位置
lastIndexOf() 该方法与indexOf一样,也可以指定开始查找的位置,不同的是indexOf是从前往后找,而lastIndexOf是从后往前找。
var str = "Hello World" ;
console.log(str[1]); //输出 e
console.log(str.length); //输出 11(空格也算一个元素)
var result = str.charaAt(1); //输出 e,可用str[1]代替
result = str.charCodeAt(1); //输出 101
result = String.fromCharCode(101); //输出 e
result = str.concat("你好","再见"); //输出 Hello World你好再见
result = str.indexOf("o"); //输出4
result = str.indexOf("o",5); //输出 7
result = str.lastIndexOf("o",5); //输出4
slice() 可以从字符串中截取指定的内容,不会影响原字符串,而是将截取到的内容返回
参数:1、开始截取位置的索引(包括开始位置)2、结束位置的索引(不包括结束位置)
如果省略第二个参数,则会截取到后面所有的
也可以传递一个负数作为参数,负数的话将从后面计算
substring() 可以用来截取一个字符串,和slice()类似
参数:1、开始截取位置的索引(包括开始位置)2、结束位置的索引(不包括结束位置)
不同的是不能接收负值作为参数,如果传递了一个负值,则默认0。而且会自动调整参数的位置,如果第二个参数小于第一个,则自动交换
substr() 用来截取字符串(ES没有对该方法进行标准化,所以不要使用)
参数:1、开始截取位置的索引 2、截取的长度
str = "abcdefjhijk";
var result = str.slice(0,2); //输出ab
result = str.slice(1,-1); //输出bcdefjhij
result = str.substring(2,-1); //即(2,0),即(0,2),输出ab
result = str.substr(3,2); //输出de
split() 可以将一个字符串拆分为一个数组
参数:需要一个字符串作为参数,将会根据该字符串去拆分数组
如果传递一个空串作为参数,则会将每个字符都拆分为数组中的一个元素
toUpperCase() 将一个字符串转换为大写并返回
toLowerCase() 将一个字符串转换为小写并返回
var str = "abc,bcd,efg,hij";
var result = str.split(","); //输出[ "abc" ,"bcd","efg","hij" ]。typrof为object
console.log(Array.isArray(result)); //输出true
正则表达式 RegularExpression又称规则表达式,用于定义一些字符串的规则,计算机可以根据正则表达式检查一个字符串是否符合规则,或者将字符串中符合规则的内容提取出来
语法:var 变量 = new RegExp ( “正则表达式” , “匹配模式” );
使用typeof检查正则表达式,会返回object(对象除了函数检查为function,其他均为object)
var reg = new RegExp(“a”); //这个正则表达式可以用来检查一个字符串中是否含有a
使用字面量创建正则表达式,这种方法更加简单,但是使用构造函数创建更加灵活
语法:var 变量 = / 正则表达式 / 匹配模式
var reg = /a/i;
在构造函数中可以传递一个匹配模式作为第二个参数,可以是:i 忽略大小写、g 全局匹配模式
可以为一个正则表达式设置多个匹配模式,且顺序无所谓
正则表达式的方法
test() 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则,如果符合则返回true,否则返回false
var reg = new RegExp("a"); //这个正则表达式可以用来检查一个字符串中是否含有a
console.log(reg); //输出/a/,typeof为object
var str = "a";
var result = reg.test(str); //输出true
使用 | 表示或者的意思
中括号 [ ] 里的内容也是或的关系
[ ab ] == a | b
[ a - z ] 任意小写字母
[ A - Z ] 任意大写字母
[ A - z ] 任意字母
[ 0 - 9 ] 任意数字
[^ ] 任何不在中括号里的
var reg = /a|b|c/; //检查字符串中是否含有a或b或c
reg =/a[bcd]a/; //检查字符串中是否含有aba,aca,ada
reg =/[^ab]/; //除了ab
console.log(reg.test("abc")); //输出true
console.log(reg.test("a")); //输出false
量词通过量词可以设置一个内容出现的次数
量词只对它前面的一个内容起作用,可添加()
{ n } 正好出现n次
{ m, n } 出现m~n次
{ m, } 出现m次以上
+ 至少一个,相当于{ 1,}
* 0个或多个,相当于{ 0,}
? 0个或1个,相当于{ 0,1 }
var reg = /a{3} /; //检查一个字符串是否含有aaa
var reg = /(ab){ 3}/; //检查是否含有ababab
var reg =/ab{ 3 }c/; //检查是否含有abbbc
var reg =/ab{1,3}c/; //检查是否含有abc,abbc,abbbc
var reg =/ab+c/;
var reg =/ab*c/;
var reg =/ab?c/;
检查是否以a开头
^ 表示开头
$ 表示结尾
如果在正则表达式中同时使用^ $,则要求字符串必须完全符合正则表达式
var reg =/^a/; //开头的a
var reg =/a$/; //结尾的a
var reg =/^a$/; //a开头的同时也是结尾,所以只有"a" 才是true
var reg =/^a|a$/; //以a开头或者以a结尾
// ^1 [3-9] [0-9]{9}$
var phoneStr ="13854976584";
var phoneReg =/^1[3-9][0-9]{9}$/;
console.log(phoneReg.test(phoneStr));
检查一个字符串中是否含有 .
. 表示任意字符
\\ 表示 \
在正则表达式中使用\作为转义字符
使用构造函数时,由于它的参数是一个字符串,而\是字符串中的转义字符,如果要使用 \ ,则需要使用 \\ 来代替
var reg =/\./; //检查.
var reg =/\\/; //检查\
reg =new RegExp("\."); //需要两个\\,才会输出\.
console.log(reg.test("$#%@")); //输出true
console.log(reg); //输出/./
\w 任意字母,数字、_ (相当于 [ A-z0-9_ ] )
\W 除了任意字母,数字、_ (相当于 [ ^A-z0-9_ ] )
\d 任意数字 (相当于 [ 0-9 ] )
\D 除了数字 (相当于 [ ^0-9 ] )
\s 空格
\S 除了空格
\b 单词边界
\B 除了单词边界
reg = /child/;
console.log(reg.test("Hello Children"); //输出true
reg = /\bchild\b/;
console.log(reg.test("Hello Children"); //输出false
//去掉字符串中的空格,就是使用""来替换空格
var str =" he llo ";
str =str.replace(/\s/g,""); //这种方法也会去掉中间的空格
console.log(str); //输出hello
//去掉开头的空格
str =str.replace(/^\s*/,"");
console.log(str); //输出"he llo "
//去掉结尾的空格
str =str.replace(/\s*$/,"");
//合并
str = str.replace(/^\s*|\s*$/g,"");
字符串和正则相关的方法
split() 可以将一个字符串拆分为一个数组
方法中可以传递一个正则表达式作为参数,这样方法将会根据正则表达式去拆分字符串
这个方法即使不指定全局匹配,也会全部拆分
match() 可以根据正则表达式,从一个字符串中将符合条件的内容提取出来
默认情况下,match只会找到第一个符合要求的内容,找到以后就停止检索。我们可以设置正则表达式为全局匹配模式,这样就会匹配到所有的内容
match() 会将匹配到的内容封装到一个数组中返回,即使只查询到一个结果
var str = "1a2b3c4d5e6f7";
//根据任意字母将字符串拆分
var result = str.split(/[A-z]/); //输出1,2,3,4,5,6,7
result = str.match(/[A-z]/); //输出 a
result = str.match(/[A-z]/g); //输出 a,b,c,d,e,f
var str2 ="1a2b3c4d5e6f7A8B9C";
result = str2.math(/[a-z]/gi); //输出a,b,c,d,e,f,A,B,C。ig既忽略大小写,又全局匹配模式
search() 可以搜索字符串中是否含有指定内容
如果搜索到指定内容,则会返回第一次出现的索引,如果没有搜索到返回-1
它可以接收一个正则表达式作为参数,然后根据正则表达式去检索字符串
只会查找第一个,即使设置了全局匹配也没用
replace() 可以将字符串中指定内容替换为新的内容
参数:
1、被替换的内容 ,可以接受一个正则表达式作为参数
2、新的内容
默认只会替换第一个
var str = "hello abc hello aec afc";
//搜索字符串中是否含有abc,或aec,或afc
result = str.search(/a[bef]c/); //输出 6
var str2 = "1a2b3c4d5e6f7a";
result = str.replace("a","@@"); //输出1@@2b3c4d5e6f7a
result = str.replace(/a/g,"@@"); //输出1@@2b3c4d5e6f7@@
// \w{3,} (\.\w+)* @ [A-z0-9]+ (\.[A-z]{2,5}){1,2}
var emailReg=/\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}/;
console.log(emailReg.test("[email protected]")); //输出true
//应该加上 邮箱的开头和结尾
var emailReg=/^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;