Partilhar via

about_Case-Sensitivity

Breve descrição

O PowerShell não diferencia maiúsculas de minúsculas quanto possível, preservando maiúsculas e minúsculas.

Descrição longa

Como princípio geral, o PowerShell é insensível a maiúsculas minúsculas sempre que possível, preservando a maiúscula e sem quebrar o sistema operativo subjacente.

Os sistemas baseados em Windows são insensíveis a maiúsculas e minúsculas na maioria das operações. No entanto, sistemas não Windows são sensíveis a maiúsculas e minúsculas na maioria das operações, especialmente para o acesso a sistemas de ficheiros e variáveis de ambiente.

O PowerShell é garantido insensível a maiúsculas minúsculas em todos os sistemas para as seguintes áreas:

  • Nomes de variável
  • Nomes dos operadores
  • Acesso não a membros do dicionário
  • Descoberta de comandos de comandos e aliases PowerShell. Isto exclui comandos ExternalScript e Application.
  • Nomes de parâmetros e pseudónimos
  • Palavras-chave da linguagem PowerShell
  • using namespace declarações
  • Literais de tipo
  • #Requires declarações
  • Palavras-chave de ajuda baseadas em comentários
  • Nomes PSProvider
  • Nomes PSDrive
  • Modificadores de escopo

Casos especiais

  • Os nomes dos módulos não diferenciam maiúsculas de minúsculas (com exceções)

    O nome do módulo é puramente um conceito do PowerShell e tratado sem distinção entre maiúsculas e minúsculas. No entanto, há um mapeamento forte para um nome de pasta, que pode diferenciar maiúsculas de minúsculas no sistema operacional subjacente. Importar dois módulos com o mesmo nome insensível a maiúsculas minúsculas tem o mesmo comportamento que importar dois módulos com o mesmo nome de caminhos diferentes.

    O nome de um módulo é armazenado no estado da sessão usando o caso pelo qual ele foi importado. O nome, tal como armazenado no estado da sessão, é usado por Update-Help quando procura novos ficheiros de ajuda. O serviço web que serve os ficheiros de ajuda para a Microsoft utiliza um sistema de ficheiros sensível a maiúsculas minúsculas. Quando o caso do nome importado do módulo não corresponde, Update-Help não é possível encontrar os arquivos de ajuda e relata um erro.

  • Fornecedores de PS:

    Os FileSystem fornecedores e Environment são sensíveis a maiúsculas de minúsculas em sistemas que não são Windows. Geralmente, operações envolvendo caminhos ou variáveis de ambiente são sensíveis a caso nestes sistemas.

    No entanto, a correspondência de wildcard por cmdlets de prestadores é indistinta a maiúsculas e minúsculas, independentemente do sistema.

    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

  • Os nomes dos conjuntos de parâmetros são sensíveis a maiúsculas minúsculas.

    O DefaultParameterSetName caso deve ser idêntico a ParameterSetName.

  • Os métodos .NET frequentemente apresentam comportamento sensível a maiúsculas minúsculas por defeito.

    Os exemplos incluem:

    • Métodos .NET equivalentes (sem opt-in explícito) para operadores comuns do PowerShell, tais como:
      • Array.Contains(), String.Contains(), String.Replace(), Regex.Match(), Regex.Replace()
    • Reflexão; Os nomes dos membros devem usar a maiúscula correta.
    • Instância de dicionário não literal. Por exemplo:
      • [hashtable]::new() tem chaves sensíveis a maiúsculas minúsculas, enquanto um literal @{} hashtable tem chaves insensíveis a maiúsculas.
      • [ordered]::new() tem teclas sensíveis a maiúsculas minúsculas, enquanto a [ordered] @{} tem teclas insensíveis a maiúsculas e maiúsculas. O [ordered]Type Accelerator não está disponível no PowerShell v5.1 e versões anteriores.
    • A chamada Enum.Parse() explicita é sensível a maiúsculas minúsculas por defeito, enquanto o PowerShell normalmente lida com enums de forma insensível a maiúsculas minúsculas.

  • -Unique Cmdlets:

  • Compare-Object é insensível a maiúsculas minúsculas por defeito, mas tem um -CaseSensitive switch. A comparação de [char] tipos é sensível a maiúsculas minúsculas por defeito. A comparação de cadeias é insensível a maiúsculas minúsculas por defeito.

    # 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 foi adicionado no PS v6. No PS v7.3, foi feita uma alteração para tratar as chaves JSON como sensíveis a maiúsculas minúsculas quando este parâmetro é especificado.
      • Com o parâmetro, é emitido um objeto do tipo Management.Automation.OrderedHashtable , que possui chaves sensíveis a maiúsculas minúsculas.
      • Sem o parâmetro, as chaves JSON são tratadas como indistintas a maiúsculas minúsculas. A saída é um objeto personalizado; A última chave insensível a maiúsculas minúsculas vence.
    • https://github.com/PowerShell/PowerShell/issues/19928

  • Group-Object:

    • Insensível a maiúsculas minúsculas por defeito, mas tem um -CaseSensitive interruptor.

    • No Windows PowerShell v5.1, -CaseSensitive e -AsHashtable produz uma tabela de hash insensível a maiúsculas minúsculas. Chaves duplicadas resultam num erro.

      [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

    • No PowerShell v7 e superiores, -CaseSensitive e -AsHashtable produz uma tabela de hash sensível a maiúsculas minúsculas. Não ocorre erro com teclas duplicadas.

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

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

  • Select-String:

    • Insensível a maiúsculas minúsculas por defeito, mas tem um -CaseSensitive interruptor.

  • Get-Command e descoberta/invocação de comandos:

    • Em sistemas de ficheiros sensíveis a maiúsculas e minúsculas, a descoberta e invocação de ExternalScript e Application comando são sensíveis a maiúsculas minúsculas.
    • Get-Command A correspondência de coringa com estes tipos também é sensível a maiúsculas e maiúsculas.
    • Todos os outros CommandTypes são indistintos a maiúsculas minúsculas.

  • Operadores de comparação:

    • Por defeito, os operadores são insensíveis a maiúsculas e maiúsculas.

    • -c* Os operadores são sensíveis a maiúsculas e maiúsculas.

    • -i* Os operadores são indiferentes a maiúsculas e maiúsculas.

    • -replace / -ireplace é insensível a maiúsculas minúsculas por defeito, exceto com grupos de captura nomeados, que são sensíveis a maiúsculas minúsculas.

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

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

  • -split Operador:

    • -split e -isplit não distinguem maiúsculas e minúsculas.

    • -csplit é sensível a maiúsculas minúsculas, a menos que a IgnoreCase opção seja especificada.

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

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

  • Conclusão do separador:

    • Em sistemas de ficheiros sensíveis a maiúsculas minúsculas, a completude e o globo de tabulação são ambos indiferentes a maiúsculas. Por exemplo, TabExpansion2 -inputScript ./foo completa-se no ./Foo.txt Linux.

  • using Declaração:

    • Em sistemas de ficheiros sensíveis a maiúsculas minúsculas, using module e using assembly são sensíveis a maiúsculas e minúsculas quando um caminho é especificado.
    • using module com apenas o nome de um módulo é indistinto a maiúsculas e maiúsculas.
    • using namespace é sempre indistinto a maiúsculas minúsculas.

  • Personagens especiais:

    • As sequências de fuga são `n sensíveis a maiúsculas e minúsculas.

Consulte também

  • Last updated on