Share via

about_Numeric_Literals

  • Article

Description courte

Cet article décrit la syntaxe et l’utilisation des valeurs numériques dans PowerShell.

Description longue

Il existe deux types de littéraux numériques : entier et réel. Les deux peuvent avoir des suffixes de type et de multiplicateur.

Littéraux d'entier

Les littéraux entiers peuvent être écrits en notation décimale, hexadécimale ou binaire. Les littéraux hexadécimaux sont préfixés et les littéraux binaires sont préfixés 0x0b pour les distinguer des nombres décimaux.

Les littéraux entiers peuvent avoir un suffixe de type et un suffixe multiplicateur.

Suffixe Signification Remarque
y type de données d’octet signé Ajouté dans PowerShell 6.2
uy type de données d’octet non signé Ajouté dans PowerShell 6.2
s short (type de données) Ajouté dans PowerShell 6.2
us type de données court non signé Ajouté dans PowerShell 6.2
l type de données long
u type de données non signé ou long Ajouté dans PowerShell 6.2
ul type de données long non signé Ajouté dans PowerShell 6.2
n Type de données BigInteger Ajouté dans PowerShell 7.0
kb multiplicateur de kilooctets
mb multiplicateur de mégaoctets
gb multiplicateur de gigaoctets
tb multiplicateur de téraoctets
pb multiplicateur de pétaoctet

Le type d’un littéral entier est déterminé par sa valeur, le suffixe de type et le suffixe multiplicateur numérique.

Pour un littéral entier sans suffixe de type :

  • Si la valeur peut être représentée par type [int], c’est-à-dire son type.
  • Sinon, si la valeur peut être représentée par type [long], c’est-à-dire son type.
  • Sinon, si la valeur peut être représentée par type [decimal], c’est-à-dire son type.
  • Sinon, il est représenté par type [double].

Pour un littéral entier avec un suffixe de type :

  • Si le suffixe de type est u et que la valeur peut être représentée par type, son type [uint] est [uint].
  • Si le suffixe de type est u et que la valeur peut être représentée par type, son type [ulong] est [ulong].
  • Si sa valeur peut être représentée par le type spécifié, il s’agit de son type.
  • Sinon, ce littéral est mal formé.

Littéraux réels

Les littéraux réels ne peuvent être écrits qu’en notation décimale. Cette notation peut inclure des valeurs fractionnaires à la suite d’une notation décimale et scientifique à l’aide d’une partie exponentielle.

La partie exponentielle inclut un « e » suivi d’un signe facultatif (+/-) et d’un nombre représentant l’exposant. Par exemple, la valeur 1e2 littérale est égale à la valeur numérique 100.

Les littéraux réels peuvent avoir un suffixe de type et un suffixe multiplicateur.

Suffixe Signification
d type de données decimal
kb multiplicateur de kilooctets
mb multiplicateur de mégaoctets
gb multiplicateur de gigaoctets
tb multiplicateur de téraoctets
pb multiplicateur de pétaoctet

Il existe deux types de littéraux réels : double et decimal. Elles sont indiquées par l’absence ou la présence, respectivement, du suffixe de type décimal. PowerShell ne prend pas en charge une représentation littérale d’une [float] valeur. Un littéral double réel a le type [double]. Un littéral réel décimal a le type [decimal]. Les zéros de fin dans la partie fractionnaire d’un littéral réel décimal sont significatifs.

Si la valeur des chiffres du composant exposant dans un [double] littéral réel est inférieure à la valeur minimale prise en charge, la valeur de ce [double] littéral réel est 0. Si la valeur des chiffres du composant exposant dans un [decimal] littéral réel est inférieure à la valeur minimale prise en charge, ce littéral est mal formé. Si la valeur des chiffres du composant exposant dans un [double] littéral réel ou [decimal] réel est supérieure à la valeur maximale prise en charge, ce littéral est mal formé.

Remarque

La syntaxe permet à un littéral double réel d’avoir un suffixe de type long. PowerShell traite ce cas comme un littéral entier dont la valeur est représentée par le type [long]. Cette fonctionnalité a été conservée à des fins de compatibilité descendante avec les versions antérieures de PowerShell. Toutefois, il est déconseillé aux programmeurs d’utiliser des littéraux entiers de cette forme, car ils peuvent facilement masquer la valeur réelle du littéral. Par exemple, 1.2L a la valeur 1, 1.2345e1L a la valeur 12 et 1.2345e-5L a la valeur 0, dont aucune n’est immédiatement évidente.

Multiplicateurs numériques

Pour des raisons pratiques, les entiers et les littéraux réels peuvent contenir un multiplicateur numérique, qui indique l’un des ensembles de puissances couramment utilisées de 2. Le multiplicateur numérique peut être écrit dans n’importe quelle combinaison de lettres majuscules ou minuscules.

Les suffixes multiplicateurs peuvent être utilisés en combinaison avec tous les suffixes de type, mais doivent être présents après le suffixe de type. Par exemple, le littéral 100gbL est mal formé, mais le littéral 100Lgb est valide.

