La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

struct2table

Convertir un arreglo de estructuras a una tabla

contraer todo en la página

Sintaxis

T = struct2table(S)
T = struct2table(S,Name,Value)

Descripción

T = struct2table(S) convierte un arreglo de estructuras a una tabla. Cada campo de la estructura de entrada se convierte en una variable en la tabla de salida.

  • Si la entrada es una estructura escalar con n campos, los cuales tienen todos m filas, la salida es una tabla de m por n.

  • Si la entrada es un arreglo de estructuras de m por 1 o de 1 por m con n campos, la salida es una tabla de m por n.

ejemplo

T = struct2table(S,Name,Value) crea una tabla a partir de un arreglo de estructuras, con opciones adicionales especificadas por uno o más argumentos Name,Value.

Por ejemplo, puede especificar nombres de filas para incluirlos en la tabla.

ejemplo

Ejemplos

contraer todo

Abrir script en vivo

Convierta una estructura escalar a una tabla utilizando las opciones predeterminadas.

Cree un arreglo de estructuras, S. 

S.Name = ["Chang";"Brown";"Ruiz"];
S.Smoker = ["Y";"N";"Y"];
S.SystolicBP = [124;122;130];
S.DiastolicBP = [93;80;92];

La estructura escalar, S, tiene cuatro campos, cada uno con tres filas.

Convierta el arreglo de estructuras en una tabla. 

T = struct2table(S)
T=3×4 table
     Name      Smoker    SystolicBP    DiastolicBP
    _______    ______    __________    ___________

    "Chang"     "Y"         124            93     
    "Brown"     "N"         122            80     
    "Ruiz"      "Y"         130            92

Los nombres de los campos de estructura de S se convierten en los nombres de las variables en la tabla de salida. El tamaño de T es de 3 por 4.

Cambie Name de una variable a nombres de fila modificando la propiedad de la tabla, T.Properties.RowNames, y eliminando la variable Name. 

T.Properties.RowNames = T.Name;
T.Name = [];

T
T=3×3 table
             Smoker    SystolicBP    DiastolicBP
             ______    __________    ___________

    Chang     "Y"         124            93     
    Brown     "N"         122            80     
    Ruiz      "Y"         130            92
Abrir script en vivo

Cree un arreglo de estructuras no escalar, S. 

S(1,1).Name = "Chang";
S(1,1).Smoker = "Y";
S(1,1).SystolicBP = 124;
S(1,1).DiastolicBP = 93;

S(2,1).Name = "Brown";
S(2,1).Smoker = "N";
S(2,1).SystolicBP = 122;
S(2,1).DiastolicBP = 80;

S(3,1).Name = "Ruiz";
S(3,1).Smoker = "Y";
S(3,1).SystolicBP = 130;
S(3,1).DiastolicBP = 92;

S
S=3×1 struct array with fields:
    Name
    Smoker
    SystolicBP
    DiastolicBP

S es un arreglo de estructuras de 3 por 1 con cuatro campos.

Convierta el arreglo de estructuras en una tabla. 

T = struct2table(S)
T=3×4 table
     Name      Smoker    SystolicBP    DiastolicBP
    _______    ______    __________    ___________

    "Chang"     "Y"         124            93     
    "Brown"     "N"         122            80     
    "Ruiz"      "Y"         130            92

Los nombres de los campos de estructura de S se convierten en los nombres de las variables en la tabla de salida. El tamaño de T es de 3 por 4.

Abrir script en vivo

Utilice "AsArray",true para crear una tabla a partir de una estructura escalar cuyos campos tengan diferentes números de filas.

Cree una estructura escalar, S, con los campos name, billing y test. 

S.name = "John Doe";
S.billing = 127.00;
S.test = [79, 75, 73; 180, 178, 177.5; 220, 210, 205]
S = struct with fields:
       name: "John Doe"
    billing: 127
       test: [3×3 double]

Los campos tienen diferentes números de filas. Por lo tanto, no puede utilizar struct2table(S), que utiliza "AsArray",false de forma predeterminada.

