复习 JavaScript 高程 ， 基本上 是 摘抄原文。

在 HTML 中 使用 JavaScript

    JS 包括：核心（ECMAScript）、文档对象模型（DOM）、浏览器对象模型（BOM）

    <script> 元素的 6 个 属性

    async :可选，表示应该立即下载脚本，但不妨碍页面中的其他操作，比如下载其他资源或等待加载其他脚本。只对外部脚本有效

    charset : 可选，表示通过 src 属性指定代码的字符集。（很少用）

    defer：可选，表示脚本可以延迟到文档完全被解析和显示之后再执行。只对外部脚本文件有效。

    language：弃用

    src:可选，表示包含要执行代码的外部文件

    type:可选，表示编写代码使用的脚本语言的内容类型（MIME类型），如 type= text/javascript

延迟脚本

    defer属性，这个属性的用途是表明脚本在执行时不会影响页面的构造，也就是说，脚本会被延迟到 整个页面都解析完毕 后在运行，因此，在<script>元素中设置defer属性，相当于告诉浏览器理解下载，但延迟执行。延迟脚本按照规定要根据先后顺序执行，但是在现实中不一定会按照顺序，也不一定会在 DOMContentLoaded 事件触发前执行，因此 最好 只包含 一个延迟脚本。

异步脚本

    async 属性，与 defer 属性类似，都用于改变处理脚本的行为。同样与 defer 类似，async 只用于外部脚本文件，并告诉浏览器立即下载文件，但与 defer 不同的，标记为 async 的脚本并不保证按照指定他们的先后顺序执行。

    指定 async 属性的目的是不让页面等待两个脚本下载和执行，从而异步加载页面其他内容。为此, 建议异步脚本不要在加载期间修改DOM

    异步脚本一定会在页面的load 时间前执行，但可能会在 DOMContentLoaded事件触发之前或者后执行。

一般把 <srcipt> 元素放在页面最后，即 主要内容后面，</body> 标签前面。

使用 defer 属性可以让脚本在文档完全呈现之后再执行，延迟脚本总是按照指定他们的顺序执行；使用 async 属性可以表示当前脚本不必等待其他脚本，也不必阻塞文档呈现。不能保证异步脚本按照他们在页面中出现的顺序执行。

尽量 使用 script 的 src 来外链 外部的文件， 好处： 1 可维护性；2 可缓存，如果两个页面使用同一个文件，那么这个文件只需 下载一次； 最终能够加快 页面的 加载速度；3 适应未来

基本概念

ECMAScript 中的一切( 变量、函数名 和 操作符）都 区分大小写。

ECMAScript 5 中引入和 严格模式（strict mode)的概念，严格模式 是为了 Javascript 定义了一种不同的 解析与 执行模型。在 严格模式 下，ECMAScript 3 中的一些 不确定的 行为 将得到处理，而对某些 不安全的 操作 也会 抛出错误。 要在 整个脚本中使用 严格模式， 可以在 代码顶部添加 : ' use strict  '

ECMAScript 的 变量 是 松散类型 的，意思 是 可以用来保存 任何类型的 数据。

变量

数据类型

    基本数据类型 undefined null Boolean Number String  Symbol

    复杂数据类型 Object

    typeof 返回值： 

        undefined ------- 如果这个值未定义，

        boolean -------  如果这个值时布尔值，

        string  ------- 如果这个值是字符串，

        number  ------- 如果这个值是数值(NaN)，

        object ------- 如果这个值是对象或者null或者是数组，

        function ------- 如果这个值是函数

typeof  是一个操作符 ，而 不是一个 函数。

从逻辑角度来看， null 表示 一个 空对象 指针， 而这也是使用 typeof 操作符 检测 null 值 返回 ' Object ' 的 原因。

toString() 可以输出二进制，八进制，十六进制

var num = 10；  num.toString(2)  num.toString(8)  num.toString(16)

typeof （NaN) ; // number

NaN 是一个 特殊的数值

