Flashゲームプログラミング講座 for ActionScript3.0

 

Vector クラスとは?

 


■Vector クラスについて


Vector クラスは、配列を扱うためのクラスです。
 
すべての番地には、同じ型のデータを格納することができます。
 
■Array クラスとの違い
 
配列を扱うクラスとして、Array クラスがあります。
 
Array クラスには、以下の様な性質があります。
 
「マイナスの番地や、配列のサイズより大きい番地へも格納可能」
 
「どんな型のデータでも格納可能」
 
Vector クラスは、以下の様な性質があります。
 
「マイナスの番地や、配列のサイズより大きい番地へアクセスする事は不可能」
 
「配列の最後尾にデータを追加していくことは可能」
 
「すべての番地には、同じ型のデータのみ格納可能」
 
Array クラスと Vector クラスは、基本的に同じようなメソッドを使用する事ができます。
 
■利用に最適な場面
 
Vector クラスは、Array クラスより、高速にアクセスすることができます。
 
すべての番地に、同じ型のデータを格納する場合は、Vector クラスを使用するといいでしょう。
 
 

 

Vector オブジェクトを作成する

 
 


■ベース型について


Vector に格納可能なデータの型の事を、ベース型といいます。
 
ベース型を指定するには、「後置型パラメータシンタックス」を使用します。
 
「後置型パラメータシンタックス」は以下のように記述します。
 
後置型パラメータシンタックスの記述方法

Vector.< 型名 >
 

■Vector オブジェクトを作成する

 
new 演算子を使って、Vector クラスをインスタンス化します。
 
new Vector ( 初期の配列のサイズ , 配列のサイズを固定するか? ) :Vector
第01引数(略可)uint初期の配列のサイズを指定。デフォルトは 0
第02引数(略可)Booleantrue を指定すると配列のサイズを固定。デフォルトは false
戻り値 VectorVector オブジェクト
 
■第01引数 初期サイズ
 
初期サイズを指定すると、実際に内部で領域が確保されます
 
配列の中身は、0 や null などのデータで埋められます。
 
■第02引数 配列のサイズを固定するか?
 
true を指定すると、配列のサイズを固定することができます。
 
固定した場合、配列のサイズの変更を試みると、エラーとなります。
 
配列のサイズが変化するメソッドの呼び出しを試みると、エラーとなります。
 
■Vector オブジェクトの作成例
 
Boolean 型のデータを格納するための Vector オブジェクトを作成する

// Vector オブジェクトを作成する(Boolean 型)
var vector : Vector.<Boolean> = new Vector.<Boolean>();

vector[0] = true;
vector[1] = false;
vector[2] = true;
 
String 型のデータを格納するための Vector オブジェクトを作成する

// Vector オブジェクトを作成する(String 型)
var vector : Vector.<String> = new Vector.<String>();

vector[0] = "abc";
vector[1] = "def";
vector[2] = "ghi";
 
DisplayObject 型のデータを格納するための Vector オブジェクトを作成する

import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.MovieClip;

// Vector オブジェクトを作成する(DisplayObject 型)
var vector : Vector.<DisplayObject> = new Vector.<DisplayObject>();

vector[0] = new Sprite();
vector[1] = new MovieClip();
 
Vector3D 型のデータを格納するための Vector オブジェクトを作成する(初期サイズは 1024)(サイズは固定)

import flash.geom.Vector3D;

// Vector オブジェクトを作成する(Vector3D 型)(初期サイズは 1024) (サイズは固定)
var vector : Vector.<Vector3D> = new Vector.<Vector3D>(1024 , true);
 

■初期データを格納しつつ Vector オブジェクトを作成する


■Vector() 関数を使用する
 
初期データを格納しつつ Vector オブジェクトを作成するには、Vector() 関数を使用します。
 
引数に、Array オブジェクトか Vector オブジェクトを渡します。
 
Vector オブジェクトを作成しつつ Number 型のデータを格納する

