1、<script>元素：该元素定义了下列6个属性
<1>async:表示应该立即下载脚本，但不应妨碍页面中的其他操作，比如下载其他资源或等待加载其他脚本。只对外部脚本文件有效。
<2>charset:表示src属性指定的代码字符集。
<3>defer:表示脚本可以延迟到文档完全被解析和显示之后在执行。只对外部脚本有效。IE7及更早版本对嵌入脚本也支持这个属性
<4>language
<5>src:表示包含要执行代码的外部文件。
<6>type:表示编写代码使用的脚本语言内容类型。
延迟脚本：defer属性的用途是表示脚本在执行时不会影响页面的构造。也就是说脚本会被延迟到整个页面都解析完毕后再运行。相当于告诉浏览器立即下载，但延迟执行。
异步脚本：async属性同defer属性类似，都用于改变处理脚本的行为。async的脚本都不保证按照指定他们的先后顺序执行。
2、嵌入代码和外部文件
应尽可能使用外部文件来包含JavaScript代码，优点是：
1.可维护行：遍及不同HTML页面的JavaScript会造成维护问题。但把所有JavaScript文件都放在一个文件夹中，维护起来轻松多了。而且开发人员因此也能够在不触及HTML标记的情况下，集中精力编辑JavaScript代码；
2.可缓存：浏览器能够根据具体的设置缓存链接的所有外部JavaScript文件。也就是说，如果有两个页面都使用同一个文件，那么这个文件只需下载一次。因此，最终结果就是能够加快页面加载的速度。
3.适应未来：通过外部文件来包含JavaScript无须使用前面提到XHTML或注释hack。HTML和XHTML包含外部文件的语法是相同的。
3、<noscript>元素：noscript元素中的内容只有在下列情况下才会显示出来：
浏览器不支持脚本；
浏览器支持脚本，但脚本被禁用。
4、基本概念、区分大小写
5、关键字和保留字（*为新增关键字）
====================关键字=========================
break do instanceof typeof
case else new var
catch finally return void
continue for switch while
debugger* function this with
default if throw
delete in try
=====================保留字=========================
abstract enum int short
boolean export interface static
byte extends long super
char final native synchronized
class float package throws
const goto private transient
debugger implements protected volatile
double import public
6、数据类型
undefined：值未定义（对尚未声明过的变量，只能执行一项操纵，即使用typeof操作符检测其数据类型）
boolean：布尔值（区分大小写；字面值为true和false）
string：字符串
number：数值
object：对象或null
function：函数
注：对未初始化和未声明的变量指定typeof操作符都返回了undefined值。
1.数值转换：非数值转换为数值函数：Number(),parseInt() 和 parseFloat()。
Number()函数的转换规则如下：
1、如果是Boolean值，true和false将分别被转换为1和0.
2、如果是数字值，只是简单的传入和返回；
3、如实是null值，返回0；
4、如果是undefined，返回NaN；
5、如果是字符串，则遵循下列规则：
如果字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即"1"会变成 1，"123"会变成 123，而"011"会变成 11（注意：前导的零被忽略了）；
如果字符串中包含有效的浮点格式，如"1.1"，则将其转换为对应的浮点数值（同样，也会忽略前导零）；
如果字符串中包含有效的十六进制格式，例如"0xf"，则将其转换为相同大小的十进制整数值；
如果字符串是空的（不包含任何字符），则将其转换为 0；
如果字符串中包含除上述格式之外的字符，则将其转换为 NaN。
6、如果是对象，则调用对象的valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()方法，然后再次依照前面的规则转换返回的字符串值。
实例：
var num1 = Number("Hello world!"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1
parseInt()函数的转换规则如下：
parseInt()函数在转换字符串时，更多的是看其是否符合数值模式。它会忽略字符串前面的空格，直至找到第一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt()就会返回 NaN；
也就是说，用 parseInt()转换空字符串会返回 NaN（Number()对空字符返回 0）。如果第一个字符是数字字符，parseInt()会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。
例如，"1234blue"会被转换为 1234，因为"blue"会被完全忽略。类似地，"22.5"会被转换为 22，因为小数点并不是有效的数字字符。如果字符串中的第一个字符是数字字符，
parseInt()也能够识别出各种整数格式（即前面讨论的十进制、八进制和十六进制数）。也就是说，如果字符串以"0x"开头且后跟数字字符，就会将其当作一个十六进制整数；
如果字符串以"0"开头且后跟数字字符，则会将其当作一个八进制数来解析。
实例：
var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt(""); // NaN
var num3 = parseInt("0xA"); // 10（十六进制数）
var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); // 56（八进制数）
var num6 = parseInt("70"); // 70（十进制数）
var num7 = parseInt("0xf"); // 15（十六进制数）
指定基数会影响到转换的输出结果。例如：
var num1 = parseInt("10", 2); //2 （按二进制解析）
var num2 = parseInt("10", 8); //8 （按八进制解析）
var num3 = parseInt("10", 10); //10 （按十进制解析）
var num4 = parseInt("10", 16); //16 （按十六进制解析）
注：不指定基数意味着让 parseInt()决定如何解析输入的字符串，因此为了避免错误的解析，我们建议无论在什么情况下都明确指定基数。
parseFloat()函数的转换规则如下：
与 parseInt()函数类似，parseFloat()也是从第一个字符（位置0）开始解析每个字符。而且也是一直解析到字符串末尾，或者解析遇到一个无效的浮点数字字符为止。也就是说，字符串中第一个小数点是有效的，
而第二个小数点就是无效的了，因此他后面的字符串将被忽略。举例来说，"22.34.5"将会被转换为 22.34。
除了第一个小数点有效之外，parseFloat()与 parseInt()的第二个区别在于它始终都会忽略前导的零。parseFloat()可以识别前面讨论过的所有浮点数值格式，也包括十进制整数格式。
但十六进制格式的字符串则始终会被转换成 0。由于 parseFloat()只解析十进制值，因此它没有用第二个参数指定基数的用法。最后还要注意一点：如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后
都是零），parseFloat()会返回整数。以下是使用 parseFloat()转换数值的几个典型示例。
实例：
var num1 = parseFloat("1234blue"); //1234 （整数）
var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
var num6 = parseFloat("3.125e7"); //31250000
String()函数遵循下列转换规则：
如果值有 toString()方法，则调用该方法（没有参数）并返回相应的结果；
如果值是 null，则返回"null"；
如果值是 undefined，则返回"undefined"。
实例：
var value1 = 10;
var value2 = true;
var value3 = null;
var value4;
alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"
注：null 和 undefined 没有 toString()方法，所以 String()函数就返回了这两个值的字面量。
7、相等操作符
相等和不相等（!= and ==）--先转换再比较，全等和不全等（!== and ===）--仅比较而不转换。
8、基本概念小结
1.ECMAScript 中的基本数据类型包括 Undefined、Null、Boolean、Number 和 String。与其他语言不同，ECMScript 没有为整数和浮点数值分别定义不同的数据类型，Number 类型可用于表示所有数值。
2.ECMAScript 中也有一种复杂的数据类型，即 Object 类型，该类型是这门语言中所有对象的基础类型。严格模式为这门语言中容易出错的地方施加了限制。
3.ECMAScript 提供了很多与 C 及其他类 C 语言中相同的基本操作符，包括算术操作符、布尔操作符、关系操作符、相等操作符及赋值操作符等。
4.ECMAScript 从其他语言中借鉴了很多流控制语句，例如 if 语句、for 语句和 switch 语句等。
5.ECMAScript 中的函数与其他语言中的函数有诸多不同之处。无须指定函数的返回值，因为任何 ECMAScript 函数都可以在任何时候返回任何值。实际上，未指定返回值的函数返回的是一个特殊的 undefined 值。
6.ECMAScript 中也没有函数签名的概念，因为其函数参数是以一个包含零或多个值的数组的形式传递的。可以向 ECMAScript 函数传递任意数量的参数，并且可以通过 arguments 对象来访问这些参数。由于不存在函数签名的特性，ECMAScript 函数不能重载。
9、基本类型和引用类型的值
基本类型指的是简单的数据段（Undefined,Null,Boolean,Number,String），而引用类型指那些可能由多个值构成的对象。
10、执行环境及作用域
执行环境的类型总共只有两种--全局和局部（函数）。
当执行流进入下列任何一种语句时，作用域链就会得到加长：
1.try-catch 语句的 catch 块；
2.with 语句。
11、没有块级作用域：Javascript没有块级作用域经常会导致理解上的困惑。
经典实例：
if (true) {
var color = "blue";
}
alert(color); //"blue"
for (var i=0; i < 10; i++){
doSomething(i);
}
alert(i); //10
1.声明变量
使用var声明的变量会自动被添加到最近的环境中。在函数内部，最接近的环境就是函数的局部环境；在with语句中，最接近的环境是函数环境。如果初始化变量时没有使用var声明，该变量会自动被添加到全局环境。
注：在编写JavaScript代码的过程中，不声明而直接初始化变量是一个常见的错误做法，因为这样可能会导致意外。我们建议在初始化变量之前，一定要先声明，这样就可以避免类似问题。
在严格模式下，初始化未经声明的变量会导致错误。
2.查询标识符：就近原则，延作用链域向上搜索。搜索过程会一直追溯到全局环境的变量对象，如果全局环境中没有找到标识符，则意味着该变量尚未声明。
在搜索过程中，如果存在一个局部的变量的定义，则搜索会自动停止，不再进入另一个变量对象。及局部环境中存在着同名标识符，则不会使用父环境中的标识符。
经典实例：
var color = "blue";
function getColor(){
var color = "red";
return color;
}
alert(getColor()); //"red"
3.JavaScript垃圾收集原理：
找出那些不在继续使用的变量，然后释放其占用的内存。垃圾收集器会按照固定的时间间隔（或代码执行中预定的收集时间），周期性的执行这一操作。
用于标示无用变量的策略可能会因实现而异，而具体到浏览器中的实现，而通常有两个策略。
标记清除；
垃圾回收器在运行的时候会给存储在内存中的所有变量都加上标记（当然，可以使用任何标记方式）。然后，他会去掉环境中的变量引用的变量和标记。而在次之后再被加上标记的变量将被视为准备删除的变量，
原因是环境中的变量已经无法访问到这些变量了。最后，垃圾收集器完成内存清除工作，销毁哪些带标记的值并回收它们所占用的内存空间。
引用计数
管理内存：原因--分配给Web浏览器的可用内存数量通常要比分配给桌面应用程序的少。
12、变量、作用域和内存问题小结：
JavaScript 变量可以用来保存两种类型的值：基本类型值和引用类型值。基本类型的值源自以下 5 种基本数据类型：Undefined、Null、Boolean、Number 和 String。基本类型值和引用类型值具有以下特点：
1、基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中：从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本；
2、引用类型的值是对象，保存在堆内存中；
3、包含引用类型值的变量实际上包含的并不是对象本身，而是一个指向该对象的指针；
4、从一个变量向另一个变量复制引用类型的值，复制的其实是指针，因此两个变量最终都指向同一个对象；
5、确定一个值是哪种基本类型可以使用 typeof 操作符，而确定一个值是哪种引用类型可以使用instanceof 操作符。
所有变量（包括基本类型和引用类型）都存在于一个执行环境（也称为作用域）当中，这个执行环境决定了变量的生命周期，以及哪一部分代码可以访问其中的变量。以下是关于执行环境的几点总结：
1、执行环境有全局执行环境（也称为全局环境）和函数执行环境之分；
2、每次进入一个新执行环境，都会创建一个用于搜索变量和函数的作用域链；
3、函数的局部环境不仅有权访问函数作用域中的变量，而且有权访问其包含（父）环境，乃至全局环境；
4、全局环境只能访问在全局环境中定义的变量和函数，而不能直接访问局部环境中的任何数据；
5、变量的执行环境有助于确定应该何时释放内存。
JavaScript 是一门具有自动垃圾收集机制的编程语言，开发人员不必关心内存分配和回收问题。可以对 JavaScript 的垃圾收集例程作如下总结。
1、离开作用域的值将被自动标记为可以回收，因此将在垃圾收集期间被删除。
2、“标记清除”是目前主流的垃圾收集算法，这种算法的思想是给当前不使用的值加上标记，然后再回收其内存。
3、另一种垃圾收集算法是“引用计数”，这种算法的思想是跟踪记录所有值被引用的次数。JavaScript引擎目前都不再使用这种算法；但在 IE 中访问非原生 JavaScript 对象（如 DOM 元素）时，这种算法仍然可能会导致问题。
4、当代码中存在循环引用现象时，“引用计数”算法就会导致问题。
5、解除变量的引用不仅有助于消除循环引用现象，而且对垃圾收集也有好处。为了确保有效地回收内存，应该及时解除不再使用的全局对象、全局对象属性以及循环引用变量的引用。
13、引用类型
引用类型是一种结构，用于将数据和功能组织在一起。
1.Object 类型:
创建 Object 实例的方式有两种：第一种是使用 new 操作符后跟 Object 构造函数。
var person=new Object();
person.name="Rain";
person.age=29;
另一种方式是使用对象字面量表示法。对象字面量是对象定义的一种简写形式，目的在于简化创建包含大量属性的对象的过程。
var person={
name:"Rain",
age:29
};
注：在对象最后一个属性后边不需要添加逗号，否则会在IE7及更早的版本和Opera中导致错误。
JavaScript中使用方括号表示法来访问对象的属性。使用时，将要访问的属性以字符串的形式放在方括号中。
alert(person["name"]); //"Rain"
alert(person.name); //"Rain"
当属性名中包含关键字或空格时，不能通过点表示法来访问它。这时候也需要用到方括号访问对象。
通常，除非必须使用变量来访问属性，否则我们建议使用点表示法。
2.Array ；类型
同其他语言数组不同的是ECMScript数组的每一项可以保存任何类型的数据。
创建 Array 数组的基本方式有两种。
第一种是使用 Array 构造函数：
var colors=new Array(20); //创建length值为20的数组。
var colors=new Array("red","blue","green"); //创建包含3个字符串的数组
在使用 Array 构造函数时也可以省略 new 操作符：
var colors=Array(20);
var colors=Array("red","blue","green");
第二种是使用数组字面量表示法：
var colors = ["red", "blue", "green"]; //创建一个包含 3 个字符串的数组
Array 对象中的 length 属性不是只读的。通过设置这个属性，可以从数组的末尾移除项或向数组中添加项。
var colors = ["red", "blue", "green"];
colors.length=2; //异常colors中的最后一项，使数组长度变为2
alert(colors[2]); //undefined
注：数组最多可以包含 4 294 967 295 个项，这几乎已经满足任何编程需求了。如果想添加的项数超过这个上限值，就会发生异常。
而创建一个初始大小与这个上限值接近的数组，则可能会导致运行时间超长的脚本错误。
检测数组：
使用 instanceof 操作符就能得到满意的结果。
if(value instanceof Array){
//操作数组
}
网页中包含多个框架，那实际上就存在两个以上不同的全局执行环境，从而存在两个以上不同版本的 Array 构造函数。
为了解决这个问题，ECMAScript 5 新增了 Array.isArray() 方法。这个方法的目的是最终确定某个值到底是不是数组，
而不管它是在那个全局执行环境中创建的。
if(Array.isArray(value)){
//操作数组
}
支持 Array.isArray()方法的浏览器有 IE9+、Firefox 4+、Safari 5+、Opera 10.5+和 Chrome。要在尚未实现这个方法中的浏览器中准确检测数组。
转换方法：
toLocaleString()、toString() 和 valueOf() 方法。（返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串）
var colors=["red","blue","green"];
alert(colors.toString()); //red,blue,green
alert(colors.valueOf()); //red,blue,green
alert(colors); //red,blue,green
toLocaleString()方法经常也会返回与 toString()和 valueOf()方法相同的值，但也不总是如此。当调用数组的 toLocaleString()方法时，
它也会创建一个数组值的以逗号分隔的字符串。而与前两个方法唯一的不同之处在于，这一次为了取得每一项的值，调用的是每一项的 toLocaleString()方法，
而不是toString()方法。
var person1 = {
toLocaleString : function () {
return "Nikolaos";
},
toString : function() {
return "Nicholas";
}
};
var person2 = {
toLocaleString : function () {
return "Grigorios";
},
toString : function() {
return "Greg";
}
};
var people = [person1, person2];
alert(people); //Nicholas,Greg
alert(people.toString()); //Nicholas,Greg
alert(people.toLocaleString()); //Nikolaos,Grigorios
join():该方法只接收一个参数，即用作分隔符的字符串，然后返回包含所有数组项的字符串。
var colors=["red","green","blue"];
alert(colors.join(",")); //red,green,blue
alert(colors.join("||")); //red||green||blue
注：如果数组中的某一项的值是 null 或者 undefined，那么该值在 join()、toLocaleString() 和 valueOf() 方法返回的结果中以空字符串表示。
栈方法（LIFO 后进先出）
push() 方法可以接收任意数量的参数，把他们逐个添加到数组末尾，并返回修改数组的长度。
pop() 方法则从数组末尾移除最后一项，减少数组的 length 值，然后返回移除的项。
实例：
var colors = new Array(); // 创建一个数组
var count = colors.push("red", "green"); // 推入两项
alert(count); //2
count = colors.push("black"); // 推入另一项
alert(count); //3
var item = colors.pop(); // 取得最后一项
alert(item); //"black"
alert(colors.length); //2
队列方法（FIFL 先进先出）
shift() 移除数组第一项并返回该项，同时将数组长度减1.
unshift() 它能在数组前端添加任意个项并返回新数组的长度。
实例：
var colors = new Array(); //创建一个数组
var count = colors.unshift("red", "green"); //推入两项
alert(count); //2
count = colors.unshift("black"); //推入另一项
alert(count); //3
var item = colors.pop(); //取得最后一项
alert(item); //"green"
alert(colors.length); //2
注：IE7 及更早版本对 JavaScript 的实现中存在一个偏差，其 unshift()方法总是返回 undefined 而不是数组的新长度。IE8 在非兼容模式下会返回正确的长度值。
重排序方法：
reverse() 反转数组的顺序
sort() 按照升序排列数组项。其原理是先调用每个数组项的 toString() 转型方法，然后比较得到的字符串，以确定如何排序。因此就存在一个问题，即使数组中的每一项
都是数值，sort() 方法比较的也是字符串。
var values=[0,5,2,36,11,9,8,14];
values.sort();
alert(values); //0,11,14,2,36,5,8,9
解决该问题需要添加一个比较函数，并将其作为参数传递给 sort() 方法即可。
实例：
function asc(value1, value2) {
return value1 - value2; //升序
}
function desc(value1, value2) {
return value2 - value1; //降序
}
jsapp.sortAscArray = function() {
var values = [0, 5, 2, 36, 11, 9, 8, 14];
values.sort(asc);
alert(values); //0,2,5,8,9,11,14,36
}
jsapp.sortDescArray = function() {
var values = [0, 5, 2, 36, 11, 9, 8, 14];
values.sort(desc);
alert(values); //36,14,11,9,8,5,2,0
}
注：reverse()和 sort()方法的返回值是经过排序之后的数组。
操作方法：
concat() 方法可以基于当前数组中的所有项创建一个新数组。（先创建当前数组的一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。）
slice(start, end) 它能够基于当前数组中的一或多个项创建一个新数组。
slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。注意，slice()方法不会影响原始数组。
实例：
var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2); //green,blue,yellow,purple
alert(colors3); //green,blue,yellow
splice() 方法：使用这种方法的方式主要有如下三种：
1.删除：可以删除任意数量的项，只需指出两个参数：要删除的第一项的位置和要删除的项数。例如：splice(0,2) 会删除数组中的前两项。
2.插入：可以向指定位置插入任意数量的项，只需提供三个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多项。
例如，splice(2,0,"red","green")会从当前数组的位置 2 开始插入字符串"red"和"green"。
3.替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
例如，splice(2,1,"red","green") 会删除当前数组位置2的项，然后再从位置2开始插入字符串"red"和"green".
splice() 方法始终都会返回一个数组，该数组中包含从原始数组中删除的项（如果没有删除任何项，则返回一个空数组）。
位置方法：
indexOf() 方法从数组的开头（位置0）开始向后查找
lastIndexOf() 方法则从数组的末尾开始向前查找
这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1.（要求查找的项必须严格相等，就像=== 一样）
实例：
var _arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
alert(_arr.lastIndexOf(5, 2)); //-1:lastIndexOf方法查找的方向是从结尾反序查找元素，当前方法的其实位置是2，从位置2倒序查找元素5是找不到的，则返回-1
迭代方法：
ECMAScript 5 为数组定义了 5 个迭代方法.每个方法都接收两个参数：要在每一项上运行的函数和（可选的）运行在该函数的作用域对象---影响 this 的值。
参入这些方法中的函数会接收三个参数：数组项的值、该项在数组中的位置和数组对象本身。
1.every(): 对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。
2.filter():对数组中的每一项运行给定函数，返回该函数会返回true的项组成的数组。
3.forEach():对数组中的每一项运行给定函数，这个函数没有返回值。
4.map():对数组中的每一项运行给定的函数，返回每次函数调用的结果组成的数组。
5.some():对数组中的每一项运行给定的函数，如果该函数对任一项返回true，则返回true。
注：以上方法都不会修改数组中的包含的值。
var _arr = [5, 12, 16, 85, 296, 856, 75];
var result = _arr.map(function(item, index, array) {
return item - 500;
});
alert("item - 500:" + result);
归并函数：
reduce() 从数组的第一项开始，逐个遍历到最后。
redeceRight() 从数组的最后一项开始，向前遍历到第一项。
这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。
传给reduce() 和 redeceRight() 的函数接收4个参数：前一个值、当前值、项的索引和数组对象。
这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数就是数组的第二项。
reduce()和reduceRight()主要的区别是从那个方向开始遍历数组，除此之外，它们完全相同。
3.Date 类型
日期/时间主键组件方法
方 法 说 明
--------------------------------------------------------------------------------------------
getTime() 返回表示日期的毫秒数；与valueOf()方法返回的值相同
setTime(毫秒) 以毫秒数设置日期，会改变整个日期
getFullYear() 取得4位数的年份（如2007而非仅07）
getUTCFullYear() 返回UTC日期的4位数年份
setFullYear(年) 设置日期的年份。传入的年份值必须是4位数字（如2007而非仅07）
setUTCFullYear(年) 设置UTC日期的年份。传入的年份值必须是4位数字（如2007而非仅07）
getMonth() 返回日期中的月份，其中0表示一月，11表示十二月
getUTCMonth() 返回UTC日期中的月份，其中0表示一月，11表示十二月
setMonth(月) 设置日期的月份。传入的月份值必须大于0，超过11则增加年份
setUTCMonth(月) 设置UTC日期的月份。传入的月份值必须大于0，超过11则增加年份
getDate() 返回日期月份中的天数（1到31）
getUTCDate() 返回UTC日期月份中的天数（1到31）
setDate(日) 设置日期月份中的天数。如果传入的值超过了该月中应有的天数，则增加月份
setUTCDate(日) 设置UTC日期月份中的天数。如果传入的值超过了该月中应有的天数，则增加月份
getDay() 返回日期中星期的星期几（其中0表示星期日，6表示星期六）
getUTCDay() 返回UTC日期中星期的星期几（其中0表示星期日，6表示星期六）
getHours() 返回日期中的小时数（0到23）
getUTCHours() 返回UTC日期中的小时数（0到23）
setHours(时) 设置日期中的小时数。传入的值超过了23则增加月份中的天数
setUTCHours(时) 设置UTC日期中的小时数。传入的值超过了23则增加月份中的天数
getMinutes() 返回日期中的分钟数（0到59）
getUTCMinutes() 返回UTC日期中的分钟数（0到59）
setMinutes(分) 设置日期中的分钟数。传入的值超过59则增加小时数
setUTCMinutes(分) 设置UTC日期中的分钟数。传入的值超过59则增加小时数
getSeconds() 返回日期中的秒数（0到59）
getUTCSeconds() 返回UTC日期中的秒数（0到59）
setSeconds(秒) 设置日期中的秒数。传入的值超过了59会增加分钟数
setUTCSeconds(秒) 设置UTC日期中的秒数。传入的值超过了59会增加分钟数
getMilliseconds() 返回日期中的毫秒数
getUTCMilliseconds() 返回UTC日期中的毫秒数
setMilliseconds(毫秒) 设置日期中的毫秒数
setUTCMilliseconds(毫秒) 设置UTC日期中的毫秒数
getTimezoneOffset() 返回本地时间与UTC时间相差的分钟数。例如，美国东部标准时间返回300。在某地进入夏令时的情况下，这个值会有所变化
------------------------------------------------------------------------------------------------------------------------------------
4.RegExp 类型 用来支持正则表达式。略过
5.Function 类型
函数实际是对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定。
解析器在想执行环境中加载数据时，对函数声明和函数表达式并非一视同仁。解析器会率先读取函数声明，并使其在执行任何代码之前可用（可访问）；
至于函数表达式，则必须等到解析器执行到它所在的代码行，才会真正被解释执行。
作为值的函数
因为ECMAScript中的函数名本身就是变量，所以函数也可以作为值来使用。因此，可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数结果返回。
function callSomeFunction(someFunction,someArgument){
return someFunction(someArgument);
}
arguments 的主要用途是保存函数参数，但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个arguments对象的函数。
window.color = "red";
var o = { color: "blue" };
function sayColor(){
alert(this.color);
}
sayColor(); //"red"
o.sayColor = sayColor;
o.sayColor(); //"blue"
函数的名字仅仅是一个包含指针的变量，即使是在不同的环境中执行，全局的 syaColor()函数和 o.sysColor()指向的仍然是同一个函数。
函数对象的另一个属性caller,这个属性中保存着调用当前函数的函数的引用，如果在全局作用域中调用当前函数，它的值为null。
函数的属性和方法
函数都包含两个属性：length ：表示当前函数希望接收的命名参数的个数；
prototype：保存函数所有实例方法的真是所在。该属性是不可枚举的，因此使用 for-in 无法发现。
每个函数都包含了两个非继承而来的方法：apply() 和 call().
apply() 方法接收两个参数：一个是在其中运行函数的作用域，另一个是参数数组。其中第二个参数可以是 Array 的实例，也可以是 arguments 对象来访问这些参数。由于不存在函数签名的特性，ECMAScript
function sum(num1,num2){
return num1+num2;
}
function callSum1(num1,num2){
return sum.apply(this,arguments);
}
function callSum2(num1,num2){
return sum.apply(this,[num1,num2]);
}
function callSum3(num1,num2){
return sum.call(this,num1,num2);
}
alert(callSum1(10,10)); //20
alert(callSum2(10,10)); //20
alert(callSum3(10,10)); //20
call() 方法与 apply() 方法的作用相同，它们的区别仅在与接收参数的方式不同。第一个参数是 this 值没有变化，变化的是其余参数都直接传递给函数，必须逐个列举出来。
bind() 方法会创建一个函数的实例，其 this 值会被绑定到传给 bind() 函数在转换字符串时，更多的是看其是否符合数值模式。它会忽略字符串前面的空格，直至找到第一个非空格字符。如果第一个字符不是数字字符或者负号，parseInt
window.color="red";
var o={color:"blue"};
function sayColor(){
alert(this.color);
}
var objectSayColor=sysColor.bind(o);
objectSayColor(); //blue
14、基本类型
6.Number 类型
方法：toString()
var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"
toFixed()会按照指定的小数位返回数值的字符串表示
alert(num.toFixed(2)); //"10.00"
toExponential()该方法返回以指数表示法（也称e 表示法）表示的数值的字符串形式。
alert(num.toExponential(1)); //"1.0e+1"
toPrecision()
alert(num.toPrecision(1)); //"1e+2"
alert(num.toPrecision(2)); //"99"
alert(num.toPrecision(3)); //"99.0"
7.String 类型
字符串方法；
charAt() :
charCodeAt() :这两个方法都是访问字符串中的特定字符（接收的参数是基于 0 的字符位置）
concat() :用于将一个或多个字符串拼接起来，返回拼接得到的新字符串。
slice(start, end) :
substr(start,len) :
substring(start,end) :这三个方法都会返回被操作字符串的一个子字符串，而且也都接受一或两个参数。
当传递的参数是负值的情况下，它们的行为就不尽相同了。
slice()方法会将传入的负值与字符串的长度相加，substr()方法将负的第一个参数加上字符串的长度，而将负的第二个参数转换为 0，
substring()方法会把所有负值参数都转换为0.
实例：
var stringValue = "hello world";
alert(stringValue.slice(3)); //"lo world"
alert(stringValue.substring(3)); //"lo world"
alert(stringValue.substr(3)); //"lo world"
alert(stringValue.slice(3, 7)); //"lo w"
alert(stringValue.substring(3,7)); //"lo w"
alert(stringValue.substr(3, 7)); //"lo worl"
var stringValue = "hello world";
alert(stringValue.slice(-3)); //"rld"
alert(stringValue.substring(-3)); //"hello world"
alert(stringValue.substr(-3)); //"rld"
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()：与RegExp 的 exec() 方法相同。match() 方法只接受一个参数，要么是一个正则表达式，要么是一个 RegExp 对象来访问这些参数。
该方法返回一个数组，保存着与正则表达式中的捕获组匹配的字符串。
search()：参数与 match() 相同，返回字符串中第一个匹配项的索引。该方法始终是从字符串开头向后查找模式。
replace()：这个方法接受两个参数：第一个参数可以是一个RegExp 对象或者一个字符串（这个字符串不会被转换成正则表达式），第二个参
数可以是一个字符串或者一个函数。如果第一个参数是字符串，那么只会替换第一个子字符串。
要想替换所有子字符串，唯一的办法就是提供一个正则表达式，而且要指定全局（g）标志。
var text = "cat, bat, sat, fat";
var result = text.replace("at", "ond");
alert(result); //"cond, bat, sat, fat"
result = text.replace(/at/g, "ond");
alert(result); //"cond, bond, sond, fond"
localeCompare() 方法：比较两个字符串
返回值为下列值中的一个：
如果字符串在字母表中应该排在字符串参数之前，则返回一个负数（通常为-1）
如果字符串等于字符串参数，则返回0
如果字符串在字母表中应该排在字符串参数之后，则返回一个正数（通常为1）
var stringValue = "yellow";
alert(stringValue.localeCompare("brick")); //1
alert(stringValue.localeCompare("yellow")); //0
alert(stringValue.localeCompare("zoo")); //-1
fromCharCode() 方法：接收一或多个字符编码，然后将他们转换成一个字符串。
从本质上看，这个方法与实例方法 charCodeAt() 执行的是相反的操作。
8、单体内置对象
由ECMAScript实现提供的、不依赖于宿主环境的对象，这些对象在ECMAScript程序执行之前就已经存在了。
程序员不必显式地实例化内置对象，因为他们已经实例化了。（Object 、Array 、String 、Global 和 Math）
1.Global对象：所有全局作用域中定义的属性和函数都是Global对象的属性。
1.1 URI编码方法：对URI（Uniform Resource Identifiers,通用资源标识符）进行编码，一边发送给浏览器。
encodeURI():主要用于整个URI编码，不会对本身属于URI的特殊字符进行编码。
encodeURIComponent():主要用于对URI中的某一段进行编码，会对任何非标准字符进行编码。
var uri = "http://www.wrox.com/illegal value.htm#start";
//"http://www.wrox.com/illegal%20value.htm#start"
alert(encodeURI(uri));
//"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"
alert(encodeURIComponent(uri));
使用encodeURI()编码后的结果是除了空格之外的其他字符都原封不动，只有空格被替换成了%20。而encodeURIComponent()方法则会使用对应的编码替换所有非字母数字字符。这也正是可以
对整个URI 使用encodeURI()，而只能对附加在现有URI 后面的字符串使用encodeURIComponent()的原因所在。
注：encodeURIComponent()使用比较多，因为实践中更多的是对查询字符串参数而不是对基础URI进行编码。
1.2 URI解码方法：
decodeURI():
decodeURIComponent():
var uri = "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start";
//http%3A%2F%2Fwww.wrox.com%2Fillegal value.htm%23start
alert(decodeURI(uri));
//http://www.wrox.com/illegal value.htm#start
alert(decodeURIComponent(uri));
1.3 eval() 方法 就像一个完整的ECMAScript解析器，它只接受一个参数，即要执行的ECMAScript（或JavaScript）字符串。
var msg = "hello world";
eval("alert(msg)"); //"hello world"
2.window 对象
ECMAScript虽然没有指出如何直接访问 Global 对象，但Web浏览器都是将这个全局对象作为 window
对象的一部分加以实现的。因此，在全局作用域中声明的所有变量和函数，就都成为了 window 对象的属性。
3.Math 对象：提供了数学公式和信息
min():获取最小值
max():获取最大值
实例：
var values = [1, 2, 3, 4, 5, 6, 7, 8];
var max = Math.max.apply(Math, values);
4.舍入方法
ceil():执行向上舍入，即它总是将数值向上舍入为最接近的整数；
floor():执行向下舍入，即它总是将数值向下舍入为最接近的整数；
round():执行标准舍入，即他总是将数值四舍五入为最接近的整数。
5.随机方法
random():返回大于等于0小于1的一个随机数。
小结：
>1、引用类型与传统面向对象程序设计中的类相似，但实现不同；
>2、Object 是一个基础类型，其中所有类型都从 Object 继承了基本的行为；
>3、Array 类型是一组值得有序列表，同时还提供了操作转换这些值得功能；
>4、Date 类型提供了有关日期和时间的信息包括当前日期和时间以及相关的计算功能；
>5、RegExp 类型是ECMAScript支持正则表达式的一个接口，提供了最基本的和一些高级的正则表达式功能。
函数实际上是Function 类型的实例，因此函数也是对象；而这一点正是JavaScript 最有特色的地
方。由于函数是对象，所以函数也拥有方法，可以用来增强其行为。
因为有了基本包装类型，所以JavaScript 中的基本类型值可以被当作对象来访问。三种基本包装类
型分别是：Boolean、Number 和String。以下是它们共同的特征：
>1、每个包装类型都映射到同名的基本类型；
>2、在读取模式下访问基本类型值时，就会创建对应的基本包装类型的一个对象，从而方便了数据
操作；
>3、操作基本类型值的语句一经执行完毕，就会立即销毁新创建的包装对象。
在所有代码执行之前，作用域中就已经存在两个内置对象：Global 和Math。在大多数ECMAScript
实现中都不能直接访问Global 对象；不过，Web 浏览器实现了承担该角色的window 对象。全局变
量和函数都是Global 对象的属性。Math 对象提供了很多属性和方法，用于辅助完成复杂的数学计算
任务。