Ruby 使用笔记

禾西

一些简单的基础：
- 这帖不是教程，只是单纯地展示一些脚本基础涉及到的内容 -

赋值

one = 1

整数（integer）

int = 1

小数（或浮点 - float）

float = 3.14159265

字符串

str = "This is a String"
str = 'This is a String too'

输出: p,  print

p "Hellow World"
print "Hellow World"

注释

# 注释行以#开头

长注释

=begin
注释行1
注释行2
=end

四则运算

a = 3
#加法
p a + 1
#减法
p a - 1
#乘法
p a * 1
#阶乘
p a**2
#除法
p a / 3
#余除
p a % 3

空值

empty = nil

真假值

bool = true
bool = false

比较符

a = 1
b = 2
#相等?
p a == b
#a大于b?
p a > b
#a小于b?
p a < b
#a小于或等于b?（a 不超过 b?)
p a <= b
#a大于或等于b?（a 超过 b?)
p a >= b

条件分歧

a = 1
b = 2
if a > b
  p "a 大于 b"
elsif a < b
  p "a 小于 b"
else
  p "a 等于 b"
end

取值分歧

a = 1
case a
when 1
  p  "a == 1"
when 2
  p  "a == 2"
else
  p  "a == 其他值"
end

数组

array = [1,2,3,4]

实例

obj = Object.new
p obj

Hash表

hash = {1=>"one",2=>"two"}
p hash

定义一个类

class CLS

end

定义一个方法

def method

end

各种标签

local_var = "局部变量"
$global_var = "全局变量"
@insta_var = "实例变量"
@@class_var = "类变量"
CONSTA = "常量"

loop 循环

a = 1
loop do
  p a += 1
  break if a == 5
end

for 循环

for a in 0...5
  p a
end

while 循环

a = 1
while a < 5
  p a += 1
end

方法调用

ar = Array.new
ar.push 1
p ar

参数

def method(var)
  p var
end
method(1)

退出系统

exit

module

module MOD

end

继承父类

class Father

end
class Son < Father

end

导入模板（多重继承）

module MOD_A
end
class CLS
include MOD_A
end

引用模板/类常数

module MOD
  CONSTA = 1
end
module CLS
  CONSTA = 2
end
p MOD::CONSTA
p CLS::CONSTA

嵌套类

class CLS_lv1
  class CLS_lv2
    class CLS_lv3
    end
  end
end
module MOD
  class CLS
  end
end
p obj = CLS_lv1::CLS_lv2::CLS_lv3.new
p obj = MOD::CLS

端口

class CLS
  attr_reader :info
  attr_writer :content
  attr_accessor :data
end
obj = CLS.new
obj.content = 1
obj.data = 1
p obj.info
p obj.data

创建方法別名

def method_1
  p 1
end
alias method_2 method_1
method_2

回调

def method
  return 1
end
def call_back(var)
  p var
end
call_back( method )

数组迭代
详细：http://rpg.blue/thread-157153-1-2.html

[1,2,3,4].each do |i|
  p i
end

行间分隔符

a = 1;
p a;

“如果……然后……否则”结构

bool = true
if bool then p true else p false end
p bool ? true : false

用 super 调用父类方法

class Father
  def method
    p "ori"
  end
end
class Son < Father
  def method
    super
  end
end

格式化字符

hour = 1; min = 2; sec = 3
p sprintf("%02d:%02d:%02d", hour, min, sec)

符号(Symbol)

symbol = :sym

正则式(Regexp)

reg = /\w\d\n*/

随机数

rand_num = rand(100)

evel 执行字符串脚本

script = "p 1"
eval(script)

取得系统时间

time = Time.now

捕捉错误并进行补救

begin
  p nil + 1
rescue
  p 1
end

禾西

数组(Array)的操作与入门
0.  什么是数组？
你可以把数组当作一个什么都能容纳的链式容器(List)。
1.  定义数组
arr1 = []
arr2 = Array.new
arr3 = ['1','2','3']
2.  访问数组元素
arr1[int]   #int为整数，因为第一位为0，所以与实际的对应为 int = n-1
arr1[0]     #取得第一个数据
arr1[-1]    #取得最后一个数据
arr1.size    #取得数组长度
3.  操作数组
arr3[4] = '5'                    #将第5位元素设定为5。5之前没有设定的元素将会自动为 nill
arr3.delete_at(3)             #删除指定位置的元素
arr3.push('6')                  #向数组尾部加入元素
arr3<<'6'                        #push 的简写方式
arr3<<"f"<<'g'               #从左至右地连续加入元素
arr3.pop                         #删除尾元素
arr3.shift                         #删除首元素
arr3.clear                        #清空数组
p "Str1\nStr2"

