陣列的常用方法

length

length 是一個可讀可寫的屬性，用來表示陣列的長度（即陣列元素個數），通過訪問 length 屬性，可以獲取陣列長度；而通過修改 length 的值，可以增加或減少陣列元素，甚至可以完全清空陣列元素，

length 屬性的讀、寫操作示例如下：

var arr = [1,2,3];
alert(arr.length);//讀取陣列長度,結果為3
arr.length = 1;//修改陣列長度為1，此時陣列只剩第一個元素
arr.length = 0;//快速清空陣列，此時陣列中沒有任何元素

注：快速清空除了可以通過修改 length 屬性值為 0 外，還有一種方法就是使用代碼：arr=[]，如果 arr 原來的元素有很多，則使用 arr=[] 清空陣列的方法效率比修改 length 屬性值為 0 的方法更高，

push(元素1,…,元素n)

push() 方法可把引數指定的元素依次添加到陣列的末尾，并回傳添加元素后的陣列長度（該方法必須至少有一個引數）

var arr = [1,2,3];
alert(arr.push(4));//回傳最終陣列的長度:4
alert(arr);//回傳：1,2,3,4
alert(arr.push(5,6,7));//回傳最終陣列的長度:7
alert(arr);//回傳：1,2,3,4,5,6,7

unshift(元素1,…,元素n)

unshift() 方法可把引數指定的元素依次添加到陣列的前面，并回傳添加元素后的陣列長度，該方法必須至少有一個引數，注意：IE6、IE7 不支持方法的回傳值

var arr = [1,2,3];
alert(arr.unshift('a'));//回傳最終陣列的長度:4
alert(arr);//回傳：a,1,2,3
alert(arr.unshift('b','c','d'));//回傳最終陣列的長度:7
alert(arr);//回傳：b,c,d,a,1,2,3

pop()

pop() 方法可彈出（洗掉）陣列最后一個元素，并回傳彈出的元素

var arr = ['A','B','C','D'];
alert(arr.pop());//回傳：D
alert(arr);//回傳：A,B,C

shift()

shift() 方法可洗掉陣列第一個元素，并回傳洗掉的元素

var arr = ['A','B','C','D'];
alert(arr.shift());//回傳：A
alert(arr);//回傳：B,C,D

splice(index,count[,元素1,…,元素n])

splic() 方法功能比較強，它可以實作洗掉指定數量的元素、替換指定元素以及在指定位置添加元素，這些不同功能的實作需要結合方法引數來確定：

• 當引數只有 index 和 count 兩個引數時，如果 count 不等于 0，splice() 方法實作洗掉功能，同時回傳所洗掉的元素：從 index引數指定位置開始洗掉 count 引數指定個數的元素；
• 當引數為 3 個以上，且 count 引數不為0時，splice() 方法實作替換功能，同時回傳所替換的元素：用第三個及其之后的引數替換 index 引數指定位置開始的 count 引數指定個數的元素；
• 當引數為 3 個以上，且 count 引數為 0 時，splice() 方法的實作添加功能：用第三個及其之后的引數添加到 index 引數指定位置上，

從指定位置洗掉指定個數的元素

var arr = ['A','B','C','D'];
//2個引數，第二個引數不為 0，實作洗掉功能
alert(arr.splice(0,2));
alert(arr);  //回傳C,D

用指定元素替換從指定位置開始的指定個數的元素

var arr = ['A','B','C','D'];
//3個引數，第二個引數不為 0，實作替換功能：用 a 替換掉 A，回傳：A
alert(arr.splice(0,1,'a'));
alert(arr);  //回傳:a,B,C,D
alert(arr.splice(0,2,'a or b'));//用a or b替換掉a和B，回傳a,B
alert(arr);  //回傳：a or b,C,D

在指定位置添加指定的元素

var arr = ['A','B','C','D'];
//4個引數，第二個引數為 0，實作添加功能：在下標為 1 處添加 aaa,bbb，沒有回傳值
alert(arr.splice(1,0,'aaa','bbb'));
alert(arr);//回傳：A,aaa,bbb,B,C,D

實作陣列去重

var arr = [1,2,2,2,4,2];
 for(var i = 0; i < arr.length; i++){
	 for(var j = i + 1; j < arr.length; j++){
		  if(arr[i] == arr[j]){
			  arr.splice(j,1);//洗掉 j 位置處的元素
			  j--;
		  }
	 }
 }
 alert(arr);//回傳1,2,4三個元素

上述代碼使用了具有兩個引數的 splice()，實作了洗掉指定元素的功能

