前言：引用型別的值(物件)是引用型別的一個例項。引用型別是一種資料結構，用於將資料和功能組織在一起。有時候也被稱為物件定義，因為它們描述的是一類物件所具有的屬性和方法。

1.引用資料型別

Object型別

	var person  = new Object();//通過object的建構函式去建立物件
	var person  = {			   //通過物件字面量表示法建立
		name:"張三",
		"age":23,
		5:true      //數值屬性名5會自動轉成字串
	};
	var person = {};  //與new Object();相同，但是使用字面量建立物件不會呼叫Object建構函式
 

使用字面量方式像函式傳遞大量可選引數:

	function displayInfo(args){
		var output = "";
		if(typeof args.name == "string"){
			output += "Name:"+args.name;
		}

		if(typeof args.age == "number"){
			output += "Age:"+args.age;
		}	
	}
	displayInfo({
			name:"張三"，
			age: 2
		});
	displayInfo({
			name:"李四"
		});

tips：對必需的值使用命名引數，對多個可選引數使用字面量方式封裝。

使用方括號訪問物件的屬性：

	var propertyName = "name";
	person[propertyName];   //  可通過變數訪問屬性
	person[first name];     // 可訪問帶特殊字元，或關鍵字的屬性名

Array型別

	//建立陣列的方法
	//一
	var colors = new Array();
	//二
	var colors1 = ["red","blue"];
	//注意：
	colors1[3] = "green";
	alert(colors1[3]);  //green
	alert(colors1[4]); //undefined

	colors1.length = 2; //通過設定陣列長度可以移除陣列後面的項，或新增新項

	colors1[colors1.length] = "black"; //在陣列末尾新增項
	colors1[colors1.length] = "yellow";
 

陣列檢測:    instanceof ，Array.isArray(value)

轉換方法： 

var person1 = {
	toLocaleString : function(){  //重寫方法
		return "張三";
	}
	toString : function(){
		return "李四";
	}
};
var person2 = {
	toLocaleString : function(){
		return "張三2";
	}
	toString : function(){
		return "李四2";
	}
};
var people = [person1,person2];
alert(people);  //預設呼叫陣列元素的toString() 李四,李四2
console.log(people.toString());//呼叫每個元素的toString()  李四,李四2
console.log(people.toLocaleString());//張三,張三2

陣列繼承的toLocaleString(),toString()和valueOf()方法，在預設情況下都會以逗號分隔的字串形式返回陣列頂。使用join()方法可以改變不用的分隔符。

alert(people.join("||"));//  李四||李四2

棧方法

使陣列表現得像棧一樣push()：接收任意數量的引數，將它們逐個新增到陣列末尾，並返回修改後的陣列長度。pop()：從陣列末尾移除最後一項，減少陣列的length值，然後返回移除的項。

佇列方法

shift()：移除陣列的第一項並返回該項，同時將陣列長度減1。

	var arr = [];
	var count = arr.push("zhangsan","lisi","wangwu","zhaoliu","sunqi");
	console.log(count);
	var firstItem = arr.shift();  //移除第一項，陣列長度-1，返回移除的項
	console.log(firstItem);   //zhangsan
	console.log(arr[0]);  //lisi

unshift()：在陣列前端新增任意個項，返回新陣列長度

重排序方法

reverse()：反轉陣列項的順序sort()：預設按升序排列陣列項，sort()方法會呼叫每個陣列項的toString()轉型方法，然後比較得到的字串，以確定如何排序。即使陣列中的每一項都是數值，sort()方法比較的也是字串。

	var arr = [0,1,5,10,15];
	alert(arr.sort());  // 0,1,10,15,5  按字串比較10在5之前

