Nouvelles fonctionnalités TypeScript pour une convivialité améliorée

À bien des égards, TypeScript ne ressemble plus à un langage de programmation, mais à un puissant outil de linting et de documentation de code qui vous aide à écrire de meilleurs programmes JavaScript.

L'une des forces les plus notables de TypeScript est sa prise en charge de certaines des dernières fonctionnalités décrites dans la spécification ECMAScript. Lorsqu'un développeur effectue une mise à niveau vers une nouvelle version de TypeScript, cela signifie qu'il dispose de nouvelles fonctionnalités JavaScript. De plus, l'utilisation de ces fonctionnalités ne signifie pas de problèmes de compatibilité potentiels. TypeScript, en plus d'introduire les dernières fonctionnalités JavaScript, se distingue également par le fait que les créateurs du langage présentent constamment quelque chose de nouveau à la communauté des programmeurs TS, conçu pour augmenter la convivialité. Cela inclut, par exemple, des outils auxiliaires pour la refactorisation de code, des outils pour renommer des entités et pour trouver des endroits où elles sont utilisées dans des programmes.



Le matériel, dont nous publions la traduction aujourd'hui, abordera quelques nouvelles fonctionnalités intéressantes de TypeScript. Pour une liste complète des innovations TypeScript, jetez un œil ici .

Objets et tableaux immuables


Afin de rendre les tableaux immuables utilisés sous la forme de variables ordinaires et de paramètres de fonction pendant la compilation, dans TypeScript, vous pouvez utiliser des types auxiliaires Readonlyet ReadonlyArray. Cependant, leur utilisation peut provoquer un sentiment d'hétérogénéité dans l'annotation des types, en particulier lors de la déclaration de tableaux utilisant des caractères []après avoir spécifié un type. TypeScript 3.4 introduit une nouvelle façon d'étiqueter les paramètres qui sont des tableaux en lecture seule. Immédiatement, il est apparu une nouvelle façon de déclarer des variables qui devraient être immuables.

Amélioration de la convivialité avec des paramètres en lecture seule


Lorsque vous déclarez les paramètres des fonctions avec lesquelles vous devez travailler en tant que tableaux en lecture seule, vous pouvez désormais utiliser le mot clé readonly. Dans l'exemple suivant, les signatures des deux méthodes sont identiques:

function foo(s: ReadonlyArray<string>) { /* ... */ }
 
function foo(s: readonly string[]) { /* ... */ }

Dans les deux cas, toute tentative de modification du tableau (par exemple, en utilisant sa méthode push) entraînera une erreur. Cette innovation élimine le besoin d'un type générique auxiliaire, ce qui signifie que le code est plus facile à lire. Les types d'objets peuvent également être étiquetés en tant qu'entités en lecture seule, mais ils ont toujours besoin d'un type d'assistance Readonly.

Amélioration de l'utilisabilité des variables immuables à l'aide de la construction as const


Le type d'une variable déclarée à l'aide d'un mot-clé constne peut pas être modifié. Ce concept existe en JavaScript. Il est également adopté en TypeScript dans le but d'organiser un travail plus rigoureux avec les types. Mais lorsque vous travaillez avec des types de données d'objets, tels que des objets ou des tableaux, il s'avère que de telles structures ne sont pas vraiment immuables. L'utilisation d'un mot-clé constsignifie qu'une instance spécifique d'un objet ou d'un tableau restera inchangée lorsque vous travaillez avec une constante, mais le contenu de cet objet ou tableau peut être facilement modifié. Par exemple, sans enfreindre les règles de travail avec les entités const, vous pouvez ajouter de nouvelles valeurs au tableau à l'aide de la méthode push, vous pouvez modifier les valeurs des propriétés des objets.

Utilisation de ReadonlyetReadonlyArrayvous pouvez indiquer à TypeScript que le système doit traiter les entités comme si elles étaient vraiment immuables. Cela signifie que chaque fois qu'une tentative est faite dans le code pour changer une telle entité, un message d'erreur sera émis.

interface Person { 
  name: string; 
}
 
const person = { 
  name: 'Will' 
} as Readonly<Person>;
person.name = 'Diana'; // !

Dans TypeScript 3.4, entre autres innovations, le concept d'assertion de const (instruction constante), qui prévoit l'utilisation d'une construction, est apparu as const. Il s'agit d'une méthode simplifiée pour déclarer des constantes contenant des objets et des tableaux immuables. Ces déclarations sont construites en ajoutant as constune constante à la fin de la déclaration. Cette méthode présente un avantage supplémentaire, c'est que lorsque vous l'utilisez, vous n'avez pas besoin de spécifier explicitement le type dans l'instruction as const.

const person = { 
        name: 'Will' 
} as const;
 
person.name = 'Diana'; // !
 
//      as const
const array = [1, 2, 3] as const
array.push(4); // !

