• 字符串
  • save this as guess.rb
    • 保存为guess.rb

    字符串

    Strings

    字符串

    Ruby deals with strings as well as numerical data. A string may be double-quoted (“…”) or single-quoted (‘…’).

    Ruby处理字符串就同处理数值数据一样优秀。定义字符串可以用双引号或者单引号。

    1. ruby> "abc"
    2.    "abc"
    3. ruby> 'abc'
    4.    "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:

    在某些场景中，双引号和单引号会产生不同的结果。双引号字符串允许通过反斜线对字符进行转义，以及对使用#{}嵌入的表达式进行求值。单引号字符串则不对这些进行解释，你所看到的便是其最终的结果。比如：

    1. ruby> puts "a\nb\nc"
    2. a
    3. b
    4. c
    5.    nil
    1. ruby> puts 'a\nb\n'
    2. a\nb\nc
    3.    nil
    1. ruby> "\n"
    2.    "\n"
    1. ruby> '\n'
    2.    "\\n"
    1. ruby> "\001"
    2.    "\t"
    1. ruby> '\001'
    2.    "\001"
    1. ruby> "abcd #{5*3} efg"
    2.    "abcd 15 efg"
    1. ruby> var = " abc "
    2.    " abc "
    1. ruby> "1234#{var}5678"
    2.    "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的字符串处理比C语言更智能，更直观。举个例子，你可以使用+把字符串连接起来，或者使用*将字符串重复多次。

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

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

    在C语言中连接字符串要显得更笨拙，因为它需要显式地进行内存管理：

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

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

    但是如果使用的是Ruby，我们则不需要考虑字符串占用的空间，由此从所有的内存管理工作中解放出来。

    Here are some things you can do with strings.

    这里有一些你可以用字符串完成的事情。

    Concatenation:

    连接：

    1. ruby> word = "fo" + "o"
    2.    "foo"

    Repetition:

    重复：

    1. ruby> word = word * 2
    2.    "foofoo"

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

    取出字符(注意在Ruby中字符是整数)：

    1. ruby> word[0]
    2.    102            # 102是`f'的ASCII码 
    3. ruby> word[-1]
    4.    111            # 111是`o'的ASCII码

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

    (负数的索引则表示从字符串末尾开始计算的偏移量，而不是从头开始计算。)

    Extracting substrings:

    取出子字符串：

    1. ruby> herb = "parsley"
    2.    "parsley"
    3. ruby> herb[0,1]
    4.    "p"
    5. ruby> herb[-2,2]
    6.    "ey"
    7. ruby> herb[0..3]
    8.    "pars"
    9. ruby> herb[-5..-2]
    10.    "rsle"
    11. Testing for equality:
    13. ruby> "foo" == "foo"
    14.    true
    15. ruby> "foo" == "bar"
    16.    false

    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

    保存为guess.rb

    1. words = ['foobar', 'baz', 'quux']
    2. secret = words[rand(3)]
    4. print "guess? "
    5. while guess = STDIN.gets
    6.   guess.chop!
    7.   if guess == secret
    8.     puts "You win!"
    9.     break
    10.   else
    11.     puts "Sorry, you lose."
    12.   end
    13.   print "guess? "
    14. end
    15. puts "The word was ", secret, "."

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

    现在，不要太担心这段代码的细节。下面是这个谜题程序的运行情况。

    1. ruby guess.rb
    2. guess? foobar
    3. Sorry, you lose.
    4. guess? quux
    5. Sorry, you lose.
    6. guess? ^D
    7. The word was baz.

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

    (考虑到1/3的成功概率，我应该可以做得更好一些。)

    上一章 简单示例
    下一章 正则表达式