Si un multiplicateur crée une valeur qui dépasse les valeurs possibles pour le type numérique spécifié par le suffixe, le littéral est mal formé. Par exemple, le littéral 1usgb est mal formé, car la valeur 1gb est supérieure à ce qui est autorisé pour le [ushort] type spécifié par le us suffixe.

Exemples multiplicateurs

PS> 1kb
1024

PS> 1.30Dmb
1363148.80

PS> 0x10Gb
17179869184

PS> 1.4e23tb
1.5393162788864E+35

PS> 0x12Lpb
20266198323167232

Accélérateurs de type numérique

PowerShell prend en charge les accélérateurs de type suivants :

Accélérateur Remarque Description
[byte] Octet (non signé)
[sbyte] Octet (signé)
[Int16] Entier de 16 bits
[short] alias pour [int16] Entier de 16 bits
[UInt16] Entier 16 bits (non signé)
[ushort] alias pour [uint16] Entier 16 bits (non signé)
[Int32] Entier de 32 bits
[int] alias pour [int32] Entier de 32 bits
[UInt32] Entier 32 bits (non signé)
[uint] alias pour [uint32] Entier 32 bits (non signé)
[Int64] Entier 64 bits
[long] alias pour [int64] Entier 64 bits
[UInt64] Entier 64 bits (non signé)
[ulong] alias pour [uint64] Entier 64 bits (non signé)
[bigint] Voir Struct BigInteger
[single] Virgule flottante simple précision
[float] alias pour [single] Virgule flottante simple précision
[double] Double précision à virgule flottante
[decimal] Virgule flottante 128 bits

Remarque

Les accélérateurs de type suivants ont été ajoutés dans PowerShell 6.2 : [short], [ushort], [uint], [ulong].

Exemples

Le tableau suivant contient plusieurs exemples de littéraux numériques et répertorie leur type et leur valeur :

Number Type Value
100 Int32 100
100u UInt32 100
100D Décimal 100
100l Int64 100
100uL UInt64 100
100us UInt16 100
100uy Byte 100
100y SByte 100
1e2 Double 100
1.e2 Double 100
0x1e2 Int32 482
0x1e2L Int64 482
0x1e2D Int32 7725
482D Décimal 482
482gb Int64 517543559168
482ngb BigInteger 517543559168
0x1e2lgb Int64 517543559168
0b1011011 Int32 91
0xFFFFs Int16 -1
0xFFFFFFFF Int32 -1
-0xFFFFFFFF Int32 1
0xFFFFFFFFu UInt32 4294967295

Utilisation de nombres binaires ou hexadécimaux

Les littéraux binaires ou hexadécimaux trop volumineux peuvent retourner comme [bigint] au lieu d’échouer l’analyse, si et uniquement si le n suffixe est spécifié. Les bits de signe sont toujours respectés au-dessus des plages paires [decimal] , cependant :

  • Si une chaîne binaire est plusieurs de 8 bits de long, le bit le plus élevé est traité comme le bit de signe.
  • Si une chaîne hexadécimal, dont la longueur est un multiple de 8, a le premier chiffre avec 8 ou supérieur, le chiffre est traité comme négatif.

La spécification d’un suffixe non signé sur des littéraux binaires et hexadécimaux ignore les bits de signe. Par exemple, 0xFFFFFFFF retourne -1, mais 0xFFFFFFFFu retourne la [uint]::MaxValue 4294967295.

Dans PowerShell 7.1, l’utilisation d’un suffixe de type sur un littéral hexadécimal retourne désormais une valeur signée de ce type. Par exemple, dans PowerShell 7.0, l’expression 0xFFFFs retourne une erreur, car la valeur positive est trop grande pour un [int16] type. PowerShell 7.1 interprète cela comme -1 un [int16] type.

Le préfixe du littéral avec un 0 ignorera cette opération et sera traité comme non signé. Par exemple : 0b011111111. Cela peut être nécessaire lors de l’utilisation de littéraux dans la [bigint] plage, car les suffixes et n les u suffixes ne peuvent pas être combinés.

Vous pouvez également négation des littéraux binaires et hexadécimaux à l’aide du - préfixe. Cela peut entraîner un nombre positif, car les bits de signe sont autorisés.

Les bits de signe sont acceptés pour les chiffres avec suffixe BigInteger :

  • BigInteger-suffixe hexadécimal traite le bit élevé de n’importe quel littéral avec une longueur multiple de 8 caractères comme le bit de signe. La longueur n’inclut pas le 0x préfixe ni les suffixes.
  • Le fichier binaire avec suffixe BigInteger accepte les bits de signe à 96 et 128 caractères, et à toutes les 8 caractères après.

Conversion de type numérique

Lorsque des chaînes sont converties en nombres, des indicateurs de format hexadécimal supplémentaires sont pris en charge. Ces formats supplémentaires ne sont pas reconnus en tant que littéraux.