isNaN () 函数 确定这个 检测的对象 是否 ' 不是数值 '；isNaN () 接受到参数后，会尝试 将这个值转换 为数值，某些不是 数值 的 值 会 直接转换为 数值。 例如 字符串 ' 10 '，经过转换后成为 数值 10 ，所以返回 false

数值转换

    有三个函数 可以把 非数值 转换为 数值： Number（），parseInt()， parseFloat()

    Number()  可用于任何类型，转换规则参考书

    parseInt ()， parseFloat() 专门 将 字符串 转换成数字，具体规则 参考书

字符串

    toString（）方法，可以 把 数字 转换为 字符串

    可以 把 数组 转换为 以 逗号 连接 的 字符串

toString 方法

null 和 undefined 没有 toString  方法。

在 不知道 要转换的 值 是不是 null  或者 undefined 的情况下，还可以使用 String(), 这个函数 能够将 任何类型的值 转换为 字符串（ 如果 是 null 或者 是 undefined 就 返回 它本身）

Object类型

    Object 每个实例 都具有 一下 属性 和方法

        constructor： 保存者用于创建 当前对象的 函数

        hasOwnProperty： 用来判断某个对象 自身 属性是否含有指定的属性。 作为参数的属性名 必须以字符串形式 指定， 返回 布尔值。

         语法 ： obj.hasOwnProperty(prop)

        isPrototypeOf ： 方法用于测试一个对象是否存在于另一个对象的原型链上

         语法： prototypeObj.isPrototypeOf(object)

        property​IsEnumerable： 方法返回一个布尔值，表示 指定的属性 是否可以使用 for in 语句枚举。与 hasOwnProperty 方法一样，作为参数 的 属性名必须 以 字符串 形式指定。

        语法 ： obj.propertyIsEnumerable(prop)

        toLocaleString:  方法返回一个该对象的字符串表示。该 字符串 与 执行环境的 地区对应。

        语法：obj.toLocaleString()

        toString: 方法返回一个表示当前函数源代码的字符串。

        语法： obj.toString()

        function c () {} 

        c.toString(); // "function c () {}"

        valueOf：方法返回指定对象的原始值（ 返回 对象 的 字符串、数值 或者 布尔值表示。通常与toString() 返回的值相同）; 如果对象没有原始值，则 valueOf 将返回对象本身。

一元加 和 减 操作符 

    对于 非数值 应用一元加操作符 时，该操作符 会像 Number() 转型 函数 一样 对这个值 执行 转换。布尔值 false 和 true 将被转换 成 0 和 1， 字符串 会被按照 一组 特殊的 规则 进行解析，而对象是 先 调用 它们 的 valueOf() 或者 toString() 方法，再 转换 得到的值。

一元加

    一元减 和 加 差不多，只不过 放在整数 前面，变成 负数， 非数字操作 和 一元加 是差不多的。

逻辑非 !

    1 如果 操作数 是一个 对象，返回 false；(注意： 空对象进行 逻辑非 操作 也是 false）

    2 如果 操作数 是一个 空字符串， 返回 true； 如果是 非空字符串 ， 返回 false 

        （! ' 0 ' === false)

    3 如果  操作数 是 数字0 ，返回 true

    4 如果 操作数 是 任意非 0 数值 ，返回 false 

    5 如果 操作数 是  null、NaN、 undefined 返回 true

   同时 使用 两个 逻辑非 操作符，实际上 是模拟 Boolean（）转型 函数的 行为。其中 第一个 逻辑非 会 基于 无论 什么操作数 返回 一个 布尔值，第二个逻辑非 则 对 该布尔值 取反，于是得到了这个值 真正 对应的布尔值。

 逻辑与 &&

        逻辑与 操作 属于 短路操作，即 如果第一个 操作数 能够决定结果，那么就不会 对 第二个操作数求值（所以，在实际项目中，应该将 简单、容易判断的 值 放在前面，进行优化）。对于 逻辑与 ，如果 第一个 操作数 是 false ，则 无论 第二个操作数 是什么值，结果都不可能是 true。

