2.3 ruby的数据类型--字符串(String)、区间(Range)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/shine_a/article/details/85058593

1、字符串（String）

字符串是String类的对象。分为单引号字符串和双引号字符串。双引号字符串能支持较多的转义字符以及支持字符串#{}q嵌入变量。实际开发中多用双引号字符串。

（1）字符串嵌入变量用#{ }，这个是ruby特有的，经常使用的一个功能。只支持双引号的字符串。

irb(main):013:0> name = "Mary"
=> "Mary"
irb(main):014:0> puts "你好，我是#{name}"
你好，我是Mary

#{ }里面不仅可以放变量，还可以放表达式。输出结果会显示表达式的结果

irb(main):016:0> x = 1
=> 1
irb(main):017:0> y = 2
=> 2
irb(main):018:0> puts "x加y等于#{x+y}"
x加y等于3

2、类型转换

（1）数字转字符串：to_s

irb(main):019:0> 1.2.to_s
=> "1.2"

（2）字符串转整型：to_i，只会保留字符串里面数字的整数部分

irb(main):021:0> "1.2".to_i
=> 1
irb(main):022:0> "1.2你好，世界".to_i
=> 1

（3）字符串转浮点型：to_f，如果字符串的开头为数字，则转换后的值为字符串开头的数字。如果字符串的开头不是数字，则转换后的值为0.0

irb(main):023:0> "1.2".to_f
=> 1.2
irb(main):024:0> "1.2abc5.6".to_f
=> 1.2
irb(main):025:0> "abc5.6".to_f
=> 0.0

（4）字符串转分子式：to_r

irb(main):026:0> "200/2".to_r
=> (100/1)
irb(main):027:0> "1.2".to_r
=> (6/5)
irb(main):028:0> "12345".to_r
=> (12345/1)
irb(main):029:0> "-9.2e2".to_r
=> (-920/1)

（5）字符串转符号：to_sym。符号也是ruby数据类型的一种，后面会单独介绍

irb(main):030:0> "hello".to_sym
=> :hello

3、操作字符串

（1）str % arg 格式化输出。

不同类型占位符如下所示：

占位符	代表类型
%d	整数
%f	浮点数
%s	字符串

irb(main):041:0> age = 22
=> 22
irb(main):042:0> name = "Mary"
=> "Mary"
irb(main):043:0> salary = "8000.78"
=> "8000.787"
#%s给name字符串占位，%d给age整数占位，%f给salary浮点数占位
irb(main):044:0> puts "my name is %s, my age is %d, my salary is %f" % [name,age,salary]
=>my name is Mary, my age is 22, my salary is 8000.787000

当然如果仅仅是将变量显示在字符串里面的话，咱们还是用字符串内嵌#{}功能比较好，但是我们想要将这些变量进行一些处理再显示，用占位符就比较方便了。比如想要在name后面加7个空格，age前面加5个空格，salary保留两位小数，可以像下面这样写

puts "my name is %-7s, my age is %5d, my salary is %.2f" % [name,age,salary]
=>my name is Mary   , my age is    22, my salary is 8000.78

占位符比较常用的功能就是限制数字的小数位数，在项目中会经常用到

irb(main):049:0> num = 12345.678
=> 12345.678
irb(main):050:0> "%.1f" % num
=> "12345.7"

（2）str * num 字符串乘以一个整数，会得到num个str

irb(main):052:0> "str"*3
=> "strstrstr"
irb(main):053:0> "str"*0
=> ""

（3）str + str1 两个字符串相加，相当于拼接两个字符串。

值得注意的是，如果要拼接数字的话，需要将数字转换成字符串（to_s方法），再做拼接

irb(main):057:0> age = 22
=> 22
irb(main):058:0> name = "Mary"
=> "Mary"
irb(main):059:0> puts "I am " + name + " my age is " + age.to_s
I am Mary my age is 22

（4）== 判断两个字符串是否相等，相等返回true，否则返回false

（5）str.length 获取字符串的长度。中文字符的长度和英文字符一样，都是1。

irb(main):060:0> "Hello".length
=> 5
irb(main):061:0> "我爱我家".length
=> 4

（6）通过索引截取字符串，索引从0开始

• str[n] 取索引数为n的字符，索引从0开始数
• str[n, length] 从索引数为n的字符开始，取length个字符
• str[start…end] 取索引数为start到end之间的值，包含索引为end的字符，涉及到范围（Range）知识点，先了解，后面会讲
• str[start…end] 取索引数为start到end之间的值，不包含索引为end的字符

irb(main):062:0> str = "HelloWorld"
=> "HelloWorld"
#索引0，代表第一个字符，为H
irb(main):063:0> str[0]
=> "H"
irb(main):064:0> str[1]
=> "e"
#从索引为2的字符开始（即第3个字符），取3个字符
irb(main):066:0> str[2,5]
=> "lloWo"
#从索引为2的字符开始，到索引为5的字符，包含索引为5的字符
irb(main):067:0> str[2..5]
=> "lloW"
#从索引为2的字符开始，到索引为5的字符，不包含索引为5的字符
irb(main):068:0> str[2...5]
=> "llo"

（7）str.capitalize和 str.capitalize! 将str的第一个字符转换成大写，其他字符转换成小写。

capitalize和capitalize!的区别是：
capitalize不改变str的值，只是返回值为首字母为大写的字符
capitalize!会改变str的值，并且返回首字母为大写的字符

irb(main):069:0> a = "HELLO"
=> "HELLO"
irb(main):070:0> a.capitalize
=> "Hello"
irb(main):071:0> a
#a还是原先的值
=> "HELLO"
irb(main):072:0> a.capitalize!
=> "Hello"
irb(main):073:0> a
#a的值已经改变了
=> "Hello"