[int] '0xF' -eq 0xF
[int] '&hF' -eq 0xF
[int] '#F' -eq 0xF
[int] '0b1111' -eq 0b1111
[int] '0b1111' -eq 15

Commandes qui ressemblent à des littéraux numériques

Toute commande qui ressemble à un littéral numérique valide doit être exécutée à l’aide de l’opérateur d’appel (&), sinon elle est interprétée comme un nombre. Les littéraux mal formés avec une syntaxe valide comme 1usgb suit entraînent l’erreur suivante :

PS> 1usgb
At line:1 char:6
+ 1usgb
+      ~
The numeric constant 1usgb is not valid.
+ CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : BadNumericConstant

Toutefois, les littéraux mal formés avec une syntaxe non valide comme 1gbus seront interprétés comme une chaîne nue standard et peuvent être interprétés comme un nom de commande valide dans les contextes où les commandes peuvent être appelées.

Accéder aux propriétés et méthodes des objets numériques

Pour accéder à un membre d’un littéral numérique, il existe des cas où vous devez placer le littéral entre parenthèses.

  • Le littéral n’a pas de virgule décimale
  • Le littéral n’a aucun chiffre suivant le point décimal
  • Le littéral n’a pas de suffixe

Par exemple, l’exemple suivant échoue :

PS> 2.GetType().Name
At line:1 char:11
+ 2.GetType().Name
+           ~
An expression was expected after '('.
+ CategoryInfo          : ParserError: (:) [], ParentContainsErrorRecordException
+ FullyQualifiedErrorId : ExpectedExpression

Les exemples suivants fonctionnent :

PS> 2uL.GetType().Name
UInt64
PS> 1.234.GetType().Name
Double
PS> (2).GetType().Name
Int32

Les deux premiers exemples fonctionnent sans placer la valeur littérale entre parenthèses, car l’analyseur PowerShell peut déterminer où se termine le littéral numérique et la méthode GetType démarre.

Comment PowerShell analyse les littéraux numériques

PowerShell v7.0 a changé la façon dont les littéraux numériques sont analysés pour activer les nouvelles fonctionnalités.

Analyse de littéraux numériques réels

Si le littéral contient une virgule décimale ou la notation électronique, la chaîne littérale est analysée en tant que nombre réel.

  • Si le suffixe décimal est présent, directement dans [decimal].
  • Sinon, analysez comme [Double] et appliquez le multiplicateur à la valeur. Ensuite, case activée les suffixes de type et tentez de convertir en type approprié.
  • Si la chaîne n’a aucun suffixe de type, analysez la valeur [Double].

Analyse de littéraux numériques entiers

Les littéraux de type entier sont analysés en procédant comme suit :

  1. Déterminer le format radix
    • Pour les formats binaires, analysez en [BigInteger].
    • Pour les formats hexadécimaux, analysez l’utilisation [BigInteger] de cass spéciaux pour conserver les comportements d’origine lorsque la valeur se trouve dans la ou [long] la [int] plage.
    • Si ni binaire ni hexadécimal, analysez normalement en tant que [BigInteger].
  2. Appliquez la valeur multiplicateur avant d’essayer des casts pour vous assurer que les limites de type peuvent être correctement case activée ed sans dépassements de capacité.
  3. Vérifiez les suffixes de type.
    • Vérifiez les limites de type et tentez d’analyser ce type.
    • Si aucun suffixe n’est utilisé, la valeur est limitée case activée dans l’ordre suivant, ce qui entraîne le premier test réussi déterminant le type du nombre.
      • [int]
      • [long]
      • [decimal] (littéraux de base 10 uniquement)
      • [double] (littéraux de base 10 uniquement)
    • Si la valeur est en dehors de la [long] plage pour les nombres hexadécimaux et binaires, l’analyse échoue.
    • Si la valeur est en dehors de la plage pour le [double] nombre de base 10, l’analyse échoue.
    • Les valeurs supérieures doivent être écrites explicitement à l’aide du n suffixe pour analyser le littéral sous la forme d’un BigInteger.

Analyse de littéraux de valeur élevée

Auparavant, les valeurs entières supérieures étaient analysées comme doubles avant d’être converties en tout autre type. Cela entraîne une perte de précision dans les plages supérieures. Par exemple :

PS> [bigint]111111111111111111111111111111111111111111111111111111
111111111111111100905595216014112456735339620444667904

Pour éviter ce problème, vous deviez écrire des valeurs sous forme de chaînes, puis les convertir :

PS> [bigint]'111111111111111111111111111111111111111111111111111111'
111111111111111111111111111111111111111111111111111111

Dans PowerShell 7.0, vous devez utiliser le N suffixe.

PS> 111111111111111111111111111111111111111111111111111111n
111111111111111111111111111111111111111111111111111111

Les valeurs entre [ulong]::MaxValue et [decimal]::MaxValue doivent également être indiquées à l’aide du suffixe D décimal pour maintenir la précision. Sans le suffixe, ces valeurs sont analysées comme [Double] utilisant le mode d’analyse réel.