Type d'assistance Omettre


Il existe plusieurs types d'assistance dans TypeScript qui facilitent le mappage des types existants vers de nouveaux, ou définissent conditionnellement un type basé sur d'autres types.

Le type auxiliaire Partialpermet de marquer toutes les propriétés de l'objet comme facultatives. Avant la sortie de TypeScript 3.5, il s'est avéré que j'utilisais constamment un mécanisme intéressant dans mes projets. C'est la même chose que l'utilisation du type auxiliaire permet désormais de réaliser Omit. Ce type, comme son nom l'indique, vous permet d'exclure quelque chose d'autres types. Omitaccepte le type et la combinaison de clés, puis renvoie un nouveau type dont les propriétés décrites par les clés sont exclues. Il est révolu le temps où je devais utiliser Pickce Excludepour la mise en œuvre indépendamment des fonctionnalitésOmit.

//     TypeScript 3.5
type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
interface A { 
    propA?: string; 
    propB?: string; 
    propC?: string; 
}
 
type B = Omit<A, 'propA' | 'propC'>; 
const b: B = { propA: 'hi' }; // ;

Nouvelles fonctionnalités JavaScript prises en charge par TypeScript


Lorsque les suggestions de nouvelles fonctionnalités JavaScript atteignent le 4ème stade de coordination, elles sont considérées comme faisant partie de la prochaine version du langage. Certes, cela ne signifie pas que ces fonctionnalités peuvent être immédiatement utilisées en JavaScript, car leur prise en charge doit être implémentée dans des environnements appropriés. L'application doit avoir accès à ces opportunités partout où son fonctionnement normal est supposé.

La prise en charge des nouvelles fonctionnalités JavaScript est régulièrement ajoutée au compilateur TypeScript. En règle générale, le code qui implémente ces fonctionnalités peut être converti en code JavaScript compatible avec tous les navigateurs prenant en charge l'objectif de création de projet spécifié dans tsconfig.json.

▍ Vérifier la valeur nulle et non définie


Les développeurs JavaScript connaissent le concept de vérité et de fausseté. Lors de la vérification de la vérité peut être identifié 6 valeurs, qui sont toujours faux: 0, null, undefined, «», NaN, et, bien sûr, false. Le plus souvent, le développeur a juste besoin de savoir si la valeur est vraie ou fausse, mais dans certains cas, il suffit de savoir si la valeur étudiée est une valeur réelle nullou undefined. Par exemple, dans le cas où il est nécessaire de faire la distinction entre le code 0et undefined:

//  ||     ,  index  0
const getValueOrOne = (x?: number) => index || 1
getValueOrOne(0); // 1 <-- 

Ce code fonctionnera en définissant xla valeur écrite dans index, dans tous les cas sauf ceux où la valeur indexest égale 0. Pour que ce code fonctionne correctement dans n'importe quelle situation, il doit être réécrit à l'aide d'un schéma de test plus complexe pour trouver le type réel de valeur.

//   ,    
const getValueOrOne = (x?: number) => index !== null && index !== undefined ? : 1
getValueOrOne(0); // 0

Maintenant, le code fonctionne, mais il nécessite l'utilisation de vérifications plus complexes. Le nouvel opérateur de vérification de la valeur nullet undefined(cela ressemble à deux points d'interrogation - ??) simplifie ces vérifications en renvoyant la valeur située dans sa partie gauche, si elle n'est pas égale à nullet undefined. Sinon, il renvoie ce qui se trouve sur son côté droit.

// !
const getValueOrOne = (x?: number) => index ?? 1
getValueOrOne(0); // 0
getValueOrOne(2); // 2
getValueOrOne(); // 1

▍ Séquences optionnelles


Une autre nouvelle fonctionnalité JavaScript disponible dans TypeScript 3.7 est l'opérateur permettant d'organiser des séquences facultatives ( ?.). J'ai d'abord rencontré un tel opérateur dans le langage de programmation Groovy. Depuis lors, je voulais qu'il apparaisse également en JavaScript. Cet opérateur vous permet d'organiser l'accès aux propriétés incorporées des objets sans avoir besoin de vérifier constamment leur existence. Si, lors de l'accès à une propriété, cet opérateur rencontre une valeur undefined, il retournera simplement cette valeur sans lancer d'erreur TypeError.

//    
const value = foo && foo.bar && foo.bar.baz;
 
//    
const value = foo?.bar?.baz;

L'opérateur de séquence facultatif combiné à l'opérateur de vérification des valeurs nullet undefineddonne au développeur encore plus de possibilités, permettant, par exemple, d'écrire dans la variable soit la valeur d'une propriété imbriquée de l'objet, soit, si une telle propriété n'existe pas, une valeur standard. Voici à quoi ça ressemble:

