Javascript知识点

一、操作符及类型转换与流程控制语句

1.操作符

*除'+'外,其他运算符可以自动将字符串数字隐形转成数字

*'+'可以将数字字符串或布尔类型等隐式转换成number类型

*正、负号可以将字符串数字隐式转换成数字(负负得正)
var a = '123';
var b = true;
console.log(+a, +b); // 123  1

*  ++放在前面,并进行赋值:先累加,后赋值
   ++放在后面,并进行赋值:先赋值,后累加

*基本类型的转换
1.字符串加数字,数字就会转成字符串
var a = 1 + 2 + '3';
console.log(a, typeof a); // '33' string
2.数字减字符串,字符串转成数字。10 - '20'    //-10
  字符串减数字,字符串转成数字。
  两个字符串相减,两个字符串转成数字。
  (字符串不是纯数字就会转成NaN) 10 - 'one'   //NaN
3.乘,除,大于,小于跟减的转换也是一样。'10'*'20'    //200  两个字符串都转换为number

*有关==的隐式转换
1.undefined等于null
2.字符串和数字比较时,字符串转数字
3.数字和布尔比较时,布尔转数字
4.字符串和布尔比较时,两者转数字
 
*引用类型的转换
PreferredType转换策略:
1.是一个原始值,则直接返回它
2.valueOf()方法:还跟原来的一样就往下走。返回值是一个原始值,则返回这个原始值。
3.toString()方法:返回值是一个原始值,则返回这个原始值。
4. 否则,抛出TypeError异常。

*案例
1.[] + []   // ""
先调用valueOf(),结果还是[],不是原始值
继续调用toString(),结果是“”(空字符串)原始值
加号两边结果都是String类型,进行字符串拼接
2.[] + {}    // "[object Object]"
[]的结果是“”。
{}先调用valueOf(),结果是{},不是原始值
继续调用toString(),结果是“[object Object]”,是原始值
加号两边结果都是String类型,进行字符串拼接
3.{} + [] // 0    相当于{};+[] 写在外面会自动把{}当作一个代码块,会在后面加上分号
{} + []被解析成了{};+[]
{};是一个空代码块被略过
+[]就成了一元运算
[]的原值是””,将””转化成Number结果是0。
4.{} + {} // "[object Object][object Object]"
#金丝雀版本的chrome浏览器和node:”object Object
  node中会将以“{”开始,“}”结束的语句外面包裹一层( ),就变成了({ } + { }),
#普通版本的chrome浏览器中:NaN
 会解析成{};+{}
 {};是一个空代码块被略过
 +{}就成了一元运算
 {}的原值是[object Object],将[object Object]转换成number结果是NaN

 *赋值运算符
 var x=12
 x+=1  相当于 x=x+1

 *比较运算符
 1.== 值相等  
   console.log(null == undefined); //true
   字符串转换成数值
   console.log(123 == '123');  //true
   console.log(1 == true); //true
   console.log(0 == false);  //true
 2.=== 值相等并且类型相等 console.log(1 === true);  //false
 3.!= 不相等
 4.!== 值不相等或类型不相等

 **如果符号两侧都是字符串,不会将其转换为数值进行比较,而会分别比较字符串中字符的Unicode编码。**
 **注意:所以在比较两个字符串型的数字时,一定要先转型。**
 console.log('134545353' > +'5');// 这样结果才返回true 显示转化:在字符串前放个“+”,使其变成数字类型
 比较字符编码时,是一位一位进行比较的

 *逻辑运算符
 && 有假且为假
 || 有真或为真
 !

 *三目运算符 var result = age > 16 ? "成年人":"未成年人"; // 当age大于16岁时,条件为真,执行sentence1,其次反之


 2.类型转换

 1.其他类型转换为String:toString()函数
    转成有效进制格式**的字符串值**
    var num = 10;
    console.log(num.toString());  //"10"
    console.log(num.toString(2))    //"1010"
    console.log(num.toString(8))    //"12"
    console.log(num.toString(16))    //"a"
    任意其他数据与字符串相加都会转化为字符串
    console.log(typeof (true + ''));  //string
 2.布尔类型:Boolean()包装器  Boolean('hello') //true
 3.数字类型:Number()包装器
   Number(true); //1
   Number(false); //0
   Number(null); //0
   Number(undefined); //NaN

3.流程控制语句

