split

Dividir cadenas usando delimitadores

Sintaxis

newStr = split(str)

newStr = split(str,delimiter)

newStr = split(str,delimiter,dim)

[newStr,match] = split(___)

Descripción

newStr = split(str) divide el texto de entrada str desde los caracteres de espacio en blanco y devuelve el texto separado en el arreglo newStr. La salida newStr no incluye los caracteres de espacio en blanco de str.

newStr = split(str,delimiter) divide el texto de entrada str desde los delimitadores especificados por delimiter. La salida newStr no incluye los delimitadores de str.

newStr = split(str,delimiter,dim) divide el texto de entrada str desde los delimitadores especificados y coloca el texto separado en la dimensión especificada por dim.

[newStr,match] = split(___) también devuelve un arreglo, match, que contiene todas las instancias de delimitadores en las que la función split divide str. Puede utilizar esta sintaxis con cualquiera de los argumentos de entrada de las sintaxis anteriores.

Ejemplos

Dividir cadenas usando espacios en blanco como delimitadores y volver a unirlas

Divida nombres de un arreglo de cadenas usando caracteres de espacio en blanco como delimitadores. Después, reordene las cadenas y únalas de modo que los últimos nombres precedan a los primeros nombres.

Cree un arreglo de cadenas de 3 por 1 que contenga nombres.

names = ["Mary Butler";
         "Santiago Marquez";
         "Diana Lee"]

names = 3×1 string
    "Mary Butler"
    "Santiago Marquez"
    "Diana Lee"

Divida names usando los caracteres de espacio en blanco como delimitadores, convirtiéndolo en un arreglo de cadenas de 3 por 2.

names = split(names)

names = 3×2 string
    "Mary"        "Butler" 
    "Santiago"    "Marquez"
    "Diana"       "Lee"    

Cambie las columnas de names para que los apellidos aparezcan en la primera columna. Añada una coma después de cada apellido.

names = [names(:,2) names(:,1)];
names(:,1) = names(:,1) + ','

names = 3×2 string
    "Butler,"     "Mary"    
    "Marquez,"    "Santiago"
    "Lee,"        "Diana"   

Una los apellidos y los nombres. La función join sitúa un carácter de espacio entre las cadenas que une. Después de la unión, names es un arreglo de cadenas de 3 por 1.

names = join(names)

names = 3×1 string
    "Butler, Mary"
    "Marquez, Santiago"
    "Lee, Diana"

Dividir cadenas usando delimitadores y unirlas con un nuevo delimitador

Cree una cadena que contenga la ruta a una carpeta.

myPath = "/Users/jdoe/My Documents/Examples"

myPath = 
"/Users/jdoe/My Documents/Examples"

Divida la ruta usando el carácter / como delimitador. split devuelve myFolders como un arreglo de cadenas de 5 por 1. La primera cadena es "" porque myPath empieza con el carácter /.

myFolders = split(myPath,"/")

myFolders = 5×1 string
    ""
    "Users"
    "jdoe"
    "My Documents"
    "Examples"

Una myFolders en una ruta nueva con \ como el delimitador. Añada C: como el inicio de la ruta.

