Dart specification states:
Reified type information reflects the types of objects at runtime and may always be queried by dynamic typechecking constructs (the analogs of instanceOf, casts, typecase etc. in other languages).
Sounds great, but there is no instanceof-like operator. So how do we perform runtime type-checking in Dart? Is it possible at all?
The instanceof-operator is called is in Dart. The spec isn't exactly friendly to a casual reader, so the best description right now seems to be http://www.dartlang.org/articles/optional-types/.
Here's an example:
class Foo { }
main() {
var foo = new Foo();
if (foo is Foo) {
print("it's a foo!");
}
}
is operator is defined on page 59 of the spec, section 10.30 'Type test' –
Soto is and is! can be found in the Operators section of the Dart language tour. –
Boehmenist getTypeName(dynamic obj) => obj.runtimeType; –
Emlynne foo.runtimeType is String that screwed me up for a while. –
Sokol Dart Object type has a runtimeType instance member (source is from dart-sdk v1.14, don't know if it was available earlier)
class Object {
//...
external Type get runtimeType;
}
Usage:
Object o = 'foo';
assert(o.runtimeType == String);
runtimeType may be overriden by classes, although I can't think of a reason why they would. (external code can't set the value sinse it's a getter) Personally, I would stick to is and reflection. –
Kiss runtimeType has these limitations. –
Beverle runtimeType should only be used for debugging purposes? I ask because there isn't any mention of this in the docs for Object, or elsewhere (that I could find). –
Spiniferous runtimeType to generate HTML classes on the fly, it works with development build, but fails with release build, e.g. in my case result is minified:ed instead of column –
Montalvo As others have mentioned, Dart's is operator is the equivalent of Javascript's instanceof operator. However, I haven't found a direct analogue of the typeof operator in Dart.
Thankfully the dart:mirrors reflection API has recently been added to the SDK, and is now available for download in the latest Editor+SDK package. Here's a short demo:
import 'dart:mirrors';
getTypeName(dynamic obj) {
return reflect(obj).type.reflectedType.toString();
}
void main() {
var val = "\"Dart is dynamically typed (with optional type annotations.)\"";
if (val is String) {
print("The value is a String, but I needed "
"to check with an explicit condition.");
}
var typeName = getTypeName(val);
print("\nThe mirrored type of the value is $typeName.");
}
Unsupported operation: dart:mirrors is no longer supported for web apps –
Emlynne Simply use .runtimeType on the property like below,
print(unknownDataTypeProperty.runtimeType)
Exact type matching is done via runtimeType property. Checking if an instance or any of its parent types (in the inheritance chain) is of the given type is done via is operator:
class xxx {}
class yyy extends xxx {}
void main() {
var y = yyy();
print(y is xxx);
print(y.runtimeType == xxx);
}
Returns:
true
false
There are two operators for type testing: E is T tests for E an instance of type T while E is! T tests for E not an instance of type T.
Note that E is Object is always true, and null is T is always false unless T===Object.
T===Object? Dart doesn't have the triple equals operator, but you chose to use it rather than double equals, so I assume the difference has significance. –
Spiniferous null is Object would be true but null is T false for any other type T. tbh though I haven't been near Dart for many years now so can't be certain. –
Soto var isAuthFailure = Failure is! AuthenticationFailure; –
Closefisted Just to clarify a bit the difference between is and runtimeType. As someone said already (and this was tested with Dart V2+) the following code:
class Foo {
@override
Type get runtimeType => String;
}
main() {
var foo = Foo();
if (foo is Foo) {
print("it's a foo!");
}
print("type is ${foo.runtimeType}");
}
will output:
it's a foo!
type is String
Which is wrong. Now, I can't see the reason why one should do such a thing...
if(value is int ) Returns true if the type of the value is int,
else if(value is! int )
To check the type of a variable use runtimeType
void main() {
int a = 10;
print(a.runtimeType);
}
to check whether the type of a variable is the same as your expected use is or runtimeType
void main() {
int a = 10;
print(a.runtimeType == int); // true
//or
print(a is int); // true
}
.runtimeType property does an exact type match.is keyword matches on parent class types and class extension types class Aaa {}
class Bbb extends Aaa {}
void main() {
var x = Bbb();
print(x is Aaa); // true
print(x is Bbb); // true
print(x.runtimeType == Aaa); // false
print(x.runtimeType == Bbb); // true
print(x.runtimeType); // Bbb
print(x.runtimeType.runtimeType); // _Type
print(x.runtimeType.toString()); // Bbb
}
© 2022 - 2024 — McMap. All rights reserved.
isoperator at all in the specification. It's better to refere to the grammar file in Dart sources: code.google.com/p/dart/source/browse/trunk/dart/language/… – Sense