高级程序设计01第一章：简介三部分组成： ECMAScript 提供核心语言功能和对象方法 DOM 提供访问和操作网页

第一章：简介

三部分组成：

ECMAScript 提供核心语言功能和对象方法
DOM 提供访问和操作网页内容的方法和接口
BOM 提供与浏览器交互的方法和接口

ES的功能：语法、类型、语句、关键字、保留字、操作符、对象

DOM的功能：DOM 视图、DOM 事件、DOM 样式、DOM 遍历和范围

BOM的功能：

弹出新浏览器窗口的功能；
移动、缩放和关闭浏览器窗口的功能；
提供浏览器详细信息的 navigator 对象；
提供浏览器所加载页面的详细信息的 location 对象；
提供用户显示器分辨率详细信息的 screen 对象；
对 cookies 的支持；
像 XMLHttpRequest 和 IE 的 ActiveX

第二章：使用js

1、标签位置：

2、延迟脚本：

3、异步脚本：

4、在XHTML中使用js，需要使用一个CData片段来包含js代码，这样XHTML才能正确执行。

<script>
    //<![CDATA[
    var myarr = [];
    myarr.mynumber = 10;
    myarr.mytest = function(){
        console.log(myarr.mynumber);
    }
    //]]>
</script>

5、文档模式：分为标准模式和混杂模式,

<!--HTML 5-->
<!doctype html>

第三章：基本概念

1、语法

1）区分大小写（变量、函数名和操作符）
2）标识符，第一个字符必须是字母、_下划线或美元符号$
3）严格模式use strict，是一个编译指示，让js引擎切换到严格模式，支持浏览器IE10+\Firefox 4+\Safari 5.1+\Opera 12+和Chrome

2、变量

es的变量是松散类型的，变量可以保存任何类型的数据。

var message;            //已声明，未初始化，变量保存特殊的值 undefined
var message = 'hi';     //初始化，字符串值'hi'

3、数据类型

基本类型：Number、String、Boolean、Null、Undefined和复杂类型：Object

使用 typeof 操作符的返回结果：

"undefined"——如果这个值未定义；

"number"——如果这个值是数值；
"string"——如果这个值是字符串；
"boolean"——如果这个值是布尔值；

"object"——如果这个值是对象或 null；
"function"——如果这个值是函数。

1）Undefined只有一个值，就是Undefined。使用var声明了变量但未初始化时，变量的值就是Undefined。

2）Null值也是只有一个值，就是null。

null值表示一个空对象指针，typeof检测null会返回"object"。

var car = null;
alert( typeof car);      //"object"

所以定义的变量将来准备用于保存对象，最好将变量初始化为null而不是其他值。

直接检查null值就可以知道相应的变量是否已经保存了一个对象的引用。

3）Boolean类型，true or false，转型函数Boolean( )。

隐性转换，使用"取反！，或||，并&&"

4）Number类型数值转换方法，Number( )、parseInt( )、parseFloat( )

隐性转换，使用乘1 "value * 1";

var num1 = Number("Hello world!"); //NaN 
var num2 = Number("");          //0 
var num3 = Number("000011");    //11 
var num4 = Number(true);        //1

Number()函数的转换规则如下：

如果是 Boolean 值，true 和 false 将分别被转换为 1 和 0。
如果是数字值，只是简单的传入和返回。
如果是 null 值，返回 0。
如果是 undefined，返回 NaN。
如果是字符串，取有效数字；如果是空字符串，转换为0；如果是纯字符串，返回NaN。

5）String 类型字符串转换方法，toString( )和 string( )

隐性转换，使用加字符串空值  + "" ;

var age = 11; 
var ageAsString = age.toString(); // 字符串"11"

6）Object 类型

constructor：保存着用于创建当前对象的函数。
hasOwnProperty( )：用于检查给定的属性在当前对象实例中是否存在。如：obj.hasOwnProperty("name")
isPrototypeOf：用于检查传入的对象是否是传入对象的原型
propertyIsEnumerable( )：用于检查给定的属性是否能够使用 for-in 语句（本章后面将会讨论）来枚举。
toString()：返回对象的字符串表示
valueOf()：返回对象的字符串、数值或布尔值表示。

4、操作符

1)相等操作符 == 和 != 返回true和false，先转换操作数（强制转型），然后再比较他们的相等性。

基本规则如下：

a、布尔值，转换为0或者1；
b、字符串--数值，字符串转为数值；
c、对象--其他，
d、null和undefined是相等的；