// 初期データを格納しつつ Vector オブジェクトを作成する(Number 型)
var vector : Vector.<Number> = Vector.<Number>([0,123,456]);
 
■ベクターリテラルシンタックスコンストラクターを使用する(Adobe Flash CS5 以降)

以下のような構文を使って Vector オブジェクトを作成することもできます。
 
「Adobe Flash CS5.0」以降、「Flash Builder 4」以降、「Flex 4」以降で利用可能です。
 
構文を使って Vector オブジェクトを作成する

// 初期データを格納しつつ Vector オブジェクトを作成する(Number 型)
var vector : Vector.<Number> = new <Number>[0,123,456];
 

■配列のすべての番地のデータにアクセスする


■ 0 から順番にアクセスする
 
配列のサイズを取得するには、length プロパティを使用します。
 
for 文を使って、0 から順番にアクセスします。
 
0 から順番に、すべての番地のデータにアクセスする

// Vector オブジェクトを作成する(String 型)
var vector:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// 0 から順番に、すべての番地のデータにアクセスする
var i:uint;
var num:uint = vector.length;
for(i=0;i < num;i++){
	trace("---");
	trace("index:" + i);
	trace("data:" + vector[i]);
}
 
■ for..in 文を使用する
 
for..in 文を使って、アクセスする例です。
 
プロパティ名を取得できるので、配列アクセス演算子を使ってデータにアクセスします。
 
for..in 文を使用して、すべての番地のデータにアクセスする

// Vector オブジェクトを作成する(String 型)
var vector:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// for..in 文を使用して、すべての番地のデータにアクセスする
var key:String;
for (key in vector){
	trace("---");
	trace("index:" + key);
	trace("data:" + vector[key]);
}
 
■ for each..in 文を使用する
 
for each..in 文を使って、アクセスする例です。
 
データを直接取得することができます。
 
for each..in 文を使用して、すべての番地のデータにアクセスする

// Vector オブジェクトを作成する(String 型)
var vector:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// for each..in 文を使用して、すべての番地のデータにアクセスする
var data:String;
for each (data in vector){
	trace("data:" + data);
}
 


 

Vector クラスのプロパティについて

 


■Vector クラスのプロパティ


Vector クラスには、以下のプロパティがあります。
 
プロパティ 説明
length uint 配列のサイズ
fixed Boolean 配列のサイズを固定する
 
 


■length プロパティ


配列のサイズを取得するには、length プロパティを使用します。
 
配列のサイズを調べる

// Vector オブジェクトを作成する(Number 型)
var vector:Vector.<Number> = Vector.<Number>([0,1,2,3,4]);

// 配列のサイズを取得
var num:uint = vector.length;

// 出力テスト
trace(num);
 

■fixed プロパティ


配列のサイズを固定するには、fixed プロパティに、true をセットします。
 
固定した場合、配列のサイズの変更を試みると、エラーとなります。
 
配列のサイズが変化するメソッドの呼び出しを試みると、エラーとなります。
 
配列を作成して、サイズを固定する

// Vector オブジェクトを作成する(Number 型)(初期サイズは 10)
var vector:Vector.<Number> = new Vector.<Number>(10);

// 配列のサイズを固定する
vector.fixed = true;


try{
	// サイズを超える番地にアクセスを試みる
	vector[10] = 9;
}catch(e:Error){
	// エラーを出力
	trace(e);
}

try{
	// 配列の最後尾にデータの追加を試みる
	vector.push(0);
}catch(e:Error){
	// エラーを出力
	trace(e);
}
 


 

Vector クラスのメソッドについて

 


■Vector クラスのメソッド一覧


Vector クラスには、以下のメソッドがあります。
 