給定比較函式：比較函式接收兩個引數，如果第一個引數應該位於第二個引數前則返回負數，相等返回0

	var arr = [0,1,5,10,15];
	alert(arr.sort());  // 0,1,10,15,5  按字串比較10在5之前
	function compare(value1,value2){
		if(value1<value2){
			return -1;
		}else if(value1 > value2){
			return 1;
		}else{
			return 0;
		}
	}
	arr.sort(compare);
	alert(arr);  //0,1,5,10,15

操作方法

concat()：陣列連線，方法會先建立當前陣列的一個副本，然後將接收到的引數新增到這個副本的末尾，最後返回新構建的陣列。

	var arr = ["red","blue","yellow"];
	var arr1 = arr.concat(["green","gray"]); //拼接陣列
	var arr2 = arr1.concat("purple",["orange","black"]);
	alert(arr); // red,blue,yellow原來陣列不變
	alert(arr1);// red,blue,yellow,green,gray
	alert(arr2);// red,blue,yellow,green,gray,purple,orange,black

 slice()：擷取子陣列

	var arr = ["red","blue","yellow","green","gray","purple","orange","black"];
	var arr1 = arr.slice(1);  //blue,yellow,green,gray,purple,orange,black
	var arr2 = arr.slice(1,5);  //blue,yellow,green,gray
	alert(arr1);
	alert(arr2);

注意：如果slice()方法引數中是負數，就用陣列長度加負數來確定位置。如果結束位置小於其實位置，返回空陣列。

splice()方法：主要用途是向陣列的中部插入項

• 刪除：指定兩個引數（要刪除的第一項的位置，要刪除的項數），splice(0,2) 刪除陣列前兩項
• 插入：可以向指定位置插入任意數量的項3個引數（起始位置，要刪除的項數0，插入的項）splice(2,0,"red","green")從當前陣列的位置2開始插入red,green兩項
• 替換：指定位置插入任意項，同時刪除任意項，3個引數（起始位置，刪除的項數，插入的項），插入的項數不必與刪除的項數相等。如                  splice(2,1,"red","green") 刪除位置2的一項元素，在位置2新增red,green

注意：splice()方法始終返回一個數組，陣列中包含從原來陣列中刪除的項，如果沒刪除任何項，則返回一個空陣列。

	var arr = ["red","blue","yellow","green","gray","purple","orange","black"];
	var removed = arr.splice(0,1); //刪除第一項
	alert(removed)
	var removed1 = arr.splice(2,0,"hehe","haha");//位置2插入兩項
	alert(removed1);
	var removed2 = arr.splice(2,2,"heihei","huahua");
	alert(removed2);
	alert(arr);

位置方法

indexOf()：從陣列頭開始查詢，沒找到返回-1lastIndexOf()：從陣列尾開始查詢

	var person = {name:"zhangsan"};  
	var people = [{name:"zhangsan"}]; 
	var people1 = [person];

	alert(people.indexOf(person));  // -1  查詢的項必須嚴格相等
	alert(people1.indexOf(person));  // 0

迭代方法

every()：對陣列中的每一項執行給定函式，如果該函式每一項都返回true，則返回true。

some()：對陣列中的每一項執行給定函式，如果該函式對任一項返回true，則返回true。

	var numbers = [1,2,3,4,5,4,3,2,1];
	//只要有一個是false就立刻返回false,結束迭代
	var everyResult = numbers.every(function(item,index,array){
		console.log(item);//迭代的項
		console.log(index);//陣列下標
		return (item>2);
	});
	alert(everyResult);
	//只要有一項返回true，就結束迭代
	var someResult = numbers.some(function(item,index,array){
		console.log(item);
		console.log(index);
		return (item>2);
	});
	alert(someResult);

filter()：對陣列每一項給定函式，返回函式返回true的項組成的陣列

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

通常用來過濾掉陣列中不符合條件的項

forEach()：對陣列每一項給定函式，沒有返回值。與for迴圈迭代陣列一樣

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

map()：對陣列中的每一項執行給定函式，返回每次函式呼叫的結果返組成的陣列

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