2）条件操作符

var max = (num1 > num2)? num1 : num2;

5、语句

1)for-in语句，用来枚举对象的属性和值。

for(var val in window){
    document.write(val+':'+window[val]+'<br>')  //打印window对象的属性和值
 }

2）break和continue语句

break 语句会立即退出循环，强制继续执行循环后面的语句。
continue 语句虽然也是立即退出循环，但退出循环后会从循环的顶部继续执行。

3）with语句

with 语句的作用是将代码的作用域设置到一个特定的对象中。with 语句的目的主要是为了简化多次编写同一个对象的工作。

严格模式下不允许使用 with 语句，否则将视为语法错误。

6、函数

这个函数会在执行完 return 语句之后停止并立即退出。

function diff(num1, num2) { 
     if (num1 < num2) { 
        return num2 - num1; 
     } else { 
        return num1 - num2；
     }
}

第四章变量、作用域和内存

一、基本类型和引用类型的值

js语言的定义变量不分数据类型，变量的值及其数据类型可以在脚本的生命周期内改变。

1、基本类型\引用类型

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

基本类型：undefined、null、boolean、number和string.是按值访问的，可以操作保存在变量中的实际的值。

引用类型：保存在内存中的对象（实际上是在操作对象的引用而不是实际的对象）

引用类型的值，可以为其添加属性和方法，也可以改变其属性和方法

2、复制变量

复制基本类型时，num1 = num2，这两个变量可以参与任何操作而不会互相影响。
复制引用类型时， obj1 = obj2，这两个变量实际上是引用同一个对象，改变其中一个变量，就会影响另一个变量。

3、传递参数

向参数传递基本类型的值时，被传递的值会被复制给一个局部变量。
向参数传递引用类型的值时，会把这个值在内存中的地址复制给局部变量，因此局部变量的变化会反应在函数的外部。例子：

var num1 = 10;
var obj01 = {
    'name':'Nixi'
}
function change(number,obj){
    obj.name = 'flyting';
    number = 20
}
change(num1,obj01);

console.log(num1);          //10 不改变
console.log(obj01.name);    //flyting 已改变

向参数传递引用类型的值时，当在函数内部重写obj时，这个变量引用的就是一个局部对象了，这个局部对象会在函数执行完毕后立即销毁。例子：

var obj01 = {
    'name':'Nixi'
}
function change(obj){
    obj.name = 'flyting';
    obj = new Object();
    obj.name = 'lily';
}
change(obj01);

console.log(obj01.name);    //flyting，而不是lily

4、检测类型

typeof操作符，在变量是一个对象或null时，都返回"object";

instanceof 检测引用类型

在检测一个引用类型值和 Object 构造函数时，instanceof 操作符始终会返回 true。

var person = {
                'name':'ting'
            }
var colors = ['red','blue','white']
var pattern = new RegExp();
console.log(person instanceof Object);       //true
console.log(colors instanceof Array);       //true
console.log(pattern instanceof  RegExp);    //true

二、执行环境及作用域

执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。

每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中，我们编写的代码无法访问这个对象，但解析器在处理数据时会在后台使用它。

当代码在一个环境中执行时，会创建变量对象的一个作用域链。

作用域链的用途，是保证对执行环境有权访问的所有变量和函数的有序访问。

1）作用域链的前端，是当前执行的代码所在环境的变量对象
2）全局执行环境的变量对象始终都是作用域链中的最后一个对象
3）标识符解析：沿着作用域链一级一级，逐级向后回溯，直至找到标识符为止（如果找不到，通常会导致错误发生）配图

1、延长作用域链

执行环境的类型--全局和局部（函数），有些类型可以在作用域链的前端临时增加一个变量对象，该变量对象会在代码执行后被移除。

try-catch语句的catch块
with语句

对with语句来说，会将指定的对象添加到作用域链中

对catch语句来说，会创建一个新的变量对象，其中包含的是被抛出的错误对象的声明。

例子：

function buildUrl(){
   var qs = "?debug=true";
   with(location){
       var url = href + qs;
   }
   return url;
}
var getUrl = buildUrl();
console.log(getUrl);   //http://localhost:63342/JavaScript/Ch21/00.html?debug=true

2、没有块级作用域

在js中，for（）{ ... } 以及 if（）{ ...} ，没有自己的作用域，会存在循环外部的执行环境中。

1）声明变量

使用var声明的变量会自动添加到最接近的环境中。在with语句中，最接近的环境是函数环境。