メソッド 説明
concat() 2つ以上の配列を繋げて、新しい配列を取得する。
unshift() 配列の最先頭に複数のデータを追加して、新しいサイズを取得する。
push() 配列の最後尾に複数のデータを追加して、新しいサイズを取得する。
shift() 配列の最先頭を削除して、格納されていたデータを取得する。
pop() 配列の最後尾を削除して、格納されていたデータを取得する。
slice() 配列の X 番目から Y 番目までを、新しい配列として取得する。
splice() 配列の X 番目から L 個分を削除して、新しい配列として取得する。
配列の X 番目から複数のデータを追加する。
sort() 配列をソートする。
reverse() 配列の順番を反転する。
join() 配列の各データの間に任意の文字列を挟み、すべて繋げたストリングを取得する。
indexOf() 配列の前から後へデータを検索し、一致した位置を取得する。
lastIndexOf() 配列の後から前へデータを検索し、一致した位置を取得する。
forEach() 関数を使用して、データを順番に調べる。(すべての番地のデータにアクセスする)
every() 関数を使用して、1つでも偽となるデータが存在するか調べる。(検証テスト用)
some() 関数を使用して、1つでも真となるデータが存在するか調べる。(検証テスト用)
filter() 関数を使用して、新しい配列を取得する。(データの抽出用)
map() 関数を使用して、新しい配列を取得する。(データの変換用)
 
 


■concat() メソッド

 
2つ以上の配列を繋げて、新しい配列を取得するには、concat() メソッドを使用します。
 
ベース型が違う場合、エラーとなります。
 
可変引数を使って複数の配列を指定した場合、コンパイル環境によっては、結合順序が反転します
 
Adobe Flash CS5.5 以降の場合、最先頭から最後尾の順番で結合されます。
 
Adobe Flash CS5.0 以前の場合、最後尾から最先頭の順番で結合されます。
 
互換性が気になる場合は、複数指定を使わずに2つずつ結合するといいでしょう。
 
Vector.concat( Vector ... ) :Vector
可変引数 Vector連結したい配列を指定。引数の最先頭から最後尾の順番で結合される。環境によっては順序が反転するので注意。
戻り値 Vector新しい配列
 
2つの配列を連結して、新しい配列を取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);
var b:Vector.<String> = Vector.<String>(["D","E","F"]);

// 2つの配列を連結して新しい配列を取得する
var c:Vector.<String> = a.concat(b);
 
 
4つの配列を連結して、新しい配列を取得する。(コンパイル環境によっては順序が反転するので注意)

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B"]);
var b:Vector.<String> = Vector.<String>(["C","D"]);
var c:Vector.<String> = Vector.<String>(["E","F","G"]);
var d:Vector.<String> = Vector.<String>(["H"]);

// 複数の配列を連結して新しい配列を取得する
var e:Vector.<String> = a.concat(b,c,d);

// 2つずつ結合する場合
//var e:Vector.<String>;
//e = a.concat(b);
//e = e.concat(c);
//e = e.concat(d);
 
通常の場合
 
 
順序が反転する場合
 
 

■unshift() メソッド

 
配列の最先頭に複数のデータを追加して、新しいサイズを取得するには、unshift() メソッドを使用します。
 
Vector.unshift( * ... ) :uint
可変引数 *追加したいデータを指定。引数の最先頭から最後尾の順番で追加される。
戻り値 uintデータ追加後のサイズ
 
配列の先頭に "D" を追加して、新しいサイズを取得する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);

// 配列の先頭にデータを追加して、新しいサイズを取得する
var num:uint = a.unshift("D");
 
 
配列の先頭に "D","E","F" を追加して、新しいサイズを取得する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);

// 配列の先頭に複数のデータを追加して、新しいサイズを取得する
var num:uint = a.unshift("D" ,"E" ,"F");
 
 

■push() メソッド

 
配列の最後尾に複数のデータを追加して、新しいサイズを取得するには、push() メソッドを使用します。
 
Vector.push( * ... ) :uint
可変引数 *追加したいデータを指定。引数の最先頭から最後尾の順番で追加される。
戻り値 uintデータ追加後のサイズ
 
配列の最後尾に "D" を追加して、新しいサイズを取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);

// 配列の最後尾にデータを追加して、新しいサイズを取得する
var num:uint = a.push("D");
 
 
配列の最後尾に "D","E","F" を追加して、新しいサイズを取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);

