第六章 JavaScript内置对象

[/size]什么是函数
函数的定义
函数的调用
函数的参数
递归函数
函数的闭包

Array (重点)
Boolean （基本数据类型的包装类）
Date (重点)
Math （次重点）
Number （基本数据类型的包装类）
String （基本数据类型的包装类）
RegExp (重点)

[size=large]JavaScript的内置对象

在JavaScript中，常用对象有Array,Boolean,Date,Math,Number,String,RegExp。
其中，Boolean，Number，String是基本类型的包装类，前面已经学习过，在此就不在讨论。
今天主要目标是：
1.Array
2.Date
3.Math
4.RegExp

Array

Array 对象相当于Java中的数组与集合综合体，但是很多细节的地方和Java的数组，集合差别还是很大，并且用法还有些别扭。
数组有四种定义的方式
使用构造函数：var a = new Array();var b = new Array(8);var c = new Array(“first”, “second”, “third”);或者数组直接量：var d = [“first”, “second”, “third”];我们在Java中使用集合时，可使用泛型来规定集合中存放的数据类型，在JavaScript中，我们只能靠自己好的编码习惯来使用Array对象，我们要确保Array对象中最好不要放置不同类型的数据类型。
var a = new Array("first", 1, new Date());
for (var x in a)
{
document.write(a[x] + " " + typeof a[x]  + "<br />");
}
从上例中，我们可以看到Array对象中，可以存放不同类型的数据类型。但是建议大家不要这样使用Array对象，这样用起来会很不方便。
定义一个空数组 var arr = new Array();
var arr = new Array();  //此时数组中的元素个数为0个
arr[0] = "hello";
arr[1] = "JavaScript";
arr[2] = "呵呵";
for (var  x in arr)
{
document.write(arr[x] + " " + typeof arr[x]  + "<br />");
}
使用不带参数的构造函数可以定义一个没有元素的空数组，可以在定义了空数组之后再设置元素。
通过指定数组长度定义数组 var arr = new Array(3);
使用new Array(size)构造函数可以在定义数组的同时指定数组元数的个数，但是此时并没有为数组元素赋值，所有数组元素的值都为undefined.
var arr = new Array(3);
document.write("arr.length=" + arr.length + "<BR/>");
var x;
for(var i=0; i<arr.length; i++){
document.write("arr[" + i + "]=" + arr[i] + "<BR/>");
}
var arr = new Array(3);
document.write("arr.length=" + arr.length + "<BR/>");
for(var i=0; i<arr.length; i++){
document.write("arr[" + i + "]=" + arr[i] + "<BR/>");
}
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
document.write("arr.length=" + arr.length + "<BR/>");
for(var i=0; i<arr.length; i++){
document.write("arr[" + i + "]=" + arr[i] + "<BR/>");
}
在此例子中，
var arr = new Array(3);
语句定义了一个包含了三个元素的数组，此时虽然没有为数组元素赋值，但数组还是包含三个元素，不过这三个元素的值都为undefined.

可以看到arr的长度是可以随时改变的。
通过指定数组元素定义数组 var c = new Array(“first”, “second”, “third”);
var arr = new Array("a","b","c","d","e");
document.write("arr.length=" + arr.length + "<BR/>");
for (var x in arr){
document.write("arr[" + x + "]=" + arr[x] + "<BR/>");
}
使用new Array(element1,element2,…) 构造函数可以在定义数组的同时指定数组元素的值，其中参数列表中的数组依次为数组中的第一个元素，第二个元素…的值。
上例子中，在定义数组的同时，就已经设置了数组元素的值。
直接量定义数组 var arr = ["a","b","c","d","e"];

var arr = ["a","b","c","d","e"];
document.write("arr.length=" + arr.length + "<BR/>");
for (var x in arr){
document.write("arr[" + x + "]=" + arr[x] + "<BR/>");
}
创建数组需要注意的地方：
定义数组时不管是否确定了数组的长度，数组的长度都是不固定的。

请牢记两种遍历数组的区别.

Array 对象的方法--concat()

