FAQ TypeScriptConsultez toutes les FAQ

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

1
2
3
4
(function() { 
    var greets = "Hello"; 
    console.log(greets + " world !"); 
})();

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

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

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

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

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

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

let maClotûreGéniale = () => return 0;

let maClotûreGéniale = (): number => return 0;

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();

function id_func(basic_arg : any, ...multiple_args);

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]; 
    } 
}