// 配列の最後尾に複数のデータを追加して、新しいサイズを取得する
var num:uint = a.push("D" ,"E" ,"F");
 
 

■shift() メソッド

 
配列の最先頭を削除して、格納されていたデータを取得するには、shift() メソッドを使用します。
 
Vector.shift() :*
引数 voidなし
戻り値 *配列の先頭に格納されていたデータ
 
配列の先頭を削除して、格納されていたデータを取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// 配列の最先頭を削除して、格納されていたデータを取得する
var b:String = a.shift();
 
 

■pop() メソッド

 
配列の最後尾を削除して、格納されていたデータを取得するには、pop() メソッドを使用します。
 
Vector.pop() :*
引数 voidなし
戻り値 *配列の最後尾に格納されていたデータ
 
配列の最後尾を削除して、格納されていたデータを取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D"]);

// 配列の最後尾を削除して、格納されていたデータを取得する
var b:String = a.pop();
 
 

■slice() メソッド

 
配列の開始位置と終了位置を指定して、新しい配列を取得するには、slice() メソッドを使用します。
 
第02引数で指定する終了位置は、取得対象に含まれません。
 
引数を省略した場合、配列全体の複製となります。
 
Vector.slice( 開始位置 , 終了位置 ) :Vector
第01引数(略可)int開始位置を指定。(0 から始まる番号)デフォルトは 0
第02引数(略可)int終了位置を指定。(0 から始まる番号)デフォルトは 16777215
マイナス値を指定すると「length + 第02引数」 の位置。(-1で最後尾は含まれない)
戻り値 Vector新しい配列
 
配列を複製する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C"]);

// 配列を複製する
var b:Vector.<String> = a.slice();
 
 
配列の 1 番目から 4 番目を、新しい配列として取得する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// 開始位置と終了位置を指定して、新しい配列を取得する
var b:Vector.<String> = a.slice(1, 5);
 
 

■splice() メソッド

 
指定した位置から、配列の削除と追加を行うには、splice() メソッドを使用します。
 
開始位置と個数を指定して、配列を削除する事ができます。
 
削除した範囲は、新しい配列として取得することができます。
 
特に削除しない場合は、第02引数に 0 を指定します。
 
開始位置から、新しいデータを追加することができます。
 
特にデータを追加しない場合は、第03引数以降を省略します。
 
Vector.splice( 開始位置 , 削除する個数 , * ... ) :Vector
第01引数(略可)int開始位置を指定。(0 から始まる番号)デフォルトは 0
第02引数(略可)uint削除する個数を指定。デフォルトは 4294967295
可変引数(略可)*追加したいデータを指定。第03引数から最後尾の順番で追加される。
戻り値 Vector削除した範囲を新しい配列として返す
 
配列の 3 番目から 2 個分を削除して、新しい配列として取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// 開始位置と個数を指定して配列を削除し、削除した範囲は新しい配列として取得する
var b:Vector.<String> = a.splice(3,2);
 
 
配列の 1 番目に、"G" を追加する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// 開始位置を指定し、データを追加する(第02引数に 0 を指定)
var b:Vector.<String> = a.splice(1,0,"G");
 
 
配列の 1 番目から 4 個分を削除して、新しい配列として追加する。配列の 1 番目から "G","H","I" を追加する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","F"]);

// 指定した位置から、配列の削除と追加を行う
var b:Vector.<String> = a.splice(1,4,"G","H","I");
 
 

■sort() メソッド

 
配列をソートするには、sort() メソッドを使用します。
 
以下の使用方法があります。
 
 

■sort() メソッド (定数を指定)

 
定数を指定して、配列をソートします。
 
Vector.sort( Array.* ) :Vector
第01引数 uintソート用の設定。Array.* 定数を論理和で指定。
戻り値 Vector配列の参照。
 
■第01引数 (ソート用の設定)
 
第01引数に、以下の定数を指定します。
 