流程控制:1.分支(条件)2.循环
1.分支语句:
*if 语句
if (condition)
{
    当条件为 true 时执行的代码
}
*if...else 语句
if (condition)
{
    当条件为 true 时执行的代码
}
else
{
    当条件不为 true 时执行的代码
}
*if...else if...else 语句
if (condition1)
{
        statement1
    当条件 1 为 true 时执行的代码
}
else if (condition2)
{
        statement2
    当条件 2 为 true 时执行的代码
}
else
{
        statement3
      当条件 1 和 条件 2 都不为 true 时执行的代码
}
2.switch 语句
default 关键词:匹配不存在时做的事情:
switch(n)
{
    case 1:
        执行代码块 1
        break;
    case 2:
        执行代码块 2
        break;
    default:
        与 case 1 和 case 2 不同时执行的代码
}


2.循环语句
*For 循环
for (*语句 1*; *语句 2*; *语句 3*)
{
  *被执行的代码块*
}

*增强版for循环
for..in用于遍历数组或者对象的属性

for(自定义变量名 in 数组/对象){

​    执行代码

}

关键字 break:立即跳出循环体
       continue:不会跳出循环,立即结束当前循环,进入下一次循环。

*while 循环
while (*条件*)
{
  *需要执行的代码*
}

*do/while 循环
do
{
    需要执行的代码
}
while (条件);

*递归
函数自己调用自己 停不下来  需要有 跳出的条件



二、对象

1.对象的创建

#字面量模式
var obj = {  
    name:"terry",  
    age:12,  
    sayName:function(){
            console.log("my name is ",this.name);
          }
}
#构造函数模式
var obj = new Object();
obj.name = "terry";
obj.age = 12;
obj.sayName = function(){
  console.log("my name is",this.name);
}
//等价于 <==>
var obj={};
obj.name="terry";
obj.age=12;


2.对象的访问

#属性访问
obj.name  
obj['name']
#方法的访问
obj.sayName();
#遍历对象中的属性
增强版的for循环:
for(自定义变量名 in 数组/对象){
    执行代码
}
for(var key in obj){
    var value=obj[key];
}

3.新增删除对象中的属性

#删除对象的自有属性:
delete obj.pro
delete obj[“proname”]
delete obj.sayName     //从obj对象中删除sayName属性
#新增属性:
obj.newproname=”value”

4.Object显示类型转换(强制类型转换)

#Object类型到Boolean类型:Boolean(value)
#Object类型转String类型:可以重写toString方法,进行我们想要的转换
var obj = {
  name: 'zhangsan',
  age: 12,
  // 可以重写toString方法,进行我们想要的转换
  toString:function(){
    return this.name+"--"+this.age;
  }
};
console.log(obj.toString(), typeof obj.toString());
console.log(String(obj), typeof String(obj));
#Object类型转Number类型:
   1.如果只重写了valueOf()或者toString()方法,则调用该方法,并将返回值用Number()转换。
   2.如果两个方法都重写了,则调用valueOf(),并将返回值用Number()转换。
   3.如果两个方法都没有重写,则返回NaN
 toString:function(){
    return "100";
  },
  valueOf:function(){
    return 10;
  }


5.检测属性

  1.in:console.log('name' in obj); //true
  2.Object.prototype.hasOwnProperty():
    console.log(obj.hasOwnProperty('name')); //true
  3.Object.prototype.propertyIsEnumerable():
  除了是自身属性外,还要求是可枚举属性,不是手动创建出来的就会是false。
  枚举属性:我们创建的属性。
  console.log(obj.propertyIsEnumerable('name')); //true

6.每个构造函数都有一个原型对象(Object.prototype),

  原型对象都包含一个指向构造函数的指针(Object.prototype.constructor),
  实例都包含一个指向原型对象的内部指针(obj.__proto__ )。
// 构造函数 Object
console.log(Object);  //[Function: Object]
// 原型对象 Object.prototype
console.log(Object.prototype);  // {}
// 原型对象中的constructor属性  原型对象中的constructor属性指向构造函数
console.log(Object.prototype.constructor);  //[Function: Object]
// 实例__proto__ 指向 原型对象
console.log(obj.__proto__ === Object.prototype);  //true

*Object构造函数:
Object构造函数的属性和方法是静态属性和静态方法,
静态属性和静态方法只能由构造函数本身调用,
实例与原型对象不能调用:
数据属性特性:Object.defineProperty()
             Object.defineProperties()
读取属性的特性:Object.getOwnPropertyDescriptor()
              Object. getOwnPropertyDescriptors()
