Partilhar via

Format-Hex

  • Referência
Módulo:
Microsoft.PowerShell.Utility

Exibe um arquivo ou outra entrada como hexadecimal.

Sintaxe

Format-Hex
      [-Path] <String[]>
      [-Count <Int64>]
      [-Offset <Int64>]
      [<CommonParameters>]
Format-Hex
      -LiteralPath <String[]>
      [-Count <Int64>]
      [-Offset <Int64>]
      [<CommonParameters>]
Format-Hex
      -InputObject <PSObject>
      [-Encoding <Encoding>]
      [-Count <Int64>]
      [-Offset <Int64>]
      [-Raw]
      [<CommonParameters>]

Description

O Format-Hex cmdlet exibe um arquivo ou outra entrada como valores hexadecimais. Para determinar o deslocamento de um caractere da saída, adicione o número na extremidade esquerda da linha ao número na parte superior da coluna desse caractere.

O Format-Hex cmdlet pode ajudá-lo a determinar o tipo de arquivo de um arquivo corrompido ou um arquivo que pode não ter uma extensão de nome de arquivo. Você pode executar esse cmdlet e, em seguida, ler a saída hexadecimal para obter informações sobre o arquivo.

Ao usar Format-Hex em um arquivo, o cmdlet ignora caracteres de nova linha e retorna todo o conteúdo de um arquivo em uma cadeia de caracteres com os caracteres de nova linha preservados.

Exemplos

Exemplo 1: Obter a representação hexadecimal de uma cadeia de caracteres

Este comando retorna os valores hexadecimais de uma cadeia de caracteres.

'Hello World' | Format-Hex

Label: String (System.String) <2944BEC3>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 48 65 6C 6C 6F 20 57 6F 72 6C 64                Hello World

A cadeia de caracteres Hello World é enviada pelo pipeline para o Format-Hex cmdlet. A saída hexadecimal de mostra os valores de cada caractere na cadeia de Format-Hex caracteres.

Exemplo 2: Localizar um tipo de ficheiro a partir da saída hexadecimal

Este exemplo usa a saída hexadecimal para determinar o tipo de arquivo. O cmdlet exibe o caminho completo do arquivo e os valores hexadecimais.

Para testar o comando a seguir, faça uma cópia de um arquivo PDF existente no computador local e renomeie o arquivo copiado para File.t7f.

Format-Hex -Path .\File.t7f -Count 48

Label: C:\Test\File.t7f

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 25 50 44 46 2D 31 2E 35 0D 0A 25 B5 B5 B5 B5 0D %PDF-1.5..%????.
0000000000000010 0A 31 20 30 20 6F 62 6A 0D 0A 3C 3C 2F 54 79 70 .1 0 obj..<</Typ
0000000000000020 65 2F 43 61 74 61 6C 6F 67 2F 50 61 67 65 73 20 e/Catalog/Pages

O Format-Hex cmdlet usa o parâmetro Path para especificar um nome de arquivo no diretório atual, File.t7f. A extensão .t7f do arquivo é incomum, mas a saída %PDF hexadecimal mostra que é um arquivo PDF. Neste exemplo, o parâmetro Count é usado para limitar a saída aos primeiros 48 bytes do arquivo.

Exemplo 3: Formatar uma matriz de diferentes tipos de dados

Este exemplo usa uma matriz de diferentes tipos de dados para destacar como Format-Hex eles são manipulados no Pipeline.

Ele passará cada objeto pelo Pipeline e processará individualmente. No entanto, se forem dados numéricos e o objeto adjacente também for numérico, ele os agrupará em um único bloco de saída.

'Hello world!', 1, 1138, 'foo', 'bar', 0xdeadbeef, 1gb, 0b1101011100 , $true, $false | Format-Hex

Label: String (System.String) <24F1F0A3>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 48 65 6C 6C 6F 20 77 6F 72 6C 64 21             Hello world!

   Label: Int32 (System.Int32) <2EB933C5>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 01 00 00 00 72 04 00 00                         �   r�

   Label: String (System.String) <4078B66C>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 66 6F 6F                                        foo

   Label: String (System.String) <51E4A317>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 62 61 72                                        bar

   Label: Int32 (System.Int32) <5ADF167B>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 EF BE AD DE 00 00 00 40 5C 03 00 00             ï¾-Þ   @\�

   Label: Boolean (System.Boolean) <7D8C4C1D>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 01 00 00 00 00 00 00 00                         �

Parâmetros

-Count

Isso representa o número de bytes a serem incluídos na saída hexadecimal.

Esse parâmetro foi introduzido no PowerShell 6.2.

Tipo:Int64
Position:Named
Default value:Int64.MaxValue
Necessário:False
Aceitar entrada de pipeline:False
Aceitar carateres universais:False

-Encoding

Especifica a codificação das cadeias de caracteres de entrada. Isto aplica-se apenas aos [string] inputs. O parâmetro não tem efeito sobre os tipos numéricos. O valor de saída é sempre utf8NoBOM.

