Fonctions TypeScript

Une fonction est un groupe d'instructions qui exécutent ensemble une tâche.

Vous pouvez diviser votre code en différentes fonctions. La façon de répartir le code entre différentes fonctions dépend de vous, mais logiquement, la division est généralement basée sur le fait que chaque fonction exécute une tâche spécifique.

Une déclaration de fonction indique au compilateur le nom de la fonction, son type de retour et ses paramètres. La définition de fonction fournit le corps réel de la fonction.


Définition de fonction

Une fonction est un bloc de code entouré d'accolades, précédé du mot-clé function :

La syntaxe est la suivante :

function function_name()
{
    // 执行代码
}

Exemple

TypeScript

function () { //Définition de fonction console.log("Appel de la fonction") }

Appel d'une fonction

Une fonction ne peut exécuter le code qu'elle contient que lorsqu'elle est appelée.

La syntaxe est la suivante :

function_name()

Exemple

TypeScript

function test() { //Définition de fonction console.log("Appel de la fonction") } test() //Appel de la fonction

Valeur de retour de la fonction

Parfois, nous voulons qu'une fonction renvoie le résultat de son exécution à l'endroit où elle a été appelée.

Cela peut être réalisé en utilisant l'instruction return.

Lorsqu'une instruction return est utilisée, la fonction arrête son exécution et renvoie la valeur spécifiée.

La syntaxe est la suivante :

function function_name():return_type { 
    // 语句
    return value; 
}
  • return_type est le type de la valeur de retour.

  • Le mot-clé return est suivi du résultat à renvoyer.

  • En général, une fonction n'a qu'une seule instruction return.

  • Le type de la valeur renvoyée doit être cohérent avec le type de retour (return_type) défini dans la fonction.

Exemple

TypeScript

//Définition de fonction function greet():string { //Retourner une chaîne return "Hello World" } function caller() { var msg = greet() //Appeler la fonction greet() console.log(msg) } //Appel de la fonction caller()
  • Dans l'exemple, une fonction est définiegreet(), et le type de retour est string.

  • greet()La fonction retourne à l'endroit où elle a été appelée via l'instruction return, c'est-à-dire la variable msg, puis affiche la valeur de retour.

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

//Définition de fonction function greet() { return "Hello World"; } function caller() { var msg = greet(); //Appeler la fonction greet() console.log(msg); } //Appel de la fonction caller();

Fonctions avec paramètres

Lors de l'appel d'une fonction, vous pouvez lui passer des valeurs, et ces valeurs sont appelées paramètres.

Ces paramètres peuvent être utilisés dans la fonction.

Vous pouvez envoyer plusieurs paramètres à une fonction, chaque paramètre étant séparé par une virgule,:

La syntaxe est la suivante :

function func_name( param1 [:datatype], param2 [:datatype]) {   
}
  • param1 et param2 sont des noms de paramètres.

  • datatype est le type du paramètre.

Exemple

TypeScript

function add(x: number, y: number): number { return x + y; } console.log(add(1,2))
  • Dans l'exemple, une fonction est définieadd(), et le type de retour est number.

  • add()La fonction définit deux paramètres de type number, additionne les deux paramètres et renvoie le résultat.

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

function add(x, y) { return x + y; } console.log(add(1, 2));

La sortie est :

3

Paramètres optionnels et par défaut

Paramètres facultatifs

Dans les fonctions TypeScript, si nous définissons des paramètres, nous devons passer ces paramètres sauf si nous les définissons comme optionnels. Les paramètres optionnels sont marqués par un point d'interrogation ?.

Exemple

TypeScript

function buildName(firstName: string, lastName: string) { return firstName + " " + lastName; } let result1 = buildName("Bob"); //Erreur, paramètre manquant let result2 = buildName("Bob", "Adams", "Sr."); //Erreur, trop de paramètres let result3 = buildName("Bob", "Adams"); //Correct

Dans l'exemple suivant, nous définissons lastName comme un paramètre optionnel :

TypeScript

function buildName(firstName: string, lastName?: string) { if (lastName) return firstName + " " + lastName; else return firstName; } let result1 = buildName("Bob"); //Correct let result2 = buildName("Bob", "Adams", "Sr."); //Erreur, trop de paramètres let result3 = buildName("Bob", "Adams"); //Correct

Les paramètres optionnels doivent suivre les paramètres obligatoires. Si, dans l’exemple ci-dessus, nous voulons que firstName soit optionnel et lastName obligatoire, nous devons alors ajuster leurs positions et placer firstName en dernier.

Peu importe si tous les paramètres sont optionnels.

Paramètres par défaut

Nous pouvons également définir des valeurs par défaut pour les paramètres, de sorte que, lors de l’appel de la fonction, si la valeur du paramètre n’est pas transmise, le paramètre par défaut est utilisé. La syntaxe est :

function function_name(param1[:type],param2[:type] = default_value) { 
}
Remarque : un paramètre ne peut pas être défini à la fois comme optionnel et par défaut.

Exemple

Dans l’exemple suivant, le paramètre rate de la fonction est défini sur une valeur par défaut de 0.50. Lorsque la fonction est appelée sans transmettre le paramètre, la valeur par défaut est utilisée :

TypeScript

function calculate_discount(price:number,rate:number = 0.50) { var discount = price * rate; console.log("Résultat du calcul :",discount); } calculate_discount(1000) calculate_discount(1000,0.30)

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

function calculate_discount(price, rate) { if (rate === void 0) { rate = 0.50; } var discount = price * rate; console.log("Résultat du calcul :", discount); } calculate_discount(1000); calculate_discount(1000, 0.30);

La sortie est :

计算结果:  500
计算结果:  300

Paramètres du reste

Il y a des cas où nous ne savons pas combien de paramètres passer à une fonction. Dans ce cas, nous pouvons utiliser les paramètres du reste pour la définir.

La syntaxe des paramètres du reste nous permet de passer un nombre indéfini de paramètres sous forme de tableau.

TypeScript

function buildName(firstName: string, ...restOfName: string[]) { return firstName + " " + restOfName.join(" "); } let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");

Le dernier paramètre nommé de la fonction, restOfName, est préfixé par ..., et il devient un tableau composé des paramètres restants, avec des valeurs d'index allant de 0 (inclus) à restOfName.length (exclu).

TypeScript

function addNumbers(...nums:number[]) { var i; var sum:number = 0; for(i = 0;i<nums.length;i++) { sum = sum + nums[i]; } console.log("La somme est :",sum) } addNumbers(1,2,3) addNumbers(10,10,10,10,10)

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

function addNumbers() { var nums = []; for (var _i = 0; _i < arguments.length; _i++) { nums[_i] = arguments[_i]; } var i; var sum = 0; for (i = 0; i < nums.length; i++) { sum = sum + nums[i]; } console.log("La somme est :", sum); } addNumbers(1, 2, 3); addNumbers(10, 10, 10, 10, 10);

La sortie est :

和为: 6
和为: 50

Fonctions anonymes

Une fonction anonyme est une fonction sans nom de fonction.

Les fonctions anonymes sont déclarées dynamiquement à l'exécution du programme. À part le fait de ne pas avoir de nom de fonction, elles sont identiques aux fonctions standard.

Nous pouvons affecter une fonction anonyme à une variable, et une telle expression devient une expression de fonction.

La syntaxe est la suivante :

var res = function( [arguments] ) { ... }

Exemple

Fonction anonyme sans paramètres :

TypeScript

var function = return() { return "hello world"; } console.log(msg())

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var function = return () { return "hello world"; }; console.log(msg());

La sortie est :

hello world

Fonction anonyme avec paramètres :

TypeScript

var res = function(a:number,b:number) { return a*b; }; console.log(res(12,2))

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var res = function (a, b) { return a * b; }; console.log(res(12, 2));

La sortie est :

24

Fonctions anonymes auto-invoquées

Une fonction anonyme peut être auto-invoquée en utilisant () après la fonction :

TypeScript

(function () { var x = "Hello!!"; console.log(x) })()

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

(function () { var x = "Hello!!"; console.log(x) })()

La sortie est :

Hello!!

Constructeur Function

TypeScript prend également en charge l'utilisation du constructeur intégré de JavaScript Function() pour définir des fonctions :

La syntaxe est la suivante :

var res = new Function ([arg1[, arg2[, ...argN]],] functionBody)

Description du paramètre :

  • arg1, arg2, ... argN: Une liste de paramètres.
  • functionBody: Une chaîne contenant des instructions JavaScript qui incluent la définition de la fonction.

Exemple

TypeScript

var myFunction = new Function("a", "b", "return a * b"); var x = myFunction(4, 3); console.log(x);

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var myFunction = new Function("a", "b", "return a * b"); var x = myFunction(4, 3); console.log(x);

La sortie est :

12

Fonctions récursives

Une fonction récursive est une fonction qui s'appelle elle-même à l'intérieur de la fonction.

Par exemple :
Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine racontant une histoire à un petit moine ! Quelle était l'histoire ? "Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine racontant une histoire à un petit moine ! Quelle était l'histoire ? 'Il était une fois une montagne, dans la montagne il y avait un temple, dans le temple il y avait un vieux moine racontant une histoire à un petit moine ! Quelle était l'histoire ? …'"

Exemple

TypeScript

function factorial(number) { if (number <= 0) { //Arrêter l'exécution return 1; } else { return (number * factorial(number - 1)); //S'appelle elle-même } }; console.log(factorial(6)); //Sortie 720

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

function factorial(number) { if (number <= 0) { //Arrêter l'exécution return 1; } else { return (number * factorial(number - 1)); //S'appelle elle-même } } ; console.log(factorial(6)); //Sortie 720

La sortie est :

720

Fonctions lambda

Les fonctions lambda sont également appelées fonctions fléchées.

Les expressions de fonction fléchée ont une syntaxe plus courte que les expressions de fonction.

Une fonction avec une seule instruction :

( [param1, param2,…param n] )=>statement;

Exemple

L'exemple suivant déclare une fonction d'expression lambda qui renvoie la somme de deux nombres :

TypeScript

var foo = (x:number)=>10 + x console.log(foo(100)) //La sortie est 110

Compilez le code ci-dessus pour obtenir le code JavaScript suivant :

JavaScript

var foo = function (x) { return 10 + x; }; console.log(foo(100)); //La sortie est 110

La sortie est :

110

Une fonction est un bloc d'instructions :

( [param1, param2,…param n] )=> {
 
    // 代码块
}

Exemple

L'exemple suivant déclare une fonction d'expression lambda qui renvoie la somme de deux nombres :

TypeScript

var foo = (x:number)=> { x = 10 + x console.log(x) } foo(100)

La compilation du code ci-dessus produit le code JavaScript suivant :

JavaScript

var foo = function (x) { x = 10 + x; console.log(x); }; foo(100);

La sortie est :

110
Nous n'avons pas besoin de spécifier les types des paramètres ; les types sont inférés dans la fonction :

TypeScript

var func = (x)=> { if(typeof x=="number") { console.log(x+"est un nombre") } else if(typeof x=="string") { console.log(x+"est une chaîne") } } func(12) func("Tom")

La compilation du code ci-dessus produit le code JavaScript suivant :

JavaScript

var func = function (x) { if (typeof x == "number") { console.log(x + "est un nombre"); } else if (typeof x == "string") { console.log(x + "est une chaîne"); } }; func(12); func("Tom");

La sortie est :

12 是一个数字
Tom 是一个字符串

Un seul paramètre()est facultatif :

TypeScript

var display = x => { console.log("La sortie est"+x) } display(12)

La compilation du code ci-dessus produit le code JavaScript suivant :

JavaScript

var display = function (x) { console.log("La sortie est" + x); }; display(12);

La sortie est :

输出为 12

Lorsqu'il n'y a pas de paramètres, des parenthèses vides peuvent être utilisées :

TypeScript

var disp =()=> { console.log("Fonction invoquée"); } disp();

La compilation du code ci-dessus produit le code JavaScript suivant :

JavaScript

var disp = function () { console.log("Appel de la fonction"); }; disp();

La sortie est :

Call function

Surcharge de fonction

La surcharge signifie que les méthodes ont le même nom mais des paramètres différents, et que les types de retour peuvent être identiques ou différents.

Chaque méthode surchargée (ou constructeur) doit avoir une liste de types de paramètres unique.

Différents types de paramètres :

function disp(string):void; 
function disp(number):void;

Nombre de paramètres différent :

function disp(n1:number):void; 
function disp(x:number,y:number):void;

Ordre différent des types de paramètres :

function disp(n1:number,s1:string):void; 
function disp(s:string,n:number):void;

Si les types de paramètres sont différents, le type de paramètre doit être défini surany。

Si le nombre de paramètres diffère, vous pouvez définir les paramètres différents comme facultatifs.

Exemple

L'exemple suivant définit différents types de paramètres et différents nombres de paramètres :

TypeScript

function disp(s1:string):void; function disp(n1:number,s1:string):void; function disp(x:any,y?:any):void { console.log(x); console.log(y); } disp("abc") disp(1,"xyz");

La compilation du code ci-dessus produit le code JavaScript suivant :

JavaScript

function disp(x, y) { console.log(x); console.log(y); } disp("abc"); disp(1, "xyz");

La sortie est :

abc
undefined
1
xyz
Autres extensions