如果初始化变量时没有使用var声明，该变量会自动添加到全局环境。

2）查询标识符

查找标识符，搜索过程从作用域链的前端开始，向上逐级查询与给定名字匹配的标识符。

三、垃圾收集

垃圾收集机制：找出那些不再继续使用的变量，然后释放其占用的内存，按照固定的时间间隔（或代码执行中预定的收集时间）。

1）标记清除， 当变量进入环境（如在函数中声明一个变量），此变量标记为“进入环境”，当变量离开环境时，其标记为“离开环境.....

2）引用计数 弊端：循环引用，对象A中包含一个指向对象B的指针，而对象B中也包含一个指向对象A的引用。为了避免类似的循环引用问题，在不使用它们的时候手工断开原生JS对象与DOM元素之间的连接。例子：

var element = document.getElementById("some_element");
var myObj = new Object();
myObj.element = element;
element.someObj = myObj;

myObj.element = null;
element.someObj = null;

性能问题： 频繁的触发垃圾收集器运行，会引发严重性能问题。

IE7的js引擎来及收集例程的工作方式，触发垃圾收集的变量分配、字面量和数组元素的临界值被调整为动态修正。

管理内存： 优化内存占用的最佳方式，就是为执行中的代码只保存必要的数据，一旦数据不再有用，最好通过值=null来释放其引用，即解除引用。

适用于大多数全局变量和全局对象的属性，局部变量会在它们离开执行环境时自动被解除引用。如：

function createPerson(name){
    var localPerson = new Object();
    localPerson.name = name;
    return localPerson;
}
var globalPerson = createPerson('flyting');

//手工移除globalPerson的引用
globalPerson = null;

在 ES 中，引用类型是一种数据结构，用于将数据和功能组织在一起。
它也常被称为类，但它不具备传统的面向对象语言所支持的类和接口等基本结构。
引用类型有时候也被称为对象定义，因为它们描述的是一类对象所具有的属性和方法。
对象（引用类型的值）是引用类型的一个实例

第五章引用类型

一、Object类型

1、创建Object类型的两种方式

    //方式 1，new操作符
    var obj1 = new Object();
    obj1.name = 'lily';
    obj1.age = 30;
    
    //方式 2，对象字面量表示法
    var obj2 = {
        name : 'flyting',
        age : 30
    }

2、访问对象属性时，使用点表示法和方括号表示法。

使用[]表示法，可以通过变量来访问属性，并且变量内的值，可以包含非字母非数字

console.log( person.name );
console.log( person["name"] );

二、Array类型

ECMAScript数组的每一项可以保存任何类型的数据。（如字符串，数值，对象等）

var colors = ["red",20,{"age":20},3];
colors[99] = 'black';
console.log(colors.length);   //100

数组的长度是100，位置3到98的实际上是不存在，访问它们都将返回undefined。

1、检测数组

Array.isArray( colors ) ,这个方法的目的是确定某个值到底是不是数组，而不管它是在哪个全局执行环境中创建的。

2、转换方法

toString()：返回由数组值，字符串的形式，用逗号分隔

valueOf(): 返回的还是数组

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString());   // red,blue,green 字符串
alert(colors.valueOf());    // red,blue,green 数组

3、栈方法（LIFO 后进先出）

栈是一种LIFO的数据结构，就是最新添加的项被最早移除，插入和移除只发生在一个位置---栈的顶部。

push(): 添加到数组末尾, 返回值是修改后数组的长度

pop(): 从数组末尾移出最后一项，返回值是移除的项

var colors = ['red','green'];
var count = colors.push('black');

console.log(colors);    // ["red", "green", "black"]
console.log(count);     // 3

4、队列方法（FIFO 先进先出）

队列是一种FIFO的数据结构，就是队列在列表的末端添加项，从列表的前端移除项。

push(): 添加到数组末尾

shift(): 从数组中的第一个项移除，并返回该项。

unshift()：添加到数组第一项，返回值是新数组的长度。

var colors = ['red','green'];
var count = colors.unshift('black','white');

console.log(colors);    // ["black", "white", "red", "green"]
console.log(count);     // 4

5、重排序方法

reverse(): 反转数组项

sort(): 按升序排列数组项

var values = [1, 0, 3, 4, 5];

values.reverse();
console.log(values);  // 5, 4, 3, 0, 1

values.sort();
console.log(values);  //0, 1, 3, 4, 5

6、操作方法

concat(): 添加数组（参数可以是数组或其他）

