ECMAScript標準では、配列はインデックスから値へのマップ（辞書）として規定されています。言い換えれば、配列は連続的でなくてもよく、穴があっても構いません。例：

> var arr = [];
> arr[0] = 'a';
'a'
> arr[2] = 'b';
'b'
> arr
[ 'a', , 'b' ]

上記の配列には穴があります。インデックス1には要素がありません。「配列の穴」で穴について詳しく説明します。

ほとんどのJavaScriptエンジンは、内部的に穴のない配列を最適化し、連続的に格納することに注意してください。

配列は依然としてオブジェクトであり、オブジェクトのプロパティを持つことができます。それらは実際の配列の一部とは見なされません。つまり、配列要素とは見なされません。

> var arr = [ 'a', 'b' ];
> arr.foo = 123;
> arr
[ 'a', 'b' ]
> arr.foo
123

コンストラクターArrayを使用するには、2つの方法があります。指定された長さの空の配列を作成するか、要素が指定された値である配列を作成できます。このコンストラクターでは、newはオプションです。（newなしで）通常の関数として呼び出すことは、コンストラクターとして呼び出すことと同じです。

> var arr = new Array(2);
> arr.length
2
> arr  // two holes plus trailing comma (ignored!)
[ , ,]

// The same as ['a', 'b', 'c']:
var arr1 = new Array('a', 'b', 'c');

> new Array(2)  // alas, not [ 2 ]
[ , ,]

> new Array(5.7)  // alas, not [ 5.7 ]
RangeError: Invalid array length

> new Array('abc')  // ok
[ 'abc' ]

要素に複数の次元が必要な場合は、配列をネストする必要があります。このようなネストされた配列を作成すると、最も内側の配列は必要に応じて成長できます。ただし、要素に直接アクセスする場合は、少なくとも外側の配列を作成する必要があります。次の例では、三目並べ用の3x3の行列を作成します。行列は（必要に応じて行を拡張するのではなく）データで完全に埋められています。

// Create the Tic-tac-toe board
var rows = [];
for (var rowCount=0; rowCount < 3; rowCount++) {
    rows[rowCount] = [];
    for (var colCount=0; colCount < 3; colCount++) {
        rows[rowCount][colCount] = '.';
    }
}

// Set an X in the upper right corner
rows[0][2] = 'X';  // [row][column]

// Print the board
rows.forEach(function (row) {
    console.log(row.join(' '));
});

出力は次のとおりです。

. . X
. . .
. . .

この例では、一般的なケースを示したかったのです。明らかに、行列が非常に小さく、固定された次元を持つ場合は、配列リテラルで設定できます。

var rows = [ ['.','.','.'], ['.','.','.'], ['.','.','.'] ];

in演算子は、オブジェクトが特定のキーを持つプロパティを持っているかどうかを検出します。ただし、配列に特定の要素インデックスが存在するかどうかを判断するためにも使用できます。例：

> var arr = [ 'a', , 'b' ];
> 0 in arr
true
> 1 in arr
false
> 10 in arr
false

プロパティの削除に加えて、delete演算子は配列要素も削除します。要素を削除すると穴が作成されます（lengthプロパティは更新されません）。

> var arr = [ 'a', 'b' ];
> arr.length
2
> delete arr[1]  // does not update length
true
> arr
[ 'a',  ]
> arr.length
2

配列の長さを短くして、末尾の配列要素を削除することもできます（詳細については「length」を参照）。穴を作成せずに要素を削除するには（つまり、後続の要素のインデックスがデクリメントされる）、Array.prototype.splice()を使用します（「要素の追加と削除（破壊的）」を参照）。この例では、インデックス1で2つの要素を削除します。

> var arr = ['a', 'b', 'c', 'd'];
> arr.splice(1, 2) // returns what has been removed
[ 'b', 'c' ]
> arr
[ 'a', 'd' ]

配列のインデックスは見た目どおりではありません。今まで、配列のインデックスは数値であると仮定していました。そして、それがJavaScriptエンジンが内部的に配列を実装する方法です。ただし、ECMAScript仕様では、インデックスは異なるものとして捉えられています。セクション15.4を言い換えると、

言い換えれば、仕様の世界では、括弧内のすべての値は文字列に変換され、数値であってもプロパティキーとして解釈されます。次のやり取りでこれを示します。

> var arr = ['a', 'b'];
> arr['0']
'a'
> arr[0]
'a'

配列インデックスであるためには、プロパティキーP（文字列！）は、次の計算の結果と等しくなければなりません。

つまり、配列インデックスは、32ビット範囲0 ≤ i < 2³²−1の文字列化された整数iでなければなりません。上限は、（前に引用したように）仕様で明示的に除外されています。最大長の予約済みです。この定義がどのように機能するかを確認するために、「ビット単位演算子による32ビット整数」の関数ToUint32()を使用しましょう。

まず、数値を含まない文字列は常に0に変換されます。これは、文字列化後、文字列と等しくありません。

