FAQ TypeScriptConsultez toutes les FAQ

Nombre d'auteurs : 2, nombre de questions : 25, dernière mise à jour : 20 septembre 2016  Ajouter une question

 

Cette FAQ a été réalisée en partie sur base de discussions avec l'équipe de TypeScript mais également grâce à des membres passionnés par la technologie.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs et traducteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, contactez-nous.

Nous désirons remercier toutes les personnes ayant participer à la création de cette FAQ.

Sur ce, nous vous souhaitons une bonne lecture.

N’hésitez pas à nous faire part de vos remarques sur le contenu de cette FAQ ou à nous faire vos propositions de contribution !

La rédaction Developpez.com.


SommaireLangage (11)
précédent sommaire suivant
 

Oui.
Il vous faudra utiliser les apostrophes inversées `, conformément à la norme ES2015, pour englober votre chaîne de caractères comme ceci :

Code TypeScript : Sélectionner tout
1
2
3
4
(function() { 
	const greets: string = "Hello"; 
	console.log(`${greets} world !`); 
})();

Équivalent JavaScript ES5 et antérieures :

Code JavaScript : Sélectionner tout
1
2
3
4
(function() { 
    var greets = "Hello"; 
    console.log(greets + " world !"); 
})();

Mis à jour le 25 juillet 2016 Songbird

Dart et TypeScript, bien qu'étant de prime abord de simples surcouches JavaScript, sont deux outils bien différents.

Le premier, Dart, privilégie la performance du programme écrit tout en s'éloignant drastiquement de la syntaxe de JavaScript, en plus de proposer une API différente (qui était tout d'abord dédiée à la machine virtuelle).

Le second, TypeScript, se rapproche plus d'une surcouche composée « principalement » de sucres syntaxiques, tout en conservant un code lisible et permettant à des développeurs JavaScript de bénéficier d'un support plus important en termes de débogage grâce au compilateur de TypeScript et du typage statique optionnel.

En somme, tout dépend de votre besoin. TypeScript permet d'être compris par un développeur JavaScript sans problème, Dart non. En revanche dart2js sera plus rigoureux en termes d'optimisation et de propreté du code (élimination du code mort).

Mis à jour le 31 juillet 2016 Songbird

Non, bien entendu, car TypeScript est un sur-ensemble de JavaScript. Ce qui signifie que n'importe quelle construction syntaxique JavaScript est valable en TypeScript, à de rares exceptions près.

Par exemple, rien ne vous empêche d'écrire ceci :

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
  
var MaClasseGéniale = (function() { 
    function MaClasseGéniale() { 
    } 
    MaClasseGéniale.prototype.sayHello = function() { 
        console.log("Hello, dude !"); 
    }; 
    return MaClasseGéniale; 
}());

Plutôt que ceci :

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
  
class MaClasseGéniale { 
    sayHello(): void { 
        console.log("Hello, dude !"); 
    } 
}

Voyez ces sucres comme des raccourcis, ils ne sont donc pas un passage obligatoire pour écrire un programme avec TypeScript (vous bénéficierez quoi qu'il arrive de la relecture du compilateur).

Mis à jour le 31 juillet 2016 Songbird

Malheureusement non.
Vous pouvez, si vous le souhaitez, utiliser cet exemple qui reproduit le comportement d'une assertion simple :

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
function assert(expression: boolean, error_message?: string, return_code?: number): void { 
    try { 
        if (expression === null) 
            throw new Error("expression is null."); 
  
        if (!error_message && !return_code) { 
            error_message = "An error was occurred."; 
            return_code = 1; /* You can write the error line, if you want. */ 
        } 
  
        if (expression === false) 
            throw new Error(`Debug log:\n${error_message} return code: ${return_code}`); 
    } 
    catch(e) { 
        console.log(e.stack); 
    } 
} 
  
function assertionTest(arg: string): void { 
    assert(arg ? true : false, "arg's value is null, cf. error line to return code.", 22); 
} 
assertionTest("No error, cool ! :D");

N.B. La fonction assertionTest() n’est, bien entendu, pas nécessaire au bon fonctionnement de la macro, elle vous permet simplement de visionner l’exemple directement dans votre navigateur.

Mis à jour le 1er août 2016 Songbird

Oui !
Les paramètres optionnels sont suffixés d’un point d’interrogation ? :

Code TypeScript : Sélectionner tout
1
2
3
4
  
function maFonctionGéniale(paramOptionnel?: string): void { 
    console.log(paramOptionnel ? paramOptionnel : "Le paramètre n'est pas renseigné !"); 
}

Mis à jour le 1er août 2016 Songbird

Oui !
Il est d'ailleurs très similaire à celui utilisé par Java/C#, mais il possède tout de même quelques subtilités (en particulier à propos du mot-clé protected).

TypeScript permet donc d'encapsuler les attributs d'une classe grâce aux mots-clés suivants :

  • public ;
  • protected ;
  • private.


Allons du plus souple au plus restrictif :

  • public possède toujours la même fonction qu'en Java/C# : il permet d'accéder directement à l'attribut précédé par ce mot-clé sans besoin de passer par un accesseur. En POO classique, les attributs publics sont très souvent des constantes avec un accès en lecture seule :
  • protected change un peu la donne puisqu'il ne permet pas d'accéder aux attributs des classes se trouvant dans le même « package », mais à ceux se trouvant dans une classe mère (un exemple sera présenté plus bas) ;
  • private ne permet aucun accès à l'attribut (sauf exception pour l'introspection, évidemment), sauf si le couple mutateur/accesseur a été déclaré.


Voici un exemple mettant en pratique tous les mots-clés présentés plus haut :
Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
  
class A { 
    private privAttr: string; // sécurisé, visible via introspection ou accesseur uniquement 
    protected protAttr: string; // protégé, visible depuis une classe/sous-classe uniquement 
    public pubAttr: string; // non sécurisé, visible sans restriction 
  
    constructor(privAttr: string, pubAttr: string) { 
        try { 
            if (privAttr && pubAttr) { 
                this.privAttr = attr; 
                this.pubAttr = pubAttr; 
            } 
            else throw new Error("privAttr et/ou pubAttr sont null"); 
        } 
        catch(e) { 
            console.log(e.stack); 
        } 
    } 
    setPrivAttr(privAttr: string) { 
        try { 
                if (privAttr && privAttr !== "") { 
                    this.privAttr = privAttr; 
                } 
                else throw new Error("la valeur de privAttr est null ou vide");  
        } 
        catch(e) { 
            console.log(e.stack); 
        } 
    } 
  
    getPrivAttr() { 
        return this.privAttr; 
    } 
} 
  
class B extends A { 
    protAttrInitialization() { 
        this.protAttr = "Salut maman ! :)"; // Ok 
    } 
} 
  
let objetGénial = new A("Attribut privé", "Attribut public"); 
  
objetGénial.setAttr(""); // Erreur 
objetGénial.setAttr(null); // Erreur 
objetGénial.setAttr("Hi !"); // Ok 
objetGénial.pubAttr = "C'est dommage ! :("; // Accessible de n'importe où 
objetGénial.protAttr = "Je suis protégé !"; // Erreur, vous devez créer un mutateur

Mis à jour le 4 août 2016 Songbird

Pour plus d’informations à propos du mot-clé protected, vous pouvez vous rendre ici.

Non pas encore, mais cela devrait être possible avec la version 2.1 de TypeScript qui devrait être disponible vers la fin de l'année 2016.

Vous pouvez cependant utiliser une des nombreuses bibliothèques JavaScript existantes qui vous permettront d'utiliser cette fonctionnalité.

Mis à jour le 4 août 2016 Songbird

L'opérateur pipe | définit une union de types et permet d'indiquer que le type d'une variable peut être l'un de ceux spécifiés dans l'union de type.
Ainsi, une variable peut avoir le type chaîne de caractères ou tableau de chaînes de caractères sans passer par le type any. Ce qui nous permet de continuer de bénéficier du contrôle du typage sur cette variable.

Exemple :

Code JavaScript : Sélectionner tout
1
2
3
4
5
6
7
function foo(s : string | string[]) { 
    // Le type du paramètre s ne peut pas être autre chose ici que string ou string[] 
} 
  
foo("Hi."); // Ok 
foo(["Hello", "world"]); // Ok 
foo(1); // Erreur

Mis à jour le 4 août 2016 Songbird

Oui.
Cette syntaxe de la norme ES2015 est depuis longtemps implémentée dans TypeScript. Elle permet de raccourcir la notation de base des fonctions anonymes et évite de redéfinir le contexte this.

Code TypeScript : Sélectionner tout
let maClotûreGéniale = () => return 0;

Vous pouvez bien entendu préciser le type de retour comme sur des fonctions :

Code TypeScript : Sélectionner tout
let maClotûreGéniale = (): number => return 0;

Simplification du problème du contexte this :

Code TypeScript : Sélectionner tout
1
2
3
4
5
6
7
8
9
function Personne(){ 
  this.âge = 0; 
  
  setInterval(() => { 
    this.âge++; // this réfère bien à l'objet personne 
  }, 1000); 
} 
  
var p = new Personne();

Mis à jour le 4 août 2016 Songbird

L'identifiant indéfini des paramètres est préfixé par des points de suspension ... comme ceci :

Code TypeScript : Sélectionner tout
function id_func(basic_arg : any, ...multiple_args);

Équivalent JavaScript :

Code JavaScript : Sélectionner tout
1
2
3
4
5
6
function id_func(basic_arg) { 
    var multiple_args = []; 
    for (var _i = 1; _i < arguments.length; _i++) { 
        multiple_args[_i - 1] = arguments[_i]; 
    } 
}

Obtenant ainsi seulement les arguments souhaités (sans avoir à parcourir tous les arguments de la fonction).

Mis à jour le 10 août 2016 Songbird

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2019 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Contacter le responsable de la rubrique TypeScript

Partenaire : Hébergement Web