Format-Hex

  • Riferimento
Modulo:
Microsoft.PowerShell.Utility

Visualizza un file o un altro input come esadecimale.

Sintassi

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>]

Descrizione

Il Format-Hex cmdlet visualizza un file o un altro input come valori esadecimali. Per determinare l'offset di un carattere dall'output, aggiungere il numero all'estrema sinistra della riga al numero nella parte superiore della colonna per tale carattere.

Il Format-Hex cmdlet consente di determinare il tipo di file di un file danneggiato o un file che potrebbe non avere un'estensione del nome file. È possibile eseguire questo cmdlet e quindi leggere l'output esadecimale per ottenere informazioni sul file.

Quando si usa Format-Hex in un file, il cmdlet ignora i caratteri di nuova riga e restituisce l'intero contenuto di un file in una stringa con i caratteri di nuova riga mantenuti.

Esempio

Esempio 1: Ottenere la rappresentazione esadecimale di una stringa

Questo comando restituisce i valori esadecimali di una stringa.

'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

La stringa Hello World viene inviata alla pipeline al Format-Hex cmdlet . L'output esadecimale da Format-Hex mostra i valori di ogni carattere nella stringa.

Esempio 2: Trovare un tipo di file dall'output esadecimale

In questo esempio viene usato l'output esadecimale per determinare il tipo di file. Il cmdlet visualizza il percorso completo del file e i valori esadecimali.

Per testare il comando seguente, creare una copia di un file PDF esistente nel computer locale e rinominare il file copiato in 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

Il Format-Hex cmdlet usa il parametro Path per specificare un nome file nella directory corrente, File.t7f. L'estensione .t7f del file non è comune, ma l'output %PDF esadecimale mostra che si tratta di un file PDF. In questo esempio, il parametro Count viene usato per limitare l'output ai primi 48 byte del file.

Esempio 3: Formattare una matrice di tipi di dati diversi

In questo esempio viene usata una matrice di tipi di dati diversi per evidenziare il modo Format-Hex in cui vengono gestiti nella pipeline.

Passerà ogni oggetto attraverso la pipeline ed eseguirà singolarmente il processo. Tuttavia, se si tratta di dati numerici e l'oggetto adiacente è anche numerico, li raggruppa in un singolo blocco di output.

'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                         �

Parametri

-Count

Rappresenta il numero di byte da includere nell'output esadecimale.

Questo parametro è stato introdotto in PowerShell 6.2.

Tipo:Int64
Posizione:Named
Valore predefinito:Int64.MaxValue
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Encoding

Specifica la codifica delle stringhe di input. Questo vale solo per l'input [string] . Il parametro non ha alcun effetto sui tipi numerici. Il valore di output è sempre utf8NoBOM.

I valori accettabili per questo parametro sono i seguenti:

  • ascii: usa la codifica per il set di caratteri ASCII (a 7 bit).
  • ansi: usa la codifica per per la tabella codici ANSI delle impostazioni cultura correnti. Questa opzione è stata aggiunta in PowerShell 7.4.
  • bigendianunicode: codifica in formato UTF-16 usando l'ordine dei byte big-endian.
  • bigendianutf32: codifica in formato UTF-32 usando l'ordine dei byte big-endian.
  • oem: usa la codifica predefinita per i programmi MS-DOS e console.
  • unicode: codifica in formato UTF-16 usando l'ordine dei byte little-endian.
  • utf7: codifica in formato UTF-7.
  • utf8: codifica in formato UTF-8.
  • utf8BOM: codifica in formato UTF-8 con byte order mark (BOM)
  • utf8NoBOM: codifica in formato UTF-8 senza byte order mark (BOM)
  • utf32: codifica in formato UTF-32.

A partire da PowerShell 6.2, il parametro Encoding consente anche ID numerici di tabelle codici registrate (ad esempio ) o nomi di stringhe di tabelle codici registrate (ad esempio -Encoding 1251-Encoding "windows-1251"). Per altre informazioni, vedere la documentazione di .NET per Encoding.CodePage.

