Share
Ruby es uno de los idiomas más populares utilizados en la web. Comenzamos una nueva sesión aquí en Nettuts + que te presentará a Ruby, así como a los excelentes marcos y herramientas que acompañan el desarrollo de Ruby. En esta lección, veremos cómo usar expresiones regulares en Ruby.
Si está familiarizado con las expresiones regulares, le agradará saber que la mayor parte de la sintaxis para escribir las expresiones regulares reales es muy similar a la que conoce de PHP, JavaScript o [su idioma aquí].
Si no está familiarizado con las expresiones regulares, querrá ver nuestros tutoriales Regex aquí en Nettuts + para ponerse al día..
Al igual que todo lo demás en Ruby, las expresiones regulares son objetos regulares: son instancias de Regexp clase. Sin embargo, normalmente creará una expresión regular con la sintaxis literal estándar:
/ myregex / / \ (\ d 3 \) \ d 3 - \ d 4 /
Para empezar, la forma más sencilla de usar una expresión regular es aplicarla a una cadena y ver si hay una coincidencia. Tanto las cadenas como los objetos de expresión regular tienen una partido Método que hace esto:
"(123) 456-7890" .match / \ (\ d 3 \) \ d 3 - \ d 4 / / \ (\ d 3 \) \ d 3 - \ d 4 /. Coincide con "(123) 456-7890"
Ambos ejemplos coinciden, por lo que vamos a obtener una MatchData instancia de vuelta (veremos MatchData objetos pronto). Si no hay partido, partido volverá nulo. Porque un MatchData objeto evaluará a cierto, puedes usar el partido Método en sentencias condicionales (como una sentencia if), y simplemente ignore que está obteniendo un valor de retorno.
Hay otro método que puede usar para hacer coincidir la expresión regular con cadenas: esa es la = ~ (el operador de tilde igual). Recuerda que los operadores son métodos en Ruby. Me gusta partido, este método devuelve nulo en ningún partido. Sin embargo, si hay una coincidencia, devolverá la posición numérica de la cadena donde comenzó la coincidencia. También como el partido, tanto las cadenas como las expresiones regulares tienen = ~.
"Ruby For Newbies: Expresiones regulares" = ~ / Nuevo / # => 9
Las expresiones regulares se vuelven más útiles cuando estamos recogiendo algunos datos. Esto generalmente se hace con agrupaciones: envolviendo ciertas partes de la expresión regular entre paréntesis. Digamos que queremos hacer coincidir un nombre, un apellido y una ocupación en una cadena, donde la cadena tiene un formato como este:
str1 = "Joe Schmo, fontanero" str2 = "Stephen Harper, Primer Ministro"
Para obtener los tres campos, crearemos esta expresión regular:
re = / (\ w *) \ s (\ w *), \ s? ([\ w \ s] *) /
Esto coincide con cualquier número de caracteres de palabras, algunos espacios en blanco, cualquier número de caracteres de palabras, una coma, algunos espacios en blanco opcionales y cualquier número de caracteres de palabras o espacios en blanco. Como puede suponer, las partes que incluyen caracteres de palabras se refieren a los nombres u ocupaciones que estamos buscando, por lo que están entre paréntesis.
Entonces, ejecutemos esto:
match1 = str1.match re match2 = str2.match re
Ahora nuestra match1 y match2 las variables sostienen MatchData Objetos (porque nuestros dos partidos fueron exitosos). Entonces, veamos cómo podemos usar en estos MatchData objetos.
A medida que pasemos por esto, notará que hay varias formas diferentes de obtener los mismos datos de nuestra MatchData objeto. Comenzaremos con la cadena coincidente: si desea ver cuál es la cadena original que coincidió con la expresión regular, use la cuerda método. También puedes usar el [] Método (corchetes), y pasar el parámetro 0:
match1.string # => "Joe Schmo, fontanero" match1 [0] # (esto es lo mismo que match1. [] 0) => "Joe Schmo, fontanero"
¿Qué pasa con la expresión regular en sí? Usted puede encontrar que con el expresión regular método.
match1.regex # => wsw, s [ws] (esta es la forma única de IRB de mostrar expresiones regulares; todavía funcionará normalmente)
Ahora, ¿qué hay de obtener esos grupos emparejados que fueron el punto de este ejercicio? En primer lugar, podemos obtenerlos con índices numerados en el MatchData objeto en sí mismo; por supuesto, están en el orden en que los combinamos en:
match1 [1] # => "Joe" match1 [2] # => "Schmo" match1 [3] # => "Plumber" match2 [1] # => "Stephen" match2 [2] # => "Harper" match2 [3] # => "Primer Ministro"
En realidad, hay otra forma de obtener estas capturas: eso es con la propiedad de matriz captura; ya que esta es una matriz, esta basada en cero.
match1.captures [0] # => "Joe" match2.captures [2] # => "Prime Minister"
Lo creas o no, en realidad hay una tercera forma de obtener tus capturas. Cuando ejecutas partido o = ~, Ruby completa una serie de variables globales, una para cada uno de los grupos capturados en tu expresión regular:
"Andrew Burgess" .match / (\ w *) \ s (\ w *) / # devuelve un objeto MatchData, pero ignoramos que $ 1 # => "Andrew" $ 2 # => "Burgess"
De regreso MatchData objetos. Si desea averiguar el índice de cadena de una captura dada, pase el número de capturas a la empezar función (aquí, usted quiere el número de la captura como lo usaría con el [] método, no a través captura). Alternativamente, puedes usar fin para ver cuando termina esa captura.
m = "Nettuts + es el mejor" .Match / (is) (the) / m [1] # => "is" m.begin 1 # => 8 m [2] # => "end" m.end 2 # => 14
También está el Previo al partido y después del partido Métodos, que son bastante claros: esto te muestra qué parte de la cadena apareció antes y después de la coincidencia, respectivamente..
# m desde arriba m.pre_match # => "Nettuts +" m.post_match # => "best"
Eso cubre prácticamente lo básico de trabajar con expresiones regulares en Ruby.
Dado que las expresiones regulares son muy útiles cuando manipulas cadenas, encontrarás varios métodos de cadena que las aprovechan. Los más útiles son probablemente los métodos de sustitución. Éstos incluyen
Accentsconagua
subsub!gsubgsub!Estos son para la sustitución y la sustitución global, respectivamente. La diferencia es que gsub Reemplaza todas las instancias de nuestro patrón, mientras que sub reemplaza solo la primera instancia en la cadena.
Así es como los usamos:
"alguna cadena" .sub / string /, "mensaje" # => "mensaje" "El hombre en el parque" .gsub / the /, "a" # => "un hombre en un parque"
Como ya sabrá, los métodos bang (¡los que terminan con un signo de exclamación!) Son métodos destructivos: cambian los objetos de cadena reales, en lugar de devolver los actuales. Por ejemplo:
original = "Mi nombre es Andrew." new = original.sub / Mi nombre es /, "Hola, soy" original # => Mi nombre es Andrew. "new # =>" Hola, Andrew "original =" Who are you? "original. sub! / ¿Quiénes son /, "Y" original # => "¿Y tú?"
Además de estos ejemplos simples, puedes hacer cosas más complejas, como esto:
"1234567890" .sub / (\ d 3) (\ d 3) (\ d 4) /, '(\ 1) \ 2- \ 3' # => "(123) 456-7890 "
No conseguimos MatchData objetos o las variables globales con los métodos de sustitución; sin embargo, podemos usar el? backslash-number? patrón en la cadena de reemplazo, si lo envolvemos en comillas simples. Si desea seguir manipulando la cadena capturada, puede pasar un bloque en lugar del segundo parámetro:
"¿QUÉ ESTÁ PASANDO?". Gsub (/ \ S * /) | s | en el caso negativo # => "¿qué está pasando?"
Hay muchas otras funciones que usan expresiones regulares; Si estás interesado, echa un vistazo String # scan y Cadena # división, para principiantes.
Eso es expresiones regulares en Ruby para ti. Si tiene alguna pregunta, escuchémosla en los comentarios..
