Bien que la réponse acceptée est bien, je me sentais vraiment qu'il ne rend pas justice dactylographiée à ce stade. Ce ne sont pas les premiers jours plus. Tapuscrit est de trouver beaucoup plus maintenant avec l'adoption de plusieurs cadres populaires étant écrits en caractères dactylographiés. Les raisons pour lesquelles vous devriez choisir tapuscrit au lieu de JavaScript sont nombreux maintenant.

Relation avec JavaScript

JavaScript est standardisé par les normes de ECMAScript. Tous les navigateurs à l' appui d'utiliser toutes les fonctionnalités des normes plus récentes ECMAScript (voir ce tableau ). Tapuscrit soutient les nouvelles normes ECMAScript et les compile à (plus) les objectifs de ECMAScript de votre choix (objectifs actuels sont 3, 5 et 6 [aka 2015]). Cela signifie que vous pouvez utiliser les fonctions de ES2015 et au - delà, comme les modules, les fonctions lambda, les classes, l'opérateur de diffusion, déstructurant, aujourd'hui. Il ajoute également de type support de cours, qui ne fait pas partie d'une norme ECMAScript et peut probablement jamais en raison de la nature interprétée au lieu de la nature compilé JavaScript. Le système de type dactylographiées est relativement riche et comprend: interfaces, énumérations, types hybrides, les génériques, les syndicats et les types intersection, les modificateurs d'accès et bien plus encore. lesite officiel dactylographiées donne un aperçu de ces caractéristiques.

Relation avec d'autres langues de ciblage JavaScript

Tapuscrit a une philosophie unique par rapport aux autres langues qui compilent JavaScript. Code JavaScript est valide code tapuscrit; Tapuscrit est une surcouche de JavaScript. Vous pouvez presque renommer vos .jsfichiers vers des .tsfichiers et commencer à utiliser tapuscrit. Les fichiers tapuscrit sont compilés à LISIBLE JavaScript, de sorte que la migration est de retour possible et comprendre le tapuscrit compilé n'est pas difficile du tout. Cette tapuscrit façon se fonde sur les succès de JavaScript tout en améliorant ses faiblesses.

D'une part, vous avez des outils de preuve futurs qui prennent les normes ECMAScript modernes et compilent vers le bas aux anciennes versions JavaScript avec Babel étant le plus populaire. D'autre part, vous avez des langues qui peuvent totalement différer de JavaScript qui ciblent JavaScript, comme coffeescript, Clojure, Dart, Elm, Haxe, ScalaJs, et une foule plus (voir cette liste). Ces langues, mais ils pourraient être mieux que là où l'avenir de JavaScript pourrait jamais conduire, courent un plus grand risque de ne pas trouver suffisamment adoption pour leur avenir être garantie. Vous pourriez aussi avoir plus de mal à trouver des développeurs expérimentés pour certaines de ces langues, bien que ceux que vous trouverez peut souvent être plus enthousiaste. Interop avec JavaScript peut également être un peu plus impliqué, car ils sont plus éloignées de ce que JavaScript est en réalité.

Tapuscrit se trouve entre ces deux extrêmes, l'équilibre entre le risque. Tapuscrit n'est pas un choix risqué par aucune norme. Il prend très peu d'efforts pour s'y habituer si vous êtes familier avec JavaScript, car il est pas une langue complètement différente, offre un excellent support d'interopérabilité JavaScript et il a vu beaucoup d'adoption récemment.

frappe en option statique et l'inférence de type

JavaScript est typé dynamiquement. Cela signifie JavaScript ne sait pas ce type d'une variable jusqu'à ce qu'il soit réellement instancié lors de l'exécution. Cela signifie également qu'il peut être trop tard. Tapuscrit ajoute le soutien de type JavaScript. Bugs qui sont causées par de fausses hypothèses d'un être variable d'un certain type peut être éradiquée complètement si vous jouez vos cartes; comment strict vous tapez votre code ou si vous tapez votre code tout est à vous.

