本文是对自己学过的js做一个小结与复习，主要记录了自己不太熟悉的知识点。从数据类型 数组 对象 函数 原型 作用域 JS内置对象 正则等。
下一篇从DOM开始。
本文参考轻松的小希的博客
1、数据类型
Undefined Null
1.1Undefined
- 类型只有一个值，即特殊的 undefined
- 在使用 var 声明变量但未对其加以初始化时，
var a这个变量的值就是 undefined - 使用typeof对没有初始化和没有声明的变量，
typeof a会返回“undefined”
1.2Null
- Null 类型是第二个只有一个值的数据类型，这个特殊的值是 null
- undefined值实际上是由null值衍生出来的，所以如果比较undefined和null是否相等，会返回true
- null表示的是一个空的对象，所以使用typeof检查null会返回一个Object
1.3转为String类型
toString()、String()、 拼串
1.3.1 toString()方法
- b=a.toString()
- toString()方法不会影响到原变量，它会将转换的结果返回
- null和undefined这两个值没有toString()方法，如果调用它们的方法，会报错
- 该方法属于Object对象，由于所有对象的祖宗都是Object，所以所有对象都能用它
1.3.2 String(a)函数
- b=String(a);
- 调用String()函数，不会影响到原变量，并将被转换的数据作为参数
- 将 null 直接转换为 “null”，将 undefined 直接转换为 “undefined”
1.3.3 拼接
- 任意的数据类型 +""
1.4 转为Number类型
有 Number()可以将任意数据类型转换， parseInt() parseFloat()只能转字符串型数据三种方法。 parseInt()转为整数，parseFloat()转为浮点数
1.4.1 Number()
- 字符串–>数字
（1）空串–>0
（2）纯数字的字符串–>数字
（3）含有非数字字符–>NaN - 布尔–>数字
true–>1,false–>0 - undefined–>NaN
- Null–>0
1.4.2 parseInt() parseFloat()
- 只能把字符串型转为数字，非String使用parseInt()或parseFloat()，它会先将其转换为String然后在操作
- parseInt只保留整数，parseFloat保留浮点数
1.5转为Boolean
使用Boolean()方法
- 数字型–>布尔：除了0 NaN，其余都为true
- 字符串型–>布尔：除了空串，其余都为true
- undefined–>布尔：false
- null–>布尔：false
- 对象–>布尔：true
2、运算符
与或非&& || ！，会形成逻辑短路，即：一旦能确定整个表达式的值，求解就会立即停止
2.1逻辑与
- 运算规则：只要有一个值为false，就返回false，只有两个值都为true时，才会返回true
- 逻辑短路：第一个值为false，则不会检查第二个值，会影响表达式的值。当A为假，则不处理B。如以下代码:
var a = 3;
var b = 5;
a<2&&b++;
document.write(b);
输出结果为5
var a = 3;
var b = 5;
a>2&&b++;
document.write(b);
输出结果为6
- 逻辑与赋值问题：有条件为false的表达式（包括数字型0，字符串型空串，布尔值false，null,undefined），则返回它。没有则返回最后一个表达式的值
var a = 0 && 3 // a == 0
var a = 2 && 0 // a == 0
var a = 2 && false // a == false
var a = 2 && 3 // a == 3
var a = 2 && 3 && 4 // a ==4
var a = 2 && false && 4 // a==false
2.2逻辑或
- 运算规则：两个值中只要有一个true，就返回true，只有两个值都为false，才会返回false
- 逻辑短路：第一个值为true，则不会检查第二个值。当A为真，则不处理B
var a = 3;
var b = 5;
a>2||b++;
document.write(b);
输出结果为5
var a = 3;
var b = 5;
a<2||b++;
document.write(b);
输出结果为6
- 逻辑或赋值问题：有条件为true的表达式（非0数字，非空字符串，非null undefined），返回它。没有则返回最后一个表达式的值
var a = 0 || 3 // a==3
var a = 3 || 0 // a==2
var a = 2 || 3 // a==2
var a = 0 || 2 || 3 // a==2
var a = 0 || false || null // a==null
2.3 比较运算符
2.3.1 ==与 !=
- == !=类型不同时，自动进行类型转换，转换规则如下：
Null == Undefined ->true
String == Number ->先将String转为Number，在比较大小
Boolean == Number ->现将Boolean转为Number，在进行比较
Object == String，Number，Symbol -> Object 转化为原始类型
2.3.2 === 与 !==
- 不会做自动的类型转换，如果两个值的类型不同，直接返回布尔值
- break跳出多层循环：在外循环加上一个label
outer: for (var i = 0; i < 10; i++) {
for (var j = 0; j < 10; j++) {
if (j == 5) {
break outer;
}
console.log(j);
}
}
3、对象 原型 原型链
3.1遍历对象
3.1.1 for in 遍历
var key in obj，key表示属性名。得到属性值的两种写法：obj.key，obj.name obj[‘name’]
var obj = {
name:'小明',
age:18,
sex:'man'
}
for(var key in obj) {
console.log(key); // name,age,sex
console.log(obj[key]); //小明,18,man
}
3.1.2 Object.keys(obj)
得到的是，obj的keys值组成的数组
var obj = {
name:'小明',
age:18,
sex:'man'
}
console.log(Object.keys(obj)) //["name", "age", "sex"]
打印结果为obj对象的key组成的数组
3.1.3 Object.values(obj)
得到的是，obj的values值组成的数组
var obj = {
name: "小明",
age: 18,
sex: "man",
};
console.log(Object.values(obj)); //["小明", 18, "man"]
打印结果为obj对象的value组成的数组
3.1.4 Object.getOwnPropertyNames(obj)
区别：可以得到该对象的所有属性,包括不可枚举的，再对数组遍历，通过obj[key]得到属性值value
var obj = {
name: "小明",
age: 18,
sex: "man",
};
console.log(Object.getOwnPropertyNames(obj)); //["name", "age", "sex"]
打印结果为obj对象的key组成的数组
通过对这个数组做遍历可取得对应的value值,如下:
Object.getOwnPropertyNames(obj).forEach(key=>{
console.log(obj[key]); //小明,18,man
})
3.2构造函数创建对象
- 构造函数：首字母大写
- 使用构造函数创建对象时，使用new关键字，而普通函数直接调用即可
- 构造函数的this指向创建的实例对象，如上述Person中的this依次指向person1 person2 person3
// 使用构造函数来创建对象
function Person(name, age) {
// 设置对象的属性
this.name = name;
this.age = age;
// 设置对象的方法1:构造函数里写方法
this.sayName = function () {
console.log(this.name);
};
}
//在构造函数的原型上添加方法，这样使用Person创建的对象身上就都有sayName方法了
Person.prototype.sayName=function(){
console.log(this.name);
}
var person1 = new Person("孙悟空", 18);
var person2 = new Person("猪八戒", 19);
var person3 = new Person("沙和尚", 20);
console.log(person1);
console.log(person2);
console.log(person3);
3.3原型与原型链
- 原型对象就相当于一个公共的区域，所有同一个类的实例对象 都可以访问到这个原型对象，我们可以将对象中共有的内容，统一设置到原型对象中
- 实例对象调用方法时，先在自身找，如果没有，再到原型对象构造函数身上找。
- 原型链：访问一个对象的属性时，先在自身属性中查找，找到返回， 如果没有，再沿着__proto__这条链向上查找原型对象，找到返回，如果没找到，则向上找原型对象的原型，直到找到Object对象，再向上找，Object原型是null（即Object没有原型，到这里已经找到尽头了），如果最终没找到，返回undefined，这就是原型链，又称隐式原型链，它的作用就是查找对象的属性(方法)。
- Object对象是所有对象的祖宗，Object的原型对象指向为null，也就是没有原型对象
3.4 hasOwnProperty()方法
- 只检查自身对象，不检查原型，是否含有某个方法或属性，我们可以使用Object的hasOwnProperty()方法，它返回一个布尔值，判断对象是否包含特定的自身（非继承）属性
- 如果使用 name in mac，则会检查自身和原型对象身上是否有name，如果自身没有但原型对象上有时，结果也为true
- hasOwnProperty()是Object对象特有的，其他构造函数的实例对象在使用该方法时，会从自身出发，沿着隐式原型链查找该方法
// 创造一个构造函数
function MyClass() {
}
// 向MyClass的原型中添加一个name属性
MyClass.prototype.name = "我是原型中的名字";
// 创建一个MyClass的实例
var mc = new MyClass();
mc.age = 18;
// 检查当前对象false
console.log(mc.hasOwnProperty("hasOwnProperty"));
// 检查当前对象的原型对象false
console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));
// 检查当前对象的原型对象的原型对象true
console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"));
3.5继承
包括原型链继承，构造函数继承(call apply)，组合继承（重要）
3.5.1 原型链继承
- 子类型的原型=父类型实例对象Son.prototype=new Father();
- 子类型原型上的构造属性=子类型 Son.prototype.constructor=Son;
- 继承单一
//创建构造函数Father
function Father(){
this.fatProto='father Prototype';
}
//给父类型构造函数原型上添加方法
Father.prototype.showFatProto=function(){
console.log(this.fatProto);
}
//创建子类型构造函数Son
function Son(){
this.sonProto='son Prototype';
}
//子类型构造函数原型=父类型实例对象
Son.prototype=new Father();
//子类型原型上的构造属性constructor设置为子类型
Son.prototype.constructor=Son;
//子类型添加方法
Son.prototype.showSonProto=function(){
console.log(this.sonProto);
}
var s=new Son();
s.showFatProto();//father Prototype
s.showSonProto();//son Prototype
3.5.2构造函数继承
- 只能继承父类实例属性和方法，不能继承父类原型上添加的方法
//创建构造函数Father
function Father(name,age){
this.name=name;
this.age=age;
this.showFatName=function(){
console.log(this.name);
};
}
//给父类型构造函数原型上添加方法，这个原型上的方法不能被继承
Father.prototype.showFatProto=function(){
console.log(this.fatProto);
}
//创建子类型构造函数Son
function Son(name,age,sex){
//在子类型中调用call()方法继承父类
Father.call(this,name,age);
this.sex=sex;
}
//子类型添加方法
Son.prototype.showSonName=function(){
console.log(this.name);
}
var s=new Son('小二',20);
console.log(s.name);//小二
console.log(s.age);//20
s.showFatName();//小二
s.showSonName();//小二
3.5.3 组合继承
- 原型链+借用构造函数的组合继承
- 借助Father.call(this,name,price)实现对父类的实例属性和方法继承
- 借助Son.prototype=new Father()实现对父类原型上方法的继承
- 记得修正constructor才能写子类自己的原型方法 Son.prototype.constructor=Son
- 写子类独有的原型方法 Son.prototypr.getName=function(){}
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.setName = function (name) {
this.name = name;
};
function Student(name, age, price) {
Person.call(this, name, age); // 为了得到父类型的实例属性和方法
this.price = price; // 添加子类型私有的属性
}
Student.prototype = new Person(); // 为了得到父类型的原型属性和方法
Student.prototype.constructor = Student; // 修正constructor属性指向
Student.prototype.setPrice = function (price) { // 添加子类型私有的方法
this.price = price;
};
var s = new Student("孙悟空", 24, 15000);
console.log(s.name, s.age, s.price);
s.setName("猪八戒");
s.setPrice(16000);
console.log(s.name, s.age, s.price);
3.6 声明提前
- var声明的变量都是将变量名提到当前作用域的头部，赋值留在原位置
- 如果在赋值之前访问变量或函数，返回结果分别是undefined和报错
3.6.1. 变量声明提前
console.log(a); //不会出错，会输出undefined
var a=100;
console.log(a); //100;
声明提前变为：
var a; //声明提前
console.log(a);//undefined
a=100; //赋值任然留在原位置
console.log(a);//100
把变量提升到当前所在作用域的顶部
function fn(){
console.log(a); //undefined
var a=100;
console.log(a); //100
};
fn();
console.log(a);// 报引用错误！
声明提前变为：
function fn(){
var a;
console.log(a);
a=100;
console.log(a);
}
fn();
console.log(a);//没有全局的a，全局访问不到局部a
3.6.2 函数声明提前
- 通过function fn(){}定义函数，是将整个函数体提前了，此时使用fn()调用函数就会正常
fn();
function fn(){
console.log('函数体提前');
}
//结果：函数体提前
- 通过 var fn=function(){}定义函数，只是将函数名提前了，函数体没有提前，如果在函数体前使用fn()调用函数就会报错
fn();
var fn = function(){
console.log('函数体没有提前');
}
//结果：报错！Uncaught TypeError: fn is not a function
3.6.3函数优先提升
- 函数声明和变量声明都会被提升，但是函数会首先提升，然后才是变量。var 重复声明的变量会被忽略
function a(){ return 1 }
var a=undefined;
a();
function a(){ return 1 }
var a; //重复声明的变量会被忽略
a=undefined; //赋值留在原地
a();
结果为 a is not a function
[变量提升](http://t.csdn.cn/uLJ5c)
3.7 作用域与作用域链
3.7.1作用域
- 全局作用域：
全局作用域在页面打开时创建，在页面关闭时销毁
创建的变量都会作为window对象的属性保存
创建的函数都会作为window对象的方法保存
全局作用域中的变量都是全局变量，在页面的任意的部分都可以访问的到 - 函数作用域
调用函数时创建函数作用域，函数执行完毕以后，函数作用域销毁
每调用一次函数就会创建一个新的函数作用域，它们之间是互相独立的
函数作用域中可以访问到全局作用域的变量，在全局作用域中无法访问到函数作用域的变量。函数中要访问全局变量可以使用window对象 - 作用域链
当在函数作用域操作一个变量时，它会先在自身作用域中寻找，如果有就直接使用，如果没有则向上一级作用域中寻找，直到找到全局作用域，如果全局作用域中依然没有找到，则会报错ReferenceError
从内到外
4、函数
函数也是一个对象，typeof fn得到的是Function
4.1函数声明
- 函数对象new
var fun=new Function("console.log(1)");
- 函数声明
function fun(a,b){
console.log(1)
}
- 函数表达式，可以把函数当作变量使用(匿名函数)
var fun = function(a,b){
console.log(1)
}
fun(1,2);
4.2函数返回值return
- return后的语句都不会执行
- return后不跟任何值就相当于返回一个undefined；不写return，则也会返回undefined
- return后可以跟任意类型的值，对象 数组
4.3嵌套函数
嵌套函数只能在当前函数中可以访问，在当前函数外无法访问
son只能在father内部调用，在father外使用就会报错。
function father() {
function son() {
console.log("我是儿子")
}
console.log('我是父亲');
son();
}
father();
4.4匿名函数（即函数表达式创建的函数）
匿名函数this指向全局
var fun = function(a,b){
console.log(1)
}
fun(1,2);
4.5立即执行函数
(function () {
alert("我是一个匿名函数");
})();
4.6对象中作为value的函数
var person = {
name: "zhangsan",
age: 18,
sayHello: function () {
console.log(name + " hello")
}
}
person.sayHello();
4.7this指向
全局函数中，this等于window
函数被作为某个对象的方法调用时，this等于那个对象
匿名函数this指向全局
注意匿名函数中形成闭包，闭包访问变量的顺序：闭包中的局部变量、外部函数的局部变量、全局变量
当以构造函数的形式调用时，this就是新创建的那个对象
例子1：
var name = "the window";
var obj = {
name : "my object",
getName : function(){
return function(){
return this.name;
}
}
};
var nameValue = obj.getName()();
alert(nameValue); // the window
解析：
var nameValue = obj.getName()(); 即：
var nameValue = function(){
return this.name;
}();
注意：匿名函数function(){return this.name;}的执行环境具有全局性，匿名函数中的this对象指向window对象
例子2：
var name = "the window";
var obj = {
name : "my object",
getName : function(){
// 把匿名函数的外部(函数)作用域中的this对象保存在一个闭包能够访问到的变量里。
var that = this;
return function(){
return that.name;
}
}
};
var nameValue = obj.getName()();
alert(nameValue); // my object
解析：
var nameValue = obj.getName()(); 即：
var nameValue = function(){
return that.name;
}();
说明：that不是关键字，只是一个普通的变量。闭包访问变量的顺序：闭包中的局部变量、外部函数的局部变量、全局变量！！！
版权声明：本文为CSDN博主「A__17」
原文链接：https://blog.csdn.net/wodewutai17quiet/article/details/52282650
5 js内置对象
5.1数组对象
5.1.1创建数组对象
数组对象中的元素可以是不同类型，如字符串型 数字型存在一个数组中
- 使用对象创建
var arr=new Array(); arr[0]='123'; arr[1]=4' arr[2]=8; - 使用字面量创建
var arr=['123',4,8,99,'hi'];
5.1.2 数组属性与方法
push pop unshift shift splice reverse sort改变原数组
- arr.constructor属性返回创建数组的原型函数 f Array(){}
- push pop unshift shift均改变原数组
//向数组结尾 开头追加元素，返回数组的长度，会改变原数组
var result = arr.push('1','2');
var result = arr.unshift('3','4');
//从数组结尾 开头取走一个元素，返回取走的元素，会改变原数组
var value = arr.pop();
var value = arr.shift();
- forEach( function(value,index,array ){ } )
（1）用于遍历数组，参数是一个回调函数，数组有几个元素就调几次。
（2）回调函数有三个参数：value index array当前正在访问的数组 数组下表 当前正在遍历的数组所有值
arr.forEach(function(value,index,array){
console.log(value);
})
- var new Arr = arr.slice(a,b) 不会改变元素数组，生成一个新数组并返回
（1）从数组提取指定元素，该方法不会改变元素数组，而是将截取到的元素封装到一个新数组中返回
（2）a:开始截取的索引值，包含； b:结束截取的索引值，不包含
（3）b省略时表示截取到最后一个；b=-1是倒数第一个 b=-3是倒数第三个
var arr = ["孙悟空", "猪八戒", "沙和尚", "唐僧", "白骨精"];
var result = arr.slice(1, 4);
console.log(result);//["猪八戒", "沙和尚", "唐僧"]
result = arr.slice(3);
console.log(result);//["唐僧", "白骨精"]
result = arr.slice(1, -2);
console.log(result);//["猪八戒", "沙和尚"]
-
var result = arr.splice(a,b,c);改变原数组，把指定元素从原数组中删除，并将它返回
（1）有三个参数：第一个表示开始删除的索引
（2）第二个表示删除元素的个数（slice中第二个参数表示结束索引下标）
（3）第三个表示插入的元素，会插入到开始索引的前面
（4）返回的是删除的元素 -
var result = arr.concat(arr1,arr2,‘hihihi’);把数组连接起来形成新数组，不影响原数组
-
var result = arr.join(’@’);把数组转为字符串，括号内可指定连接符，默认使用逗号连接，不影响原数组
-
arr.reverse();把数组翻转，直接影响原数组
-
arr.sort();将数组排序，直接影响原数组
（1）arr.sort();默认使用Unicode编码对数组元素进行排序
（2）arr.sort( function(a,b) { return a-b } );给sort()函数指定一个参数，该参数为回调函数，a-b是升序；b-a是降序
arr.forEach((value,index,arr)=>{
console.log(value,index,arr);//数组中有多少个元素就调用多少次
});
var result = arr.slice(3,6);//从索引3开始截取到索引6
var elements = arr.splice(3,2,'我是补进来的','我也是');//从索引值3开始删除两个，并在3之前补两个,返回删除的元素，arr会改变
var result = arr.concat(arr1,'2','nihaoa');
var result = arr.join('@');
arr.reverse();
arr.sort((a,b)=>{
return a-b; //升序
});
5.2 函数对象
5.2.1 call()和apply()
通过函数对象来调用，用于改变this指向
- fun.call(obj,2,3);
- 第一个参数是对象，第二个开始是调用fun函数传入的实参。该对象成为fun函数执行时的this
function fun(a, b) {
console.log("a = " + a);
console.log("b = " + b);
console.log("fun = " + this);
}
var obj = {
name: "obj",
sayName: function () {
console.log(this.name);
}
};
fun(2, 3);
console.log("===============");
fun.call(obj, 2, 3);
输出结果为：
a=2
b=3
fun=[object Window]
=======================
a=2
b=3
fun=[object Object]
- fun函数是全局函数，它的this本来指向Window；在调用fun.call(obj,2,3)之后，传入第一个参数是对象，它就是this指向的对象；从第二个参数开始是实参。
- fun.apply(obj,[2,3]);apply把实参以数组形式传给函数。
- 默认fun()函数调用，this指向的是window对象，你可以使用apply()调用函数，在调用的时候传入一个对象，这个对象就是this所指向的对象，也就是说，可以自己指定this的指向，然后从第二个参数开始，需要制定一个实参数组进行参数传递
- call还可以用于构造函数继承
Father.call(this,name,age);
5.2.2 this指向问题
- 以函数形式调用时，this永远都是window，如上述fun
- 以方法的形式调用时，this是调用方法的对象
- 以构造函数的形式调用时，this是新创建的那个对象，如
Father.call(this,name,age);this指向Son - 使用call和apply调用时，this是传入的那个指定对象
5.2.3 arguments
- 调用函数时，默认会传过来this和arguments。
- 其中arguments把实参以数组形式保存起来，可以在函数里使用
arguments[0] arguments[1]可以访问到实参，使用arguments.length获取参数长度，arguments.callee查看它的函数对象fun
5.3 Date对象
- getFullYear() getMonth() getDate()
- getHours() getMinutes() getSeconds() getMilliseconds()
5.4 Math对象
/*固定值*/
console.log("PI = " + Math.PI);
console.log("E = " + Math.E);
console.log("===============");
/*正数*/
console.log(Math.abs(1)); //可以用来计算一个数的绝对值
console.log(Math.ceil(1.1)); //可以对一个数进行向上取整，小数位只有有值就自动进1
console.log(Math.floor(1.99)); //可以对一个数进行向下取整，小数部分会被舍掉
console.log(Math.round(1.4)); //可以对一个数进行四舍五入取整
console.log("===============");
/*负数*/
console.log(Math.abs(-1)); //可以用来计算一个数的绝对值
console.log(Math.ceil(-1.1)); //可以对一个数进行向上取整，小数部分会被舍掉
console.log(Math.floor(-1.99)); //可以对一个数进行向下取整，小数位只有有值就自动进1
console.log(Math.round(-1.4)); //可以对一个数进行四舍五入取整
console.log("===============");
/*随机数*/
//Math.random()：可以用来生成一个0-1之间的随机数
//生成一个0-x之间的随机数：Math.round(Math.random()*x)
//生成一个x-y之间的随机数：Math.round(Math.random()*(y-x)+x)
console.log(Math.round(Math.random() * 10)); //生成一个0-10之间的随机数
console.log(Math.round(Math.random() * (10 - 1) + 1)); //生成一个1-10之间的随机数
console.log("===============");
/*数学运算*/
console.log(Math.pow(12, 3)); //Math.pow(x,y)：返回x的y次幂
console.log(Math.sqrt(4)); //Math.sqrt(x) ：返回x的平方根
5.5 String()对象
- constructor属性 str.constructor() 输出为f String(){}
- length属性
- var a = charAt(index);根据索引获取指定位置的字符
- var a = charCodeAt(index);获取指定位置字符的字符编码（Unicode编码）
- str.concat(str1,str2);连接两个或多个字符串
- var i = str.indexOf(‘e’);查找指定字符第一次出现的索引，如果没有则返回-1
var j = str.indexOf(‘o’,4);从索引4开始查找指定字符出现的索引 - var m = str.lastIndexOf(‘w’);从后往前查找w第一次出现的索引
var m = str.lastIndexOf(‘w’,4);从索引4开始往前查找w第一次出现的索引 - var new = str.slice(3,8);截取字符，不包括8，可以出现-1表示倒数第一个，不影响原字符串
- var new = str.substring(3,9);截取字符，和slice相似，但是！它不能出现负值，出现负值时默认是0，而且自动跳转两个参数
- var new = str.substr(5,2);从指定下标开始截取一定个数的字符串，不影响原串
- var arr = str.split(’，’);将字符串转为数组，使用，分割。对比数组中join(’@’)方法
- var new = str.toUpperCase();
- var new = str.toLowerCase();
5.6 RegExp()正则表达式
5.6.1 创建正则变量
- 使用对象创建：var exp = new RegExp(“正则表达式”/“匹配模式”);
- i：忽略大小写；g：全局匹配模式；ig：忽略大小写且全局匹配
// 这个正则表达式可以来检查一个字符串中是否含有a
var reg = new RegExp("ab", "i");
var str = "Abc";
var result = reg.test(str);
console.log(result);
- 使用字面量创建：var ab = /正则表达式/匹配模式
- i：忽略大小写；g：全局匹配模式；m：多行匹配
// 这个正则表达式可以来检查一个字符串中是否含有a
var reg = /a/i;
var str = "Abc";
var result = reg.test(str);
console.log(result);
5.6.2正则进阶(是否包含，除了之外是否还有别的)
5.6.2.1 检查字符串中是否包含有字母[aef] [a-c]
- 检查一个字符串中是否含有字母
// 这个正则表达式可以来检查一个字符串中是否含有字母
var reg = /[A-z]/;
var str = "Abc";
var result = reg.test(str);
console.log(result);
[a-z]：是否有小写字母 [A-Z] [A-z] [0-9]是否包含数字
- 创建一个正则表达式，检查一个字符串中是否含有 abc 或 adc 或 aec
var reg = /a[bde]c/;
var str = 'aecoi';
console.log(reg.test(str);
5.6.2.2 判断字符串中除了…是否还有其他的[^a ] [^a-z]
- 判断除了小写字母是否还有其他字符
var reg = /[^a-z]/;
var str = '0123a';
console.log(reg.test(str));
[^a-z] [^abc] [^0-9] [^A-Z]
5.6.3正则方法
- split(/[a-z]/);把字符串分割成数组，分割符为小写a-z.即使不指定全局匹配，也会全都插分
var str = "1a2b3c4d5e6f7";
var result = str.split(/[A-z]/);
console.log(result); //['1','2','3','4','5','6','7']
- search(/a[bdc]e/);查找字符串abe adc ace，并返回第一次出现的索引位置.serach()只会查找第一个，即使设置全局匹配也没用
var str = "hello abc hello aec afc";
var result = str.search(/a[bef]c/);
console.log(result); //6
- str.match(/[a-z]/);从字符串中查找a-z并返回一个数组，默认只查找第一个且找到后就停止检索，可以设置正则表达式为全局匹配模式，这样就会匹配到所有的内容。
var str = "1a2a3a4a5e6f7A8B9C";
var result = str.match(/[a-z]/ig);
console.log(result);
//9['a','a','a','a','e','f','A','B','C']
- str.replace(/[a-z]/ig,’@’);从字符串中查找a-z，并替换成新的字符，默认只替换第一个。可以设置为全局匹配就会全部替换
var str = "1a2a3a4a5e6f7A8B9C";
var result = str.replace(/[a-z]/gi, "@_@");
console.log(result);
5.6.4正则量词
{m}：正好出现m次 reg = /(ab){2}c/ reg.test(str)；ab是否正好出现两次
{n,}：出现n次及以上
{m,n}：出现m-n次
+：至少出现1次，相当于{1，}
*：出现0或多个，相当于{0，}
?：0个或1个，相当于{0，1}
var str = "abbc";
reg = /(ab){3}/;
console.log(reg.test(str)); //false
console.log("===============");
reg = /b{3}/;
console.log(reg.test(str)); //false
console.log("===============");
reg = /ab{1,3}c/;
console.log(reg.test(str)); //true
console.log("===============");
reg = /ab{3,}c/;
console.log(reg.test(str)); //false
console.log("===============");
reg = /ab+c/;
console.log(reg.test(str)); //true
console.log("===============");
reg = /ab*c/;
console.log(reg.test(str)); //true
console.log("===============");
reg = /ab?c/;
console.log(reg.test(str)); //false，b出现了两次
console.log("===============");
5.6.5正则高阶
- 判断是否以a开头^a
- 判断是否以a结尾a$
var str = "abcabca";
var reg = /^a/;
console.log(reg.test(str)); //true
var str = "abcabca";
var reg = /a$/;
console.log(reg.test(str)); //true
/[^a]/：判断除了a以外是否还有其他字符
/^a/：判断是否以a开头
- / . /:表示是否含有.
- / \ /:表示是否含有\
- / \bchild\b /：是单词边界
总结
本文对之前所学的js做一个小结，主要是写下自己不太熟悉的知识点，方便以后自己复习。
本文参考：轻松的小希的博客
扫一扫
123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
