about_Numeric_Literals
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 0x
0b
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 :
- 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]
.
- Pour les formats binaires, analysez en
- 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é.
- 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’unBigInteger
.
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.