通常用來建立包含的項與另一個數組一一對應的陣列

縮小方法

reduce()：從陣列的第一項開始，逐個遍歷到最後reduceRight()：從陣列最後一項開始，向前遍歷

	var numbers = [1,2,3,4,5];
	var sum = numbers.reduce(function(prev,cur,index,array){
		return prev+cur;
	});
	alert(sum);//15  前一個元素與當前迭代的元素相加

Date型別

Date型別使用UTC(Coordinated Universal Time，國際協調時間) 19701月1日零點開始經過的毫秒數來儲存日期。

	var date3 = new Date(); //獲取當前日期
	var date = new Date("May 28, 2016");
	var date1 = Date.now(); //獲取當前日期的毫秒數
	var date2 = +new Date(); //獲取當前日期的毫秒數
	alert(date);
	alert(date1);
	alert(date2-date1);
	alert(date3);

繼承方法重寫：

valueOf()：獲取日期的毫秒數值

	var date1 = new Date(2016,0,1);//0-11月，0-23小時,軍用時間
	var date2 = new Date(2016,0,2);
	alert(date1 < date2); //true
	alert(date1 > date2); //false

日期格式化：

toDateString()：以特定格式顯示 星期，月，日，年

toTimeString()：以特定格式顯示  時，分，秒，時區

RegExp型別

Function型別

函式實際上是物件，每個函式都是Function型別的例項，而且與其它引用型別一樣具有屬性和方法。函式名實際上也是一個指向函式物件的指標，不會與函式繫結

函式的定義：

	var sum = function(num1,num2){
		return num1+num2;
	};
	function sum(num1,num2){
		return num1+num2;
	}
	var sum = new Function("num1","num2","return num1+num2"); //不推薦

注意：使用Function建構函式去建立函式物件的時候，會導致程式碼解析兩次(第一次是解析ECMAScript程式碼，第二次是解析傳入建構函式中的字串引數)，從而影響效能。

由於函式名僅僅是指向函式的指標，所以一個函式可以有多個名稱。

沒有過載

	var sum = function(num1,num2){
		return num1+num2;
	};
	function sum(num1,num2,num3){
		return num1+num2+num3;
	}
	//相當於,在建立第二個函式的時候，實際上覆蓋了引用第一個函式的變數sum
	sum = function(num1,num2,num3){
		return num1+num2+num3;
	}

函式宣告與表示式

在解析器向執行環境載入資料時，解析器會先讀取函式宣告，並使其在執行任何程式碼前可用。函式表示式則要等到解析器執行到該表示式所在的程式碼行時才被解釋執行。

	alert(sum(10,10));  //20,不會報錯
	function sum(num1,num2){
		return num1+num2;
	}

	alert(sum1(12,12));  //會報錯，Uncaught TypeError: sum1 is not a function
	var sum1 = function(num1,num2){
		return num1+num2;
	}

說明：第一段程式碼正常執行，因為在程式碼開始執行之前，解析器就已經通過一個名為函式宣告提升(function declaration hoisting)的過程，讀取並將函式宣告新增到執行環境中。對程式碼求值時，JavaScript引擎在第一遍會宣告函式並將它們放到原始碼樹的頂部。所以，即使宣告函式的程式碼在呼叫它的程式碼的後面，JavaScript引擎也能把函式宣告提升到頂部。

第二段程式碼出錯，原因在於函式位於一個初始化語句中，而不是一個函式宣告。也就是說，在執行到函式所在的語句之前，sum1並不會儲存有對函式的引用。

作為值的函式

ECMAScript中的函式名本來就是變數，所以函式也可以作為值來使用(可以將函式當引數傳遞，也可以在函式中返回另一個函式);

	function callFunction(functionName,param){
		return functionName(param);
	}

	function add10(num){
		return num+10;
	}
	var result = callFunction(add10,10); // 20,注意傳入的是add10函式的指標，而不是add10()函式執行後的結果
	function sayHello(name){
		return "hello "+name;
	}
	var result1 = callFunction(sayHello,"ethan"); //hello ethan