Trate la estructura escalar como un arreglo y conviértala en una tabla. 

T = struct2table(S,"AsArray",true)
T=1×3 table
       name       billing        test    
    __________    _______    ____________

    "John Doe"      127      {3×3 double}

T contiene una fila.

Argumentos de entrada

contraer todo

Arreglo de entrada, especificado como una estructura.

Argumentos de par nombre-valor

contraer todo

Especifique pares opcionales de argumentos como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de otros argumentos, pero el orden de los pares no importa.

En las versiones anteriores a R2021a, utilice comas para separar cada nombre y valor, y encierre Name entre comillas.

Ejemplo: "RowNames",["row1","row2","row3"] utiliza los nombres de fila row1, row2 y row3 para la tabla T.

Nombres de fila, especificados como un arreglo de celdas de vectores de caracteres o un arreglo de cadenas cuyos elementos no están vacíos y son distintos. El número de nombres de fila debe ser igual al número de filas del arreglo de entrada.

Los nombres de fila pueden tener cualquier carácter Unicode®, incluidos espacios y caracteres no ASCII, excepto ':'.

Si especifica nombres de fila que tienen espacios en blanco iniciales o finales, struct2table los elimina de los nombres de fila.

Desde R2021a

Nombres de dimensiones, especificados como un arreglo de celdas de dos elementos de vectores de caracteres o un arreglo de cadenas de dos elementos cuyos elementos no están vacíos y son distintos.

Los nombres de las dimensiones pueden tener cualquier carácter Unicode, incluidos espacios y caracteres no ASCII. No obstante, un nombre de dimensión no puede coincidir con ningún nombre de variable de tabla ni con los nombres reservados 'Properties', 'RowNames', 'VariableNames' o ':'.

Como alternativa, en todas las versiones se pueden especificar nombres de dimensiones estableciendo la propiedad DimensionNames de la tabla.

Indicador para tratar la entrada como un arreglo de estructuras, especificado como un 1 (true) o 0 (false) numérico o lógico.

true

Valor predeterminado si la entrada es un arreglo de estructuras no escalar

Convierte un arreglo de estructuras a una tabla con una fila para cada estructura y una variable para cada campo del arreglo de estructuras. Los campos pueden tener diferentes tamaños.

Si los valores del campo S(1:m).fieldname tienen:

  • Tamaños y tipos de datos compatibles, y cada valor tiene una fila, la variable de la tabla correspondiente es un arreglo homogéneo.

    Ejemplo:

    S(1).a = [1 2]
S(2).a = [3 4]
S(1).b = 5
S(2).b = 6
T = struct2table(S)

    T =
  2×2 table
      a       b
    ______    _
    1    2    5
    3    4    6

  • Tamaños diferentes, tipos de datos incompatibles, o cualquier valor tiene más de una fila, la variable de la tabla correspondiente es un arreglo de celdas.

    Ejemplo:

    S(1).a = [1 2]
S(2).a = [3 4 5 6]
S(1).b = 7
S(2).b = 8
T = struct2table(S)

    T =
  2×2 table
         a         b
    ___________    _
    {[    1 2]}    7
    {[3 4 5 6]}    8

false

Valor predeterminado si la entrada es una estructura escalar

Convierta una estructura escalar con n campos a una tabla de m por n. Cada campo debe tener m filas.

Ejemplo:

S.a = [1;2;3]
S.b = [4 5;6 7;8 9]
T = struct2table(S)

T =
  3×2 table
    a      b   
    _    ______
    1    4    5
    2    6    7
    3    8    9

Argumentos de salida

contraer todo

Tabla de salida, devuelta como tabla. La tabla puede almacenar metadatos como descripciones, unidades de variables, nombres de variables y nombres de filas. Para obtener más información, consulte la sección Propiedades de table.

Capacidades ampliadas

expandir todo

Entorno basado en subprocesos
Ejecute código en segundo plano con MATLAB® backgroundPool o acelere código con Parallel Computing Toolbox™ ThreadPool.

Historial de versiones

Introducido en R2013b

Consulte también

| | |

Temas