访问器属性特性:Object.getOwnPropertyDescriptor()

*Object.prototype原型对象:
写在原型对象内的属性和方法是实例属性和实例方法,
实例属性和方法的调用:原型对象调用、实例调用
toString()
toLocaleString()
hasOwnProperty(prop)
propertyIsEnumerable(prop)
isPrototypeOf(obj2)

*实例obj:
继承原型对象中的方法:
toString()
toLocaleString()
hasOwnProperty(prop)
propertyIsEnumerable(prop)
isPrototypeOf(obj2)

7.深入理解对象-定义属性

构造函数的属性
1.数据属性
*Object.defineProperty(obj, prop, descriptor):定义新属性或修改原有的属性。

var obj={
    name:'zs',
    age:12,
    gender:'male'
}
Object.defineProperty(obj,'name',{
   configurable:true,
   enumerable:true,
   writable:true,
   value:'terry'
})
*Object.defineProperties(obj, props):一个或多个键值对定义
var obj={
    name:'zs',
    age:12,
    gender:'male'
}
Object.defineProperties(obj,{
    name:{
        value:'lisi'
    },
    age:{
        writable:false,
        value:22
    }
})

2.读取属性的特性
Object.getOwnPropertyDescriptor():对象上一个自有属性对应的属性描述符
var obj={
    name:'zs',
    age:12,
    gender:'male'
}
console.log(Object.getOwnPropertyDescriptor(obj,'name'));
console.log(Object.getOwnPropertyDescriptor(obj));

3.访问器属性特性
Object.getOwnPropertyDescriptor()
(1)访问器属性不能直接定义,要通过Object.defineProperty()这个方法来定义
(2)问器属性可以通过Object.getOwnPropertyDescriptor()查询
get:读取想要修改的属性值
set:设置想要修改的属性值


8.对象序列化:

JSON.stringify(obj) 将对象序列化
JSON.parse(jsonStr) 反序列化

// 将对象转换为JSON字符串
var json = JSON.stringify(obj);
console.log(json);//string类型的字符串
// 将JSON字符串转换为对象
var obj = JSON.parse(json);
console.log(obj);


三、函数

-------------函数先看哪里调用了它  不调用不用看!!!

1.函数介绍

功能的封装,直接调用,代码复用率提高

2.函数声明

*函数声明
function 函数名(形参列表){函数体}
*函数表达式
var 函数名=function(形参列表){函数体}

*函数声明与var变量声明类似,会进行提升
// function foo(){}  函数声明提前
foo()
function foo(){
    console.log('222');
}
foo()

3.函数内部属性

arguments:一个类数组对象,包含着传入函数中的所有参数
功能:保存函数参数
function foo(a,b){
    console.log(a,b);
    console.log(arguments);
    console.log(arguments.length);
}
foo(1,2,3,4,5)

*callee属性是 **arguments** 对象的一个成员,仅当相关函数正在执行时才可用。

*this:谁调用它,它就指向谁
1. 在方法中,this 表示该方法所属的对象。
2.如果单独使用,this 表示全局对象。
    在浏览器中,window 就是该全局对象为 [**object Window**]:
    在node中,指向的是一个{}
3.在函数中,this 表示全局对象。
   在浏览器中,window 就是该全局对象为 [**object Window**]:
   在node中,指向的就是global对象
4.在事件中,this 表示接收事件的元素。
   <button οnclick="this.style.display='none'"> 点我后我就消失了 </button>
5.在显示函数绑定时,我们可以自己决定this的指向
   apply 和 call:切换函数执行的上下文环境(context),切换this绑定的对象
   var person1 = {
  fullName: function () {
    return this.firstName + " " + this.lastName;
  }
}
var person2 = {
  firstName: "Zach",
  lastName: "Muyi",
}
var name = person1.fullName.call(person2);  // 返回 "Zach Muyi"
console.log(name);


4.IIFE立即执行函数

IIFE的写法:
1.对返回结果不进行处理
(function (形参){
    函数体
})(实参);
2.对返回结果不进行处理
(function(形参){
    函数体
}(实参));
3.返回的是一个布尔值,然后进行取反
!function(形参){
    函数体内容
}(实参)
4.对于数字返回的是原来的结果,非数字返回NaN
+function(形参){
    函数体内容
}(实参)
5.对于数字返回的是正负符号相反,非数字返回NaN
-function(形参){
    函数体内容
}(实参)
6.对于数字返回的是正负符号相反再减1,非数字返回-1
~function(形参){
    函数体内容
}(实参)
7.返回的结果是undefined
void function(形参){
    函数体内容
}(实参)

