Compartir a través de

Format-Hex

  • Referencia
Módulo:
Microsoft.PowerShell.Utility

Muestra un archivo u otra entrada como hexadecimal.

Sintaxis

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

El Format-Hex cmdlet muestra un archivo u otra entrada como valores hexadecimales. Para determinar el desplazamiento de un carácter de la salida, agregue el número situado más a la izquierda de la fila al número situado en la parte superior de la columna para ese carácter.

El Format-Hex cmdlet puede ayudarle a determinar el tipo de archivo de un archivo dañado o un archivo que podría no tener una extensión de nombre de archivo. Puede ejecutar este cmdlet y, a continuación, leer la salida hexadecimal para obtener información de archivo.

Cuando se usa Format-Hex en un archivo, el cmdlet omite los caracteres de nueva línea y devuelve todo el contenido de un archivo en una cadena con los caracteres de nueva línea conservados.

Ejemplos

Ejemplo 1: Obtener la representación hexadecimal de una cadena

Este comando devuelve los valores hexadecimales de una cadena.

'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 cadena Hola mundo se envía a la canalización al Format-Hex cmdlet . La salida hexadecimal de Format-Hex muestra los valores de cada carácter de la cadena.

Ejemplo 2: Buscar un tipo de archivo de la salida hexadecimal

En este ejemplo se usa la salida hexadecimal para determinar el tipo de archivo. El cmdlet muestra la ruta de acceso completa del archivo y los valores hexadecimales.

Para probar el siguiente comando, realice una copia de un archivo PDF existente en el equipo local y cambie el nombre del archivo copiado a 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

El Format-Hex cmdlet usa el parámetro Path para especificar un nombre de archivo en el directorio actual, File.t7f. La extensión .t7f de archivo es poco común, pero la salida %PDF hexadecimal muestra que es un archivo PDF. En este ejemplo, el parámetro Count se usa para limitar la salida a los primeros 48 bytes del archivo.

Ejemplo 3: Dar formato a una matriz de diferentes tipos de datos

En este ejemplo se usa una matriz de diferentes tipos de datos para resaltar cómo Format-Hex los controla en la canalización.

Pasará cada objeto a través de la canalización y el proceso individualmente. Sin embargo, si es datos numéricos y el objeto adyacente también es numérico, los agrupará en un único bloque de salida.

'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

Representa el número de bytes que se van a incluir en la salida hexadecimal.

Este parámetro se introdujo en PowerShell 6.2.

Tipo:Int64
Posición:Named
Valor predeterminado:Int64.MaxValue
Requerido:False
Aceptar entrada de canalización:False
Aceptar caracteres comodín:False

-Encoding

Especifica la codificación de las cadenas de entrada. Esto solo se aplica a la [string] entrada. El parámetro no tiene ningún efecto en los tipos numéricos. El valor de salida siempre utf8NoBOMes .

Los valores aceptables para este parámetro son los siguientes:

  • ascii: usa la codificación para el juego de caracteres ASCII (7 bits).
  • ansi: usa la codificación para la página de códigos ANSI de la referencia cultural actual. Esta opción se agregó en PowerShell 7.4.
  • bigendianunicode: codifica en formato UTF-16 mediante el orden de bytes big-endian.
  • bigendianutf32: codifica en formato UTF-32 mediante el orden de bytes big-endian.
  • oem: usa la codificación predeterminada para los programas de consola y MS-DOS.
  • unicode: codifica en formato UTF-16 mediante el orden de bytes little-endian.
  • utf7: codifica en formato UTF-7.
  • utf8: codifica en formato UTF-8.
  • utf8BOM: codifica en formato UTF-8 con marca de orden de bytes (BOM)
  • utf8NoBOM: codifica en formato UTF-8 sin marca de orden de bytes (BOM)
  • utf32: codifica en formato UTF-32.

A partir de PowerShell 6.2, el parámetro Encoding también permite identificadores numéricos de páginas de códigos registradas (como -Encoding 1251) o nombres de cadena de páginas de códigos registradas (como -Encoding "windows-1251"). Para obtener más información, consulte la documentación de .NET para Encoding.CodePage.

