Main Content

Dar formato a texto

Para convertir datos a texto y controlar su formato, puede utilizar los operadores de formato con funciones de conversión habituales, como num2str y sprintf. Estos operadores controlan la notación, la alineación, los dígitos significativos, etc. Son similares a los que utiliza la función printf en el lenguaje de programación C. Entre los usos habituales del texto con formato se encuentran el texto para mostrar y los archivos de salida.

Por ejemplo, %f convierte valores de punto flotante a texto mediante notación de punto fijo. Ajuste el formato agregando información al operador, como %.2f para representar dos dígitos tras la marca decimal o %12f para representar 12 caracteres en la salida, rellenando con espacios donde sea necesario.

A = pi*ones(1,3);
txt = sprintf('%f | %.2f | %12f', A)
txt = 
'3.141593 | 3.14 |     3.141593'

Puede combinar operadores con texto ordinario y caracteres especiales en un especificador de formato. Por ejemplo, \n inserta un carácter de línea nueva.

txt = sprintf('Displaying pi: \n %f \n %.2f \n %12f', A)
txt = 
    'Displaying pi: 
      3.141593 
      3.14 
          3.141593'

Las funciones compatibles con los operadores de formato son compose, num2str, sprintf, fprintf y las funciones de gestión de errores assert, error, warning y MException.

Campos del operador de formato

Un operador de formato puede tener seis campos, como se muestra en la figura. De derecha a izquierda, los campos son: carácter de conversión, subtipo, precisión, anchura de campo, indicadores e identificador numérico. (No se permiten caracteres de espacio en el operador. Solo se muestran aquí para mejorar la legibilidad de la figura). El carácter de conversión es el único campo obligatorio, junto con el carácter % antepuesto.

Schematic of formatting operator characters.

Carácter de conversión

El carácter de conversión especifica la notación de la salida. Se compone de un único carácter y aparece el último en el especificador de formato.

Especificador

Descripción

c

Carácter único.

d

Notación decimal (con signo).

e

Notación exponencial (con una e minúscula, como en 3.1415e+00).

E

Notación exponencial (con una E mayúscula, como en 3.1415E+00).

f

Notación de punto fijo.

g

%e o %f, lo que sea más compacto. (Los ceros insignificantes no se imprimen).

G

Igual que %g, pero con una E mayúscula.

o

Notación octal (sin signo).

s

Vector de caracteres o arreglo de cadena.

u

Notación decimal (sin signo).

x

Notación hexadecimal (sin signo, con letras a a f minúsculas).

X

Notación hexadecimal (sin signo, con letras A a F mayúsculas).

Por ejemplo, dé formato al número 46 utilizando diferentes caracteres de conversión para mostrar el número en formato decimal, de punto fijo, exponencial y hexadecimal.

A = 46*ones(1,4);
txt = sprintf('%d   %f   %e   %X', A)
txt = 
'46   46.000000   4.600000e+01   2E'

Subtipo

El campo subtipo es un único carácter alfabético que precede inmediatamente al carácter de conversión. Sin el campo subtipo, los caracteres de conversión %o, %x, %X y %u tratan los datos de entrada como enteros. Para tratar los datos de entrada como valores de punto fijo en su lugar y convertirlos a representaciones octales, decimales o hexadecimales, utilice uno de los siguientes especificadores de subtipo.

b

Los datos de entrada son valores de punto flotante de doble precisión en lugar de enteros sin signo. Por ejemplo, para imprimir un valor de doble precisión en hexadecimal, utilice un formato como %bx.

t

Los datos de entrada son valores de punto flotante de precisión simple en lugar de enteros sin signo.

Precisión

El campo precisión en un operador de formato es un entero no negativo que sigue inmediatamente a un punto. Por ejemplo, en el operador %7.3f, la precisión es 3. En el operador %g, la precisión indica el número de dígitos significativos que se van a mostrar. En los operadores %f, %e y %E, la precisión indica cuántos dígitos mostrar a la derecha del separador decimal.

Muestre números con diferentes precisiones mediante el campo precisión.

txt = sprintf('%g   %.2g   %f   %.2f', pi*50*ones(1,4))
txt =

    '157.08   1.6e+02   157.079633   157.08'

Aunque puede especificar la precisión en un operador de formato para el texto de entrada (por ejemplo, en el operador %s), no suele haber ninguna razón para hacerlo. Si especifica la precisión como p y p es inferior al número de caracteres del texto de entrada, la salida contendrá solo los primeros p caracteres.

Anchura de campo

La anchura de campo en un operador de formato es un entero no negativo que especifica el número de dígitos o caracteres en la salida cuando se da formato a valores de entrada. Por ejemplo, en el operador %7.3f, la anchura de campo es 7.

Especifique diferentes anchuras de campo. Para mostrar la anchura de cada salida, utilice el carácter |. De forma predeterminada, el texto de salida se rellena con caracteres de espacio cuando la anchura de campo es mayor que el número de caracteres.