为什么需要IIFE?
js只有全局作用域(global scope)、函数作用域(function scope),
从ES6开始才有块级作用域(block scope)。因此想要将一段代码隔离出来,
就要用一个函数进行包装,js中声明的函数大多数都是为了复用,为了起到
代码的隔离作用,通常只使用一次函数,立即函数只执行一次就很好的解决
了这个问题。


5.作用域

注意:**ES5中**!!!!!!!!

函数作用域: 在 JavaScript函数中声明的变量,会成为函数的局部变量。

​                        函数内部声明的变量,在函数外部不能访问。

全局作用域:函数之外声明的变量,会成为全局变量。

​                       函数外部声明的变量,在函数内部可以访问。

​                       当函数嵌套,在这个时候,内部函数与外部函数的这个变量就组成了闭包。


*作用域链
什么是自由变量:当前作用域没有定义的变量
自由变量的值如何得到: **要到创建这个函数的那个父级作用域寻找**,
如果没有就一直向上级祖先元素寻找(这就是所谓的"静态作用域")
var a = 100
function fn() {
    var b = 200
    console.log(a) // 这里的a在这里就是一个自由变量  // 100
    console.log(b)
}
fn()

*什么是作用域链: 先找自己内部的,找不到再找父级。
函数会优先找自己的内部变量,var变量提升,val == undefined;
如果父级也没呢?再一层一层向上寻找,直到找到全局作用域还是没找到,
就宣布放弃。这种一层一层的关系,就是作用域链。
综合案例-作用域链-闭包-经典面试题:
var a = 10
function fn() {
  var b = 20
  function bar() {
    console.log(a + b) //30
  }
  return bar
}
var x = fn(), // 执行fn() 返回的是bar
b = 200
x() //执行x,就是执行bar函数


闭包案例:
var i = 1;
var i = 2;
var add = function() {
    var i = 0;
    return function()
{
        i++;
        console.log(i);
    }
}();
add();

代码回收规则如下:

1.全局变量不会被回收。

2.局部变量会被回收,也就是函数一旦运行完以后,函数内部的东西都会被销毁。

3.只要被另外一个作用域所引用就不会被回收


6.函数调用

*函数名(实参列表);
*函数名.call(执行环境对象,实参列表); b.call(obj,1,2);
*函数名.apply(执行环境对象,实参列表数组); b.apply(obj,[100,200]);
*函数名.bind(执行环境对象)(实参列表);
var b = obj.sayName;
b.bind(obj);
var c = b.bind(obj);
console.log(c); // 发现c是一个[Function: bound sayName]函数
// 执行c
c();

注意:如果call和apply的第一个参数是null,那么this在node环境下指向的是global对象,
在HTML中指向的是window对象

注意!!.call()与.apply()的区别
.call(对象,参数1,参数2),VS .apply(对象,[参数1,参数2]),
第一个对象类型的参数用来重定向this的指向,
从第二个参数开始.call()是直接一个个传入,而.apply()是支持传入一个参数数组

7.函数的应用

*回调函数
主函数的事先做完,回头再调用传进来的那个函数
实参定位传进来的数是一个函数
//定义主函数,回调函数作为参数
function A(callback) {
  callback();
  console.log('我是主函数');
}
//定义回调函数
function B() {
  // 模仿延时操作
  setTimeout(() => {
    console.log('我是回调函数');
  }, 3000);
}
//调用主函数,将函数B传进去
A(B);
*作为返回值
**函数作为返回值**
var a = 10
function fn() {
  var b = 20
  function bar() {
    console.log(a + b) //30
  }
  return bar //函数作为返回值
}

8.闭包

有权访问另一个函数作用域中的变量的函数
- **函数嵌套函数**
- **内部函数引用了外部函数中的数据(属性、函数)**
- **参数和变量不会被回收**


四、数组

1.数组创建

*字面量创建数组
var names = ["terry","larry","tom"]
*构造函数创建数组(new 一个)
var names = new Array();
var names = new Array(3);  创建一个长度为3的数组

2.数组访问

数组变量名[索引] 索引从0开始
设置新的长度:arr.length = 4

3.数组API

