Prev | Contents | Next

| Ruby user's guide | Strings |

Ruby deals with strings as well as numerical data. A string may be double-quoted ("...") or single-quoted ('...').

    ruby> "abc"
       "abc"
    ruby> 'abc'
       "abc"

Double- and single-quoting have different effects in some cases. A double-quoted string allows character escapes by a leading backslash, and the evaluation of embedded expressions using `#{}`. A single-quoted string does not do this interpreting; what you see is what you get. Examples:

    ruby> print "a\nb\nc","\n"
    a
    b
    c
       nil
    ruby> print 'a\nb\n',"\n"
    a\nb\nc
       nil
    ruby> "\n"
       "\n"
    ruby> '\n'
       "\\n"
    ruby> "\001"
       "\001"
    ruby> '\001'
       "\\001"
    ruby> "abcd #{5*3} efg"
       "abcd 15 efg"
    ruby> var = " abc "
       " abc "
    ruby> "1234#{var}5678"
       "1234 abc 5678"

Ruby's string handling is smarter and more intuitive than C's. For instance, you can concatenate strings with `+`, and repeat a string many times with `*`:

    ruby> "foo" + "bar"
       "foobar"
    ruby> "foo" * 2
       "foofoo"

Concatenating strings is much more awkward in C because of the need for explicit memory management:

    char *s = malloc(strlen(s1)+strlen(s2)+1);
    strcpy(s, s1);
    strcat(s, s2);
    /* ... */
    free(s);

But using ruby, we do not have to consider the space occupied by a string. We are free from all memory management.

Here are some things you can do with strings.

Concatenation:

    ruby> word = "fo" + "o"
       "foo"

Repetition:

    ruby> word = word * 2
       "foofoo"

Extracting characters (note that characters are integers in ruby):

    ruby> word[0]
       102            # 102 is ASCII code of `f'
    ruby> word[-1]
       111            # 111 is ASCII code of `o'

(Negative indices mean offsets from the end of a string, rather than the beginning.)

Extracting substrings:

    ruby> herb = "parsley"
       "parsley"
    ruby> herb[0,1]
       "p"
    ruby> herb[-2,2]
       "ey"
    ruby> herb[0..3]
       "pars"
    ruby> herb[-5..-2]
       "rsle"

Testing for equality:

    ruby> "foo" == "foo"
       true
    ruby> "foo" == "bar"
       false

Note: In ruby 1.0, results of the above are reported in uppercase, e.g. `TRUE`.

Now, let's put some of these features to use. This puzzle is "guess the word," but perhaps the word "puzzle" is too dignified for what is to follow `;-)`

    # save this as guess.rb
    words = ['foobar', 'baz', 'quux']
    secret = words[rand(3)]

    print "guess? "
    while guess = STDIN.gets
      guess.chop!
      if guess == secret
        print "You win!\n"
        break
      else
        print "Sorry, you lose.\n"
      end
      print "guess? "
    end
    print "The word was ", secret, ".\n"

For now, don't worry too much about the details of this code. Here is what a run of the puzzle program looks like.

    % ruby guess.rb
    guess? foobar
    Sorry, you lose.
    guess? quux
    Sorry, you lose.
    guess? ^D
    The word was baz.

(I should have done a bit better, considering the 1/3 probability of success.)

Prev | Contents | Next