プロパティ 数値 説明
Array.CASEINSENSITIVE 0x01 指定すれば、大文字と小文字を区別しません。
指定しなければ、大文字と小文字を区別します。
Array.DESCENDING 0x02 指定すれば、降順でソートします。
指定しなければ昇順でソートします。
Array.NUMERIC 0x10 指定すれば、数値として比較を試みます。
指定しなければ、文字列として比較を試みます。(コードは Unicode)
Array.UNIQUESORT 0x04 すべての番地にユニーク(唯一)なデータが格納されている場合に指定します。
同じデータがある場合ソートは行われません。
 
使用例です。
 
配列をソートする。(数値として比較)

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([2,4,1,3,0]);

// 配列をソートする(数値として比較)
a.sort(Array.NUMERIC);
 
 
配列をソートする。(文字列として比較)(大文字と小文字を区別する)

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["C","B","A","a","c","b"]);

// 配列をソートする(文字列として比較)(大文字と小文字を区別する)
a.sort(0);
 
 
配列をソートする。(数値として比較)(降順)

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([2,4,1,3,0]);

// 配列をソートする(数値として比較)(降順)
a.sort(Array.NUMERIC | Array.DESCENDING);
 
 

■sort() メソッド (コールバック関数を指定)

 
コールバック関数を指定して、配列をソートします。
 
Vector.sort( コールバック関数 ) :Vector
第01引数 Functionコールバック関数を指定。
戻り値 Vector配列の参照。
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数と第02引数から、任意の番地に格納されているデータが取得できます。
 
昇順にソートしたい場合は、
 
(第01引数 < 第02引数) となる場合、負の数 を返します。
 
(第01引数 == 第02引数) となる場合、0 を返します。
 
(第01引数 > 第02引数) となる場合、正の数 を返します。
 
降順にソートしたい場合は、
 
(第01引数 > 第02引数) となる場合、負の数 を返します。
 
(第01引数 == 第02引数) となる場合、0 を返します。
 
(第01引数 < 第02引数) となる場合、正の数 を返します。
 
使用例です。
 
数値として比較し配列をソートする。

// ------------------------------------------------------------
// ソート用コールバック関数(数値として比較)
// ------------------------------------------------------------
function VectorSortNumeric(prev:Number,next:Number):Number{
	return (prev - next);
}


// ------------------------------------------------------------
// 配列をソートする
// ------------------------------------------------------------
// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([2,4,1,3,0]);

// 配列をソートする(数値として比較)
a.sort(VectorSortNumeric);
 
 
文字列として比較し配列をソートする。

// ------------------------------------------------------------
// ソート用コールバック関数(文字列として比較)
// ------------------------------------------------------------
function VectorSortString(prev:String,next:String):Number{
	var i:uint = 0;
	while(true){
		var p:Number = prev.charCodeAt(i) || 0;
		var n:Number = next.charCodeAt(i) || 0;
		var s:Number = p - n;
		if(s) return s;
		if(!p) break;
		i++;
	}
	return 0;
}


// ------------------------------------------------------------
// 配列をソートする
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["C","E","B","D","A"]);

// 配列をソートする(文字列として比較)
a.sort(VectorSortString);
 
 
連番文字列として比較し配列をソートする。

// ------------------------------------------------------------
// ソート用コールバック関数(連番付き文字列として比較)
// ------------------------------------------------------------
function VectorSortSerialNumberString(prev:String,next:String):Number{
	var re:RegExp = new RegExp("^(.*?)([0-9]+)$","i");
	var p:Array = prev.match(re);
	var n:Array = next.match(re);
	if(p && n && (p[1] === n[1])){
		return parseInt(p[2]) - parseInt(n[2]);
	}
	return prev.localeCompare(next);
}


// ------------------------------------------------------------
// 配列をソートする
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["Ba","A64","B10","B2","A123","A0","A"]);

// 配列をソートする(連番付き文字列として比較)
a.sort(VectorSortSerialNumberString);
 
 

