Flash 字典（）as3_Flash_Actionscript 3

Flash 字典（）as3

flash actionscript-3

Flash 字典（）as3,flash,actionscript-3,Flash,Actionscript 3,我使用字典变量来匹配拖放练习 var dict = new Dictionary (); dict[box_a]=s1; dict[box_b]=s2; dict[box_c]=s3; dict[box_d]=s4; 问题1：最后，我想检查带有s1的复选框a==是否，依此类推。。。。我该怎么做 for each( var item in dict) { item.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler

我使用字典变量来匹配拖放练习

var dict = new Dictionary ();
dict[box_a]=s1;
dict[box_b]=s2;
dict[box_c]=s3;
dict[box_d]=s4;

问题1：最后，我想检查带有s1的复选框a==是否，依此类推。。。。我该怎么做

for each( var item  in dict)
    {   item.removeEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
        item.removeEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
    if(item==????)
// what do i have to put instead of ???
    hits=hits+1;

问题2：我希望box_d也接受s3，我会怎么做如果我这样做 dict[box_d]=s4；和dict[box_d]=s3；它不起作用，因为它与最后一个相等项相匹配(

谢谢！！

似乎只有基元类型才能检查相等性，用

==

替换

运算符不会改变任何内容：

        var dict:Dictionary = new Dictionary();
        dict['ololo1'] = { one : 1, two : '2' };
        dict[ { one : 1, two : '2' } ] = function(o:*):String { return o as String; };
        dict[function(o:*):String { return o as String; }] = 'ololo';
        dict['ololo2'] = 'ololo2';
        dict[{ one : 1, two : '2' }] = { one : 1, two : '2' };
        for (var key:* in dict) {
            trace(key, dict[key], key == dict[key]); 
        }
        trace('equal functions :', (function(o:*):String { return o as String; } === 
                                    function(o:*):String { return o as String; } ));
        trace('equal objects :', ({ one : 1, two : '2' } === 
                                  { one : 1, two : '2' } ));
        trace('equal functions :', (function(o:*):String { return o as String; } == 
                                    function(o:*):String { return o as String; } ));
        trace('equal objects :', ({ one : 1, two : '2' } == 
                                  { one : 1, two : '2' } ));

        var obj:Object = { one : 1, two : '2' };
        var obj1:Object = { one : 1, two : '2' };
        var fun:Function = function(o:*):String { return o as String; };
        var fun1:Function = function(o:*):String { return o as String; };
        trace(obj == { one : 1, two : '2' }, 
              obj == obj1,
              fun == function(o:*):String { return o as String; },
              fun == fun1);

输出

[object Object] [object Object] false
function Function() {} ololo false
[object Object] function Function() {} false
ololo2 ololo2 true
ololo1 [object Object] false
equal functions : false
equal objects : false
equal functions : false
equal objects : false
false false false false

但是，

obj==obj

true

；）

似乎只能对基本类型检查相等性，用

==

替换

运算符不会改变任何内容：

        var dict:Dictionary = new Dictionary();
        dict['ololo1'] = { one : 1, two : '2' };
        dict[ { one : 1, two : '2' } ] = function(o:*):String { return o as String; };
        dict[function(o:*):String { return o as String; }] = 'ololo';
        dict['ololo2'] = 'ololo2';
        dict[{ one : 1, two : '2' }] = { one : 1, two : '2' };
        for (var key:* in dict) {
            trace(key, dict[key], key == dict[key]); 
        }
        trace('equal functions :', (function(o:*):String { return o as String; } === 
                                    function(o:*):String { return o as String; } ));
        trace('equal objects :', ({ one : 1, two : '2' } === 
                                  { one : 1, two : '2' } ));
        trace('equal functions :', (function(o:*):String { return o as String; } == 
                                    function(o:*):String { return o as String; } ));
        trace('equal objects :', ({ one : 1, two : '2' } == 
                                  { one : 1, two : '2' } ));

        var obj:Object = { one : 1, two : '2' };
        var obj1:Object = { one : 1, two : '2' };
        var fun:Function = function(o:*):String { return o as String; };
        var fun1:Function = function(o:*):String { return o as String; };
        trace(obj == { one : 1, two : '2' }, 
              obj == obj1,
              fun == function(o:*):String { return o as String; },
              fun == fun1);

输出

[object Object] [object Object] false
function Function() {} ololo false
[object Object] function Function() {} false
ololo2 ololo2 true
ololo1 [object Object] false
equal functions : false
equal objects : false
equal functions : false
equal objects : false
false false false false

但是，

obj==obj

true

；）

介绍字典是键/值的集合，类似于表：

+------+--------+
| key1 | value1 |
+------+--------+
| key2 | value2 |
+------+--------+
| key3 | value3 |
+------+--------+
| key4 | value4 |
+------+--------+

要访问值，必须使用键，即：

dict[key2]

value2

答复1：您不能直接访问密钥，但可以使用

for（）

语句访问密钥，因此：

for (var key:* in dict) {
    trace('dict[' + key + '] = ' + dict[key]);
}

for each (var value:* in dict) {
    trace(value);
}

将输出以下内容：

dict[key1] = value1
dict[key2] = value2
dict[key3] = value3
dict[key4] = value4

value1
value2
value3
value4

对于每个（）语句，您都使用了一个

。对于该特定语句，您将得到另一个结果，因为您正在迭代值而不是键，因此：
for (var key:* in dict) {
    trace('dict[' + key + '] = ' + dict[key]);
}

for each (var value:* in dict) {
    trace(value);
}

将输出以下内容：
dict[key1] = value1
dict[key2] = value2
dict[key3] = value3
dict[key4] = value4

value1
value2
value3
value4

因此，如果您想使用密钥检查某些内容，必须使用for（key in dict）
表单
答复2：
我建议您使用如下数组：
dict[box_a] = [s1];
dict[box_b] = [s2];
dict[box_c] = [s3];
dict[box_d] = [s3, s4];

然后以数组形式访问这些值，并检查所有值：
for (var key:* in dict) {
    var values:Array = dict[key];
    for each (var value:* in values) {
        // do what you want with s1, s2, s3, etc
    }
}

简介
字典是键/值的集合，类似于表：
+------+--------+
| key1 | value1 |
+------+--------+
| key2 | value2 |
+------+--------+
| key3 | value3 |
+------+--------+
| key4 | value4 |
+------+--------+

要访问值，必须使用键，即：dict[key2]
返回value2

答复1：
您不能直接访问密钥，但可以使用for（）
语句访问密钥，因此：
for (var key:* in dict) {
    trace('dict[' + key + '] = ' + dict[key]);
}

for each (var value:* in dict) {
    trace(value);
}

将输出以下内容：
dict[key1] = value1
dict[key2] = value2
dict[key3] = value3
dict[key4] = value4

value1
value2
value3
value4

对于每个（）

语句，您都使用了一个

。对于该特定语句，您将得到另一个结果，因为您正在迭代值而不是键，因此：
for (var key:* in dict) {
    trace('dict[' + key + '] = ' + dict[key]);
}

for each (var value:* in dict) {
    trace(value);
}

将输出以下内容：
dict[key1] = value1
dict[key2] = value2
dict[key3] = value3
dict[key4] = value4

value1
value2
value3
value4

因此，如果您想使用密钥检查某些内容，必须使用for（key in dict）
表单
答复2：
我建议您使用如下数组：
dict[box_a] = [s1];
dict[box_b] = [s2];
dict[box_c] = [s3];
dict[box_d] = [s3, s4];

然后以数组形式访问这些值，并检查所有值：
for (var key:* in dict) {
    var values:Array = dict[key];
    for each (var value:* in values) {
        // do what you want with s1, s2, s3, etc
    }
}

什么是s*变量（s1、s2等）？您是否没有在代码中保留对它们的引用（您正在创建它们，并且没有将引用存储在dict
变量之外的任何位置）？你能为你正在做的事情提供更多的上下文（更多的代码）吗？s*变量（s1、s2等）是什么？您是否没有在代码中保留对它们的引用（您正在创建它们，并且没有将引用存储在dict
变量之外的任何位置）？你能为你正在做的事情提供更多的上下文（更多的代码）吗？非常感谢你的解释！！如果我需要查看框a中的对象是否为s1，我会怎么做？对于（var key:*in dict）{If（key==dict[key]）{hits=hits+1；}}}P.s这些键和dict[key]都是movieclipsy，你应该这样做：key==dict[key]，如果你想知道键的值是否就是键本身。谢谢你的精彩解释！！如果我需要查看框a中的对象是否为s1，我会怎么做？对于（var key:*in dict）{If（key==dict[key]）{hits=hits+1；}}}P.s这些键和dict[key]都是movieclipsys，如果你想知道键的值是否是键本身，你应该这样做：key==dict[key]。