slice(): 截取数组。两个参数时，返回起始和结束位置之间的项；一个参数时，返回指定位置开始到末尾的所有项（不包括结束位置的项）

splice()：最强大的数组方法

splice(起始位置，删除的项数，插入的项数)

删除：splice(0,2)会删除数组中的前两项
插入：splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。
替换：splice (2,1,"red","green")会删除当前数组位置 2 的项，然后再从位置 2开始插入字符串"red"和"green"

var colors = ["red", "green", "blue"]; 
var colors2 = colors.concat("yellow", ["black", "brown"]); 

console.log(colors);    //red,green,blue
console.log(colors2);   //red,green,blue,yellow,black,brown

var colors = ["red", "green", "blue", "yellow", "purple"]; 
var colors2 = colors.slice(1); 
var colors3 = colors.slice(1,3); 

alert(colors2);     //green,blue,yellow,purple 
alert(colors3);     //green,blue

7、位置方法（查找特定项在数组中的位置）

indexOf()和lastIndexOf()

两个参数，要查找的项和表示查找起点位置的索引（可选的）。
返回要查找的项在数组中的位置，没找到返回-1

var numbers = [1,2,3,4,5,4];
console.log(numbers.indexOf(4));    //3
console.log(numbers.lastIndexOf(4));    //5
console.log(numbers.indexOf(10));       //-1

8、迭代方法

ES5 为数组定义了 5 个迭代方法（every,filter,forEach,map,some）。

都接收两个参数：要在每一项上运行的函数和运行该函数的作用域对象——影响 this 的值（可选的）。
传入这些方法中的函数会接收三个参数：数组项的值、位置和数组对象本身(item, index, array)。

[1]、every()和 some()

它们都用于查询数组中的项是否满足某个条件，

every()，传入的函数每一项都返回 true，则是true；而 some()方法某一项返回 true，就会返回 true。

例1：检查是否所有给定项大于2；

var numbers = [1,2,3,4,5,6];
var everyResult = numbers.every(function(item, index, array){
    return (item > 2);
});
var someResult = numbers.some(function(item, index, array){
    return (item > 2);
});

console.log(everyResult);   //false
console.log(someResult);    //true

[2]、filter()

它利用指定的函数确定是否在返回的数组中包含某一项,返回符合条件的数组。

var numbers = [1,2,3,4,5,6];
var filterResult = numbers.filter(function(item, index, array){
    return (item > 2);
});

console.log(filterResult); // [3,4,5,6];

[3]、map()

返回一个新数组，为数组每一项执行一个指定函数。

var numbers = [1,2,3,4,5,6];
var mapResult = numbers.map(function(item, index, array){
    return item * 2;
});

console.log(mapResult); // [2, 4, 6, 8, 10, 12]

[4]、forEach()

这个方法没有返回值, 对数组中的每一项运行传入的函数。与使用 for 循环迭代数组一样。

var numbers = [1,2,3,4,5,6]; 
numbers.forEach(function(item, index, array){ 
 //执行某些操作 
});

9、归并方法

reduce()和 reduceRight()

这两个方法都会迭代数组的所有项，然后构建一个最终返回的值。
reduce()方法从左向右，而 reduceRight()则从右向左。
两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。
函数接收 4 个参数：前一个值、当前值、项的索引和数组对象(prev, cur, index, array)

例子：所有值的和

