为什么Ruby会返回`str [-1..1]`它的作用是什么？

Question

Suppose we have a string str . If str contains only one character, for example, str = "1" , then str[-1..1] returns 1 .
But if the size ( length ) of str is longer than one, like str = "anything else" , then str[-1..1] returns "" (empty string).

Why does Ruby interpret string slicing like this?

Answer 1

This behaviour is just how ranges of characters work.

The range start is -1, which is the last character in the string. The range end is 1, which is the second position from the start.

So for a one character string, this is equivalent to 0..1, which is that single character.

For a two character string, this is 1..1, which is the second character.

For a three character string, this is 2..1, which is an empty string. And so on for longer strings.

Answer 2

To get a non-trivial substring, the start position has to represent a position earlier than the end position.

For a single-length string, index -1 is the same as index 0 , which is smaller than 1 . Thus, [-1..1] gives a non-trivial substring.

For a string longer than a single character, index -1 is larger than index 0 . Thus, [-1..1] cannot give a non-trivial substring, and by default, it returns an empty string.

Answer 3

Writing down the indices usually helps me:

#      0   1   2   3   4   5   6   7   8   9   10  11  12
str = 'a' 'n' 'y' 't' 'h' 'i' 'n' 'g' ' ' 'e' 'l' 's' 'e' #=> "anything else"
#     -13 -12 -11 -10 -9  -8  -7  -6  -5  -4  -3  -2  -1

You can refer to each character by either its positive or negative index. For example, you can use either 3 or -10 to refer to "t" :

str[3]   #=> "t"
str[-10] #=> "t"

and either 7 or -6 to refer to "g" :

str[7]  #=> "g"
str[-6] #=> "g"

Likewise, you can use each of these indices to retrieve "thing" via a range:

str[3..7]    #=> "thing"
str[3..-6]   #=> "thing"
str[-10..7]  #=> "thing"
str[-10..-6] #=> "thing"

str[-1..1] however would return an empty string, because -1 refers to the last character and 1 refers to the second. It would be equivalent to str[12..1] .

But if the string consists of a single character, that range becomes valid:

#      0
str = '1'
#     -1

str[-1..1] #=> "1"

In fact, 1 refers to an index after the first character, so 0 would be enough:

str[-1..0] #=> "1"