Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Cours sur Dart le langage orienté Web de Google Par Yohan Beschi (Soat) Date de

Cours sur Dart le langage orienté Web de Google Par Yohan Beschi (Soat) Date de publication : 8 septembre 2013 Dart, le nouveau langage orienté Web de Google, a été dévoilé au monde en octobre 2011. Il se veut un langage structuré, non pas révolutionnaire, mais facile d'apprentissage pour tout développeur, quel que soit son background (C#, Java ou JavaScript) puisque Dart est un agrégat de ces trois langages avec d'autres, tel que Smalltalk. Ce nouveau langage a pour objectif d'être tout ce qu'aurait pu être JavaScript s'il avait été inventé aujourd'hui. En d'autres termes, garder la nature dynamique du JavaScript, tout en offrant un langage et des outils facilitant le développement de grosses applications Web. Pour réagir à ce support de cours, un espace de dialogue vous est proposé sur le forum : Commentez Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) Préface......................................................................................................................................................................... 5 À propos de l'auteur.................................................................................................................................................... 6 1 - Introduction.............................................................................................................................................................7 1.1 - Le langage.....................................................................................................................................................7 1.2 - L'écoystème................................................................................................................................................... 7 1.2.1 - Dart Editor............................................................................................................................................. 8 1.2.2 - Les Machines Virtuelles........................................................................................................................ 8 1.2.3 - Dartium.................................................................................................................................................. 8 1.2.4 - dart2js....................................................................................................................................................8 1.2.5 - Pub........................................................................................................................................................ 9 1.2.6 - dartdoc...................................................................................................................................................9 Premières applications.................................................................................................................................................9 2.1 - Création d'une application serveur..............................................................................................................10 2.2 - Création d'une application cliente............................................................................................................... 13 2.2.1 - Fichier *.html....................................................................................................................................... 14 2.2.2 - Fichier *.dart........................................................................................................................................15 3 - Le langage........................................................................................................................................................... 15 3.1 - Utiliser le code d'exemple........................................................................................................................... 15 3.2 - Noms de variables, fonctions, classes et bibliothèques..............................................................................16 3.3 - Variables...................................................................................................................................................... 16 3.4 - Types intégrés............................................................................................................................................. 16 3.4.1 - Chaînes de caractères........................................................................................................................17 3.4.1.1 - Définition..................................................................................................................................... 17 3.4.1.2 - Échapper un caractère............................................................................................................... 17 3.4.1.3 - Le type String est aussi de type Object..................................................................................... 17 3.4.1.4 - Concaténation............................................................................................................................. 17 3.4.1.5 - Interpolation.................................................................................................................................18 3.4.1.6 - Formater une chaîne de caractères........................................................................................... 18 3.4.1.7 - Texte brut.................................................................................................................................... 18 3.4.2 - Nombres.............................................................................................................................................. 19 3.4.3 - Booléens..............................................................................................................................................19 3.4.4 - Listes................................................................................................................................................... 20 3.4.4.1 - Initialisation d'une liste avec des valeurs................................................................................... 20 3.4.4.2 - Instanciation d'une liste vide de taille fixe.................................................................................. 20 3.4.4.3 - Ajouter des valeurs à une liste de taille fixe...............................................................................20 3.4.4.4 - Instanciation d'une liste vide de taille indéterminée................................................................... 20 3.4.4.5 - Generics......................................................................................................................................21 3.4.4.6 - Liste de Liste.............................................................................................................................. 21 3.4.5 - Maps....................................................................................................................................................21 3.4.5.1 - Initialisation d'une map avec des valeurs...................................................................................22 3.4.5.2 - Initialisation d'une map vide....................................................................................................... 22 3.4.5.3 - Generics......................................................................................................................................22 3.5 - Opérateurs................................................................................................................................................... 22 3.5.1 - Liste des opérateurs et leur précédence............................................................................................ 23 3.5.2 - Opérateurs arithmétiques....................................................................................................................23 3.5.3 - Opérateurs d'égalité et relationnels.................................................................................................... 24 3.5.4 - Opérateurs de test de type.................................................................................................................24 3.5.5 - Opérateurs logiques............................................................................................................................ 24 3.5.6 - Opérateurs de déplacement de bits et d'opérations de bit à bit......................................................... 25 3.5.7 - Opérateurs d'assignation.....................................................................................................................25 3.5.8 - Autres opérateurs................................................................................................................................26 3.6 - Commentaires..............................................................................................................................................26 3.6.1 - Commentaires de code.......................................................................................................................26 3.6.2 - Commentaires de documentation....................................................................................................... 26 3.7 - Contrôle du flow d'exécution....................................................................................................................... 27 3.7.1 - Boucles................................................................................................................................................27 3.7.1.1 - for................................................................................................................................................ 27 3.7.1.2 - for in............................................................................................................................................27 - 2 - Copyright ® 2013 Soat. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://soat.developpez.com/tutoriels/dart/dart-manuel-reference/ Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) 3.7.1.3 - foreach........................................................................................................................................ 27 3.7.1.4 - while............................................................................................................................................ 28 3.7.2 - Instructions conditionnelles................................................................................................................. 28 3.7.2.1 - if … else......................................................................................................................................28 3.7.2.2 - Switch case.................................................................................................................................29 3.7.3 - Break et continue................................................................................................................................ 29 3.7.3.1 - Boucles........................................................................................................................................29 3.7.3.2 - Switches......................................................................................................................................30 3.8 - Fonctions......................................................................................................................................................30 3.8.1 - Fonctions de haut niveau....................................................................................................................31 3.8.2 - Fonctions de premier ordre.................................................................................................................31 3.8.3 - Fonctions locales.................................................................................................................................33 3.8.3.1 - Fonctions anonymes...................................................................................................................33 3.8.3.2 - Fonctions locales nommées....................................................................................................... 34 3.8.4 - Formes simplifiées.............................................................................................................................. 34 3.8.5 - Closures...............................................................................................................................................35 3.8.5.1 - Imbrication de closures...............................................................................................................36 3.8.5.2 - Closure hell.................................................................................................................................36 3.8.5.3 - Rendre testable une closure.......................................................................................................37 3.8.6 - Typedefs.............................................................................................................................................. 38 3.8.7 - Paramètres optionnels........................................................................................................................ 39 3.8.7.1 - Paramètres optionnels positionnels............................................................................................39 3.8.7.1.1 - Valeurs par défaut.............................................................................................................. 40 3.8.7.1.2 - Position d'un paramètre......................................................................................................40 3.8.7.2 - Paramètres optionnels nommés................................................................................................. 41 3.8.8 - Types optionnels................................................................................................................................. 41 3.8.9 - Wrap Up.............................................................................................................................................. 42 3.9 - Programmation Orientée Objet....................................................................................................................44 3.9.1 - Classes concrètes............................................................................................................................... 44 3.9.1.1 - Fonction main complète..............................................................................................................45 3.9.2 - Constructeurs...................................................................................................................................... 45 3.9.2.1 - this...............................................................................................................................................45 3.9.3 - Un constructeur avec un sucre, svp !................................................................................................. 46 3.9.4 - Écriture standard et sucre syntaxique................................................................................................ 46 3.9.5 - Surchage de constructeurs................................................................................................................. 46 3.9.6 - Constructeur avec paramètres optionnels.......................................................................................... 47 3.9.7 - Préconstructeur................................................................................................................................... 47 3.9.8 - Méthodes.............................................................................................................................................47 3.9.9 - Variables et méthodes statiques......................................................................................................... 49 3.9.9.1 - Variables statiques......................................................................................................................49 3.9.9.2 - Méthodes statiques.....................................................................................................................50 3.9.9.3 - Variables et méthodes statiques vs champs et méthodes d'instances.......................................51 3.9.10 - Héritage............................................................................................................................................. 51 3.9.11 - Surcharge d'une méthode................................................................................................................. 54 3.9.12 - Classes abstraites............................................................................................................................. 55 3.9.13 - Héritage de classes abstraites..........................................................................................................56 3.9.14 - Interfaces...........................................................................................................................................56 3.9.14.1 - Types multiples......................................................................................................................... 56 3.9.14.2 - Inversion of Control...................................................................................................................59 3.9.15 - Factories............................................................................................................................................60 3.9.15.1 - Implémentations par défaut...................................................................................................... 60 3.9.15.2 - Caching..................................................................................................................................... 60 3.9.16 - Generics............................................................................................................................................ 61 3.9.17 - Exceptions......................................................................................................................................... 63 3.9.18 - noSuchMethod...................................................................................................................................65 3.9.18.1 - Invocation..................................................................................................................................65 3.9.18.2 - Définir la méthode noSuchMethod().........................................................................................66 3.9.18.3 - Délégation................................................................................................................................. 67 - 3 - Copyright ® 2013 Soat. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://soat.developpez.com/tutoriels/dart/dart-manuel-reference/ Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) 3.9.19 - Cascade.............................................................................................................................................68 3.9.20 - Constantes.........................................................................................................................................69 3.9.20.1 - final............................................................................................................................................69 3.9.20.2 - const..........................................................................................................................................70 3.9.20.3 - Énumérations............................................................................................................................ 71 3.9.21 - Redéfinition d'opérateurs...................................................................................................................71 3.9.21.1 - Opérateurs pouvant être redéfinis............................................................................................ 71 3.9.22 - Mixins.................................................................................................................................................73 3.10 - Bibliothèques..............................................................................................................................................74 3.10.1 - Importer une bibliothèque................................................................................................................. 74 3.10.2 - Aliases............................................................................................................................................... 75 3.10.3 - Créer une bibliothèque......................................................................................................................75 3.10.4 - Scope.................................................................................................................................................76 3.10.5 - Getters et Setters..............................................................................................................................77 3.10.6 - Multifichiers........................................................................................................................................78 3.10.7 - Réexporter une bibliothèque.............................................................................................................79 3.10.8 - Bibliothèques externes...................................................................................................................... 80 3.11 - Variables Globales..................................................................................................................................... 80 Conclusion..................................................................................................................................................................81 Remerciements.......................................................................................................................................................... 81 - 4 - Copyright ® 2013 Soat. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://soat.developpez.com/tutoriels/dart/dart-manuel-reference/ Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) Préface Dart étant encore jeune, il est difficile de dire s'il participera à la nouvelle révolution du Web. Cependant, nous pouvons applaudir la démarche de Google nous offrant une solution aux différentes problématiques actuelles du développement Web, notamment pour ceux à qui JavaScript donne des boutons, mais pas uniquement. Dart s'inscrit dans une mouvance de nouveaux paradigmes Web tels que TypeScript, CoffeeScript ou encore Node.js. qui ont tous pour objectif de simplifier les développements. Il est important de noter qu'avec Dart, Google n'a pas l'intention de casser le Web puisque l'un des prérequis de Dart est d'être compilable en JavaScript (grâce à l'outil dart2js), pour être utilisé dans tout navigateur moderne (IE 6, 7, 8 et 9 étant donc exclus) ayant une Machine Virtuelle JavaScript compatible HTML5, mais pas de Machine Virtuelle Dart. Dart faisant partie du projet Chrome, nous pouvons espérer voir apparaître une Machine Virtuelle Dart dans Chrome une fois la version 1.0 sortie. Ce tutoriel a été réalisé avec la participation de Soat. - 5 - Copyright ® 2013 Soat. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://soat.developpez.com/tutoriels/dart/dart-manuel-reference/ Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) À propos de l'auteur Développeur depuis l'âge de 14 ans (Assembleur, C/C++, PHP, Python, Java), Yohan Beschi ne fait quasiment que du Java depuis 2002. Il s'est récemment penché sur le développement Dart, qu'il évangélise depuis. Il participe à la team d'expertise Soat dans le cadre de ses expériences dans le domaine du Web et Java. À ce titre il contribue à l'émulation technologique sur developpez.com, le blog soat et sur twitter (@yohanbeschi). - 6 - Copyright ® 2013 Soat. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://soat.developpez.com/tutoriels/dart/dart-manuel-reference/ Cours sur Dart le langage orienté Web de Google par Yohan Beschi (Soat) 1 - Introduction 1.1 - Le langage Dart en quelques mots : • Dart est un langage orienté objet avec un héritage simple, des classes concrètes et abstraites, des interfaces et des mixins (sorte d'héritage multiple limité) ; • Dart est optionnellement typé que ce soit dans l'assignation d'une variable ou la définition d'une fonction ; • Dart est gouverné par des fonctions de haut niveau, c'est-à-dire des fonctions non encapsulées dans une classe ou un objet. Des fonctions encapsulées dans une classe ou un objet sont aussi appelées méthodes ; • en Dart, les fonctions sont des uploads/Litterature/ manuel-dart.pdf