var values = [1,2,3,4,5]; 
var sum = values.reduce(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
alert(sum); //15

三、Date类型（待补充）

Date类型使用自UTC（国际协调时间）1970年1月1日零时开始经过的毫秒数来保存日期。

Dare类型保存的日期可以精确到1970年之前或之后的285 616年。

Date函数不传参数的时候，获得的是当前的日期和时间。

console.log( Date() );          //获得当前时间，Tue Jun 12 2018 09:38:46 GMT+0800 (中国标准时间)
console.log( Date.now() );      //获得当前时间，1528772996582
console.log( Date.parse("May 20,1980"));   //转换时间，327600000000
console.log( Date.UTC(1980,5,20) )         //转换时间，330307200000

// 取得开始时间
var start = Date.now(); 
// 调用函数
doSomething(); 
// 取得停止时间
var stop = Date.now();
var result = stop –start;

1、继承的方法

2、日期格式化方法

Date类型有一些专门用于将日期格式化为字符串的方法。

3、日期/时间组件方法

一些取得和设置日期的API方法，其中，UTC日期指的是在没有时区偏差的情况下的日期值。（将日期转换为GMT时间）。

console.log( nowTime.getTime() );      //1528774418642
console.log( nowTime.getFullYear() );   //2018
console.log( nowTime.getMonth()+1 );    //6
console.log( nowTime.getUTCDate() );    //12

四、RegExp 类型（待补充）

五、Function 类型

函数是对象，函数名是指针
一个函数可能会有多个名字，
使用不带圆括号的函数名是访问函数指针，而非调用函数。

function sum(num1, num2){ 
 return num1 + num2; 
} 

var anotherSum = sum;   // 访问函数指针
alert(anotherSum(10,10));       //20 
sum = null; 
alert(anotherSum(10,10));       //20

1、没有重载（深入理解）

当函数命名重复时，会被覆盖。

2、函数声明与函数表达式

区别：

（1）解析器会率先读取函数声明，并使其在执行任何代码之前可用（可以访问）；

alert(sum(10,10)); 
function sum(num1, num2){ 
 return num1 + num2; 
}

（2）至于函数表达式，则必须等到解析器执行到它所在的代码行，才会真正被解释执行。

alert(sum(10,10)); 
var sum = function(num1, num2){ 
 return num1 + num2; 
};      // 运行错误

3、作为值的函数

函数也可以作为值来使用。1）当做参数传递，2）当做函数的结果返回。

4、函数内部属性

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

（1）arguments是一个类数组对象，包含着传入函数中的所有参数;

arguments.callee,该属性是一个指针,指向拥有这个 arguments 对象的函数.

例子：无论引用函数时使用的是什么名字，都可以保证正常完成递归调用。

// 当前函数执行时，与函数名factorial紧紧耦合了，
function factorial(num){ 
 if (num <=1) { 
 return 1; 
 } else { 
 return num * factorial(num-1) 
 } 
} 

// 为了解除耦合，将factorial 改为arguments.callee
function factorial(num){ 
 if (num <=1) { 
 return 1; 
 } else { 
 return num * arguments.callee(num-1) 
 } 
}

（2）this引用的是函数据以执行的环境对象——或者也可以说是this值（当在网页的全局作用域中调用函数时，this 对象引用的就是 window）。

window.color = "red"; 
var newObj = { color: "blue" }; 
function sayColor(){ 
alert(this.color); 
} 

newObj.sayColor = sayColor; 

sayColor();     //"red" 
newObj.sayColor();   //"blue"

当在全局作用域中调用sayColor()时，this 引用的是全局对象window；

而当把这个函数赋给对象newObj并调用newObj.sayColor()时，this引用的是对象newObj.

5、函数属性和方法

每个函数都包含两个属性：length 和 prototype。

(1)length 属性表示函数的命名参数的个数

function sum(num1, num2){ 
 return num1 + num2; 
} 
alert(sum.length); //2

(2)prototype属性

在ES5中，prototype 属性是不可枚举的，因此使用 for-in 无法发现

prototype 是保存它们所有实例方法的真正所在

每个函数都包含两个非继承而来的方法：apply()和 call()。

这两个方法的用途：在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。

它们真正强大的地方是能够扩充函数赖以运行的作用域。

（1）apply()方法接收两个参数：（在其中运行函数的作用域，参数数组array或者arguments 对象）

function sum(num1, num2){ 
 return num1 + num2; 
} 
function callSum1(num1, num2){ 
 return sum.apply(this, arguments);   // 传入arguments对象或数组[num1,num2]
} 

console.log(callSum1(10,10)); //20

(2)call()方法

与apply()方法的区别：在于接收参数的方式不同。

function sum(num1, num2){ 
 return num1 + num2; 
} 
function callSum(num1, num2){ 
 return sum.call(this, num1, num2);   //参数是列举出来的
} 

console.log(callSum1(10,10)); //20

（3）bind()，会创建一个函数的实例，其 this 值会被绑定到传给 bind()函数的值。

window.color = "red"; 
var o = { color: "blue" }; 
function sayColor(){ 
 alert(this.color);   //red
} 
var objectSayColor = sayColor.bind(o); 
objectSayColor(); //blue

六、基本包装类型

ES 还提供了 3 个特殊的引用类型：Boolean、Number 和String。

基本类型值不是对象，从逻辑上讲它们不应该有方法（实际上它们有方法）
每当读取一个基本类型值，后台就会创建一个对应的基本包装类型的对象，从而我们能够调用一些方法来操作这些数据。
引用类型与基本包装类型的主要区别：就是对象的生存期。引用类型是作用域，基本类型是一行代码的执行瞬间。

1、Boolean类型

不建议直接实例化 Boolean类型

基本类型与引用类型的布尔值区别：

typeof 操作符对基本类型返回"boolean"，而对引用类型返回"object"。
由于 Boolean 对象是 Boolean 类型的实例，所以使用 instanceof 操作符测试 Boolean 对象会返回 true，而测试基本类型的布尔值则返回 false。

2、Number类型

不建议直接实例化 Number 类型

3、String类型

String 类型提供了很多方法，用于辅助完成对 ES 中字符串的解析和操作。

1）字符方法： charAt()和 charCodeAt()：用于访问字符串中特定字符的方法

var stringValue = "hello world"; 
alert(stringValue.charAt(1)); //"e"
alert(stringValue.charCodeAt(1)); //"101" 字符编码

2）字符串操作方法

concat()它们只是返回一个基本类型的字符串值，对原始字符串没有任何影响

var stringValue = "hello "; 
var result = stringValue.concat("world", "!"); 
alert(result);      //"hello world!"

slice()、substr(), 参数是(开始位置,结束位置) substring(),参数是(开始位置,返回的字符个数)

var stringValue = "hello world"; 
alert(stringValue.slice(3, 7));     //"lo w" 
alert(stringValue.substring(3,7));      //"lo w" 
alert(stringValue.substr(3, 7));        //"lo worl" 

alert(stringValue.slice(3, -4));        //"lo w" 
alert(stringValue.substring(3, -4));    //"hel" 
alert(stringValue.substr(3, -4));       //""（空字符串）

字符串位置方法

indexOf()和lastIndexOf(), 参数是(要查找的元素,开始位置)

trim()方法

原始字符串不变,这个方法会创建一个字符串的副本，删除前置及后缀的所有空格，然后返回结果.

字符串大小写转换方法

toLowerCase()、toLocaleLowerCase()、toUpperCase()和toLocaleUpperCase()。

字符串的模式匹配方法

match()方法只接受一个参数,返回了一个数组

search()方法只接受一个参数,返回字符串中第一个匹配项的索引；如果没有找到匹配项，则返回-1

replace()方

split()

localeCompare()方法

比较两个字符串,字母表中的顺序.

var stringValue = "yellow"; 
alert(stringValue.localeCompare("brick"));      //1 
alert(stringValue.localeCompare("yellow"));     //0 
alert(stringValue.localeCompare("zoo"));        //-1

fromCharCode()方法

接收一或多个字符编码，然后将它们转换成一个字符串

alert(String.fromCharCode(104, 101, 108, 108, 111));    //"hello"

七、单体内置对象

ES实现提供的、不依赖于宿主环境的对象，这些对象在 ECMAScript 程序执行之前就已经存在了。

如 Object、Array、String，以及Global 和 Math。

1、Global对象

所有在全局作用域中定义的属性和函数，都是 Global 对象的属性。

诸如 isNaN()、isFinite()、parseInt()以及 parseFloat()，实际上全都是 Global对象的方法。

(1)encodeURI()和 encodeURIComponent()方法

对 URI（Uniform Resource Identifiers，通用资源标识符）进行编码，它们用特殊的 UTF-8 编码替换所有无效的字符，从而让浏览器能够接受和理解。

有效的 URI 中不能包含某些字符，例如空格，字符。

var uri = "http://www.wrox.com/illegal value.htm#start"; 

console.log(encodeURI(uri));        //"http://www.wrox.com/illegal%20value.htm#start" 
console.log(encodeURIComponent(uri));     //"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"

(2)Global 对象的属性

(3) window 对象

Web 浏览器都是将这个全局对象作为window 对象的一部分加以实现的。

2、 Math对象

Math 对象提供的一些计算功能的方法。

（1） min()和 max()方法：取最大值和最小值

var max = Math.max(3, 54, 32, 16);
var min = Math.min(3, 54, 32, 16);
alert(max); //54
alert(min); //3
    
    
var array = [3, 54, 32, 16];
var max = Math.max.apply(Math, array);  //54
var min = Math.min.apply(Math, array);  //3
    
// 这个技巧的关键是把 Math 对象作为 apply()的第一个参数，从而正确地设置 this 值。
然后，可以将任何数组作为第二个参数。

(2) 舍入方法

Math.ceil()、Math.floor()和 Math.round()。

(3) random()方法

返回大于等于 0 小于 1 的一个随机数。

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

高级程序设计01