A partire da PowerShell 7.4, è possibile usare il Ansi valore per il parametro Encoding per passare l'ID numerico per la tabella codici ANSI delle impostazioni cultura correnti senza doverlo specificare manualmente.

Nota

UTF-7* non è più consigliato per l'uso. A partire da PowerShell 7.1, viene scritto un avviso se si specifica utf7 per il parametro Encoding .

Tipo:Encoding
Valori accettati:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Posizione:Named
Valore predefinito:UTF8NoBOM
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-InputObject

Specifica gli oggetti da formattare. Immettere una variabile che contiene gli oggetti oppure digitare un comando o un'espressione che ottiene gli oggetti.

Sono supportati solo determinati tipi scalari e [system.io.fileinfo] .

I tipi scalari supportati sono:

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

Prima di PowerShell 6.2, Format-Hex gestirebbe un input della pipeline con più tipi di input raggruppando tutti gli oggetti come insieme. Ora gestisce ogni singolo oggetto mentre passa attraverso la pipeline e non raggruppa gli oggetti a meno che gli oggetti non siano adiacenti.

Tipo:PSObject
Posizione:Named
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:True
Accettare caratteri jolly:False

-LiteralPath

Specifica il percorso completo di un file. Il valore di LiteralPath viene usato esattamente come viene tipizzato. Questo parametro non accetta caratteri jolly. Per specificare più percorsi per i file, separare i percorsi con una virgola. Se il parametro LiteralPath include caratteri di escape, racchiudere il percorso tra virgolette singole. PowerShell non interpreta i caratteri in una singola stringa tra virgolette come sequenze di escape. Per altre informazioni, vedere about_Quoting_Rules.

Tipo:String[]
Alias:PSPath, LP
Posizione:Named
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Offset

Rappresenta il numero di byte da ignorare dall'essere parte dell'output esadecimale.

Questo parametro è stato introdotto in PowerShell 6.2.

Tipo:Int64
Posizione:Named
Valore predefinito:0
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

-Path

Specifica il percorso dei file. Usare un punto (.) per specificare la posizione corrente. Il carattere jolly (*) viene accettato e può essere usato per specificare tutti gli elementi in una posizione. Se il parametro Path include caratteri di escape, racchiudere il percorso tra virgolette singole. Per specificare più percorsi per i file, separare i percorsi con una virgola.

Tipo:String[]
Posizione:0
Valore predefinito:None
Necessario:True
Accettare l'input della pipeline:False
Accettare caratteri jolly:True

-Raw

Questo parametro non esegue più alcuna operazione. Viene conservato per la compatibilità degli script.

Tipo:SwitchParameter
Posizione:Named
Valore predefinito:None
Necessario:False
Accettare l'input della pipeline:False
Accettare caratteri jolly:False

Input

String

È possibile inviare tramite pipe una stringa a questo cmdlet.

Output

ByteCollection

Questo cmdlet restituisce un Oggetto ByteCollection. Questo oggetto rappresenta una raccolta di byte. Include metodi che convertono la raccolta di byte in una stringa formattata come ogni riga di output restituita da Format-Hex. L'output indica anche il tipo di byte da elaborare. Se si specifica il parametro Path o LiteralPath , l'oggetto contiene il percorso del file che contiene ogni byte. Se si passa una stringa, un valore booleano, un numero intero e così via, verrà etichettata in modo appropriato.

Note

PowerShell include gli alias seguenti per Format-Hex:

  • Tutte le piattaforme:
    • fhx

La colonna di output più a destra tenta di eseguire il rendering dei byte come caratteri ASCII:

In genere, ogni byte viene interpretato come punto di codice Unicode, il che significa che:

  • Il rendering dei caratteri ASCII stampabili viene sempre eseguito correttamente
  • Il rendering dei caratteri UTF-8 a più byte non viene mai eseguito correttamente
  • I caratteri UTF-16 vengono visualizzati correttamente solo se il byte di ordine elevato è NUL.