const value = foo?.bar?.baz ?? 'default value';

▍ Champs de cours privés


TypeScript, depuis l'avènement de ce langage, a son propre concept de champs de classe privés déclarés avec un modificateur d'accès private. Ce concept est apparu dans TypeScript avant même que les classes ne soient décrites dans le standard ECMAScript. Mais dans TypeScript, ce concept fait référence aux mécanismes qui fonctionnent lors de la compilation du code. Le compilateur générera une erreur si le champ privé de la classe n'est pas accessible à partir des propres méthodes de la classe. Désormais, en JavaScript, il est possible de déclarer les propriétés et méthodes privées d'une classe. Mais cette fonctionnalité est à la fois sémantiquement et syntaxiquement différente de ce qui existait encore dans TypeScript.

Les champs privés en JavaScript ne sont pas déclarés à l'aide d'un modificateur d'accès private. Au lieu de cela, ils sont déclarés en mettant un symbole au début de leur nom #.

class Fan 
    #on = false
    private name = 'fan';
 
    turnOn() { 
        this.#on = true
    }
   isTurnedOn() { 
        return this.#on; 
    }
}
 
const fan = new Fan(); 
fan.isTurnedOn(); // false  
fan.turnOn(); 
fan.isTurnedOn(); // true
 
fan.on; //  
fan.#on; // 
fan.name; //   ,    JS

JavaScript prend désormais en charge les champs privés, la proposition de méthodes privées est dans la troisième phase d'approbation. Actuellement, le modificateur privateet le caractère #du nom de champ ne peuvent pas être utilisés ensemble. Les deux approches peuvent être utiles pendant le développement, et celle à choisir dépend du programmeur. Voici un podcast qui discute de la nouvelle syntaxe pour déclarer des champs privés.

▍Utilisation du mot-clé wait au niveau supérieur du code


Les mécanismes de programmation asynchrones étendent considérablement les capacités de JavaScript et de TypeScript. Au début, des promesses sont apparues dans ce domaine, puis - une conception async/awaitqui vous permet d'écrire du code asynchrone plus propre.

Un des cas où les promesses sont utilisées, et non, async/awaitest un appel de méthode asynchrone en dehors de la fonction asynchrone. Par exemple, au niveau supérieur du module ou du code d'application. Pour contourner cette situation, vous pouvez proposer de créer une expression de fonction immédiatement appelée asynchrone (IIFE, Expression de fonction immédiatement invoquée) et d'exécuter du code asynchrone à l'intérieur d'une telle expression.

(async () => { 
    const response = await fetch('https://api.github.com/users/sitepen'); 
    const data = await response.json(); 
    console.log(`Check out the blog at ${data.blog}`); 
})();

TypeScript prend désormais en charge la capacité de JavaScript à utiliser des mots clés awaitau plus haut niveau de code. Cela signifie que l'attente peut être utilisée en dehors des fonctions déclarées avec le mot-clé async. C'est très bon pour écrire du code compact et clair. Certes, les expressions awaitau niveau supérieur du code sont critiquées pour le fait qu'elles peuvent ralentir le chargement des modules et créer une situation dans laquelle un certain module peut ralentir le chargement de l'application entière, car le système doit attendre la fin de l'opération asynchrone, puis exécuter tout le code du module.

const response = await fetch('https://api.github.com/users/sitepen'); 
const data = await response.json();
 
export default { ...data };

Environnement d'expérimentation TypeScript amélioré


Cela ne peut pas être appelé une nouvelle fonctionnalité TypeScript, mais étant donné que nous parlons de TypeScript en tant qu'outil, TypeScript Playground peut être appelé un outil efficace pour vérifier rapidement toutes les constructions TypeScript et afficher le code JavaScript dans lequel ces constructions se transforment. La plupart des exemples ici sont testés spécifiquement dans TypeScript Playground. Cet environnement prend désormais en charge la possibilité de sélectionner une version spécifique de TypeScript (y compris la prise en charge des versions bêta). Il comprend plusieurs exemples qui aideront les débutants à démarrer avec TypeScript.

Sommaire


TypeScript est un outil qui vous aide à écrire du code JavaScript meilleur et plus expressif. Les outils d'assistance TypeScript facilitent la résolution de tâches complexes, telles que la refactorisation et le renommage d'entités, qui sont beaucoup plus compliquées dans le JavaScript ordinaire. TypeScript introduit constamment de nouveaux mécanismes, tels que Omitet as const. Dans la langue, on peut observer une amélioration continue du support des types complexes. TypeScript implémente rapidement les dernières fonctionnalités JavaScript. C'est pourquoi de nombreuses personnes choisissent TypeScript, le percevant comme un outil, un langage et un écosystème.

Chers lecteurs! Quelles nouvelles fonctionnalités TypeScript trouvez-vous les plus intéressantes?


All Articles