Partager via

about_Case-Sensitivity

Brève description

PowerShell est aussi insensible à la casse que possible tout en préservant la casse.

Description longue

En principe général, PowerShell ne respecte pas la casse dans la mesure du possible tout en préservant le cas et ne cassant pas le système d’exploitation sous-jacent.

Les systèmes Windows ne respectent pas la casse pour la plupart des opérations. Toutefois, les systèmes non-Windows respectent la casse pour la plupart des opérations, en particulier pour l’accès aux variables de système de fichiers et d’environnement.

PowerShell est garanti qu’il ne respecte pas la casse sur tous les systèmes pour les domaines suivants :

  • Noms de variable
  • Noms d’opérateurs
  • Accès aux membres non-dictionnaire
  • Découverte de commandes et d’alias PowerShell. Cela exclut les commandes ExternalScript et Application.
  • Noms et alias de paramètres
  • Mots clés du langage PowerShell
  • Instructions using namespace
  • Littéraux de type
  • Instructions #Requires
  • Mots clés d’aide basés sur des commentaires
  • Noms PSProvider
  • Noms PSDrive
  • Modificateurs d’étendue

Cas particuliers

  • PowerShell les traite de manière insensible à la casse.

    Le nom du module est purement un concept PowerShell et traité de manière insensible à la casse. Cependant, il existe une forte correspondance avec un nom de dossier, qui peut être sensible à la casse dans le système d’exploitation sous-jacent. L’importation de deux modules portant le même nom sans respect de la casse a le même comportement que l’importation de deux modules portant le même nom à partir de chemins différents.

    Le nom d’un module est stocké dans l’état de session à l’aide du cas par lequel il a été importé. Le nom, tel qu’il est stocké dans l’état de session, est utilisé lors Update-Help de la recherche de nouveaux fichiers d’aide. Le service web qui sert les fichiers d’aide pour Microsoft utilise un système de fichiers respectant la casse. Lorsque le cas du nom importé du module ne correspond pas, Update-Help ne trouve pas les fichiers d’aide et signale une erreur.

  • Fournisseurs PS :

    Les FileSystem fournisseurs et Environment les fournisseurs respectent la casse sur les systèmes non-Windows. En règle générale, les opérations impliquant des chemins d’accès ou des variables d’environnement respectent la casse sur ces systèmes.

    Toutefois, la correspondance de caractères génériques par les applets de commande du fournisseur ne respecte pas la casse, quel que soit le système.

    PS /home/user01> New-Item -Path Temp:foo.txt -Force

    Directory: /tmp

UnixMode      User Group      LastWriteTime         Size Name
--------      ---- -----      -------------         ---- ----
-rw-r--r--  user01 user01    1/6/2026 10:53            0 foo.txt

PS /home/user01> (Get-Item -Path Temp:FOO.txt).Name
Get-Item: Cannot find path 'Temp:/FOO.txt' because it does not exist.

PS /home/user01> (Get-Item -Path Temp:F[O]*.txt).Name
foo.txt

PS /home/user01> (Get-Item -Path Env:hOM[E]).Name
HOME

  • Les noms des ensembles de paramètres respectent la casse.

    Le DefaultParameterSetName cas doit être identique à ParameterSetName.

  • Les méthodes .NET présentent souvent un comportement sensible à la casse par défaut.

    Voici quelques exemples :

    • Méthodes .NET équivalentes (sans opt-in explicite) pour les opérateurs PowerShell courants tels que :
      • Array.Contains(), String.Contains(), , String.Replace(), Regex.Match(), Regex.Replace()
    • Réflexion; les noms de membres doivent utiliser le cas approprié.
    • Instanciation de dictionnaire non littéral. Par exemple:
      • [hashtable]::new() a des clés sensibles à la casse, tandis qu’un littéral @{} de table de hachage a des clés qui ne respectent pas la casse.
      • [ordered]::new() a des clés sensibles à la casse, tandis qu’une [ordered] @{} clé ne respectant pas la casse. L’accélérateur[ordered] de type n’est pas disponible dans PowerShell v5.1 et versions antérieures.
    • L’appel Enum.Parse() explicite respecte la casse par défaut, tandis que PowerShell gère généralement les énumérations de manière sensible à la casse.

  • -Unique Cmdlets:

  • Compare-Object ne respecte pas la casse par défaut, mais a un -CaseSensitive commutateur. La comparaison des [char] types respecte la casse par défaut. La comparaison de chaînes ne respecte pas la casse par défaut.

    # Compare strings - Equal (no output)
