Why does using a regex and .scan produce these results?

>> "aaaaaafbfbfsjjseew".scan(/(.)/)
=> [["a"], ["a"], ["a"], ["a"], ["a"], ["a"], ["f"], ["b"], ["f"], ["b"], ["f"], ["s"], ["j"], ["j"], ["s"], ["e"], ["e"], ["w"]]


>> "aaaaaafbfbfsjjseew".scan(/((.))/)
=> [["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["f", "f"], ["b", "b"], ["f", "f"], ["b", "b"], ["f", "f"], ["s", "s"], ["j", "j"], ["j", "j"], ["s", "s"], ["e", "e"], ["e", "e"], ["w", "w"]]

>> "aaaaaafb开发者_如何学Gofbfsjjseew".scan(/((.)\2*)/)
=> [["aaaaaa", "a"], ["f", "f"], ["b", "b"], ["f", "f"], ["b", "b"], ["f", "f"], ["s", "s"], ["jj", "j"], ["s", "s"], ["ee", "e"], ["w", "w"]]


>> "aaaaaafbfbfsjjseew".scan(/((.)\1*)/)
=> [["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["f", "f"], ["b", "b"], ["f", "f"], ["b", "b"], ["f", "f"], ["s", "s"], ["j", "j"], ["j", "j"], ["s", "s"], ["e", "e"], ["e", "e"], ["w", "w"]]

>> "aaaaaafbfbfsjjseew".scan(/((.)\3*)/)
=> [["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["a", "a"], ["f", "f"], ["b", "b"], ["f", "f"], ["b", "b"], ["f", "f"], ["s", "s"], ["j", "j"], ["j", "j"], ["s", "s"], ["e", "e"], ["e", "e"], ["w", "w"]]

From the fine manual:

str.scan(pattern) → array
[...]
If the pattern contains groups, each individual result is itself an array containing one entry per group.

This one:

"aaaaaafbfbfsjjseew".scan(/(.)/)

has a group so you get an array of arrays: each individual result is a single element array.

The next one:

"aaaaaafbfbfsjjseew".scan(/((.))/)

has two groups which happen to have the same value so you get two identical elements in your individual result arrays.

The third one:

"aaaaaafbfbfsjjseew".scan(/((.)\2*)/)

again contains two groups but also contains a back-reference to the inner group so the outer group (AKA the first group) gobbles up duplicates and you get ["aaaaaa", "a"], ["jj", "j"], and ["ee", "e"].

The fourth one:

"aaaaaafbfbfsjjseew".scan(/((.)\1*)/)

just tries to switch the back-reference to the outer group but \1 isn't defined inside group 1 so it is equivalent to /((.))/.

The fifth one:

"aaaaaafbfbfsjjseew".scan(/((.)\3*)/)

tries to refer to a non-existant group (group 3 when there are only two groups) so it behaves the same as /((.))/.

"aaaaaafbfbfsjjseew".scan(/(.)/) means the string can be splitted into individual array of strings.

Here parenthesis tells that it's an array, and the .-symbol in parenthesis represents number of characters in that individual string of array.

If we write for suppose "hellovenkat".scan(/(...)/) , this results [["hel"],["lov"],["enk"]]. It doesn't give the last index, because it can not contain three characters.

If we give "hello venkat".scan(/(...)/), this results as following. Ans: [["hel"], ["lo "], ["ven"], ["kat"]].