Tapuscrit facilite la frappe un peu plus facile et beaucoup moins explicite par l'utilisation de l' inférence de type. Par exemple: var x = "hello"dactylographiée est le même que var x : string = "hello". Le type est simplement déduit de son utilisation. Même ce que vous ne tapez pas explicitement les types, ils sont toujours là pour vous sauver de faire quelque chose qui autrement entraînerait une erreur d' exécution.

Tapuscrit est éventuellement saisi par défaut. Par exemple function divideByTwo(x) { return x / 2 }est une fonction valide dactylographiée qui peut être appelé à tout type de paramètre, même si l' appelant avec une chaîne entraînera évidemment une exécution erreur. Tout comme vous êtes habitué en JavaScript. Cela fonctionne, parce que quand aucun type n'a été explicitement attribué et le type ne pouvait être déduit, comme dans l'exemple divideByTwo, tapuscrit attribue implicitement le type any. Cela signifie que la signature de type de fonction divideByTwo devient automatiquement function divideByTwo(x : any) : any. Il y a un drapeau du compilateur pour interdire ce comportement: --noImplicitAny. L' activation de cette option vous donne un plus grand degré de sécurité, mais signifie également que vous devrez faire plus taper.

Les types ont un coût qui leur sont associés. Tout d'abord , il y a une courbe d'apprentissage, et en second lieu, bien sûr, il vous en coûtera un peu plus de temps pour mettre en place une base de code en utilisant la saisie stricte correcte aussi. Dans mon expérience, ces coûts sont tout à fait une valeur sur une base de code sérieux que vous partagez avec d' autres. Une étude à grande échelle de Langages de programmation et qualité du code dans Github suggère que « que les langues statiquement en général sont tapées défaut moins sujettes que les types dynamiques, et que le typage fort est meilleur que typage faible dans la même matière ».

Il est intéressant de noter que ce même document constate que tapuscrit est moins sujette aux erreurs JavaScript alors:

Pour ceux qui ont des coefficients positifs que nous pouvons nous attendre à ce que la langue est associée à, ceteris paribus, un plus grand nombre de corrections de défauts. Ces langues sont C, C ++, JavaScript , Objective-C, Php et Python. Les langues Clojure, Haskell, Ruby, Scala et tapuscrit , tous ont des coefficients négatifs ce qui implique que ces langues sont moins susceptibles que la moyenne pour aboutir à la fixation des défauts engage.

support EIDE

L'expérience de développement avec tapuscrit est une nette amélioration par rapport JavaScript. L'IDE est informé en temps réel par le compilateur dactylographiée sur son riche informations de type. Cela donne deux avantages majeurs. Par exemple, avec tapuscrit vous pouvez faire en toute sécurité refactorisations comme renomme à travers l'ensemble de votre base de code. Grâce à la complétion de code, vous pouvez obtenir de l'aide en ligne sur ce que les fonctions d'une bibliothèque peut offrir. Plus besoin de les rappeler ou les consulter dans les références en ligne. Les erreurs de compilation sont signalées directement dans l'IDE avec une ligne rouge squiggly pendant que vous êtes occupé de codage. Dans tout cela permet un gain de productivité significatif par rapport au travail avec JavaScript. On peut passer plus de codage de temps et moins de temps de débogage.

Il existe une large gamme de IDEs qui ont un excellent support pour tapuscrit, comme le code Visual Studio & VS, Atom, Sublime et IntelliJ / WebStorm.

contrôles stricts null

Les erreurs d'exécution de la forme cannot read property 'x' of undefinedou undefined is not a functionsont très souvent causés par des erreurs dans le code JavaScript. Hors de la boîte tapuscrit réduit déjà la probabilité de ce genre d'erreurs se produisent, car on ne peut pas utiliser une variable qui n'est pas connue du compilateur tapuscrit (à l'exception des propriétés des anyvariables typées). Il est encore possible que d'utiliser par erreur une variable qui est réglée sur undefined. Cependant, avec la version 2.0 de tapuscrit vous pouvez éliminer ces types d'erreurs tous ensemble grâce à l'utilisation de types non-nullable. Cela fonctionne comme suit:

