摘要：方法由于構造函數創建數組時的怪異行為，比方說如下方法總會創建一個包含所有參數的數組方法不通過屬性確定返回值的類型，它使用當前構造函數，也就是方法中的值來確定正確的返回數據的類型方法以前總是使用將類數組轉換成數組方法可接受可迭代對象或類數組對

由于Array構造函數創建數組時的怪異行為，比方說如下：

let items = new Array(2)
console.log(items.length)//2
items = new Array("2")
console.log(items.length)//1

Array.of方法總會創建一個包含所有參數的數組

let items = Array.of(1, 2)
console.log(items.length)//2
console.log(items[0])//1

Array.of方法不通過Symbol.species屬性確定返回值的類型，它使用當前構造函數，也就是of方法中的this值來確定正確的返回數據的類型

以前總是使用Array.prototype.slice.call(arrayLike)將類數組轉換成數組
Array.from方法可接受可迭代對象或類數組對象，最終返回一個數組
Array.from也是通過this來確定返回數組的類型
Array.from接受第二個參數，表示映射函數，第三個參數表示映射函數中的this的值
來看幾個例子：

function translate() {
    return Array.from(arguments, (value) => value + 1)
}
let numbers = translate(1, 2, 3)
console.log(numbers) //2、3、4

let helper={
    diff:1,
    add(value){
        return value+this.diff
    }
}
function translate(){
    return Array.from(arguments,helper.add,helper)
}
let numbers = translate(1, 2, 3)
console.log(numbers) //2、3、4

看看用Array.from轉換可迭代對象

let numbers = {
    *[Symbol.iterator]() {
        yield 1;
        yield 2;
        yield 3;
    }
}
let numbers2 = Array.from(numbers, value => value + 1)
console.log(numbers2) //2、3、4

find方法和findIndex方法都接受兩個參數，一個是回調函數，另外一個是可靠參數用于指定回調函數中this的值

let numbers = [25, 30, 35, 40, 45]
console.log(numbers.find(n => n > 35))//40
console.log(numbers.findIndex(n => n > 35))//3

如果要在數組中根據某個條件查找匹配的元素，那么find方法和findIndex方法可以很好的完成任務，但是如果只想查找與某個值匹配的元素，則indexOf和lastIndexOf應該是更好的選擇

fill方法可以用指定的值填充一至多個數組元素，當傳入一個值時，fill方法會用這個值重寫數組中的所有值
fill方法的第二個參數表示開始索引，第三個參數作為不包含結束索引，如果沒有傳第三個參數則默認使用numbers.length作為不包含結束索引
如果開始索引和結束索引為負值，那么這些值會與數組的length屬性相加為作為最終位置

調用copyWithin方法時需要傳入兩個參數，一個是方法開始填充值的索引位置，另一個是開始復制值的索引位置，第三個參數為可選參數，用來限制被重寫元素的數量，也就是指定停止復制值的位置

let numbers = [1, 2, 3, 4]
numbers.copyWithin(2, 0, 1)
console.log(numbers)//1,2,1,4

跟fill方法一樣，copyWithin方法的所有參數都接受負數值，并且會自動與數組長度相加來作為最終使用的索引

JS中數字是以64位浮點格式存儲并按需轉換成32位整數
數組緩沖區是所有定型數組的根基，數組緩沖區包含的實際字節數量在創建時就已確定，可以修改緩沖區內的數據，但是不能修改緩沖區的尺寸大小

let buffer = new ArrayBuffer(10)
let buffer2 = buffer.slice(4, 6)
console.log(buffer2.byteLength)//2

數組緩沖區是內存中的一段地址，視圖是用來操作內存的接口，視圖可以操作數組緩沖區或緩沖區字節的子集，并按照其中一種數值型數據類型來讀取和寫入數據

let buffer = new ArrayBuffer(10),
    view1 = new DataView(buffer),
    view2 = new DataView(buffer, 5, 2);
console.log(view1.buffer === buffer)//true
console.log(view2.byteOffset)//5
console.log(view2.byteLength)//2

事實上你可以寫入兩個int8類型的值，然后使用int16類型的方法從緩沖區中讀出這些值

let buffer = new ArrayBuffer(10),
    view = new DataView(buffer);
view.setInt8(0, 5)
view.setInt8(1, -1)
console.log(view.getInt8(0))//5