p 'Str1\nStr2'

禾西

字符串(String)的入门
0.  定义字符串
字符串的定义有两种方法
str1 = "String"
str2 = 'String'

1. 他们有一些重要的区别：
系统几乎不对「单引号定义的字符串」做任何处理，除了几个特殊情况外。
系统会对「双引号定义的字符串」做更多的处理：
  x1. 首先，查找字符串中的换行符（比如 \n ），
  x2. 然后，替换成对应的二进制值。

因此，由「单引号定义的字符串」几乎不能加入任何控制符。而「双引号定义的字符串」则可以。
print 'Str1\nStr2'          # => Str1\nStr2

print "Str1\nStr2"         # => Str1
                                    # => Str2

  另外，由「单引号定义的字符串」不能加入任何内嵌表达式。而「双引号定义的字符串」可以。
game = "RPG"
print "#{game} Maker XP"         # => RPG Maker XP
print '#{game} Maker XP'          # => #{game} Maker XP

1. 
   
2. 正則表達式(Regexp) < Object
   
3. 
   
4. Object 下的一個子類。所有 Obejct 能用的方法 Regexp 都能用
   
5. 
   
6. ：甚麽是正則表達式？
   
7.         所謂正則表達式(Regular Expresion)，
   
8.         就是用一串「古怪的字母公式」去解釋一列「文字」。
   
9.         
   
10. ：正則表達式的作用？
    
11.         如上所說，正則表達式可以幫助我們迅速地處理大量的文本資料(主要是 String 資料)
    
12.         
    
13. ：如何生成正則表達式的式？
    
14.         在 Ruby 當中，常用的方法是用 「/ /」如下面的例子：
    
15.        |/Orz/
    
16.         任何/ /當中的文字，系統都會當作 String(字符串) 處理。
    
17.         實際上，就算正則表達式也是一個實例。
    
18.         它是由Regexp Class 産生的。
    
19.         因此我們也可以通過正規的方法實例生成方法去生成正則表達式
    
20.        |Regexp.new("字符串")
    
21.        |Regexp.compile("字符串")
    
22.         以上提到的三種方法是完全一樣的。
    
23.         他們的作用就是把一個 string 轉化爲一個正式表達式實例
    
24.         
    
25.         那麽，既然正則表達式是一個實例。理所當然地，我們也可以用變量來記錄他
    
26.        |a = /Orz/
    
27. 
    
28. ：如何使用正則表達式？
    
29.         正則表達式的使用方法有兩種
    
30.         一種是搜索字符當中的關鍵字眼：
    
31.        |"ORZOrz"[/Orz/] #=>"Orz"
    
32.        |"囧rz"[/Orz/]
    
33.         當左邊的字符串當中含有左邊的正則表達式內容的時候，系統就會放回該串字符(String)
    
34.         
    
35.         另外一種就是檢查字符是否有符合正則表達式的描述的「部分」
    
36.        |"XRZOrz" =~ /Orz/ #=> 3
    
37.         如果有，系統會返回符合部分的開始 index (String 的 index 參考String筆記或者幫助)
    
38.         否則，就會返回 nil
    