作為返回值的函式，例子：（獲取一個根據指定屬性名排序的函式）

	function getComparisonFunction(propertyName){
		return function(object1,object2){
			var value1 = object1[propertyName];//使用[]可根據變數訪問屬性
			var value2 = object2[propertyName];

			if(value1<value2){
				return -1;
			}else if(value1>value2){
				return 1;
			}else{
				return 0;
			}
		}
	}

	var data  = [{name:"zhangsan",age:25},{name:"lisi",age:26}];
	data.sort(getComparisonFunction("name"));//根據name排序,lisi,zhangsan
	console.log(data);
	data.sort(getComparisonFunction("age"));//根據age排序,zhangsan,lisi
	console.log(data);

函式內部屬性

函式內部有兩個特殊的物件，arguments(類陣列物件)和this：arguments包含著傳入函式中的所有引數。雖然arguments物件的主要用途是儲存函式引數，但這個物件還有一個名叫callee的屬性，該屬性是一個指標，指向擁有這個arguments物件的函式。

	function factorial(num){//通過遞迴演算法，定義一個階乘函式，與函式名緊耦合
		if(num <=1){
			return 1;
		}else{
			return num*factorial(num-1);
		}
	}
	//使用callee改進
	function factorial1(num){
		if(num <=1){
			return 1;
		}else{
			return num*arguments.callee(num-1);//callee指向factorial1函式
		}
	}

	var trueFactorial = factorial1;//讓trueFactorial指向階乘函式
	var factorial1 = function(){//解除factorial1與階乘函式的關聯
		return 0;
	};
	console.log(trueFactorial(5));//120  
	console.log(factorial1(5));// 0 

this引用的是函資料以執行的環境物件，當在全域性作用域中呼叫函式時，this物件引用的就是window

	function sayHello(){
		return this.helloName;
	}
	window.helloName = "window";
	sayHello();//全域性,window呼叫，this指向window。返回"window"
	var o = {helloName:"ooooo"};
	o.sayHello = sayHello;
	o.sayHello(); //通過o物件呼叫sayHello函式，this指向的是o，返回 "ooooo"

ECMAScript5中也規範化了另一個函式物件的屬性：caller。這個屬性中儲存著呼叫當前函式的函式的引用（如果在全域性作用域中呼叫，它的值為null）

	function outer(){
		inner();
	}
	function inner(){
		alert(arguments.callee.caller);//arguments.callee指向inner()函式，arguments.callee.caller指向outer()函式
	}

	outer();

函式屬性和方法

length：表示函式希望接收的命名引數的個數

prototype：對於ECMAScript中的引用型別而言，prototype是儲存它們所有例項方法的真正所在。toString()和valueOf()等方法都儲存在prototype名下，只不過是通過各自物件的例項訪問罷了。prototype是不可列舉的，無法使用for-in發現。

每個函式都包含兩個非繼承而來的方法：apply()和call()。用途就是在特定的作用域中呼叫函式，相當於設定函式體內this物件的值。

apply()：接收兩個引數，一個是在其中執行函式的作用域，另一個是引數陣列(可以是Array的例項，也可以是arguments物件)，如：

	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]);
	}
	console.log(callSum1(10,10));
	console.log(callSum2(10,20));

call()方法與apply()方法的作用相同，它們的區別僅在於接收引數的方式不同。call()方法接收引數時必須逐個列出來(明確傳入的每個引數)
使用apply()與call()方法擴充函式賴以執行的作用域。

	window.color = "red";
	var o = {color:"blue"};

	function sayColor(){
		alert(this.color);
	}

	sayColor.apply(this); // window.color  red
	sayColor.call(window);// window.color  red
	sayColor.apply(o);  // o.color   blue

