Google Apps ScriptでのArrayオブジェクトの種類

Arrayオブジェクトは、複数のデータをまとめて扱うためのものです。Arrayオブジェクトを使うことで、データを配列に格納してとして処理速度を向上させることができます。

オブジェクト一覧

主なオブジェクトを紹介します。

メンバー	説明
concat(配列)	配列同士を結合します
copyWithin(対象の開始位置, コピー元の開始位置, コピー元の終了位置（省略可能）)	配列内の要素を他の位置にコピーします
entries()	配列の各要素とそのインデックスのペアを含む新しい配列イテレーターオブジェクトを返します
every(テスト関数, thisArg（省略可能）)	配列内の全ての要素が指定した関数を満たすかどうかを確認します
fill(値, 開始位置（省略可能）, 終了位置（省略可能）)	配列内の指定された部分を静的に指定した値で埋めます
filter(テスト関数, thisArg（省略可能）)	指定した関数を満たす要素を含む新しい配列を作成します
find(テスト関数, thisArg（省略可能）)	指定した関数を満たす最初の要素を返します
findIndex(テスト関数, thisArg（省略可能）)	指定した関数を満たす最初の要素のインデックスを返します
flat(深さ（省略可能）)	配列を指定された深さまで再帰的にフラット化します
flatMap(マッピング関数, thisArg（省略可能）)	各要素に関数を適用し、その結果を新しい配列にフラット化して返します
forEach(コールバック関数, thisArg（省略可能）)	配列の各要素に対して指定した関数を一度ずつ実行します
includes(値, 開始位置（省略可能）)	配列が特定の値を含んでいるかどうかを確認します
indexOf(値, 開始位置（省略可能）)	配列内の指定された値の最初のインデックスを返します
join(区切り文字)	配列の全要素を文字列に結合します
keys()	配列内の各インデックスを含む新しい配列イテレーターオブジェクトを返します
lastIndexOf(値, 開始位置（省略可能）)	配列内の指定された値の最後のインデックスを返します
map(マッピング関数, thisArg（省略可能）)	配列内の全ての要素に指定した関数を適用し、新しい配列を返します
pop()	配列の最後の要素を削除し、その要素を返します
push(値)	配列の末尾に一つまたは複数の要素を追加し、新しい配列の長さを返します
reduce(集約関数, 初期値（省略可能）)	配列の全要素に対して左から右へ指定した関数を適用し、単一の値を計算します
reduceRight(集約関数, 初期値（省略可能）)	配列の全要素に対して右から左へ指定した関数を適用し、単一の値を計算します
reverse()	配列の要素の順番を逆にします
shift()	配列の最初の要素を削除し、その要素を返します
slice(開始位置, 終了位置（省略可能）)	配列の一部を新しい配列として返します
some(テスト関数, thisArg（省略可能）)	配列内の少なくとも一つの要素が指定した関数を満たすかどうかを確認します
sort(比較関数（省略可能）)	配列の要素を並べ替えます
splice(開始位置, 削除する要素数, 追加する要素...)	配列から要素を削除または追加します
toLocaleString()	配列の要素をロケールに応じた文字列に変換します
toString()	配列とその要素を表す文字列を返します
unshift(値)	配列の先頭に一つまたは複数の要素を追加し、新しい配列の長さを返します
values()	配列の各要素の値を含む新しい配列イテレーターオブジェクトを返します
Symbol.iterator	配列のデフォルトのイテレーターを取得します
Symbol.species	派生オブジェクトの作成に使用されるコンストラクタを取得します
length	配列の要素数を示します

プログラミング例

具体的なプログラミング例を紹介します。

concat(配列) の例

function 配列を結合() {
  let 配列1 = [1, 2, 3];
  let 配列2 = [4, 5, 6];
  let 結果 = 配列1.concat(配列2);
  Logger.log(結果); // 出力: [1, 2, 3, 4, 5, 6]
}

copyWithin(対象の開始位置, コピー元の開始位置, コピー元の終了位置（省略可能）) の例