逻辑 或 ||     

    逻辑或 操作符 也属于 短路操作，即 如果第一个 操作数 的 求值 结果 为 true ，就不会对第二个操作数 进行 求值了。

   Infinity * 0  // NaN

   Infinity 与 非0 数值 相乘 结果 是 Infinity 或者 -Infinity ，取决于 有符号 操作数的 符号。
   如果一个 操作数 是 NaN, 则 结果 是 NaN.

   如果 Infinity  被 Infinity  除 ，结果是 NaN.

   如果 Infinity  加 - Infinity  ，结果是 NaN

    - Infinity + (- Infinity )  ===  - Infinity  //true

    Infinity  +  Infinity  === Infinity  // true

    + 0 + ( + 0) === + 0 // true

    -0 + (- 0) === -0 // true

    -0 + (+ 0) === +0 // true

    如果 一个 操作数是 字符串，另一个 是数值， 则将 数值 转换为 字符串，然后进行 拼接。

    如果 一个操作数 是对象、数值或者 布尔值，则 调用 他们的 toString()方法获取 相应的字符串值， 然后在进行 操作。

比较操作符

    如果两个 操作数 都是 数字，则直接进行比较； 一个是数字 ，则将 另一个 操作数 转换为 数字 ，进行比较；如果 两个都是 字符串，怎进行 对应字符编码值 的比较； 如果一个是对象，则进行 valueOf() 方法，然后 得到 的结果 进行比较。如果没有 valueOf ，则调用 toString()方法； 如果一个 是布尔值，则先将其 转换为数值，然后进行比较。

null == undefined // true  

null === undefined // false

NaN ! = NaN // true

逗号操作符

    使用逗号操作符 可以 在一条语句 执行多个操作

    var num1 = 1, num2 = 2, num3 = 3;

    此外，逗号操作符 还可以 用于赋值，在赋值时候，逗号操作符 总会返回 表达式中的最后一项。

    var num = (5,1,4,8,0) ; // num 的值为 0 ，不太常用

for 语句语法

    for( initialization; expression; post-loop-expression) statement