concat() 连接两个或更多的数组，并返回结果。
语法：arrayObject.concat(arrayX,arrayX,......,arrayX)
arrayX 必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。
返回的还是数组,不是字符串.
var a = [1,2,3];
document.write(a.concat(4,5));
输出：1,2,3,4,5

var arr = ["a","b","c","d","e"];
arr = arr.concat("f", ["g","h"]);
输出：a,b,c,d,e,f,g,h

Array 对象的方法--join()

语法:arrayObject.join(separator)参数 描述
separator 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。
返回值:返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
document.write(arr.join())
输出：George,John,Thomas

Array 对象的方法--pop()

pop():方法用于删除并返回数组的最后一个元素。
语法:arrayObject.pop()
返回值:arrayObject 的最后一个元素。
var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
for(var x in arr){
document.write(arr[x] + "<br />");
}
document.write("<p />");
document.write("删除的元素：" + arr.pop() + "<p />");
for(var x in arr){
document.write(arr[x] + "<br />");
}

Array 对象的方法-- push()

定义和用法:push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
语法:arrayObject.push(newelement1,newelement2,....,newelementX);
返回值:把指定的值添加到数组后的新长度。
说明:push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject，而不是创建一个新的数组。push() 方法和 pop() 方法使用数组提供的先进后出栈的功能。
var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr + "<br />");
document.write(arr.push(“James”) + “<br />”);//此方法相当于add()方法.
document.write(arr);

Array 对象的方法--reverse()
reverse() 颠倒数组中元素的顺序。
定义和用法:reverse() 方法用于颠倒数组中元素的顺序。
语法:arrayObject.reverse()提示和注释
注释：该方法会改变原来的数组，而不会创建新的数组。
var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr + "<br />");
document.write(arr.reverse());

Array 对象的方法-- shift()

定义和用法:shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
语法:arrayObject.shift();
返回值:数组原来的第一个元素的值。
说明:如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。请注意，该方法不创建新数组，而是直接修改原有的 arrayObject。
注释：该方法会改变数组的长度。
提示：要删除并返回数组的最后一个元素，请使用 pop() 方法。
var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr + "<br />");
document.write(arr.shift() + "<br />");
document.write(arr);

Array 对象的方法-- slice()

slice() 从某个已有的数组返回选定的元素
定义和用法:slice() 方法可从已有的数组中返回选定的元素。
语法:arrayObject.slice(start,end)
start 必需。规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
说明:请注意，该方法并不会修改数组，而是返回一个子数组。如果想删除数组中的一段元素，应该使用方法 Array.splice()。
注释：您可使用负值从数组的尾部选取元素。
注释：如果 end 未被规定，那么 slice() 方法会选取从 start 到数组结尾的所有元素。

var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr + "<br />");
document.write(arr.slice(1) + "<br />");
document.write(arr);

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr + "<br />");
document.write(arr.slice(2,4) + "<br />");
document.write(arr);

Array 对象的方法-- sort()

定义和用法:sort() 方法用于对数组的元素进行排序。
语法:arrayObject.sort(sortby)
sortby 可选。规定排序顺序。必须是函数。
返回值:对数组的引用。请注意，数组在原数组上进行排序，不生成副本。
说明:如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较。
如果想按照其他标准进行排序，就需要提供比较函数，该函数要比较两个值，然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
若 a 等于 b，则返回 0。
若 a 大于 b，则返回一个大于 0 的值。

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr + "<br />");
document.write(arr.sort());

var arr = new Array(6);
arr[0] = "10";
arr[1] = "5";
arr[2] = "40";
arr[3] = "25";
arr[4] = "1000";
arr[5] = "1";
document.write(arr + "<br />");
document.write(arr.sort());

function sortNumber(a,b){
return a - b;
}
var arr = new Array(6);
arr[0] = "10";
arr[1] = "5";
arr[2] = "40";
arr[3] = "25";
arr[4] = "1000";
arr[5] = "1";
document.write(arr + "<br />");
document.write(arr.sort(sortNumber));

Array 对象的方法--splice()