slice(index1[,index2])

slice() 方法回傳包含從陣列物件中的第 index1～index2-1 之間的元素的陣列，index2 引數可以省略，省略時表示回傳從 index1 位置開始一直到最后位置的元素，需要注意的是，該方法只是讀取指定的元素，并不會對原陣列作任何修改

var arr = ['A','B','C','D'];
alert(arr.slice(0,3));  //回傳：A,B,C
alert(arr);   //回傳A,B,C,D
alert(arr.slice(0));   //回傳陣列全部元素：A,B,C,D
alert(arr);   //回傳A,B,C,D

sort()、sort(compareFunction)

sort() 方法用于按某種規則排序陣列：當方法的引數為空時，按字典序（即元素的 Unicode 編碼從小到大排序順序）排序陣列元素；當引數為一個匿名函式時，將按匿名函式指定的規則排序陣列元素，sort() 排序后將回傳排序后的陣列

按字典序排序陣列

var arr = ['c','d','a','e'];
alert(arr.sort());   //回傳排序后的陣列：a,c,d,e
alert(arr);   //回傳排序后的陣列：a,c,d,e

從上述代碼，我們可看到沒有引數時，sort() 按字典序排列陣列中的各個元素

再用元素的 sort() 對幾個數字排序

var arr = [4,3,5,76,2,0,8];
arr.sort();
alert(arr);  //回傳排序后的陣列：0,2,3,4,5,76,8

排序后，結果并不是所預期的 76 最大應排在最后，反而是 8 排在最后，似乎 8 在這些元素中是最大的，即元素并沒按數字大小進行排序

是因為 sort() 默認是對每個元素按字串進行排序，排序時會從左到右按位比較元素的每位字符，對應位的 Unicode 編碼大的就意味著這個元素大，此時將不再對后面的字符進行比較；對應位字符相同時才比較后面位置的字符，顯然上述陣列的排序使用了 sort() 的默認排序規則，此時要讓陣列中的元素按數字大小進行排序，就必須通過匿名函式引數來修改排序規則，

按匿名函式引數指定的規則排序陣列

下面通過定義匿名函式來修改 sort() 的默認排序規則，實作對上面數字元素按數字大小進行排序

var arr = [4,3,5,76,2,0,8];
arr2.sort(function(a,b){
     return a-b;//從小到大排序
     //return b-a;//從大到小排序
});
alert(arr);//回傳排序后的陣列：0,2,3,4,5,8,76

說明：匿名函式中回傳第一個引數減第二個引數的值，此時將按元素數值從小到大的規則排序各個元素：當兩個引數的差為正數時，前后比較的兩個元素將調換位置排序；否則元素不調換位置，如果回傳第二個引數減第一個引數的值，則按元素數值從大到小的規則排序各個元素，元素調換規則和從小到大類似，

當陣列元素的前綴為數字而后綴為字串時，如果希望這些元素能按數字大小進行排序，此時需對匿名函式中的引數作一些變通處理，因為這些引數代表了陣列元素，所以它們也是一個包含數字和字符的字串，因此要按數字大小來排序它們，就需要將引數決議為一個數字，然后再回傳這些決議結果的差，

var arrWidth = ['345px','23px','10px','1000px'];
arrWidth.sort(function(a,b){
     return parseInt(a)-parseInt(b);
});
alert(arrWidth);//排序后的結果為：10px,23px,345px,1000px

通過匿名函式，還可以實作隨機排序陣列元素

var arr = [1,2,3,4,5,6,7,8];
arr.sort(function(a,b){
     return Math.random()-0.5;//random()回傳：0～1之間的一個值
});
alert(arr);//排序后的結果為：4,3,1,2,6,5,7,8，注意：每次執行的結果可能會不一樣

上述代碼中的匿名函式并沒有回傳兩個引數的差值，而是回傳 Math 物件中的 random() 隨機函式和 0.5 的差值，這就使得元素的排序將不是根據元素大小來排序，由于 random() 的值為 0～1 之間的一個隨機值，所以它和 0.5 的差時正時負，這就導致陣列元素位置的調換很隨機，所以排序后的陣列是隨機排序的

concat(陣列1,…,陣列n)

concat() 將引數指定的陣列和當前陣列連成一個新陣列

var arr1 = [1,2,3];
var arr2 = [4,5,6];
var arr3 = [7,8,9];
alert(arr1.concat(arr2,arr3));//最侄訓得連接后的陣列：1,2,3,4,5,6,7,8,9