Compare-object -ReferenceObject a            -DifferenceObject A
# Compare chars - Different (output)
Compare-object -ReferenceObject ([char] 'a') -DifferenceObject ([char] 'A')

  • ConvertFrom-Json -AsHashtable :

    • -AsHashtable a été ajouté dans PS v6. Dans PS v7.3, une modification a été apportée pour traiter les clés JSON comme sensibles à la casse lorsque ce paramètre est spécifié.
      • Avec le paramètre, un objet de type Management.Automation.OrderedHashtable est émis, qui a des clés sensibles à la casse.
      • Sans le paramètre, les clés JSON sont traitées comme non sensibles à la casse. La sortie est un objet personnalisé ; dernière clé non sensible à la casse gagne.
    • https://github.com/PowerShell/PowerShell/issues/19928

  • Group-Object :

    • Ne respectant pas la casse par défaut, mais a un -CaseSensitive commutateur.

    • Dans Windows PowerShell v5.1, -CaseSensitive et -AsHashtable produit une table de hachage non sensible à la casse. Les clés en double entraînent une erreur.

      [pscustomobject] @{ Foo = 'Bar' }, [pscustomobject] @{ Foo = 'bar' } |
    Group-Object -Property Foo -CaseSensitive -AsHashtable

      Group-Object : The objects grouped by this property cannot be expanded
because there is a key duplication. Provide a valid value for the
property, and then try again.
At line:2 char:11
+           Group-Object -Property Foo -CaseSensitive -AsHashtable
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidArgument: (:) [Group-Object], Exception
    + FullyQualifiedErrorId : The objects grouped by this property
cannot be expanded because there is a key duplication. Provide a valid
value for the property, and then try again.,Microsoft.PowerShell.Comman
ds.GroupObjectCommand

    • Dans PowerShell v7 et versions ultérieures, -CaseSensitive et -AsHashtable produit une table de hachage sensible à la casse. Aucune erreur ne se produit avec des clés dupliquées.

      [pscustomobject] @{ Foo = 'Bar' }, [pscustomobject] @{ Foo = 'bar' } |
    Group-Object -Property Foo -CaseSensitive -AsHashtable

      Name                           Value
----                           -----
Bar                            {@{Foo=Bar}}
bar                            {@{Foo=bar}}

  • Select-String :

    • Ne respectant pas la casse par défaut, mais a un -CaseSensitive commutateur.

  • Get-Command et découverte/appel de commandes :

    • Sur les systèmes de fichiers respectant la casse, la découverte et l’appel des ExternalScriptApplication commandes respectent la casse.
    • Get-Command La correspondance de caractères génériques avec ces types est également sensible à la casse.
    • Toutes les autres CommandTypes ne respectent pas la casse.

  • Opérateurs de comparaison :

    • Par défaut, les opérateurs ne respectent pas la casse.

    • -c* les opérateurs respectent la casse.

    • -i* les opérateurs ne respectent pas la casse.

    • -replace / -ireplace ne respecte pas la casse par défaut, sauf avec les groupes de capture nommés, qui respectent la casse.

      'Bar' -replace '(?<a>a)', '${a}${a}'
# Baar

'Bar' -replace '(?<a>a)', '${A}${A}'
# B${A}${A}r

  • -split opérateur :

    • -split et ne respectent pas -isplit la casse.

    • -csplit respecte la casse, sauf si l’option IgnoreCase est spécifiée.

      'Bar' -csplit 'A', 0
# Bar

'Bar' -csplit 'A', 0, 'IgnoreCase'
# B
# r

  • Saisie semi-automatique de tabulation :

    • Sur les systèmes de fichiers respectant la casse, la saisie semi-automatique de tabulation et le globbing ne respectent pas la casse. Par exemple, TabExpansion2 -inputScript ./foo se termine ./Foo.txt sur Linux.

  • using Déclaration:

    • Sur les systèmes de fichiers respectant la casse et using moduleusing assembly respectent la casse lorsqu’un chemin d’accès est spécifié.
    • using module avec simplement un nom de module ne respecte pas la casse.
    • using namespace ne respecte toujours pas la casse.

  • Caractères spéciaux :

    • Les séquences d’échappement comme `n celles-ci respectent la casse.

Voir aussi

  • Last updated on