定义和用法:splice() 方法用于插入、删除或替换数组的元素。
语法:arrayObject.splice(index,howmany,element1,.....,elementX)参数 描述
index 必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。
howmany 必需。规定应该删除多少元素。必须是数字，但可以是 "0"。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
element1 可选。规定要添加到数组的新元素。从 index 所指的下标处开始插入。
elementX 可选。可向数组添加若干元素。
返回值:如果从 arrayObject 中删除了元素，则返回的是含有被删除的元素的数组。
说明:splice()方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。
注释：请注意，splice() 方法与 slice() 方法的作用是不同的，splice() 方法会直接对数组进行修改。

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr + "<br />");
arr.splice(2,0,"William");
document.write(arr + "<br />");
在本例中，我们将创建一个新数组，并向其添加一个元素

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr + "<br />");
arr.splice(2,1,"William");
document.write(arr);
在本例中我们将删除位于 index 2 的元素，并添加一个新元素来替代被删除的元素

var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr + "<br />");
arr.splice(2,3,"William");
document.write(arr);
在本例中我们将删除从 index 2 ("Thomas") 开始的三个元素，并添加一个新元素 ("William") 来替代被删除的元素

Array 对象的方法—toSource()

toSource() 代表对象的源代码
var arr = new Array(6);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
arr[3] = "James";
arr[4] = "Adrew";
arr[5] = "Martin";
document.write(arr.toSource());
显示：["George", "John", "William", "Martin"]
注意：IE不支持此方法，Firefox支持

Array 对象的方法-- toString()

定义和用法:toString() 方法可把数组转换为字符串，并返回结果。
语法:arrayObject.toString()返回值
arrayObject 的字符串表示。返回值与没有参数的 join() 方法返回的字符串相同。
说明:当数组用于字符串环境时，JavaScript 会调用这一方法将数组自动转换成字符串。但是在某些情况下，需要显式地调用该方法。
注释：数组中的元素之间用逗号分隔。

var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr.toString());

Array 对象的方法-- toLocaleString()

toLocaleString() 方法把数组转换为本地字符串。
语法:arrayObject.toLocaleString()返回值
arrayObject 的本地字符串表示。
说明:首先调用每个数组元素的 toLocaleString() 方法，然后使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串。

var arr = new Array(3);
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr.toLocaleString());

Array 对象的方法-- unshift()

定义和用法：unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
语法：arrayObject.unshift(newelement1,newelement2,....,newelementX)
newelement1 必需。向数组添加的第一个元素。
newelement2 可选。向数组添加的第二个元素。
newelementX 可选。可添加若干个元素。
返回值：arrayObject 的新长度。
说明：unshift() 方法将把它的参数插入 arrayObject 的头部，并将已经存在的元素顺次地移到较高的下标处，以便留出空间。该方法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。
请注意，unshift() 方法不创建新的数组，而是直接修改原有的数组。
注释：该方法会改变数组的长度。
注释：unshift() 方法无法在 Internet Explorer 中正确地工作！
提示：要把一个或多个元素添加到数组的尾部，请使用 push() 方法。
var arr = new Array();
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr + "<br />");
document.write(arr.unshift("William") + "<br />");
document.write(arr);
IE 中显示：
George,John,ThomasundefinedWilliam,George,John,Thomas
Firefox中显示：
George,John,Thomas4William,George,John,Thomas

Array 对象的方法-- valueOf()

valueOf() 返回数组对象的原始值。

var arr = new Array();
arr[0] = "George";
arr[1] = "John";
arr[2] = "Thomas";
document.write(arr.valueOf());

Date 日期对象

Date 对象是 JavaScript 的一种内部数据类型。
Date 对象没有可以直接读写的属性，所有对日期和时间值的访问都是通过其方法执行的。

首先看一下创建日期对象的方式：
1.var dateObj = new Date(); //用当前时间构造日期对象
2.var dateObj = new Date(dateVal);//用毫秒数构造日期对象
3.var dateObj = new Date(year, month, date[, hours[, minutes[, seconds[,ms]]]]);//通过指定的年、月、日、小时、分钟、秒、毫秒来构造日期对象，年，月，日为必须指定的参数，其它可不指定。
4.var dateObj = new Date(“Mon Aug 17 16:08:17 2009”)//通过标准时间格式字符串来构建日期对象



