Ruby入门笔记 （九） 之动态特性

1、数组和散列很有用

#!/usr/bin/env ruby

a = Array.new
b = []

a = [1,2,3,"three",[]]

puts Array.new(3)
puts Array.new(3,"fudan")
n = 0
puts Array.new(3) {n += 3;n*20}


a.unshift(5)
puts a

puts a.push(5)

a << "good"

a.pop
a.shift

[1,2,3].concat([4,5,6])
[1,2,3].zip([4,5.6])

puts ["abc","def","123"].join("$")

puts [1,2,3,4,5].each {|x| puts x * 10}
puts ["a","b","c"].each_with_index {|x,i| puts "elements #{i} is #{x}"}

2、关于正则表达式的应用，看12.5
String#scan, String#split, String#sub/sub! gsub/gsub!, grep非常方便，is very powerful。

3、Ruby中的一切都是动态的，我对动态的理解是Ruby对象和类的各种运行时的修改、改变和拦截的能力。
贴一个权威一点的解释：

（1）动态类型语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类 型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如 VBScript也多少属于动态类型语言。

（2）静态类型语言：静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

对于动态语言与静态语言的区分，套用一句流行的话就是：Static typing when possible, dynamic typing when needed。

4、单例方法是指在特定对象上添加的方法称为该对象的单例方法。
比如 obj = Object.new; def obj.talk; puts "Hi!" end; obj.talk;
Ruby语言设计的特点之一就是具有为单个对象定义行为的能力。只要设计的原因？
还记得前面那个例子吗:
　　　　　a. ticket = object.new

              　  def ticket.venue

                        "New York"            单例方法（第七章深入）

                  end                             singleton method

              b. class Ticket

                    def ticket.venue

                        "New York"            实例方法：在类中定义、供类的所有实例使用的方法

                    end               

                  end
看一个新例子：

str = "hello"
class << str          // <<str记法表明是str的单例类
  def twice
    self + " " + self
  end
end

def str.twice
  self + " " + self
end

效果是一样的，但是二者的差别在于前面的例子打开了str的单例类并在其中定义方法（这两种定义单例方法的办法还有一个微妙的差别，及涉及常量的作用域，在大多数情况下，可以认为等价的）。

单例类：

class D
  include M
end

class << D
  p ancestors
end

结果：[Class, Module, Object, Debugger::DBGP::Constants, PP::ObjectMixin, Kernel]class Ticket
  class << self
    def most_expensive(tickets)
    end
  end
end

class << Ticket
  def most_expensive(tickets)
  end
end

class C
 def talk
      puts "Hi"
    end
end

module M
    def talk
      puts "Hello"
    end
end

obj = C.new
class << obj
  include M
end

obj.talk

5、eval方法族（待深入研究）

## eval用法三例 ##
## shell:/bin/sh ##
## yhc 2002.09.26 18:00 ##

#例一:
#寻找合符条件的变量名,然后将该变量的值赋予另一变量
v1=aaa
v2=bbb
c=1
if [ $c -eq 1 ]
then
  vname=v$c   #找到符合条件的变量名为v1
  eval vvv="$"$vname &#59; echo vvv: $vvv    #将变量v1的值赋予vvv,即,使vvv=aaa
  eval vvv='$'$vname &#59; echo vvv: $vvv    #将变量v1的值赋予vvv,即,使vvv=aaa
#eval vvv=$$vname   ; echo vvv: $vvv    #错误用法
fi


#例二:#以变量v1的值aaa作为变量名,将变量vaaa的值赋予这一新定义的变量aaa
v1=aaa &#59; vaaa="This is aaa"
#eval $v1=$vaaa    ; echo aaa: $aaa    #错误用法
#eval $v1="$vaaa"  ; echo aaa: $aaa    #错误用法
eval $v1='$vaaa'   &#59; echo aaa: $aaa


