日星网 windows 中文论坛

 找回密码
 加入我们

QQ登录

只需一步,快速开始

查看: 1160|回复: 17

Ruby基础知识

[复制链接]
发表于 2016-2-23 04:27:21 | 显示全部楼层 |阅读模式
 楼主| 发表于 2016-2-23 04:51:52 | 显示全部楼层
制作一个sample.rb文件

1. 输出 -- puts (默认为带换行输出,如果是直接输入,使用 print
  1. puts "hello world"
  2. ruby sample.rb
复制代码


如果想使用UTF-8以外的文字代码
在文件的最上面输入

  1. # coding: gbk
  2. puts "世界你好"
复制代码

 楼主| 发表于 2016-2-23 06:38:16 | 显示全部楼层
2. 变量 -- 变量是指向含有数字或文字等各种对象的容器。

  1. message = "Hello!"
  2. num = 123
复制代码


通常以上都为变量

实例
  1. message = "Hello"
  2. num = 24800
  3. puts message
  4. puts num
复制代码


变量的注意事项
  • 半角英文字符,数字及下划线_
  • 第一个字符必须是半角英文或者是_(原则上可以使用中文,但是不推荐)


变量的种类
变量名 种类
message 普通变量
$message 全局变量
@message 实例变量
@@message 类变量
MESSAGE 常数


变量自身的方法
  1. message = "Hello"
  2. puts message.length #length方法,获得变量的长度
  3. num = 123
  4. num.to_s  #to_s 强制转换成字符串
复制代码



Ruby 一般情况下换行就为文法结束,不过也可以使用 ; 号写在一行
  1. a = 2; b = 3
复制代码


Ruby的注释 #
Ruby的多行注释
#=>返回值的说明方法

  1. =begin
  2. 多好注释开始
  3. 。。。。
  4. =end
复制代码


Ruby没有变量类型
 楼主| 发表于 2016-2-23 07:36:41 | 显示全部楼层
3. 数值和字符串 数值 分为三大类 Fixnum, Bignum, Float ■数值
  1. num = 1234 #Fixnum 整数
  2. big_num = 2 ** 62 #Bignum 非常大的整数
  3. pi = 3.14159 #Float 浮点小数
复制代码
注意 Fixnum的值大到一定范围后会自动转换为Bignum, 整数值与小数值进行计算时,自动转换为Float
  1. a = 5
  2. b = 2
  3. c = 2.0
  4. puts a/b #2
  5. puts a/c #2.5
复制代码
■字符串 --由字符组成的字符集合
  1. hello = "你好"
  2. goodbye = "再见"
  3. puts hello
  4. puts goodbye
复制代码
字符串与字符串之间可以使用 + 进行连接
  1. print "请输入你的姓名:"
  2. name = gets.chomp #gets获得命令行输入的字符串。 chomp去掉字符串行尾的换行符
  3. puts name + "先生您好!"
复制代码
二重引用符 --使用#{}将结果直接引用到字符串中
  1. puts "2乘以3等于#{2*3}" #2乘以3等于6
  2. name = "红宝石"
  3. puts "#{name}先生你好" #红宝石先生你好
复制代码
也可以使用%q, %Q, %进行对""替换
  1. msg = %q/hello/
  2. msg = %Q(hello)
  3. msg = %!hello!
复制代码
数值与字符串的互换 可以使用的方法有 to_s, to_i, to_f
  1. a = 4
  2. b = "6"
  3. puts a.to_s + b #46 to_s将数值转换成字符串
  4. puts a + b.to_i #10 to_i将字符串转换成数值
  5. puts a + b.to_f #10.0 to_f将字符串转换成浮点小数
复制代码
数组
  1. animals = ["dog", "cat", "pig"]
  2. puts animals[0] #dog
  3. animals[1] = "elephant"
  4. puts animals[1] #elephant
复制代码
※数组的追加还可以使用 <<来进行
  1. animals = ["dog", "cat", "pig"]
  2. animals << "elephant"
  3. puts animals.length #4
复制代码
数组%w()记述方法
  1. animals = %w(dog cat pig)
复制代码
可以通过inspect来显示数组
  1. arr = [1,2,3]
  2. puts arr.inspect #[1,2,3]
复制代码
转义字符
反斜杠符号十六进制字符描述
\a0x07报警符
\b0x08退格键
\cx Control-x
\C-x Control-x
\e0x1b转义符
\f0x0c换页符
\M-\C-x Meta-Control-x
\n0x0a换行符
\nnn 八进制表示法,其中 n 的范围为 0.7
\r0x0d回车符
\s0x20空格符
\t0x09制表符
\v0x0b垂直制表符
\x 字符 x
\xnn 十六进制表示法,其中 n 的范围为 0.9、 a.f 或 A.F
 楼主| 发表于 2016-2-24 02:46:06 | 显示全部楼层
4. 运算符

irb的使用方法 在linux或是windows的CMD窗口中输入irb

Ruby 算术运算符
运算符描述实例
+加法 - 把运算符两边的操作数相加 a + b 将得到 30
-减法 - 把左操作数减去右操作数 a - b 将得到 -10
*乘法 - 把运算符两边的操作数相乘 a * b 将得到 200
/除法 - 把左操作数除以右操作数 b / a 将得到 2
%求模 - 把左操作数除以右操作数,返回余数 b % a 将得到 0
**指数 - 执行指数计算 a**b 将得到 10 的 20 次方


  1. a = 6
  2. b = 7
  3. puts a+b #=>13
  4. puts a-b #=>-1
  5. puts a*b #=>42
  6. puts a/b #=>0
  7. puts a%b #=>6
复制代码


Ruby 比较运算符
运算符描述实例
==检查两个操作数的值是否相等,如果相等则条件为真。 (a == b) 不为真。
!=检查两个操作数的值是否相等,如果不相等则条件为真。 (a != b) 为真。
>检查左操作数的值是否大于右操作数的值,如果是则条件为真。 (a > b) 不为真。
<检查左操作数的值是否小于右操作数的值,如果是则条件为真。 (a < b) 为真。
>=检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 (a >= b) 不为真。
<=检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 (a <= b) 为真。
<=>联合比较运算符。如果第一个操作数等于第二个操作数则返回 0,如果第一个操作数大于第二个操作数则返回 1,如果第一个操作数小于第二个操作数则返回 -1。 (a <=> b) 返回 -1。
===用于测试 case 语句的 when 子句内的相等。 (1...10) === 5 返回 true。
.eql?如果接收器和参数具有相同的类型和相等的值,则返回 true。 1 == 1.0 返回 true,但是 1.eql?(1.0) 返回 false。
equal?如果接收器和参数具有相同的对象 id,则返回 true。如果 aObj 是 bObj 的副本,那么 aObj == bObj 返回 true,a.equal?bObj 返回 false,但是 a.equal?aObj 返回 true。


Ruby 赋值运算符
运算符描述实例
=简单的赋值运算符,把右操作数的值赋给左操作数 c = a + b 将把 a + b 的值赋给 c
+=加且赋值运算符,把右操作数加上左操作数的结果赋值给左操作数 c += a 相当于 c = c + a
-=减且赋值运算符,把左操作数减去右操作数的结果赋值给左操作数 c -= a 相当于 c = c - a
*=乘且赋值运算符,把右操作数乘以左操作数的结果赋值给左操作数 c *= a 相当于 c = c * a
/=除且赋值运算符,把左操作数除以右操作数的结果赋值给左操作数 c /= a 相当于 c = c / a
%=求模且赋值运算符,求两个操作数的模赋值给左操作数 c %= a 相当于 c = c % a
**=指数且赋值运算符,执行指数计算,并赋值给左操作数 c **= a 相当于 c = c ** a


Ruby 位运算符
运算符描述实例
&如果同时存在于两个操作数中,二进制 AND 运算符复制一位到结果中。 (a & b) 将得到 12,即为 0000 1100
|如果存在于任一操作数中,二进制 OR 运算符复制一位到结果中。 (a | b) 将得到 61,即为 0011 1101
^如果存在于其中一个操作数中但不同时存在于两个操作数中,二进制异或运算符复制一位到结果中。 (a ^ b) 将得到 49,即为 0011 0001
~二进制补码运算符是一元运算符,具有"翻转"位效果。 (~a ) 将得到 -61,即为 1100 0011,2 的补码形式,带符号的二进制数。
<<二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 a << 2 将得到 240,即为 1111 0000
>>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 a >> 2 将得到 15,即为 0000 1111


Ruby 逻辑运算符
运算符描述实例
and称为逻辑与运算符。如果两个操作数都为真,则条件为真。 (a and b) 为真。
or称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 (a or b) 为真。
&&称为逻辑与运算符。如果两个操作数都非零,则条件为真。 (a && b) 为真。
||称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 (a || b) 为真。
!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(a && b) 为假。
not称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 not(a && b) 为假。


Ruby 三元运算符
运算符描述实例
? :条件表达式如果条件为真 ? 则值为 X : 否则值为 Y


Ruby 运算符的优先级
方法运算符描述
:: 常量解析运算符
[ ] [ ]= 元素引用、元素集合
** 指数
! ~ + - 非、补、一元加、一元减(最后两个的方法名为 +@ 和 -@)
* / % 乘法、除法、求模
+ - 加法和减法
>> << 位右移、位左移
& 位与
^ | 位异或、位或
<= < > >= 比较运算符
<=> == === != =~ !~ 相等和模式匹配运算符(!= 和 !~ 不能被定义为方法)
&& 逻辑与
|| 逻辑或
.. ... 范围(包含、不包含)
? : 三元 if-then-else
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= 赋值
defined? 检查指定符号是否已定义
not 逻辑否定
or and 逻辑组成

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?加入我们

x
 楼主| 发表于 2016-2-24 03:23:21 | 显示全部楼层
5. 条件判断

■if语句 --if...else...end

  1. a = 6
  2. b = 7
  3. if  a == b then
  4.         puts "a 等于 b"
  5. else
  6.         puts "a不等于b"
  7. end
复制代码


Ruby的条件式非常简单也可以使用以下方法
  1. print "请输入一个数字:"
  2. num = gets.to_i
  3. b = (num >=0 && num <10 )
  4. puts b
复制代码


Ruby的条件式可以写成一行
  1. if num % 2 == 0  then puts "偶数" end
  2. puts "偶数" if num % 2 == 0
复制代码


*注意Ruby里面 0 和 ""都为真,只有结果为false或是nil时为假


■unless语句 --unless ..end
  1. unless num % 2 == 0  then puts "不是偶数" end
复制代码


case语句 --case .. when ..else .. end
  1. num = rand 10  #rand 随机数生成
  2. case num
  3. when 0
  4.         puts "大吉"
  5. when 1, 2, 3
  6.         puts "中吉"
  7. when 4, 5, 6
  8.         puts "吉"
  9. when 7, 8
  10.         puts "凶"
  11. else
  12.         puts "大凶"
  13. end
复制代码


还可以将判断代入到变量中如下
  1. num = rand 10  #rand 随机数生成
  2. result = case num
  3. when 0
  4.         "大吉"
  5. when 1, 2, 3
  6.         "中吉"
  7. when 4, 5, 6
  8.         "吉"
  9. when 7, 8
  10.         "凶"
  11. else
  12.         "大凶"
  13. end

  14. puts result
复制代码
 楼主| 发表于 2016-3-3 06:56:04 | 显示全部楼层
6. 方法

■ 式样
  1. def 方法名称(参数,参数,....)
  2.     方法代码
  3. end
复制代码


实例
  1. def hello
  2.         puts "hello my world"
  3.         puts "see you later"
  4. end

  5. hello  #调用方法
复制代码


■ 参数和返回值

一般方法的参数之间用 , 号隔开,返回值,则是在最后一行传给一个变量即可。
  1. def circuF(pi_num, r_num)
  2.         cir = 2 * pi_num * r_num
  3.         cir
  4. end

  5. puts circuF(3.1415926, 50)  #=> 314.15926
复制代码


简写方式
  1. def circuF(pi_num, r_num)
  2.         2 * pi_num * r_num
  3. end

  4. puts circuF(3.1415926, 50)  #=> 314.15926
复制代码


中途返回值时使用 return
  1. def circuF(pi_num, r_num)
  2.         return nil pi_num <0 || r_num <0 #pi_num小于0 或者是r_num小于0都返回nil
  3.         cir = 2 * pi_num * r_num
  4.         cir
  5. end
复制代码


■ 参数设置默认值 和 参数不定

参数设置默认值
  1. def message(msg = "hello world")
  2.         puts msg
  3. end

  4. message  #=>hello world
复制代码


参数不定
在参数变量名前使用 *

  1. def message(*msg)
  2.         msg.each { |m| puts m}
  3. end

  4. message "hello world", "This is a test", "program" #=>hello world this is a test program
复制代码


代码结束后添加 ! 号,表示将末尾的换行符删掉
  1. line.chomp!
复制代码



 楼主| 发表于 2016-3-3 09:08:50 | 显示全部楼层
7. 循环 和 块

“块”的概念是Ruby中一个非常有意思的部分。 利用 “块” , 你可以更好的处理循环
在Ruby代码中,经常会把 “块” 传给调用的方法。  

7.1 简单的块实例
  1. 10.times do |i|  #times为对象方法
  2.         print i, ", "  #=>0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  3. end  
复制代码


上面的例子里面, do ... end 部分为 “块” , 除了 do ... end 还可以使用 {}

  1. 10.times {|i| print i, ", "}
复制代码

  1. 2.upto(6) {|i| print i, ", "}  #=>2, 3, 4, 5, 6,  upto方法为从2 到 6执行
复制代码


此外还有 6.downto(2)  step(10, 2)等方法

7.2 循环

each方法 针对数组最好用的循环方法
  1. arr = ['apple', 'orange', 'grape']
  2. arr.each do |items|
  3.         print items + ', '  #=> apple, orange, grape,
  4. end
复制代码


each_with_index 获取数组的要素及要素的索引
  1. arr = ['apple', 'orange', 'grape']
  2. arr.each_with_index do |items, i|
  3.         print "#{i}. #{items}"
  4.         print ", " if i<arr.length - 1 #=>0. apple, 1. orange, 2. grape
  5. end
复制代码


while 和 for Ruby也使用while 和 for但是由于块的使用,导致很少使用。


循环外的 块 应用
  1. File.open("output.txt", "w", encoding: "utf-8") do |file|
  2.         file.puts "hello world" #在当前目录创建一个output.txt的文件,内容是hello world
  3. end
复制代码

  1. #接收 块 的方法
  2. def stopwatch(time)
  3.         start = Time.now.to_f
  4.         time.times{ |i| yield i}
  5.         Time.now.to_f - start
  6. end

  7. secs = stopwatch(10000) do |i|
  8.         Math.sqrt(i)
  9. end

  10. puts "用了#{secs}秒"
复制代码






 楼主| 发表于 2016-3-7 07:31:42 | 显示全部楼层
8. 错误处理及异常  程序在运行的时候遇到任何错误捕捉错误的机制
Ruby一般使用 begin ~ end, 当错误发生时,马上执行 rescue下面的代码

  1. begin
  2.         File.open("some.txt", encoding:"utf-8") do |f|
  3.                 print f.gets
  4.         end
  5. rescue
  6.         warn "错误发生"
  7. end
复制代码


*在函数及方法中可以省略 begin

如果想获得更详细的错误信息可以使用以下方法
  1. begin
  2.         File.open("some.txt", encoding:"utf-8") do |f|
  3.                 print f.gets
  4.         end
  5. rescue => e
  6.         warn "错误发生"
  7.         warn "#{e.class} / #{e.message}"
  8. end
复制代码
 楼主| 发表于 2016-3-7 08:28:49 | 显示全部楼层
9. 符号symbol  暂时未理解,无法说明
 楼主| 发表于 2016-3-7 08:49:25 | 显示全部楼层
10. 数组, 哈希,  范围  


■数组
使数组简单便利的方法
include?  数组中如果含有变量的值,就返回true

  1. shuiguo = ["apple", "orange", "banana"]
  2. puts "Ok" if shuiguo.include?("banana") #=>Ok
复制代码


all? 是否全部元素符合要求
any? 是否部分元素符合要求
detect 查找第一个符合条件的元素
find_all 查找全部符合条件的元素
  1. number = [1,2,3,4,5,6,7,8,9]
  2. puts "Ok" if number.all? {|item| item > 0}  #=>Ok
  3. puts "Ok" if number.any? {|item| item % 2 == 0}  #=>Ok
  4. puts number.detect {|item| item > 5}  #=>6
  5. puts number.find_all{|item| item > 5}  #=>6 7 8 9
复制代码


map将结果作为新的数组
  1. number = [1,2,3,4,5,6,7,8,9]
  2. bai2 = number.map {|item| item * 2}  #=>[2, 4, 6, 8, 10, 12, 14, 16, 18]
  3. p bai2
复制代码


(&: 方法名)  可以替代 {|item| item * 2}


■哈希  与数组相似,但不同的地方是哈希使用的是 key => value,而不是序列

  1. bigNumber = {
  2.         "big" => 123000000,
  3.         "middle" => 1230000,
  4.         "small" => 123
  5. }

  6. puts bigNumber["big"]  #=>123000000
  7. bigNumber["very_big"]=999999999  #追加新的哈希
  8. puts bigNumber["very_big"]  #=>999999999
复制代码



■哈希和参数

哈希的参数不光位置可以改变,方法调用时也可以省略如下

  1. big_N({height:5, base:10})
  2. big_N{height:5, base:10}
  3. big_N height:5, base:10
复制代码

以上代码都是对的


■范围Range  将最初元素和结束元素使用 .. 连接即可做成范围

  1. range = 1..10 #=>1 2 3 4 5 6 7 8 9 10范围1到10
  2. range = 1...10  #=>1 2 3 4 5 6 7 8 9范围1到9不包含最后元素
  3. range = "a".."z" #=>a b c d... z
复制代码


也可以通过each方法按照顺序去除范围内的值
  1. range =1..4
  2. range.each{ |num| puts "2 x #{num} = #{2*num}"}
  3. #=>
  4. #2 x 1 = 2
  5. #2 x 2 = 4
  6. #2 x 3 = 6
  7. #2 x 4 = 8
复制代码





 楼主| 发表于 2016-3-8 09:50:02 | 显示全部楼层
11. 正则表达式 是一种特殊模式的字符组合,它通过使用有专门语法的模式来匹配或查找字符串集合。 ■正则表达式的使用方法
  1. re = /pattern/ #正则表达式写在 / /内
复制代码
  1. str = "This is a big world"
  2. if str =~ /orl/ #Ruby使用 =~来检查字符串
  3. puts "发现orl"
  4. end
复制代码
同时还可以使用string的match方法
  1. str = "This is a big world b"
  2. md = str.match(/(\S+) a .+ (\S+) b/)
  3. if md
  4. puts "#{md[0]} 匹配成功"
  5. puts "第一个匹配 #{md[1]}"
  6. puts "第二个匹配 #{md[2]}"
  7. end
  8. #=>
  9. #is a big world b
  10. #第一个匹配 is
  11. #第二个匹配 world
复制代码
使用String的gsub方法
  1. str = "a white cat and a black dog"
  2. str2 = str.gsub(/cat|dog/, "bird") #gsub 替换
  3. puts str2 #=>a white bird and a black bird
复制代码
使用String的gsub! 返回的不是新的字符串而是将元字符串替换
  1. str = "a white cat and a black dog"
  2. str.gsub!(/cat|dog/) do |name|
  3. name == "cat" ? "mouse" : "monkey"
  4. end
  5. puts str #=>a white mouse and a black monkey
复制代码
正则表达式修饰符
修饰符描述
i当匹配文本时忽略大小写。
o只执行一次 #{} 插值,正则表达式在第一次时就进行判断。
x忽略空格,允许在整个表达式中放入空白符和注释。
m匹配多行,把换行字符识别为正常字符。
u,e,s,n把正则表达式解释为 Unicode(UTF-8)、EUC、SJIS 或 ASCII。如果没有指定修饰符,则认为正则表达式使用的是源编码。
正则表达式模式
模式描述
^匹配行的开头。
$匹配行的结尾。
.匹配除了换行符以外的任意单字符。使用 m 选项时,它也可以匹配换行符。
[...]匹配在方括号中的任意单字符。
[^...]匹配不在方括号中的任意单字符。
re*匹配前面的子表达式零次或多次。
re+匹配前面的子表达式一次或多次。
re?匹配前面的子表达式零次或一次。
re{ n}匹配前面的子表达式 n 次。
re{ n,}匹配前面的子表达式 n 次或 n 次以上。
re{ n, m}匹配前面的子表达式至少 n 次至多 m 次。
a| b匹配 a 或 b。
(re)对正则表达式进行分组,并记住匹配文本。
(?imx)暂时打开正则表达式内的 i、 m 或 x 选项。如果在圆括号中,则只影响圆括号内的部分。
(?-imx)暂时关闭正则表达式内的 i、 m 或 x 选项。如果在圆括号中,则只影响圆括号内的部分。
(?: re)对正则表达式进行分组,但不记住匹配文本。
(?imx: re)暂时打开圆括号内的 i、 m 或 x 选项。
(?-imx: re)暂时关闭圆括号内的 i、 m 或 x 选项。
(?#...)注释。
(?= re)使用模式指定位置。没有范围。
(?! re)使用模式的否定指定位置。没有范围。
(?> re)匹配无回溯的独立模式。
\w匹配单词字符。
\W匹配非单词字符。
\s匹配空白字符。等价于 [\t\n\r\f]。
\S匹配非空白字符。
\d匹配数字。等价于 [0-9]。
\D匹配非数字。
\A匹配字符串的开头。
\Z匹配字符串的结尾。如果存在换行符,则只匹配到换行符之前。
\z匹配字符串的结尾。
\G匹配最后一个匹配完成的点。
\b当在括号外时匹配单词边界,当在括号内时匹配退格键(0x08)。
\B匹配非单词边界。
\n, \t, etc.匹配换行符、回车符、制表符,等等。
\1...\9匹配第 n 个分组子表达式。
\10如果已匹配过,则匹配第 n 个分组子表达式。否则指向字符编码的八进制表示。
正则表达式实例 字符
实例描述
/ruby/匹配 "ruby"
匹配 Yen 符号。Ruby 1.9 和 Ruby 1.8 支持多个字符。
字符类
实例描述
/[Rr]uby/ 匹配 "Ruby" 或 "ruby"
/rub[ye]/ 匹配 "ruby" 或 "rube"
/[aeiou]/匹配任何一个小写元音字母
/[0-9]/ 匹配任何一个数字,与 /[0123456789]/ 相同
/[a-z]/匹配任何一个小写 ASCII 字母
/[A-Z]/匹配任何一个大写 ASCII 字母
/[a-zA-Z0-9]/匹配任何一个括号内的字符
/[^aeiou]/ 匹配任何一个非小写元音字母的字符
/[^0-9]/匹配任何一个非数字字符
特殊字符类
实例描述
/./ 匹配除了换行符以外的其他任意字符
/./m 在多行模式下,也能匹配换行符
/\d/匹配一个数字,等同于 /[0-9]/
/\D/ 匹配一个非数字,等同于 /[^0-9]/
/\s/匹配一个空白字符,等同于 /[ \t\r\n\f]/
/\S/ 匹配一个非空白字符,等同于 /[^ \t\r\n\f]/
/\w/ 匹配一个单词字符,等同于 /[A-Za-z0-9_]/
/\W/匹配一个非单词字符,等同于 /[^A-Za-z0-9_]/
重复
实例描述
/ruby?/ 匹配 "rub" 或 "ruby"。其中,y 是可有可无的。
/ruby*/ 匹配 "rub" 加上 0 个或多个的 y。
/ruby+/匹配 "rub" 加上 1 个或多个的 y。
/\d{3}/刚好匹配 3 个数字。
/\d{3,}/匹配 3 个或多个数字。
/\d{3,5}/匹配 3 个、4 个或 5 个数字。
非贪婪重复
实例描述
/<.*>/贪婪重复:匹配 "<ruby>perl>"
/<.*?>/ 非贪婪重复:匹配 "<ruby>perl>" 中的 "<ruby>"
通过圆括号进行分组
实例描述
/\D\d+/ 无分组: + 重复 \d
/(\D\d)+/ 分组: + 重复 \D\d 对
/([Rr]uby(, )?)+/匹配 "Ruby"、"Ruby, ruby, ruby",等等
反向引用
实例描述
/([Rr])uby&\1ails/匹配 ruby&rails 或 Ruby&Rails
/(['"])(?:(?!\1).)*\1/单引号或双引号字符串。\1 匹配第一个分组所匹配的字符,\2 匹配第二个分组所匹配的字符,依此类推。
替换
实例描述
/ruby|rube/匹配 "ruby" 或 "rube"
/rub(y|le))/匹配 "ruby" 或 "ruble"
/ruby(!+|\?)/ "ruby" 后跟一个或多个 ! 或者跟一个 ?
实例描述
/^Ruby/匹配以 "Ruby" 开头的字符串或行
/Ruby$/ 匹配以 "Ruby" 结尾的字符串或行
/\ARuby/ 匹配以 "Ruby" 开头的字符串
/Ruby\Z/匹配以 "Ruby" 结尾的字符串
/\bRuby\b/匹配单词边界的 "Ruby"
/\brub\B/\B 是非单词边界:匹配 "rube" 和 "ruby" 中的 "rub",但不匹配单独的 "rub"
/Ruby(?=!)/如果 "Ruby" 后跟着一个感叹号,则匹配 "Ruby"
/Ruby(?!!)/ 如果 "Ruby" 后没有跟着一个感叹号,则匹配 "Ruby"
圆括号的特殊语法
实例描述
/R(?#comment)/ 匹配 "R"。所有剩余的字符都是注释。
/R(?i)uby/ 当匹配 "uby" 时不区分大小写。
/R(?i:uby)/ 与上面相同。
/rub(?:y|le))/只分组,不进行 \1 反向引用
time 之 strftime方法
实例描述
%a英语日期简称
%A英语日期
%b英语月简称
%B英语月
%d
%H24小时
%I12小时
%m
%M
%pAM,PM
%S
%y2位年
%Y4位年
%Z时区名称
%%文字%
  1. time = Time.now
  2. puts time.strftime("%Y/%m/%d %H:%M")
复制代码
 楼主| 发表于 2016-3-11 08:29:28 | 显示全部楼层
12.  引用

  1. require "文件名"
复制代码


在大型程序及程序集中需要使用
 楼主| 发表于 2016-3-11 08:33:53 | 显示全部楼层
13. class类

■类与实例  类好比是设计图, 而实例则是根据设计图生产出来的产品

语法 class 类名 ~ end

  1. class Robot
  2. end

  3. robo1 = Robot.new
  4. p robo1  
复制代码


■参照 与 复制

z2 = z1  在Ruby中的含义是 z2 和 z1参照同一个实例
  1. z1 = "hello"
  2. z2 = z1
  3. puts z1.object_id          #=>69920670847180
  4. puts z2.object_id        #=>69920670847180       

  5. z1.upcase!
  6. puts z2  #=>HELLO
复制代码


class方法  返回类
kind_of  |  is_a 方法  如果是对象参数指定的类的实例,返回true, 如果直接指定父类,返回true
instance_of方法  如果是对象参数指定的类的实例,返回true, 如果直接指定父类,返回false

  1. z1="hello"
  2. puts z1.class  #=>String
  3. puts z1.kind_of?(String)  #=>true
  4. puts z1.kind_of?(Object)  #=>true
  5. puts z1.instance_of?(String)  #=>true
  6. puts z1.instance_of?(Object)  #=>false
复制代码


 楼主| 发表于 2016-3-14 04:03:32 | 显示全部楼层
13.1. 实例方法 初始化及方法 Ruby的类中的方法是用 def ~ end来记述 @变量 为类变量,一般为接收实例变量而制作, 变量初始化时使用 initialize方法 任何类都有一个 to_s 实例方法来返回对象的字符串表示形式。
  1. class Robot
  2. def initialize(name)
  3. @name = name
  4. @x = @y = 0
  5. end
  6. def move(x, y)
  7. @x += x
  8. @y += y
  9. end
  10. def to_s
  11. "#{@name}: #{@x}, #{@y}"
  12. end
  13. end
  14. robo1 = Robot.new("机器人1号") #"机器人1号实例"
  15. robo2 = Robot.new("机器人2号") #"机器人2号实例"
  16. puts robo1
  17. robo2.move(10,20)
  18. puts robo2
复制代码
■限制方法的调用
级别描述
public在实例中任何地方都可以调用
protected只能在同一类中或是子类中调用
private只能在同一类中或是子类中调用, 实例中无法调用
  1. class Robot
  2. def initialize(name)
  3. @name = name
  4. @x = @y = 0
  5. end
  6. def move(x, y)
  7. @x += x
  8. @y += y
  9. crash if @x < 0 || @y < 0
  10. end
  11. private
  12. def crash
  13. puts "损坏"
  14. end
  15. end
  16. robo1 = Robot.new("机器人1号") #"机器人1号实例"
  17. robo2 = Robot.new("机器人2号") #"机器人2号实例"
  18. robo1.move(-100,50) #=>损坏
  19. robo1.crash #=>错误
复制代码
 楼主| 发表于 2016-3-14 06:55:56 | 显示全部楼层
13.2. 创建属性

在实例中即使创建@name,在对象的实例终也无法直接访问,所以有了属性的创建
  1. class Robot
  2.         def name
  3.                 @name
  4.         end
  5.        
  6.         def name=(name)
  7.                 @name = name
  8.         end
  9. end

  10. robo1 = Robot.new
  11. robo1.name = "机器人1号"
  12. puts robo1.name         #=>机器人1号
复制代码


这样name属性就创建成功了。但是一个一个这么写很麻烦,也可以使用以下的方法。
  1. class Robot
  2.         attr_reader :name        #多个属性时,可以使用 , 号分开
  3.         attr_writer :name
  4. end

  5. robo1 = Robot.new
  6. robo1.name = "机器人1号"
  7. puts robo1.name         #=>机器人1号
复制代码


读写双方都需要的时候,可以使用 attr_accessor



 楼主| 发表于 2016-3-14 08:18:42 | 显示全部楼层
13.3. 类方法及常量
类方法, 在Ruby中不光实例可以拥有方法及属性,类也可以。

类方法
使用方法, 类.方法
记述方式, def self.方法 ~ end
特别写法, 可以添加复数方法,还可以省略self
  1. class Robot
  2.   class << self
  3.     def load(fname)
  4.       source
  5.     end
  6.   end
  7. end
复制代码


常量  在程序运行时,不会被修改的量。(不能修改的变量)
  1. class Shape
  2.         PI = 3.14159
  3.        
  4.         def self.circle(r)
  5.                 r * r * PI
  6.         end
  7. end

  8. puts Shape::PI        #=>3.14159
  9. puts Shape.circle(5)        #=>78.53975
复制代码

在类外部访问常量时,可以使用 ::



 楼主| 发表于 2016-3-14 08:43:06 | 显示全部楼层
14. 继承和Mix-in

继承  对已存在的类进行方法的扩张

在原来的类的基础上,创建新的类,新类完全包含父类的所有功能,子类追加的功能, 不论是父类还是子类都可以使用。
记述方法: class 子类名 < 父类名 ~ end

  1. class Robot
  2.         def initialize(name)
  3.                 @name = name
  4.                 @x = @y = 0
  5.         end
  6.        
  7.         def move(x, y)
  8.                 @x += x
  9.                 @y += y
  10.         end
  11.        
  12.         def to_s
  13.                 "#{@name}: #{@x}, #{@y}"
  14.         end
  15. end

  16. class FlyingRobot < Robot
  17.         def initialize(name)
  18.                 super
  19.                 @z = 0
  20.         end
  21.        
  22.         def move(x, y, z)
  23.                 super(x, y)
  24.                 @z += z
  25.         end
  26.        
  27.         def to_s
  28.                 super + ",#{@z}"
  29.         end
  30. end

  31. robo1 = FlyingRobot.new("飞行机器人1号")
  32. robo1.move(20, 10, 30)
  33. puts robo1        #=>飞行机器人1号: 20, 10, 30
复制代码


模块 和 Mix-in  在Ruby中和类相似的还有模块module
记述方式: module 模块名 ~ end
模块可以扩展相应的类功能, 类读取模块叫做Mix-in

  1. module Radar
  2.         def distance_to(other)
  3.                 Math.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
  4.         end
  5. end

  6. class Robot
  7.         include Radar
  8.         attr_accessor :name, :x, :y
  9.        
  10.         def initialize(name)
  11.                 @name = name
  12.                 @x = @y = 0
  13.         end
  14.        
  15.         def move(x, y)
  16.                 @x += x
  17.                 @y += y
  18.         end
  19.        
  20.         def to_s
  21.                 "#{@name}: #{@x}, #{@y}"
  22.         end
  23. end

  24. robo1 = Robot.new("机器人1号")
  25. robo2 = Robot.new("机器人2号")
  26. robo1.move(10, 50)
  27. robo2.move(0, 70)
  28. puts "两个机器人的距离是 #{robo1.distance_to(robo2)}"
复制代码




您需要登录后才可以回帖 登录 | 加入我们

本版积分规则

手机版|小黑屋|日星网 ( 黑ICP备07001742号 )

GMT, 2018-11-21 09:44 AM , Processed in 0.025501 second(s), 19 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表