function 配列をコピー() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.copyWithin(0, 3);
  Logger.log(結果); // 出力: [4, 5, 3, 4, 5]
}

entries() の例

function 配列エントリを取得() {
  let 配列 = ['a', 'b', 'c'];
  let イテレーター = 配列.entries();
  for (let [インデックス, 値] of イテレーター) {
    Logger.log(`インデックス: ${インデックス}, 値: ${値}`);
  }
  // 出力:
  // インデックス: 0, 値: a
  // インデックス: 1, 値: b
  // インデックス: 2, 値: c
}

every(テスト関数, thisArg（省略可能）) の例

function 全要素をテスト() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.every(値 => 値 > 0);
  Logger.log(結果); // 出力: true
}

fill(値, 開始位置（省略可能）, 終了位置（省略可能）) の例

function 配列を埋める() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.fill(0, 2, 4);
  Logger.log(結果); // 出力: [1, 2, 0, 0, 5]
}

filter(テスト関数, thisArg（省略可能）) の例

function 配列をフィルタリング() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.filter(値 => 値 > 2);
  Logger.log(結果); // 出力: [3, 4, 5]
}

find(テスト関数, thisArg（省略可能）) の例

function 要素を見つける() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.find(値 => 値 > 3);
  Logger.log(結果); // 出力: 4
}

findIndex(テスト関数, thisArg（省略可能）) の例

function インデックスを見つける() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.findIndex(値 => 値 > 3);
  Logger.log(結果); // 出力: 3
}

flat(深さ（省略可能）) の例

function 配列をフラット化() {
  let 配列 = [1, [2, [3, 4]], 5];
  let 結果 = 配列.flat(2);
  Logger.log(結果); // 出力: [1, 2, 3, 4, 5]
}

flatMap(マッピング関数, thisArg（省略可能）) の例

function 配列をフラットマップ() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.flatMap(値 => [値, 値 * 2]);
  Logger.log(結果); // 出力: [1, 2, 2, 4, 3, 6]
}

forEach(コールバック関数, thisArg（省略可能）) の例

function 各要素に処理を適用() {
  let 配列 = [1, 2, 3];
  配列.forEach(値 => Logger.log(値));
  // 出力:
  // 1
  // 2
  // 3
}

includes(値, 開始位置（省略可能）) の例

function 値が含まれているか確認() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.includes(2);
  Logger.log(結果); // 出力: true
}

indexOf(値, 開始位置（省略可能）) の例

function 値のインデックスを取得() {
  let 配列 = [1, 2, 3, 2];
  let 結果 = 配列.indexOf(2);
  Logger.log(結果); // 出力: 1
}

join(区切り文字) の例

function 配列を結合して文字列にする() {
  let 配列 = ['a', 'b', 'c'];
  let 結果 = 配列.join('-');
  Logger.log(結果); // 出力: "a-b-c"
}

keys() の例

function 配列キーを取得() {
  let 配列 = ['a', 'b', 'c'];
  let キー = 配列.keys();
  for (let キー値 of キー) {
    Logger.log(キー値);
  }
  // 出力:
  // 0
  // 1
  // 2
}

lastIndexOf(値, 開始位置（省略可能）) の例

function 最後のインデックスを取得() {
  let 配列 = [1, 2, 3, 2];
  let 結果 = 配列.lastIndexOf(2);
  Logger.log(結果); // 出力: 3
}

map(マッピング関数, thisArg（省略可能）) の例

function 配列をマップ() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.map(値 => 値 * 2);
  Logger.log(結果); // 出力: [2, 4, 6]
}

pop() の例

function 最後の要素を削除() {
  let 配列 = [1, 2, 3];
  let 最後の要素 = 配列.pop();
  Logger.log(最後の要素); // 出力: 3
  Logger.log(配列); // 出力: [1, 2]
}

push(値) の例

function 要素を追加() {
  let 配列 = [1, 2];
  let 新しい長さ = 配列.push(3);
  Logger.log(新しい長さ); // 出力: 3
  Logger.log(配列); // 出力: [1, 2, 3]
}

reduce(集約関数, 初期値（省略可能）) の例

