> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentación sobre funciones de división de cadenas # Funciones de división de cadenas export const DeprecatedBadge = () => { return
Deprecated feature
; }; La documentación que aparece a continuación se genera a partir de la system table `system.functions`. {/*AUTOGENERATED_START*/}
## alphaTokens
Introducido en: v1.1.0 Selecciona subcadenas de bytes consecutivos de los rangos `a-z` y `A-Z` y devuelve un Array con las subcadenas seleccionadas. **Sintaxis** ```sql theme={null} alphaTokens(s[, max_substrings]) ``` **Alias**: `splitByAlpha` **Argumentos** * `s` — La cadena que se va a dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Cuando `max_substrings > 0`, el número de subcadenas devueltas no será mayor que `max_substrings`; de lo contrario, la función devolverá tantas subcadenas como sea posible. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un Array de las subcadenas seleccionadas de `s`. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT alphaTokens('abca1abc'); ``` ```response title=Response theme={null} ┌─alphaTokens('abca1abc')─┐ │ ['abca','abc'] │ └─────────────────────────┘ ```
## arrayStringConcat
Introducido en: v1.1.0 Concatena las representaciones en forma de cadena de los valores incluidos en el array usando el separador proporcionado, que es un parámetro opcional cuyo valor predeterminado es una cadena vacía. **Sintaxis** ```sql theme={null} arrayStringConcat(arr[, separator]) ``` **Alias**: `array_to_string` **Argumentos** * `arr` — El array que se va a concatenar. [`Array(T)`](/es/reference/data-types/array) * `separator` — Opcional. Cadena separadora. De forma predeterminada, una cadena vacía. [`const String`](/es/reference/data-types/string) **Valor devuelto** Devuelve la cadena concatenada. [`String`](/es/reference/data-types/string) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString; ``` ```response title=Response theme={null} ┌─DateString──────────┐ │ 12/05/2021 12:50:00 │ └─────────────────────┘ ```
## extractAllGroupsVertical
Introducido en: v20.5.0 Encuentra todos los grupos de una cadena mediante una expresión regular y devuelve un array de arrays, donde cada array contiene los fragmentos coincidentes de cada grupo, agrupados según el orden de aparición en la cadena de entrada. **Sintaxis** ```sql theme={null} extractAllGroupsVertical(s, regexp) ``` **Alias**: `extractAllGroups` **Argumentos** * `s` — Cadena de entrada de la que extraer. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `regexp` — Expresión regular con la que buscar coincidencias. [`const String`](/es/reference/data-types/string) o [`const FixedString`](/es/reference/data-types/fixedstring) **Valor devuelto** Devuelve un array de arrays, donde cada array interno contiene los grupos capturados de una coincidencia. Cada coincidencia produce un array con elementos correspondientes a los grupos de captura de la expresión regular (grupo 1, grupo 2, etc.). Si no se encuentra ninguna coincidencia, devuelve un array vacío. [`Array(Array(String))`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} WITH '< Server: nginx < Date: Tue, 22 Jan 2019 00:26:14 GMT < Content-Type: text/html; charset=UTF-8 < Connection: keep-alive ' AS s SELECT extractAllGroupsVertical(s, '< ([\\w\\-]+): ([^\\r\\n]+)'); ``` ```response title=Response theme={null} [['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']] ```
## ngrams
Disponible desde: v21.11.0 Divide una cadena UTF-8 en n-gramas de longitud `N`. **Sintaxis** ```sql theme={null} ngrams(s, N) ``` **Argumentos** * `s` — Cadena de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `N` — La longitud del n-grama. [`const UInt8/16/32/64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array de n-gramas. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT ngrams('ClickHouse', 3); ``` ```response title=Response theme={null} ['Cli','lic','ick','ckH','kHo','Hou','ous','use'] ```
## reverseBySeparator
Introducido en: v26.2.0 Invierte el orden de las subcadenas de una cadena separadas por un separador especificado. Esta función divide la cadena por el separador, invierte el orden de las partes resultantes y las vuelve a unir usando el mismo separador. Resulta útil para analizar nombres de dominio, rutas de archivo u otros datos jerárquicos en los que necesites invertir el orden de los componentes. Ejemplos: * reverseBySeparator('[www.google.com](http://www.google.com)') devuelve 'com.google.www' * reverseBySeparator('a/b/c', '/') devuelve 'c/b/a' * reverseBySeparator('x::y::z', '::') devuelve 'z::y::x' **Sintaxis** ```sql theme={null} reverseBySeparator(string[, separator]) ``` **Argumentos** * `string` — La cadena de entrada cuyo orden de partes se va a invertir. [`String`](/es/reference/data-types/string) * `separator` — La cadena separadora que se usa para identificar las partes. Si no se proporciona, se usa '.' (punto). Valor predeterminado: '.' [`String`](/es/reference/data-types/string) **Valor devuelto** Devuelve una cadena con las subcadenas de la cadena original ordenadas de derecha a izquierda, unidas por el mismo separador. [`String`](/es/reference/data-types/string) **Ejemplos** **Inversión básica de dominios** ```sql title=Query theme={null} SELECT reverseBySeparator('www.google.com') ``` ```response title=Response theme={null} 'com.google.www' ``` **Ruta invertida** ```sql title=Query theme={null} SELECT reverseBySeparator('a/b/c', '/') ``` ```response title=Response theme={null} 'c/b/a' ``` **Separador personalizado** ```sql title=Query theme={null} SELECT reverseBySeparator('x::y::z', '::') ``` ```response title=Response theme={null} 'z::y::x' ``` **Caso especial con puntos** ```sql title=Query theme={null} SELECT reverseBySeparator('.a.b.', '.') ``` ```response title=Response theme={null} '.b.a.' ``` **Un solo elemento** ```sql title=Query theme={null} SELECT reverseBySeparator('single') ``` ```response title=Response theme={null} 'single' ``` **Separador vacío** ```sql title=Query theme={null} SELECT reverseBySeparator('abcde', '') ``` ```response title=Response theme={null} 'edcba' ```
## splitByChar
Introducido en: v1.1.0 Divide una cadena en un Array de subcadenas usando como separador una cadena constante `separator` de exactamente un carácter. Se pueden obtener subcadenas vacías si el separador aparece al principio o al final de la cadena, o si hay varios separadores consecutivos. La configuración [`splitby_max_substrings_includes_remaining_string`](/es/reference/settings/session-settings#splitby_max_substrings_includes_remaining_string) (valor predeterminado: `0`) controla si la cadena restante se incluye en el último elemento del Array resultante cuando el argumento `max_substrings > 0`. Se pueden obtener subcadenas vacías cuando: * Un separador aparece al principio o al final de la cadena * Hay varios separadores consecutivos * La cadena original `s` está vacía **Sintaxis** ```sql theme={null} splitByChar(separator, s[, max_substrings]) ``` **Argumentos** * `separator` — El separador debe ser un carácter de un solo byte. [`String`](/es/reference/data-types/string) * `s` — La cadena que se debe dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Si `max_substrings > 0`, el array devuelto contendrá como máximo `max_substrings` subcadenas; de lo contrario, la función devolverá tantas subcadenas como sea posible. El valor predeterminado es `0`. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array de las subcadenas seleccionadas. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT splitByChar(',', '1,2,3,abcde'); ``` ```response title=Response theme={null} ┌─splitByChar(⋯2,3,abcde')─┐ │ ['1','2','3','abcde'] │ └──────────────────────────┘ ```
## splitByNonAlpha
Introducido en: v21.9.0 Divide en un array de subcadenas una cadena delimitada por caracteres de espacio en blanco y de puntuación. La configuración [`splitby_max_substrings_includes_remaining_string`](/es/reference/settings/session-settings#splitby_max_substrings_includes_remaining_string) (predeterminada: `0`) controla si la cadena restante se incluye en el último elemento del array resultante cuando el argumento `max_substrings > 0`. **Sintaxis** ```sql theme={null} splitByNonAlpha(s[, max_substrings]) ``` **Argumentos** * `s` — La cadena que se va a dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Cuando `max_substrings > 0`, las subcadenas devueltas no serán más de `max_substrings`; de lo contrario, la función devolverá tantas subcadenas como sea posible. Valor predeterminado: `0`. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un Array de subcadenas seleccionadas de `s`. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT splitByNonAlpha('user@domain.com'); ``` ```response title=Response theme={null} ['user','domain','com'] ```
## splitByRegexp
Introducido en: v21.6.0 Divide una cadena separada por la expresión regular proporcionada en un array de subcadenas. Si la expresión regular proporcionada está vacía, la cadena se dividirá en un array de caracteres individuales. Si no se encuentra ninguna coincidencia para la expresión regular, la cadena no se dividirá. Pueden seleccionarse subcadenas vacías cuando: * se produce una coincidencia no vacía de la expresión regular al principio o al final de la cadena * hay varias coincidencias no vacías consecutivas de la expresión regular * la cadena original está vacía mientras que la expresión regular no lo está. La configuración [`splitby_max_substrings_includes_remaining_string`](/es/reference/settings/session-settings#splitby_max_substrings_includes_remaining_string) (valor predeterminado: `0`) controla si la cadena restante se incluye en el último elemento del array de resultados cuando el argumento `max_substrings > 0`. **Sintaxis** ```sql theme={null} splitByRegexp(regexp, s[, max_substrings]) ``` **Argumentos** * `regexp` — Expresión regular. Constante. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `s` — La cadena que se debe dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Cuando `max_substrings > 0`, el número de subcadenas devueltas no será mayor que `max_substrings`; de lo contrario, la función devolverá tantas subcadenas como sea posible. Valor predeterminado: `0`. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un Array con las subcadenas seleccionadas de `s`. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT splitByRegexp('\\d+', 'a12bc23de345f'); ``` ```response title=Response theme={null} ┌─splitByRegex⋯c23de345f')─┐ │ ['a12bc23de345f'] │ └──────────────────────────┘ ``` **Expresión regular vacía** ```sql title=Query theme={null} SELECT splitByRegexp('', 'abcde'); ``` ```response title=Response theme={null} ┌─splitByRegexp('', 'abcde')─┐ │ ['a','b','c','d','e'] │ └────────────────────────────┘ ```
## splitByString
Introducido en: v1.1.0 Divide una cadena con un `separator` constante compuesto por varios caracteres en un array de subcadenas. Si la cadena `separator` está vacía, dividirá la cadena `s` en un array de caracteres individuales. Pueden seleccionarse subcadenas vacías cuando: * Un separador no vacío aparece al principio o al final de la cadena * Hay varios separadores no vacíos consecutivos * La cadena original `s` está vacía mientras que el separador no lo está La configuración [`splitby_max_substrings_includes_remaining_string`](/es/reference/settings/session-settings#splitby_max_substrings_includes_remaining_string) (valor predeterminado: `0`) controla si la cadena restante se incluye en el último elemento del array de resultados cuando el argumento `max_substrings > 0`. **Sintaxis** ```sql theme={null} splitByString(separator, s[, max_substrings]) ``` **Argumentos** * `separator` — El separador. [`String`](/es/reference/data-types/string) * `s` — La cadena que se va a dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Cuando `max_substrings > 0`, el número de subcadenas devueltas no será mayor que `max_substrings`; de lo contrario, la función devolverá tantas subcadenas como sea posible. Valor predeterminado: `0`. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array con las subcadenas obtenidas de `s` [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT splitByString(', ', '1, 2 3, 4,5, abcde'); ``` ```response title=Response theme={null} ┌─splitByStrin⋯4,5, abcde')─┐ │ ['1','2 3','4,5','abcde'] │ └───────────────────────────┘ ``` **Separador en blanco** ```sql title=Query theme={null} SELECT splitByString('', 'abcde'); ``` ```response title=Response theme={null} ┌─splitByString('', 'abcde')─┐ │ ['a','b','c','d','e'] │ └────────────────────────────┘ ```
## splitByWhitespace
Introducido en: v21.9.0 Divide una cadena separada por caracteres de espacio en blanco en un array de subcadenas. La configuración [`splitby_max_substrings_includes_remaining_string`](/es/reference/settings/session-settings#splitby_max_substrings_includes_remaining_string) (por defecto: `0`) controla si la cadena restante se incluye en el último elemento del array de resultado cuando el argumento `max_substrings > 0`. **Sintaxis** ```sql theme={null} splitByWhitespace(s[, max_substrings]) ``` **Argumentos** * `s` — La cadena que se va a dividir. [`String`](/es/reference/data-types/string) * `max_substrings` — Opcional. Cuando `max_substrings > 0`, las subcadenas devueltas no serán más de `max_substrings`; de lo contrario, la función devolverá tantas subcadenas como sea posible. Valor predeterminado: `0`. [`Int64`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve un array con las subcadenas seleccionadas de `s`. [`Array(String)`](/es/reference/data-types/array) **Ejemplos** **Ejemplo de uso** ```sql title=Query theme={null} SELECT splitByWhitespace(' 1! a, b. '); ``` ```response title=Response theme={null} ['1!','a,','b.'] ```
## tokens
Introducido en: v21.11.0 Divide una cadena en tokens usando el tokenizador indicado. Tokenizadores disponibles: * `splitByNonAlpha` divide cadenas por caracteres ASCII no alfanuméricos (consulte también la función [splitByNonAlpha](/es/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha)). * `splitByString(S)` divide cadenas usando determinadas cadenas separadoras `S` definidas por el usuario (consulte también la función [splitByString](/es/reference/functions/regular-functions/splitting-merging-functions#splitByString)). Los separadores pueden especificarse mediante un parámetro opcional; por ejemplo, `tokens(value, 'splitByString', [', ', '; ', '\n', '\\'])`. Tenga en cuenta que cada cadena puede constar de varios caracteres (`', '` en el ejemplo). La lista de separadores predeterminada, si no se especifica explícitamente, es un único espacio en blanco `[' ']`. * `asciiCJK` divide cadenas en tokens usando reglas de límite de palabra de Unicode (similares a UAX #29). Los caracteres ASCII alfanuméricos y los guiones bajos forman tokens con conectores (`:` para letras, `.` y `'` para caracteres del mismo tipo). Los caracteres Unicode no ASCII pasan a ser tokens de un solo carácter. * `ngrams(N)` divide cadenas en n-gramas de tamaño uniforme `N` (consulte también la función [ngrams](/es/reference/functions/regular-functions/splitting-merging-functions#ngrams)). La longitud del n-grama puede especificarse mediante un parámetro entero opcional entre 1 y 8; por ejemplo, `tokens(value, 'ngrams', 3)`. El tamaño predeterminado del n-grama, si no se especifica explícitamente, es 3. * `sparseGrams(min_length, max_length, min_cutoff_length)` divide cadenas en n-gramas de longitud variable de al menos `min_length` y como máximo `max_length` caracteres (inclusive) (consulte también la función [sparseGrams](/es/reference/functions/regular-functions/string-functions#sparseGrams)). A menos que se especifique explícitamente, `min_length` y `max_length` toman los valores predeterminados 3 y 100. Si se proporciona el parámetro `min_cutoff_length`, solo se devuelven n-gramas con una longitud mayor o igual que `min_cutoff_length`. En comparación con `ngrams(N)`, el tokenizador `sparseGrams` produce n-gramas de longitud variable, lo que permite una representación más flexible del texto original. Por ejemplo, `tokens(value, 'sparseGrams', 3, 5, 4)` genera internamente 3-, 4- y 5-gramas a partir de la cadena de entrada, pero solo se devuelven los 4- y 5-gramas. * `array` no realiza tokenización; es decir, cada valor de fila es un token (consulte también la función [array](/es/reference/functions/regular-functions/array-functions#array)). En el caso del tokenizador `splitByString`, si los tokens no forman un [código prefijo](https://en.wikipedia.org/wiki/Prefix_code), probablemente le convenga que la coincidencia dé prioridad a los separadores más largos. Para ello, pase los separadores en orden descendente de longitud. Por ejemplo, con separators = `['%21', '%']`, la cadena `%21abc` se tokenizaría como `['abc']`, mientras que separators = `['%', '%21']` se tokenizaría como `['21ac']` (que probablemente no es lo que quería). **Sintaxis** ```sql theme={null} tokens(value) -- tokenizador 'splitByNonAlpha' tokens(value, 'splitByNonAlpha') tokens(value, 'splitByString'[, separators]) tokens(value, 'asciiCJK') tokens(value, 'ngrams'[, n]) tokens(value, 'sparseGrams'[, min_length, max_length[, min_cutoff_length]]) tokens(value, 'array') ``` **Argumentos** * `value` — La cadena de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `tokenizer` — El tokenizador que se va a usar. Los argumentos válidos son `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` y `array`. Es opcional; si no se establece explícitamente, el valor predeterminado es `splitByNonAlpha`. [`const String`](/es/reference/data-types/string) * `n` — Solo es relevante si el argumento `tokenizer` es `ngrams`: un parámetro opcional que define la longitud de los ngrams. Si no se establece explícitamente, el valor predeterminado es `3`. [`const UInt8`](/es/reference/data-types/int-uint) * `separators` — Solo es relevante si el argumento `tokenizer` es `split`: un parámetro opcional que define las cadenas separadoras. Si no se establece explícitamente, el valor predeterminado es `[' ']`. [`const Array(String)`](/es/reference/data-types/array) * `min_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud mínima de los gramas; el valor predeterminado es 3. [`const UInt8`](/es/reference/data-types/int-uint) * `max_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud máxima de los gramas; el valor predeterminado es 100. [`const UInt8`](/es/reference/data-types/int-uint) * `min_cutoff_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud mínima de corte. [`const UInt8`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve el array de tokens resultante de la cadena de entrada. [`Array`](/es/reference/data-types/array) **Ejemplos** **Tokenizador predeterminado** ```sql title=Query theme={null} SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\ test4') AS tokens; ``` ```response title=Response theme={null} ['test1','test2','test3','test4'] ``` **Tokenizador de ngramas** ```sql title=Query theme={null} SELECT tokens('abc def', 'ngrams', 3) AS tokens; ``` ```response title=Response theme={null} ['abc','bc ','c d',' de','def'] ```
## tokensForLikePattern
Introducido en: v26.3.0 Divide una cadena de patrón LIKE en tokens mediante el tokenizador especificado. A diferencia de la función `tokens`, esta función tiene en cuenta la semántica de los patrones LIKE (como los caracteres comodín al principio y al final) y aplica reglas específicas del tokenizador para extraer tokens significativos para la coincidencia de patrones. Admite los mismos conjuntos de argumentos que la función `tokens`; los argumentos adicionales después de `tokenizer` se interpretan según el tokenizador seleccionado (por ejemplo, `n` para `ngrams`, `separators` para `splitByString`, y `min_length` / `max_length` \[/ `min_cutoff_length`] para `sparseGrams`). Esta función está pensada principalmente para tareas de depuración y pruebas, y se utiliza internamente para analizar el comportamiento de la tokenización en patrones LIKE. **Sintaxis** ```sql theme={null} tokensForLikePattern(value[, tokenizer[, tokenizer_specific_arguments...]]) ``` **Argumentos** * `value` — La cadena de entrada. [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) * `tokenizer` — El tokenizador que se utilizará. Los argumentos válidos son `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` y `array`. Es opcional; si no se establece explícitamente, el valor predeterminado es `splitByNonAlpha`. [`const String`](/es/reference/data-types/string) * `n` — Solo es relevante si el argumento `tokenizer` es `ngrams`: un parámetro opcional que define la longitud de los ngrams. Si no se establece explícitamente, el valor predeterminado es `3`. [`const UInt8`](/es/reference/data-types/int-uint) * `separators` — Solo es relevante si el argumento `tokenizer` es `split`: un parámetro opcional que define las cadenas separadoras. Si no se establece explícitamente, el valor predeterminado es `[' ']`. [`const Array(String)`](/es/reference/data-types/array) * `min_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud mínima del gram; el valor predeterminado es 3. [`const UInt8`](/es/reference/data-types/int-uint) * `max_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud máxima del gram; el valor predeterminado es 100. [`const UInt8`](/es/reference/data-types/int-uint) * `min_cutoff_length` — Solo es relevante si el argumento `tokenizer` es `sparseGrams`: un parámetro opcional que define la longitud mínima de corte. [`const UInt8`](/es/reference/data-types/int-uint) **Valor devuelto** Devuelve el array de tokens resultante de la cadena de entrada. [`Array`](/es/reference/data-types/array) **Ejemplos** **Tokenizador predeterminado** ```sql title=Query theme={null} SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens; ``` ```response title=Response theme={null} ['test2'] ```