reverse()

reverse() 方法可回傳當前陣列倒序排序形式

var arr = [1,2,3,4,5,6];
alert(arr.reverse());//回傳：6,5,4,3,2,1

join(分隔符)

join() 方法可將陣列內各個元素按引數指定的分隔符連接成一個字串，引數可以省略，省略引數時，分隔符默認為“逗號”

forEach()

forEach() 方法用于對陣列的每個元素執行一次回呼函式

array物件.forEach(function(currentValue[,index[,array]])[,thisArg])

forEach() 方法的第一個引數為 array 物件中每個元素需要呼叫的函式，
forEach() 方法中的各個引數說明如下：

1. currentValue 引數：必需引數，表示正在處理的陣列元素（當前元素）；
2. index 引數：可選引數，表示正在處理的當前元素的索引；
3. array 引數：可選引數，表示方法正在操作的陣列；
4. thisArg 引數，可選引數，取值通常為 this，為空時取值為 undefined，

回傳值為 undefined

var fruit = ["蘋果","橙子","梨子"];
fruit.forEach(function(item,index){
    console.log("fruit[" + index + "] = " + item);
});

顯示：fruit[0]=蘋果、fruit[1]=橙子和fruit[2]=梨子

filter()

filter() 方法用于創建一個新的陣列，其中的元素是指定陣列中所有符合指定函式要求的元素

array物件.filter(function(currentValue[,index[,array]])[,thisArg])

filter() 方法的第一個引數為回呼函式，array 物件中每個元素都需要呼叫該函式，filter() 會回傳所有使回呼函式回傳值為 true 的元素，
filter() 方法中的各個引數說明如下：

1. currentValue 引數：必需引數，表示正在處理的陣列元素（當前元素）；
2. index 引數：可選引數，表示正在處理的當前元素的索引；
3. array 引數：可選引數，表示方法正在操作的陣列；
4. thisArg 引數，可選引數，取值通常為 this，為空時取值為 undefined，

filter() 函式回傳一個新陣列，其中包含了指定陣列中的所有符合條件的元素，如果沒有符合條件的元素則回傳空陣列，

var names1 = ["張山","張小天","李四","張萌萌","王寧","陳浩"];//原陣列
function checkName(name){ //定義回呼函式，判斷名字是否姓“張”
     if(name.indexOf("張") != -1){
              return true;
         }else{
              return false;
         }
}
var names2 = names1.filter(checkName);//對names1執行回呼叫函式，回傳所有姓張的名字
names2.forEach(function(item,index){//遍歷names2陣列中的每個元素
          console.log("names2[" + index + "] = " + item);
});

顯示：names2[0]=張山、names2[1]=張小天和names2[2]=張萌萌

map()

map() 方法用于創建一個新的陣列，其中的每個元素是指定陣列的對應元素呼叫指定函式處理后的值

array物件.map(function(currentValue[,index[,array]])[,thisArg])

map() 方法的第一個引數為回呼函式，array 物件中每個元素都需要呼叫該函式，
map() 方法中的各個引數說明如下：

• currentValue 引數：必需引數，表示正在處理的陣列元素（當前元素）；
• index 引數：可選引數，表示正在處理的當前元素的索引；
• array 引數：可選引數，表示方法正在操作的陣列；
• thisArg 引數，可選引數，取值通常為 this，為空時取值為 undefined，

map() 函式回傳一個新陣列，其中的元素為原始陣列元素呼叫回呼函式處理后的值

var number = [1,2,3];//原陣列
var num=number.map(function(item){//對原陣列中的每個元素*2，將值分別存盤在num陣列中
          return item * 2;
});
num.forEach(function(item,index){//遍歷num中的每個元素
          console.log("num[" + index + "]=" + item);
});

顯示：num[0]=2、num[1]=4和num[2]=6

reduce()

reduce() 用于使用回呼函式對陣列中的每個元素進行處理，并將處理進行匯總回傳

array物件.reduce(function(result,currentValue[,index[,array]])[,initialValue])

reduce() 方法的第一個引數為回呼函式，
reduce() 方法中的各個引數說明如下，

1. result 引數：必需引數，表示初始值或回呼函式執行后的回傳值，在第一次呼叫回呼函式前，result 引數表示初始值；在呼叫回呼函式之后，result 引數表示回呼函式執行后的回傳值，

   需要注意的是，如果指定了 initialValue 引數，則初始值就是 initialValue 引數值，否則初始值為陣列的第一個元素，