1.数组序列化
console.log(arr.toString());逗号分隔字符串
console.log(arr.join(""));指定的字符串隔字符串
序列化、反序列化:
var result = JSON.stringify(arr);
console.log(result);//”[1,5,2,8,10,{"a":1}]”
console.log(JSON.parse(result));//[ 1, 5, 2, 8, 10, { a: 1 } ]
2.构造函数的方法
Array.isArray():判断某个变量是否是一个数组对象
Array.from():类数组对象、可迭代对象 创建新的数组实例
Array.of():一组参数来创建新的数组实例

4.栈与队列方法

## Array.prototype.push()
在数组的末尾添加一个或多个元素
返回值:新的数组长度
语法:array.push(item1, item2, ..., itemX)
## Array.prototype.pop()
删除数组的最后一个元素
返回值:被删除的数组元素
语法:array.pop()
## Array.prototype.shift()
删除数组的第一个元素
返回值:返回被删除的元素
## Array.prototype.unshift()
在数组的开头添加一个或者多个元素
返回值:返回新的数组长度
语法:array.unshift(item1,item2, ..., itemX)

5.排序方法

## Array.prototype.reverse()
颠倒数组中的元素
返回值:颠倒后的数组
语法:array.reverse()
## Array.prototype.sort()
字母排序:Ascall编码
排序对象:字母、数字
升序:a-b
降序:b-a
语法:array.sort(sortfunction)
数字排序(升序):
var points = [40,100,1,5,25,10];
points.sort(function(a,b){
    return a-b
});
//points输出结果:1,5,10,25,40,100


6.操作方法

## Array.prototype.concat()
连接两个或多个数组
返回值:返回被连接数组的一个副本
语法:array1.concat(array2,array3,...,arrayX)
## Array.prototype.slice()
提取字符串的某个部分(截取数组)
语法:array.slice(start, end)
返回值:包含从 start 到 end 的元素的新数组。
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);
//citrus 结果输出:Orange,Lemon
## Array.prototype.splice()
添加或删除数组中的元素。
返回值:新的数组
语法:array.splice(index,howmany,item1,.....,itemX)
index:何处添加并删除元素
howmany:删除多少元素,可以为0
item1, ..., itemX:添加到数组的新元素


7.位置方法

## Array.prototype.indexOf()
返回数组某个指定的元素位置,返回索引值
从头到尾检索数组:
  找到一个item:返回item第一次出现的位置、索引
  找不到item:返回-1
语法:array.indexOf(item,start)
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple");
//a结果输出:2
//以上输出结果意味着 "Apple" 元素位于数组中的第 3 个位置。
## Array.prototype.lastIndexOf()
元素在数组中最后出现的位置
从字符串的后面向前查找,没找到返回-1
语法:array.lastIndexOf(item,start)

8.迭代方法

## Array.prototype.every()
所有元素是否都符合指定条件,有一个元素不满足就返回false
 every() 不会改变原始数组。
 语法:array.every(function(currentValue,index,arr), thisValue)
var ages = [32, 33, 16, 40];
var result = ages.every(function (age) {
  return age >= 18
})
console.log(result);//输出结果为:false
## Array.prototype.some()
如果有一个元素满足条件,则表达式返回true , 剩余的元素不会再执行检测。
some() 不会改变原始数组。
语法: array.some(function(currentValue,index,arr),thisValue)
## Array.prototype.filter()         过滤器/筛选
创建一个新的数组,新数组中的元素是符合条件的所有元素
1.数组去重
2.将数组中无意义的值进行过滤
3.提供一个条件 过滤去数组中符合条件的数据
4.提供一个条件 过滤去数组对象中符合条件的数据
filter() 不会改变原始数组。
语法:array.filter(function(currentValue,index,arr), thisValue)
var ages = [32, 33, 16, 40];
var result = ages.filter(function (age) {
  return age >= 18
})
console.log(result);//输出结果为:[ 32, 33, 40 ]
## Array.prototype.map()
按照原始数组元素顺序依次处理元素。
返回值:新数组
语法:array.map(function(currentValue,index,arr), thisValue)
## Array.prototype.forEach()
调用数组的每个元素,并将元素传递给回调函数。
语法:array.forEach(function(currentValue, index, arr), thisValue)



五、正则表达式

1.正则表达式的创建