Avec des contrôles de null stricts activés ( --strictNullChecksoption du compilateur) le compilateur dactylographiée ne permettra pas undefinedd'être affecté à une variable , sauf si vous déclarez explicitement être de type Nullable. Par exemple, let x : number = undefinedse traduira par une erreur de compilation. Cela correspond parfaitement à la théorie de type, puisque undefinedn'est pas un numéro. On peut définir xcomme un type de somme numberet undefinedpour corriger ceci: let x : number | undefined = undefined.

Une fois qu'un type est connu pour être annulable, ce qui signifie qu'il est d'un type qui peut aussi être de la valeur nullou undefined, le compilateur dactylographiée peut déterminer par une analyse de type à base de flux de contrôle si votre code peut utiliser en toute sécurité une variable ou non. En d' autres termes lorsque vous vérifiez une variable est undefinedpar exemple une ifdéclaration , le compilateur tapuscrit déduira que le type dans cette branche du flux de contrôle de votre code n'est plus annulable et peut donc être utilisé en toute sécurité. Voici un exemple simple:

let x: number | undefined;
if (x !== undefined) x += 1; // this line will compile, because x is checked.
x += 1; // this line will fail compilation, because x might be undefined.

Au cours de la construction 2016 conférence co-designer dactylographiées Anders Hejlsberg a donné une explication détaillée et la démonstration de cette fonctionnalité: vidéo (de 44:30 à 56:30).

Compilation

Pour utiliser tapuscrit vous avez besoin d' un processus de compilation pour compiler le code JavaScript. Le processus de construction prend généralement que quelques secondes en fonction bien sûr de la taille de votre projet. Le compilateur dactylographiée prend en charge la compilation incrémentale ( --watchdrapeau du compilateur), de sorte que toutes les modifications ultérieures peuvent être compilés à une plus grande vitesse.

Le compilateur dactylographiée peut inline des informations cartographiques source dans les fichiers .js générés ou créer des fichiers .map séparés. Informations cartographiques de source peut être utilisée par le débogage des utilitaires comme les DevTools Chrome et d' autres IDE pour relier les lignes du JavaScript à ceux qui les ont engendrés dans le tapuscrit. Cela permet pour vous de définir des points d' arrêt et inspectez les variables lors de l' exécution directement sur votre code dactylographiée. Informations cartographiques source fonctionne assez bien, il était bien avant tapuscrit, mais tapuscrit de débogage est généralement pas aussi grande que lors de l' utilisation directement JavaScript. Prenez le thismot - clé par exemple. En raison de la sémantique changement du thismot - clé autour de la fermeture depuis ES2015, thispeuvent exister en réalité lors de l' exécution comme une variable appelée _this(voir cette réponse). Cela peut vous embrouiller pendant le débogage, mais est généralement pas un problème si vous connaissez ou inspectez le code JavaScript. Il convient de noter que Babel souffre exactement le même genre de question.

Il y a quelques autres trucs du compilateur tapuscrit peut faire, comme la génération d' interception code basé sur les décorateurs , la génération du code de chargement des modules pour les systèmes de modules différents et l' analyse syntaxique JSX . Toutefois, vous aurez probablement besoin d' un outil de construction en plus du compilateur dactylographiée. Par exemple , si vous voulez compresser votre code que vous devez ajouter d' autres outils à votre processus de construction de le faire.

Il y a des plugins de compilation tapuscrit disponibles pour Webpack , Gulp , Grunt et à peu près tout autre outil de construction JavaScript là. La documentation dactylographiée a une section sur l' intégration des outils de construction couvrant toutes. Un linter est également disponible si vous souhaitez encore plus construire la vérification du temps. Il y a aussi un grand nombre de projets semenciers là - bas qui vous aider à démarrer avec tapuscrit en combinaison avec un tas d'autres technologies comme angulaire 2, React, Ember, SystemJs, WebPack, Gulp, etc.

interopérabilité JavaScript