2. currentValue 引數：必需引數，表示正在處理的陣列元素（當前元素），

   需要注意的是，如果指定了 initialValue 引數，則第一次執行回呼函式時的 currentValue 為陣列的第一個元素，否則為第二個元素，

3. index 引數：可選引數，表示正在處理的當前元素的索引，
4. array 引數：可選引數，表示方法正在操作的陣列，
5. initialValue 引數，可選引數，作為第一次呼叫回呼函式時的第一個引數的值，如果沒有提供該引數，第一次呼叫回呼函式時的第一個引數將使用陣列中的第一個元素，

   需要注意的是：對一個空陣列呼叫 reduce() 方法時，如果沒有指定 initialValue 引數此時將會報錯，

var num1 = [1,3,6,9];
//reduce()沒有initialValue引數
var num2 = num1.reduce(function(v1,v2){ //①
     return v1 + 2 * v2;//將當前元素值*2后和初始值或函式的前一次執行結果進行相加
});
console.log("num2=" + num2);//輸出：num2=37
//reduce()提供了initialValue引數
var num3 = num1.reduce(function(v1,v2){ //②
     return v1 + 2 * v2;//將當前元素值*2后和初始值或函式的前一次執行結果進行相加
},2);
console.log("num3=" + num3); //輸出：num3=40

上述示例中，① 處呼叫的 reduce() 沒有指定 initialValue 引數，因而初始值為陣列的第一個元素，即 1，此時 reduce() 的執行程序等效于：1+2*3+2*6+2*9 運算運算式的執行，結果回傳 37，② 處呼叫的 reduce() 指定了值為 2 的 initialValue 引數，因而初始值為 2，此時 reduce() 的執行程序等效于：2+2*1+2*3+2*6+2*9 運算運算式的執行，結果回傳 40，

find()

find() 用于獲取使回呼函式值為 true 的第一個陣列元素，如果沒有符合條件的元素，將回傳 undefined

array物件.find(function(currentValue[,index[,array]])[,thisArg])

filter() 方法的第一個引數為回呼函式，array 物件中每個元素都需要呼叫該函式，filter() 會回傳所有使回呼函式回傳值為 true 的元素，
filter() 方法中的各個引數說明如下：

1. currentValue 引數：必需引數，表示正在處理的陣列元素（當前元素）；
2. index 引數：可選引數，表示正在處理的當前元素的索引；
3. array 引數：可選引數，表示方法正在操作的陣列；
4. thisArg 引數，可選引數，取值通常為 this，為空時取值為 undefined

var names = ["Tom","Jane","Marry","John","Marissa"];
//定義回呼函式
function checkLength(item){
     return item.length >= 4;
}
var name = names.find(checkLength);//回傳名字陣列中名字長度大于或等于4的第一個名字
console.log("name: " + name);

// name:Jane

字串常用方法

陣列與字串相互轉換方法

toString() 方法讀取陣列的值

陣列中 toString() 方法能夠把每個元素轉換為字串，然后以逗號連接輸出顯示

var a = [1,2,3,4,5,6,7,8,9,0];  //定義陣列
var s = a.toString();  //把陣列轉換為字串
console.log(s);  //回傳字串“1,2,3,4,5,6,7,8,9,0”
console.log(typeof s);  //回傳字串string，說明是字串型別

當陣列用于字串環境中時，JavaScript 會自動呼叫 toString() 方法將陣列轉換成字串，在某些情況下，需要明確呼叫這個方法，

var a = [1,2,3,4,5,6,7,8,9,0];  //定義陣列
var b = [1,2,3,4,5,6,7,8,9,0];  //定義陣列
var s = a + b;  //陣列連接操作
console.log(s);  //回傳“1,2,3,4,5,6,7,8,9,01,2,3,4,5,6,7,8,9,0”
console.log(typeof s);  //回傳字串string，說明是字串型別

toString() 在把陣列轉換成字串時，首先要將陣列的每個元素都轉換為字串，當每個元素都被轉換為字串時，才使用逗號進行分隔，以串列的形式輸出這些字串

var a = [1,[2,3],[4,5]],[6,[7,[8,9],0]]];  //定義多維陣列
var s = a.toString();  //把陣列轉換為字串
console.log(S);  //回傳字串“1,2,3,4,5,6,7,8,9,0”

其中陣列 a 是一個多維陣列，JavaScript 會以迭代的方式呼叫 toString() 方法把所有陣列都轉換為字串，

toLocalString() 方法讀取陣列的值

