Compartilhar via

about_Case-Sensitivity

Descrição curta

O PowerShell não diferencia maiúsculas de minúsculas ao mesmo tempo que preserva maiúsculas e minúsculas.

Descrição longa

Como um princípio geral, o PowerShell não diferencia maiúsculas de minúsculas sempre que possível, preservando maiúsculas e minúsculas e não interrompendo o sistema operacional subjacente.

Sistemas baseados em Windows não diferenciam maiúsculas de minúsculas para a maioria das operações. No entanto, sistemas não Windows diferenciam maiúsculas de minúsculas para a maioria das operações, especialmente para acesso a variáveis de ambiente e sistema de arquivos.

O PowerShell tem a garantia de não diferenciar maiúsculas de minúsculas em todos os sistemas para as seguintes áreas:

  • Nomes da variável
  • Nomes de operador
  • Acesso a membros que não são de dicionário
  • Descoberta de comando de comandos e aliases do PowerShell. Isso exclui os comandos ExternalScript e Application.
  • Nomes de parâmetros e aliases
  • Palavras-chave de linguagem do PowerShell
  • Instruções using namespace
  • Digitar literais
  • Instruções #Requires
  • Palavras-chave de ajuda baseadas em comentários
  • Nomes PSProvider
  • Nomes do PSDrive
  • Modificadores de escopo

Casos especiais

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

    O nome do módulo é puramente um conceito do PowerShell e tratado sem diferenciar a maiúsculas e minúsculas. No entanto, há um mapeamento forte para a denominação da pasta, que pode diferenciar letras maiúsculas e minúsculas no sistema operacional subjacente. Importar dois módulos com o mesmo nome que não diferencia maiúsculas de 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, conforme armazenado no estado da sessão, é usado Update-Help ao procurar novos arquivos de ajuda. O serviço Web que atende aos arquivos de ajuda da Microsoft usa um sistema de arquivos que diferencia maiúsculas de minúsculas. Quando o caso do nome importado do módulo não corresponde, Update-Help não consegue localizar os arquivos de ajuda e relata um erro.

  • Provedores de PS:

    Os FileSystem provedores e os provedores Environment diferenciam maiúsculas de minúsculas em sistemas que não são do Windows. Em geral, as operações que envolvem caminhos ou variáveis de ambiente diferenciam maiúsculas de minúsculas nesses sistemas.

    No entanto, a correspondência curinga por cmdlets do provedor não diferencia maiúsculas de 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 do conjunto de parâmetros diferenciam maiúsculas de minúsculas.

    O DefaultParameterSetName caso deve ser idêntico a ParameterSetName.

  • Os métodos .NET geralmente exibem um comportamento que diferencia maiúsculas de minúsculas por padrão.

    Os exemplos incluem:

    • Métodos .NET equivalentes (sem aceitação explícita) para operadores comuns do PowerShell, como:
      • Array.Contains(), String.Contains(), String.Replace(), , Regex.Match()Regex.Replace()
    • Reflexão; os nomes de membro devem usar o caso correto.
    • Instanciação de dicionário não literal. Por exemplo:
      • [hashtable]::new() tem chaves que diferenciam maiúsculas de minúsculas, enquanto um literal @{} hashable tem chaves que não diferenciam maiúsculas de minúsculas.
      • [ordered]::new() tem chaves que diferenciam maiúsculas de minúsculas, enquanto uma [ordered] @{} chave que não diferencia maiúsculas de minúsculas. O [ordered]acelerador de tipo não está disponível no PowerShell v5.1 e anterior.
    • A chamada Enum.Parse() explícita diferencia maiúsculas de minúsculas por padrão, enquanto o PowerShell normalmente manipula enumes de maneira que não diferencia maiúsculas de minúsculas.

  • -Unique Cmdlets:

  • Compare-Object não diferencia maiúsculas de minúsculas por padrão, mas tem uma -CaseSensitive opção. A comparação de [char] tipos diferencia maiúsculas de minúsculas por padrão. A comparação de cadeia de caracteres não diferencia maiúsculas de minúsculas por padrão.

    # 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 de minúsculas quando esse parâmetro é especificado.
      • Com o parâmetro, um objeto do tipo Management.Automation.OrderedHashtable é emitido, que tem chaves que diferenciam maiúsculas de minúsculas.
      • Sem o parâmetro, as chaves JSON são tratadas como que não diferenciam maiúsculas de minúsculas. A saída é um objeto personalizado; última chave que não diferencia maiúsculas de minúsculas vence.
    • https://github.com/PowerShell/PowerShell/issues/19928

  • Group-Object:

    • Não diferencia maiúsculas de minúsculas por padrão, mas tem uma -CaseSensitive opção.

    • No Windows PowerShell v5.1, -CaseSensitive e -AsHashtable produz um hashtable que não diferencia maiúsculas de minúsculas. Chaves duplicadas resultam em um 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 superior, -CaseSensitive e -AsHashtable produz um hashtable que diferencia maiúsculas de minúsculas. Nenhum erro ocorre com chaves duplicadas.

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

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

  • Select-String:

    • Não diferencia maiúsculas de minúsculas por padrão, mas tem uma -CaseSensitive opção.

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

    • Em sistemas de arquivos que diferenciam maiúsculas de minúsculas, a descoberta e a invocação e ExternalScriptApplication o comando diferenciam maiúsculas de minúsculas.
    • Get-Command A correspondência curinga com esses tipos também diferencia maiúsculas de minúsculas.
    • Todos os outros CommandTypes não diferenciam maiúsculas de minúsculas.

  • Operadores de comparação:

    • Por padrão, os operadores não diferenciam maiúsculas de minúsculas.

    • -c* os operadores diferenciam maiúsculas de minúsculas.

    • -i* os operadores não diferenciam maiúsculas de minúsculas.

    • -replace / -ireplace não diferencia maiúsculas de minúsculas por padrão, exceto com grupos de captura nomeados, que diferenciam maiúsculas de 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 diferenciam maiúsculas de minúsculas.

    • -csplit diferencia maiúsculas de minúsculas, a menos que a opção IgnoreCase seja especificada.

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

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

  • Conclusão da guia:

    • Em sistemas de arquivos que diferenciam maiúsculas de minúsculas, a conclusão da guia e o globbing não diferenciam maiúsculas de minúsculas. Por exemplo, TabExpansion2 -inputScript ./foo será concluído ./Foo.txt no Linux.

  • using Declaração:

    • Em sistemas de arquivos que diferenciam maiúsculas using module de minúsculas e using assembly diferenciam maiúsculas de minúsculas quando um caminho é especificado.
    • using module com apenas um nome de módulo não diferencia maiúsculas de minúsculas.
    • using namespace sempre diferencia maiúsculas de minúsculas.

  • Caracteres especiais:

    • Sequências de escape como `n diferenciam maiúsculas de minúsculas.

Consulte também

  • Last updated on