A partir de PowerShell 7.4, puede usar el Ansi valor del parámetro Encoding para pasar el identificador numérico de la página de códigos ANSI de la referencia cultural actual sin tener que especificarlo manualmente.

Nota:

Ya no se recomienda usar UTF-7*. A partir de PowerShell 7.1, se escribe una advertencia si especifica utf7 para el parámetro Encoding .

Tipo:Encoding
Valores aceptados:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Posición:Named
Valor predeterminado:UTF8NoBOM
Requerido:False
Aceptar entrada de canalización:False
Aceptar caracteres comodín:False

-InputObject

Especifica los objetos a los que se dará formato. Especifique una variable que contenga los objetos, o escriba un comando o una expresión que obtenga los objetos.

Solo se admiten determinados tipos escalares y [system.io.fileinfo] .

Los tipos escalares admitidos son:

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

Antes de PowerShell 6.2, Format-Hex controlaría una entrada de canalización con varios tipos de entrada agrupando todos los objetos similares. Ahora, controla cada objeto individual a medida que pasa por la canalización y no agrupará los objetos a menos que los objetos sean adyacentes.

Tipo:PSObject
Posición:Named
Valor predeterminado:None
Requerido:True
Aceptar entrada de canalización:True
Aceptar caracteres comodín:False

-LiteralPath

Especifica la ruta de acceso completa a un archivo. El valor de LiteralPath se usa exactamente como se escribe. Este parámetro no acepta caracteres comodín. Para especificar varias rutas de acceso a los archivos, separe las rutas de acceso con una coma. Si el parámetro LiteralPath incluye caracteres de escape, incluya la ruta de acceso entre comillas simples. PowerShell no interpreta ningún carácter de una sola cadena entre comillas como secuencias de escape. Para obtener más información, consulte about_Quoting_Rules.

Tipo:String[]
Alias:PSPath, LP
Posición:Named
Valor predeterminado:None
Requerido:True
Aceptar entrada de canalización:False
Aceptar caracteres comodín:False

-Offset

Esto representa el número de bytes que se omitirán de formar parte de la salida hexadecimal.

Este parámetro se introdujo en PowerShell 6.2.

Tipo:Int64
Posición:Named
Valor predeterminado:0
Requerido:False
Aceptar entrada de canalización:False
Aceptar caracteres comodín:False

-Path

Especifica la ruta de acceso a los archivos. Use un punto (.) para especificar la ubicación actual. El carácter comodín (*) se acepta y se puede usar para especificar todos los elementos de una ubicación. Si el parámetro Path incluye caracteres de escape, incluya la ruta de acceso entre comillas simples. Para especificar varias rutas de acceso a los archivos, separe las rutas de acceso con una coma.

Tipo:String[]
Posición:0
Valor predeterminado:None
Requerido:True
Aceptar entrada de canalización:False
Aceptar caracteres comodín:True

-Raw

Este parámetro ya no hace nada. Se conserva para la compatibilidad de scripts.

Tipo:SwitchParameter
Posición:Named
Valor predeterminado:None
Requerido:False
Aceptar entrada de canalización:False
Aceptar caracteres comodín:False

Entradas

String

Puede canalizar una cadena a este cmdlet.

Salidas

ByteCollection

Este cmdlet devuelve un byteCollection. Este objeto representa una colección de bytes. Incluye métodos que convierten la colección de bytes en una cadena con formato similar a cada línea de salida devuelta por Format-Hex. La salida también indica el tipo de bytes que se están procesando. Si especifica el parámetro Path o LiteralPath , el objeto contiene la ruta de acceso del archivo que contiene cada byte. Si pasa una cadena, booleana, entero, etcetera, se etiquetará correctamente.

Notas

PowerShell incluye los siguientes alias para Format-Hex:

  • Todas las plataformas:
    • fhx

La columna de salida más derecha intenta representar los bytes como caracteres ASCII:

Por lo general, cada byte se interpreta como un punto de código Unicode, lo que significa que:

  • Los caracteres ASCII imprimibles siempre se representan correctamente
  • Los caracteres UTF-8 de varios bytes nunca se representan correctamente
  • Los caracteres UTF-16 se representan correctamente solo si su byte de orden alto se produce como NUL.