注意：使用call()或apply()來擴充作用域的好處，就是物件與方法不需要有任何耦合
bind()：建立函式的例項，this指向傳給bind()函式的值。

	window.color = "red";
	var o = {color:"blue"};

	function sayColor(){
		alert(this.color);
	}

	var sayColorObj = sayColor.bind(o); //sayColor()
	sayColorObj();  //blue  建立了sayColorObj()函式，this指向o物件

基本包裝型別

Boolean，Number，String。每當讀取一個基本型別值的時候，後臺就會建立一個對應的基本包裝型別的物件。

	var s1 = "some text";
	var s2 = s1.substring(2);
	console.log(s2);  // me text

在上面程式碼中，s1字串可以呼叫方法，實際上在讀取模式中，後臺會自動完成一下處理

(1)建立String 型別的一個例項

(2)在例項上呼叫指定的方法

(3)銷燬這個例項

	var s1 = new String("some text");
	var s2 = s1.substring(2);
	s1 = null;

說明：引用型別與基本包裝型別的主要區別就是物件的生存期。使用new建立的應用型別的例項，在執行流離開當前作用域之前都一直儲存在記憶體中。而自動建立的基本包裝型別的物件，只存在於一行程式碼執行的瞬間，然後就立刻銷燬。意味著我們不能在執行時為基本型別新增屬性和方法
tips：可以顯示呼叫Boolean，Number，String的建構函式來建立基本包裝型別的物件。不過在非必須的情況下儘量不要這麼做，因為這樣很容易讓人分不清自己是在處理基本型別還是引用型別。對基本包裝型別的例項呼叫typeof會返回"object"，而且所有基本包裝型別的物件都會被轉換為true。

	var obj = new Object("some text");
	alert(obj instanceof String); //true

Object建構函式也像工廠方法一樣，根據傳入值的型別，返回相應的基本包裝型別例項。

	var value = "22";
	var number = Number(value);//轉型函式
	alert(typeof(number)); //"number"

	var obj = new Number(value); //建構函式
	alert(typeof obj); // "object"

注意：使用建構函式和同名的轉型函式是不一樣的。

Boolean型別

常見問題：（Boolean型別容易造成誤解）

	var falseObj = new Boolean(false);
	var result = falseObj && true; //在布林表示式中，所有物件都會轉換成true
	alert(result);

	var falseValue = false;
	result1 = falseValue && true;
	alert(result1); // false 

	console.log(typeof falseObj);   //object
	console.log(typeof falseValue);  //boolean
	console.log(falseObj instanceof  Boolean); // true
	console.log(falseValue instanceof Boolean); // false

最好不要用Boolean

Number型別

toString(2);轉換成指定的進位制，返回字串

toFixed(2);保留指定的小數位，返回字串(四捨五入)

String型別

	var stringValue  = new String("zhang san");
	alert(stringValue.length);

每個String的例項都有length屬性，表示字串中字元的個數。即使字串中包含雙位元組字元，每個字元也只算一個字元

1. 字元方法

	var stringValue  = new String("zhang san");
	alert(stringValue.charAt(1)); //  h
	alert(stringValue.charCodeAt(1)); // 104 輸出h的字元編碼
	alert(stringValue[1]);// 直接使用數字索引加[]來訪問字串中的特定字元

2.字串操作方法

slice(),substr(),substring()。不會修改字串本身，而是返回一個基本型別的字串。

	var stringValue  = new String("zhang san");
	stringValue.slice(3); // ng san
	stringValue.substring(3);// ng san
	stringValue.substr(3); // ng san
	stringValue.slice(3,7);//   ng s   下標3~7的字元
	stringValue.substring(3.7);// ng s
	stringValue.substr(3,7); // ng san  下標3開始，取7位字元

3.字串位置方法