Depuis tapuscrit est si étroitement liée à JavaScript , il a de grandes capacités d'interopérabilité, mais un travail supplémentaire est nécessaire pour travailler avec les bibliothèques JavaScript dactylographiée. Définitions tapuscrit sont nécessaires pour que le compilateur dactylographiée comprend que des appels de fonction comme _.groupByou angular.copyou $.fadeOutne sont pas en fait des déclarations illégales. Les définitions de ces fonctions sont placées dans des .d.tsfichiers.

La forme la plus simple une définition peut prendre est de permettre un identifiant à utiliser de quelque façon. Par exemple, lors de l' utilisation Lodash , un fichier de définition d'une seule ligne declare var _ : anyvous permettra d'appeler toutes les fonctions que vous voulez sur _, mais bien sûr vous êtes également toujours en mesure de faire des erreurs: _.foobar()serait un appel tapuscrit juridique, mais il est bien sûr un appel illégal lors de l'exécution. Si vous voulez le support de type et la complétion de code votre fichier de définition doit être plus précis (voir définitions lodash pour un exemple).

Modules NPM qui sont pré-emballés avec leurs propres définitions de type sont comprises automatiquement par le compilateur tapuscrit (voir documentation ). Pour à peu près toute autre bibliothèque JavaScript semi-populaire qui ne comprend pas ses propres définitions quelqu'un là - bas a déjà fait des définitions de type disponibles dans un autre module NPM. Ces modules sont préfixés par « types de @ / » et proviennent d'un dépôt Github appelé DefinitelyTyped .

Il y a une mise en garde: les définitions de type doivent correspondre à la version de la bibliothèque que vous utilisez au moment de l'exécution. Si elles ne le font pas, tapuscrit peut vous interdire d'appeler une fonction ou déréférencement une variable qui existez ou vous permettre d'appeler une fonction ou déréférencer une variable qui n'existe pas, simplement parce que les types ne correspondent pas à l'exécution à la compilation . Donc, assurez-vous de charger la bonne version des définitions de type pour la bonne version de la bibliothèque que vous utilisez.

Pour être honnête, il y a un léger tracas à cela et il peut être l'une des raisons pour lesquelles vous ne choisissez pas tapuscrit, mais plutôt aller pour quelque chose comme Babel qui ne souffre pas d'avoir à obtenir des définitions de type du tout. D'autre part, si vous savez ce que vous faites, vous pouvez facilement surmonter toutes sortes de problèmes causés par des fichiers de définition incorrects ou manquants.

Conversion de JavaScript pour tapuscrit

Tout .jsfichier peut être renommé à un .tset a couru par le compilateur dactylographiée pour obtenir syntaxiquement le même code JavaScript en tant que sortie (si elle était syntaxiquement correct en premier lieu). Même lorsque le compilateur dactylographiée obtient des erreurs de compilation , il produira encore un .jsfichier. Il peut même accepter des .jsfichiers en entrée avec le --allowJsdrapeau. Cela vous permet de commencer avec tapuscrit tout de suite. Malheureusement , les erreurs de compilation sont susceptibles de se produire au début. T - on besoin de se rappeler que ceux - ci ne sont pas des erreurs d'arrêt montrent que vous pouvez être utilisé pour d'autres compilateurs.

Les erreurs de compilation on obtient au début lors de la conversion d' un projet JavaScript à un projet dactylographié sont inévitables par la nature de tapuscrit. Tapuscrit vérifie tout code de validité et donc il a besoin de connaître toutes les fonctions et variables qui sont utilisées. Ainsi , les définitions de type doivent être en place pour tous sinon des erreurs de compilation sont tenus de se produire. Comme il est mentionné dans le chapitre ci - dessus, pour à peu près tout framework JavaScript , il y a des .d.tsfichiers qui peuvent facilement être acquis avec l'installation de paquets DefinitelyTyped. Il pourrait cependant être que vous avez utilisé une bibliothèque obscure pour lesquelles aucune définition de tapuscrit sont disponibles ou que vous avez polyfilled des primitives JavaScript. Dans ce cas , vous devez fournir des définitions de type pour ces bits pour que les erreurs de compilation à Dissapear. Il suffit de créer un .d.tsfichier et l' inclure dans le tsconfig.json filesde tableau, de sorte qu'il est toujours considéré par le compilateur dactylographiée. Dans ce document déclarer ces bits tapuscrit ne connaît pas le type any. Une fois que vous avez éliminé toutes les erreurs que vous pouvez introduire progressivement la saisie de ces pièces en fonction de vos besoins.