■reverse() メソッド

 
配列の順序を反転するには、reverse() メソッドを使用します。
 
Vector.reverse( ) :Vector
引数 voidなし
戻り値 Vector配列の参照。
 
配列の順番を反転する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// 配列を反転する
a.reverse();
 
 

■join() メソッド

 
配列の各データの間に任意の文字列を挟み、すべて繋げたストリングを取得するには、join() メソッドを使用します。
 
Vector.join( 任意の文字列 ) :String
第01引数 String配列の各データの間に挟む文字列を指定。デフォルトは ","
戻り値 String配列の各データの間に、第01引数で指定した文字列を挟み、すべて繋げたストリング。
 
配列の各データの間に任意の文字列を挟み、すべて繋げたストリングを取得する

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([0,1,2,3,4]);

// 各データの間に任意の文字列を挟み、すべて繋げたストリングを取得する
var str:String = a.join("-");
 
 
■toString() メソッド
 
配列の各データの間にカンマ『,』を挟み、すべて繋げたストリングを取得するには、toString() メソッドや、toLocaleString() メソッドを使用します。
 
配列の各データの間にカンマを挟み、すべて繋げたストリングを取得する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// 各データの間にカンマを挟み、すべて繋げたストリングを取得する
var str:String = a.toString();
 
 

■indexOf() メソッド

 
配列の前から後へデータを検索し、一致した位置を取得するには、indexOf() メソッドを使用します。
 
Vector.indexOf( 検索データ , 開始位置 ) :int
第01引数 *検索したいデータを指定
第02引数(略可)int検索を開始する位置を指定。(0 から始まる番号)デフォルトは 0。
マイナス値を指定すると「length + 第02引数」 の位置。(-1 で最後尾)
戻り値 int第01引数で指定したデータと厳密な等価(===)で一致した位置。存在しない場合は -1。
 
配列の前から後へデータを検索し、一致した位置を取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","A","B","C"]);

// 配列の前から後へデータを検索し、一致した位置を取得する
var pos:int = a.indexOf("B",0);

// 検索結果
if(pos >= 0){
	trace("検索結果:" + pos);
}else{
	trace("見つからない");
}
 

■lastIndexOf() メソッド

 
配列の後から前へデータを検索し、一致した位置を取得するには、lastIndexOf() メソッドを使用します。
 
Vector.lastIndexOf( 検索データ , 開始位置 ) :int
第01引数 *検索したいデータを指定
第02引数(略可)int検索を開始する位置を指定。(0 から始まる番号)デフォルトは 0x7fffffff。
マイナス値を指定すると「length + 第02引数」の位置。(-1 で最後尾)
戻り値 int第01引数で指定したデータと厳密な等価(===)で一致した位置。存在しない場合は -1。
 
配列の後から前へデータを検索し、一致した位置を取得する。

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E","A","B","C"]);

// 配列の後から前へデータを検索し、一致した位置を取得する
var pos:int = a.lastIndexOf("B",-1);

// 検索結果
if(pos >= 0){
	trace("検索結果:" + pos);
}else{
	trace("見つからない");
}
 

■forEach() メソッド

 
コールバック関数を使用して、データを順番に調べるには、forEach() メソッドを使用します。
 
このメソッドは、途中で終了できません。
 
全ての番地のデータにアクセスしたい時に使用します。
 
Vector.forEach( コールバック関数 , thisのアクセス先 ) :void
第01引数 Functionコールバック関数を指定
第02引数(略可)*コールバック関数内で this のアクセス先となるオブジェクトを指定。デフォルトは null
戻り値 voidなし
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数から、データを取得できます。(ベース型)
 
第02引数から、番地を取得できます。
 
第03引数から、配列の参照が取得できます。
 
戻り値はありません。
 
使用例です。
 
コールバック関数を使用して、データを順番に調べる。

// ------------------------------------------------------------
// コールバック関数
// ------------------------------------------------------------
function VectorForEachFunc(item:String,index:int,vector:Vector.<String>):void{
	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);
}


