javascript 的函数对象方法、arguments对象、Date对象、Math工具类、包装类、字符串方法、正则表达式：
- Ⅰ、函数对象方法(包含this情况)：call()/apply()
- Ⅱ、arguments类数组对象：
- Ⅲ、Date对象：
- Ⅳ、Math工具类：
- Ⅴ、包装类：
- Ⅵ、字符串方法：charAt(),charCodeAt(),concat(),indexOf(),lastIndexOf(),slice(),substring(),substr(),split(),toUpperCase(),toLowerCase(),String.formCharCode()
- Ⅶ、正则表达式：
-
- [其一、代码为：正则定义(new RegExp())](#其一、代码为：正则定义(new RegExp()))
- 其二、结果为：
- 其三、代码为：用字面量创建正则
- 其四、结果为：
- 其五、代码为：正则与字符串联用(split(),search(),match(),replace())
- 其六、结果为：
- 其七、代码为：将字符串逆序输出案例
- 其八、结果为：
- [其九、代码为：正则量词的使用 {},+,*,?,^,](#其九、代码为：正则量词的使用 {},+,*,?,^,)
- 其十、结果为：
- [其十一、代码为：正则 \(转义字符),\w,\W,\d,\D,\s,\S,\b,\B,\\,\.](#其十一、代码为：正则 \(转义字符),\w,\W,\d,\D,\s,\S,\b,\B,\,.)
- 其十二、结果为：
- 其十三、代码为：符合邮件正则规则的案例
- 其十四、结果为：
- Ⅷ、小结：
Ⅰ、函数对象方法(包含this情况)：call()/apply()
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
function fun(a,b) {
console.log("a = "+a);
console.log("b = "+b);
//alert(this);
console.log(this);
}
var obj = {
name: "obj",
sayName:function(){
// alert(this.name);
console.log(this);
}
};
/*
* call() 和 apply()
* - 这两个方法都是函数对象的方法，需要通过函数对象来调用
* - 当对函数调用 call() 和 apply() 都会调用函数执行
* - 在调用 call() 和 apply() 可以将一个对象指定为第一个参数
* 此时这个对象将会成为函数执行时的 this(即：call 函数和 apply 函数，都可以修改函数执行时的 this 值(即：可修改 this 指向))
* - call() 方法可以将实参在对象之后依次传递
* - apply() 方法需要将实参封装到一个数组中统一传递
*
* - this 的情况：
* 1.以函数形式调用时，this 永远都是 window
* 2.以方法的形式调用时，this 是调用方法的对象
* 3.以构造函数的形式调用时，this 是新创建的那个对象
* 4.使用 call 和 apply 调用时，this 是指定的那个对象
*/
// fun.call(obj,2,3);// a = 2 b = 3 {name: 'obj', sayName: ƒ}(即：此时 this 指向为 obj)
// fun.apply(obj,[4,5]);// a = 4 b = 5 {name: 'obj', sayName: ƒ}(即：此时 this 指向为 obj)
var obj2 = {
name: "obj2"
};
// fun.apply();// a = undefined b = undefined Window {}(即：此时 this 指向为 Window)
// fun.call();// a = undefined b = undefined Window {}(即：此时 this 指向为 Window)
// fun();// a = undefined b = undefined Window {}(即：此时 this 指向为 Window)
// fun.call(obj);// a = undefined b = undefined {name: 'obj', sayName: ƒ}(即：此时 this 指向为 obj)
// fun.apply(obj);// a = undefined b = undefined {name: 'obj', sayName: ƒ}(即：此时 this 指向为 obj)
// fun();// a = undefined b = undefined Window {}(即：此时 this 指向为 Window)
obj.sayName.apply(obj2);// {name: 'obj2'}(即：此时 this 指向为 obj2)
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅱ、arguments类数组对象：
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 在调用函数时，浏览器每次都会传递进两个隐含的参数：
* 1.函数的上下文对象 this
* 2.封装实参的对象 arguments
* - arguments 是一个类数组对象,它也可以通过索引来操作数据，也可以获取长度
* - 在调用函数时，我们所传递的实参都会在 arguments 中保存
* - arguments.length 可以用来获取实参的长度
* - 我们即使不定义形参，也可以通过 arguments 来使用实参，
* 只不过比较麻烦
* arguments[0] 表示第一个实参
* arguments[1] 表示第二个实参 。。。
* - 它里边有一个属性叫做 callee，
* 这个属性对应一个函数对象，就是当前正在指向的函数的对象
*
*/
function fun(a,b){
console.log(arguments instanceof Array);// false(即：说明 arguments 并不是数组)
console.log(Array.isArray(arguments));// false(即：说明 arguments 并不是数组)
console.log(arguments[1]);// true(即：表示第二个实参)
console.log(arguments.length);// 2(即：说明有 2 个实参)
console.log(arguments.callee == fun);//true(即：当前正在指向的函数的对象是 fun)
}
fun("hello",true);
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅲ、Date对象：
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* Date 对象
* - 在 JS 中使用 Date 对象来表示一个时间
*/
//创建一个 Date 对象
//如果直接使用构造函数创建一个 Date 对象，则会封装为当前代码执行的时间
var d = new Date();
//创建一个指定的时间对象
//需要在构造函数中传递一个表示时间的字符串作为参数
//日期的格式 月份/日/年 时:分:秒
var d2 = new Date("2/18/2011 11:10:30");
// console.log(d2)// Fri Feb 18 2011 11:10:30 GMT+0800 (中国标准时间)
/*
* getDate()
* - 获取当前日期对象是几日(即：一个月中的某一天，1-31)
*/
var date = d2.getDate();
// console.log(date)// 18(即：表示第18天)
/*
* getDay()
* - 获取当前日期对象时周几(即：一周内的某一天，0-6)
* - 会返回一个 0-6 的值
* 0 表示周日
* 1 表示周一
* 。。。
*/
var day = d2.getDay();
// console.log(day)// 5(即：表示周五)
/*
* getMonth()
* d2 = new Date("12/18/2011 11:10:30");
* - 获取当前时间对象的月份(即：一年中的某一月份，0-11)
* - 会返回一个 0-11 的值
* 0 表示 1 月
* 1 表示 2 月
* 11 表示 12 月
*/
var month = d2.getMonth();
// console.log(month)// 1(即：表示2月)
/*
* getFullYear()
* - 获取当前日期对象的年份(即：以四位数字返回年份)
*/
var year = d2.getFullYear();
// console.log(d2);// Fri Feb 18 2011 11:10:30 GMT+0800 (中国标准时间)
// console.log("day = "+day);// day = 5
// console.log("date = "+date);// date = 18
// console.log("month = "+month);// month = 1
// console.log(year);// 2011
/*
* getTime()
* - 获取当前日期对象的时间戳
* - 时间戳，指的是从格林威治标准时间的 1970 年 1 月 1 日，0 时 0 分 0 秒
* 到当前日期所花费的毫秒数（1秒 = 1000毫秒）
* - 计算机底层在保存时间时使用都是时间戳
*/
var time = d2.getTime();
// console.log(time/1000/60/60/24/365);// 41.15926655251142(即：从 2011/2/18 到 1970/1/1 的时间为 41.16 年)
// var d3 = new Date("1/1/1970 0:0:0");
// time = d3.getTime();//发现输出结果是负值(负值表示：此时的实际日期是在 1970 年前)，并不是为0(原因：是中国的时间，有8个小时的时差)
// console.log(time);// -28800000
//利用时间戳来测试代码的执行的性能
//获取当前的时间戳
var start = Date.now();
for(var i=0 ; i<100 ; i++){
console.log(i);
}
var end = Date.now();
console.log("执行了："+(end - start)+"毫秒");// 执行了：6毫秒
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅳ、Math工具类：
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* Math
* - Math 和其他的对象不同，它不是一个构造函数，
* 它属于一个工具类不用创建对象，它里边封装了数学运算相关的属性和方法
* - 比如
* Math.PI 表示的圆周率
*/
// console.log(Math.PI);// 3.141592653589793
/*
* abs() 可以用来计算一个数的绝对值
*/
// console.log(Math.abs(-1));// 1
/*
* Math.ceil()
* - 可以对一个数进行向上取整，小数位只要有值就自动进1
* Math.floor()
* - 可以对一个数进行向下取整，小数部分会被舍掉
* Math.round()
* - 可以对一个数进行四舍五入取整
*/
// console.log(Math.ceil(1.1));// 2
// console.log(Math.floor(1.99));// 1
// console.log(Math.round(1.4));// 1
/*
* Math.random()
* - 可以用来生成一个 0-1 之间的随机数
* - 生成一个 0-10 的随机数
* - 生成一个 0-x 之间的随机数
* Math.round(Math.random()*x)
*
* - 生成一个 1-10
* - 生成一个 x-y 之间的随机数
* Math.round(Math.random()*(y-x)+x)
*/
// for(var i=0 ; i<100 ; i++){
// //console.log(Math.round(Math.random()*10));// 生成 0-10 之间的随机数
// //console.log(Math.round(Math.random()*20));// 生成 0-20 之间的随机数
// //console.log(Math.round(Math.random()*9)+1);// 生成 1-10 之间的随机数
// //console.log(Math.round(Math.random()*8)+2);// 生成 2-10 之间的随机数
// //生成 1-6 之间的随机数
// console.log(Math.round(Math.random()*5+1));
// }
/*
* max() 可以获取多个数中的最大值
* min() 可以获取多个数中的最小值
*/
var max = Math.max(10,45,30,100);
var min = Math.min(10,45,30,100);
// console.log(max);// 100
// console.log(min);// 10
/*
* Math.pow(x,y)
* 返回x的y次幂
*/
// console.log(Math.pow(12,3));// 12 的 3 次幂为 1728
/*
* Math.sqrt()
* 用于对一个数进行开方运算
*/
console.log(Math.sqrt(2));// 根号 2 为 1.4142135623730951
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅴ、包装类：
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 基本数据类型
* String Number Boolean Null Undefined
* 引用数据类型
* Object
*
* 在 JS 中为我们提供了三个包装类，通过这三个包装类可以将基本数据类型的数据转换为对象
* String()
* - 可以将基本数据类型字符串转换为 String 对象
* Number()
* - 可以将基本数据类型的数字转换为 Number 对象
* Boolean()
* - 可以将基本数据类型的布尔值转换为 Boolean 对象
* 但是注意：我们在实际应用中不会使用基本数据类型的对象，
* 如果使用基本数据类型的对象，在做一些比较时可能会带来一些不可预期的结果
*/
//创建一个 Number 类型的对象
//num = 3;
var num = new Number(3);
var num2 = new Number(3);
var str = new String("hello");
var str2 = new String("hello");
var bool = new Boolean(true);
var bool2 = true;
//向 num 中添加一个属性
num.hello = "abcdefg";
// console.log(str === str2);//false，因为是创建了两个对象，此时比较的是两个对象的地址，是不相同的两个地址;
var b = new Boolean(false);
// if(b){ //对象转为布尔值都是 true(即：布尔值转为 Boolean 对象再用布尔值判断一定为 true),因此此时永远会出现弹窗;
// alert("我运行了~~~");
// }
/*
* 方法和属性能添加给对象，不能添加给基本数据类型
* 当我们对一些基本数据类型的值去调用属性和方法时，
* 浏览器会临时使用包装类将其转换为对象，然后在调用对象的属性和方法
* 调用完以后，在将其转换为基本数据类型
*/
var s = 123;
s = s.toString();
s.hello = "你好";//内部操作：s 是基本类型，在执行 s.hello 操作时，s 会被浏览器临时转换成包装类，在 s.hello 操作完成后再转换成基本类型，但输出 s.hello 为 undefined;
//注意：第一次调用 s.hello 操作与第二次调用 s.hello 操作时转化的对象是不一样的，都是使用时转化成包装类，使用完毕就将该包装类销毁掉，然后转化成基本类型;
console.log(s.hello);// undefined
console.log(typeof s);// string
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅵ、字符串方法：charAt(),charCodeAt(),concat(),indexOf(),lastIndexOf(),slice(),substring(),substr(),split(),toUpperCase(),toLowerCase(),String.formCharCode()
其一、代码为：
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
//创建一个字符串
var str = "Hello Atguigu";
/*
* 在底层字符串是以字符数组的形式保存的
* ["H","e","l"]
*/
/*
* length 属性
* - 可以用来获取字符串的长度
*/
// console.log(str.length);// 13
// console.log(str[5]);// (即：str[5] 刚好是空格，因此输出的是空格)
/*
* charAt()
* - 可以返回字符串中指定位置的字符
* - 根据索引获取指定的字符
*/
str = "中Hello Atguigu";
// console.log(str)// 中Hello Atguigu
var result = str.charAt(6);
// console.log(result)// (即：str.charAt(6) 刚好是空格，因此输出的是空格)
/*
* charCodeAt()
* - 获取指定位置字符的字符编码（Unicode 编码）
*/
// console.log(str)// 中Hello Atguigu
result = str.charCodeAt(0);
// console.log(result)// 20013(即：此时 '中' 的 Unicode 编码为 20013)
/*
* String.formCharCode()
* - 可以根据字符编码去获取字符(注意：是用构造函数来调用的 fromCharCode 方法)
*/
result = String.fromCharCode(0x2692);
// console.log(result)// ⚒(即：此时 0x2692 的 Unicode 编码对应的字符为 ⚒)
/*
* concat()
* - 可以用来连接两个或多个字符串
* - 作用和 + 一样
*/
// console.log(str)// 中Hello Atguigu
result = str.concat("你好","再见");
// console.log(result)// 中Hello Atguigu你好再见
/*
* indexOf()
* - 该方法可以检索一个字符串中是否含有指定内容
* - 如果字符串中含有该内容，则会返回其第一次出现的索引
* 如果没有找到指定的内容，则返回 -1
* - 可以指定一个第二个参数，指定开始查找的位置
*
* lastIndexOf();
* - 该方法的用法和 indexOf() 一样，
* 不同的是 indexOf 是从前往后找，
* 而 lastIndexOf 是从后往前找
* - 也可以指定开始查找的位置(即：[0-第二个参数] 中从后往前第一个参数的索引)
*/
str = "hello hatguigu";
// console.log(str)// hello hatguigu
result = str.indexOf("h",1);
// console.log(result)// 6(即：从 1 这个索引往后寻找第一个 'h' 的索引为 6)
result = str.indexOf("i",1);
// console.log(result)// 11(即：从 1 这个索引往后寻找第一个 'h' 的索引为 11)
str = "hello hatguigu";
// console.log(str)// hello hatguigu
result = str.lastIndexOf("i");
// console.log(result)// 11(即：从后往前寻找第一个 'i' 的索引为 11)
// console.log(str)// hello hatguigu
result = str.lastIndexOf("h",5);
// console.log(result)// 0(即：从 [0-5] 的范围内，从后往前寻找第一个 'h' 的索引为 6)
result = str.lastIndexOf("h",8);
// console.log(result)// 6(即：从 [0-8] 的范围内，从后往前寻找第一个 'h' 的索引为 6)
result = str.lastIndexOf("u",13);
// console.log(result)// 13(即：从 [0-13] 的范围内，从后往前寻找第一个 'u' 的索引为 13)
result = str.lastIndexOf("i",8);
// console.log(result)// -1(即：从 [0-8] 的范围内，从后往前寻找第一个 'i' 的索引不存在)
/*
* slice()
* - 可以从字符串中截取指定的内容
* - 不会影响原字符串，而是将截取到内容返回
* - 参数：
* 第一个，开始位置的索引（包括开始位置）
* 第二个，结束位置的索引（不包括结束位置）
* - 如果省略第二个参数，则会截取到后边所有的
* - 也可以传递一个负数作为参数，负数的话将会从后边计算(即：-1 表示倒数第一个，-2 表示倒数第二个)
*/
str = "abcdefghijk";
// console.log(str)// abcdefghijk
result = str.slice(1,4);
// console.log(result)// bcd(即：[1,4)，从第一个到第四个，包含第一个不包含第四个])
result = str.slice(1,-1);
// console.log(result)// bcdefghij(即：从第一个到最后一个，包含第一个不包含最后一个)
// console.log(str)// abcdefghijk
/*
* substring()
* - 可以用来截取一个字符串，与 slice() 类似
* - 参数：
* - 第一个：开始截取位置的索引（包括开始位置）
* - 第二个：结束位置的索引（不包括结束位置）
* - 不同的是这个方法不能接受负值作为参数，
* 如果传递了一个负值，则默认使用 0
* - 而且他还自动调整参数的位置，如果第二个参数小于第一个，则自动交换(即：str.substring(1,0) 的实际效果就是 str.substring(0,1))
*/
// console.log(str)// abcdefghijk
result = str.substring(0,1);
// console.log(result)// a
// console.log(str)// abcdefghijk
/*
* substr()
* - 用来截取字符串(不建议用，因为 ECMAscript 中没对该方法标准化)
* - 参数：
* 1.截取开始位置的索引
* 2.截取的长度
*/
str = "abcdefg";
// console.log(str)// abcdefg
result = str.substr(3,2);
// console.log(result)// de
// console.log(str)// abcdefg
/*
* split()
* - 可以将一个字符串拆分为一个数组
* - 参数：
* -需要一个字符串作为参数，将会根据该字符串去拆分数组
*/
str = "abcbcdefghij";
// console.log(str)// abcbcdefghij
result = str.split("d");
// console.log(result)// ['abcbc', 'efghij']
// console.log(str)// abcbcdefghij
/*
* 如果传递一个空串作为参数，则会将每个字符都拆分为数组中的一个元素
*/
result = str.split("");
// console.log(Array.isArray(result));// true
// console.log(result[0]);// a
// console.log(result);// ['a', 'b', 'c', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
str = "abcdefg";
/*
* toUpperCase()
* - 将一个字符串转换为大写并返回
*/
// console.log(str)// abcdefg
result = str.toUpperCase();
// console.log(result)// ABCDEFG
// console.log(str)// abcdefg
str = "ABCDEFG";
/*
* toLowerCase()
* -将一个字符串转换为小写并返回
*/
console.log(str)// ABCDEFG
result = str.toLowerCase();
console.log(result);// abcdefg
console.log(str)// ABCDEFG
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
Ⅶ、正则表达式：
其一、代码为：正则定义(new RegExp())
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 正则表达式
* - admin@atguigu.com
* - admin@.com adminatguigu.com
* - 邮件的规则：
* 1.前边可以是 xxxx 乱七八糟
* 2.跟着一个 @
* 3.后边可以是 xxxx 乱七八糟
* 4..com 获取其他的乱七八糟
*
* - 正则表达式用于定义一些字符串的规则，
* 计算机可以根据正则表达式，来检查一个字符串是否符合规则，
* 或者将字符串中符合规则的内容提取出来
*/
//创建正则表达式的对象
/*
* 语法：
* var 变量 = new RegExp("正则表达式","匹配模式");
* 使用 typeof 检查正则对象，会返回 object
* var reg = new RegExp("a"); 这个正则表达式可以来检查一个字符串中是否含有 a
* 在构造函数中可以传递一个匹配模式作为第二个参数，
* 可以是
* i 忽略大小写
* g 全局匹配模式
*/
var reg = new RegExp("ab","i");// 检查字符串中是否含有 'ab'，并忽略大小写
var str = "a";
/*
* 正则表达式的方法：
* test()
* - 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则，
* 如果符合则返回 true，否则返回 false
*/
var result = reg.test(str);
console.log(result);// false(即：在 str 中未含有忽略大小写的 'ab'，因此输出为 false)
console.log(reg.test("Ab"));// true(即：在 "Ab" 中含有忽略大小写的 'ab'，因此输出为 true)
</script>
</head>
<body>
</body>
</html>其二、结果为：
// 一进入页面后的控制台：
其三、代码为：用字面量创建正则
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 使用字面量来创建正则表达式
* 语法：var 变量 = /正则表达式/匹配模式
* 使用字面量的方式创建更加简单
* 使用构造函数创建更加灵活
*
*/
//var reg = new RegExp("a","i");
var reg = /a/i;
// console.log(typeof reg);// object
// console.log(reg.test("abc"));// true(即：'abc' 中存在 'a')
//创建一个正则表达式，检查一个字符串中是否有 a 或 b 或 c
/*
* 使用 | 表示或者的意思
*/
reg = /a|b|c/;
/*
* 创建一个正则表达式检查一个字符串中是否有字母
*/
//reg = /a|b|c|d|e|f|g/;
/*
* []里的内容也是或的关系
* [ab] == a|b
* [a-z] 任意小写字母
* [A-Z] 任意大写字母
* [A-z] 任意字母
* [0-9] 任意数字
*/
reg = /[A-z]/;
//检查一个字符串中是否含有 abc 或 adc 或 aec
reg = /a[bde]c/;
/*
* [^ ] 除了
*/
reg = /[^ab]/;//表示除了 ab 之外，若还有其它元素则返回 true;
reg = /[^0-9]/;//表示除了数字之外，若还有其它元素则返回为 true;
console.log(reg.test("12a3456"));// true(即：字符串中存在非数字的元素)
</script>
</head>
<body>
</body>
</html>其四、结果为：
// 一进入页面后的控制台：
其五、代码为：正则与字符串联用(split(),search(),match(),replace())
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
var str = "1a2b3c4d5e6f7";
/*
* split()
* - 可以将一个字符串拆分为一个数组
* - 方法中可以传递一个正则表达式作为参数，这样方法将会根据正则表达式去拆分字符串
* - 这个方法即使不指定全局匹配，也会全都拆分
*/
/*
* 根据任意字母来将字符串拆分
*/
// console.log(str)// 1a2b3c4d5e6f7
var result = str.split(/[A-z]/);
// console.log(result);// ['1', '2', '3', '4', '5', '6', '7']
// console.log(str)// 1a2b3c4d5e6f7
/*
* search()
* - 可以搜索字符串中是否含有指定内容
* - 如果搜索到指定内容，则会返回第一次出现的索引，如果没有搜索到返回 -1
* - 它可以接受一个正则表达式作为参数，然后会根据正则表达式去检索字符串
* - search() 只会查找第一个，即使设置全局匹配也没用
*/
str = "hello abc hello aec afc";
/*
* 搜索字符串中是否含有 abc 或 aec 或 afc
*/
// console.log(str)// hello abc hello aec afc
result = str.search(/a[bef]c/);
// console.log(result);// 6(即：str 中第一次出现 /a[bef]c/ 的索引为 6)
// console.log(str)// hello abc hello aec afc
/*
* match()
* - 可以根据正则表达式，从一个字符串中将符合条件的内容提取出来
* - 默认情况下我们的 match 只会找到第一个符合要求的内容，找到以后就停止检索
* 我们可以设置正则表达式为全局匹配模式，这样就会匹配到所有的内容
* 可以为一个正则表达式设置多个匹配模式，且顺序无所谓
* - match() 会将匹配到的内容封装到一个数组中返回，即使只查询到一个结果
*
*
*/
str = "1a2a3a4a5e6f7A8B9C";
// console.log(str)// 1a2a3a4a5e6f7A8B9C
result = str.match(/[A-z]/);//此时是在 str 中找到第一个符合 /[A-z]/ 要求的字符，就停止检索; 此时的输出结果为：a
// console.log(result)// ['a', index: 1, input: '1a2a3a4a5e6f7A8B9C', groups: undefined](即：实际为 ['a'])
result = str.match(/[a-z]/ig);//g 表示全局匹配(即：匹配全局而非找到第一个符合的就停止检索)，i 表示忽略大小写; 此时的输出结果为：a,a,a,a,e,f,A,B,C(注意是数组)
// console.log(result)// ['a', 'a', 'a', 'a', 'e', 'f', 'A', 'B', 'C']
// console.log(result[2]);// a
// console.log(str)// 1a2a3a4a5e6f7A8B9C
/*
* replace()
* - 可以将字符串中指定内容替换为新的内容
* - 参数：
* 1.被替换的内容，可以接受一个正则表达式作为参数
* 2.新的内容
* - 默认只会替换第一个
*/
console.log(str)// 1a2a3a4a5e6f7A8B9C
result = str.replace(/[a-z]/gi , "@_@");//此时是匹配全局将字母替换成 "@_@"(即：将 str 字符串中的所有字母替换为 "@_@")
console.log(result);// 1@_@2@_@3@_@4@_@5@_@6@_@7@_@8@_@9@_@
result = str.replace(/[a-z]/gi , "");//此时是匹配全局将字母替换成空字符串(即：去除 str 字符串中的所有字母)
console.log(result);// 123456789
console.log(str)// 1a2a3a4a5e6f7A8B9C
</script>
</head>
<body>
</body>
</html>其六、结果为：
// 一进入页面后的控制台：
其七、代码为：将字符串逆序输出案例
html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
<script type="text/javascript">
// var str = prompt("请输出任意的内容:");
var str = "hello world!"
//var arr = str.split("");
//arr.reverse();
//str = arr.join("");
console.log(str)// hello world!
str = str.split("").reverse().join("");
console.log(str)// !dlrow olleh
</script>
</head>
<body>
</body>
</html>其八、结果为：
// 一进入页面后的控制台：
其九、代码为：正则量词的使用 {},+,*,?,^,$
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 创建一个正则表达式检查一个字符串中是否含有 aaa
*/
/*
* 量词
* - 通过量词可以设置一个内容出现的次数
* - 量词只对它前边的一个内容起作用
* - {n} 正好出现 n 次
* - {m,n} 出现 m-n 次
* - {m,} m 次以上
* - + 至少一个，相当于{1,}
* - * 0 个或多个，相当于{0,}
* - ? 0 个或 1 个，相当于{0,1}
*/
var reg = /a{3}/;
//ababab
reg = /(ab){3}/;
reg = /b{3}/;
reg1 = /ab{1,3}c/;
reg = /ab{3,}c/;
reg = /ab+c/;
reg = /ab*c/;
reg = /ab?c/;
// console.log(reg1.test("aaaabccc"));// true(即：字符串中包含至少有一个 b 的 ab{1,3}c，因此输出为 true)
// console.log(reg1.test("acbbbc"));// false(即：字符串中包含至少有一个 b 的 ab{1,3}c，因此输出为 false)
// console.log(reg.test("abbc"));// false(即：字符串中包含至多有一个 b 的 ab?c，因此输出为 false)
// console.log(reg.test("ac"));// true(即：字符串中包含至多有一个 b 的 ab?c，也可以没有 b，因此输出为 true)
/*
* 检查一个字符串中是否以 a 开头
* ^ 表示开头
* $ 表示结尾
*/
reg = /^a/; //匹配开头的 a
reg = /a$/; //匹配结尾的 a
// console.log(reg.test("abcabca"));// true(即：该字符串是以 a 结尾的字符串，因此输出为 true)
/*
* 如果在正则表达式中同时使用 ^ $ 则要求字符串必须完全符合正则表达式
*/
// reg = /^a|a$/;//该正则表示：以 a 开头或以 a 结尾;
reg = /^a$/;
// console.log(reg.test("bbca"));// false(即：该字符串是以 a 结尾但不是以a开头的字符串，因此输出为 false)
/*
* 创建一个正则表达式，用来检查一个字符串是否是一个合法手机号
*
* 手机号的规则：
* 1 3 567890123 （11位）
*
* 1. 以 1 开头
* 2. 第二位 3-9 任意数字
* 3. 三位以后任意数字 9 个
*
* ^1 [3-9] [0-9]{9}$
*
*/
var phoneStr = "13067890123";
// var phoneReg = /^1[3-9][0-9]{9}$/;//表示 phoneStr 字符串中只要有手机号，返回值就为 true(即：除了要求的手机号外，可以有其它的字符);
var phoneReg = /^1[3-9][0-9]{9}$/;//表示：完全符合正则表达式(即：要求的手机号)的需求;
console.log(phoneReg.test(phoneStr));// true(即：字符串符合合法手机号的校验规则，因此输出为 true)
</script>
</head>
<body>
</body>
</html>其十、结果为：
// 一进入页面后的控制台：
其十一、代码为：正则 (转义字符),\w,\W,\d,\D,\s,\S,\b,\B,\,.
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 检查一个字符串中是否含有 .
* . 表示任意字符
* 在正则表达式中使用 \ 作为转义字符
* \. 来表示 .
* \\ 表示 \
*
* 注意：使用构造函数时，由于它的参数是一个字符串，而 \ 是字符串中转义字符，
* 如果要使用 \ 则需要使用 \\ 来代替
*/
var reg = /\./;
reg = /\\/;
reg = new RegExp("\\.");
reg = new RegExp("\\\\");
/*
* \w
* - 任意字母、数字、_ [A-z0-9_]
* \W
* - 除了字母、数字、_ [^A-z0-9_]
* \d
* - 任意的数字 [0-9]
* \D
* - 除了数字 [^0-9]
* \s
* - 空格
* \S
* - 除了空格
* \b
* - 单词边界
* \B
* - 除了单词边界
*/
reg = /\w/;
reg = /\W/;
reg = /\d/;
reg = /\D/;
reg = /\s/;
reg = /\S/;
/*
* 创建一个正则表达式检查一个字符串中是否含有单词 child
*/
reg = /\bchild\b/;
// console.log(reg.test("hello child "));// true(即：字符串中含有 child 单词)
//接收一个用户的输入
//var str = prompt("请输入你的用户名:");
var str = " he llo ";
//去除掉字符串中的前后的空格
//去除空格就是使用 "" 来替换空格
console.log(str);// he llo
// str = str.replace(/\s/g , "");//用空字符串去除全局中的空格(即：在使用 g 全局匹配模式后)
// console.log(str)// hello(即：去除 str 字符串中所有的空格)
//去除开头的空格
// str = str.replace(/^\s*/, "");//全局匹配开头的0个或多个空格(即：^ 表示开头，* 表示0个或多个)，并使用空字符串来代替;
// console.log(str)// he llo(即：去除 str 字符串中开头所有的空格)
//去除结尾的空格
// str = str.replace(/\s*$/, "");//全局匹配结尾的0个或多个空格(即：$ 表示结尾，* 表示0个或多个)，并使用空字符串来代替;
// console.log(str)// he llo(即：去除 str 字符串中结尾所有的空格)
// /^\s*|\s*$/g 匹配开头和结尾的空格
str = str.replace(/^\s*|\s*$/g,"");//注意：+ 表示 1 个或多个，而 * 表示 0 个或多个;
console.log(str);// he llo(即：去除 str 字符串中开头和结尾的所有空格)
</script>
</head>
<body>
</body>
</html>其十二、结果为：
// 一进入页面后的控制台：
其十三、代码为：符合邮件正则规则的案例
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
/*
* 电子邮件
* hello .nihao @ abc .com.cn
*
* 任意字母数字下划线 .任意字母数字下划线 @ 任意字母数字 .任意字母（2-5位） .任意字母（2-5位）
*
* \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}$/;
var email = "abc.hello@163.com";
console.log(emailReg.test(email));// true(即：字符串是符合电子邮件校验规则的，输出为 true)
</script>
</head>
<body>
</body>
</html>其十四、结果为：
// 一进入页面后的控制台：
Ⅷ、小结：
其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！
其三、有兴趣的话，可以多多关注这个专栏(Vue(Vue2+Vue3)面试必备专栏)(直接点击下面 url 跳转)：https://blog.csdn.net/weixin_43405300/category_11525646.html?spm=1001.2014.3001.5482
其四、再有兴趣的话，也可以多多关注这个专栏(Java)(直接点击下面 url 跳转)：https://blog.csdn.net/weixin_43405300/category_12654744.html?spm=1001.2014.3001.5482