> ToUint32('xyz')
0
> ToUint32('?@#!')
0

次に、範囲外の文字列化された整数も、完全に異なる整数に変換されます。これは、文字列化後、文字列と等しくありません。

> ToUint32('-1')
4294967295
> Math.pow(2, 32)
4294967296
> ToUint32('4294967296')
0

第三に、文字列化された非整数数値は整数に変換されます。これもまた異なります。

> ToUint32('1.371')
1

仕様では、配列インデックスに指数がないことも強制されています。

> ToUint32('1e3')
1000

また、先頭にゼロがないことも強制されています。

> var arr = ['a', 'b'];
> arr['0']  // array index
'a'
> arr['00'] // normal property
undefined

配列の長さを手動で増やしても、配列にほとんど影響はありません。穴が作成されるだけです。

> var arr = [ 'a', 'b' ];
> arr.length = 3;
> arr  // one hole at the end
[ 'a', 'b', ,]

最後の結果には末尾に2つのカンマがあります。これは、末尾のカンマがオプションであり、常に無視されるためです。

先ほど行った操作では、要素は追加されませんでした。

> countElements(arr)
2

ただし、lengthプロパティは、新しい要素を挿入する場所を示すポインターとして機能します。例：

> arr.push('c')
4
> arr
[ 'a', 'b', , 'c' ]

したがって、Arrayコンストラクターを使用して配列の初期長さを設定すると、完全に空の配列が作成されます。

> var arr = new Array(2);
> arr.length
2
> countElements(arr)
0

配列の長さを短くすると、新しい長さ以上のすべての要素が削除されます。

> var arr = [ 'a', 'b', 'c' ];
> 1 in arr
true
> arr[1]
'b'

> arr.length = 1;
> arr
[ 'a' ]
> 1 in arr
false
> arr[1]
undefined

function clearArray(arr) {
    arr.length = 0;
}

> var arr = [ 'a', 'b', 'c' ];
> clearArray(arr)
> arr
[]

arr = [];

> var a1 = [1, 2, 3];
> var a2 = a1;
> a1.length = 0;

> a1
[]
> a2
[]

> var a1 = [1, 2, 3];
> var a2 = a1;
> a1 = [];

> a1
[]
> a2
[ 1, 2, 3 ]

配列の最大長は2³²−1です。

> var arr1 = new Array(Math.pow(2, 32));  // not ok
RangeError: Invalid array length

> var arr2 = new Array(Math.pow(2, 32)-1);  // ok
> arr2.push('x');
RangeError: Invalid array length

配列のインデックスに割り当てることで、穴を作成できます。

> var arr = [];
> arr[0] = 'a';
> arr[2] = 'c';
> 1 in arr  // hole at index 1
false

配列リテラルで値を省略することでも、穴を作成できます。

> var arr = ['a',,'c'];
> 1 in arr  // hole at index 1
false

> [ 'a', ].length
1
> [ 'a', ,].length
2

このセクションでは、要素としての穴とundefinedの違いについて検討します。穴を読み取るとundefinedが返されるため、両者は非常によく似ています。

穴のある配列はスパースと呼ばれます。穴のない配列は密と呼ばれます。密な配列は連続しており、ゼロから始まり、length − 1で終わる各インデックスに要素があります。スパース配列と密な配列という、次の2つの配列を比較してみましょう。これら2つは非常によく似ています。

var sparse = [ , , 'c' ];
var dense  = [ undefined, undefined, 'c' ];

穴は、ほとんど同じインデックスに要素undefinedがあるようなものです。どちらの配列も同じ長さを持っています。

> sparse.length
3
> dense.length
3

しかし、スパース配列はインデックス0に要素を持っていません。

> 0 in sparse
false
> 0 in dense
true

forによる反復は、両方の配列で同じです。

> for (var i=0; i<sparse.length; i++) console.log(sparse[i]);
undefined
undefined
c
> for (var i=0; i<dense.length; i++) console.log(dense[i]);
undefined
undefined
c

forEachによる反復は、穴をスキップしますが、undefined要素はスキップしません。

> sparse.forEach(function (x) { console.log(x) });
c
> dense.forEach(function (x) { console.log(x) });
undefined
undefined
c

配列に関する操作の中には、穴を無視するものと、穴を考慮するものがあります。このセクションでは、詳細を説明します。

> ['a',, 'b'].forEach(function (x,i) { console.log(i+'.'+x) })
0.a
2.b

> ['a',, 'b'].every(function (x) { return typeof x === 'string' })
true

> ['a',, 'b'].map(function (x,i) { return i+'.'+x })
[ '0.a', , '2.b' ]

> ['a',, 'b'].filter(function (x) { return true })
[ 'a', 'b' ]

> ['a',, 'b'].join('-')
'a--b'
> [ 'a', undefined, 'b' ].join('-')
'a--b'

> ['a',, 'b'].sort()  // length of result is 3
[ 'a', 'b', ,  ]

> for (var key in ['a',, 'b']) { console.log(key) }
0
2

