Delen via

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 uiterst links 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 bestandsinformatie op te halen.

Wanneer u op Format-Hex een bestand gebruikt, negeert de cmdlet nieuwe regeltekens en retourneert de volledige inhoud van een bestand in één tekenreeks met behoud van de nieuwe regeltekens.

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 toont de waarden van elk teken in de tekenreeks.

Voorbeeld 2: Een bestandstype zoeken uit 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 path-parameter 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 met verschillende gegevenstypen opmaken

In dit voorbeeld wordt een matrix met verschillende gegevenstypen gebruikt om te laten zien hoe Format-Hex ze worden verwerkt in de pijplijn.

Elk object wordt afzonderlijk doorgegeven via de pijplijn en het proces. Als het echter numerieke gegevens zijn en het aangrenzende object ook numeriek is, worden ze 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 hexuitvoer.

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 invoertekenreeksen. Dit geldt alleen voor [string] invoer. De parameter heeft geen invloed 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: Gebruikt 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 er 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 op 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], [uint], [int32], [uint32],
  • [long], [ulong], [int64], [uint64]
  • [single], [float], [double]
  • [boolean]

Vóór PowerShell 6.2 werd Format-Hex een pijplijninvoer met meerdere invoertypen verwerkt door alle objecten te groeperen. Nu wordt elk afzonderlijk object verwerkt wanneer het de pijplijn passeert en worden objecten niet gegroepeerd, tenzij er objecten als 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 precies gebruikt zoals deze wordt 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 met aanhalingstekens als escape-reeksen. 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 vertegenwoordigt het aantal bytes 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 doorsnijden 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 bevat dat 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

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
  • Multi-byte UTF-8-tekens worden nooit correct weergegeven
  • UTF-16-tekens worden alleen correct weergegeven als hun byte met hoge volgorde plaatsvindt NUL.