toLocalString() 方法與 toString() 方法用法基本相同，主要區別在于 toLocalString() 方法能夠使用用戶所在地區特定的分隔符把生成的字串連接起來，形成一個字串

var a = [1,2,3,4,5];  //定義陣列
var s = a.toLocalString();  //把陣列轉換為本地字串
console.log(s);  //回傳字串“1,2,3,4,5,6,7,8,9,0”

在上面示例中，toLocalString() 方法根據中國的使用習慣，先把數字轉換為浮點數之后再執行字串轉換操作

join() 方法可以把陣列轉換為字串

join() 方法可以把陣列轉換為字串，不過它可以指定分隔符，在呼叫 join() 方法時，可以傳遞一個引數作為分隔符來連接每個元素，如果省略引數，默認使用逗號作為分隔符，這時與 toString() 方法轉換操作效果相同

var a = [1,2,3,4,5];  //定義陣列
var s = a.join("==");  //指定分隔符
console.log(s);  //回傳字串“1==2==3==4==5”

split() 方法把字串轉換為陣列

split() 方法是 String 物件方法，與 join() 方法操作正好相反，該方法可以指定兩個引數，第 1 個引數為分隔符，指定從哪兒進行分隔的標記；第 2 個引數指定要回傳陣列的長度

var s = "1==2== 3==4 ==5";
var a = s.split("==");
console.log(a);
console.log(a.constructor == Array);

JS字串大小寫轉換及比較

toLowerCase()和toUpperCase()

var oStr = "Hello,歡迎學習JavaScript";
alert(oStr.toLowerCase()));//輸出：hello,歡迎學習javascript
alert(oStr.toUpperCase());//輸出：HELLO,歡迎學習JAVASCRIPT

valueOf()和toString()

var oStr = new String("Hello,JavaScript!");
console.log(oStr.toString());//輸出：Hello,JavaScript!
console.log(oStr.valueOf());//輸出：Hello,JavaScript!

字串的比較

兩個字串之間的比較是逐位比較字符的 Unicode 值的大小，字串的比較可使用>、<、>=、<=、==5 個比較運算子，當使用>或<運算子時，一旦某位置上的字符的 Unicode 值不相等時，將回傳 true 或 false，否則繼續比較，一直到一個字串的所有字符都比較完時，對應位的字符的 Unicode 都相等，此時如果兩個字串的長度相等，則表示這兩個字串相等；此時如果兩個字串的長度不相等，則長度較長的那個字串大于長度較短的字串，

需要注意的是，如果兩個字串物件進行比較，則在比較前會默認呼叫 toString() 方法獲取它們的原始字串值，然后再用字串值進行比較，此外，如果比較的兩個資料有一個是字串，另一個是數值型資料，則默認會將字串隱式轉變為數值，然后按數值大小進行比較，

var str1 = "JavaScript";
var str2 = "javaScript";
var str3 = "JavaScript";
var str4 = "Java";
var oStr1 = new String("JavaScript");
var oStr2 = new String("VBScript");
alert(str1 < str2)//比較兩個字串變數,j的Unicode比J的大，輸出：true
alert(str1 == str3)//輸出：true
alert(str3 > str4);//輸出：true
alert(oStr1> oStr2);//比較兩個字串物件,等效于oStr1.toString()==oStr2.toString(),輸出：false
alert('100' > '2');//兩個比較數都是字串，將按對應位的Unicode進行比較，輸出：false
alert('100' > 2);//比較數存在數值資料，首先將字串隱式轉換為數值再比較，輸出：true

Math物件的常用方法

random()函式

獲取 0～1.0 之間的亂數

Math.random();

隨機獲取 0 和 1

Math.round(Math.random());

使用 round() 對 random() 函式所回傳的 0～1.0 之間的數進行四舍五入后，最終結果或者是 0 或者是 1，

隨機獲取 0～10 之間的一個整數

Math.round(Math.random()*10);

首先使用 Math.random()*10 可得到 0～10.0 之間的一個亂數，然后再使用 Math.round() 對 0～10.0 之間的亂數進行四舍五入，最終就可得到 0～10 之間的一個隨機整數，

隨機獲取 5～10 之間的一個整數

Math.round(Math.random()*5+5);

首先使用 Math.random()*5+5 可得到 5.0～10.0 之間的一個亂數，然后再使用 Math.round() 對 5.0～10.0 之間的亂數進行四舍五入，最終就可得到 5～10 之間的一個隨機整數，

隨機獲取 10～20 之間的一個整數

Math.round(Math.random()*10+10);