Os valores aceitáveis para este parâmetro são os seguintes:

  • ascii: Usa a codificação para o conjunto de caracteres ASCII (7 bits).
  • ansi: Usa a codificação para a página de código ANSI da cultura atual. Essa opção foi adicionada no PowerShell 7.4.
  • bigendianunicode: Codifica no formato UTF-16 usando a ordem de bytes big-endian.
  • bigendianutf32: Codifica no formato UTF-32 usando a ordem de bytes big-endian.
  • oem: Usa a codificação padrão para MS-DOS e programas de console.
  • unicode: Codifica no formato UTF-16 usando a ordem de bytes little-endian.
  • utf7: Codifica em formato UTF-7.
  • utf8: Codifica em formato UTF-8.
  • utf8BOM: Codifica no formato UTF-8 com marca de ordem de bytes (BOM)
  • utf8NoBOM: Codifica no formato UTF-8 sem marca de ordem de bytes (BOM)
  • utf32: Codifica em formato UTF-32.

A partir do PowerShell 6.2, o parâmetro Encoding também permite IDs numéricas de páginas de código registradas (como -Encoding 1251) ou nomes de cadeia de caracteres de páginas de código registradas (como -Encoding "windows-1251"). Para obter mais informações, consulte a documentação do .NET para Encoding.CodePage.

A partir do PowerShell 7.4, você pode usar o Ansi valor do parâmetro Encoding para passar a ID numérica da página de código ANSI da cultura atual sem precisar especificá-la manualmente.

Nota

UTF-7* não é mais recomendado para usar. A partir do PowerShell 7.1, um aviso será escrito se você especificar utf7 para o parâmetro Encoding .

Tipo:Encoding
Valores aceites:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Position:Named
Default value:UTF8NoBOM
Necessário:False
Aceitar entrada de pipeline:False
Aceitar carateres universais:False

-InputObject

Especifica os objetos a serem formatados. Insira uma variável que contenha os objetos ou digite um comando ou expressão que obtenha os objetos.

Apenas alguns tipos escalares e [system.io.fileinfo] são suportados.

Os tipos escalares suportados são:

  • [string], [char]
  • [byte], [sbyte]
  • [int16], [uint16], [short], [ushort]
  • [int], [uint], [int32], [uint32],
  • [long], [ulong], [int64], [uint64]
  • [single], [float], [double]
  • [boolean]

Antes do PowerShell 6.2, Format-Hex tratava uma entrada de Pipeline com vários tipos de entrada agrupando todos os objetos semelhantes. Agora, ele lida com cada objeto individual à medida que passa pelo Pipeline e não agrupará objetos, a menos que objetos semelhantes estejam adjacentes.

Tipo:PSObject
Position:Named
Default value:None
Necessário:True
Aceitar entrada de pipeline:True
Aceitar carateres universais:False

-LiteralPath

Especifica o caminho completo para um arquivo. O valor de LiteralPath é usado exatamente como é digitado. Este parâmetro não aceita caracteres curinga. Para especificar vários caminhos para arquivos, separe os caminhos com uma vírgula. Se o parâmetro LiteralPath incluir caracteres de escape, coloque o caminho entre aspas simples. O PowerShell não interpreta nenhum caractere em uma única cadeia de caracteres entre aspas como sequências de escape. Para obter mais informações, consulte about_Quoting_Rules.

Tipo:String[]
Aliases:PSPath, LP
Position:Named
Default value:None
Necessário:True
Aceitar entrada de pipeline:False
Aceitar carateres universais:False

-Offset

Isso representa o número de bytes a serem ignorados de fazer parte da saída hexadecimal.

Esse parâmetro foi introduzido no PowerShell 6.2.

Tipo:Int64
Position:Named
Default value:0
Necessário:False
Aceitar entrada de pipeline:False
Aceitar carateres universais:False

-Path

Especifica o caminho para os arquivos. Use um ponto (.) para especificar o local atual. O caractere curinga (*) é aceito e pode ser usado para especificar todos os itens em um local. Se o parâmetro Path incluir caracteres de escape, coloque o caminho entre aspas simples. Para especificar vários caminhos para arquivos, separe os caminhos com uma vírgula.

Tipo:String[]
Position:0
Default value:None
Necessário:True
Aceitar entrada de pipeline:False
Aceitar carateres universais:True

-Raw

Este parâmetro já não faz nada. Ele é mantido para compatibilidade de script.

Tipo:SwitchParameter
Position:Named
Default value:None
Necessário:False
Aceitar entrada de pipeline:False
Aceitar carateres universais:False

Entradas

String

Você pode canalizar uma cadeia de caracteres para este cmdlet.

Saídas

ByteCollection

Este cmdlet retorna um ByteCollection. Este objeto representa uma coleção de bytes. Ele inclui métodos que convertem a coleção de bytes em uma cadeia de caracteres formatada como cada linha de saída retornada pelo Format-Hex. A saída também indica o tipo de bytes que estão sendo processados. Se você especificar o parâmetro Path ou LiteralPath , o objeto conterá o caminho do arquivo que contém cada byte. Se você passar uma corda, booleano, inteiro, etc, ele será rotulado adequadamente.

Notas

O PowerShell inclui os seguintes aliases para Format-Hex:

  • Todas as plataformas:
    • fhx

A coluna mais à direita da saída tenta renderizar os bytes como caracteres ASCII:

Geralmente, cada byte é interpretado como um ponto de código Unicode, o que significa que:

  • Caracteres ASCII imprimíveis são sempre renderizados corretamente
  • Caracteres UTF-8 de vários bytes nunca são renderizados corretamente
  • Os caracteres UTF-16 são renderizados corretamente somente se o byte de alta ordem for NUL.