引用類型的值（對象）是引用類型的一個實例。引用類型有時也稱對象定義，因為它們描述的是一類對象所具有的屬性和方法。
對象是某個特定引用類型的實例，新對象是使用new操作符后跟一個構(gòu)造函數(shù)來創(chuàng)建的，構(gòu)造函數(shù)本身就是一個函數(shù)，只不過該函數(shù)是出于創(chuàng)建新對象的目的而定義的。
ver dada = new Object();JavaScript對象劃分為：
引用類型，基本包裝類型，內(nèi)置對象
JavaScript引用類型分：Object類型，Array類型，RegExp類型，Date類型，F(xiàn)unction類型。
基本包裝類型，Boolean類型，Number類型，String類型。
Object類型
Object類型是JavaScript中常見的一種類型，使用new操作符
var dada = new Object();
dada.name = "dada";
dada.age = 12;使用對象字面量表示法：
var dada = {
name: 'dada',
age: 12,
}訪問對象的屬性
console.log(dada.name);
console.log(dada['name']);var dadaname = "dada";
console.log(dada[dadaname]);注意，除非是必須非要使用變量來訪問屬性，否則不建議使用，還是建議使用點方法來表示。
new運算符的作用就是創(chuàng)建一個對象的實例，這個對象可以是用戶自定義，也可以是帶有構(gòu)造函數(shù)的一些系統(tǒng)自帶的對象。
創(chuàng)建Object類型有兩種方法：
第一，使用new運算符創(chuàng)建Object，第二，使用對象字面量方式創(chuàng)建Object，使用最多。
判斷js對象是否擁有這個屬性，第一種，使用in判斷對象的所有屬性，包含對象實例以及其原型的屬性；第二種，使用
Object.hasOwnProperty(proName);判斷的是對象的實例是否具有某個屬性。
引用類型通常叫做類，即是，遇到引用值，可以理解為對象。
對象是由 new 運算符加上要實例化的對象的名字創(chuàng)建的
var o = new Object();Object對象具有的屬性
constructor對創(chuàng)建對象的函數(shù)的引用（指針），對于Object對象，該指針指向原始的Object()函數(shù)。
檢測數(shù)組
instanceof
Array.isArray(value)
Object.prototype.toString.call(obj)
轉(zhuǎn)換方法
toString() 返回字符串
valueOf() 返回數(shù)組本身
toLocaleString()
join()
var dada = ['da1','da2'];
dada.toString()
"da1,da2"
dada.valueOf()
['da1','da2']添加移除
push()數(shù)組末尾接收任意數(shù)量，并返回修改后的數(shù)組的長度。
pop()數(shù)組末尾移除最后一項，減少length值，返回移除的項
shift()移除數(shù)組第一項，并返回該項，數(shù)組長度減一
unshift()數(shù)組前面添加任意項并返回新的數(shù)組的長度
重排序
reverse() 反轉(zhuǎn)
sort()排序
var arr = [1,3,7,9,4,5]
var arr2 = arr.sort(function(a,b) {
// 從小到大的排序
return a-b
// 從大到小的排序
return b-a
})
console.log(arr2);操作方法，concat()創(chuàng)建當(dāng)前數(shù)組的一個副本，如果有參數(shù)則添加這個副本的末尾，如果沒有參數(shù)就返回當(dāng)前數(shù)組的副本。
slice(start,end)接收一個或兩個參數(shù)，但不返回結(jié)束位置的項，不會影響原數(shù)組；splice(起始位置，刪除的項數(shù)量，要插入的項），刪除，替換，插入。
dada.splice(1, 0, 'da1','da2');
// dada從1位置插入兩項
dada.splice(1,1, 'da1','da2');
// 為在1位置刪除1項，插入兩項indexOf()從數(shù)組開頭向后查找
lastIndexOf()從數(shù)組的末尾開始向前查找
返回的是查找項在數(shù)組中的位置，如果沒有找到就返回-1
基本類型值和引用類型值，基本類型值是簡單的數(shù)據(jù)，而引用類型是指由多個值構(gòu)成的對象。
基本類型，undefined,null,boolean,number,string
引用類型，Object,Array等
從一個變量向另一個變量復(fù)制引用類型的值時，同樣也會將存儲在變量對象中的值復(fù)制一份到新變量分配的空間中。不同的是，這個值的副本實際上是一個指針，這個指針指向存儲在堆中的一個對象，復(fù)制后的結(jié)果是，兩個變量實際上將引用同一個對象，兩個變量對象指向堆內(nèi)存中同一個Object對象，所以當(dāng)改變其中一個變量，就會影響另一個變量。
var dada = new Object();
var dashu = dada;
dada.name='da1';
console.log(dashu.name);
// da1
數(shù)值的傳遞，函數(shù)的參數(shù)
在JavaScript中所有函數(shù)的參數(shù)都是使用值傳遞的，就是把函數(shù)外的值復(fù)制傳遞給函數(shù)內(nèi)部的參數(shù)，就好像從一個變量賦值到另一個變量一樣
基本類型值的傳遞如同基類型變量的復(fù)制效果一樣，引用類型的值傳遞，就如同引用類型變量的復(fù)制一樣的效果。
在向參數(shù)傳遞基本類型值時，被傳遞的值會復(fù)制給一個局部變量，在向參數(shù)傳遞引用類型的值時，會把這個值在內(nèi)存中的地址復(fù)制給這個局部變量。
基本類型
function add(num) {
num += 1;
return num;
}
var da1 = 12;
var result = add(da1);
console.log(da1);
console.log(result);
引用類型
function setName(obj) {
obj.name = 'dada';
}
var person = new Object();
setName(person);
console.log(person.name);
dada
typeof檢測基本類型
typeof中 var da; // 檢測為undefined
typeof中 var da = null; // 檢測為object
typeof中 var da = new Object(); // 檢測為object
instanceof檢測引用類型的值
如果不是檢測的不是引用類型的值，而是基本類型的值，則返回false
如果是引用類型的值，返回為true
var d = new Number(11);
console.log(d instanceof Number);
true
Object.prototype.toString表示返回一個表示該對象的字符串
Object.prototype.toString.call(null);
"[object Null]"
Object.prototype.toString.call(1111);
"[object Number]"
Object.prototype.toString.call('string');
"[object String]"
總結(jié)Object類型，大部分引用類型值都是Object類型的實例，創(chuàng)建Object實例的方式有兩種，一種是使用new操作符后跟Object構(gòu)造函數(shù)，一種是使用對象字面量表示法。
array類型，Date類型，RegExp類型，F(xiàn)unction類型，基本包裝類型是什么呢？
我相信你在學(xué)習(xí)時一定見到過Array類型，也是最常見的，數(shù)組的每一項可以存儲任何類型的數(shù)據(jù)，數(shù)組的大小是可以動態(tài)變動的，數(shù)組的長度越大就可以存儲更多的數(shù)據(jù)。
那么第一問，數(shù)組是怎么創(chuàng)建的呢？
數(shù)組有哪些自帶的屬性，如何檢查是否為一個數(shù)組，數(shù)組元素的增刪改等，數(shù)組與字符串的相互轉(zhuǎn)化，數(shù)據(jù)的一些方法，如，截取，合并，排序，查找數(shù)組元素的元素，如何遍歷數(shù)組，進(jìn)行迭代等。
數(shù)組的創(chuàng)建，同樣數(shù)組也有兩種基本的創(chuàng)建方式，一種是使用array構(gòu)造函數(shù)，和創(chuàng)建對象一樣new Object()方法。看看使用Array構(gòu)造函數(shù)的語句代碼:
var da = new Array();
new Array(); // 創(chuàng)建一個數(shù)組
new Array([size]); // 創(chuàng)建一個數(shù)組并指定長度
new Array(element0, element1, ..., elementn);
// 創(chuàng)建一個數(shù)組并賦值
采用字面量的方法
var da = []; // 創(chuàng)建一個空數(shù)組
var da1 = [1,2,3]; // 創(chuàng)建一個有三個元素的數(shù)組
var da1 = [1,2,3];
console.log(da1 instanceof Array);
VM272:1 true
var dada = [1,2,3];
undefined
console.log(Array.isArray(dada));
VM422:1 true
檢查是否是數(shù)組的兩種方法：
一種使用instanceof，一種使用Array.isArray()方法。
constructor
// 返回創(chuàng)建數(shù)組對象的原型函數(shù)
length
// 返回數(shù)組的長度
prototype
// 可以增加數(shù)組的原型方法和函數(shù)
可以看出一個數(shù)組中方法：
_proto_
concat
constructor
copyWithin
entries
every
fill
filter
find
findIndex
flat
flatMap
forEach
includes
indexOf
join
keys
lastIndexOf
length
map
pop
push
reduce
reduceRight
reverse
shift
slice
some
sort
splice
toLocaleString
toString
unshift
數(shù)組的length屬性，返回數(shù)組的長度。
var array = new Array();
undefined
console.log(array.constructor);
VM576:1 ? Array() { [native code] }
undefined
console.log(array.constructor === Array);
VM615:1 true
undefined
constructor屬性返回對創(chuàng)建此對象的數(shù)組函數(shù)的引用，即是返回對象相對應(yīng)的構(gòu)造函數(shù)。
array.push(元素1，元素2，...)將一個或多個元素添加到數(shù)組的末尾，并返回新數(shù)組的長度。
array.unshift(元素1，元素2，...)將一個或多個元素添加到數(shù)組的開頭，并返回新數(shù)組的長度。
array.pop()從數(shù)組中刪除最后一個元素，并返回最后一個元素的值。
原始數(shù)組的最后一個元素被刪除。
array.shift()刪除數(shù)組的第一個元素，并返回第一個元素。
原始數(shù)組的第一個元素被刪除。
array.splice(start 第一個參數(shù)為指定開始修改的位置，如果超出了數(shù)組的長度就從末尾開始添加內(nèi)容，如果為負(fù)值，就從數(shù)組末尾開始的第幾位，從1開始計數(shù)， deleteCount第二個參數(shù)為，要刪除的元素的個數(shù)，是從start位置開始要刪除的元素個數(shù)，為0時表示不刪除元素，其后的參數(shù)為要加入的元素，從start位置開始，添加的元素。
數(shù)組轉(zhuǎn)為字符串
array.join('')
所有對象都具有toLocaleString()，toString()，valueOf()方法
var da = [1,23,4];
undefined
console.log(da.toString());
VM727:1 1,23,4
undefined
console.log(da.valueOf());
VM813:1 (3) [1, 23, 4]
undefined
console.log(da.toLocaleString());
VM861:1
undefined
toString()方法（toLocaleStirng方法），返回這個數(shù)組中每個值的字符串形式，拼接而成的一個以逗號分隔的字符串，valueOf()方法，返回的是數(shù)組本身。
當(dāng)有一個值為null或者是undefined時，在join()方法，toStirng()方法和valueOf()方法，toLocaleString()方法的返回則都是以空字符串表示。
字符串變化為數(shù)組
string.split(第一個參數(shù)為字符串或者是正則表達(dá)式，從該參數(shù)指定的地方對字符串進(jìn)行分割，第二個參數(shù)為指定返回的數(shù)組的最大長度)用于把一個字符串分割成字符串?dāng)?shù)組
數(shù)組的截取與合并
array.slice(start,end)方法，從數(shù)組中返回start下標(biāo)開始，直到end下標(biāo)結(jié)束（不包含），該方法不會改變原始數(shù)組，只會返回一個新的子數(shù)組。
var arr = [2,23,3,23];
undefined
array.slice(-1);
[]
console.log(arr);
VM1019:1 (4) [2, 23, 3, 23]
undefined
arr.slice(1,3)
(2) [23, 3]
console.log(arr);
VM1131:1 (4) [2, 23, 3, 23]
undefined
可以看出這個方法不會修改原始數(shù)組，只是會返回一個新的子數(shù)組，如果想要刪除數(shù)組中的元素，可以使用array.splice()。
數(shù)組的合并
array.concat()方法
sort()方法用于對數(shù)組的元素進(jìn)行排序，并返回原數(shù)組。
不帶參數(shù)，按照字符串UniCode碼的順序進(jìn)行排序。
const array = ['a', 'd', 'c', 'b'];
array.sort(); //['a', 'b', 'c', 'd']
按照數(shù)值大小進(jìn)行排序-升序
array.sort((a,b) => {
return a-b;
// 從小到大排序
});
按照數(shù)值大小進(jìn)行排序-降序
array.sort((a,b)=>{
return b-a;
// 從大到小排序
});
array.reverse()方法
reverse() 方法將數(shù)組中元素的位置顛倒，第一個數(shù)組元素成為最后一個數(shù)組元素，最后一個數(shù)組元素成為第一個。
數(shù)組的sort()和reverse()方法都對原數(shù)組進(jìn)行了修改，返回值是經(jīng)過排序之后的數(shù)組。
find(callback[, thisArg])方法，用于找出第一個符合條件的數(shù)組元素。
[1, 3, -5, 20].find((n) => n < 0)
// -5
findIndex(callback[, thisArg])返回第一個符合條件的數(shù)組成員的位置，如果所有成員都不符合條件，則返回-1。
[1, 3, 13, 25].findIndex(function(value, index, arr) {
return value > 9;
}) // 2
function f(value){
return value > this.age;
}
let person = {name: 'dada', age: 20};
[1, 12, 25, 5].find(f, person); // 25
includes(第一個參數(shù)為要查找的元素，第二個參數(shù)為開始查找的索引位置）方法，返回一個布爾值，表示是否存在給定值在該數(shù)組中。
array.filter()方法，array.every()方法檢測數(shù)組中的每個元素是否通過測試的，如果測試通過為true。
arr.some()判斷數(shù)組匯總是否包含可以通過測試的元素怒，和every不同的是，這里只要某一個元素通過測試，即返回true。
[2, 3, 15, 1, 4].some(item => item > 6);
// true
let a = [1, 2, 3, 4, 5];
let b = [];
a.forEach((item) => {
b.push(item + 1);
});
console.log(b); // [2,3,4,5,6]
keys()是對鍵名的遍歷、values()對鍵值的遍歷、entries()是對鍵值對的遍歷。
for(let item of ['a','b'].keys()){
consloe.log(item);
//0
//1
}
for(let item of ['a','b'].values()){
consloe.log(item);
//'a'
//'b'
}
let arr = [0,1];
for(let item of arr.entries()){
console.log(item);
// [0, 0]
// [1, 1]
}
const total = [0, 1, 2, 3].reduce((a, b) => {
return a + b;
}, 0);
// total is 6
const da = [[0, 1], [2, 3], [4, 5]].reduce((a, b) => {
return a.concat(b);
}, []);
// da is [0, 1, 2, 3, 4, 5]
Array.from()方法可以用來將json數(shù)組格式轉(zhuǎn)換為數(shù)組
let da = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
};
let arr = Array.from(da); // ['a', 'b', 'c']
Array.of()方法可以將一組值轉(zhuǎn)換為數(shù)組
let da = Array.of(1,2,3,4);
console.log(da);//[1,2,3,4]
console.log(...[1, 2, 3])
// 1 2 3
console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5
棧方法，隊列方法
數(shù)組的表示像棧一樣，棧是一種后進(jìn)先出的數(shù)據(jù)結(jié)構(gòu)。
棧中項的插入（叫做推入）和移除（叫做彈出），只發(fā)生在一個位置——棧的頂部。
push()方法可以接收任意數(shù)量的參數(shù)，在數(shù)組的末尾逐個添加，并返回修改后數(shù)組的長度，pop()方法可以從數(shù)組末尾移除最后一項，返回移除的項。
隊列方法
隊列數(shù)據(jù)結(jié)構(gòu)的訪問方法是先進(jìn)先出，隊列在列表末端添加項，從列表的前端移除項。
every()方法，傳入的函數(shù)必須對每一項返回true，才會返回true，否則它就返回false，some()方法則是只要傳入的函數(shù)對數(shù)組中的某項返回true，就會返回true。
Object對象具有的屬性
constructor
對創(chuàng)建對象的函數(shù)的引用（指針），對于Object對象，該指針指向原始的Object()函數(shù)。
Prototype
對該對象的對象原型 的引用，對于所有的對象，它默認(rèn)返回Object對象的一個實例。
方法：
hasOwnProperty(property)
判斷對象是否有某個特定的屬性，必須要字符串指定該屬性
IsPrototypeOf(object)
判斷該對象是否為另一個對象的原型
PropertyIsEnumerable
判斷給定的屬性是否可以用for...in語句進(jìn)行枚舉
toString()返回對象的原始字符串表示。
valuOf()方法返回最合適該對象的原始值。
reduce()方法從數(shù)組的第一項開始，逐個遍歷到最后。
reduceRight()方法從數(shù)組的最后一個項開始，向前遍歷到第一項。
JavaScript引用類型中的Date對象
Date 類型使用自 UTC（Coordinated Universal Time，國際協(xié)調(diào)時間）1970 年 1 月 1 日午夜（零時）開始經(jīng)過的毫秒數(shù)來保存日期。
創(chuàng)建Date對象，使用new 操作符和Date構(gòu)造函數(shù)：
var date = new Date();
var date = new Date("1178/08/06 04:20:00");
var date = new Date(154656847478617);
靜態(tài)方法，Date.now()方法返回當(dāng)前時間距離時間零點，1970年1月1日00:00:00UTC的毫秒數(shù)，相當(dāng)于Unix時間戳乘以1000。
getTime()方法
返回實例距離1970年1月1日00:00:00的毫秒數(shù)，等同于valueOf方法
Date類型使用UTC國際協(xié)調(diào)時間1970年1月1日午夜（零時）開始經(jīng)過的毫秒數(shù)來保存日期。如果調(diào)用Date構(gòu)造函數(shù)而不傳遞參數(shù)，則新創(chuàng)建的對象獲取的是當(dāng)前的日期和時間。
如果想要特定的日期和時間創(chuàng)建日期對象，傳入?yún)?shù)。
// 提供了兩個方法
Date.parse()
Date.UTC()
Date.parse()方法接收一個表示日期的字符串參數(shù)
var newDate = new Date(Date.parse('May 23, 2010'));
Date.UTC()方法返回表示日期的毫秒數(shù)。
getFullYear()
返回四位的年份
getMonth()
返回月份（0 ~ 11，0表示1月，11表示12月）
getDay()
返回星期幾，星期日為0，星期一為1，以此類推
getDate()
返回實例對象對應(yīng)每個月的幾號（從1開始）
getHours()
返回小時數(shù) （0 ~ 23）
getMinutes()
返回分鐘數(shù) （0 ~ 59）
getSeconds()
返回秒數(shù) （0 ~ 59）
getMilliseconds()
返回毫秒數(shù) （0 ~ 999）
setTime(milliseconds)
設(shè)置毫秒時間戳
setYear(year)
設(shè)置距離1900年的年數(shù)
setFullYear(year [, month, date])
設(shè)置四位年份
setMonth(month [, date])
設(shè)置月份（0-11）
setDate(date)
設(shè)置實例對象對應(yīng)的每個月的幾號（1-31），返回改變后毫秒時間戳
setHours(hour [, min, sec, ms])
設(shè)置小時（0-23）
setMinutes(min [, sec, ms])
設(shè)置分鐘（0-59）
setSeconds(sec [, ms])
設(shè)置秒（0-59）
setMilliseconds()
設(shè)置毫秒（0-999）
toDateString()
顯示格式星期幾，月，日，年
toTimeString()
顯示時，分，秒和時區(qū)
toLocalDateString()
顯示星期幾，月，日，和年
toLocaleTimeString()
顯示實現(xiàn)的格式顯示時，分，秒
toUTCString()
顯示完整的UTC日期
RegExp類型
ECMAScript 通過 RegExp 類型來支持正則表達(dá)式。
var expression = / pattern / flags ;
// 模式（pattern）部分可以是任何簡單或復(fù)雜的正則表達(dá)式
// 標(biāo)志（flags）用以標(biāo)明正則表達(dá)式的行為
g表示全局模式，即是模式將被應(yīng)用于所有字符串
i表示不區(qū)分大小寫模式
m表示多行模式
RegExp 構(gòu)造函數(shù)接收兩個參數(shù)：
一個是要匹配的字符串模式，一個是可選的標(biāo)志字符串。
RegExp實例方法
exec()方法，用于檢索字符串的正則表達(dá)式的匹配。
string，檢索的字符串，返回一個數(shù)組，沒有則返回null
/\d{2,4}/ //匹配2~4個數(shù)字
/\w{3}\d?/ //精確匹配三個單詞和一個可選的數(shù)字
函數(shù)，函數(shù)其實是對象，每個函數(shù)都是Function類型的實例。
韓式是定義一次就可以調(diào)用或者是執(zhí)行任意多次的一段代碼，通過函數(shù)可以封裝很多代碼塊，而且可以在任何地方，任何時候調(diào)用，函數(shù)本身沒有運行功能，只有調(diào)用才能運行。
函數(shù)實際上是對象，每個函數(shù)都是Function類型的實例
函數(shù)名是指向函數(shù)對象的指針，不會與某個函數(shù)綁定，使用不帶有圓括號的函數(shù)名是訪問函數(shù)指針，不是調(diào)用函數(shù)。
在函數(shù)中，有兩個特殊的對象，arguments和this。
function method() {
// 沒有參數(shù)的函數(shù)
console.log("da");
}
function method(name){
// 帶有參數(shù)的函數(shù)
console.log("da1");
}
函數(shù)聲明：
使用函數(shù)聲明語法
function method(name) {
return name;
}
使用變量初始化函數(shù)
var da = function(name){
return name;
}
使用function構(gòu)造函數(shù)
var da1 = new Function(name);
var add=new Function(‘num1’,’num2’,’return num1+num2’);
// 不推薦這種方式，因為會導(dǎo)致解析兩次代碼，
// 第一次解析常規(guī)ECMAscript代碼（全部代碼），
// 第二次解析傳入構(gòu)造函數(shù)中的字符串，從而影響性能。
參數(shù)，把函數(shù)的返回值作為參數(shù)傳遞，把函數(shù)本身作為參數(shù)傳遞。
var result=add(sum(10),10);
var result=add(sum,10);
//sum是一個函數(shù)
return返回值，函數(shù)也可以不帶有返回值，將返回undefined
函數(shù)名實際上也是一個指向函數(shù)對象的指針，不會與某個函數(shù)綁定。
定義函數(shù)，第一，使用函數(shù)聲明語法，第二，使用函數(shù)吧表達(dá)式，第三，使用function構(gòu)造函數(shù)。
函數(shù)聲明與函數(shù)表達(dá)式的區(qū)別
解釋器會先讀取函數(shù)聲明，在使其在執(zhí)行之前可以訪問。
函數(shù)聲明語法
function sum (num1, num2) {
return num1 + num2;
}
使用函數(shù)表達(dá)式則必須要等到解析器執(zhí)行到它所在的代碼行時，才會執(zhí)行，變量聲明提前，而值留在原地。
console.log(sum(10,10));
function sum(num1, num2){
return num1 + num2;
}
在代碼執(zhí)行前，解析器會通過函數(shù)聲明提升，讀取并將函數(shù)聲明添加到執(zhí)行環(huán)境中，放入到代碼樹的頂部。
console.log(sum(10,10)); // 報錯
var sum = function(num1, num2){
return num1 + num2;
};
此代碼函數(shù)位于一個初始化語句中，不是函數(shù)聲明，不會提前，會把var sum提前，也就是在執(zhí)行到函數(shù)所在語句之前，變量sum中不會保存對函數(shù)的引用。
函數(shù)是對象來著，函數(shù)名是指針。函數(shù)名僅僅是指向函數(shù)的指針，所以，一個函數(shù)對象可以有多個名字。
沒有重載的概念
function dada(num){
return num + 100;
}
function dada(num) {
return num + 200;
}
var result = dada(100); //300
// 后面的函數(shù)覆蓋了前面的函數(shù)
以上代碼實際上與下面的代碼沒有什么區(qū)別：
var da1= function (num){
return num + 100;
};
da1= function (num) {
return num + 200;
};
var result = da1(100); //300
函數(shù)作為參數(shù)傳遞給另一個函數(shù)
要訪問函數(shù)的指針而不執(zhí)行函數(shù)的話，必須去掉函數(shù)名后面的那對圓括號；從一個函數(shù)中返回另一個函數(shù)。
函數(shù)內(nèi)部的屬性
arguments是個類數(shù)組對象
傳入函數(shù)的所有參數(shù)，對象有一個叫callee的屬性，屬性值是一個指針，指向擁有arguments對象的函數(shù)本身。
this對象，指向函數(shù)執(zhí)行的環(huán)境對象，在哪個對象中執(zhí)行，就指向哪個對象。
caller屬性，保存著調(diào)用當(dāng)前函數(shù)的函數(shù)的引用
如果是在全局作用域中調(diào)用當(dāng)前函數(shù)，它的值為 null。
function outer(){
inner();
}
function inner(){
console.log(inner.caller);
}
outer();
/*輸出結(jié)果：
?unction outer(){
inner();
}
*/
prototype屬性：
是一個對象，通過調(diào)用構(gòu)造函數(shù)而創(chuàng)建的一個對象，可以由特定類型的所有實例共享的屬性和方法。
toString()方法將函數(shù)體轉(zhuǎn)換成對應(yīng)的字符串。
bind()方法：
會創(chuàng)建一個函數(shù)的實例，其 this 值會被綁定到傳給 bind() 函數(shù)的值。
apply()與call()方法
兩個方法的作用都是在特定的作用域中調(diào)用函數(shù)
實際上就是設(shè)置函數(shù)內(nèi)部的this值
apply()：接收兩個參數(shù)
一個是函數(shù)運行的作用域，
一個是參數(shù)數(shù)組，可以是數(shù)組，也可以是arguments這個類數(shù)組對象;
在使用 call()方法時，傳遞給函數(shù)的參數(shù)必須逐個列舉出來；
區(qū)別僅在于接收參數(shù)的方式不同。
apply() 和 call() 真正的本質(zhì)是用來，擴(kuò)充函數(shù)賴以運行的作用域。
基本包裝類型
為了便于操作基本數(shù)據(jù)類型，ECMAScript還提供了3個特殊的引用數(shù)據(jù)類型：Boolean、Number和String。
引用類型與基本包裝類型的區(qū)別，在于它們的對象生命周期不同：
引用類型：
使用new創(chuàng)建引用類型的實例，
在執(zhí)行數(shù)據(jù)流離開當(dāng)前作用域時會一直存儲在內(nèi)存中。
基本包裝類型：
自動創(chuàng)建基本包裝類型的對象，
只執(zhí)行一行代碼的瞬間之后就會立即銷毀。
這意味著在運行時為基本包裝類型值添加屬性和方法是無效的。
創(chuàng)建Boolean對象
// 定義了一個名為 da 的布爾對象
var da = new Boolean(true);
如果布爾對象無初始值或者其值為：0、-0、null、""、false、undefined、NaN，那么對象的值為false，否則，其值為true
在布爾表達(dá)式中，所有的對象都會被轉(zhuǎn)換為true。
引用類型的布爾值，其實是對象，所以在布爾表達(dá)式中使用Boolean 對象都會返回為true。
var da = new Boolean(false);
alert(typeof da); // object
var da1 = false;
alert(typeof da1); // boolean
var da = new Boolean(false);
alert(da instanceof Boolean); // true
var da1 = false;
alert(da1 instanceof Boolean); // false
toString()方法
功能：根據(jù)布爾值返回字符串 "true" 或"false"。
valueOf()方法
功能：返回 Boolean 對象的原始值，就是返回基本類型值
true 或 false。
創(chuàng)建Number對象
Number類型是數(shù)字值創(chuàng)建的引用類型。
var da = new Number(10);
toFixed()方法
Number類型的toFixed()方法可以接受一個數(shù)值，表示保留的小數(shù)的個數(shù)（會自動四舍五入）。
toString()方法
將Number數(shù)值轉(zhuǎn)換為字符串，該方法接受一個可選參數(shù)基數(shù)，告訴它返回幾進(jìn)制數(shù)值的字符串形式，若省略，則默認(rèn)基數(shù)為10，即十進(jìn)制。
valueOf()方法
valueOf()返回一個 Number 對象的基本數(shù)字值。
創(chuàng)建String對象
String類型是字符串值創(chuàng)建的引用類型。
var da = new String("hello world");
charAt()和 charCodeAt()兩個方法都接收一個參數(shù)
即基于 0 的字符位置
charAt()：
以單字符字符串的形式返回給定位置的那個字符
charCodeAt()：
返回給定位置的那個字符的字符編碼
截取字符串的方法：
slice()、substr()和 substring()
這三個函數(shù)，都不改變原本的字符串，只是在原先的字符串上創(chuàng)建了一個副本，返回操作副本后的值。
slice()
方法會將傳入的負(fù)值與字符串的長度相加
substr()
方法將負(fù)的第一個參數(shù)加上字符串的長度，而將負(fù)的第二個參數(shù)轉(zhuǎn)換為 0
substring()
方法會把所有負(fù)值參數(shù)都轉(zhuǎn)換為 0。
indexOf()
方法從索引 0 的位置開始查詢子字符串
lastIndexOf()
方法從最后一個索引開始查找字符串
trimLeft()和 trimRight()方法，
分別用于刪除字符串開頭和末尾的空格。
字符串大小寫轉(zhuǎn)換的方法：
toLowerCase()、toUpperCase()
var stringValue = "hello world";
alert(stringValue.toUpperCase());
//"HELLO WORLD"
alert(stringValue.toLowerCase());
//"hello world"
match()方法
var s = 'hello21 world21';
console.log(s.match(/\d{2}/));
// [ '21', index: 5, input: 'hello21 world21' ]
parseInt():轉(zhuǎn)換為整型；
parseFloat()：轉(zhuǎn)換為浮點型；
isNaN():判斷為是否不是數(shù)值；
encodeURI():對字符串進(jìn)行編碼；
decodeURI():
對encodeURI（）函數(shù)編碼過的字符串進(jìn)行解碼。
內(nèi)置對象:
ECMA-262對內(nèi)置對象是，由ECMAScript實現(xiàn)提供的，不依賴宿主環(huán)境的對象。
程序執(zhí)行之前就已經(jīng)存在了。不需要自己定義，不需要自己實例化。
定義了兩個內(nèi)置對象：Global和Math。
