ComparaisonComparaisons

interface vs type

interface décrit la forme d’un objet et fusionne avec une déclaration du même nom, tandis que type est un alias pour tout type, y compris les unions et les tuples.

Sur cette page

Comparaison point par point

#
  • Ce qu’elle décrit

    interface
    La forme d’un objet : champs et méthodes
    type
    N’importe quel type, par ex. objet, union, tuple, fonction
  • Extension

    interface
    Avec le mot extends
    type
    Avec l’intersection &
  • Deux déclarations du même nom

    interface
    Fusionnent en une seule (merging)
    type
    Erreur : Duplicate identifier 'Name'
  • Unions et tuples

    interface
    Impossible à exprimer
    type
    Usage de base
  • Implémentation par une classe (`implements`)

    type
    Oui, si l’alias décrit un objet
  • Usage typique

    interface
    Objets, contrats de classes, API publiques de bibliothèques
    type
    Unions, tuples, types de fonctions, résultats de types utilitaires

Exemple

#
TypeScript
interface CourseInterface {
  title: string
  modules: number
}

type CourseType = {
  title: string
  modules: number
}

type Difficulty = 'easy' | 'medium' | 'hard'

const html: CourseInterface = { title: 'HTML et CSS', modules: 11 }
const python: CourseType = { title: 'Python', modules: 12 }
const level: Difficulty = 'medium'

console.log(html.title, python.modules, level)
Résultat
HTML et CSS 12 medium

Définition et utilisation

#

Les deux constructions donnent un nom à la forme d’un objet, et dans la plupart des cas vous pouvez utiliser l’une ou l’autre. Le compilateur les vérifie de la même façon : un objet correspond au type s’il a les champs requis avec les bons types, peu importe que la forme ait été décrite par interface ou par type.

Les différences apparaissent à l’extension et avec les types qui ne sont pas des objets. Une interface s’étend avec le mot extends, et vous pouvez lui ajouter des champs avec une seconde déclaration du même nom, car les déclarations fusionnent. Un alias type s’étend avec l’intersection &, et deux déclarations du même nom sont une erreur de compilation. Seul type peut décrire une union, un tuple ou un type de fonction, car interface n’exprime que la forme d’un objet.

Pour les objets et les contrats de classes, interface est le choix naturel, surtout dans les bibliothèques, où la fusion de déclarations est utile. Pour les unions, les tuples, les types de fonctions et les résultats de types utilitaires, type est nécessaire. Beaucoup d’équipes adoptent une règle simple : les objets avec interface, tout le reste avec type.

Syntaxe

#
Syntaxe
interface Name {
  field: type
}

type Name = type

Plus d’exemples

#
La fusion de déclarations ne fonctionne que pour interface
TypeScript
interface Config {
  darkMode: boolean
}

interface Config {
  fontSize: number
}

const config: Config = { darkMode: true, fontSize: 16 }
console.log(Object.keys(config))
Résultat
['darkMode', 'fontSize']
type ne peut pas être rouvert par une seconde déclaration
TypeScript
type Profile = { name: string }
type Profile = { age: number }
// Erreur : Duplicate identifier 'Profile'.
Seul type exprime une union et un tuple
TypeScript
type Pair = [string, number]
type Status = 'draft' | 'published'

const [title, exp]: Pair = ['Flexbox', 20]
const status: Status = 'draft'

console.log(title, exp, status)
Résultat
Flexbox 20 draft

Bonnes pratiques

#
  • Si vous avez seulement besoin d’un contrat sans implémentation, rappelez-vous qu’une classe abstraite est un autre outil : une interface ne contient pas de code, une classe abstraite le peut.
  • Nommez les interfaces d’après ce que l’objet est (User, Course), sans le préfixe I.
  • Fixez dans le projet une seule convention pour les objets ordinaires, pour ne pas hésiter à chaque déclaration.

Entrées associées

#

Vous voyez une erreur ou il manque un exemple ? Écrivez-nous.