División de cadenas en Ruby utilizando el método de división de cadena #

A menos que la entrada del usuario sea una sola palabra o número, esa entrada deberá dividirse o convertirse en una lista de cadenas o números.

Por ejemplo, si un programa solicita su nombre completo, incluida la inicial del segundo nombre, primero deberá dividir esa entrada en tres cadenas separadas antes de que pueda funcionar con su nombre, segundo nombre y apellido individuales. Esto se logra utilizando el Cadena # dividida método.

Cómo funciona String # split

En su forma más básica, Cadena # dividida toma un solo argumento: el delimitador de campo como una cadena. Este delimitador se eliminará de la salida y se devolverá una serie de cadenas divididas en el delimitador..

Entonces, en el siguiente ejemplo, suponiendo que el usuario ingrese su nombre correctamente, debería recibir un elemento de tres elementos Formación de la división.

#! / usr / bin / env ruby
print "¿Cuál es tu nombre completo?"
full_name = gets.chomp
nombre = full_name.split (")
pone "Su nombre es # name.first"
pone "Su apellido es # name.last"

Si ejecutamos este programa e ingresamos un nombre, obtendremos algunos resultados esperados. Además, tenga en cuenta que nombre primero y apellido son coincidencias los nombre la variable será un Formación, y esas dos llamadas a métodos serán equivalentes a nombre [0] y nombre [-1] respectivamente.

$ ruby ​​split.rb
¿Cuál es su nombre completo? Michael C. Morin
Tu nombre es michael
Tu apellido es Morin

sin embargo, Cadena # dividida es un poco más inteligente de lo que piensas. Si el argumento para Cadena # dividida es una cadena, de hecho lo usa como delimitador, pero si el argumento es una cadena con un solo espacio (como lo usamos), entonces infiere que desea dividir en cualquier cantidad de espacio en blanco y que también desea eliminar cualquier espacio en blanco principal.

Entonces, si tuviéramos que darle una entrada ligeramente malformada como

Michael C. Morin

(con espacios adicionales), luego Cadena # dividida aún haría lo que se espera. Sin embargo, ese es el único caso especial cuando pasa un Cuerda como el primer argumento Delimitadores de expresión regular

También puede pasar una expresión regular como primer argumento. aquí, Cadena # dividida se vuelve un poco más flexible. También podemos hacer que nuestro pequeño código de división de nombres sea un poco más inteligente.

No queremos el período al final de la inicial del segundo nombre. Sabemos que es una inicial del segundo nombre, y la base de datos no querrá un punto allí, por lo que podemos eliminarla mientras nos dividimos. Cuando Cadena # dividida coincide con una expresión regular, hace exactamente lo mismo que si hubiera coincidido con un delimitador de cadena: lo saca de la salida y lo divide en ese punto.

Entonces, podemos evolucionar un poco nuestro ejemplo:

$ cat split.rb
#! / usr / bin / env ruby
print "¿Cuál es tu nombre completo?"
full_name = gets.chomp
name = full_name.split (/ \.? \ s + /)
pone "Su nombre es # name.first"
pone "Tu inicial del segundo nombre es # nombre [1]"
pone "Su apellido es # name.last"

Separador de registro predeterminado

Ruby no es realmente grande en "variables especiales" que puede encontrar en idiomas como Perl, pero Cadena # dividida utiliza uno que necesita tener en cuenta. Esta es la variable de separador de registro predeterminada, también conocida como PS.

Es global, algo que no se ve con frecuencia en Ruby, por lo que si lo cambia, podría afectar a otras partes del código, solo asegúrese de volver a cambiarlo cuando haya terminado..

Sin embargo, todo lo que hace esta variable es actuar como el valor predeterminado para el primer argumento para Cadena # dividida. Por defecto, esta variable parece estar configurada en nulo. Sin embargo, si Cadena # divididaEl primer argumento es nulo, lo reemplazará con una cadena de espacio simple.

Delimitadores de longitud cero

Si el delimitador pasó a Cadena # dividida es una cadena de longitud cero o una expresión regular, entonces Cadena # dividida actuará un poco diferente. No eliminará nada de la cadena original y se dividirá en cada carácter. Esto esencialmente convierte la cadena en una matriz de igual longitud que contiene solo cadenas de un carácter, una para cada carácter en la cadena.

Esto puede ser útil para iterar sobre la cadena y se usó en versiones anteriores a 1.9.xy anteriores a 1.8.7 (que respaldaban una serie de características de 1.9.x) para iterar sobre los caracteres en una cadena sin preocuparse por dividir múltiples byte caracteres Unicode. Sin embargo, si lo que realmente quiere hacer es iterar sobre una cadena y está usando 1.8.7 o 1.9.x, probablemente debería usar Cadena # each_char en lugar.

#! / usr / bin / env ruby
str = "¡Ella me convirtió en un tritón!"
str.split ("). cada do | c |
pone c
final

Limitar la longitud de la matriz devuelta

Volviendo a nuestro ejemplo de análisis de nombre, ¿qué pasa si alguien tiene un espacio en su apellido? Por ejemplo, los apellidos holandeses a menudo pueden comenzar con "van" (que significa "de" o "de").

Solo queremos realmente una matriz de 3 elementos, por lo que podemos usar el segundo argumento para Cadena # dividida que hasta ahora hemos ignorado. Se espera que el segundo argumento sea un Fixnum. Si este argumento es positivo, a lo sumo, se completarán muchos elementos en la matriz. Entonces, en nuestro caso, nos gustaría pasar 3 para este argumento.

#! / usr / bin / env ruby
print "¿Cuál es tu nombre completo?"
full_name = gets.chomp
name = full_name.split (/ \.? \ s + /, 3)
pone "Su nombre es # name.first"
pone "Tu inicial del segundo nombre es # nombre [1]"
pone "Su apellido es # name.last"

Si ejecutamos esto nuevamente y le damos un nombre holandés, actuará como se esperaba.

$ ruby ​​split.rb
¿Cuál es su nombre completo? Vincent Willem van Gogh
Tu nombre es Vincent
Tu inicial del segundo nombre es Willem
Tu apellido es van Gogh

Sin embargo, si este argumento es negativo (cualquier número negativo), no habrá límite en el número de elementos en la matriz de salida y los delimitadores finales aparecerán como cadenas de longitud cero al final de la matriz.

Esto se demuestra en este fragmento de IRB:

: 001> "this, is, a, test ,,,,". Split (',', -1)
=> ["esto", "es", "a", "prueba", "", "", "", ""]