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"