Entiende el sistema de tipos de M: tipos primitivos, nullable, conversión explícita y las funciones Type.*.
IntermedioAvanzado
🔍
🏷️
Tipos Primitivos de M
Tipos primitivos
Principiante
Referencia de tipos
Tipo M
Descripción
Ejemplo de valor
type number
Número (entero o decimal, 64-bit IEEE 754)
42, 3.14
type text
Cadena de texto Unicode
"hola"
type logical
Booleano
true, false
type date
Fecha sin hora
#date(2024,1,15)
type time
Hora sin fecha
#time(14,30,0)
type datetime
Fecha y hora sin zona horaria
#datetime(2024,1,15,14,30,0)
type datetimezone
Fecha y hora con zona horaria
#datetimezone(2024,1,15,14,30,0,1,0)
type duration
Duración de tiempo
#duration(1,2,30,0)
type binary
Datos binarios
#binary({0x48,0x65})
type null
Ausencia de valor
null
type any
Cualquier tipo
(cualquier valor)
type list
Lista de valores
{1, 2, 3}
type record
Record de campos
[A=1, B=2]
type table
Tabla
#table(...)
type function
Función
(x) => x + 1
type type
Un tipo en sí mismo
type number
🏷️
Tipos Nullable
nullable — Tipos que aceptan null
Intermedio
Sintaxis
nullable type // p.ej. nullable text, nullable number
type nullable text // equivalente
¿Qué hace?
Un tipo nullable indica que el valor puede ser null además del tipo base. La mayoría de las funciones del lenguaje M aceptan nullable en sus parámetros, lo cual es parte del motivo por el que propagan null automáticamente.
Ejemplo
// Función con parámetro nullable
let
saludar = (nombre as nullable text) as text =>
if nombre = null then "Hola, desconocida"
else "Hola, " & nombre
in [
a = saludar("Sara"), // "Hola, Sara"
b = saludar(null) // "Hola, desconocida"
]
// Anotación de columna nullable en tipo tabla
type table [Nombre = nullable text, Edad = nullable number]
💡 Tip kawaii: En la práctica, la distinción text vs nullable text rara vez importa en Power Query interactivo. Donde sí importa es en funciones personalizadas para connectors y en APIs de M avanzadas.
🔬
Funciones Type.*
Type.Is / Type.IsNullable
Avanzado
Sintaxis
Type.Is(type1 as type, type2 as type) as logical
Type.IsNullable(type as type) as logical
Type.NonNullable(type as type) as type
Type.Union(types as list) as type
¿Qué hace?
Funciones de introspección y manipulación de tipos. Type.Is comprueba la compatibilidad de tipos. Type.IsNullable comprueba si un tipo admite null. Type.NonNullable elimina el nullable.
Ejemplo
Type.Is(type number, type any) // true (number es subtype de any)
Type.Is(type nullable text, type text) // false (nullable no es subtype de no-nullable)
Type.IsNullable(type nullable text) // true
Type.IsNullable(type text) // false
Type.NonNullable(type nullable number) // type number
// Crear unión de tipos
Type.Union({type text, type number}) // type (text | number)
Type.RecordFields / Type.TableRow
Avanzado
Sintaxis
Type.RecordFields(type as type) as record
Type.TableRow(type as type) as type
Type.ListItem(type as type) as type
Type.FunctionParameters(type as type) as record
Type.FunctionReturn(type as type) as type
¿Qué hace?
Introspección de tipos estructurados. Permite extraer información sobre los campos de un record type, las columnas de un table type, etc.
Ejemplo
let tipoTabla = type table [Nombre = text, Edad = number]
in Type.TableRow(tipoTabla)
// type record [Nombre = text, Edad = number]
// Obtener tipo de la función Text.Upper
let tipoFn = Value.Type(Text.Upper)
in Type.FunctionReturn(tipoFn) // type nullable text
🏷️
Anotaciones de Tipo en Funciones
Anotaciones de tipo en funciones personalizadas
Intermedio
¿Qué hace?
Puedes anotar los parámetros y el tipo de retorno de funciones personalizadas. Esto activa la validación de tipos y mejora el autocompletado en Power Query Editor.
Ejemplo
// Sin anotaciones (any implícito)
let suma = (a, b) => a + b
// Con anotaciones de tipo
let sumaAnotada = (a as number, b as number) as number => a + b
// Con tipos nullable (acepta null)
let formatearPrecio = (precio as nullable number) as text =>
if precio = null then "N/D"
else Number.ToText(precio, "N2", "es-ES") & " €"
// Con tipo tabla tipado (útil para funciones que devuelven tablas)
let crearPersona = (nombre as text, edad as number) as record =>
[Nombre = nombre, Edad = edad, FechaCreacion = DateTime.LocalNow()]
📌 Buena práctica: Anota siempre los tipos en funciones personalizadas que compartes con otros. Hace el código autodocumentado y los errores de tipo se detectan antes.
Define el esquema de una tabla como tipo M. Útil para documentar funciones, validar salidas y crear tablas con tipos explícitos. Table.Schema devuelve el esquema actual de una tabla como tabla de metadatos.
Ejemplo
// Definir tipo tabla
let TipoVentas = type table [
Fecha = nullable date,
Producto = nullable text,
Cantidad = nullable number,
Importe = nullable number
]
// Obtener esquema de una tabla existente
Table.Schema(tabla)
// Devuelve tabla con columnas: Name, Position, TypeName, Kind, IsNullable...
// Forzar esquema al cargar datos
Table.TransformColumnTypes(tabla, {
{"Fecha", type date},
{"Importe", type number},
{"Producto", type text}
})
🔄
Conversión Explícita de Tipos
Patrones de conversión de tipos
Intermedio
Funciones de conversión por tipo destino
Destino
Función principal
Alternativa
number
Number.From(valor)
Number.FromText(texto)
text
Text.From(valor)
Number.ToText(n, formato)
logical
Logical.From(valor)
Logical.FromText(texto)
date
Date.From(valor)
Date.FromText(texto)
datetime
DateTime.From(valor)
DateTime.FromText(texto)
datetimezone
DateTimeZone.From(valor)
DateTimeZone.FromText(texto)
duration
Duration.From(valor)
Duration.FromText(texto)
Ejemplo — Conversión robusta con try/otherwise
// Convertir texto a número de forma segura
let convertirNumero = (texto as text) as nullable number =>
try Number.FromText(texto, "es-ES")
otherwise try Number.FromText(texto, "en-US")
otherwise null
// Convertir texto a fecha con varios formatos
let convertirFecha = (texto as text) as nullable date =>
try Date.FromText(texto, [Format="dd/MM/yyyy"])
otherwise try Date.FromText(texto, [Format="yyyy-MM-dd"])
otherwise null
💡 Tip kawaii: La conversión en cadena con try ... otherwise try ... otherwise null es el patrón más robusto para procesar datos de calidad variable con múltiples formatos posibles.
🚀 ¡Sistema de tipos dominado! Ahora explora los Conectores de Datos para conectar Power Query a tus fuentes de datos.