Freigeben über

Format-Hex

  • Referenz
Modul:
Microsoft.PowerShell.Utility

Zeigt eine Datei oder eine andere Eingabe als hexadezimal an.

Syntax

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

Beschreibung

Das Format-Hex Cmdlet zeigt eine Datei oder eine andere Eingabe als Hexadezimalwerte an. Um den Offset eines Zeichens aus der Ausgabe zu bestimmen, fügen Sie die Zahl ganz links neben der Zeile zur Zahl am oberen Rand der Spalte für dieses Zeichen hinzu.

Mit dem Format-Hex Cmdlet können Sie den Dateityp einer beschädigten Datei oder einer Datei ermitteln, die möglicherweise nicht über eine Dateinamenerweiterung verfügt. Sie können dieses Cmdlet ausführen und dann die Hexadezimalausgabe lesen, um Dateiinformationen abzurufen.

Bei Verwendung Format-Hex in einer Datei ignoriert das Cmdlet Neuzeilenzeichen und gibt den gesamten Inhalt einer Datei in einer Zeichenfolge zurück, wobei die Neuenzeilenzeichen beibehalten werden.

Beispiele

Beispiel 1: Abrufen der hexadezimalen Darstellung einer Zeichenfolge

Dieser Befehl gibt die Hexadezimalwerte einer Zeichenfolge zurück.

'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

Die Zeichenfolge Hallo Welt wird an das Format-Hex Cmdlet gesendet. Die Hexadezimalausgabe zeigt Format-Hex die Werte der einzelnen Zeichen in der Zeichenfolge an.

Beispiel 2: Suchen eines Dateityps aus hexadezimaler Ausgabe

In diesem Beispiel wird die Hexadezimalausgabe verwendet, um den Dateityp zu bestimmen. Das Cmdlet zeigt den vollständigen Pfad der Datei und die Hexadezimalwerte an.

Um den folgenden Befehl zu testen, erstellen Sie eine Kopie einer vorhandenen PDF-Datei auf Ihrem lokalen Computer, und benennen Sie die kopierte Datei 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

Das Format-Hex Cmdlet verwendet den Parameter Path, um einen Dateinamen im aktuellen Verzeichnis anzugeben. File.t7f Die Dateierweiterung .t7f ist ungewöhnlich, aber die Hexadezimalausgabe %PDF zeigt, dass es sich um eine PDF-Datei handelt. In diesem Beispiel wird der Count-Parameter verwendet, um die Ausgabe auf die ersten 48 Bytes der Datei zu beschränken.

Beispiel 3: Formatieren eines Arrays verschiedener Datentypen

In diesem Beispiel wird ein Array unterschiedlicher Datentypen verwendet, um hervorzuheben, wie Format-Hex sie in der Pipeline behandelt werden.

Es wird jedes Objekt durch die Pipeline übergeben und einzeln verarbeitet. Wenn es sich jedoch um numerische Daten handelt und das angrenzende Objekt auch numerisch ist, wird es in einen einzelnen Ausgabeblock gruppiert.

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

Parameter

-Count

Dies stellt die Anzahl der Bytes dar, die in die Hexausgabe eingeschlossen werden sollen.

Dieser Parameter wurde in PowerShell 6.2 eingeführt.

Typ:Int64
Position:Named
Standardwert:Int64.MaxValue
Erforderlich:False
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:False

-Encoding

Gibt die Codierung der Eingabezeichenfolgen an. Dies gilt nur für [string] Eingaben. Der Parameter hat keine Auswirkungen auf numerische Typen. Der Ausgabewert ist immer utf8NoBOM.

Die zulässigen Werte für diesen Parameter sind wie folgt:

  • ascii: Verwendet die Codierung für den ASCII-Zeichensatz (7-Bit).
  • ansi: Verwendet die Codierung für die ANSI-Codeseite der aktuellen Kultur. Diese Option wurde in PowerShell 7.4 hinzugefügt.
  • bigendianunicode: Codiert im UTF-16-Format mit der Big-End-Byte-Reihenfolge.
  • bigendianutf32: Codiert im UTF-32-Format mithilfe der Big-End-Byte-Reihenfolge.
  • oem: Verwendet die Standardcodierung für MS-DOS- und Konsolenprogramme.
  • unicode: Codiert im UTF-16-Format mithilfe der Little-Endian-Bytereihenfolge.
  • utf7: Codiert im UTF-7-Format.
  • utf8: Codiert im UTF-8-Format.
  • utf8BOM: Codiert im UTF-8-Format mit Bytereihenfolgezeichen (BOM)
  • utf8NoBOM: Codiert im UTF-8-Format ohne Byte Order Mark (BOM)
  • utf32: Codiert im UTF-32-Format.

Ab PowerShell 6.2 ermöglicht der Encoding-Parameter auch numerische IDs registrierter Codeseiten (z -Encoding 1251. B. ) oder Zeichenfolgennamen registrierter Codeseiten (z -Encoding "windows-1251". B. ). Weitere Informationen finden Sie in der .NET-Dokumentation für Encoding.CodePage.