從字串中搜索給定的子字串，然後返回子字串的位置(沒找到就返回-1)

	var stringValue  = new String("zhang san");
	alert(stringValue.indexOf("a")); //從開頭向後搜尋   2
	alert(stringValue.lastIndexOf("a"));//從結尾向前搜尋   7
	alert(stringValue.indexOf("a",4));// 從第四位開始向後搜尋 7
	alert(stringValue.lastIndexOf("a",4))//從第四位開始向前搜尋  2

通過迴圈查詢出所有匹配的子字串

	var stringValue  = "'Card Crawl' Developers Bringing 'Enyo',a Tactical Roguelike to Mobile";
	var posArr = [];
	var pos = stringValue.indexOf("e");
	while(pos > -1){
		posArr.push(pos);
		pos = stringValue.indexOf("e",pos+1);
	}
	alert(posArr);

4.trim()方法

	var stringValue  = "   zhang san   ";
	var trimmedStr = stringValue.trim();
	alert(trimmedStr); // 返回字串的副本，原始字串不變

5.字串大小寫轉換方法

	var stringValue  = "   zhang san   ";
	alert(stringValue.toLocaleUpperCase()); // ZHANG SAN
	alert(stringValue.toLocaleLowerCase()); //  zhang san
	alert(stringValue.toUpperCase()); // ZHANG SAN
	alert(stringValue.toLowerCase());//  zhang san

6.字串的模式匹配方法

match();只接收一個引數，正則表示式或RegExp物件。

	var stringValue  = "cat, bat , sat , fat";
	var pattern = /.at/;
	var matches = stringValue.match(pattern);
	console.log(matches);

	var pos = stringValue.search(/at/);
	alert(pos);

macth()方法返回陣列：第一項是與整個模式匹配的字串，之後每一項儲存著與正則表示式中的捕獲組匹配的字串。
search()返回字串匹配的索引，從頭向後查詢

replace()方法，替換匹配的子字串

	var stringValue  = "cat, bat , cat , fat";
	var result = stringValue.replace("at","kkk"); //替換第一個匹配的at子字串
	alert(result); // ckkk, bat , cat , fat

	var result1 = stringValue.replace(/at/g,"kkk");
	alert(result1); // ckkk, bkkk , ckkk , fkkk

split()方法：將字串根據指定的分割符切分成多個子字串，返回陣列（可指定第二個引數，指定返回的陣列大小）
localeCompare()方法：比較兩個字串，字串子字母表中排在引數前，返回負數-1。相等返回0，之後返回1

	var stringVal = "red";
	result = stringVal.localeCompare("blue");
	alert(result); // 1

fromCharCode()方法：String建構函式本身還有一個靜態方法，接收一個或多個字元編碼，轉成字串返回(與charCodeAt()相反)

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

單體內建物件

定義：由ECMAScript實現提供的，不依賴於宿主環境的物件，這些物件在ECMAScript程式執行之前就已經存在了。不必顯示地例項化內建物件，因為它們已經例項化了。Object，Array，String，Global，Math都是內建物件

Global物件

