Format-Hex

  • Referentie
Module:
Microsoft.PowerShell.Utility

Geeft een bestand of andere invoer weer als hexadecimaal.

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

Description

De Format-Hex cmdlet geeft een bestand of andere invoer weer als hexadecimale waarden. Als u de verschuiving van een teken uit de uitvoer wilt bepalen, voegt u het getal aan de linkerkant van de rij toe aan het getal boven aan de kolom voor dat teken.

De Format-Hex cmdlet kan u helpen bij het bepalen van het bestandstype van een beschadigd bestand of een bestand dat mogelijk geen bestandsnaamextensie heeft. U kunt deze cmdlet uitvoeren en vervolgens de hexadecimale uitvoer lezen om bestandsgegevens op te halen.

Wanneer u een bestand gebruikt Format-Hex , negeert de cmdlet newlinetekens en retourneert de volledige inhoud van een bestand in één tekenreeks, waarbij de nieuwe regeltekens behouden blijven.

Voorbeelden

Voorbeeld 1: de hexadecimale weergave van een tekenreeks ophalen

Met deze opdracht worden de hexadecimale waarden van een tekenreeks geretourneerd.

'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

De tekenreeks Hallo wereld wordt door de pijplijn naar de Format-Hex cmdlet verzonden. De hexadecimale uitvoer van Format-Hex waaruit de waarden van elk teken in de tekenreeks worden weergegeven.

Voorbeeld 2: Een bestandstype zoeken uit de hexadecimale uitvoer

In dit voorbeeld wordt de hexadecimale uitvoer gebruikt om het bestandstype te bepalen. De cmdlet geeft het volledige pad van het bestand en de hexadecimale waarden weer.

Als u de volgende opdracht wilt testen, maakt u een kopie van een bestaand PDF-bestand op uw lokale computer en wijzigt u de naam van het gekopieerde bestand 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

De Format-Hex cmdlet gebruikt de parameter Path om een bestandsnaam op te geven in de huidige map, File.t7f. De bestandsextensie .t7f is ongebruikelijk, maar de hexadecimale uitvoer %PDF laat zien dat het een PDF-bestand is. In dit voorbeeld wordt de parameter Count gebruikt om de uitvoer te beperken tot de eerste 48 bytes van het bestand.

Voorbeeld 3: Een matrix van verschillende gegevenstypen opmaken

In dit voorbeeld wordt een matrix met verschillende gegevenstypen gebruikt om aan te geven hoe Format-Hex deze worden verwerkt in de pijplijn.

Elk object wordt doorgegeven via de pijplijn en wordt afzonderlijk verwerkt. Als het echter numerieke gegevens zijn en het aangrenzende object ook numeriek is, worden deze gegroepeerd in één uitvoerblok.

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

Parameters

-Count

Dit vertegenwoordigt het aantal bytes dat moet worden opgenomen in de hex-uitvoer.

Deze parameter is geïntroduceerd in PowerShell 6.2.

Type:Int64
Position:Named
Default value:Int64.MaxValue
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Encoding

Hiermee geeft u de codering van de invoerreeksen. Dit geldt alleen voor [string] invoer. De parameter heeft geen effect op numerieke typen. De uitvoerwaarde is altijd utf8NoBOM.

De acceptabele waarden voor deze parameter zijn als volgt:

  • ascii: gebruikt de codering voor de ASCII-tekenset (7-bits).
  • bigendianunicode: Codeert in UTF-16-indeling met behulp van de bytevolgorde big-endian.
  • bigendianutf32: Codeert in UTF-32-indeling met behulp van de bytevolgorde big-endian.
  • oem: maakt gebruik van de standaardcodering voor MS-DOS en consoleprogramma's.
  • unicode: Codeert in UTF-16-indeling met behulp van de bytevolgorde little-endian.
  • utf7: Codeert in UTF-7-indeling.
  • utf8: Codeert in UTF-8-indeling.
  • utf8BOM: Codeert in UTF-8-indeling met Byte Order Mark (BOM)
  • utf8NoBOM: Codeert in UTF-8-indeling zonder Byte Order Mark (BOM)
  • utf32: Codeert in UTF-32-indeling.

Vanaf PowerShell 6.2 staat de coderingsparameter ook numerieke id's toe van geregistreerde codepagina's (zoals -Encoding 1251) of tekenreeksnamen van geregistreerde codepagina's (zoals-Encoding "windows-1251"). Zie de .NET-documentatie voor Encoding.CodePage voor meer informatie.