myNewPath = join(myFolders,"\");
myNewPath = 'C:' + myNewPath

myNewPath = 
"C:\Users\jdoe\My Documents\Examples"

Dividir cadenas usando un patrón como delimitador

Desde la versión R2020b

Obtenga los números de una cadena tratando el texto como un delimitador. Utilice un patrón para que coincida con el texto. Después, añada los números.

En primer lugar, cree una cadena que tenga números.

str = "10 apples 3 bananas and 5 oranges"

str = 
"10 apples 3 bananas and 5 oranges"

Después, cree un patrón que coincida con un carácter de espacio o letras.

pat = " " | lettersPattern

pat = pattern
  Matching:

    " " | lettersPattern

Divida la cadena usando pat como el delimitador. Las cadenas vacías representan divisiones entre espacios y secuencias de letras que no tienen nada más entre ellas. Por ejemplo, en "10 apples", hay una división antes del delimitador " " y entre " " y "apples". Dado que no hay nada entre los delimitadores " " y "apples", la función split devuelve una cadena vacía para indicar que no hay nada entre ellos.

N = split(str,pat)

N = 11×1 string
    "10"
    ""
    ""
    "3"
    ""
    ""
    ""
    ""
    "5"
    ""
    ""

Descarte las cadenas vacías y mantenga las subcadenas que representan números.

N = N(strlength(N) > 0)

N = 3×1 string
    "10"
    "3"
    "5"

Por último, convierta N a un arreglo numérico y súmelo.

N = str2double(N);
sum(N)

ans = 
18

Para ver una lista de las funciones que crean objetos de patrones, consulte pattern.

Dividir cadenas usando varios delimitadores

Cree una cadena.

str = "A horse! A horse! My kingdom for a horse!"

str = 
"A horse! A horse! My kingdom for a horse!"

Divida str usando signos de exclamación y caracteres de espacio en blanco como delimitadores. newStr es un arreglo de cadenas de 10 por 1. La última cadena es una cadena vacía, "", porque el último carácter de str es un delimitador.

newStr = split(str,[" " "!"])

newStr = 12×1 string
    "A"
    "horse"
    ""
    "A"
    "horse"
    ""
    "My"
    "kingdom"
    "for"
    "a"
    "horse"
    ""

Dividir arreglos de cadenas con datos faltantes entre delimitadores

Cree un arreglo de cadenas en el que cada elemento contenga datos delimitados por comas sobre un paciente.

patients = ["LastName,Age,Gender,Height,Weight";
            "Adams,47,F,64,123";
            "Jones,,,68,175";
            "King,,M,66,180";
            "Smith,38,F,63,118"]

patients = 5×1 string
    "LastName,Age,Gender,Height,Weight"
    "Adams,47,F,64,123"
    "Jones,,,68,175"
    "King,,M,66,180"
    "Smith,38,F,63,118"

Divida el arreglo de cadenas. Un par de comas sin nada entre ellas indica datos faltantes. Cuando split divide usando delimitadores repetidos, devuelve cadenas vacías como elementos correspondientes del arreglo de salida.

patients = split(patients,",")

patients = 5×5 string
    "LastName"    "Age"    "Gender"    "Height"    "Weight"
    "Adams"       "47"     "F"         "64"        "123"   
    "Jones"       ""       ""          "68"        "175"   
    "King"        ""       "M"         "66"        "180"   
    "Smith"       "38"     "F"         "63"        "118"   

Orientar cadenas en una dimensión especificada

Cree un arreglo de cadenas de 3 por 1 que contenga nombres.

names = ["Mary Butler";
         "Santiago Marquez";
         "Diana Lee"]

names = 3×1 string
    "Mary Butler"
    "Santiago Marquez"
    "Diana Lee"

Divida el arreglo en caracteres de espacio en blanco. De forma predeterminada, split orienta las subcadenas en la primera dimensión final con un tamaño de 1. Dado que names es un arreglo de cadenas de 3 por 1, split orienta las subcadenas en la segunda dimensión de splitNames, es decir, las columnas.

splitNames = split(names)

splitNames = 3×2 string
    "Mary"        "Butler" 
    "Santiago"    "Marquez"
    "Diana"       "Lee"    

Para orientar las subcadenas a lo largo de las filas o la primera dimensión, especifique la dimensión después de especificar el delimitador. splitNames es ahora un arreglo de cadenas de 2 por 3, con los primeros nombres en la primera fila y los últimos nombres en la segunda fila.

splitNames = split(names," ",1)

splitNames = 2×3 string
    "Mary"      "Santiago"    "Diana"
    "Butler"    "Marquez"     "Lee"  

Dividir una cadena y devolver los delimitadores

Cree una cadena.

str = "bacon, lettuce, and tomato"

str = 
"bacon, lettuce, and tomato"

Divida str usando delimitadores. Devuelva los resultados de la división en un arreglo de cadenas y los delimitadores en un segundo arreglo de cadenas. Cuando no hay texto entre delimitadores consecutivos, split devuelve una cadena vacía.

[newStr,match] = split(str,["and" "," " "])

newStr = 7×1 string
    "bacon"
    ""
    "lettuce"
    ""
    ""
    ""
    "tomato"

match = 6×1 string
    ","
    " "
    ","
    " "
    "and"
    " "

Vuelva a unir newStr y match con la función join.

originalStr = join(newStr,match)

originalStr = 
"bacon, lettuce, and tomato"

Argumentos de entrada

str — Texto de entrada

arreglo de cadenas | vector de caracteres | arreglo de celdas de vectores de caracteres

Texto de entrada, especificado como arreglo de caracteres, vector de caracteres o arreglo de celdas de vectores de caracteres. Si str es un arreglo con varios elementos, cada elemento debe contener el mismo número de subcadenas.

delimiter — Subcadenas delimitadoras

arreglo de cadenas | vector de caracteres | arreglo de celdas de vectores de caracteres | Arreglo de pattern (desde la versión R2020b)

Subcadenas delimitadoras, especificadas como una de las siguientes opciones:

• Arreglo de cadenas

• Vector de caracteres

• Arreglo de celdas de vectores de caracteres

• Arreglo de pattern (desde la versión R2020b)

Las subcadenas especificadas en delimiter no aparecen en la salida newStr.

Especifique varios delimitadores en un arreglo de cadenas, arreglo de celdas de vectores de caracteres o arreglo pattern. La función split divide str desde los elementos de delimiter. El orden en el que aparecen los delimitadores en delimiter no tiene importancia salvo si múltiples delimitadores comienzan una coincidencia en el mismo carácter de str. En ese caso, la función split divide desde el primer delimitador que coincide de delimiter.

Ejemplo: split(str,{' ',',','--'}) divide str usando espacios, comas y pares de guiones consecutivos como delimitadores.

dim — Dimensión en la que se desea colocar subcadenas de salida

entero positivo

Dimensión en la que se desea colocar subcadenas de salida, especificada como entero positivo. Si no especifica dim, el valor predeterminado es la primera dimensión final (del arreglo de entrada str) que tiene un tamaño de 1.

Argumentos de salida

newStr — Subcadenas extraídas de un arreglo original

arreglo de cadenas | arreglo de celdas de vectores de caracteres

Subcadenas extraídas del arreglo original, devueltas como arreglo de cadenas o arreglo de celdas de vectores de caracteres. Si la entrada str es un arreglo de cadenas, también lo es newStr. De lo contrario, newStr es un arreglo de celdas de vectores de caracteres.

El tamaño de newStr depende del tamaño de str y el argumento de entrada dim. Si str es un arreglo con varios elementos, cada elemento debe contener el mismo número de subcadenas (N). Con el valor dim predeterminado, las subcadenas divididas de cada elemento de la entrada str se colocan en la primera dimensión final de str que tiene un tamaño de 1:

• Si str es un escalar de cadena o un vector de caracteres, newStr es un arreglo de cadenas o un arreglo de celdas de vectores de caracteres de N por 1, donde N es el número de subcadenas.

• Si str es un arreglo de cadenas o un arreglo de celdas de M por 1, newStr es un arreglo de M por N.

• Si str es un arreglo de cadenas o un arreglo de celdas de 1 por M, newStr es un arreglo de 1 por M por N.

• Si str es un arreglo de cadenas o un arreglo de celdas de M1 por M2, newStr es un arreglo de M1 por M2 por N.

match — Delimitadores identificados

arreglo de cadenas | arreglo de celdas de vectores de caracteres

Delimitadores identificados, devueltos como arreglo de cadenas o arreglo de celdas de vectores de caracteres. Si el arreglo de entrada str es un arreglo de cadenas, también lo es match. De lo contrario, match es un arreglo de celdas de vectores de caracteres.

match siempre contiene un elemento menos de los que contiene la salida newStr.

Sugerencias

• Si str es un arreglo de cadenas o un arreglo de celdas de vectores de caracteres y cada elemento del arreglo no contiene el mismo número de subcadenas, procese los elementos de uno en uno en un bucle for y llame a split en cada elemento individualmente.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

La función split es totalmente compatible con los arreglos altos. Para obtener más información, consulte Arreglos altos.

Entorno basado en subprocesos

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

La función split es totalmente compatible con entornos basados en subprocesos. Para obtener más información, consulte Ejecutar funciones de MATLAB en entornos basados en subprocesos.

Arreglos distribuidos

Realice particiones de arreglos grandes por toda la memoria combinada de su cluster mediante Parallel Computing Toolbox™. (desde R2024b)

La función split es totalmente compatible con los arreglos distribuidos. Para obtener más información, consulte Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historial de versiones

Introducido en R2016b

Consulte también

join | extract | string | newline | compose | splitlines | pattern | lettersPattern | count

Temas

• Crear arreglos de cadenas
• Analyze Text Data with String Arrays
• Build Pattern Expressions