注意这里，方法的命名和Java中几乎一样，这里的方法是 我们是最常用的，可以 设置/获取 日期对象各个部分的值



这里的方法并不常用，和前面的方法一样，不过是根据世界时来 设置/返回 时间的各个部分的值



这里的getDay(),getUTCDay()两个方法可以获取日期对象是星期几的值，注意0代表星期天，一周其实是从星期天开始的;
其它方法几乎都是获取日期对象字符串的表现形式
function startTime(){
var today=new Date(); //获取当前日期
//获取日期对象的各个部分值
var y = today.getFullYear(); //年
var month = today.getMonth() + 1; //月,注意月份从0开始
var d = today.getDate();//日
var h=today.getHours();  //小时
var m=today.getMinutes(); //分钟
var s=today.getSeconds(); //秒
//格式化月、日、小时、分钟、秒
month = checkTime(month);
d = checkTime(d);
h = checkTime(h);
m = checkTime(m);
s = checkTime(s);
//设置窗口状态栏的值
window.status = y + "-" + month + "-" + d + " " + h + ":" + m + ":" + s;
setTimeout("startTime()",1000);
}
function checkTime(i){
if (i<10){
i="0" + i;
}
return i;
}

此例子会在窗口状态栏显示一个动态时间。
需要注意的方法：
getYear() 方法可返回表示年份的两位或四位的数字。对于介于 1900 与 1999 之间的年份，getYear() 方法仅返回两位数字。对于 1900 之前或 1999 之后的年份，则返回 4 位数字！
var d = new Date()
document.write(d.getYear()) 
输出：2009
var born = new Date(1979,11,26);
document.write(born.getYear());
输出：79
重要事项：从 ECMAScript v3 开始，JavaScript 的实现就不再使用该方法，而使用 getFullYear() 方法取而代之！

Math对象




Math对象中的方法，我们只需要掌握几个常用的方法即可
floor(x)
round(x)
random()

下面， 我们用示例来体会这几个方法的用处。
floor() 方法执行的是向下取整计算，它返回的是小于或等于函数参数，并且与之最接近的整数。
document.write(Math.floor(0.60) + "<br />")
document.write(Math.floor(0.40) + "<br />")
document.write(Math.floor(5) + "<br />")
document.write(Math.floor(5.1) + "<br />")
document.write(Math.floor(-5.1) + "<br />")
document.write(Math.floor(-5.9))
输出：
0
0
5
5
-6
-6
round() 方法可把一个数字舍入为最接近的整数。
document.write(Math.round(0.60) + "<br />")
document.write(Math.round(0.50) + "<br />")
document.write(Math.round(0.49) + "<br />")
document.write(Math.round(-4.40) + "<br />")
document.write(Math.round(-4.60))
输出：
1
1
0
-4
-5
random() 方法可返回介于 0 ~ 1 之间的一个随机数。

document.write(Math.random())
输出：0.6778130668253315

RegExp对象

RegExp 对象表示正则表达式，它是对字符串执行模式匹配的强大工具。
创建方式：
var re = /pattern/[flags]
var re = new RegExp("pattern",["flags"])
Pattern:要使用的正则表达式
flags:模式，值可以为：g(全文查找出现的所有pattern), i(忽略大小写), m(多行查找)

RegExp 对象有 3 个方法：test()、exec() 以及 compile()。
test() 方法检索字符串中的指定值。返回值是 true 或 false。
exec() 方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。
compile() 方法用于改变 RegExp。

RegExp 对象—test()方法

方法检索字符串中的指定值。返回值是 true 或 false。
var patt1 = new RegExp("e");
document.write(patt1.test("The best things in life are free"));
输出：true

var patt2 = /^\w+$/;
document.write(patt2.test("asdf1_~!564243"));
输出：false

RegExp 对象—exec()

exec()方法检索字符串中的指定值。返回值是被找到的值的一个封装对象，这个对象中包含了找到的值，并且还保存了两个属性，一是这个值在字符串中的下标(index属性)，以及下次开始匹配的下标(lastIndex)，如果没有找到，则返回null.