for 语句中的 初始化表达式、控制表达式、循环后表达式 都是可选的，将这几个表达式全部省略，就会创建 一个 无限循环

    for( ; ; ）{ // 无限循环

        doSomething()

    }

 为保证最大限度的兼容性，建议在使用 for-in 循环之前，先检测确认该对象的值 不是 null 和 undefined。

变量、作用域 和 内存问题

    ECMAScript 变量 包含两种不同 数据类型的值： 基本类型值 和 引用类型值。

    基本类型值 指的是 简单的 数据段，而 引用类型值 指的是那些可能由多个值构成的对象。

    五种基本数据类型 是 按值访问的，因为可以操作保存在变量中的实际的值。

    引用类型的值是 保存在内存中的对象，js 不允许直接访问内存中的位置，也就是说不能直接操作对象的内存空间，在操作对象时，实际上是在 操作对象的引用 而 不是实际对象。

    传递参数，ECMAScript 中所有 函数的参数都是按值传递的，也就是说，把函数外部的值复制给函数内部的参数，就和把值从一个变量复制到另一个变量一样。

a 是一个局部变量， a 和 person 引用的是同一个对象

    一般情况下，局部变量、局部对象 会在函数执行完毕后立即销毁（ 闭包除外）。

    对于 引用类型的值，我们可以为其 添加 属性 和 方法，也可以 改变 和 删除其属性 和方法，但是 我们不能给 基本类型的 值添加属性 。 

检测类型

    typeof 有局限性，所以就 提供 instanceof 操作符。

    语法  result = variable instanceof constructor ,  返回布尔值

    根据规定 ，所有 引用类型的值 都是 Object的 实例。 因此，检测一个引用类型值 和 Object 构造函数时， instanceof 操作符 始终会 返回 true 。当然，如果 使用 instanceof 操作符 检测 基本类型 的 值，则该操作符 始终会 返回 false，因为 基本类型 不是对象。

执行环境 及 作用域

    执行环境 定义了 变量 或者 函数有权访问的其他数据，决定了 它们 各自的行为。每个 执行环境都 有一个与之关联的 变量对象（variable object），环境中定义的 所有变量 和 函数 都保存在 这个对象中。虽然 我们编写的代码 无法 访问这个对象，但是 解析器 在处理数据时候 会在后台使用它。

    全局执行环境 是 最外围 的一个执行环境。在 Web 浏览器 中，全局执行环境 被认为 是 window ，因此  所有 全局变量 和 函数 都是作为 window 对象 的属性 和 方法 创建的。 某个 执行 环境中 的 所有 代码执行完毕后，该环境被销毁，保存在 其中 的 所有 变量 和函数定义 也随之销毁（全局执行环境 知道应用程序 退出 ，例如 关闭浏览器 或网页 时，才被销毁）。

    每个函数都有 自己的 执行环境，当执行 流进入 一个函数时，函数的环境 就会被推入 一个环境栈 中。而在 函数执行后，栈将其  环境弹出，把 控制权返回给 之前的执行环境， ECMAScript 程序中的 执行流 正是 由 这个 方便的 机制 控制。

    内部环境 可以通过 作用域链 访问所有 的 外部环境，但是 外部环境不能访问内部环境中的任何变量和 函数。这些环境之间的 联系 是 线性、有次序的。每个环境 都可以向上搜索作用域链，以查询变量 和 函数名；但是 任何环境都不能通过向下 搜索作用域链 而进入 另一个 执行环境。

    声明变量

        使用 var 声明 的 变量 会被 自动添加到 最接近 的环境中。在函数内部，最接近的环境 就是 函数的局部 环境。

    垃圾收集

        JS具有 自动垃圾收集机制，执行环境 会负责管理代码执行过程中使用的内存，开发人员不用在关系内存使用问题，所需内存的分配以及无用内存的回收完全实现了自动管理。垃圾收集器 会按照 固定的时间间隔 （或 代码执行中预定的 收集时间），周期性的将不再继续使用的变量 释放器内存。

        JS 中最常用的垃圾收集方式 是  标记清除（mark-and-sweep）,  当变量 进入环境时，就将这个变量 标记 为 ' 进入环境 '。从逻辑上讲，永远不能 释放进入 环境 的变量 所占用的 内存， 因为 只要执行流 进入相应 的 环境，就可能会用到它们。而当 变量 离开环境时，则将其标记为 ' 离开环境 '。在垃圾收集 期间 ，将被删除。

        另一种方式 叫做 引用计数（reference counting），引用计数 的含义是跟踪记录每个值 被引用的次数，当声明了一个变量 并将 引用 类型值 赋给变量时，则这个值的引用次数 就是1。如果 同一个值 又 赋给 另一个变量，那么 引用次数 就会 +1。相反，如果包含 这个值 的 变量 又 取了另外一个值，那么 引用次数 就会 -1，当引用次数 为 0 时， 系统就会认为 没有办法 在访问 这个变量了，就可以 回收 其 占用 的 内存。当垃圾收集器 下次在运行时，它就会 释放那些 引用次数 为 0 的 值 所占用的内存。

        但是 这种方法 所带来的 问题 就是 ，如果出现 两个变量 相互 依赖 ，循环引用，比如

存在 循环引用，引用计数  算法会导致问题

        那么 它们的 引用次数 就 始终 是 2， 导致 大量 内存 得不到 释放。将变量 设置 为 null 意味 着 切断变量 与 它 此前引用 的值 之间的连接。当垃圾收集器 下次运行的时，就会删除 这些值并回收 他们占用的内存。

    性能

        确保占用 最少的内存 可以让 页面获取更好的性能，优化内存占用的最佳方式，就是执行中的代码值 保存 必要的数据，一旦数据不在有用，最好通过将 其值设置为 null 来释放其引用-------这个做法叫做 解除引用。

        解除一个值的引用并不意味着自动回收该值所占用的内存，解除引用的真正作用是让值脱离执行环境，以便垃圾收集器下次运行手将其回收。

        基本类型值 在内存中占用固定大小的控件，因此被保存在 栈内存 中；引用类型 的值是对象，保存在 堆内存 中。包含引用类型值的变量 实际上 包含的并不是对象本身，而是 一个指向该对象的指针。从一个变量 向 另一个变量 复制 引用 类型 的值，复制的 其实 是指针，因此 两个变量 最终都指向同一个对象。

        确定一个值 是哪种 基本类型 可以使用 typeof 操作符，而确定 一个 值 是那种 引用类型 可以使用 instanceof  操作符。

    引用类型

        属性名中包含会导致语法错误的字符，或者属性名使用的是关键字或保留字，也可以使用方括号表示法。

        例如 person[ 'first name'] = 'XXX'

        由于first name 中包含一个 空格，所以不能使用 点表示法 来访问。这时候就可以使用括号表示法来访问，通常除非必须使用变量来访问属性，否则我们 建议 使用 点表示法。

    创建一个长度为 n( n 为 正整数 ) 的一个数值

     var arr  = new Array( n )；

    有时候，配合 fill 使用，填充数组 元素。

    Array.isArray (value) 确定某个值 到底是不是数组

    调用数组的 toString() 方法 会 返回 由 数组中每个值 的字符串 形式 拼接而成 的 一个 以逗号分隔 的 字符串。 而 调用 valueOf（） 返回 的还是 数组 本身。

    数组的一些 方法： 栈 方法（push、pop）， 队列 方法(shift、unshift)，重排序方法(reverse、sort)，操作方法（count、slice、splice）,位置 方法（ indexOf、lastIndexOf）,迭代方法（every、filter、forEach、map、some）, 缩小方法（reduce、reduceRight）

   Date类型

       var now = new Date();

       Date.parse()  和 Date.UTC()

    Date.parse() 接收 一个 表示 日期的 字符串，然后 尝试 根据字符串 相应的 返回日期的 毫秒数，比如 Date.parse('May 28, 2019')， 如果传入的 字符串 不能表示 日期，返回 NaN。

    Date.UTC() 方法 同样 也是 返回 日期 的 毫秒数，与 Date.parse() 不同的是，它 的参数 分别是 年份、基于0的月份（一月是0 类推）、月中的哪一天（1到31）、小时数（0到23）、分钟、秒钟、毫秒；只有前两参数（年和月 ）是必须的。比如Date.UTC(2019,5)

    Date.now() 表示 调用该方法时的 日期 和 毫秒数

日期格式化

        日期/时间 组件 方法 参考书 102页。

    RegExp类型

            var expression = / pattern / flags （ /正则表达式主体/修饰符(可选) ）

            例如 var patt1 = /正则表达式 / i ;  字面量

            另外一种 构造函数 形式  var patt2=new RegExp (' pattern '，' flags '  )， 两个 参数都是 字符串，不能把 正则表达式 字面量 传递 给 RegExp  构造函数。

            其中 模式（pattern）部分 可以是 任何 简单或者 复杂 的 正则表达式。每个 正则表达式都可以 带一个或多个 标志（flags）， 用来标明 正则表达式的 行为。支持以下3个标志：

            g： 表示全局（global）模式，即模式 将被应用于所有字符串；

            i：表示 不区分 大小写 模式；

            m：表示 多行模式，即在到达 一行文本末尾时，还会 继续查找 下一行是否存在与模式相匹配的项。

            RegExp 的 实例属性，参考 书籍 105页

            RegExp 的 实例方法，最主要的 方法 是 exec（），该方法 是 专门 为 捕获组 而设计的，即 要应用模式 的 字符串，然后 返回 包含 第一个 匹配项信息的数组，没有匹配 返回 null。返回 的 数组 是个 Array 实例，但是包含 两个 额外的 属性， index 和 input 。index 表示匹配项 在 字符串中的 位置，input  表示应用 正则表达式 的字符串。

matches数组

            另外一个是 test() 方法用于检测一个字符串是否匹配某个模式，如果字符串中含有匹配的文本，则返回 true，否则返回 false。

test 经常运用 在 if 语句中

            RegExp 的 实例 继承的 toLocaleString  和 toString 方法 都会返回 正则表达式 的字面量，与创建正则表达式 的 方式无关。正则表达式 的 valueOf 返回 它自己本身。

            RegExp 构造函数 属性 ，详见 108页。

Function 类型

    每一个函数都是 Function 类型的 实例， 而且 与 其他类型一样 都具有 属性 和 方法。由于 函数 是对象，因此 函数名 实际上 也是一个 指向 函数对象的指针，不会与 某个 函数绑定。

函数定义的三种方式

        第三种 方式 不推荐，因为这种语法 导致 解析两次 代码（第一次解析常规的 ECMAScript代码，第二次 式 解析 传入构造函数中 的 字符串），从而影响 性能。不过这种 语法 对于 理解 ' 函数是 对象，函数名 是指针 ' 的概念 很直观。

        函数名 仅仅 是 指向函数的 指针 ，因此 函数名 与 包含 对象 指针的 其他变量 没有什么不同，换句话 来说，一个函数 可能有很多名字。

decrease  和 reduce 都指向 同一个对象

    没有重载（深入理解）

        两个 相同 函数名 的 函数， 后面的 会 覆盖 前面的。

    函数声明 和 函数表达式

解析器 会 率先 读取函数声明， 函数表达式要等到解析器 执行到它 所在的 代码行才被解析执行

    作为 值 的 函数

函数 可以当作参数进行传递

            要访问函数的指针 而不执行 函数的 话， 函数名后面 必须 不带 括号。而上图 这个函数是返回 someFunction 这个 函数 执行的 结果。

   函数内部的属性

    函数内部，有两个特殊的对象，arguments和 this 。

    arguments 是一个 类数组对象，包含着 传入 函数 的 所有参数。虽然 arguments 的主要 用途 是保存函数参数，但是 对象 还有一个 callee 的属性， 该属性 是一个指针，指向 拥有这个 arguments对象 的函数。 arguments.callee

函数 的 执行 和 函数名 耦合在一起，使用 callee 清除 了 耦合，无论函数名是什么，都可以完成递归

            caller 已经移除。

        函数属性 和 方法

            函数 是 对象，因此 函数 也有 属性 和方法。每个 函数包含 两个 属性，length  和 prototype。

            length 表示 函数 希望接受 的 命名参数的个数

length 

        每个 函数 都包含 两个 非继承 而来的 方法： apply（）  和  call（），这两个方法的用途 都是在 特定的 作用域中 调用函数，实际是等于 设置函数体 内 this 对象的值。

        apply 方法 接受两个参数，一个是在其中 运行函数的作用域，另一个是参数 数组。其中，第二个 参数可以是 Array的实例，也可以是 arguments对象。

        call 的第一个参数 也是 运行函数 的作用域，其余的参数 分别是 传入的参数。

扩充函数的作用域

        bind() 方法 创建一个函数 的实例，其 this 值 会被 绑定 到 传给 bind() 函数的值

    基本包装类型

        为了 操作 基本类型， ECMAScript 提供了 三个 特殊 的 引用类型： Boolean、Number和 String。 每当 读取一个基本类型值 的时候，后台就 会创建一个 对应 的 基本包装类型的对象，从而让我们能够 调用一些方法 来操作这些数据。

        基本类型 不是 对象，因而从逻辑上讲 它们 不应该 有方法 （但是它们 确实有方法），为了让这种 操作 能够 执行，后台自动完成了一系列操作，过程： 1 创建 String 类型 的 实例； 2 在实例上调用指定的方法； 3 销毁这个实例

经过处理，基本的字符串 就跟 对象一样了

         具体来讲： 在读取模式下 访问 基本类型，就会创建对应的 基本包装类型 的一个对象，从而方便 操作； 操作基本类型 的 语句 一经执行完毕，就会立即 销毁创建 的包装对象。

        以上 三个 步骤 也适用于  Boolean 和 Number。

        基本类型 一般不能 定义 自己的 属性 和 方法 ，定义了也没用，但是通过 基本包装类型，却可以 获取 定义的属性 和 方法。 

        当然 可以 显示 的 调用 Boolean 、 String、Number 来创建 基本包装类型 的 对象。 不过 不建议这么做。因为这种做法让人分不清楚 自己是在处理 基本类型 还是 引用类型。而且 typeof 基本包装类型 会返回 Object ，而且 所有基本包装类型 的对象 都会被转换为 布尔值 true。比如  new Boolean( false) ， 转换 后 还是 true。

        使用 new 调用 基本包装类型的 构造函数，与 直接调用同名 的 转型函数 是不同的。

二者是不同的

    Number 类型 的 toFixed() 方法 很适合 处理 货币 相关的 业务。它 接受 一个参数，表示 指定 的小数位，返回 数值 的 字符串 表示。如果 数值 本身 小数位 比 指定 的多，那么 接近指定的最大小数位 的值 就会 四舍五入。

toFixed

    字符串方法

        字符方法（chartAt、charCodeAt）

            都接受 一个参数，即 基于0 的字符位置，返回该位置 的 字符。

        字符操作方法（concat） 拼接字符串、 slice、substr、substring

        字符串位置方法 indexOf、lastIndexOf

        trim 方法 返回 一个 删除 前置 和 后缀 的 所有空格的 字符串 副本。

        字符串 大小写 转换方法 toLowerCase()、toLocaleLowerCase()、toUpperCase()和toLocaleUpperCase()

例子

         字符串的模式匹配方法

                String 类型 定义了几个用于在 字符串中 匹配模式的方法。第一个方法就是 match，在字符串上调用这个方法，本质 上与 调用 RegExp的 exec() 方法相同。match方法只接受一个参数，要么是 一个正则表达式，要么是一个 RegExp对象。

match

            另一个 用于 查找模式的方法 是 search（）。这个方法的唯一参数 与 match（）方法 的参数相同： 由字符串 或者 RegExp 对象指定的 一个 正则表达式。 search（）方法 返回 字符串中 第一个匹配项 的 索引。如果没有 ，返回 -1. search() 方法 始终是 从 字符串 开头向后 查找模式。

text 接上图 的 例子

        字符串替换 方法 replace（）。接收两个参数：第一个参数 可以 是一个 RegExp 对象 或者是一个 字符串（这个 字符串不会 被 转换成正则表达式）， 第二个参数 可以 是一个 字符串 或者 一个函数。如果第一个 参数 是 字符串，那么只会替换 第一个字符串。要想替换 所有 字符串 ，唯一的 办法就是 提供 一个正则表达式，而且要 指定全局（g）标志。

    replace 的 第二个参数 也可以 是一个函数。在只有 一个匹配项的 情况下。会向这个函数传递 3 个参数： 模式匹配项、模式匹配项在 字符串 的 位置 和原始 字符串。在正则表达 是中定义了 多个 捕获组 的情况下：传递给函数 的 参数 依次 是 模式的匹配项、第一个 捕获组的匹配项、第二个 捕获组的匹配项........但是最后两个 参数 仍然 是 模式匹配项在 字符串 的 位置 和原始 字符串。 replace 返回 一个 字符串 ，表示 应该 被 替换 的 匹配项 使用 函数 进行操作后 的返回结果。

replace 

        split（）方法用于把一个字符串分割成字符串数组。

            stringObject.split(separator, howmany)

            第一个参数 是 字符串 或者是正则表达式，第二个参数可指定返回的数组的最大长度。

split

        localeCompare方法 和 fromCharCode方法，有印象就行。有需求 在查 api

单体内置对象

       两个单体内置对象 Global 和 Math

        Global对象

            Global 是 ECAMScript 里面最特别 的一个对象，因为 不管你从什么角度 上看，这个对象都不存在。不属于 任何 其他 对象的属性 和方法 ，最终都是 它的 属性 和方法。事实上，没有全局变量 或 全局函数；所有在全局 作用域 中定义 的 属性 和 函数 都是 Global 对象 的 属性。 例如， isNaN()、isFinite（)、parseInt() 以及 parseFloat() ，实际上全都是 Global 对象的方法。除此 之外、Global 对象 还包含 其他方法。

            URI  编码方法

                Global  对象 的 encodeURI（) 和 encodeURIComponent() 方法 可以对 URI(通用资源表示符) 进行编码，以便 发送 给浏览器。有效的 URI 不能包含某些 字符，例如 空格。而 这两个 URI 编码 方法 就可以 对 URI 进行编码，它们用特殊 的 UTF-8 编码 替换所有 无效 的 字符，从而 让浏览器 能够接受 和 理解。

                其中，encodeURI() 主要 用于整个 URI，而 encodeURIComponent() 主要 用于 对URI中 的 某一段进行编码。它们的主要区别在于， encodeURI 不会对本身 属于 URI 的 特殊字符进行编码，例如 冒号、正斜杠、问号 和 井号； 而 encodeURIComponent 则会对 它发现的任何非标准 字符进行编码（会使用 对应 的 编码 替换所有 非字母数字字符）。

                这也正是可以对 整个 URI 使用 encodeURI（）, 而 只能对 附加在现有 URI 后面的字符串 使用 encodeURIComponent 的 原因 所在。（一般来说，我们使用 encodeURIComponent 方法 的时候 比 使用 encodeURI 更多，因为 在实践中 更常见的 是对 查询字符串参数 而不是 对基础 URI 进行编码）。

