在ActionScript 3中检测uint,int和Number之间的差异

Question

我想获得声明的类型我的号码,但我不知道如何获得它们.所以我用可能的检测方法编写了一个测试:

logNumber(Number(3.5), "Number");
logNumber(Number(3), "Number");
logNumber(Number(-3), "Number");
logNumber(uint(3), "uint")
logNumber(int(3), "int")
logNumber(int(-3), "int")

function logNumber(value:*, expected:String):void
{
    trace("\n\n\n ");
    trace("** Input value: " + value + "\n** Expected: " + expected + "\n")
    trace("getQualifiedClassName: ", getQualifiedClassName(value) + check(getQualifiedClassName(value), expected));

    switch (value)
    {
        case value as uint:
        {
            trace('as: uint' + check('uint', expected));
            break;
        }
        case value as int:
        {
            trace('as: int' + check('int', expected));
            break;
        }
        case value as Number:
        {
            trace('as: Number' + check('Number', expected));
            break;
        }
    }

    if(value is uint) trace("is: uint" + check('uint', expected));
    else if(value is int) trace("is: int" + check('int', expected));
    else if(value is Number) trace("is: Number" + check('Number', expected));

    trace("describeType name:" + describeType(value).@name + check(describeType(value).@name, expected));

    trace("typeof: ", typeof(value)  + check(typeof(value), expected));

    trace("\n" + describeType(value))
}

function check(type:String, expectedType:String):String
{
    return "\n  » " + (type == expectedType ? "good" : (type.toLowerCase() == expectedType.toLowerCase() ? "almost good" : "wrong"))
}

这会将以下结果输出到我的跟踪面板:

3.5作为数字

** Input value: 3.5
** Expected: Number

getQualifiedClassName:  Number
  » good
as: Number
  » good
is: Number
  » good
describeType name:Number
  » good
typeof:  number
  » almost good

<type name="Number" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

3作为数字

** Input value: 3
** Expected: Number

getQualifiedClassName:  int
  » wrong
as: uint
  » wrong
is: uint
  » wrong
describeType name:int
  » wrong
typeof:  number
  » almost good

<type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

-3作为数字

** Input value: -3
** Expected: Number

getQualifiedClassName:  int
  » wrong
as: int
  » wrong
is: int
  » wrong
describeType name:int
  » wrong
typeof:  number
  » almost good

<type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

3作为uint

** Input value: 3
** Expected: uint

getQualifiedClassName:  int
  » wrong
as: uint
  » good
is: uint
  » good
describeType name:int
  » wrong
typeof:  number
  » wrong

<type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

3为int

** Input value: 3
** Expected: int

getQualifiedClassName:  int
  » good
as: uint
  » wrong
is: uint
  » wrong
describeType name:int
  » good
typeof:  number
  » wrong

<type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

-3为int

** Input value: -3
** Expected: int

getQualifiedClassName:  int
  » good
as: int
  » good
is: int
  » good
describeType name:int
  » good
typeof:  number
  » wrong

<type name="int" base="Object" isDynamic="false" isFinal="true" isStatic="false">
  <extendsClass type="Object"/>
  <constructor>
    <parameter index="1" type="*" optional="true"/>
  </constructor>
</type>

分析很多,但有些事情正在突然出现:

• 如果一个数字等于3.5,它将作为数字输出,但如果它是3,它将作为int/uint输出.
• 很难检测它是否是uint或int,结果令人困惑且不一致.

出于调试目的(并且只是为了理解它是如何工作的),我想要我声明的类型.如何创建一个返回正确类型的函数？

Answer 1

我将解释为什么每个测试都会给你他们的结果.

如

var value:Number = 3;
trace(value as int); // 3

该as操作是弱铸造操作.它采用左手值并将其转换为右手类型,并作为结果进行评估.如果它不能进行演员表,则评估为null.在这种情况下,Number成功转换为a int,3随后评估结果.

var value:Number = 3.5;
trace(value as int); // null

在此示例中,3.5无法将值转换为int语句求值的值null.

是

var value:Number = 3.5;
trace(value is int); // false

该is运营商建立在as运营商,但计算结果为Boolean值,而不是投对象.上面的代码是一样的,

trace((value as int) != null)

所以为了你的目的,is并as完成大致相同的事情.他们都将左手值转换为右手值.转换类型与语句的值相关.

类型

var value:Number = 3;
trace(typeof value); // number

的typeof操作者是从JavaScript(其中ActionScript 3的是一个扩展)一个保存,和计算结果为StringJavaScript的的表示原始.因此,typeof在ActionScript 3类型系统中使用有限,因为它永远不会评估为ActionScript 3类名.例如,

var mc:MovieClip = new MovieClip();
trace(typeof mc); // object

var value:int = 3;
trace(typeof value); // number

MovieClip确实是一个Object,并且考虑到这一点,很明显为什么要typeof value评估number.ActionScript 3的延伸的JavaScript原始的Number与其自己的类型int和uint,该编译器然后强制和优化.这就是为什么在检查一个int或哪个uint是一个时会得到令人困惑的结果Number; 从技术上讲,他们是.ActionScript 3原语根本不是真正的原语,至少不是强类型语言.

的describeType

这些是我最不确定的结果,因为它不是语言功能而是Adobe功能.看看这个:

var value:Number = 3;
trace(describeType(value)); // int
value += 0.1;
trace(describeType(value)); // Number

似乎Flash Player正在优化value为int一个整数.这可能是因为它们可以进行性能优化,例如将a Number作为对象int的索引处理Array.这也很有趣:

var value:int = 3;
trace(describeType(value)); // int
value += 0.1;               // value is still 3
trace(describeType(value)); // int

在这种情况下,因为我们明确定义value为a int,编译器会避免运行时转换并忽略浮点运算.

结论

我认为没有一种好方法可以找到ActionScript 3基元的编译时类.这些操作员中的每一个都会告诉你你能做什么,而不是你做了什么.语言没有被打破; 它是动态的,但有时看似欺骗性.最重要的一点是,你不应该总是相信AS3中的类型系统能够做你想象的事情.有一个我能想到的解决方案,但ypu在使用uint或inton Array或者时会丢失所有的Adobe优化Vector.您可以创建自己的类型对象,并使用getQualifiedClassName或describeType在其上.

class UnsignedInteger
{
    private var v:uint = 0;

    public function UnsignedInteger(value:uint) { v = value }
    public function get value():uint { return v }
    public function set value(value:uint):void { v = value; }
 }

 var value:UnsignedInteger = new UnsignedInteger(3);
 trace(getQualifiedClassName(value)); // UnsignedInteger