Wie führe ich eine Laufzeitüberprüfung in Dart durch?

Dartspezifikation besagt:

Reifizierte Typinformationen spiegeln die Objekttypen zur Laufzeit wider und können immer von dynamischen Typprüfungskonstrukten abgefragt werden (die Analoga von instanceOf, casts, typecase usw. in anderen Sprachen).

Hört sich toll an, aber es gibt keinen instanceofähnlichen Operator. Wie führen wir eine Laufzeit-Typprüfung in Dart durch? Ist das überhaupt möglich?

Die Instanz des Operators wird isin Dart aufgerufen . Die Spezifikation ist nicht gerade für einen Gelegenheitsleser geeignet, daher scheint die derzeit beste Beschreibung http://www.dartlang.org/articles/optional-types/ zu sein .

Hier ist ein Beispiel:

class Foo { }

main() {
  var foo = new Foo();
  if (foo is Foo) {
    print("it's a foo!");
  }
}

Der Dart- ObjectTyp hat ein runtimeTypeInstanzmitglied (Quelle stammt aus dart-sdkVersion 1.14, weiß nicht, ob es früher verfügbar war)

class Object {
  //...
  external Type get runtimeType;
}

Verwendung:

Object o = 'foo';
assert(o.runtimeType == String);

object.runtimeType Gibt den Objekttyp zurück

Beispielsweise:

print("HELLO".runtimeType); //prints String
var x=0.0;
print(x.runtimeType); //prints double

Wie andere bereits erwähnt haben, isentspricht der instanceofOperator von Dart dem Operator von Javascript . Ich habe jedoch kein direktes Analogon des typeofOperators in Dart gefunden.

Zum Glück wurde die Dart: Mirrors Reflection API kürzlich zum SDK hinzugefügt und steht jetzt im neuesten Editor + SDK-Paket zum Download zur Verfügung . Hier ist eine kurze 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.");
}

Es gibt zwei Operatoren für die Typprüfung: E is TTests für E, eine Instanz vom Typ T, während E is! TTests für E keine Instanz vom Typ T sind.

Beachten Sie, dass dies E is Objectimmer wahr und null is Timmer falsch ist, es sei denn T===Object.

Nur um den Unterschied zwischen isund ein wenig zu verdeutlichen runtimeType. Wie schon jemand sagte (und dies wurde mit Dart V2 + getestet) den folgenden Code:

class Foo { 
  Type get runtimeType => String;
}
main() {
  var foo = new Foo();
  if (foo is Foo) {
    print("it's a foo!");
  }
  print("type is ${foo.runtimeType}");

}

wird ausgegeben:

it's a foo! 
type is String

Was falsch ist. Jetzt kann ich den Grund nicht erkennen, warum man so etwas tun sollte ...