定型數組實際上就是用于數組緩沖區的特定類型的視圖，你可以強制使用特定的數據類型，而不是通過使用通用的DataView對象來操作數組緩沖區
創建定型數組的方式

1、 通過數組緩沖區來生成定型數組的實例

let buffer = new ArrayBuffer(10),
    view = new Int8Array(buffer);
console.log(view.byteLength)

2、通過構造函數中傳入一個數字，這個數字表示分配給數組的元素數量

let ints = new Int32Array(10);
console.log(ints.byteLength)//20
console.log(ints.length)//10

調用定型數組的構造函數時如果不傳參數，會按照傳入0來處理，這樣由于緩沖區沒有分配到任何比特，因為創建的定型數組不能用來保存數據

可以將定型數組、可迭代對象、數組、類數組對象作為構造函數的參數傳入

let ints1 = new Int16Array([25, 50]),
    ints2 = new Int32Array(ints1);
console.log(ints1.buffer === ints2.buffer)//false
console.log(ints1.length)//2
console.log(ints2.byteLength)//8
console.log(ints2.length)//2
console.log(ints2[0])//25
console.log(ints2[1])//50

每個定型數組中元素大小指的是每個元素表示的字節數，該值存儲在每個構造函數和每個實例中BYTES_PER_ELEMENT屬性中

console.log(Uint32Array.BYTES_PER_ELEMENT)

相同點：
1、可以修改length屬性來改變普通數組的大小，而定型數組的length屬性是一個不可寫屬性，所以不能修改定型數組的大小，如果嘗試修改這個值，在非嚴格模式下會直接忽略該操作，在嚴格模式下會拋出錯誤
2、定型數組也包括許多在功能上與普通數組方法等效的方法，但是定型數組中的方法會額外的檢查數值類型是否安全
比方說：copyWithin、findIndex、lastIndexOf、slice、entries、forEach、map、some、fill、indexOf、reduce、sort、filter、join、reduceRight、values、find、keys、reverse
3、相同的迭代器(也就是keys、values、entries)，這意味著可以把定型數組當作普通數組一樣來使用展開運算符、for of 循環

let ints = new Int16Array([25, 50]),
    intsArray = [...ints];
console.log(intsArray instanceof Array)//true
console.log(intsArray[0])//25

4、所有定型數組都包含有靜態of方法和from方法（也就是Array.of和Array.from)
差異點：
1、定型數組不是普通數組，它不繼承自Array，通過Array.isArray方法檢測定型數組返回的是false

let ints = new Int16Array([25, 50])
console.log(ints instanceof Array)//false
console.log(Array.isArray(ints))//false

2、當操作普通數組時，其可以變大變小，但定型數組卻始終保持相同的尺寸。給定型數組中不存在的數值索引賦值會被忽略，而在普通數組中就可以

let ints = new Int16Array([25, 50]);
console.log(ints.length);//2
console.log(ints[0])//25
console.log(ints[1])//50
ints[2]=5;
console.log(ints.length)//2
console.log(ints[2])//undefined

定型數組同樣會檢查數據類型的合法性，0被用于代替所有非法值；所有修改定型數組值的就去執行時都會受到相同限制

let ints = new Int16Array(["hi"])
console.log(ints.length)//1
console.log(ints[0])//0

3、以下方法在定型數組中不可使用，concat、shift、pop、splice、push、unshift
因為上述列表中除concat外，所有方法都可以改變數組的尺寸，由于定型數組的尺寸不可更改，因而這些方法不適用于定型數組，之所以concat不行是因為兩個定型數組合并后的結果會變得不確定
4、定型數組新的附加方法set和subarray
set方法將其它數組復制到已有的定型數組
subarray提取已有定型數組的一部分作為一個新的定型數組

set方法接受兩個參數：一個是數組（定型數組或普通數組都支持），一個是可選的偏移量，表示開始插入數據的位置，如果什么都不傳，默認的偏移量是0

let ints = new Int16Array(4);
ints.set([25, 50])
ints.set([75, 100], 2)
console.log(ints)//[25, 50, 75, 100]

subarray方法接受兩個參數：一個是可選的開始位置，一個是可選的結束位置（不包含當前結束位置的值 ），最后返回一個新的定型數組，也可以省略這兩個參數來克隆一個新的定型數組

let ints = new Int16Array([25, 50, 75, 100]),
    subInts = ints.subarray(1, 3);
console.log(subInts)//[50, 75]