Ranges

In Ruby, a Range is a class that represents a set of values defined by a starting value and an ending value. Typically a range is defined using integers, but it may also be defined using other ordered values such as floating-point numbers or characters. Values can be negative, though you should be careful that your starting value is lower than your ending value!

Here are a few examples:

ranges.rb

a = (1..10)
b = (-10..-1)
c = (-10..10)
d = ('a'..'z')

You can also specify ranges using three dots instead of two; this creates a range that omits the final value:

d = ('a'..'z')         # this two-dot range = 'a'..'z'
e = ('a'...'z')        # this three-dot range = 'a'..'y'

You can create an array of the values defined by a range using the to_a method, like this:

(1..10).to_a

Note that to_a is not defined for floating-point numbers for the simple reason that the number of possible values between two floating-point numbers is not finite.

Ranges of Strings

You can even create ranges of strings—though you would need to take great care in so doing because you might end up with more than you bargain for. For example, see whether you can figure out which values are specified by this range:

str_range.rb

str_range = ('abc'..'def')

At first sight, the range from 'abc' to 'def' might not look like much. In fact, this defines a range of no less than 2,110 values! They are ordered like this: abc, abd, abe, and so on, until the end of the as; then you start on the bs: baa, bab, bac, and so on. Suffice to say that ranges of this sort are probably rather a rare requirement and are best used with extreme caution or not at all.

Iterating with a Range

You may use a range to iterate from a start value to an end value. For example, here is one way of printing all the numbers from 1 to 10:

for_to.rb

for i in (1..10) do
    puts( i )
end

Digging Deeper

Here you will learn how to create and iterate over ranges, write multiline strings with heredocs, and define your own string delimiters.

Heredocs

Although you can write long strings spanning multiple lines between single or double quotes, many Ruby programmers prefer to use an alternative type of string called a heredoc. A heredoc is a block of text that starts by specifying an end marker, which is simply an identifier of your choice. Here, I specify EODOC as the end marker:

heredoc.rb

hdoc1 = <<EODOC

This tells Ruby that everything following the previous line is a single string that terminates when the end marker is located. The string is assigned to the variable, hdoc1. Here is an example of a complete heredoc assignment:

hdoc1 = <<EODOC
I wandered lonely as a #{"cloud".upcase},
That floats on high o'er vale and hill...
EODOC

By default, heredocs are treated as double-quoted strings, so expressions such as #{"cloud".upcase} will be evaluated. If you want a heredoc to be treated as single-quoted string, specify its end marker between single quotes:

hdoc2 = <<'EODOC'
I wandered lonely as a #{"cloud".upcase},
That floats on high o'er vale and hill...
EODOC

The end marker of a heredoc must, by default, be placed flush with the left margin. If you want to indent it, you should use <<- rather than << when assigning the end marker:

hdoc3 = <<-EODOC
I wandered lonely as a #{"cloud".upcase},
That floats on high o'er vale and hill...
    EODOC

It is up to you to pick an appropriate end marker. It is even legitimate (though, perhaps, not particularly sensible!) to use a reserved word:

hdoc4 = <<def
I wandered lonely as a #{"cloud".upcase},
That floats on high o'er vale and hill...
def

A variable to which a heredoc is assigned can be used just like any other string variable:

puts( hdoc1 )

String Literals

As explained earlier in this chapter, you can optionally delimit strings by %q/ and / for single-quoted strings and either %Q/ and / or %/ and / for double-quoted strings.

Ruby provides similar means of delimiting back-quoted strings, regular expressions, symbols, and arrays of either single-quoted or double-quoted strings. The ability to define arrays of strings in this way is particularly useful since it avoids the necessity of entering string delimiters for each item. Here is a reference to these string literal delimiters:

%q/    /    # single-quoted
%Q/    /    # double-quoted
%/     /    # double-quoted
%w/    /    # array
%W/    /    # array double-quoted
%r|    |    # regular expression
%s/    /    # symbol
%x/    /    # operating system command

Note that you may choose which delimiters to use. I have used / except with the regular expression where I have used | (since / is the “normal” regular expression delimiter), but I could equally have used square brackets, asterisks, ampersands, or other symbols (for example, %W*dog cat #{1+2}* or %s&dog&). Here is an example of these literals in use:

literals.rb

p %q/dog cat #{1+2}/        #=> "dog cat #{1+2}"
p %Q/dog cat #{1+2}/        #=> "dog cat 3"
p %/dog cat #{1+2}/         #=> "dog cat 3"
p %w/dog cat #{1+2}/        #=> ["dog", "cat", "#{1+2}"]
p %W/dog cat #{1+2}/        #=> ["dog", "cat", "3"]
p %r|^[a-z]*$|              #=> /^[a-z]*$/
p %s/dog/                   #=> :dog
p %x/vol/                   #=> " Volume in drive C is OS [etc...]"
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.116.62.168