function 合計を計算() {
  let 配列 = [1, 2, 3, 4];
  let 結果 = 配列.reduce((累積, 値) => 累積 + 値, 0);
  Logger.log(結果); // 出力: 10
}

reduceRight(集約関数, 初期値（省略可能）) の例

function 右から合計を計算() {
  let 配列 = [1, 2, 3, 4];
  let 結果 = 配列.reduceRight((累積, 値) => 累積 + 値, 0);
  Logger.log(結果); // 出力: 10
}

reverse() の例

function 配列を逆順にする() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.reverse();
  Logger.log(結果); // 出力: [3, 2, 1]
}

shift() の例

function 最初の要素を削除() {
  let 配列 = [1, 2, 3];
  let 最初の要素 = 配列.shift();
  Logger.log(最初の要素); // 出力: 1
  Logger.log(配列); // 出力: [2, 3]
}

slice(開始位置, 終了位置（省略可能）) の例

function 部分配列を取得() {
  let 配列 = [1, 2, 3, 4, 5];
  let 結果 = 配列.slice(1, 4);
  Logger.log(結果); // 出力: [2, 3, 4]
}

some(テスト関数, thisArg（省略可能）) の例

function 要素が存在するか確認() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.some(値 => 値 > 2);
  Logger.log(結果); // 出力: true
}

sort(比較関数（省略可能）) の例

function 配列をソートする() {
  let 配列 = [3, 1, 4, 1, 5, 9];
  let 結果 = 配列.sort();
  Logger.log(結果); // 出力: [1, 1, 3, 4, 5, 9]
}

splice(開始位置, 削除する要素数, 追加する要素...) の例

function 要素を追加削除() {
  let 配列 = [1, 2, 3, 4];
  let 削除された要素 = 配列.splice(1, 2, 'a', 'b');
  Logger.log(削除された要素); // 出力: [2, 3]
  Logger.log(配列); // 出力: [1, 'a', 'b', 4]
}

toLocaleString() の例

function 配列をロケール形式に変換() {
  let 配列 = [1000, 2000, 3000];
  let 結果 = 配列.toLocaleString();
  Logger.log(結果); // 出力: "1,000,2,000,3,000"
}

toString() の例

function 配列を文字列に変換() {
  let 配列 = [1, 2, 3];
  let 結果 = 配列.toString();
  Logger.log(結果); // 出力: "1,2,3"
}

unshift(値) の例

function 要素を先頭に追加() {
  let 配列 = [2, 3];
  let 新しい長さ = 配列.unshift(1);
  Logger.log(新しい長さ); // 出力: 3
  Logger.log(配列); // 出力: [1, 2, 3]
}

values() の例

function 配列値を取得() {
  let 配列 = ['a', 'b', 'c'];
  let イテレーター = 配列.values();
  for (let 値 of イテレーター) {
    Logger.log(値);
  }
  // 出力:
  // a
  // b
  // c
}

Symbol.iterator の例

function イテレータを使ってループ() {
  let 配列 = ['x', 'y', 'z'];
  let イテレーター = 配列[Symbol.iterator]();
  let 次の要素 = イテレーター.next();
  while (!次の要素.done) {
    Logger.log(次の要素.value);
    次の要素 = イテレーター.next();
  }
  // 出力:
  // x
  // y
  // z
}

Symbol.species の例

function 新しいインスタンスを作成() {
  let 配列 = [1, 2, 3];
  let 配列種別 = 配列.constructor[Symbol.species];
  let 新しい配列 = new 配列種別(3);
  Logger.log(新しい配列); // 出力: [undefined, undefined, undefined]
}

length の例

function 配列の長さを取得() {
  let 配列 = [1, 2, 3, 4, 5];
  let 長さ = 配列.length;
  Logger.log(長さ); // 出力: 5
}

まとめ

Arrayオブジェクトのメソッドとプロパティは、配列の操作や管理に非常に便利です。配列に新しい要素を追加する方法や、並べ替え、要素の削除、検索など、よく使う操作を覚えておくと便利です。