Microsoft a annoncé la disponibilité de TypeScript 4.3, son langage maison construit au dessus de JavaScript et pour apporter à ce dernier le type statique. TypeScript 4.3 est une mouture riche dans laquelle nous remarquons principalement l'arrivé du mot clé override et du commutateur noImplicitOverride.

Microsoft justifie l'arrivé du mot clé override par le fait que s'il est très facile d'étendre des classes en JavaScript cela peut introduire des erreurs. Microsoft donne l'exemple suivant :

class SomeComponent {
    show() {
        // ...
    }
    hide() {
        // ...
    }
}

class SpecializedComponent extends SomeComponent {
    show() {
        // ...
    }
    hide() {
        // ...
    }
}

SpecializedComponent étend SomeComponent. et redéfinit les méthode show et hide. Mais que se passe-t-il si quelqu'un décide de supprimer show et ride pour les remplacer par une seule méthode ?

class SomeComponent {
-    show() {
-        // ...
-    }
-    hide() {
-        // ...
-    }
+    setVisible(value: boolean) {
+        // ...
+    }
}

class SpecializedComponent extends SomeComponent {
     show() {
         // ...
     }
     hide() {
         // ...
     }

}

SpecializedComponent n'est pas mis à jour dans ce cas. Une partie du problème ici est qu'un dévelppeur ne peut pas indiquer clairement s'il voulait ajouter une nouvelle méthode ou remplacer une méthode existante. C'est pourquoi TypeScript 4.3 ajoute le mot-clé override.

class SpecializedComponent extends SomeComponent {
    override show() {
        // ...
    }
    override hide() {
        // ...
    }
}

Lorsqu'une méthode est marquée par override, TypeScript s'assurera toujours qu'une méthode portant le même nom existe dans la classe de base.

Mais alors que se passera-t-il si le développeur oublie de donner le mot-clé override lorsque c'est nécessaire ? Par exemple :

class Base {
    someHelperMethod() {
        // ...
    }
}

class Derived extends Base {
    // Oops! We weren't trying to override here,
    // we just needed to write a local helper method.
    someHelperMethod() {
        // ...
    }
}

Pour éviter que le développeur puis 'oublier' d'utiliser le mot-clé override, TypeScript 4.3 dispose d'un nouveau commutateur --noImplicitOverride. Lorsque cette option est activée, il devient une erreur de remplacer toute méthode d'une superclasse à moins que vous n'utilisiez explicitement override.

Retrouvez toutes les nouveautés de TypeScript 4.3 dans l'annonce de Microsoft.