Entrainement
Module
Déclarer des types de variables en TypeScript - Training
Découvrez les types disponibles et la façon de les associer à des variables.
Ce navigateur n’est plus pris en charge.
Effectuez une mise à niveau vers Microsoft Edge pour tirer parti des dernières fonctionnalités, des mises à jour de sécurité et du support technique.
Une valeur de type est une valeur qui classifie d’autres valeurs. Une valeur classifiée par un type est dite conforme à ce type. Le système de type M se compose des genres de types suivants :
Types primitifs, qui classifient les valeurs primitives (binary
, date
, datetime
, datetimezone
, duration
, list
, logical
, null
, number
, record
, text
, time
, type
) et incluent également un certain nombre de types abstraits (function
, table
, any
, anynonnull
et none
)
Types d’enregistrements, qui classifient les valeurs d’enregistrement en fonction des noms de champs et des types de valeurs
Types de listes, qui classifient les listes à l’aide d’un type de base d’élément unique
Types de fonctions, qui classifient les valeurs de fonction en fonction des types de leurs paramètres et valeurs de retour
Types de tables, qui classifient les valeurs de table en fonction des noms de colonnes, des types de colonnes et des clés
Types Nullable, qui classifient la valeur Null en plus de toutes les valeurs classifiées par un type de base
Types de types, qui classifient les valeurs qui sont des types
L’ensemble de types primitifs comprend les types de valeurs primitives et un certain nombre de types abstraits, qui sont des types qui ne classifient aucune valeur de manière unique : function
, table
, any
, anynonnull
et none
. Toutes les valeurs de fonction sont conformes au type abstrait function
, toutes les valeurs de table au type abstrait table
, toutes les valeurs au type abstrait any
, toutes les valeurs non-null au type abstrait anynonnull
et les valeurs absentes au type abstrait none
. Une expression de type none
doit déclencher une erreur ou échouer, car aucune valeur ne peut être produite conforme au type none
. Notez que les types primitifs function
et table
sont abstraits, car aucune fonction ou table n’est directement de ces types, respectivement. Les types primitifs record
et list
ne sont pas abstraits, car ils représentent un enregistrement ouvert sans champs définis et une liste de type any, respectivement.
Tous les types qui ne sont pas membres de l’ensemble fermé de types primitifs plus leurs contreparties non-nullables sont collectivement désignés sous le terme de types personnalisés. Les types personnalisés peuvent être écrits à l’aide d’un type-expression
:
type-expression :
primary-expression
type
type principal
type :
primary-expression
primary-type
primary-type :
primitive-type
record-type
list-type
function-type
table-type
nullable-type
primitive-type : une des valeurs suivantes
any anynonnull binary date datetime datetimezone duration function list logical
none null number record table text time type
Les noms primitive-type sont des mots clés contextuels reconnus uniquement dans un contexte de type. L’utilisation de parenthèses dans un contexte de type redéplace la grammaire dans un contexte d’expression régulière, ce qui nécessite l’utilisation du mot clé type pour revenir dans un contexte de type. Par exemple, pour appeler une fonction dans un contexte de type, vous pouvez utiliser des parenthèses :
type nullable ( Type.ForList({type number}) )
// type nullable {number}
Vous pouvez aussi utiliser des parenthèses pour accéder à une variable dont le nom est en conflit avec un nom primitive-type :
let record = type [ A = any ] in type {(record)}
// type {[ A = any ]}
L’exemple suivant définit un type qui classifie une liste de nombres :
type { number }
De même, l’exemple suivant définit un type personnalisé qui classifie des enregistrements avec des champs obligatoires nommés X
et Y
dont les valeurs sont des nombres :
type [ X = number, Y = number ]
Le type inscrit d’une valeur est obtenu à l’aide de la fonction de bibliothèque standard Value.Type, comme illustré dans les exemples suivants :
Value.Type( 2 ) // type number
Value.Type( {2} ) // type list
Value.Type( [ X = 1, Y = 2 ] ) // type record
L’opérateur is
est utilisé pour déterminer si le type d’une valeur est compatible avec un type donné, comme indiqué dans les exemples suivants :
1 is number // true
1 is text // false
{2} is list // true
L’opérateur as
vérifie si la valeur est compatible avec le type donné, et génère une erreur si ce n’est pas le cas. Autrement, il retourne la valeur d’origine.
Value.Type( 1 as number ) // type number
{2} as text // error, type mismatch
Notez que les opérateurs is
et as
acceptent uniquement des types primitifs nullables comme opérande de droite. M n’offre aucun moyen de vérifier les valeurs en termes de conformité aux types personnalisés.
Un type X
est compatible avec un type Y
si et seulement si toutes les valeurs conformes à X
sont également conformes à Y
. Tous les types sont compatibles avec le type any
, et aucun type (sauf none
lui-même) n’est compatible avec le type none
. Le graphique suivant montre la relation de compatibilité. (La compatibilité de type est réflexive et transitive. Elle forme un treillis avec le type any
comme valeur supérieure et le type none
comme valeur inférieure.) Les noms des types abstraits sont définis en italiques.
Les opérateurs suivants sont définis pour les valeurs de type :
Opérateur | Résultat |
---|---|
x = y |
Égal à |
x <> y |
Différent de |
x ?? y |
Coalesce |
Le type natif des valeurs de type est le type intrinsèque type
.
Les types du langage M forment une hiérarchie disjointe enracinée au type any
, qui est le type qui classifie toutes les valeurs. Toute valeur M est conforme à un seul sous-type primitif de any
. L’ensemble fermé de types primitifs dérivant du type any
est le suivant :
type null
, qui classifie la valeur Null.type logical
, qui classifie les valeurs true et false.type number
, qui classifie les valeurs numériques.type time
, qui classifie les valeurs d’heure.type date
, qui classifie les valeurs de date.type datetime
, qui classifie les valeurs datetime.type datetimezone
, qui classifie les valeurs datetimezone.type duration
, qui classifie les valeurs de durée.type text
, qui classifie les valeurs de texte.type binary
, qui classifie les valeurs binaires.type type
, qui classifie les valeurs de type.type list
, qui classifie les valeurs de liste.type record
, qui classifie les valeurs d’enregistrement.type table
, qui classifie les valeurs de table.type function
, qui classifie les valeurs de fonction.type anynonnull
, qui classifie toutes les valeurs à l’exception de Null.type none
, qui classifie aucune valeur.Le type any
est abstrait, il classifie toutes les valeurs en M, et tous les types en M sont compatibles avec any
. Les variables de type any
peuvent être liées à toutes les valeurs possibles. any
étant abstrait, il ne peut pas être attribué à des valeurs ; autrement dit, aucune valeur n’est directement de type any
.
Toute valeur qui est une liste est conforme au type intrinsèque list
, qui n’impose aucune restriction sur les éléments dans une valeur de liste.
list-type:
{
type d’élément}
item-type :
type
Le résultat de l’évaluation d’un list-type est une valeur de type de liste dont le type de base est list
.
Les exemples suivants illustrent la syntaxe de déclaration de types de listes homogènes :
type { number } // list of numbers type
{ record } // list of records type
{{ text }} // list of lists of text values
Une valeur est conforme à un type de liste si la valeur est une liste et que chaque élément de cette valeur de liste est conforme au type d’élément du type de liste.
Le type d’élément d’un type de liste indique une limite : tous les éléments d’une liste conforme sont conformes au type d’élément.
Toute valeur qui est un enregistrement est conforme au type intrinsèque record, qui n’impose aucune restriction sur les valeurs ou les noms des champs dans une valeur d’enregistrement. Une valeur record-type est utilisée pour limiter l’ensemble de noms valides, ainsi que les types de valeurs qui sont autorisés à être associés à ces noms.
record-type:
[
open-record-marker]
[
field-specification-listopt]
[
field-specification-list , open-record-marker]
field-specification-list :
field-specification
field-specification-specification-list,
field-specification :
optional
opt field-name field-type-specificationopt
field-type-specification :
=
type de champ
field-type :
type
open-record-marker :
...
Le résultat de l’évaluation d’un record-type est une valeur de type dont le type de base est record
.
Les exemples suivants illustrent la syntaxe de déclaration des types d’enregistrements :
type [ X = number, Y = number]
type [ Name = text, Age = number ]
type [ Title = text, optional Description = text ]
type [ Name = text, ... ]
Les types d’enregistrements sont fermés par défaut, ce qui signifie que les champs supplémentaires absents de la fieldspecification-list ne sont pas autorisés à être présents dans les valeurs conformes. L’inclusion du openrecord-marker dans le type d’enregistrement déclare le type comme étant ouvert, ce qui autorise les champs absents de la liste de spécifications de champ. Les deux expressions suivantes sont équivalentes :
type record // primitive type classifying all records
type [ ... ] // custom type classifying all records
Une valeur est conforme à un type d’enregistrement si la valeur est un enregistrement et que chaque spécification de champ dans le type d’enregistrement est satisfaite. Une spécification de champ est satisfaite si l’une des conditions suivantes est remplie :
Il existe un nom de champ correspondant à l’identificateur de la spécification dans l’enregistrement, et la valeur associée est conforme au type de la spécification
La spécification est marquée comme étant facultative et aucun nom de champ correspondant n’a été trouvé dans l’enregistrement
Une valeur conforme peut contenir des noms de champs qui ne sont pas listés dans la liste de spécifications de champ si et uniquement si le type d’enregistrement est ouvert.
Toute valeur de fonction est conforme au type primitif function
, qui n’impose aucune restriction sur les types des paramètres formels de la fonction ou sur la valeur de retour de la fonction. Une valeur function-type personnalisée est utilisée pour imposer des restrictions de type sur les signatures des valeurs de fonction conformes.
function-type:
function (
parameter-specification-listopt)
function-return-type
parameter-specification-list :
required-parameter-specification-list
required-parameter-specification-list,
optional-parameter-specification-list
optional-parameter-specification-list
required-parameter-specification-list :
required-parameter-specification
required-parameter-specification,
required-parameter-specification-list
required-parameter-specification :
parameter-specification
optional-parameter-specification-list :
optional-parameter-specification
optional-parameter-specification,
optional-parameter-specification-list
optional-parameter-specification :
optional
parameter-specification
parameter-specification :
parameter-name parameter-type
function-return-type :
assertion
assertion :
as
Nullable-primitive-type
Le résultat de l’évaluation d’un function-type est une valeur de type dont le type de base est function
.
Les exemples suivants illustrent la syntaxe de déclaration des types de fonctions :
type function (x as text) as number
type function (y as number, optional z as text) as any
Une valeur de fonction est conforme à un type de fonction si le type de retour de la valeur de fonction est compatible avec le type de retour du type de fonction et que chaque spécification de paramètre du type de fonction est compatible avec le paramètre formel correspondant à la position de la fonction. Une spécification de paramètre est compatible avec un paramètre formel si le type parameter-type spécifié est compatible avec le type du paramètre formel, et la spécification de paramètre est facultative si le paramètre formel est facultatif.
Les noms des paramètres formels sont ignorés dans le cadre de la détermination de la conformité du type de fonction.
La spécification d’un paramètre comme facultatif fait implicitement en sorte que son type soit nullable. L’action suivante crée des types de fonctions identiques :
type function (optional x as text) as any
type function (optional x as nullable text) as any
Une valeur table-type est utilisée pour définir la structure d’une valeur de table.
table-type:
table
type de ligne
row-type :
[
field-specification-listopt]
Le résultat de l’évaluation d’un table-type est une valeur de type dont le type de base est table
.
Le type de ligne d’une table spécifie les noms des colonnes et les types de colonnes de la table en tant que type d’enregistrement fermé. Afin que toutes les valeurs de table soient conformes au type table
, son type de ligne est de type record
(type d’enregistrement ouvert vide). Ainsi, la table de type est abstraite, puisque aucune valeur de table ne peut avoir le type de ligne du type table
(mais toutes les valeurs de table ont un type de ligne qui est compatible avec le type de ligne du type table
). L’exemple suivant illustre la construction d’un type de table :
type table [A = text, B = number, C = binary]
// a table type with three columns named A, B, and C
// of column types text, number, and binary, respectively
Une valeur table-type contient également la définition des clés d’une valeur de table. Une clé est un ensemble de noms de colonnes. Une clé au plus peut être désignée en tant que clé primaire de la table. (En M, les clés de table n’ont aucune signification sémantique. Toutefois, il est courant de définir des clés sur des tables pour les sources de données externes, comme les bases de données ou les flux OData. Power Query utilise les informations sur les clés pour améliorer les performances des fonctionnalités avancées, comme les opérations de jointure entre sources.)
Vous pouvez utiliser les fonctions de bibliothèque standard Type.TableKeys
, Type.AddTableKey
et Type.ReplaceTableKeys
respectivement pour obtenir les clés d’un type de table, ajouter une clé à un type de table et remplacer toutes les clés d’un type de table.
Type.AddTableKey(tableType, {"A", "B"}, false)
// add a non-primary key that combines values from columns A and B
Type.ReplaceTableKeys(tableType, {})
// returns type value with all keys removed
Pour tout type T
, une variante pouvant accepter la valeur Null peut être dérivée à l’aide de nullable-type :
nullable-type:
nullable
type
Le résultat est un type abstrait qui autorise les valeurs de type T ou la valeur null
.
42 is nullable number // true null is
nullable number // true
L’ascription de type nullable
T réduit à l’inscription ou type null
type
(Rappelez-vous que les types nullables sont abstraits et qu’aucune valeur ne peut être directement de type abstrait.)
Value.Type(42 as nullable number) // type number
Value.Type(null as nullable number) // type null
Vous pouvez utiliser les fonctions de bibliothèque standard Type.IsNullable
et Type.NonNullable
pour tester la possibilité de valeur Null d’un type et pour supprimer la possibilité de valeur Null d’un type.
Ce qui suit est valable (pour tout type T
) :
type T
est compatible avec type nullable T
Type.NonNullable(type T)
est compatible avec type T
Les éléments suivants sont équivalents en tant que paires (pour tout type T
) :
type nullable any
any
Type.NonNullable(type any)
type anynonnull
type nullable none
type null
Type.NonNullable(type null)
type none
type nullable nullable T
type nullable T
Type.NonNullable(Type.NonNullable(type T))
Type.NonNullable(type T)
Type.NonNullable(type nullable T)
Type.NonNullable(type T)
type nullable (Type.NonNullable(type T))
type nullable T
Le type attribué d’une valeur est le type auquel une valeur a été déclarée comme étant conforme.
Un type peut être attribué à une valeur à l’aide de la fonction de bibliothèque Value.ReplaceType
. Cette fonction retourne une nouvelle valeur avec le type attribué ou génère une erreur si le nouveau type est incompatible avec la valeur.
Quand un type est attribué à une valeur, seule une vérification de conformité limitée a lieu :
Les fonctions de bibliothèque peuvent choisir de calculer et d’attribuer des types complexes à des résultats en fonction des types attribués des valeurs d’entrée.
Le type attribué d’une valeur peut être obtenu à l’aide de la fonction de bibliothèque Value.Type
. Par exemple :
Value.Type( Value.ReplaceType( {1}, type {number} )
// type {number}
L’équivalence de type n’est pas définie dans M. Une implémentation M peut éventuellement choisir d’utiliser ses propres règles pour effectuer des comparaisons d’égalité entre les valeurs de type. La comparaison de deux valeurs de type pour l’égalité doit déterminer true
si elles sont considérées comme identiques par l’implémentation, et false
dans le cas contraire. Dans les deux cas, la réponse retournée doit être cohérente si les deux mêmes valeurs sont comparées à plusieurs reprises. Notez que dans une implémentation donnée, la comparaison de certaines valeurs de type identiques (comme (type text) = (type text)
) peut retourner true
, alors que la comparaison d’autres valeurs (comme (type [a = text]) = (type [a = text])
) non.
Vous pouvez déterminer la compatibilité entre un type donné et un type primitif Nullable à l’aide de la fonction de bibliothèque Type.Is
, qui accepte une valeur de type arbitraire comme premier argument et une valeur de type primitif Nullable comme deuxième argument :
Type.Is(type text, type nullable text) // true
Type.Is(type nullable text, type text) // false
Type.Is(type number, type text) // false
Type.Is(type [a=any], type record) // true
Type.Is(type [a=any], type list) // false
Il n’existe aucune prise en charge en M pour déterminer la compatibilité d’un type donné avec un type personnalisé.
La bibliothèque standard inclut une collection de fonctions permettant d’extraire les caractéristiques de définition d’un type personnalisé. Des tests de compatibilité spécifiques peuvent par conséquent être implémentés en tant qu’expressions M. Vous trouverez quelques exemples ci-dessous. Pour plus d’informations, consultez la spécification de la bibliothèque M.
Type.ListItem( type {number} )
// type number
Type.NonNullable( type nullable text )
// type text
Type.RecordFields( type [A=text, B=time] )
// [ A = [Type = type text, Optional = false],
// B = [Type = type time, Optional = false] ]
Type.TableRow( type table [X=number, Y=date] )
// type [X = number, Y = date]
Type.FunctionParameters(
type function (x as number, optional y as text) as number)
// [ x = type number, y = type nullable text ]
Type.FunctionRequiredParameters(
type function (x as number, optional y as text) as number)
// 1
Type.FunctionReturn(
type function (x as number, optional y as text) as number)
// type number
Entrainement
Module
Déclarer des types de variables en TypeScript - Training
Découvrez les types disponibles et la façon de les associer à des variables.