Regular expression where pattern is repeated Ruby On rails - ruby-on-rails

Question

I have the following regular expression
/^[a-zA-z]+\s{0,1}$/
I use this regular expression to validate a string like "hello "
but what's up if the same format is repeated again and again
example
"hello How are you "
I don't want to write it
/^[a-zA-z]+\s{0,1}[a-zA-z]\s{0,1}[a-zA-z]\s{0,1}[a-zA-z]\s{0,1}$/
It's too long
Help me!

Answer 1

pattern = "[a-zA-z]+\s{0,1}"
expression = /^#{pattern}#{pattern}#{pattern}#{pattern}$/
However, a better approach would be to use a better regular expression, or define the regexp to allow that specific pattern to be contained more than once.
For instance
/^([a-zA-z]+\s{0,1}){4}$/
Moreover, I guess you can probably reduce the complexity of the expression if you use some better classes and matchers.
/^[a-zA-z]+\s{0,1}$/
is equivalent to
/^[[:alpha]]+\s?$/
therefore
/^([[:alpha]]+\s?){4}$/
to match an unlimited number of words (from N to unlimited)
/^([[:alpha]]+\s?){N,}$/
or use + to match one ore more.
/^([[:alpha]]+\s?)+$/

Answer 2

If what you're after is simply a bunch of letters separated by 0 or 1 space, your pattern can be drastically simplified:
/([a-z]+\s?)+/i
So, working in-to-out,
[a-z] matches characters in the range a-z
+ is a quantifier matching "1 or more" times, so [a-z]+ matches "1 or more letters"
\s? - ? is a quantifier meaning "0 or 1", the same as {0,1}, so "0 or 1 space"
([a-z]+\s?) groups that sub-expression and...
+ is a quantifier matching "1 or more" times.
/i makes the entire thing case-insensitive, so no need for [A-Za-z]. Just [a-z].
Of course, you'll want to anchor the entire thing:
/^([a-z]+\s?)+$/i

Answer 3

#SimoneCarletti recommended using /^([:alpha]+\s?)+$/, which is using a capturing group ([:alpha]+\s?). On a long string this isn't as efficient as a non-capturing group:
(?:[[:alpha:]]+\s?)
The difference happens deep down, where the first has to remember where each match was found, consuming space and time. Non-capturing just remembers that they were found which is faster.
require 'fruity'
text = 'Lorem ipsum dolor sit amet consectetur adipisicing elit Amet platonem fastidii fieri historiae populo mutans fortasse misisti quoddam recta contentus odia bona confidere magis negant caecilii theophrastus necessariam lucilius acuti nobis viris puerilis deorsum aliquid Atilii industriae sitne ipsi improborum levis mel affectus scientiam disciplinam disciplinam repellat Odioque suam graeca intereant potiora Iracundiae docui triarium triari neque assentiar maiorem ornateque futuros fruentem orestem forensibus teneam sciscat postremo animus fortibus videntur e video probant eas delectet molestia docere dictum Unde existimo tota labefactant Forensibus deterret autem putat remissius tollatur credo allicit duo accuratius magnus finxerat effecerit facillime Pertineant concederetur placet habendus'
compare do
regex1 { text[/^([[:alpha:]]+\s?)+$/] }
regex2 { text[/^(?:[[:alpha:]]+\s?)+$/] }
end
# >> Running each test 128 times. Test will take about 1 second.
# >> regex2 is faster than regex1 by 19.999999999999996% ± 10.0%
Also, the "POSIX bracket expressions" for the "alpha" character-class should be [[:alpha:]].

Answer 4

If you'd like to repeat the pattern your matching for, you can wrap it in parentheses (which groups them together), and then use a repetition meta-character to set how many repeats you'd like.
In this case, if you're looking to match if a particular string is found one or more times, you can use the following:
/^([a-zA-z]+\s{0,1})+$/
Here, we're using the + repetition meta-character, which means "this must match one or more times."
As an aside, the {0,1} you're using to match the whitespace 0 or 1 times, can be replaced by at ?, which also means "match this 0 or 1 times."
So, this could turn into:
/^([a-zA-z]+\s?)+$/
You can also do a case-insensitive match by adding the ignore case option (i) at the end of your regex, like so:
/^([a-z]+\s?)+$/i
Hope this helps.