Certains travaux (re) configurer votre pipeline de construction sera également nécessaire pour obtenir tapuscrit dans le pipeline de construction. Comme il est mentionné dans le chapitre sur la compilation il y a beaucoup de bonnes ressources là-bas et je vous encourage à rechercher des projets de semences qui utilisent la combinaison d'outils que vous voulez travailler avec.

Le plus grand obstacle est la courbe d'apprentissage. Je vous encourage à jouer avec un petit projet au début. Regardez comment il fonctionne, comment il construit, quels sont les fichiers qu'il utilise, comment il est configuré, comment il fonctionne dans votre environnement de développement, la façon dont il est structuré, les outils qu'il utilise, etc. Conversion d'une grande base de code JavaScript à tapuscrit est très faisable lorsque vous savez ce que vous faites, mais il pourrait être frustrant quand vous ne le faites pas.

Adoption

Tapuscrit est open source (Apache 2 sous licence, voir github ) et soutenu par Microsoft. Anders Hejlsberg , l'architecte principal de C # est le fer de lance du projet. C'est un projet très actif; l'équipe dactylographiée a sorti beaucoup de nouvelles fonctionnalités au cours des dernières années et beaucoup de grands sont encore prévus à venir (voir la feuille de route ).

Dans l' enquête développeur StackOverflow 2017 tapuscrit était le plus populaire transpiler JavaScript (9e place au total) et a remporté la troisième place dans la catégorie plus aimé de langage de programmation.

Tapuscrit fait quelque chose de semblable à ce que moins ou SASS fait pour CSS. Ils sont super sets de celui-ci, ce qui signifie que tous les codes JS que vous écrivez est un code valide dactylographiée. De plus, vous pouvez utiliser les autres goodies qu'il ajoute à la langue, et le code transpiled sera valide js. Vous pouvez même définir la version JS que vous voulez que votre code résultant sur.

À l'heure actuelle tapuscrit est un super ensemble de ES2015, donc peut-être un bon choix pour commencer à apprendre les nouvelles fonctionnalités js et transpile à la norme nécessaire pour votre projet.

« Principes fondamentaux tapuscrit » - un cours vidéo-Pluralsight par Dan Wahlin et John Papa est un très bon, actuellement (25 Mars, 2016) mis à jour pour refléter tapuscrit 1.8, introduction à tapuscrit.

Pour moi , les caractéristiques vraiment bien, à côté des belles possibilités pour IntelliSense, les cours , les interfaces , modules , la facilité de mise en œuvre et AMD, la possibilité d'utiliser le débogueur Visual Studio Tapuscrit lorsqu'il est appelé avec IE.

Pour résumer : Si elle est utilisée comme prévu, Tapuscrit peut rendre la programmation JavaScript plus fiable et plus facile. Il peut augmenter la productivité du programmeur JavaScript considérablement sur toute SDLC.

le script ECMA 5 (ES5) qui tout le soutien du navigateur et précompilés. ES6 / ES2015 et ES / 2016 est venu cette année avec beaucoup de changements afin de pop-up ces changements il y a quelque chose entre ce qui devrait prendre soucie si tapuscrit. • Types tapuscrit est -> signifie que nous devons définir le type de données de chaque propriété et des méthodes. Si vous connaissez C # alors Tapuscrit est facile à comprendre. • Le gros avantage est que nous dactylographiées Type d'identité Les questions liées au début avant d'aller à la production. Cela permet des tests unitaires à l'échec s'il y a une incompatibilité de type.