Funciones de conversión

A continuación se enumeran las funciones de conversión disponibles.


Función	Descripción
`Base64Decode(Arg1)`	Descodifica una cadena base64 en un objeto binario grande para que se pueda ver como una imagen en Spotfire. Ejemplo: `Base64Decode([Column])`
`Base64Encode(Arg1)`	Codifica un objeto binario grande como una cadena base64. Esto puede resultar útil si pretende exportar datos de Spotfire a otras aplicaciones. Ejemplo: `Base64Encode([Column])`
`Boolean(Arg1)`	Convierte la columna o el valor en un elemento booleano (`Boolean`). Ejemplo: `Boolean([Column])`
`Cast(Arg1 as type)`	Convierte cualquier expresión en cualquier tipo (salvo Null/Undefined). Se propagan los valores que no son válidos. La conversión de distintos tipos de entrada y salida proporciona resultados diferentes. Consulte Método de conversión para obtener más información. Ejemplo: `Cast([IntegerColumn] as Currency)`
`Currency(Arg1)`	Convierte la columna o el valor en una moneda (`Currency`). Ejemplo: `Currency([Column])`
`Date(Arg1, ..., Arg3)`	Convierte la columna o los valores en una fecha (`Date`). Si se usa un solo argumento, `Arg1` puede ser del tipo `String` o `DateTime`. Si se especifica `String`, la fecha debe escribirse en un formato que Spotfire pueda reconocer. Además, deben aparecer todas las partes de la fecha (año, mes y día). Consulte los siguientes ejemplos. Si se especifica `DateTime`, se eliminará esta última parte. Si se facilitan tres argumentos, deben ser valores `Integer`. El primero es el año, el segundo es el mes y el tercero es el día de dicho mes. Si solo se facilita un argumento `Integer`, la función `Date` interpretará `Integer` como marcas. Las marcas se cuentan con la unidad de 100 nanosegundos, empezando con la fecha 01-01-01 (uno de enero del año uno). Consulte también Funciones de fecha y hora y Método de conversión. Ejemplos: `Date("2003-03-21")` → 3/21/2003 `Date("3/21/03")` → 3/21/2003 `Date("10")` → (Empty) `Date(null)` → (Empty) `Date("2003-03-21 11:37:00")` → 3/21/2003 `Date(2003,03, 21)` → 3/21/2003 `Date(605000000000000000l)` → 3/4/1918 (Los formatos de salida disponibles dependen de la configuración regional actual).
`DateTime(Arg1, Arg2,..., Arg7)`	Convierte la columna o el valor a `DateTime`. Si solo se usa un argumento, `Arg1` puede ser del tipo `String` o `Date`. Si se especifica `String`, la fecha debe escribirse en un formato que Spotfire pueda reconocer. Además, deben aparecer como mínimo todas las partes de la fecha (año, mes y día). Si se especifica una fecha (`Date`), la parte de la hora se establece como 00:00:00 (por ejemplo, 12:00:00 a. m.). Si se facilitan siete argumentos, deben ser valores enteros (`Integer`). El primero es el año; el segundo, el mes; el tercero, el día del mes; el cuarto, la hora; el quinto, los minutos; el sexto, los segundos; y el séptimo, las milésimas de segundo. Si solo se facilita un argumento entero (`Integer`), la función `DateTime` interpretará el entero como marcas. Las marcas se cuentan con la unidad de 100 nanosegundos, empezando con la fecha 01-01-01 (uno de enero del año uno). Consulte también Funciones de fecha y hora y Método de conversión. Ejemplos: `DateTime("2003-03-21 11:37:00")` → 3/21/2003 11:37:00 AM `DateTime("10")` → (Empty) `DateTime(null)` → (Empty) `DateTime("2003-03-21")` → 2003-03-21 00:00:00 `DateTime(2003, 03, 21, 11, 37, 00)` → 2003-03-21 11:37:00 `DateTime(605000000000000000l)` → 3/4/1918 11:33:20 AM (Los formatos de salida disponibles dependen de la configuración regional actual).
`FirstValidAfter(Arg1)`	Sustituye los valores nulos de una columna por el primer valor válido después del valor que falta. Ejemplo: `FirstValidAfter([Column])`
`FromEpochMilliseconds(Arg1)`	Convierte la columna o el valor en una fecha y hora, donde los números se interpretan como el número de milisegundos que han transcurrido desde el 01-01-1970. Ejemplo: `FromEpochMilliseconds(231312)`
`FromEpochSeconds(Arg1)`	Convierte la columna o el valor en una fecha y hora, donde los números se interpretan como el número de segundos que han transcurrido desde el 01-01-1970. Ejemplo: `FromEpochSeconds(231312)`
`Integer(Arg1)`	Convierte la columna o el valor en un número entero (`Integer`). Si no se puede completar la conversión, aparecerá un mensaje de error. `Arg1` puede ser de tipo entero (`Integer`), real (`Real`) o cadena (`String`), y el resultado será de tipo `Integer`. Los número de tipo `Real` se truncan, es decir, solo se usa la parte del número entero. Ejemplos: `Integer("-123")` → -123 `Integer(-2.99)` → -2 `Integer("0%")` → (Empty) `Integer(1e20)` → (Empty) `Integer(null)` → (Empty)
`LastValidBefore(Arg1)`	Sustituye los valores nulos de una columna por el último valor válido antes del valor que falta. Ejemplo: `LastValidBefore([Column])`
`LongInteger(Arg1)`	Convierte la columna o el valor en un número entero largo (`LongInteger`). Ejemplo: `LongInteger([Column])`
`ParseDate(Arg1, ..., Arg3)`	Analiza una fecha a partir de una cadena de formato de fecha (`Date`). El primer argumento es una cadena o una columna de cadena que contiene una fecha. El segundo argumento es una cadena de formato que explica la estructura de la fecha y el tercero (opcional) es un código de cultura. Ejemplos: `ParseDate("2013-09-17", "yyyy-MM-dd")` `ParseDate("17-okt-2013","dd-MMM-yyyy","sv-SE")`
`ParseDateTime(Arg1, ..., Arg3)`	Analiza la información de fecha/hora a partir de una cadena de formato de fecha y hora (`DateTime`). El primer argumento es una cadena o una columna de cadena que contiene información de fecha y hora. El segundo argumento es una cadena de formato que explica la estructura de dicha información y el tercero (opcional) es un código de cultura. Ejemplos: `ParseDateTime("2013-09-17 10:30", "yyyy-MM-dd h:mm")` `ParseDateTime("17-okt-2013 13:25","dd-MMM-yyyy HH:mm","sv-SE")`
`ParseReal(Arg1, Arg2)`	Analiza una cadena como un valor `Real`. El primer argumento es una cadena o una columna de cadenas. El segundo argumento (opcional) es un código de cultura. Ejemplos: `ParseReal([Column], "en-US")` `ParseReal("7,25")`
`ParseTime(Arg1, ..., Arg3)`	Analiza una hora a partir de una cadena a un formato de hora (`Time`). El primer argumento es una cadena o una columna de cadena que contiene una hora. El segundo argumento es una cadena de formato que explica la estructura de dicha hora y el tercero (opcional) es un código de cultura. Ejemplos: `ParseTime("9:25", "h:mm")` `ParseTime("17:30", "HH:mm","sv-SE")`
`ParseTimeSpan(Arg1, ..., Arg3)`	Analiza la información de intervalo de tiempo a partir de una cadena con formato `TimeSpan`. El primer argumento es una cadena o una columna de cadena que contiene información de intervalo de tiempo. El segundo argumento es una cadena de formato que explica la estructura de dicha información y el tercero (opcional) es un código de cultura. Ejemplos: `ParseTimeSpan("5,7:11:3,1", "d.h:m:s.f", "sv-SE")` `ParseTimeSpan("123 3 11 7 -5", "f s m h d")`
`Real(Arg1)`	Convierte la columna o el valor en un número `Real`. Si no se puede completar la conversión, aparecerá un mensaje de error. `Arg1` puede ser de tipo entero (`Integer`), real (`Real`) o cadena (`String`), y el resultado será de tipo `Real`. Ejemplos: `Real(1.23)` → 1.23 `Real(2)` → 2 `Real("0%")` → (Empty) `Real(null)` → (Empty)
`SingleReal(Arg1)`	Convierte la columna o el valor en un elemento real sencillo (`SingleReal`). Ejemplo: `SingleReal([Column])`
`SN(Arg1, Arg2)`	Sustituye los valores nulos. Devuelve `Arg1` si no es un nulo; de lo contrario, se obtiene `Arg2`. `Arg1` y `Arg2` pueden ser de cualquier tipo, pero deben coincidir en esto o ser nulos. El resultado es del mismo tipo que el de los argumentos. Lo habitual es sustituir los valores nulos en una columna. Si `Arg1` es una columna, `Arg2` puede ser un valor del mismo tipo que el contenido de la columna o una columna con el mismo tipo de contenido. Si `Arg2` también es una columna, el error que produce `Arg1` se sustituirá por el valor de la misma fila que aparece en `Arg2`. Ejemplos: `SN(1, 2)` → 1 `SN(null, 2)` → 2 `SN(0/0, 2)` → #NA `SN([Column], 1)` → 1 (if null value in column) `SN([Column1], [Column2])` → (value from `Column2` if null value in `Column1`)
`String(Arg1)`	Convierte la columna o el valor en una cadena (`String`). `Arg1` puede ser de cualquier tipo y el resultado será del tipo de la cadena. Nota: Esta función siempre utiliza el formato de valor predeterminado. Esto podría provocar pérdida de precisión al convertir valores numéricos. Ejemplos: `String(1.23)` → "1.23" `String(null)` → (Empty)
`Time(Arg1, Arg2,..., Arg4)`	Convierte la columna o el valor en una hora (`Time`). Si no se puede completar la conversión, aparecerá un mensaje de error. Si se usa un solo argumento, `Arg1` puede ser del tipo `String` o `DateTime`. Si se especifica una cadena (`String`), la hora debe escribirse en un formato que Spotfire pueda reconocer. Además, deben especificarse las horas y los minutos. Consulte los siguientes ejemplos. Si se especifican una fecha y una hora (`DateTime`), se eliminará la parte de la fecha. Si se facilitan cuatro argumentos, deben ser valores enteros (`Integer`). El primero es la hora; el segundo, los minutos; el tercero, los segundos; y el cuarto, las milésimas de segundo. Si solo se facilita un argumento entero (`Integer`), la función `Time` interpretará el entero como marcas. Las marcas se cuentan con la unidad de 100 nanosegundos, empezando con la fecha 01-01-01 (uno de enero del año uno). Consulte también Funciones de fecha y hora y Método de conversión. Ejemplos: `Time("11:37:00")` → 11:37:00 `Time("10")` → (Empty) `Time(null)` → (Empty) `Time(11, 30, 20, 4)` → 11:30:20 `Time(605000000000000000l)` → 11:33:20 AM (Los formatos de salida disponibles dependen de la configuración regional actual).
`TimeSpan(Arg1, Arg2,...,Arg5))`	Crea un intervalo de tiempo (`TimeSpan`) a partir de una columna o de valores. Si se da un único argumento, la columna de entrada puede ser de tipo cadena (`String`) o de intervalo de tiempo (`TimeSpan`). Si se especifica una cadena (`String`), el intervalo de tiempo debe tener el formato "[-]d.h:m:s.ms". Si se dan cinco argumentos, el primero son los días; el segundo, las horas; el tercero, los minutos; el cuarto, los segundos, y el quinto son las milésimas de segundo. Los primeros cuatro argumentos son números enteros (`Integer`), mientras que el último es un número `Real`. Ejemplos: `TimeSpan([Column])` `TimeSpan("247.5:17:11.5002")` `TimeSpan(247, 05, 17, 11, 500.2)`
`ToEpochMilliseconds([Arg1])`	Convierte la columna o el valor de una fecha y hora a un número que representa los milisegundos que han transcurrido desde el 01-01-1970. Ejemplo: `ToEpochMilliseconds([Date])`
`ToEpochSeconds([Arg1])`	Convierte la columna o el valor de una fecha y hora a un número que representa los segundos que han transcurrido desde el 01-01-1970. Ejemplo: `ToEpochSeconds([Date])`

Para obtener una lista de los tipos de datos disponibles para su conversión, consulte Tipos de datos.

Consulte también Funciones.