txt = sprintf('|%e|%15e|%f|%15f|', pi*50*ones(1,4))
txt =

    '|1.570796e+02|   1.570796e+02|157.079633|     157.079633|'

Cuando se utiliza en entrada de texto, la anchura de campo puede determinar si se rellena el texto de salida con espacios. Si la anchura de campo es inferior o igual al número de caracteres del texto de entrada, no tendrá ningún efecto.

txt = sprintf('%30s', 'Pad left with spaces')
txt =

    '          Pad left with spaces'

Indicadores

Los indicadores opcionales controlan formato adicional del texto de salida. La tabla describe los caracteres que se pueden utilizar como indicadores.

Carácter

Descripción

Ejemplo

Signo menos (-)

Justifica a la izquierda el argumento convertido en su campo.

%-5.2d

Signo más (+)

En valores numéricos, imprime siempre un carácter signo (+ o -) antepuesto.
En valores textuales, justifica a la derecha el argumento convertido en su campo.

%+5.2d
%+5s

Espacio

Inserta un espacio antes del valor.

% 5.2f

Cero (0)

Rellena con ceros en lugar de espacios.

%05.2f

Almohadilla (#)

Modifica las conversiones numéricas seleccionadas:

  • En el caso de %o, %x o %X, imprime el prefijo 0, 0x o 0X.

  • En el caso de %f, %e o %E, imprime el separador decimal incluso si la precisión es 0.

  • En el caso de %g o %G, no elimina los ceros finales ni el separador decimal.

%#5.0f

Justifique a la derecha y a la izquierda la salida. El comportamiento predeterminado es justificar a la derecha el texto de salida.

txt = sprintf('right-justify: %12.2f\nleft-justify: %-12.2f',...
              12.3, 12.3)
txt =

    'right-justify:        12.30
     left-justify: 12.30       '

Muestre un signo + para los números positivos. El comportamiento predeterminado es omitir el signo + antepuesto en los números positivos.

txt = sprintf('no sign: %12.2f\nsign: %+12.2f',...
              12.3, 12.3)
txt =

    'no sign:        12.30
     sign:       +12.30'

Rellene a la izquierda con espacios y ceros. El comportamiento predeterminado es rellenar con espacios.

txt = sprintf('Pad with spaces: %12.2f\nPad with zeroes: %012.2f',...
              5.2, 5.2)
txt =

    'Pad with spaces:         5.20
     Pad with zeroes: 000000005.20'

Nota

Puede especificar más de un indicador en un operador de formato.

Identificadores de valor

De forma predeterminada, funciones como sprintf insertan valores de los argumentos de entrada en el texto de salida en orden secuencial. Para procesar los argumentos de entrada en un orden no secuencial, especifique el orden con identificadores numéricos en el especificador de formato. Especifique argumentos no secuenciales con un entero inmediatamente después del signo %, seguido del símbolo $.

Ordenados secuencialmenteOrdenados por identificador
sprintf('%s %s %s',...
        '1st','2nd','3rd')

ans =

    '1st 2nd 3rd'
sprintf('%3$s %2$s %1$s',...
        '1st','2nd','3rd')

ans =

    '3rd 2nd 1st'

Caracteres especiales

Los caracteres especiales pueden formar parte del texto de salida. Pero, dado que no pueden introducirse como texto ordinario, requieren secuencias de caracteres específicas para representarlos. Para insertar caracteres en texto de salida, utilice cualquier secuencia de caracteres de la tabla.

Carácter especial

Representación en especificador de formato

Comilla simple

''

Carácter de porcentaje

%%

Barra invertida

\\

Alarma

\a

Retroceso

\b

Salto de impresión

\f

Nueva línea

\n

Retorno de carro

\r

Tabulación horizontal

\t

Tabulación vertical

\v

Carácter cuyo valor numérico Unicode® se puede representar mediante el número hexadecimal, N

\xN

Ejemplo: sprintf('\x5A') devuelve 'Z'

Carácter cuyo valor numérico Unicode se puede representar mediante el número octal, N

\N

Ejemplo: sprintf('\132') devuelve 'Z'

Establecer la anchura de campo y la precisión

El operador de formato sigue un conjunto de reglas para dar formato al texto de salida con la anchura de campo y la precisión especificadas. También puede especificar los valores para la anchura de campo y la precisión fuera del especificador de formato y utilizar identificadores numerados con la anchura de campo y la precisión.

Reglas para dar formato a la precisión y a la anchura de campo

La figura ilustra cómo afecta la configuración de la anchura de campo y la precisión a la salida de las funciones de formato. En esta figura, el cero que sigue al símbolo % en el operador de formato significa agregar ceros antepuestos al texto de salida en lugar de caracteres de espacio.

Flowchart relating input value, Format operator, and output text.

  • Si no se especifica la precisión, se establece en seis de forma predeterminada.

  • Si la precisión p es inferior al número de dígitos en la parte fraccionaria de la entrada, solo se muestran p dígitos tras el separador decimal. El valor fraccionario se redondea en la salida.

  • Si la precisión p es mayor que el número de dígitos f en la parte fraccionaria de la entrada, se mostrarán p dígitos tras el separador decimal. La parte fraccionaria se extiende hacia la derecha con p-f ceros en la salida.

  • Si no se especifica la anchura de campo, se establece de manera predeterminada en p+1+n, donde n es el número de dígitos en toda la parte del valor de entrada.

  • Si la anchura de campo w es mayor que p+1+n, toda la parte del valor de salida se rellena hacia la izquierda con w-(p+1+n) caracteres adicionales. Los caracteres adicionales son caracteres de espacio, a no ser que el operador de formato incluya el indicador 0. En ese caso, los caracteres adicionales son ceros.

Especificar la anchura de campo y la precisión fuera del especificador de formato

Puede especificar la anchura de campo y la precisión con valores de una lista secuencial de argumentos. Utilice un asterisco (*) en lugar de los campos anchura de campo o precisión del operador de formato.

Por ejemplo, dé formato y muestre tres números. En cada caso, utilice un asterisco para especificar que la anchura de campo o la precisión proceden de argumentos de entrada que siguen al especificador de formato.

txt = sprintf('%*f   %.*f   %*.*f',...
              15,123.45678,...     
              3,16.42837,...       
              6,4,pi)
txt =

    '     123.456780   16.428   3.1416'

En la tabla se describen los efectos de cada operador de formato en el ejemplo.

Operador de formato

Descripción

%*f

Especifica la anchura como el siguiente argumento de entrada, 15.

%.*f

Especifica la precisión como el siguiente argumento de entrada, 3.

%*.*f

Especifica la anchura y la precisión como los siguientes argumentos de entrada, 6 y 4.

Puede mezclar ambos estilos. Por ejemplo, obtenga la anchura de campo del siguiente argumento de entrada y la precisión del especificador de formato.

txt = sprintf('%*.2f', 5, 123.45678)
txt =

    '123.46'

Especificar identificadores numerados en los campos anchura y precisión

También puede especificar la anchura de campo y la precisión como valores de una lista no secuencial de argumentos, utilizando la sintaxis alternativa que se muestra en la figura. Dentro del operador de formato, especifique la anchura de campo y la precisión con asteriscos que siguen a identificadores numerados y símbolos $. Especifique los valores de la anchura de campo y de la precisión con argumentos de entrada que siguen al especificador de formato.

Schematic of formatting operator characters.

Por ejemplo, dé formato y muestre tres números. En cada caso, utilice un identificador numerado para especificar que la anchura de campo o la precisión proceden de argumentos de entrada que siguen al especificador de formato.

txt = sprintf('%1$*4$f   %2$.*5$f   %3$*6$.*7$f',...
              123.45678, 16.42837, pi, 15, 3, 6, 4)
txt =

    '     123.456780   16.428   3.1416'

En la tabla se describe el efecto de cada operador de formato en el ejemplo.

Operador de formato

Descripción

%1$*4$f

1$ especifica el primer argumento de entrada, 123.45678, como el valor

*4$ especifica el cuarto argumento de entrada, 15, como la anchura de campo

%2$.*5$f

2$ especifica el segundo argumento de entrada, 16.42837 como el valor

.*5$ especifica el quinto argumento de entrada, 3, como la precisión

%3$*6$.*7$f

3$ especifica el tercer argumento de entrada, pi, como el valor

*6$ especifica el sexto argumento de entrada, 6, como la anchura de campo

.*7$ especifica el séptimo argumento de entrada, 4, como la precisión

Restricciones de uso de los identificadores

Si cualquiera de los operadores de formato incluye un campo identificador, todos los operadores del especificador de formato deberán incluir campos identificador. Si utiliza tanto el orden secuencial como el no secuencial en la misma llamada a una función, la salida se trunca en el primer cambio entre los identificadores secuenciales y los no secuenciales.

Sintaxis válidaSintaxis no válida
sprintf('%d %d %d %d',...
        1,2,3,4)

ans =

    '1 2 3 4'
sprintf('%d %3$d %d %d',...
        1,2,3,4)

ans =

    '1 '

Si la llamada a una función proporciona más argumentos de entrada que operadores de formato en el especificador de formato, los operadores se reutilizan. Sin embargo, solo las llamadas a una función que utilicen el orden secuencial reutilizan los operadores de formato. No puede reutilizar operadores de formato cuando utilice identificadores numerados.

Sintaxis válidaSintaxis no válida
sprintf('%d',1,2,3,4)

ans =

    '1234'
sprintf('%1$d',1,2,3,4)

ans =

    '1'

Si utiliza identificadores numerados cuando los datos de entrada son un vector o un arreglo, la salida no contendrá datos con formato.

Sintaxis válidaSintaxis no válida
v = [1.4 2.7 3.1];
sprintf('%.4f %.4f %.4f',v)

ans =

    '1.4000 2.7000 3.1000'
v = [1.4 2.7 3.1];
sprintf('%3$.4f %1$.4f %2$.4f',v)

ans =

  1×0 empty char array

Consulte también

| | |

Temas relacionados

Sitios web externos