Uppercase, Lowercase, Capitalize, Uncapitalize
Types intégrés qui changent la casse des lettres dans les types textuels, par ex. "gold" en "GOLD".
Exemple
#type Rank = 'bronze' | 'silver' | 'gold'
type RankConstant = Uppercase<Rank>
// type RankConstant = "BRONZE" | "SILVER" | "GOLD"
function capitalize<S extends string>(text: S): Capitalize<S> {
return (text.charAt(0).toUpperCase() + text.slice(1)) as Capitalize<S>
}
const label = capitalize('silver')
// const label: "Silver"
const constant: RankConstant = 'GOLD'
console.log(label, constant)Silver GOLD
Définition et utilisation
#Quatre types intégrés changent la casse des lettres dans les types littéraux. Uppercase met toutes les lettres en majuscules, Lowercase en minuscules, Capitalize met seulement la première lettre en majuscule, et Uncapitalize la première en minuscule. Ils fonctionnent aussi sur les unions : Uppercase<"html" | "css"> est "HTML" | "CSS".
Une telle transformation ne peut pas s’écrire avec des types ordinaires, c’est pourquoi le compilateur calcule lui-même le résultat (d’où le nom intrinsic, c’est-à-dire intégré). Ces types n’agissent qu’à la compilation. Dans le programme en cours d’exécution, il faut changer la casse séparément, par ex. avec la méthode toUpperCase(), et on marque généralement le résultat avec une assertion as.
Ils sont surtout utiles combinés avec les types de gabarits (template literal types) et les types mappés : à partir du nom d’événement start, vous créez le nom du gestionnaire onStart, et à partir du rang "gold", la constante "GOLD". Utilisés avec un simple string, ils agissent comme un filtre : Uppercase<string> n’accepte qu’une chaîne qui reste inchangée après conversion en majuscules.
Syntaxe
#type A = Uppercase<"html"> // "HTML"
type B = Lowercase<"CSS"> // "css"
type C = Capitalize<"level"> // "Level"
type D = Uncapitalize<"Title"> // "title"Quatre types
#Uppercase<S>
"gold" → "GOLD"
Toutes les lettres en majuscules.Lowercase<S>
"HTML" → "html"
Toutes les lettres en minuscules.Capitalize<S>
"level" → "Level"
Première lettre en majuscule, le reste inchangé.Uncapitalize<S>
"Title" → "title"
Première lettre en minuscule, le reste inchangé.
Plus d’exemples
#type LessonEvents = {
start: { lesson: string }
finish: { lesson: string; exp: number }
}
type Handlers = {
[K in keyof LessonEvents as `on${Capitalize<K>}`]: (event: LessonEvents[K]) => void
}
// type Handlers = {
// onStart: (event: { lesson: string }) => void
// onFinish: (event: { lesson: string; exp: number }) => void
// }
const handlers: Handlers = {
onStart: (e) => console.log(`Début : ${e.lesson}`),
onFinish: (e) => console.log(`Fin : ${e.lesson}, +${e.exp} EXP`)
}
handlers.onStart({ lesson: 'Grid' })
handlers.onFinish({ lesson: 'Grid', exp: 15 })Début : Grid Fin : Grid, +15 EXP
const courseCode: Uppercase<string> = 'HTML-1'
const wrongCode: Uppercase<string> = 'html-1'
// Erreur : Type 'string' is not assignable to type 'Uppercase<string>'.Bonnes pratiques
#- Ces types ne changent pas la valeur. Dans le code en cours d’exécution, vous avez toujours besoin de
toUpperCase()outoLowerCase(), et vous assurez la conformité au type avec une assertion, comme dans la fonctioncapitalizede l’exemple. - Seules les lettres changent.
Capitalize<"3d-model">reste inchangé, car le premier caractère est un chiffre. - Pour changer de notation, par ex. de
snake_caseàcamelCase, ces types ne suffisent pas. Il faut un type personnalisé construit avecinferet des types de gabarits.
Entrées associées
#- Types littéraux de gabaritDes types textuels construits à partir de gabarits, comme `${A}-${B}`.
- Types mappésCréent un nouveau type d’objet en transformant chaque clé d’un autre type.
- Types littérauxDes types qui n’autorisent que des valeurs précises, par ex. "easy" | "hard".
- keyofCrée une union des noms de clés d’un type d’objet donné.
- inferExtrait un type de l’intérieur d’un autre type, dans un type conditionnel.
Vous voyez une erreur ou il manque un exemple ? Écrivez-nous.