Ruby 使用笔记

禾西 · 发表于 2007-12-22 10:24:10

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

本帖最后由禾西于 2011-8-17 12:46 编辑

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

赋值

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

禾西 · 发表于 2007-12-22 10:24:10

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

本帖最后由禾西于 2011-3-2 18:20 编辑

数组(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'

禾西 · 发表于 2008-6-6 21:15:11

本帖最后由禾西于 2011-3-2 18:04 编辑

字符串(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

正則表達式(Regexp) < Object
Object 下的一個子類。所有 Obejct 能用的方法 Regexp 都能用
：甚麽是正則表達式？
所謂正則表達式(Regular Expresion)，
就是用一串「古怪的字母公式」去解釋一列「文字」。
：正則表達式的作用？
如上所說，正則表達式可以幫助我們迅速地處理大量的文本資料(主要是 String 資料)
：如何生成正則表達式的式？
在 Ruby 當中，常用的方法是用「/ /」如下面的例子：
|/Orz/
任何/ /當中的文字，系統都會當作 String(字符串) 處理。
實際上，就算正則表達式也是一個實例。
它是由Regexp Class 産生的。
因此我們也可以通過正規的方法實例生成方法去生成正則表達式
|Regexp.new("字符串")
|Regexp.compile("字符串")
以上提到的三種方法是完全一樣的。
他們的作用就是把一個 string 轉化爲一個正式表達式實例
那麽，既然正則表達式是一個實例。理所當然地，我們也可以用變量來記錄他
|a = /Orz/
：如何使用正則表達式？
正則表達式的使用方法有兩種
一種是搜索字符當中的關鍵字眼：
|"ORZOrz"[/Orz/] #=>"Orz"
|"囧rz"[/Orz/]
當左邊的字符串當中含有左邊的正則表達式內容的時候，系統就會放回該串字符(String)
另外一種就是檢查字符是否有符合正則表達式的描述的「部分」
|"XRZOrz" =~ /Orz/ #=> 3
如果有，系統會返回符合部分的開始 index (String 的 index 參考String筆記或者幫助)
否則，就會返回 nil
|"囧rz" =` /Orz/ #=> nil
這個行爲，我們稱之為「匹配」
如上所說，匹配的結果一般有兩種：
「nil」或者「整數」。
不過，雖然匹配的結果不是「true」或者「false」這樣的真假值(Boolean)
當我們需要用「匹配」的結果來進行分歧時候，
我們還是完全可以用 if "囧rz" =` /Orz/ 或者 unless "囧rz" =` /Orz/ 來判斷
(關於 nil 和 false 的關係，numerical 和 true 的關係，請參照FalseClass 和 TrueClass)
：關於正則表達式當中的古怪的字母公式...
在未曾接觸到正則表達式之前，很多情况下會覺得正則表達式沒有規律、難以理解
但是實際上，這些古怪的字母公式是有一定規則的。
這些古怪的字母公式一個分爲三種：
第一，就是指定的單個字符：
a
b
c
當使用指定的單個字符去組成正則表達式的時候，
匹配的對象一定要跟表達式內容完全相符。
|"orzsro" =~ /OrzsrO/ #=> nil(false)
|"OrzsrO" =~ /OrzsrO/ #=> 0 (true)
第二個是元字符：
|"看！gray airplane～" =~ /\S！\D*\s\D*[～]$/ #=> 0
元字符的特徵是以「\」、「^」、「*」這些非字母符號開頭
元字符的作用是進行模糊匹配。
簡單來說：
單個字符具有惟一的匹配意義
元字符具有浮動的匹配意義範圍
關於元字符的匹配範圍，可以通過正則表達式的幫助查得。
最後一種是()
|"看！gray airplane～" =~ /(\S)！(\D*)\s\(D*)([～]$)/ #=> 0
|p $1, $2, $3, $4 #=> print "看" "gray" "airplane" "～"
「( )」不具有匹配意義。也就是說正則表達式當中的( )字符不參與匹配行爲
但是 ( )有個非常重要的作用：
就是當匹配成功的時候，抽出匹配部分幷記錄在 $1，$2，$3...之類的變量當中
：常用的元字符有那些
匹配除「換行符」以外的全部符號：
.
指定字符範圍匹配：
[]
例子：/[A-Z]/ #匹配所有大寫字母
單獨匹配「數字」：
\d
[0-9]
單獨匹配「英語字母」：
[A-Za-z]
匹配「數字」與「字母」與「中文字」：
\w
匹配「空格」、「製表符」、「換行符」、「回車符」「換頁符」等「空字符」：
\s
[ \t\n\r\f] #留意這裏不是[\t\n\r\f]
匹配字符串的開端：
\A
匹配「換行符」後段落的開始：
^
匹配所有「非數字」：
\D
匹配所有非「數字」與「字母」與「中文字」：
\W
匹配包括「數字」、「英語字母」、「漢字」、「標點符號」等等所有「非空字符」：
\S
匹配字符串的結尾(不包括「換行符」)：
\Z
匹配字符串的結尾(包括「換行符」)：
\z
匹配「換行符」前段落的結尾(特殊，這個匹配符號是放在需要匹配的結尾字符後面的)：
$
例子：/z$/
匹配出現次數(特殊，這個匹配符號是放在需要匹配的字符和元字符後面的)
「零」至「無限」次：
*
例子：/\d*/
n 次：
{n}
例子：/\d{2}/
n 次以上：
{n,}
例子：/\d{2,}/
n 到 m 次：
{n,m}
例子：/\d{2,4}/
選擇性匹配(特殊，這個匹配符號是放在可以選擇匹配多個字符或元字符之間的)：
|
例子：/O|o/
抽出匹配部分字符，幷記錄在相應數字的 $1,$2,$3...變量當中
( )
單獨匹配亞洲文以及非Latin字符
神說：「所有文字都是平等的」，因此沒有這個方法。(那爲甚麼英語Latin字符可以...)
更多元符號參照正則表達式幫助 ^ ^
：可以組合兩個正則表達式嗎？
正常途徑辦不到，但是不等於不行。看看以下例子
|a = "\D*[a-z]"
|b = "\S\sz$"
|c = /#{a}#{b}/ #=>/\D*[a-z]\S\sz$/
這樣的組合是根據「正則表達式是Regexp根據其字符參數生成的一個實例」這一條原則組合的
先把兩個字符組合，然後再把他們當作一個參數傳給 Regexp Class 生成一個正則表達式實例
：如何抽取字符當中的有效部分？
把正則表達式中預計需要抽出的部分用( )框起來，然後再用 $1，$2，$3...等變量讀取
：如何使用「變量」控制「正則表達式」？
|keyword = 'error'
|str = "errorsdfsdf"
|str =~ /#{keyword}/ #=> 0
To be continued

复制代码

禾西 · 发表于 2008-6-6 21:15:26

本帖最后由禾西于 2010-11-13 07:59 编辑

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

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

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

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

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

class Test
One = 1 #定义一个常量
$two = 0 #定义一个全局变量
@@three = 0 #定义一个类变量
def init
@four = 0 #定义一个实例变量
five = 5 #定义一个本地变量
p One, $two, @@three, @four, five
end
def modify
$two = 2
@@three = 3
@four = 4
five = 5
p One, $two, @@three, @four, five
end
def test1
p One, $two, @@three, @four
end
def test2
p One, $two, @@three, @four, ifve
end
end
app = Test.new
app.init #=> 1, 0, 0, 0, 5
app.modify #=> 1, 2, 3, 4, 5
app2 = Test.new
app2.test1 #=> 1, 2, 3, nil
app2.test2 #=> 出错，未定义本地变量 five

复制代码

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

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

class Test
def test
One = 1 #=> 语法错误(Syntax Error)
end
end

复制代码

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

帐号		自动登录	找回密码
密码			注册会员

[已经过期] Ruby 使用笔记

加入我们，或者，欢迎回来。

评分

加入我们，或者，欢迎回来。

贵宾