> function f() { return [].slice.call(arguments) }
> f.apply(null, [ , , ,])
[ undefined, undefined, undefined ]

> Array.apply(null, Array(3))
[ undefined, undefined, undefined ]

> Array.apply(null, [2])
[ , ,]

すでに見たように、filter()は穴を削除します。

> ['a',, 'b'].filter(function (x) { return true })
[ 'a', 'b' ]

任意の配列の穴をundefinedに変換するためのカスタム関数を使用します。

function convertHolesToUndefineds(arr) {
    var result = [];
    for (var i=0; i < arr.length; i++) {
        result[i] = arr[i];
    }
    return result;
}

関数の使用

> convertHolesToUndefineds(['a',, 'b'])
[ 'a', undefined, 'b' ]

数値の場合、単純にa-bを返すことができますが、これにより数値オーバーフローが発生する可能性があります。それを防ぐには、より冗長なコードが必要になります。

function compareCanonically(a, b) {
    if (a < b) {
        return -1;
    } else if (a > b) {
        return 1;
    } else {
        return 0;
    }
}

私はネストされた条件演算子が好きではありません。しかし、この場合、コードが非常に簡潔になるため、お勧めしたい誘惑にかられます。

function compareCanonically(a, b) {
    return a < b ? -1 : (a > b ? 1 : 0);
}

関数の使用

> [-1, -20, 7, 50].sort(compareCanonically)
[ -20, -1, 7, 50 ]

文字列の場合、String.prototype.localeCompareを使用できます（文字列の比較を参照）

> ['c', 'a', 'b'].sort(function (a,b) { return a.localeCompare(b) })
[ 'a', 'b', 'c' ]

パラメータcompareFunctionは、オブジェクトのソートにも役立ちます。

var arr = [
    { name: 'Tarzan' },
    { name: 'Cheeta' },
    { name: 'Jane' } ];

function compareNames(a,b) {
    return a.name.localeCompare(b.name);
}

比較関数としてcompareNamesを使用すると、arrはnameでソートされます。

> arr.sort(compareNames)
[ { name: 'Cheeta' },
  { name: 'Jane' },
  { name: 'Tarzan' } ]

このセクションで説明する各メソッドは、次のようになります。

arr.examinationMethod(callback, thisValue?)

このようなメソッドは、以下のパラメータを取ります。

そして、私が今説明したシグネチャを持つ検査メソッドです。

forEach() の潜在的な落とし穴の1つは、ループを早期に中断するために break や類似のものをサポートしていないことです。それが必要な場合は、some() を使用できます。

function breakAtEmptyString(strArr) {
    strArr.some(function (elem) {
        if (elem.length === 0) {
            return true; // break
        }
        console.log(elem);
        // implicit: return undefined (interpreted as false)
    });
}

some() は、中断が発生した場合に true を返し、それ以外の場合は false を返します。これにより、（for ループでは少しトリッキーな）反復が正常に終了したかどうかによって異なる反応をすることができます。

変換メソッドは入力配列を取り、出力配列を生成します。その間、コールバックが出力の生成方法を制御します。コールバックは、検査と同じシグネチャを持ちます。

function callback(element, index, array)

変換メソッドは2つあります。

縮約の場合、コールバックは異なるシグネチャを持ちます。

function callback(previousValue, currentElement, currentIndex, array)

パラメータ previousValue は、コールバックによって以前に返された値です。コールバックが最初に呼び出されるとき、2つの可能性があります（説明は Array.prototype.reduce() の場合です。reduceRight() との違いは括弧内に記載されています）。

縮約メソッドは2つあります。

reduce メソッドの別の見方は、それが n 項演算子 OP を実装しているということです。

OP1≤i≤n x_i

二項演算子 op2 の一連の適用を介して

(...(x₁ op2 x₂) op2 ...) op2 x_n

これは前のコード例で発生したことです。JavaScript の二項プラス演算子を介して、配列の n 項和演算子を実装しました。

例として、次の関数を介して 2 つの反復方向を調べてみましょう。

function printArgs(prev, cur, i) {
    console.log('prev:'+prev+', cur:'+cur+', i:'+i);
    return prev + cur;
}

予想どおり、reduce() は左から右に反復処理します。

> ['a', 'b', 'c'].reduce(printArgs)
prev:a, cur:b, i:1
prev:ab, cur:c, i:2
'abc'
> ['a', 'b', 'c'].reduce(printArgs, 'x')
prev:x, cur:a, i:0
prev:xa, cur:b, i:1
prev:xab, cur:c, i:2
'xabc'

そして、reduceRight() は右から左に反復処理します。

> ['a', 'b', 'c'].reduceRight(printArgs)
prev:c, cur:b, i:1
prev:cb, cur:a, i:0
'cba'
> ['a', 'b', 'c'].reduceRight(printArgs, 'x')
prev:x, cur:c, i:2
prev:xc, cur:b, i:1
prev:xcb, cur:a, i:0
'xcba'