// ------------------------------------------------------------
// データを順番に調べる
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データを順番に調べる
a.forEach(VectorForEachFunc);
 
コールバック関数を使用して、データを順番に調べる。

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([111,222,333,444,555]);

// データを順番に調べる
a.forEach(function (item:Number,index:int,vector:Vector.<Number>):void{

	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);

},stage);
 

■every() メソッド

 
コールバック関数を使用して、検証テストを行うには、every() メソッドを使用します。
 
1つでも偽となるデータが存在するか、調べたい時に使用します。
 
Vector.every( コールバック関数 , thisのアクセス先 ) :Boolean
第01引数 Functionコールバック関数を指定
第02引数(略可)*コールバック関数内で this のアクセス先となるオブジェクトを指定。デフォルトは null
戻り値 Booleanコールバック関数から false を返した場合は false。それ以外は、true
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数から、データを取得できます。(ベース型)
 
第02引数から、番地を取得できます。
 
第03引数から、配列の参照が取得できます。
 
true を返すと、検証処理を継続して行います。
 
false を返すと、その時点で検証処理を終了します
 
使用例です。
 
コールバック関数を使用して、データを順番に調べる。

// ------------------------------------------------------------
// コールバック関数
// ------------------------------------------------------------
function VectorEveryFunc(item:String,index:int,vector:Vector.<String>):Boolean{

	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);

	// 何らかのチェック
	if(false){
		// 検証処理を終了する
		return false;
	}

	// 検証処理を継続する
	return true;
}


// ------------------------------------------------------------
// データの検証テストを行う
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データの検証テストを行う
var result:Boolean = a.every(VectorEveryFunc);
 
配列内のデータが、すべてプラス値であるか調べる

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([0,1,2,-3,4]);

// データの検証テストを行う
var result:Boolean = a.every(function (item:Number,index:int,vector:Vector.<Number>):Boolean{

	// マイナスのデータが見つかった
	if(item < 0){

		// 検証処理を終了する
		return false;
	}

	// 検証処理を継続する
	return true;
});

// 結果を出力
trace("配列内のデータは、すべてプラス値である:" + result);
 

■some() メソッド

 
コールバック関数を使用して、検証テストを行うには、some() メソッドを使用します。
 
1つでも真となるデータが存在するか、調べたい時に使用します。
 
Vector.some( コールバック関数 , thisのアクセス先 ) :Boolean
第01引数 Functionコールバック関数を指定
第02引数(略可)*コールバック関数内で this のアクセス先となるオブジェクトを指定。デフォルトは null
戻り値 Booleanコールバック関数から true を返した場合は true。それ以外は、false
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数から、データを取得できます。(ベース型)
 
第02引数から、番地を取得できます。
 
第03引数から、配列の参照が取得できます。
 
true を返すと、その時点で検証処理を終了します
 
false を返すと、検証処理を継続して行います。
 
使用例です。
 
コールバック関数を使用して、データを順番に調べる。

// ------------------------------------------------------------
// コールバック関数
// ------------------------------------------------------------
function VectorSomeFunc(item:String,index:int,vector:Vector.<String>):Boolean{

	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);

	// 何らかのチェック
	if(false){
		// 検証処理を終了する
		return true;
	}

	// 検証処理を継続する
	return false;
}


// ------------------------------------------------------------
// データの検証テストを行う
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データの検証テストを行う
var result:Boolean = a.some(VectorSomeFunc);
 
配列内のデータに、マイナス値が1つでも含まれるか調べる

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([0,1,2,-3,4]);

// データの検証テストを行う
var result:Boolean = a.some(function (item:Number,index:int,vector:Vector.<Number>):Boolean{

	// マイナスのデータが見つかった
	if(item < 0){

		// 検証処理を終了する
		return true;
	}

	// 検証処理を継続する
	return false;
});

// 結果を出力
trace("配列内のデータに、マイナス値が1つでも含まれる:" + result);
 

