同样，我们可以在循环使用这个范围我们的我变量。您的code可以进行更新，以这样的：

 函数createMarkers（mapLocations）{
    VAR markerArray：阵列=新的Array（）;
    对于（VAR I = 0; I＆LT; mapLocations.length;我++）{
        markerArray.push（新的标记（））;
        markerArray [I] .X = mapLocations [Ⅰ] [1];
        markerArray [I] .Y = mapLocations [I] [2];

        markerArray [I] .markerText.text = mapLocations [I] [0]的ToString（）;
        markerArray [I] .addEventListener（MouseEvent.CLICK，（函数（scopedI）{
                返回功能（E：的MouseEvent）{clickTarget（即scopedI）; };
            }）（一世））;
        bgImage.addChild（markerArray [I]）;
    }
}

功能clickTarget（E：的MouseEvent，A）{
    微量（一）;
}
 

现在， scopedI 将是唯一的每个迭代。是的，语法是有点乱，但这最终被语言的一个非常强大和前pressive功能。如果你能理解它，它是非常有用。

Could somebody possibly explain why the trace below returns the length of the array rather than the value of the "i" in the array item?

Many thanks, Nick

AS3

function createMarkers(mapLocations){
    var markerArray:Array = new Array();
    for(i=0; i<mapLocations.length; i++){
        markerArray.push(new marker());
        markerArray[i].x=mapLocations[i][1];
        markerArray[i].y=mapLocations[i][2];

        markerArray[i].markerText.text = mapLocations[i][0].toString();
        markerArray[i].addEventListener(MouseEvent.CLICK, function(e:MouseEvent){clickTarget(e,i);});
        bgImage.addChild(markerArray[i]);
    }
}

function clickTarget(e:MouseEvent,a){
    trace(a);
}

This is a common mistake when dealing with JavaScript/ActionScript functions. You're having the problem because functions are closures, which means they hold references to the variables defined in scope when the functions are defined.

This means that your anonymous handler function closes around the i variable, but it stores a reference to it, not its value. Since i changes, every function holds a reference to the same variable, which will just hold the last value assigned to it.

Basically, if you want to close around a variable's specific value, you have to declare the variable (using the var statement) within the function's scope. Because of that, this might look like it should work:

for (var i:int = 0; i < 10; i++) {
    var scopedI:int = i;
    mc[i].addEventListener(MouseEvent.CLICK, function (e:MouseEvent) { trace(scopedI); });
}

We declare a new variable, scopedI, within the loop's scope to close around that value specifically, since that variable will be redeclared every iteration of the loop with a unique value. Unfortunately, ActionScript, like JavaScript, does not have block-level scope, only function level scope, so all variable declarations are "hoisted" to the top of the function.

This pretty much just means that your scopedI type has the same scope as i, as well as any other variable declared inside that function. So, how can we create a new scope? With more functions. Keep in mind that in ActionScript, functions are objects, so we can do crazy things like this:

(function (id) {
    return function () { trace(id); };
})(7);

That bit of code creates a function, then immediately executes it with a value of 7 for the id parameter. This is useful, because now id is scoped to the inner function which we return, so that function will always print "7", no matter what happens externally.

Likewise, we can use this to scope our i variable in the loop. Your code could be updated to look like this:

function createMarkers(mapLocations){
    var markerArray:Array = new Array();
    for(var i = 0; i < mapLocations.length; i++){
        markerArray.push(new marker());
        markerArray[i].x = mapLocations[i][1];
        markerArray[i].y = mapLocations[i][2];

        markerArray[i].markerText.text = mapLocations[i][0].toString();
        markerArray[i].addEventListener(MouseEvent.CLICK, (function (scopedI) {
                return function (e:MouseEvent) { clickTarget(e, scopedI); };
            })(i));
        bgImage.addChild(markerArray[i]);
    }
}

function clickTarget(e:MouseEvent, a){
    trace(a);
}

Now, scopedI will be unique for each iteration. Yes, the syntax is a little bit messy, but this ends up being an extremely powerful and expressive feature of the language. If you can understand it, it's immensely useful.