39.        |"囧rz" =` /Orz/   #=> nil
    
40.         這個行爲，我們稱之為「匹配」
    
41.         如上所說，匹配的結果一般有兩種：
    
42.         「nil」 或者 「整數」。
    
43.         
    
44.         不過，雖然匹配的結果不是「true」或者「false」這樣的真假值(Boolean)
    
45.         當我們需要用「匹配」的結果來進行分歧時候，
    
46.         我們還是完全可以用 if "囧rz" =` /Orz/ 或者 unless "囧rz" =` /Orz/ 來判斷
    
47.         (關於 nil 和 false 的關係，numerical 和 true 的關係， 請參照FalseClass 和 TrueClass)
    
48.         
    
49. ：關於正則表達式當中的古怪的字母公式...
    
50.         在未曾接觸到正則表達式之前，很多情况下會覺得正則表達式沒有規律、難以理解
    
51.         但是實際上，這些古怪的字母公式是有一定規則的。
    
52.         
    
53.         這些古怪的字母公式一個分爲三種：
    
54.         第一，就是指定的單個字符：
    
55.         a
    
56.         b
    
57.         c
    
58.         當使用指定的單個字符去組成正則表達式的時候，
    
59.         匹配的對象一定要跟表達式內容完全相符。
    
60.        |"orzsro" =~ /OrzsrO/ #=> nil(false)
    
61.        |"OrzsrO" =~ /OrzsrO/ #=> 0  (true)
    
62.         
    
63.         第二個是元字符：
    
64.        |"看！gray airplane～" =~ /\S！\D*\s\D*[～]$/ #=> 0
    
65.         元字符的特徵是以 「\」、「^」、「*」這些非字母符號開頭
    
66.         
    
67.         元字符的作用是進行模糊匹配。
    
68.         
    
69.         簡單來說：
    
70.         單個字符具有惟一的匹配意義
    
71.         元字符具有浮動的匹配意義範圍
    
72.         
    
73.         關於元字符的匹配範圍，可以通過正則表達式的幫助查得。
    
74.         
    
75.         最後一種是()
    
76.        |"看！gray airplane～" =~ /(\S)！(\D*)\s\(D*)([～]$)/ #=> 0
    
77.        |p $1, $2, $3, $4 #=> print "看" "gray" "airplane" "～"
    
78.         「( )」不具有匹配意義。也就是說正則表達式當中的( )字符不參與匹配行爲
    
79.         但是 ( )有個非常重要的作用：
    
80.         就是當匹配成功的時候，抽出匹配部分幷記錄在 $1，$2，$3...之類的變量當中
    
81.         
    
82. ：常用的元字符有那些
    
83.         匹配除「換行符」以外的全部符號：
    
84.         .
    
85. 
    
86.         指定字符範圍匹配：
    
87.         []
    
88.         例子：/[A-Z]/ #匹配所有大寫字母
    
89.         
    
90.         單獨匹配「數字」：
    
91.         \d
    
92.         [0-9]
    
93.         單獨匹配「英語字母」：
    
94.         [A-Za-z]
    
95.         匹配「數字」與「字母」與「中文字」：
    
96.         \w
    
97.         匹配「空格」、「製表符」、「換行符」、「回車符」「換頁符」等「空字符」：
    
98.         \s
    
99.         [ \t\n\r\f] #留意這裏不是[\t\n\r\f]
    
100.         匹配字符串的開端：
     
101.         \A
     
102.         匹配「換行符」後段落的開始：
     
103.         ^
     
104.         
     
105.         匹配所有「非數字」：
     
106.         \D
     
107.         匹配所有非「數字」與「字母」與「中文字」：
     
108.         \W
     
109.         匹配包括「數字」、「英語字母」、「漢字」、「標點符號」等等所有「非空字符」：
     
110.         \S
     
111.         匹配字符串的結尾(不包括「換行符」)：
     
112.         \Z
     
113.         匹配字符串的結尾(包括「換行符」)：
     
114.         \z
     
115.         匹配「換行符」前段落的結尾(特殊，這個匹配符號是放在需要匹配的結尾字符後面的)：
     
116.         $
     
117.         例子：/z$/
     
118.         
     
119.         匹配出現次數(特殊，這個匹配符號是放在需要匹配的字符和元字符後面的)
     
120.         「零」至「無限」次：
     
121.         *
     
122.         例子：/\d*/
     
123.         n 次：
     
124.         {n}
     
125.         例子：/\d{2}/
     
126.         n 次以上：
     
127.         {n,}
     
128.         例子：/\d{2,}/
     
129.         n 到 m 次：
     
130.         {n,m}
     
131.         例子：/\d{2,4}/
     
132.         
     
133.         選擇性匹配(特殊，這個匹配符號是放在可以選擇匹配多個字符或元字符之間的)：
     
134.         |
     
135.         例子：/O|o/
     
136.         抽出匹配部分字符，幷記錄在相應數字的 $1,$2,$3...變量當中
     
137.         ( )
     
138.         
     
139.         單獨匹配亞洲文以及非Latin字符
     
140.         神說：「所有文字都是平等的」，因此沒有這個方法。(那爲甚麼英語Latin字符可以...)
     
141.         
     
142.         更多元符號參照正則表達式幫助 ^ ^
     
143.         
     
144.         
     
145. ：可以組合兩個正則表達式嗎？
     
146.         正常途徑辦不到，但是不等於不行。看看以下例子
     
147.        |a = "\D*[a-z]"
     
148.        |b = "\S\sz$"
     
149.        |c = /#{a}#{b}/ #=>/\D*[a-z]\S\sz$/
     
150.         這樣的組合是根據「正則表達式是Regexp根據其字符參數生成的一個實例」這一條原則組合的
     
151.         先把兩個字符組合，然後再把他們當作一個參數傳給 Regexp Class 生成一個正則表達式實例
     
152.         
     
153. ：如何抽取字符當中的有效部分？
     
154.         把正則表達式中預計需要抽出的部分用( )框起來，然後再用 $1，$2，$3...等變量讀取
     
155.         
     
156. ：如何使用「變量」控制「正則表達式」？
     
157.        |keyword = 'error'
     
158.        |str = "errorsdfsdf"
     
159.        |str =~ /#{keyword}/ #=> 0
     
160.          
     
161. To be continued
     
162.                
     

复制代码

禾西

常量(Constant)和变量(Variable)的入门
-1.  Ruby的常量和变量都是无类型的
note: 如果你对强类型这个说法没有概念的话，你根本不需要了解。
对于 C 或者 Java 的使用者来说，定义数据前都需要指定类型，以便编译器读懂数据结构。
然而，ruby 的数据是无类型的。你完全不需要指定类型，而可以直接将数据丢到变量中去。
你可以把 ruby 的变量当作一个大的垃圾缸？（笑）

0.  甚麼是常量，又甚麼是变量
你可以把变量和常量当作一种标签，因为他们本质上只是一个数据的指向标记而已。
系统的内部有个隐藏起来的对应表，对应表中记录了 标签 -> 数据 的指向。

1.  怎麽标记为一个常量，怎麽标记为一个变量
他的格式是： 标记 = 数据
常量标签总是以大写字母开头，比如：Constant
变量标签则会以其它形式出现，比如：var, @var, @@var, $var

2.  各种常量变量
标签可以分为常量和变量两种，变量可以分为全局变量、类变量、实例变量、本地变量四种。

他们最大的分别在于应用范围和修改范围

1. class Test
   
2.   One = 1      #定义一个常量
   
3.   $two = 0     #定义一个全局变量
   
4.   @@three = 0  #定义一个类变量
   
5.   def init
   
6.     @four = 0  #定义一个实例变量
   
7.     five = 5   #定义一个本地变量
   
8.     p One, $two, @@three, @four, five
   
9.   end
   
10.   def modify
    
11.     $two = 2
    
12.     @@three = 3
    
13.     @four = 4
    
14.     five = 5
    
15.     p One, $two, @@three, @four, five
    
16.   end
    
17.   def test1
    
18.     p One, $two, @@three, @four
    
19.   end
    
20.   def test2
    
21.     p One, $two, @@three, @four, ifve
    
22.   end
    
23. end
    
24. app = Test.new
    
25. app.init #=> 1, 0, 0, 0, 5
    
26. app.modify #=> 1, 2, 3, 4, 5
    
27. app2 =  Test.new
    
28. app2.test1  #=> 1, 2, 3, nil
    
29. app2.test2  #=> 出错，未定义本地变量 five
    

复制代码

从上面程序可以看出，常量(One)，全局变量($two)，类变量(@@three)都只需要定义一次就可以重复使用。
而实例变量(@four)，和本地变量(five)则需要每次生成实例以后重复定义才能使用。
应用未经定义的实例变量会自动当作 nil。而应用未经定义的本地变量则会出错。

而一般情况下，修改常量也会出错：

1. class Test
   
2.   def test
   
3.     One = 1 #=> 语法错误(Syntax Error)
   
4.   end
   
5. end

复制代码

更详尽的请参考这三个讨论
http://rpg.blue/viewthread.php?tid=84430
http://rpg.blue/viewthread.php?tid=81167
http://rpg.blue/thread-159895-1-1.html
以及F1中关于变量的各种说明。