■filter() メソッド

 
コールバック関数を使用して、新しい配列を取得するには、filter() メソッドを使用します。
 
データを順番に調べて、任意のデータを抽出することができます。
 
Vector.filter( コールバック関数 , thisのアクセス先 ) :Vector
第01引数 Functionコールバック関数を指定
第02引数(略可)*コールバック関数内で this のアクセス先となるオブジェクトを指定。デフォルトは null
戻り値 Vector新しい配列
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数から、データを取得できます。(ベース型)
 
第02引数から、番地を取得できます。
 
第03引数から、配列の参照が取得できます。
 
true を返すと、データを抽出対象に含めます
 
false を返すと、データを抽出対象から除外します。
 
使用例です。
 
コールバック関数を使用して、データを順番に調べる。

// ------------------------------------------------------------
// コールバック関数
// ------------------------------------------------------------
function VectorFilterFunc(item:String,index:int,vector:Vector.<String>):Boolean{

	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);

	// 何らかのチェック
	if(true){
		// データを抽出対象に含める
		return true;
	}

	// データを抽出対象に含めない
	return false;
}


// ------------------------------------------------------------
// データを抽出する
// ------------------------------------------------------------
// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データを抽出し、新しい配列を取得する
var b:Vector.<String> = a.filter(VectorFilterFunc);
 
配列内から、マイナス値のデータを抽出する

// Vector オブジェクトを作成する(Number 型)
var a:Vector.<Number> = Vector.<Number>([0,-1,2,-3,4]);

// データを抽出し、新しい配列を取得する
var b:Vector.<Number> = a.filter(function (item:Number,index:int,vector:Vector.<Number>):Boolean{

	// マイナスのデータが見つかった
	if(item < 0){

		// データを抽出対象に含める
		return true;
	}

	// データを抽出対象に含めない
	return false;
});
 
 

■map() メソッド

 
コールバック関数を使用して、新しい配列を取得するには、map() メソッドを使用します。
 
配列内のデータを、別のデータに変換することができます。
 
変換後のデータは、ベース型と同一の型である必要があります。
 
このメソッドは、コンパイル環境によっては、動作しないようです
 
Adobe Flash CS6.0 以降の場合、戻り値から、新しい配列が得られます。
 
Adobe Flash CS5.5 以前の場合、戻り値から、null が得られます。
 
Vector.map( コールバック関数 , thisのアクセス先 ) :Vector
第01引数 Functionコールバック関数を指定
第02引数(略可)*コールバック関数内で this のアクセス先となるオブジェクトを指定。デフォルトは null
戻り値 Vector新しい配列を返す。コンパイル環境によっては、null を返す。
 
■第01引数 (コールバック関数)
 
コールバック関数の仕様です。
 
第01引数から、データを取得できます。(ベース型)
 
第02引数から、番地を取得できます。
 
第03引数から、配列の参照が取得できます。
 
戻り値から、変換後のデータを返します。(ベース型と同一の型)
 
使用例です。
 
コールバック関数を使用して、データを変換する。

// ------------------------------------------------------------
// コールバック関数
// ------------------------------------------------------------
function VectorMapFunc(item:String,index:int,vector:Vector.<String>):String{

	trace("---");
	trace("index:" + index);
	trace("data:" + item);
	trace("this:" + this);

	// 変換後のデータを返す
	return ("convert_" + item);
}


// ------------------------------------------------------------
// データを変換する
// ------------------------------------------------------------
// Vector オブジェクトを作成する(Number 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データを変換し、新しい配列を取得する
var b:Vector.<String> = a.map(VectorMapFunc);
 
文字列を小文字に変換する

// Vector オブジェクトを作成する(String 型)
var a:Vector.<String> = Vector.<String>(["A","B","C","D","E"]);

// データを変換し、新しい配列を取得する
var b:Vector.<String> = a.map(function (item:String,index:int,vector:Vector.<String>):String{

	// 小文字に変換
	var lower:String = item.toLocaleLowerCase();

	// 変換後のデータを返す
	return lower;
});