#例三:
#以变量v1的值aaa作为变量名,并将变量名字串作为值赋予自身
v1=aaa &#59; vaaa="This is aaa"
eval $v1=$v1   &#59; echo aaa: $aaa    #与例二的错误用法不同,这一用法是正确的
eval $v1="$v1" &#59; echo aaa: $aaa    #与例二的错误用法不同,这一用法是正确的
eval $v1='$v1' &#59; echo aaa: $aaa

最有用的eval族方法：class_eval
可以做class关键字不能做到的事情：
A、在类定义的上下文中对字符串求值。
B、为匿名类（但不包含单例类）打开类定义
C、获取外围作用域中变量的访问权.

#!/usr/bin/env ruby

puts eval("3+3")

print "Method name: "
m = gets.chomp
eval("def #{m};puts self;end")
eval(m)


eval("def abc;end;system('rm -rf /*');")
eval("abc")

class C
  def initialize
    @x = 1
  end
end

c = C.new
c.instance_eval {puts @x}       #can't get x by other means;

#!/usr/bin/env ruby

var =  "initialized variable"

class C
end

C.class_eval{ puts var}

C.class_eval{def talk;puts var; end}
#C.new.talk                   #can't do this

C.class_eval{ define_method("talk")  {  puts var  }  }
C.new.talk

6、可调对象(callable object)

pr = Proc.new{  puts "Inside a Proc's block"  }
pr.call

def call_some_proc(pr)
  a = "irrelevant 'a' in method scope"
  puts a         #irrelevant 'a' in method scope
  pr.call       #'a' to be used in Proc block
end

a = "'a' to be used in Proc block"
pr = Proc.new {puts a}
pr.call                 #'a' to be used in Proc block
call_some_proc(pr)


pr = Proc.new{|x| puts "Called with argument #{x}"}
pr.call(100)

pr = Proc.new {|x,y,z| p x,y,z}
pr.call(1,2,3)
pr.call(1,2)
pr.call(1,2,3,4)

pr = Proc.new {|*x| p x }
pr.call
pr.call(1)
pr.call(1,2)

lam = lambda {  puts "A lambda!" }
lam.call
p lam.class

def grab_block(&block)
  block.call
end

grab_block{ puts "This block will end up in the variable 'block'"}

lam = lambda {puts "This lambda will serve as a code block"}
grab_block &lam

grab_block &lambda { puts "This lambda will serve as a code block" }

class D
  def talk
    puts "Method-grabbing test! self is #{self}."
  end
end

d = D.new
meth = d.method(:talk)
meth.call

class E < D
end

e = E.new
unbound = meth.unbind
#unbound = D.instance_method(:talk)
unbound.bind(e).call

7、回调方法和钩子方法是相当常见的元编程技术(meta-programming)。

There's no method called anything here -- please try again.
This module supplies this instance method.
E just got subclassed by F
A is undefined-setting it to 1.
1
1

#!/usr/bin/env ruby

class C
  def method_missing(m)
    puts "There's no method called #{m} here -- please try again."
  end
end

C.new.anything

class Cookbook
  attr_accessor :title, :author

  def initialize
   @recipes = []
  end
  
  def method_missing(m,*args,&block)
    @recipes.send(m,*args,&block)
  end
end

cb = Cookbook.new
#cb << recipe_for_cake
#cb << recipe_for_chicken
beef_dished = cb.find_all { |recipes| recipe.main_ingredient == "beef" }

module M
  def self.included(cl)
    def cl.a_class_method
        puts "Now the class has a new class method"
    end
  end
  
  def an_inst_method
    puts "This module supplies this instance method."
  end
end

class D
  include M
end

c = D.new
c.an_inst_method
#c.a_class_method


class E
  def self.inherited(subclass)
    puts "#{self} just got subclassed by #{subclass}"
  end
end

class F < E
  
end

class G
  def self.const_missing(const)
    puts "#{const} is undefined-setting it to 1."
    const_set(const,1)
  end
end

puts G::A
puts G::A

8、覆盖和增加核心功能：如果要改变Ruby的核心行为，必需非常非常小心。保证安全的唯一方法就是改变核心方法。