A menudo puedes aprender mucho de un pequeño y simple ejercicio. En este artículo, consideremos tres formas de dividir un campo en AVR para .NET. Nuestra necesidad es dividir un campo de nombre completo en dos campos, uno para el nombre y otro para el apellido. Inicialmente, usaremos la cadena 'Neil Young'.

Este artículo utiliza matrices de rango y dim. Si no está familiarizado con las diferencias entre los dos tipos de matriz, lea este artículo antes de continuar.

Para dejar en claro que estamos usando un solo espacio como delimitador, usaremos esta constante en los ejemplos:

DclConst SINGLE_SPACE Value(' ')

Usando la fuerza bruta para dividir la cuerda

Una forma tradicional de dividir una cadena es usar una combinación de los métodos IndexOf y SubString de la clase String.

DclFld CustomerName Type(*String)
DclFld FirstName Type(*String)
DclFld LastName Type(*String)
DclFld DelimiterPosition Type(*Integer4)

CustomerName = 'Neil Young'
DelimiterPosition = CustomerName.Trim().IndexOf(SINGLE_SPACE)
FirstName = CustomerName.Substring(0, DelimiterPosition)
LastName = CustomerName.Substring(DelimiterPosition + 1)

Un poco en el lado de la vieja escuela, este método es menos declarativo que usar el método Split. Utiliza el método Trim para garantizar que se envíen espacios en blanco iniciales y finales si es necesario, pero devuelve los resultados incorrectos si hay más de un espacio en el campo de entrada entre el nombre y el apellido.

Este era un método popular y necesario hace mucho tiempo. Olvídalo hoy, hay formas mucho mejores.

Usando el método Split de la clase String

Una forma mucho mejor de dividir cadenas es con el método Split de la clase String. Sin embargo, es un poco engorroso: tiene seis sobrecargas, cuatro de las cuales usan matrices de separadores *OneChar y dos de las cuales usan matrices de separadores de cadenas. De las seis formas de usar el método Split, la firma a continuación es probablemente la más utilizada por los programadores AVR:

Split(String[], StringSplitOptions)

Con esta sobrecarga, debe proporcionar una matriz de cadenas como delimitadores y un valor de opción de división de cadenas. Ese valor puede ser:

  • StringSplitOptions.None o
  • StringSplitOptions.RemoveEmptyEntries

El primero incluye elementos de matriz que contendrían una cadena vacía y el segundo omite cualquier elemento de matriz que contenga una cadena vacía..

Por ejemplo:

DclFld CustomerName Type(*String)
DclArray Delimiters Type(*String) Dim(1)
DclArry Result Type(*String) Rank(1)

Input = 'Neil Young'
Delimiters[0] = SINGLE_SPACE
Result = Input.Split(Delimiters, StringSplitOptions.RemoveEmptyEntries)

Esto proporciona nuestro resultado deseado donde el resultado [0] es 'Neil' y el resultado [1] es 'joven'. Usando una matriz clasificada, se ve así:

DclFld CustomerName Type(*String)
DclArray Delimiters Type(*String) Rank(1)
DclArry Result Type(*String) Rank(1)

Input = 'Neil Young'
Delimiters = *New System.String[] {' '}
Result = Input.Split(Delimiters, StringSplitOptions.RemoveEmptyEntries)

La diferencia aquí es cómo se declara la matriz Delimitadores y cómo se rellena. El uso de una matriz clasificada agrega flexibilidad porque agrega fácilmente un delimitador sin agregar una sola línea de código:

Delimiters = *New System.String[] {SINGLE_SPACE, ','}

El uso de StringSplitOptions.RemoveEmptyEntries evita problemas con espacios en blanco adulterados en la entrada (es decir, espacios en blanco iniciales, finales y múltiples como delimitadores).

Para la división básica de cadenas, esta sobrecarga del método Split proporciona una forma bastante buena de dividir cadenas simples.

La forma más flexible de dividir una cadena

La forma más flexible de dividir una cadena es con el método System.Text.RegularExpressions.Split. Utiliza una expresión regular para dividir la cadena.

Sé que las expresiones regulares no están en la bolsa del kit de cada programador. Pero debería. Las expresiones regulares tienen muchos usos en muchos lugares y un amplio conocimiento de ellas le será de gran utilidad. Como mínimo, considere esta forma de dividir una cadena en un punto de entrada en expresiones regulares.

Este método necesita esta declaración de uso en la parte superior de su código:

Using System.String.RegularExpressions
DclFld CustomerName Type(*String)
DclFld Pattern Type(*String)
DclArry Result Type(*String) Rank(1)

CustomerName = 'Neil Young'
Pattern = '\s*[ ]\s*'
Result = Regex.Split(CustomerName.Trim(), Pattern)  

Esto produce el nombre y el apellido deseados en la Result matriz de resultados. Funciona con uno o varios espacios en blanco que separan el nombre y el apellido. La parte mágica de esta solución es esta línea que proporciona la expresión regular:

Pattern = '\s*[ ]\s*'

su descripción es:

Pattern Description
\s cualquier espacio en blanco
* cero o más del patrón anterior
[ ] un grupo de personajes para buscar, en este caso un solo espacio
\s cualquier espacio en blanco
* uno o más del patrón anterior

El campo Patrón proporciona el patrón en el que dividir la cadena. En forma narrativa, la siguiente expresión dice: "Busque cero o más espacios seguidos de los caracteres dentro de los corchetes [] seguidos de cero o más espacios".

Podríamos cambiar el patrón para buscar un espacio o un separador de coma como este:

Pattern = '\s*[ |,]\s*'

Dentro de los corchetes, el carácter de canalización (|) significa "O", por lo que esto dice: "Busque un espacio o una coma".

Puede aprender mucho sobre expresiones regulares con este probador en línea de expresiones regulares. Sé que si no estás familiarizado con las expresiones regulares, todo esto parece bastante loco. Pero, confía en mí, una vez que aprendas incluso un poco sobre las expresiones regulares, las usarás, bueno, regularmente.

Para los más curiosos

Una característica de las expresiones regulares .NET son los grupos de captura. El siguiente código utiliza esa función para capturar el nombre y el apellido del campo CustomerName.

DclFld m Type(Match) 
DclFld CustomerName Type(*String)
DclFld FirstName Type(*String)
DclFld LastName Type(*String) 
DclFld Pattern Type(*String)

CustomerName = 'Neil Young'
Pattern = "^\s*(?'firstname'.*)\s*[ ]\s*(?'lastname'.*)\s*$"

m = Regex.Match(CustomerName, Pattern) 
If (m.Success) 
    FirstName = m.Groups['firstname'].Value 
    LastName = m.Groups['lastname'].Value 
EndIf

Puedes estudiar esta expresión regular, con un desglose de lo que está haciendo cada ficha, aquí.



Por favor, inicie sesión o cree una cuenta para enviar comentarios.