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 str usando caracteres de espacio en blanco como delimitadores y devuelve el resultado como el arreglo de salida newStr. El arreglo de entrada str puede ser un arreglo de cadenas, un vector de caracteres o un arreglo de celdas de vectores de caracteres. Si str es un arreglo de cadenas, también lo es newStr. De lo contrario, newStr es un arreglo de celdas de vectores de caracteres. newStr no incluye los caracteres de espacio en blanco de str.

Si str es un arreglo de cadenas o un arreglo de celdas de vectores de caracteres y tiene varios elementos, cada elemento debe ser divisible en el mismo número de subcadenas.

• 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.

Para un arreglo de cadenas o un arreglo de celdas de cualquier tamaño, split orienta las N subcadenas en la primera dimensión final con un tamaño de 1.

Si el número de subcadenas no es el mismo para cada elemento de str, llame a split en un bucle for para dividir los elementos de str de uno en uno.

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

newStr = split(str,delimiter,dim) divide cada elemento de str en un vector orientado 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.

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 dividir cadenas

entero positivo

Dimensión en la que dividir cadenas, especificada como entero positivo. Si no se especifica dim, el valor predeterminado es la última dimensión del arreglo con un tamaño que no sea igual a 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 de un arreglo original, devueltas 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 newStr. De lo contrario, newStr es un arreglo de celdas de vectores de caracteres.

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.

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.

Esta función 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)

Esta función 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