var patt1 = new RegExp("e");
var result = patt1.exec("The best things in life are free");
if(result != null){
document.write("找到匹配值：" + result + "<BR />");
document.write("匹配值的下标：" + result.index + "<BR />");
document.write("下次匹配开始的下标：" + result.lastIndex + "<BR />");
}
注意：这个时候，当匹配到第一个值时，后面的就没有再匹配了，如果我要找出这个字符串中所有的匹配的信息该怎么办呢？

var patt1 = new RegExp("e","g");
var result;
do{
result = patt1.exec("The best things in life are free");
if(result != null){
document.write("找到匹配值：" + result + "<BR />");
document.write("匹配值的下标：" + result.index + "<BR />");
document.write("下次匹配开始的下标：" + result.lastIndex + "<BR />");
}
}while(result != null);

g在这里就起了一个全局的作用。
在循环中反复地调用 exec() 方法是唯一一种获得全局模式的完整模式匹配信息的方法。
var patt1 = /^[\w\s]+$/g;
var result;
do{
result = patt1.exec("The best things in life are free");
if(result != null){
document.write("找到匹配值：" + result + "<BR />");
document.write("匹配值的下标：" + result.index + "<BR />");
document.write("下次匹配开始的下标：" + result.lastIndex + "<BR />");
}
}while(result != null);

RegExp对象--compile()

compile()方法用于改变 RegExp

var patt1=new RegExp("e");
document.write(patt1.test("The best things in life are free"));

patt1.compile("d");
document.write(patt1.test("The best things in life are free"));

String对象




String对象--blink(), charAt()

blink()方法用于显示闪动的字符串。
var str="Hello world!";
document.write(str.blink());

charAt() 方法可返回指定位置的字符。
var str="Hello world!"
document.write(str.charAt(1))
输出是：e

String对象-- charCodeAt() , concat()

charCodeAt() 方法可返回指定位置的字符的 Unicode 编码。这个返回值是 0 - 65535 之间的整数。
var str="Hello world!“;
document.write(str.charCodeAt(1));

concat() 方法用于连接两个或多个字符串。
var str1="Hello ";
var str2="world!";
document.write(str1.concat(str2));

String对象-- fromCharCode() , indexOf()

fromCharCode() 可接受一个指定的 Unicode 值，然后返回一个字符串。
document.write(String.fromCharCode(72,69,76,76,79))
document.write("<br />")
document.write(String.fromCharCode(65,66,67))

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
var str="Hello world!"
document.write(str.indexOf("Hello") + "<br />")
document.write(str.indexOf("World") + "<br />")
document.write(str.indexOf("world"))

String对象-- lastIndexOf() , link()

lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。
var str="Hello world!"
document.write(str.lastIndexOf("Hello") + "<br />")
document.write(str.lastIndexOf("World") + "<br />")
document.write(str.lastIndexOf("world"))

link() 方法用于把字符串显示为超链接。
var str="Free Web Tutorials!"
document.write(str.link("http://www.w3school.com.cn"))

String对象-- localeCompare()

localeCompare():用本地特定的顺序来比较两个字符串。
此方法一般协助sort()排序用的。
var str = ["aa","bb","啊啊","层次","宝贝","低调"];
str.sort();
for(var x in str){
document.write(str[x] + " ");
}
document.write("<BR />");
str.sort(function(a,b){
return a.localeCompare(b);
});
for(var x in str){
document.write(str[x] + " ");
}

String对象--replace

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串,一个新的字符串 
var str="Visit Microsoft!"
document.write(str.replace(/Microsoft/, "W3School"))
输出：Visit W3School!
模仿trim()功能
function trim(A){
A=A.replace(/(^　+)|(　+$)/g,"");
A=A.replace(/(^ +)|( +$)/g,"");
return A;
}
document.write("*********" + trim("    q l;kasjdf; q         ") +"*******");

String对象--slice(),substr(),substring()

slice(),substr(),substring()三个功能差不多，都是用来截取字符串用的。

var str="Hello world!"
document.write(str.substring(3))

var str="Hello world!"
document.write(str.substring(3,7))