首先使用 Math.random()*10+10 可得到 10.0～20.0 之間的一個亂數，然后再使用 Math.round() 對 10.0～20.0 之間的亂數進行四舍五入，最終就可得到 10～20 之間的一個隨機整數，

隨機獲取 20～100 之間的一個整數

Math.round(Math.random()*80+20));

首先使用 Math.random()*80+20 可得到 20.0～100.0 之間的一個亂數，然后再使用 Math.round() 對 20.0～100.0 之間的亂數進行四舍五入，最終就可得到 20～100 之間的一個隨機整數，

隨機獲取 x~y 之間的一個整數，其中 x 和 y 都是整數

通過分析前面獲取不同范圍之間的亂數的代碼發現，random() 乘以某個數 v1 再加上另一個數 v2 后再進行四舍五入，可獲得 v2~v1+v2 之間的隨機整數，由此可總結獲取任意兩個數 x～y 之間的隨機整數的一般公式如下：
Math.round(Math.random()*(y-x)+x)


例如假設 x=26，y=37，求兩個數之間的隨機整數的代碼如下：

var x = 26,y = 37;
alert(Math.round(Math.random()*(y-x)+x));
運行上述代碼后可發現結果正是 26～37 之間的一個隨機整數

隨機獲取 0～x 之間的一個整數，其中 x 是一個整數

Math.round(Math.random()*x)

首先使用 Math.random()*x 可得到 0～x 之間的一個亂數，然后再使用 Math.round() 對 0～x 之間的亂數進行四舍五入，最終就可得到 0～x 之間的一個隨機整數，

1～x 之間的一個整數，其中 x 是一個整數

Math.ceil(Math.random()*x)

首先使用 Math.random()*x 可得到 0～x 之間的一個亂數，然后再使用 Math.ceil() 向上取整得到 1～x 之間的亂數進行四舍五入，最終就可得到 1～x 之間的一個隨機整數，

Date物件的常用方法

Date物件的創建

創建 Date 物件的格式

var 物件名稱 = new Date([日期引數]);

1) 省略不寫，用于獲取系統當前時間，這是最常使用的情況，所謂系統當前時間，指的是運行獲取 Date 物件時的作業系統上的時間，

示例如下：
var now = new Date();

2) 字串形式，引數以字串形式來表示，引數格式為：“月日，公元年時：分:秒”或其日期形式“月日，公元年”，或“月/日/公元年時：分:秒”或其日期形式“月/日/公元年”，需要注意的是，月份的取值是 1～12，或者是表示 1～12 月的英文單詞：January、February、March、April、May、June、July、Augu st、September、October、November、December，

示例如下：
var date = new Date("10/27/2000 12:06:36");//月份為10月
var date = new Date("October 27,2000 12:06:36");

3) 數字形式，引數以數字來表示日期中的各個組成部分，引數格式為：“公元年，月，日，時，分，秒”或“公元年，月，日”，需要注意的是，月份的取值是 0～11，即 0 表示 1 月份，11 表示 12 月份，

例如：
var date = new Date(2012,10,10,0,0,0);//月份為11月
var date = new Date(2012,10,10);

使用表中的方法時

Date物件.方法(引數1,引數2,…)

例如：
var time = new Date();
var year = time.getFullYear();//Date物件time呼叫getFullYear()方法獲取當前系統時間的年份

使用 Date 物件獲取系統時間
var now = new Date(); //對系統當前時間創建Date物件
var year = now.getFullYear(); //獲取以四位數表示的年份
var month = now.getMonth()+1; //獲取月份
var date = now.getDate();//獲取日期
var day = now.getDay(); //獲取星期數
var hour = now.getHours();//獲取小時數
var minute = now.getMinutes();//獲取分鐘數
var second = now.getSeconds();//獲取秒數
//創建星期陣列
var week = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六"];     
hour = (hour<10) ? "0"+hour:hour;//以兩位數表示小時
minute = (minute<10) ? "0"+minute:minute;//以兩位數表示分鐘
second = (second<10) ? "0"+second:second;//以兩位數表示秒數
console.log("現在時間是："+year+"年"+month+"月"+date+"日 "+week[day]+" "+ 
  hour+":"+minute+ ":"+second);
console.log("當前時間呼叫toLocaleString()的結果: "+now.toLocaleString());
console.log("當前時間呼叫toString()的結果："+now.toString());
console.log("當前時間呼叫toUTCString()的結果: "+now.toUTCString());
/*function toTwo(num){//以兩位數來表示num
 return (num<10)?'0'+num:''+num;
}*/