ruby学习
交互式命令
irb
instance_methods(false)，列出对象（类）内部的可用方法，用于调查解析对象的使用。
respond_to? 调查对象的方法/属性是否可用。
send 执行对象的方法。
class Game
def initialize(title = "aaaa", price = 200)
@title = title
@price = price
end
def show()
puts "biaoti:#{
@title}"
puts "jiage: #{
@price}"
end
def show2()
end
def show3()
end
puts Game.instance_method(false)
mari = Game.new("chaojimaliao", 350);
if mari.respond_to?("show")
mari.send("show")
end
attr_accessor:定义可存取对象的属性
提供了可供对象外部使用的属性。
class Game
attr_accessor :price #, :title
def initialize(title = "bbbb", price = 200)
@title = title
@price = price
end
def show()
puts "biaoti: #{
@title}"
puts "jiage: #{
@price}"
end
end
mygame = Game.new()
mygame.show()
puts "title is" + mygame.respond_to?("title").to_s
puts "price is" + mygame.respond_to?("price").to_s
# mygame.title = "Super Mario world"
mygame.price = 150
mygame.show()
判断是否是一个数组
if games.respond_to?("each")
end
如果games示例有each方法，那就是数组；
之后全备注
END
字符串运算：
+字符连接
<<字符带入
*字符循环
数据结构
mvp_rank = {
"curry" => 28.1,
"harden" => 30.3,
"lebron" => 26
}
puts mvp_rank["harden"]
player = {
name: "harden",
age: 28,
}
puts player[:name]
to_i 和 to_s 区别
静态方法，不能用实例去调用，直接用类点方法名调用
class Game
def self.toStr
puts "I love this game!"
end
end
module与class区别
module BaseFunc
Version = "0.0.1"
def v
return Version
end
def add(a,b)
return a + b
end
def self.showVersion
return Version
end
# 将v方法定义范围静态方法
module_function :v
end
puts BaseFunc::Version
puts BaseFunc.showVersion
puts BaseFunc.v
#puts BaseFunc.add(10, 30)
class BaseClass include BaseFunc
end
puts "================================"
puts BaseClass::Version
# puts BaseClass.showVersion
# puts BaseClass.v
myCls = BaseClass.new
puts myCls.add(10,20)
foo = "str"
foo.instance_f?(String)
ruby中的库都叫Gems
fixum 和 bignum 区别
a = 3
a.class
b = 1_000000000000.class
3.even? # 判断偶数
3.odd? # 判断奇数
字符串可以改变值
a = 'asdf'
a.object_id
a[1] = 'c'
a.object_id
Symbol
:foo
:foo.class # Symbol
a.to_sym # 把字符串a变成symbol
看一下ruby中内存位置
a = Array.new(3, 'asdf')
a[0][0] = 'b'
a # 发现三个位置都变成bsdf
a = Array.new(3) {
'asdf'}
a[0][0] = 'b'
a # 发现只有第一个位置变了
还有一种定义字符串方法
arr = %w(foo bar wut wat)
fetch用法
arr.fetch(0) # 取下标0位置的值
arr.fetch(5, 'asdf') # 取下标5位置的值，要是取不到，就返回默认值 asdf
uniq
arr.uniq # 去重，跟set一样
shuffle
arr.shuffle # 打乱
遍历数组
arr.each {
|e| p e}
判断
arr.any? {
|e| e < 0}
Hash
h = {
a: 3, b: 4}
=> {
:a=>3, :b=>4}
里面的key都是symbol，因为symbol都是unitable，静态的不会变，所以key用symbol；
除此之外，key也可以用字符串做，虽然字符串是muteable，但是ruby私底下，都给每个字符串做了备份，虽然字符串改变了，但是备份的字符串没有改变；
h = Hash.new {
|h, k| h[k] = []}
h[:a] << 1
h
h[:b]
h[:c] = 3
h.delete(:a)
h.assoc(:b) # 把key的b和value都取出来
起别名
alias :new_name :old_name
运算符重新定义，运算符就是一个方法
arr = [1,2,3]
def arr.+(num)
self.dup << num
end
arr + 5
*b
def foo(a, *b, c)
p a
p b
p c
end
foo(1,2,3,4,5)
&
把proc转成block
arr = %w(a b c)
arr.map(&:capitalize)
等于下面这个
arr.map {
|x| x.capitalize}
proc和lambda区别
proc的行为更像Proc，lambda行为更像方法
p = Proc.new {
|x, y| p x, y}
p.call(1)
p.call(2)
p.call(1,2)
p.call(1,2,3)
l = lambda {
|x,y| p x, y}
l.call(1) # 会报错
l.call(1,2)
l.call(1,2,3) # 会报错
p = Proc.new {
|x| return if x > 0}
p.call(1)
# 会报错，因为没有函数把它包起来，return的时候会报错
l = lambda {
|x| return if x > 0}
l.call(1)
# 不会报错
ancestors
Point.ancestors
p.methods
p.class
methods class 都是introspection反省自己
attr_accessor和attr_reader
attr_accessor 就是 getter and setter
attr_reader 就是 getter
class Point
attr_accessor :x
attr_reader :y
@@origin = 0
ORIGIN = 2
def initialize(x = 0, y = 0)
@x, @y = x, y
end
def first_quadrant? # 这是instant的method
x > 0 && y > 0
# self.x > 0 && self.y > 0
end
def +(p2)
Point.new(x + p2.x, y + p2.y)
# self ，这里的self是指对象
end
def self.second_quadrant?(x,y) # 这里是class的method
x < 0 && y > 0
# self，这里的self是指类
end
class << self # 在这里面可以定义很多class的method，并不需要加self.
def foo
end
def bar
end
def wat
end
end
# self，这里的self也是指类
def self.get_origin
@@origin
end
end
p = Point.new(1,2)
p.x
p = Point.new(-1,0)
p1 = Point.new(2, 3)
p2 = Point.new(3, 4)
p1 + p2
Point.second_quadrant?(2,3)
Point.foo
Point.bar
Point.get_origin
Point::ORIGIN
子类可以继承父类的所有method
Mixin Ruby Module
include : mixin module instance method as class’ instance method
extend : mixin module instance methods as class’ class methods
module Helper
def self.distance(obj1, obj2)
Math.sqrt((obj1.x - obj2.x) ** 2 + (obj1.y - obj2.y) ** 2)
end
def shift_right(x,y,z = 0)
return x + 3, y, z
end
end
module里面不能生成instance
class Point
include Helper
end
p1 = Point.new(1,2)
p2 = Point.new(1,4)
p1.shift_right(p1.x, p1.y)
Point.distance # 会报错，不能调用 class instance
class Point
extend Helper
end
Point.shift_right(1,2)
同时变成instant method和class method
module Helper
def shift_right(x,y,z=0)
return x + 3, y, z
end
module ClassMethod
def distance(obj1, obj2)
Math.sqrt((obj1.x - obj2.x) ** 2 + (obj1.y - obj2.y) ** 2)
end
end
def self.include(klass) # 这个相当于回调，表示当前module被include，这个就会被调用
klass.extend ClassMethods
end
end
class Point
include Helper
end
Point.included_modules
Point.is_a? Module
singleton
str = 'hello world'
def str.foo
puts 'foo'
end
str.singleton_class
str.singleton_class.instance_methods(false)
=> [:foo]
An object’s singleton method == its singleton class’ instance method
Enumerable and Comparable
可列举的，可比较的
Enumerable.instance_methods
Fixnumber.included_moduless
Regex正则
?是匹配0个或者1个
*可以是0个，也可以是无穷个
+一个或者多个
.是任意字符，但是不包括换行
i是大小写不分
m包含换行
[abc]可以匹配a或b或c，[a-z]
r[^a-z]+y # 在这里^反而是取反的意思
多线程
Thread.current hash
count = 0
arr = []
10.times do |i|
arr[i] = Thread.new {
sleep(rand(0)/10.0)
Thread.current["count"] = count
count += 1
}
end
arr.each {
|t| t.join; print t["count"], ", "}
puts "count = #{
count}"
Thread priority
count1 = count2 = 0
a = Thread.new do
loop {
count1 += 1 }
end
a.priority = -1
b = Thread.new do
loop {
count2 += 1 }
end
b.priority = -2
sleep 1
count1
count2