Sintaxis
#binary(list as list) as binary
Binary.From(value as any) as nullable binary
Binary.FromText(text as nullable text, optional encoding as nullable number) as nullable binary
¿Qué hace?
Crea valores de tipo binary. La literal #binary acepta una lista de bytes. Binary.FromText codifica un texto como bytes usando la codificación especificada.
Ejemplo
// Crear binario desde lista de bytes
#binary({0x48, 0x65, 0x6C, 0x6C, 0x6F}) // bytes de "Hello"
// Codificar texto como UTF-8
Binary.FromText("Hola mundo", TextEncoding.Utf8)
// Codificar texto como UTF-16
Binary.FromText("Hola", TextEncoding.Utf16)
💡 Tip kawaii: Las constantes de codificación más usadas son: TextEncoding.Utf8 (65001), TextEncoding.Utf16 (1200), TextEncoding.Windows (1252 para Europa Occidental). El número entre paréntesis es el código de página de Windows.
Sintaxis
Binary.ToText(binary as nullable binary, optional encoding as nullable number) as nullable text
Binary.Buffer(binary as nullable binary) as nullable binary
¿Qué hace?
Binary.ToText convierte bytes a texto usando la codificación especificada. Binary.Buffer carga el binario completamente en memoria para operaciones más rápidas (evita re-lecturas del stream).
Ejemplo
// Convertir binario a texto
let
contenido = File.Contents("C:\datos\notas.txt"),
texto = Binary.ToText(contenido, TextEncoding.Utf8)
in texto
// Buffering para acceso múltiple
let
binario = Web.Contents("https://api.ejemplo.com/archivo"),
buffered = Binary.Buffer(binario),
comoExcel = Excel.Workbook(buffered, true),
comoCSV = Csv.Document(buffered) // accede de nuevo sin re-descargar
in comoExcel
📌 Buena práctica: Usa Binary.Buffer cuando necesitas acceder al mismo binario varias veces (ej. para intentar parsearlo como Excel y, si falla, como CSV). Sin buffer, cada acceso re-descargaría el archivo.
Sintaxis
Binary.Length(binary as nullable binary) as nullable number
Binary.Range(binary as binary, offset as number, optional count as nullable number) as binary
Binary.InferContentType(binary as binary) as record
¿Qué hace?
Binary.Length devuelve el tamaño en bytes. Binary.Range extrae una subsecuencia de bytes (útil para parsear formatos binarios propietarios). Binary.InferContentType detecta el tipo MIME del binario.
Ejemplo
let b = #binary({0x50, 0x4B, 0x03, 0x04, 0x00}) // cabecera ZIP
in [
longitud = Binary.Length(b), // 5
primeros2 = Binary.Range(b, 0, 2), // #binary({0x50, 0x4B})
tipoMime = Binary.InferContentType(b) // [Content-Type = "application/zip", ...]
]
Sintaxis
Binary.Combine(binaries as list) as binary
// Formatos binarios para parsear estructuras
BinaryFormat.Byte as function
BinaryFormat.SignedInteger16 as function
BinaryFormat.SignedInteger32 as function
BinaryFormat.Float as function
BinaryFormat.Double as function
BinaryFormat.Text(encoding as number, count as number) as function
BinaryFormat.List(binaryFormat as function, count as number) as function
BinaryFormat.Record(record as record) as function
¿Qué hace?
Binary.Combine concatena varios binarios. Las funciones BinaryFormat.* definen un esquema para parsear formatos binarios estructurados (protocolos de red, archivos binarios propietarios).
Ejemplo
// Combinar varios binarios
Binary.Combine({
Binary.FromText("Parte1"),
Binary.FromText("Parte2"),
Binary.FromText("Parte3")
})
// Parsear estructura binaria (ej. cabecera de archivo)
let
formato = BinaryFormat.Record([
Firma = BinaryFormat.Text(TextEncoding.Ascii, 4),
Version = BinaryFormat.SignedInteger16,
Longitud = BinaryFormat.SignedInteger32
]),
datos = formato(#binary({0x4D,0x5A,0x50,0x45,0x01,0x00,0x00,0x00,0x00,0xFF}))
in datos
Sintaxis
Binary.Decompress(binary as binary, compressionType as number) as binary
Binary.Compress(binary as binary, compressionType as number) as binary
¿Qué hace?
Comprime o descomprime datos binarios. Los tipos de compresión disponibles son: Compression.GZip, Compression.Deflate, Compression.Snappy, Compression.LZ4, Compression.Brotli.
Ejemplo
// Descomprimir respuesta GZIP de una API
let
respuesta = Web.Contents("https://api.ejemplo.com/datos"),
descomprimido = Binary.Decompress(respuesta, Compression.GZip),
texto = Binary.ToText(descomprimido, TextEncoding.Utf8),
datos = Json.Document(texto)
in datos
// Descomprimir DEFLATE
Binary.Decompress(datos, Compression.Deflate)
💡 Tip kawaii: Muchas APIs REST devuelven respuestas comprimidas con GZIP para reducir el tamaño de transferencia. Si recibes datos binarios que no parseas correctamente, prueba primero a descomprimirlos con Binary.Decompress(respuesta, Compression.GZip).
Sintaxis
// Codificar a Base64
Binary.ToText(binary, BinaryEncoding.Base64) as text
// Decodificar desde Base64
Binary.FromText(base64Text, BinaryEncoding.Base64) as binary
// Base64 URL-safe
Binary.ToText(binary, BinaryEncoding.Base64Url) as text
¿Qué hace?
Convierte entre datos binarios y representación Base64 (texto). Muy útil para autenticación HTTP Basic, envío de archivos en APIs REST y procesamiento de datos codificados.
Ejemplo
// Crear cabecera de autenticación Basic
let
usuario = "mi_usuario",
contrasena = "mi_contrasena",
credenciales = usuario & ":" & contrasena,
base64 = Binary.ToText(
Binary.FromText(credenciales, TextEncoding.Utf8),
BinaryEncoding.Base64
),
cabecera = "Basic " & base64
in
Web.Contents("https://api.ejemplo.com/datos",
[Headers = [Authorization = cabecera]])
// Decodificar campo Base64 en respuesta JSON
let
base64dato = "SGVsbG8gV29ybGQ=",
binario = Binary.FromText(base64dato, BinaryEncoding.Base64),
texto = Binary.ToText(binario, TextEncoding.Utf8)
in texto // "Hello World"
📌 Buena práctica: Para autenticación HTTP Basic, genera siempre la credencial Base64 dinámicamente desde parámetros seguros, nunca hardcodees credenciales en el código M. Usa parámetros de Power Query o Azure Key Vault.
Sintaxis
File.Contents(path as text, optional options as nullable record) as binary
¿Qué hace?
Lee un archivo del sistema de archivos local y devuelve su contenido como binario. Es la función base para leer cualquier tipo de archivo: Excel, CSV, JSON, imágenes, etc.
Ejemplo
// Leer archivo y parsear según tipo
let
ruta = "C:\datos\informe.xlsx",
binario = File.Contents(ruta),
workbook = Excel.Workbook(binario, true)
in workbook
// Leer archivo de texto plano
let
ruta = "C:\datos\log.txt",
texto = Binary.ToText(File.Contents(ruta), TextEncoding.Utf8)
in texto
// Detectar tipo de archivo automáticamente
let
ruta = "C:\datos\archivo_desconocido",
b = Binary.Buffer(File.Contents(ruta)),
tipo = Binary.InferContentType(b)[#"Content-Type"]
in tipo