Notitie

UTF-7* wordt niet meer aanbevolen om te gebruiken. Vanaf PowerShell 7.1 wordt een waarschuwing geschreven als u opgeeft utf7 voor de coderingsparameter .

Type:Encoding
Accepted values:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Position:Named
Default value:UTF8NoBOM
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-InputObject

Hiermee geeft u de objecten die moeten worden opgemaakt. Voer een variabele in die de objecten bevat of typ een opdracht of expressie waarmee de objecten worden opgehaald.

Alleen bepaalde scalaire typen en [system.io.fileinfo] worden ondersteund.

De ondersteunde scalaire typen zijn:

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

Vóór PowerShell 6.2 Format-Hex zou een pijplijninvoer met meerdere invoertypen worden verwerkt door alle achtige objecten samen te groeperen. Nu wordt elk afzonderlijk object verwerkt terwijl het door de pijplijn gaat en objecten niet groepeert, tenzij dergelijke objecten aangrenzend zijn.

Type:PSObject
Position:Named
Default value:None
Required:True
Accept pipeline input:True
Accept wildcard characters:False

-LiteralPath

Hiermee geeft u het volledige pad naar een bestand. De waarde van LiteralPath wordt exact gebruikt zoals deze is getypt. Deze parameter accepteert geen jokertekens. Als u meerdere paden naar bestanden wilt opgeven, scheidt u de paden met een komma. Als de parameter LiteralPath escape-tekens bevat, plaatst u het pad tussen enkele aanhalingstekens. PowerShell interpreteert geen tekens in één tekenreeks tussen aanhalingstekens als escapereeksen. Zie about_Quoting_Rules voor meer informatie.

Type:String[]
Aliases:PSPath, LP
Position:Named
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:False

-Offset

Dit geeft het aantal bytes aan dat moet worden overgeslagen als onderdeel van de hexuitvoer.

Deze parameter is geïntroduceerd in PowerShell 6.2.

Type:Int64
Position:Named
Default value:0
Required:False
Accept pipeline input:False
Accept wildcard characters:False

-Path

Hiermee geeft u het pad naar bestanden. Gebruik een punt (.) om de huidige locatie op te geven. Het jokerteken (*) wordt geaccepteerd en kan worden gebruikt om alle items op een locatie op te geven. Als de parameter Path escape-tekens bevat, plaatst u het pad tussen enkele aanhalingstekens. Als u meerdere paden naar bestanden wilt opgeven, scheidt u de paden met een komma.

Type:String[]
Position:0
Default value:None
Required:True
Accept pipeline input:False
Accept wildcard characters:True

-Raw

Deze parameter doet niets meer. Deze wordt bewaard voor scriptcompatibiliteit.

Type:SwitchParameter
Position:Named
Default value:None
Required:False
Accept pipeline input:False
Accept wildcard characters:False

Invoerwaarden

String

U kunt een tekenreeks doorsluisen naar deze cmdlet.

Uitvoerwaarden

ByteCollection

Deze cmdlet retourneert een ByteCollection. Dit object vertegenwoordigt een verzameling bytes. Het bevat methoden waarmee de verzameling bytes wordt geconverteerd naar een tekenreeks die is opgemaakt zoals elke regel uitvoer die wordt geretourneerd door Format-Hex. De uitvoer geeft ook aan dat het type bytes wordt verwerkt. Als u de parameter Path of LiteralPath opgeeft, bevat het object het pad van het bestand dat elke byte bevat. Als u een tekenreeks, booleaanse waarde, geheel getal enzovoort doorgeeft, wordt deze op de juiste manier gelabeld.

Notities

PowerShell bevat de volgende aliassen voor Format-Hex:

  • Alle platforms:
    • fhx

De meest rechtse kolom met uitvoer probeert de bytes weer te geven als ASCII-tekens:

Over het algemeen wordt elke byte geïnterpreteerd als een Unicode-codepunt, wat betekent dat:

  • Afdrukbare ASCII-tekens worden altijd correct weergegeven
  • UTF-8 tekens met meerdere bytes worden nooit correct weergegeven
  • UTF-16 tekens worden alleen correct weergegeven als hun byte in hoge volgorde plaatsvindt NUL.