Comment effectuer la vérification du type d'exécution dans Dart?

La spécification Dart indique:

Les informations de type réifié reflètent les types d'objets au moment de l'exécution et peuvent toujours être interrogées par des constructions de vérification de type dynamique (les analogues de instanceOf, casts, typecase, etc. dans d'autres langues).

Ça a l'air génial, mais il n'y a pas d' instanceofopérateur semblable à celui-ci. Alors, comment pouvons-nous effectuer la vérification de type à l'exécution dans Dart? Est-ce possible du tout?

L'opérateur instanceof est appelé isdans Dart. La spécification n'est pas vraiment conviviale pour un lecteur occasionnel, donc la meilleure description à l'heure actuelle semble être http://www.dartlang.org/articles/optional-types/ .

Voici un exemple:

class Foo { }

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

Le Objecttype Dart a un runtimeTypemembre d'instance (la source est de la dart-sdkv1.14, je ne sais pas si elle était disponible plus tôt)

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

Usage:

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

object.runtimeType renvoie le type d'objet

Par exemple:

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

Comme d'autres l'ont mentionné, l' isopérateur de Dart est l'équivalent de l' instanceofopérateur de Javascript . Cependant, je n'ai pas trouvé d'analogue direct de l' typeofopérateur dans Dart.

Heureusement, l' API de réflexion dart: mirrors a récemment été ajoutée au SDK et est désormais disponible au téléchargement dans le dernier package Editor + SDK . Voici une courte démo:

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.");
}

Il existe deux opérateurs pour les tests de type: E is Tteste pour E une instance de type T tandis que E is! Tteste E pas une instance de type T.

Notez que E is Objectc'est toujours vrai et null is Ttoujours faux sauf T===Object.

Juste pour clarifier un peu la différence entre iset runtimeType. Comme quelqu'un l'a déjà dit (et cela a été testé avec Dart V2 +), le code suivant:

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}");

}

affichera:

it's a foo! 
type is String

Ce qui est faux. Maintenant, je ne vois pas la raison pour laquelle on devrait faire une telle chose ...