一、什么是ruby
Ø Ruby是"一种用于迅速和简便的面向对象编程的解释性脚本语言";
1、解释性脚本语言
2、迅速和简便
3、面向对象编程
二、Ruby的构造元素
1. 字符串
| 函数 | 说明 | 示例 |
| sub | 替换第一次遇到匹配的串 | p"aab".sub("a", "c") » " cab " |
| gsub | 替换所有匹配串 | "aaaaa".gsub("aa", "bb") » "bbbba" |
| split | 按照指定串进行分割，并存入数组 | "abc".split("b") »["a", "c"] |
| scan | 使用正则表达式re反复对self进行匹配操作,并以数组的形式返回匹配成功的子字符串 | a = "aa bb" a.scan(/\w+/) » ["aa", "bb"] arr = [] |
| strip | 删除头部和尾部的所有空白字符 | " test ".strip » "test" |
2、数组
| 函数 | 说明 | 示例 |
| + | 返回两数组的并集，但不排除重复元素 | [1,2]+[2,3] » [1,2,2,3] |
| - | 返回第一个数组与第二个数组不同的元素 | [1,2]-[2,3] » [1] |
| << | 追加元素，但不排除重复元素 | [1,2]<<[2,3] » [1,2,[2,3]] |
| | | 追加元素，但排除重复元素 | [1,2] | [2,3] » [1,2,3] |
| & | 数组与，返回两数组的交集 | [1,2] & [2,3] » [2] |
| delete_at | 删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil | a = ["ant", "bat", "cat", "dog"] a.delete_at(2) » "cat" a » ["ant", "bat","dog"] a.delete_at(99) » nil |
| Each | 对数组的每个元素按值进行迭代操作 | a = [ "a", "b", "c" ] a.each {|x| print x} » "abc " |
| each_index | 对数组的每个元素按索引进行迭代操作 | a = [ "a", "b", "c" ] a.each_index {|x| print x, " -- " } » "0 -- 1 -- 2 --" |
| join | 将数组元素按一定的分隔符连接起来 | [ "a", "b", "c" ].join » "abc" [ "a", "b", "c" ].join("-") » "a-b-c" |
| to_s | 将数组的所有元素连接成字符串 | ["a","e","i","o"].to_s » "aeio" |
追加和连续的区别：
Ø +：给一个数组添加元素，创建一个新的数组
Ø <<：给一个数据添加元素，直接操作原数组，当给一个数组添加的新元 素也是一个数组时,该新元素作为数组的最后一个元素：
a=[1,2,3]
b=[4,5,6]
p(a+b) #=>[1, 2, 3, 4, 5, 6]
p(a<<b) #=>[1, 2, 3, [4, 5, 6]]
p(a<< 4) #=>[1, 2,3, 4]
p(a+ 4) #=>TypeError:can't convert Fixnum into Array
ruby 是一种强类型语言
3、散列表
Ø .复制Hash：
和数组一样，我们可以把一个Hash变量分配给另一个hash变量，它们都引用想同的Hash，所以如果其中一个的值变了，那么另外一个的值也会跟着变：
h3= h2
h3["one"]= "西安"
putsh2["one"] #=>"西安“
有的时候我们不希望上面的情况发生，即：修改了其中一个的值另一个也跟着修改了，我们可以使用clone方法make a new copy
h4= h2.clone
h4["one"]= "大连"
putsh2["one"] #=>"西安"（i.e. 值没有修改）
4、代码块
Ø 代码块可作为参数直接传递给函数，而无需包装在其他结构中传递。
<span style="font-size:18px;">def my_def
if block_given?
puts "hello world"
else
puts "sad"
end
end
my_def #=> sad
my_def{"hello"} #=>hello world
my_def{""} #=>hello world
my_def{} #=>hello world
</span>
三、类
1、变量
ruby的变量有局部变量，全局变量，实例变量，类变量，常量。
Ø 局部变量
局部变量以一个小写字母开头或下划线开头。局部变量有局部作用域限制（比如一个block内），它的作用域起始于声明处，结束于该声明所在的块、方法定义、类/模块定义的结尾。
Ø 全局变量
ruby的全局变量以$开头，例如: $x $y。全局变量可以在程序的任何地方加以引用。全局变量无需变量声明。引用尚未初始化的全局变量时，其值为nil
ruby有内置的全局变量，例如 $！记录最近一次产生的错误，$.表示行号等。良好的编程习惯，是不使用全局变量，他们危险而难以跟踪。
Ø 实例变量
ruby的实例变量以@开头，其作用域内置于、关联于当前对象。
Ø 类变量
ruby的类变量以@@开头，例如在类里申明的@@x@@y 等。类变量在类的定义中定义，可以在类的特殊方法、实例方法等处对类变量进行赋值和引用。类变量被类，类的子类和他们的实例对象共享。
<span style="font-size:18px;">class Square
def initialize(x)
@x = x
if defined?(@@num)
@@num += 1
else
@@num = 1
end
end
def scount
puts "@@num = #{@@num}"
puts "@x = #{@x}"
end
end
s1 = Square.new(2)
s1.scount
s2 = Square.new(3)
s1.scount
s2.scount
输出：
@@num = 1
@x = 2
@@num = 2
@x = 2
@@num = 2
@x = 3</span>
Ø 常量
ruby的常量以大写字母开头，常数的定义和初始化由赋值过程完成。
2、类
<span style="font-size:18px;">class Point
def initialize(x, y)
@x = x
@y = y
end
def x
@x
end
def x(value)
@x = value
end
end
p = Point.new(3,4)
puts "p.x is #{p.x}\n"
p.x(44);</span>
Ø 类方法
<span style="font-size:18px;"> class Temp
def self.print
puts "A"
end
def print
puts "B"
end
end
x = Temp.new
Temp.print
x.print
输出：
A
B
</span>
class 类名< 父类名
…
end
例如定义测试用例类:
class My_class< Test::Unit::TestCase
…
end
Ø类的重写
若子类重写父类的方法，则子类的对象调用的为子类重写的方法。对于未被重写的方法，子类对象调用起父类的方法。
<span style="font-size:18px;">class Parent
def Adef
puts "parent A"
end
def Bdef
puts "parent B"
end
end
class Child < Parent
def Adef
puts "child A"
end
end
child = Child.new
child.Adef
child.Bdef
输出：
child A
parent B<strong>
</strong></span>Ø 封装
3、模块Module
模块提供了一种结构，用来 把ruby类、方法和常量收集到单独命名和定义的单元中。这样可以有效避免与现有类、方法和常量发生冲突。
Ø 模块和类的相互嵌套
Øload和require和include
require “filename”
load “filename.rb”
include My_module
Øload和require区别
file_to_be_load.rb
puts 'It is in ' + __FILE__
test.rb
require 'file_to_be_load' #=> It is in file_to_be_load.rb
require 'file_to_be_load' #=>
load 'file_to_be_load.rb' #=> It is in file_to_be_load.rb
load 'file_to_be_load.rb' #=> It is in file_to_be_load.rb
3174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