encodeURI 和 encodeURIComponent

                与 encodeURI 和 encodeURIComponent 对应的 两个方法 分别 是 decodeURI 和 decodeURIComponent 。 decodeURI 只能 对 使用 encodeURI 替换 的 字符进行编码。

            eval() 方法

                eval 方法 大概是 ECMAScript 最强大的一个方法 （所以没事最好不要用它）。它只接受一个参数，即 要执行的 ECMAScript 字符串。

eval

                当 解析器 发现 代码中 调用 eval() 方法 时，它 会将传入 的 参数 当作实际的 ECMAScript 语句来解析， 然后 把 执行结果传入到 原位置。 通过 eval（）执行的 代码被认为 是 包含该次 调用 的 执行环境的一部分，因此 被 执行 的代码 具有 与 该执行环境 相同的 作用域链。这意味着 通过 eval（）执行的 代码 可以引用在 包含 环境中定义的变量。

                在eval 中定义一个 函数

            sayhi 是在 eval 内部 定义的，但是 由于 eval()的 调用 最终 会被 替换成 定义函数的实际代码，因此可以在下一行 使用；同理，eval中 定义的变量 也可以，在其所在的环境中 使用。 

            在eval() 中创建的 任何变量 和 函数 都不会被 提升，因为在解析代码的时候，它们被包含在一个字符串中；它们只在 eval() 执行的时候创建。在 严格模式 下， 在外部访问不到 eval()中创建的任何变量 和 函数。

            Global 对象的属性

                  比如： undefined、NaN 以及 Infinitely 都是 Global 对象的属性。此外，所有原生引用类型的构造函数，像 Object 和 Function 也都是 Global 对象的属性。其他的 详见 书133 页

            window 对象

                ECMAScript 虽然 没有指出 如何 直接 访问 Global 对象，但 Web 浏览器 都是将这个全局对象 作为 window 对象 的 一部分 加以实现的。因此，全局 作用域 中 声明的所有变量 和和 函数 ，就都变成了 window 对象的属性。

       Math对象
                详见 135页

            min() 、max()、ceil()、floor（）、round（）

            random（）

                Math.random()方法 返回 介于 0 与 1之间的随机数 ，不包含 0 和 1 .

                套用 下列 公式， 就可以 利用 Math.random()从 某个整数范围内 随机 选择一个值。

                    值 = Math.floor( Math.random() * 可能值的总数 + 第一个 可能的值 )

                如果你想选一个 1到10 之间的 数值 ，可以 像以下 那样编写：

                    var num = Math.floor( Math.random() * 10 + 1)；

                如果想选个 2 到10 之间的 值， +1 变成 +2