I have a base class called Room and a subclass called Attic, and another called Basement.
I have a controller class that has an attribute called CurrentLocation which is type Room. The idea is I want to be able to put Attic or Basement in that property and get it back, then cast that to whatever type it is.
So if on the controller the content is of type Attic, I'm trying to figure out how to explicitly cast it. I thought I knew but its not working... Here's what I thought it would be, borrowing from Java:
var myAttic:Attic = (Attic) Controller.CurrentLocation;
This gives me a syntax error:
1086: Syntax error: expecting semicolon before instance.
So how do you cast implicitly? Or can you? I could swear I've done this before as as3.
Here are your options for casting in ActionScript 3:
Use as.
var myAttic:Attic = Controller.CurrentLocation as Attic; // Assignment.
(Controller.CurrentLocation as Attic).propertyOrMethod(); // In-line use.
This will assign null to myAttic if the cast fails.
Wrap in Type().
var myAttic:Attic = Attic(Controller.CurrentLocation); // Assignment.
Attic(Controller.CurrentLocation).propertyOrMethod(); // In-line use.
This throws a TypeError if the cast fails.
Related
I have seen quite a bunch of codes casting objects from one type to another type, using what I call the "standard" casting, like this:
var myDO:DisplayObject = loader.content;
var myCastedMC:MovieClip = MovieClip(myDO);
However the as operator seems to work the same way, because when I traced both objects I get the same value:
var myAsMC:MovieClip = myDO as MovieClip;
trace(myAsMC,myCastedMC); //both outputs read [object MainTimeline]
So, what is the difference between these two? When do yo use the as operator and when do you use the "standard" casting?
You cast only when you are certain the cast will succeed. If casting fails a runtime error is thrown.
You use 'as' to produce a soft cast that will never throw an error. In that case either the cast succeed or the default value of the datatype is returned (for most object that is null).
Both casts are meant to be used in very different situations but since they are misunderstood often you will see 'as' being used when the coder really meant a direct cast.
If following a cast the coder will not check or need to check if the cast has succeeded then it should have used a direct cast. If following a cast the coder needs to check if the cast has succeeded, he should use 'as'.
It should be explained why hitman answer is not correct. The provided code assume success:
(getChildAt(i) as TextField).text=i.toString();
Meaning coder knows the display list only contains TextField object (or else an error will occur). In that case a direct cast is recommended:
TextField(getChildAt(i)).text = i.toString();
If the display list contains other object types then 'as' can be used:
var field:TextField = getChildAt(i) as TextField;
if(field)//if null then getChildAt(i) is not a TextField
{
//field exist so cast succeeded
}
Good question!
on of their differences is that casting is conversion at compile and "as" is converting at runtime.and one of others is that you can only convert subclasses to superclasses.but "as" converts anything.
let's have an example:
let's say we have a lot of textfields on stage and we don't have them in variables or an array.and we want to change their text by a loop:
for(var i:uint=0;i<numChildren;i++){
var t:TextField=getChildAt(i)
t.text=i.toString();
}
probably you see an error because getChildAtreturns displayObject and displayObject doesn't have text property!
so you must use as here:
for(var i:uint=0;i<numChildren;i++){
(getChildAt(i) as TextField).text=i.toString();
}
H☻pes this helps!
I'm learning Dart and was reading the article Using Dart with JSON Web Services, which told me that I could get help with type checking when converting my objects to and from JSON. I used their code snippet but ended up with compiler warnings. I found another Stack Overflow question which discussed the same problem, and the answer was to use the #proxy annotation and implement noSuchMethod. Here's my attempt:
abstract class Language {
String language;
List targets;
Map website;
}
#proxy
class LanguageImpl extends JsonObject implements Language {
LanguageImpl();
factory LanguageImpl.fromJsonString(string) {
return new JsonObject.fromJsonString(string, new LanguageImpl());
}
noSuchMethod(i) => super.noSuchMethod(i);
}
I don't know if the noSuchMethod implementation is correct, and #proxy seems redundant now. Regardless, the code doesn't do what I want. If I run
var lang1 = new LanguageImpl.fromJsonString('{"language":"Dart"}');
print(JSON.encode(lang1));
print(lang1.language);
print(lang1.language + "!");
var lang2 = new LanguageImpl.fromJsonString('{"language":13.37000}');
print(JSON.encode(lang2));
print(lang2.language);
print(lang2.language + "!");
I get the output
{"language":"Dart"}
Dart
Dart!
{"language":13.37}
13.37
type 'String' is not a subtype of type 'num' of 'other'.
and then a stacktrace. Hence, although the readability is a little bit better (one of the goals of the article), the strong typing promised by the article doesn't work and the code might or might not crash, depending on the input.
What am I doing wrong?
The article mentions static types in one paragraph but JsonObject has nothing to do with static types.
What you get from JsonObject is that you don't need Map access syntax.
Instead of someMap['language'] = value; you can write someObj.language = value; and you get the fields in the autocomplete list, but Dart is not able to do any type checking neither when you assign a value to a field of the object (someObj.language = value;) nor when you use fromJsonString() (as mentioned because of noSuchMethod/#proxy).
I assume that you want an exception to be thrown on this line:
var lang2 = new LanguageImpl.fromJsonString('{"language":13.37000}');
because 13.37 is not a String. In order for JsonObject to do this it would need to use mirrors to determine the type of the field and manually do a type check. This is possible, but it would add to the dart2js output size.
So barring that, I think that throwing a type error when reading the field is reasonable, and you might have just found a bug-worthy issue here. Since noSuchMethod is being used to implement an abstract method, the runtime can actually do a type check on the arguments and return values. It appears from your example that it's not. Care to file a bug?
If this was addressed, then JsonObject could immediate read a field after setting it to cause a type check when decoding without mirrors, and it could do that check in an assert() so that it's only done in checked mode. I think that would be a nice solution.
Is there any difference of use, efficiency or background technique between
var mc:MovieClip = MovieClip(getChildByName("mc"));
and
var mc:MovieClip = getChildByName("mc") as MovieClip;
?
The choice is just matter of convention, preference or are there cases where you can't use one?
This article describes the differences well:
A key difference between casting and the as operator is the behavior
on failure. When a cast fails in ActionScript 2, null is returned.
When a cast fails in ActionScript 3, a TypeError is thrown. With the
as operator in ActionScript 3, whenever a cast fails the default value
for the datatype is returned.
as also allows you to cast to Array, which wasn't possible before since the conversion function Array() took precedence.
EDIT: concerning performance, using as is reported to be faster than the function call style casting in various articles: [1] [2] [3]. The first article cited looks at the performance differences in depth and reports that as is 4x-4.5x faster.
EDIT 2: Not only is as 4x-4.5x faster in the normal best case, but when you wrap the (cast) style conversion in a try-catch block, and an error actually ends up being thrown, it's more like 30x - 230x faster. In AS3, if you think you're going to do something exceptional (in that it could throw an error) then it's clear that you should always look before you leap. Never use try/catch unless forced to by the API, and indeed that means to never (cast) It also is instructive to look at the performance implications of try/catch even when no exception is thrown. There's a performance penalty to setting up a try/catch block even in the happy case that nothing goes wrong.
Since nobody answered the performance aspect directly yet, and it was in your question, as is dramatically more efficient and faster at runtime than (cast) in AS3.
http://jacksondunstan.com/articles/830
Combined with all the other factors I see absolutely no reason to ever use (cast) and feel it should be avoided completely.
Retracted comment below actually reminds me of a good point as well in regards to this. If you (cast) then you're almost assuredly going to find yourself in a situation where you'll have to try/catch
try{
SubType(foo).bar();
}catch(e:TypeError){
// Can't cast to SubType
}
Which is murderously slow. The only way around that is an is check first
if(foo is SubType){
SubType(foo).bar();
}
Which just seems wrong and wasteful.
AS3 Casting one type to another contains the answer that answers this as well: the "as" keyword assigns null when the conversion fails, otherwise it throws a TypeError.
It is best practice to use the as keyword.
as has the advantage of not throwing an RTE (run-time error). For example, say you have a class Dog that cannot be cast into a MovieClip; this code will throw an RTE:
var dog:Dog = new Dog();
var mc:MovieClip = MovieClip(Dog);
TypeError: Error #1034: Type Coercion failed: cannot convert Dog to MovieClip.
In order for you to make this code "safe" you would have to encompass the cast in a try/catch block.
On the other hand, as would be safer because it simply returns null if the conversion fails and then you can check for the errors yourself without using a try/catch block:
var dog:Dog = new Dog();
var mc:MovieClip = Dog as MovieClip;
if (mc)
//conversion succeeded
else
//conversion failed
Prefer the use of a cast to the use of the as operator. Use the as operator only if the coercion might fail and you want the expression to evaluate to null instead of throwing an exception.
Do this:
IUIComponent(child).document
Not this:
(child as IUIComponent).document
Coding Conventions
(cast) and "as" are two completely different things. While 'as' simply tells the compiler to interpret an object as if it were of the given type (which only works on same or subclasses or numeric/string conversions) , the (cast) tries to use a static conversion function of the target class. Which may fail (throwing an error) or return a new instance of the target class (no longer the same object). This explains not only the speed differences but also the behavior on the Error event, as described by Alejandro P.S.
The implications are clear:
'as' is to be used if the class of an object is known to the coder but not to the compiler (because obfuscated by an interface that only names a superclass or '*'). An 'is' check before or a null check after (faster) is recommended if the assumed type (or a type compatible to auto-coercion) cannot be 100% assured.
(cast) is to be used if there has to be an actual conversion of an object into another class (if possible at all).
var mc:MovieClip = MovieClip(getChildByName("mc"));
will DIRECTLY SET IT AS movieclip
var mc:MovieClip = getChildByName("mc") as MovieClip;
will make mc act like a movieclip, if required type are same
Further to launch or not RTE, or return null, there is a significant difference when we manage errors in a swf loaded into a separate application domain.
Using Loader.uncaughtErrorEvents to handle errors of the loaded swf; if we cast like 'event.error as Error', the resulting error will have the original stack trace (the same that had been caught in the swf that caused the error) while if cast that with Error (event.error), the stack trace of the error will be changed by the current stack trace (in which the cast was made).
Sample Code:
if (event && event.error && event.error is Error) {
debug ("Casting with 'as Error'")
debugStackTrace (event.error as Error);
debug ("casting with 'Error (...)'");
debugStackTrace (Error (event.error));
}
Sample output:
Casting with 'as Error'
ReferenceError: Error # 1056
at Player / onEnterFrame ()
casting with 'Error (...)'
Error: ReferenceError: Error # 1056
at package :: HandlerClass / uncaughtErrorHandler ()
at EventInfo / listenerProxy ()
Reading up on ComboBox component → Link
The last code example has this line request.url = ComboBox(evt.target).selectedItem.data;
What does ComboBox(evt.target) mean? Type casting? Why would you type cast?
For curiosity reasons, I replaced the last line of changeHandler() with it too: ComboBox(evt.target).selectedIndex = -1;. It works. Does it make the handler function more flexible, since I'm not referencing aCb instance?
you are casting the trigger of the event as a ComboBox. You do this to explictly say that this variable is of this type. You don't have to most of the times but when you do you get these advantages
When you are checking what the type is
You get all of the methods in the type Class (In this case Combo Box) as autocomplete options in your IDE
Will throw an error if evt.target is not of type ComboBox after all
Also is a visual indicator of what variable it is. Very helpful when revisiting code
I narrowed the causes of an AS3 compiler error 1119 down to code that looks similar to this:
var test_inst:Number = 2.953;
trace(test_inst);
trace(test_inst.constructor);
I get the error "1119: Access of possibly undefined property constructor through a reference with static type Number."
Now if I omit the variable's type, I don't get that error:
var test_inst = 2.953;
trace(test_inst);
trace(test_inst.constructor);
it produces the expected output:
2.953
[class Number]
So what's the deal? I like explicitly typing variables, so is there any way to solve this error other than not providing the variable's type?
ok, this is a little hard to explain ... first of all, here is how it works:
var test_inst:Number = 2.953;
trace(test_inst);
trace((test_inst as Object).constructor);
to my understanding, this comes from the fact, that the property constructor comes from the ECMAScript-nature of ActionScript 3. It is an ECMAScript property of Object instances and is inherited through prototypes. From the strictly typed world of ActionScript 3 (which also uses a different inheritance mechanism), this property is thus not available.
greetz
back2dos
http://www.kirupa.com/forum/showpost.php?p=1951137&postcount=214
that has all the info you need :)
basically, trace(test_inst["constructor"]) will work.
Object(someobject).constructor will achieve the same thing -- and you don't have to deal with compiler issues.
Object(someinst) === someclass works as well.
dh