全域性物件，不屬於任何其他物件的屬性和方法，最終都是它的屬性和方法，所有在全域性作用域中定義的屬性和函式，都是Global物件的屬性。如：isNaN()，isFinite()，parseInt()，parseFloat()，都是Global物件的方法。1.URI 編碼方法encodeURI()：對整個URI(如：http://www.hehe.com/illegal value.htm)，不會對冒號，正斜槓，問號和井號編碼encodeURIComponent()：對URI中某一段(如：illegal value.htm) 進行編碼，對所有非標準字元進行編碼

有效的URI中不能包含某些特殊字元，通過上面的方法，可以對URI進行編碼，用UTF-8編碼替換無效的字元。

	var uri = "http://www.hehe.com/illegal value.htm#start";
	alert(encodeURI(uri));  //將  空格 變成了 %20   decodeURI()
	var encodeUri = encodeURIComponent(uri); //對所有特殊字元都做了轉換
	var decodeUri = decodeURIComponent(encodeUri); //解碼
	alert(decodeUri);

 一般常用的是encodeRUIComponent()方法，只需要對傳給後臺的引數進行編碼即可。

2.eval()方法

eval("alert('hi')");//等價與 alert("hi");

當呼叫eval()方法時，解析器會將引數當作ECMAScript語句來解析，然後將執行結果插入到原位置。通過eval()執行的程式碼作用域就是當前執行的環境。因此被執行的程式碼具有與當前執行環境相同的作用域鏈。如：

	var msg = "hehe";
	eval("alert(msg)"); //hehe 

	eval(eval("function sayHi(){alert('hi');}"));//定義一個函式
	sayHi();//可以呼叫

3.Global物件的屬性

undefined，NaN，Infinity，Object，Array，Function，Boolean，String等等

4.window物件

說明：ECMAScript雖然沒有指出如何直接訪問Global物件，但Web瀏覽器都是將這個全域性物件作為window物件的一部分加以實現的。因此，在全域性作用域中宣告的所有變數和函式，就都成為了window物件的屬性。

	var color = "red";
	function sayColor(){
		alert(window.color);
	};
	window.sayColor(); //red

另一種獲取global物件的方法：

	var global = function(){
		return this;
	}();

上面建立了一個立即呼叫的函式表示式，返回this。在沒有給函式明確指定this值的情況下(無論是通過將函式新增為物件的方法，還是通過呼叫call(),apply())，this值等於Global物件。

Math物件

max()和min()方法：

	var max = Math.max(2,43,23,76,23); //接收任意多個數值引數
	var min = Math.min(2,43,23,76,23);
	alert(max);   // 76
	alert(min);   // 2

	var valArr = [2,43,23,76,23];
	var maxRes = Math.max.apply(Math,valArr); //使用math方法找到陣列中的最大值
	alert(maxRes);

舍入方法：將小數值舍入為整數值

Math.ceil()：向上舍入

Math.floor()：向下舍入

Math.round()：四捨五入

	console.log(Math.ceil(25.9)); //26
	console.log(Math.ceil(25.5)); //26
	console.log(Math.ceil(25.1)); //26
	
	console.log(Math.floor(25.9)); //25
	console.log(Math.floor(25.5)); //25
	console.log(Math.floor(25.1)); //25

	console.log(Math.round(25.9)); //26 
	console.log(Math.round(25.5)); //26
	console.log(Math.round(25.1)); //25

random()方法：返回介於0和1之間的一個隨機數，不包括0和1

	var num = Math.floor(Math.random()*可能的數值總數+第一個可能的值);
	var num = Math.floor(Math.random()*10+1); //1~10的隨機數
	var num = Math.floor(Math.random()*9+2);//2~10的隨機數

	function selectForm(lowerValue,upperValue){
		var choices = upperValue - lowerValue +1;
		return Math.floor(Math.random()*choices+lowerValue);
	}
	var arr = ["red","green","blue","yellow","black","purple","brown"];
	console.log(arr[selectForm(0,arr.length-1)]);

小結：

• 引用型別與傳統面向物件程式設計中的類相似，但實現不同
• Object是一個基礎型別，其他所有型別都從Object繼承了基本的屬性和方法
• Array型別是一組值的有序列表，同時還提供了操作和轉換這些值的功能
• 每個包裝型別都對映到同名的基本型別；
• 在讀取模式下訪問基本型別值時，會建立對應的基本包裝型別的一個物件，方便資料的操作
• 操作基本型別值的語句一旦執行完畢，建立的包裝物件就會銷燬

函式實際上是Function型別的例項，因此函式也是物件；函式也擁有方法，來增強其行為

在所有程式碼執行之前，作用域中就已經存在兩個內建物件：Global和Math。在大多數ECMAScript的實現中都不能直接訪問Global物件；不過，web瀏覽器實現了承擔該角色的window物件。全域性變數和函式都是Global物件的屬性。