Ruby笔记（一）

上一篇 / 下一篇 2009-02-04 17:23:11 / 个人分类：其他

2009年2月04日3:49下午
一、模块（Module）的作用：
1.可以被其它程序代码重复使用;
2.提供了一个命名空间（namespace），防止命名冲突；
3.实现了类似多重继承的功能；

二）Include和Extend
include 方法为一个类的所有对象包含某个模块； extend 方法为一个类的某个对象包含某个模块。
（1）#E include 方法为一个类的所有对象包含某个模块。
module Me
    def sqrt(num, rx=1, e=1e-10)
        num*=1.0
        (num - rx*rx).abs <e ? rx : sqrt(num, (num/rx + rx)/2, e)
    end
end

class Person
    def talk
        puts "I'm talking."
    end
end

class Student < Person
    include Me
end

aStudent=Student.new
aStudent.talk # I'm talking.
puts aStudent.sqrt(20.7,3.3) # 4.54972526643248

（2）#E extend 方法为一个类的某个对象包含某个模块。
module Me
    def sqrt(num, rx=1, e=1e-10)
        num*=1.0
        (num - rx*rx).abs <e ? rx : sqrt(num, (num/rx + rx)/2, e)
    end
end

class Student
end

aStudent=Student.new
aStudent.extend(Me)
puts aStudent.sqrt(93.1, 25) # 9.64883412646315

二)Require和Load
1.require包含文件，只加载一次，遇到同一文件时自动忽略；不同路径下的同名文件会多次加载。
2.load包含文件，加载多次，即使是相同路径下同一文件。

NB：
1）require，load用于包含文件；include，extend则用于包含模块。
2）require加载文件一次，load加载文件多次。
3）require加载文件时可以不加后缀名，load加载文件时必须加后缀名。
4）require一般情况下用于加载库文件，而load用于加载配置文件。

二、数组
1.Ruby中，同一个数组中的元素可以是不同类型的，如arr[]=["3","2.5","This is a string"]
2.Ruby以整数作为下标，访问数组元素通过数组下标,第一个数组元素的下标为0，最大的数组下标为数组元素个数减一。当数组下标为负值时表示从数组最后向前读取第几位。如：
#数组赋值
arr=[3,4,5,6,7,8,9]

#下面两条代码都是读取第一个数组元素值
puts arr[0]                    #3
puts arr.first                     #3

#下面四条代码都是读取最后一个数组元素值
puts arr[arr.length-1]        #9
puts arr[arr.size-1]            #9
puts arr.last                #9
puts arr[-1]                #9

#倒数第二个元素的值
puts arr[-2]                 #8

#第二个到第四个元素的值
print arr[1..3] ,"\n"           #456

#第二个到第四个元素且不含第四个元素的的值
print arr[1...3] ,"\n"          #45

#从倒数第三个元素开始取值，且自该元素起始向后取两个元素的值，注意含该元素
print arr[-3,2] ,"\n"           #78

3.Ruby的数组大小可以动态变化，可以随时增删数组元素。

# 数组输出，赋值及增删、插入
arr=[4,5,6]
print arr.join(", "),"\n"         #4, 5, 6（将数组arr转换成字符串输出，用", "隔开每个元素，并且换行。）
arr[4] = "m"                 #把4号索引位置元素赋值为"m"
print arr.join(", "),"\n"         #4, 5, 6, , m
print arr[3] ,"\n"              #打印3号索引位置元素 #nil
arr.delete_at(3)               #删除3号索引位置元素
print arr.join(", "),"\n"         #4, 5, 6, m
arr[2] = ["a","b","c"]          #把2号索引位置元素赋值为["a","b","c"]
print arr.join(", "),"\n"         #4, 5, a, b, c, m
print arr[2] ,"\n"              #打印2号索引位置元素 #abc
arr[0..1] = [7,"h","b"]          #把0..1号元素替换为7,"h","b"__这里有点迷惑
print arr.join(", "),"\n"         #7, h, b, a, b, c, m
arr.push("b" )                #加入元素"b"
print arr.join(", "),"\n"         #7, h, b, a, b, c, m, b
arr.delete(["a","b","c"] )        #删除元素["a","b","c"]
print arr.join(", "),"\n"         #7, h, b, m, b
arr.delete("b")               #删除所有元素"b"——所有值为“b”的元素都删除
print arr.join(", "),"\n"         #7, h, m
arr.insert(3,"d")              #在3号索引位置插入元素"d"
print arr.join(", "),"\n"         #7, h, m, d
arr<<"f"<<2                 #加入元素"f"；加入元素2
print arr.join(", "),"\n"         #7, h, m, d, f, 2
arr.pop                     #删除尾元素
print arr.join(", "),"\n"         #7, h, m, d, f
arr.shift                    #删除首元素
print arr.join(", "),"\n"         #h, m, d, f
arr.clear                    #清空数组arr
print arr.join(", "),"\n"         #

4.数组运算
#定义两个数组，并赋值
aaaa=[" aa ",4,5," bb "]
bbbb=[4,1,3,2,5]
print aaaa + bbbb ,"\n"         # aa 45 bb 41325