Ab PowerShell 7.4 können Sie den Ansi Wert für den Codierungsparameter verwenden, um die numerische ID für die ANSI-Codeseite der aktuellen Kultur zu übergeben, ohne sie manuell angeben zu müssen.

Hinweis

UTF-7* wird nicht mehr empfohlen, zu verwenden. Ab PowerShell 7.1 wird eine Warnung geschrieben, wenn Sie für den Codierungsparameter angebenutf7.

Typ:Encoding
Zulässige Werte:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Position:Named
Standardwert:UTF8NoBOM
Erforderlich:False
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:False

-InputObject

Gibt die zu formatierenden Objekte an. Geben Sie eine Variable ein, die die Objekte enthält, oder geben Sie einen Befehl oder einen Ausdruck ein, durch den die Objekte abgerufen werden.

Nur bestimmte skalare Typen und [system.io.fileinfo] werden unterstützt.

Die unterstützten Skalartypen sind:

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

Vor PowerShell 6.2 würde eine Pipelineeingabe mit mehreren Eingabetypen behandelt, Format-Hex indem alle Objekte gruppiert werden. Jetzt behandelt es jedes einzelne Objekt, während es durch die Pipeline durchläuft, und gruppiert objekte nicht zusammen, es sei denn, es handelt sich um benachbarte Objekte.

Typ:PSObject
Position:Named
Standardwert:None
Erforderlich:True
Pipelineeingabe akzeptieren:True
Platzhalterzeichen akzeptieren:False

-LiteralPath

Gibt den vollständigen Pfad zu einer Datei an. Der Wert von LiteralPath wird genau so verwendet, wie er eingegeben wird. Dieser Parameter akzeptiert keine Wildcardzeichen. Wenn Sie mehrere Pfade für Dateien angeben möchten, trennen Sie die Pfade durch ein Komma. Wenn der LiteralPath-Parameter Escapezeichen enthält, schließen Sie den Pfad in einfache Anführungszeichen ein. PowerShell interpretiert keine Zeichen in einer einzelnen Zeichenfolge in Anzeichen als Escapesequenzen. Weitere Informationen finden Sie unter about_Quoting_Rules.

Typ:String[]
Aliase:PSPath, LP
Position:Named
Standardwert:None
Erforderlich:True
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:False

-Offset

Dies stellt die Anzahl der Bytes dar, die aus dem Teil der Hex-Ausgabe übersprungen werden sollen.

Dieser Parameter wurde in PowerShell 6.2 eingeführt.

Typ:Int64
Position:Named
Standardwert:0
Erforderlich:False
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:False

-Path

Gibt den Pfad zu Dateien an. Verwenden Sie einen Punkt (.), um die aktuelle Position anzugeben. Das Wildcardzeichen (*) wird akzeptiert und kann verwendet werden, um alle Elemente an einem Speicherort anzugeben. Wenn der Parameter Path Escapezeichen enthält, schließen Sie den Pfad in einfache Anführungszeichen ein. Wenn Sie mehrere Pfade für Dateien angeben möchten, trennen Sie die Pfade durch ein Komma.

Typ:String[]
Position:0
Standardwert:None
Erforderlich:True
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:True

-Raw

Dieser Parameter führt nichts mehr aus. Sie wird für die Skriptkompatibilität beibehalten.

Typ:SwitchParameter
Position:Named
Standardwert:None
Erforderlich:False
Pipelineeingabe akzeptieren:False
Platzhalterzeichen akzeptieren:False

Eingaben

String

Sie können eine Zeichenfolge an dieses Cmdlet weiterleiten.

Ausgaben

ByteCollection

Dieses Cmdlet gibt eine ByteCollection zurück. Dieses Objekt stellt eine Auflistung von Bytes dar. Sie enthält Methoden, mit denen die Sammlung von Bytes in eine Zeichenfolge konvertiert wird, die wie jede von ihnen zurückgegebene Format-HexAusgabezeile formatiert ist. Die Ausgabe gibt auch den Typ der zu verarbeitenden Bytes an. Wenn Sie den Parameter "Path " oder "LiteralPath " angeben, enthält das Objekt den Pfad der Datei, die jedes Byte enthält. Wenn Sie eine Zeichenfolge, einen booleschen Wert, eine ganze Zahl usw. übergeben, wird sie entsprechend beschriftet.

Hinweise

PowerShell enthält die folgenden Aliase für Format-Hex:

  • Alle Plattformen:
    • fhx

Die am weitesten rechts stehende Ausgabespalte versucht, die Bytes als ASCII-Zeichen zu rendern:

Im Allgemeinen wird jedes Byte als Unicode-Codepunkt interpretiert, was bedeutet, dass:

  • Druckbare ASCII-Zeichen werden immer korrekt gerendert.
  • Mehrbyte-UTF-8-Zeichen werden nie richtig gerendert
  • UTF-16 Zeichen werden nur ordnungsgemäß gerendert, wenn ihr Byte mit hoher Reihenfolge auftritt NUL.