##字面量(直接量):var reg = /正则表达式/修饰符;
##构造函数:var reg =new RegExp("正则表达式","修饰符")
##### 注意点:
1)如果正则表达式中有修饰符**"g"**,这时,在正则表达式的实例reg中会维护**lastIndex属性**,**记录下一次开始**的位置,当第二次执行exec的时候,**从lastIndex开始检索**。
2)如果正则表达式中没有修饰符"g",不会维护lastIndex属性,每次执行**从开始位置检索**


2.正则表达式实例方法

## exec
返回值:result数组:[匹配的内容,index: 在str中匹配的起始位置,input: 参数字符串,groups: undefined]    
## test:有可以匹配到的字符串返回true否则返回false
## toString/toLocaleString:把正则表达式的内容转化成**字面量形式字符串**/有本地特色的字符串
## valueOf:返回正则表达式本身


3.正则表达式实例属性

## lastIndex
当没设置全局匹配时,该属性值**始终为0**
每次正则的查找起点就是lastindex
每执行一次exec/test来匹配,latIndex就会移向匹配到的字符串的下一个位置
直到没有可以匹配的字符串时再执行exec返回null/test返回false,lastindex归0
重新开始匹配一轮
## ignoreCase、global、multiline
大小写、全局匹配、多行匹配
var reg1 = /hello/igm;
console.log(reg1.ignoreCase); //true
console.log(reg1.global); //true
console.log(reg1.multiline);  //true
## source
返回**字面量形式**的正则表达式(**类似于toString**)

4.正则表达式语法-元字符

## 直接量字符
通过反斜线\作为前缀进行转义:\n换行符、\r回车符
## 字符集合
方括号用于查找某个范围内的字符:
*[abc]    查找方括号之间的任何字符
*[0-9]    查找任何从0至9的数字
*[^xyz]  ^写在方括号内表示除了括号内的字符以外
## 边界符
^    匹配输入开始
$ 匹配输入结尾
^和 $ 在一起:精确匹配。
\b   匹配一个零宽单词边界
\B  匹配一个零宽非单词边界
## 字符类
.   除了回车符和换行符以外[^\n\r]
\d  数字字符 [0-9]
\D  [^0-9]
\w  字母数字下划线 [a-zA-Z0-9_]
\W  [^a-zA-Z0-9_]
\s  匹配任何Unicode空白字符,包括空格、制表符、换页符等,等效于[\f\t\n\r]
\S  [^\f\t\n\r]  space(空白)


5.数量词

*      >=0次
+      ≥1次
?     0或1次
{n}    n次
{n,}   ≥n次
{n,m}  n到m次
重复方式
1)贪婪模式:尽可能多的匹配(首先取最多可匹配的数量为一组进行匹配),当匹配剩余的字符串,
还会继续尝试新的匹配,直到匹配不到为止,为默认模式。
2)非贪婪模式:尽可能少的匹配(每次取最少匹配的数量为一组进行匹配),直到匹配不到为止
使用方法:在量词后加上  ?

6.选择,分组,引用

选择:字符"|"用于分隔供选择的字符 相当于‘或’
分组:圆括号包裹的一个小整体成为分组。
捕获与引用:
var reg = /(\d{4})-(\d{2})-(\d{2})/
var date = '2021-08-29'
reg.test(date)
// 捕获之前要先test/exec
console.log(RegExp.$1); //2021
console.log(RegExp.$2); //08
console.log(RegExp.$3); //29
嵌套分组的捕获:规则是以左括号出现的顺序进行捕获。
引用:
var reg = /(\w{3}) is \1/
console.log(reg.test('kid is kid')); // true

var reg = /(\w{3}) is \6/;
reg.test( 'kid is kid' ); // false
reg.test( 'kid is \6' );  // true


7.String对正则表达式的支持

## search
返回字符串第一次出现时的位置
无则返回null
var str = 'hello world hello';
var reg = /hello/;
var reg2 = /hello/g;
console.log(str.search(reg)); //返回 0
console.log(str.search(reg2));//返回 0
## match
返回符合要求的字符串以及分组的一个数组
但如果同时开启全局匹配则不会在数组中添加分组内容
## split
以某种形式分割字符串
## replace
满足正则表达式条件的内容将被替换
语法:replace(正则表达式, 要替换的内容)


8.前瞻表达式

(?=exp) 正向前瞻  匹配后面满足表达式exp的位置
        var reg = /H(?=i)/g;只匹配"H"后面紧跟"i"的"H"。
(?!exp) 负向前瞻  匹配后面不满足表达式exp的位置
        var reg = /H(?!i)/g;匹配"H"**,且后面不能跟着一个"i"

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值