print aaaa * 2 ,"\n"            # aa 45 bb aa 45 bb
print bbbb - aaaa ,"\n"         #132

#并运算；交运算
print aaaa | bbbb ,"\n"          # aa 45 bb 132
print aaaa & bbbb ,"\n"         #45

#排序；倒置
print bbbb.sort ,"\n"            #12345
print aaaa.reverse ,"\n"         # bb 54 aa

三、字符串
1.字符串是String类的对象，一般使用字面值来创建。
2.%q 用来生成单引号字符串；%Q用来生成双引号字符串。%q或者%Q后面跟着的是分隔符，可以是配对的! !； / /； < >； ( )； [ ] ；{ }；等等。
3.一个数组可以用join 方法转换成字符串，join( ) 内的参数也是一个字符串，用来分隔数组的每个元素，例如：arr.join(", ")。
4.转义字符：
（1）当“'”这类的字符在输出的字符串中时，需要进行转义，既可以使用“\'”将其输出。
（2）在双引号扩起来的字符串中，不仅可以使用各种转义符，而且可以放置任意的Ruby表达式在 #{ } 之中，这些表达式在使用这个字符串的时候被计算出值，然后放入字符串。
（3）其他
\t    Tab
\n    换行
5.需要注意的是，字符串的索引位置和数组一致，起始索引位置为 0.
6.示例：
str1 = 'this is str1'
str2 = "this is str2"
str3 = %q/this is str3/
str4 = %Q/this is str4/
#str5是一个字符串文档，从 <<和文档结束符的下一行开始，
#直到遇到一个放置在行首的文档结束符，结束整个字符串文档。
str5 = <<OK_str
        Here is string document, str5
            line one;
            line two;
            line three.
        OK
    OK_str
puts str3
puts str4
puts str5

str = ' this' + " is"
str += " you"
str << " string" << " ."
puts str*2                 # this is you string . this is you string .表示该内容重复两遍输出。
puts str[-12,12]             #you string .

四、正则表达式
正则表达式(regular expression)描述了一种字符串匹配的模式。
1.创建正则表达式：
（1）构造器显示创建；
（2）字面值形式创建；
（3）正则模式创建；
2.匹配一个正则表达式，用“=~”。返回模式在字符串中被匹配到的位置，否则返回nil。
不匹配一个正则表达式，用“！~”。 “！~”用来断言不符合一个正则表达式,返回 true,flase。
3.字符
特别字符
特别字符                    描述
( )        标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使        用 $ 和 $。
[]        范围描述符 (比如,[a - z] 表示在a 到 z 范围内的一个字母)，要匹配 [，请使用 \[。
{}        标记限定符表达式。要匹配 {，请使用 \{。
\        将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。
        例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配             "("。
|        指明两项之间的一个选择。要匹配 |，请使用 \|。
.        匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。

非打印字符
非打印字符                    描述
\f        匹配一个换页符。等价于 \x0c。
\n        匹配一个换行符。等价于 \x0a。
\r        匹配一个回车符。等价于 \x0d。
\s        匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S        匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t        匹配一个制表符。等价于 \x09。
\w      匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'字母或数字;相当于 [0-9A-Za-z]
\W       匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'非字母,数字
\d        匹配一个数字字符。等价于 [0-9]。 [0-9]数字;相当于 [0-9]
\D        匹配一个非数字字符。等价于 [^0-9]。非数字字符
\b        退格符 (0x08) (仅在范围描述符内部时)

限定符：用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。

* 和 + 会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现最小匹配。

限定符                        描述
*        前面元素出现0或多次。* 等价于{0,}。
         例如，zo* 能匹配 "z" 以及 "zoo"。
。        要匹配 * 字符，请使用 \*。
+        前面元素出现1或多次。+ 等价于 {1,}。
        例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。
        要匹配 + 字符，请使用 \+。
?        前面元素最多出现1次;相当于 {0,1}。
        例如，”do(es)?” 可以匹配 “do” 或 “does” 中的"do" 。
        要匹配 ? 字符，请使用 \?。
{n}      n 是一个非负整数。匹配确定的 n 次。
        例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}     n 是一个非负整数。至少匹配n 次。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
        例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。
{n,m}   m 和 n 均为非负整数，其中n <= m。前面元素最少出现n次,最多出现m次。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
        例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。

定位符用来描述字符串或单词的边界， ^ 和 $ 分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。不能对定位符使用限定符。
定位符                        描述
^        匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
$        匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配'\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
\b        匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的'er'，但不能匹配 "verb" 中的 'er'。
\B        匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'

各种操作符的运算优先级
相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下：
优先级                操作符                描述
高                     \                   转义符
                      (), []                 圆括号和方括号
               *, +, ?, {n}, {n,}, {n,m}        限定符
                      ^, $,                 位置和顺序
低                “或”操作

Ruby笔记（一）

相关阅读:

用户菜单

我的栏目

标题搜索

日历

我的存档

数据统计

RSS订阅