（8）str.chars 返回组成str的字符的数组形式

irb(main):074:0> "Hello".chars
=> ["H", "e", "l", "l", "o"]

（9）str.delete(str1,…) 删除掉str和str1相同的部分。如果括号里面有多个参数，则这多个参数的交集会被删除。delete!和delete之间的区别和前面一样，方法后面加叹号，会改变字符串本身。

irb(main):075:0> "Hello".delete("l")
=> "Heo"
#"l"和"H"没有交集的部分，所以不会删除任何字符
irb(main):076:0> "Hello".delete("l","H")
=> "Hello"
#"Hl","He"的交集部分为"H",所以会删掉"H"字符
irb(main):077:0> "Hello".delete("Hl","He")
=> "ello"

（10）str.downcase 将str的字符全部转换为小写

（11）str.upcase 将str的字符全部转换为大写

irb(main):081:0> str = "HEllo"
=> "HEllo"
irb(main):082:0> str.downcase
=> "hello"
irb(main):083:0> str.upcase
=> "HELLO"

（12）str.end_with?(str1,…) 判断str是否以str1等参数中的任意一个结尾，是的话，返回true，否则的话为false

（13）str.start_with?(str1,…),判断str是否以str1等参数中的任意一个开头，是的话，返回true，否则的话为false

irb(main):084:0> "Hello".end_with?("llo")
=> true
irb(main):085:0> "Hello".end_with?("Horizon","llo")
=> true
irb(main):086:0> "Hello".start_with?("Hel")
=> true
irb(main):087:0> "Hello".start_with?("el","lo")
=> false

（14）str.gsub(a,b)，将str中的a用b代替。a可以是正则表达式，正则表达式我们之后会讲

irb(main):088:0> "HelloWorld".gsub("l","o")
=> "HeoooWorod"

（15）str.include?(str1) 判断str中是否包含str1，包含的话，返回true，不包含的话，返回false

=> "Hello,my name is Mary"
irb(main):090:0> str.include?("hel")
=> false
irb(main):091:0> str.include?("Hel")
=> true

（16）str.index(a) 返回str中a字符的索引位置，如果str中有多个a字符，则返回第一个字符所在的位置。如果str中没有a字符，返回nil

irb(main):093:0> "Hello".index("o")
=> 4
irb(main):094:0> "Hello".index("2")
=> nil

（17）strip去除字符串两侧空格

• strip、strip! 将字符串左右两侧空格去掉，不会去掉字符串中间的空格
• lstrip、lstrip! 将字符串左两侧空格去掉
• rstrip、rstrip! 将字符串右两侧空格去掉

irb(main):097:0> str.strip
=> "h  e llo"
irb(main):098:0> str.lstrip
=> "h  e llo       "
irb(main):099:0> str.rstrip
=> "       h  e llo"

（18）str.split 分割字符串

irb(main):100:0> str = "Hello My name is Mary"
=> "Hello My name is Mary"
irb(main):101:0> str.split(" ")
=> ["Hello", "My", "name", "is", "Mary"]
#split后面没有参数，等同于str.split(" ")
irb(main):102:0> str.split
=> ["Hello", "My", "name", "is", "Mary"]
#split后面括号里面第2个参数，代表将str根据第一个参数分割，分割成长度为2的数组
irb(main):103:0> str.split(" ",2)
=> ["Hello", "My name is Mary"]
irb(main):104:0> str.split(" ",3)
=> ["Hello", "My", "name is Mary"]

（19）str.upto(str1) str到str1之间的数值，包括str和str1

系统会将str.upto(str1)储存为Enumerator（迭代器）对象，可以使用to_a将Enumerator对象转换成数组形式

irb(main):106:0> str_upto = "a".upto "f"
=> #<Enumerator: "a":upto("f")>
irb(main):107:0> str_upto.class
=> Enumerator
irb(main):108:0> str_upto.to_a
=> ["a", "b", "c", "d", "e", "f"]

“a”.upto(“f”)的功能和"a"…"f"是一样的
不过前者是Enumerator（迭代器）对象，后者是Range对象，也可以使用to_a将Range对象转换成数组形式

irb(main):109:0> str_range = "a".."f"
=> "a".."f"
irb(main):110:0> str_range.class
=> Range
irb(main):111:0> str_range.to_a
=> ["a", "b", "c", "d", "e", "f"]

（20）str.blank? 判断字符串是否为空或者nil？

blank?、empty?、nil?的区别：
nil? 判断对象是否为nil
empty？判断是否为空字段，空格不属于空字段
blank? 最常用，字符串为""、" "、nil均被判断为true，其他的为false，可认为是nil?和empty?的结合

irb(main):002:0> a = ""
=> ""
irb(main):003:0> a.nil?
=> false
irb(main):004:0> a.empty?
=> true
irb(main):005:0> a.blank?
=> true
irb(main):006:0> b = "  "
=> " "
irb(main):007:0> b.nil?
=> false
irb(main):008:0> b.empty?
=> false
irb(main):009:0> b.blank?
=> true

4、区间（Range）

区间分为两种：
一种是闭合区间（包含右边的值），就是上面讲的"a"…“f”
一种是半闭半开区间（不包括右边的值），比如"a"…“f”

irb(main):009:0> ("a".."f").to_a
=> ["a", "b", "c", "d", "e", "f"]
irb(main):010:0> ("a"..."f").to_a
=> ["a", "b", "c", "d", "e"]

区间经常会与块结合使用，后面我们讲块的时候会讲到。