[汇]Ruby知识点（一）

1.介绍Ruby的多线程

Ruby的多线程是用户级多线程，这样使得Ruby的多线程移植很是容易，你并不需关心具体的操做系统；这样作也使线程容易控制，程序不容易产生死锁这类严重的线程问题。
可是同时，因为Ruby的多线程并非真正意义上的操做系统级多线程，无论代码使用了多少个Thread类的实例，都只会在启动解释器这一个进程内执行，由Ruby解释器进行具体的线程切换管理，其效率要低于由操做系统管理线程的效率，且不能使用多个CPU。
在Ruby中同时作多件事最简单的方式就是使用Thread类，Thread类提供了一种高效和轻量级的手段来同时处理多件任务。
Thread类由Ruby解释器具体实现，提供了一种同时处理多个任务的方法， Thread类实现的并非操做系统级多线程。
Ruby多线程的优势和缺点一样明显，缺点是效率不如操做系统级多线程，不能使用多个CPU，但其优势也很明显，便可移植性很高。这就须要设计人员综合考虑。

当Ruby程序执行完毕的时候，他会杀掉全部的线程，无论其它的线程的运行状态如何。若是没有使用join方法，那么主程序执行完毕后会把全部没有执行完毕的线程杀掉。
上面的实例程序中，当主程序运行完毕时，两个线程都没有运行结束就被停止掉了。咱们可使用join方法来让主程序等待某个特定线程结束，对每个线程使用join方法，能够确保在程序结束前全部的线程能够运行完毕。

x = Thread.new { sleep 0.1; print “x”; print “y”; print “z” }
a = Thread.new { print “a”; print “b”; sleep 0.2; print “c” }
x.join
a.join

 

2.ruby如何进行集成操做？ruby能进行多重集成吗？

Ruby继承的语法很简单，使用 < 便可。
Ruby语言只支持单继承，每个类都只能有一个直接父类。这样避免了多继承的复杂度。但同时，Ruby提供了mixin的机制能够用来实现多继承。
可使用super关键字调用对象父类的方法，当super省略参数时，将使用当前方法的参数来进行调用。

3.ruby的特色

概括起来，Ruby有如下优势：
解释型执行，方便快捷
Ruby是解释型语言，其程序无需编译便可执行。
语法简单、优雅
语法比较简单，相似Algol系语法。
彻底面向对象
Ruby从一开始就被设计成纯粹的面向对象语言，所以全部东西都是对象，例如整数等基本数据类型。
内置正则式引擎，适合文本处理
Ruby支持功能强大的字符串操做和正则表达式检索功能，能够方便的对字符串进行处理。
自动垃圾收集
具备垃圾回收（Garbage Collect，GC）功能，能自动回收再也不使用的对象。不须要用户对内存进行管理。
跨平台和高度可移植性
Ruby支持多种平台，在Windows, Unix, Linux, MacOS上均可以运行。Ruby程序的可移植性很是好，绝大多数程序能够不加修改的在各类平台上加以运行。
有优雅、完善的异常处理机制
Ruby提供了一整套异常处理机制，能够方便优雅地处理代码处理出错的状况。
拥有不少高级特性
Ruby拥有不少高级特性，例如操做符重载、Mix-ins、特殊方法等等，是用这些特性能够方便地完成各类强大的功能。

同时，因为是解释型语言，Ruby也有下列缺点：
解释型语言，因此速度较慢
静态检查比较少

 

4.解释下ruby的特殊方法和特殊类

特殊方法是指某实例所特有的方法。一个对象有哪些行为由对向所属的类决定，可是有时候，一些特殊的对象有何其余对象不同的行为，在多数程序设计语言中，例如C++和Java，咱们必须定义一个新类，但在Ruby中，咱们能够定义只从属于某个特定对象的方法，这种方法咱们成为特殊方法(Singleton Method)。

class SingletonTest
  def info
   puts “This is This is SingletonTest method”
  end
end

obj1 = SingletonTest.new
obj2 = SingletonTest.new

def obj2.info
  puts “This is obj2″
end

obj1.info
obj2.info

 执行结果为：
This is This is SingletonTest method
This is obj2

有时候，咱们须要给一个对象定义一系列的特殊方法，若是按照前面的方法，那么只能一个一个定义：

def obj2.singleton_method1
end

def obj2.singleton_method2
end

def obj2.singleton_method3
end
……
def obj2.singleton_methodn
end

这样作很是繁复麻烦，并且没法给出一个统一的概念模型，所以Ruby提供了另一种方法，
class << obj
……
end

obj是一个具体的对象实例，class << 表明它的特殊类。

class SingletonTest
  def meth1
   puts “This is meth1″
  end

  def meth2
   puts “This is meth2″
  end
end

obj1 = SingletonTest.new
obj2 = SingletonTest.new

class << obj2
  def meth1
   puts “This is obj2′s meth1″
  end
 
  def meth2
   puts “This is obj2′s meth2″
  end
end

obj1.meth1
obj1.meth2
obj2.meth1
obj2.meth2

执行结果为：
This is meth1
This is meth2
This is obj2′s meth1
This is obj2′s meth2

 

5.ruby如何实现动态方法调用

在Ruby中，有多种方法能够实现方法的动态调用。1. 使用send方法第一种实现动态方法调用是使用send方法，send方法在Object类中定义，方法的第一个参数是一个符号用来表示所要调用的方法，后面则是所调用方法须要的参数。“This is a dog1″.send(:length) => 14上面的代码中经过send方法去对一个字符串执行length操做，返回字符串的长度。class TestClass def hello(*args)  ”Hello ” + args.join(‘ ‘) endenda = TestClass.newputs a.send :hello, “This”, “is”, “a”, “dog!”执行结果为：Hello This is a dog!2. 使用Method类和UnboundMethod类另外一种实现动态方法调用是使用Object类的method方法，这个方法返回一个Method类的对象。咱们可使用call方法来执行方法调用。test1 = “This is a dog1″.method(:length)test1.call  => 14class Test def initialize(var)  @var = var end  def hello()  ”Hello, @var = #{@var}” endendk = Test.new(10)m = k.method(:hello)m.call   #=> “Hello, @iv = 99″l = Test.new(‘Grant’)m = l.method(“hello”)m.call   #=> “Hello, @iv = Fred”能够在使用对象的任何地方使用method对象，当调用call方法时，参数所指明的方法会被执行，这种行为有些像Ｃ语言中的函数指针。你也能够把method对象做为一个迭代器使用。def square(a) a*aendmObj = method(:square)[1, 2, 3, 4].collect(&mObj)  => [1 4 9 16]Method对象都是和某一特定对象绑定的，也就是说你须要经过某一对象使用Method对象。你也能够经过UnboundMethod类建立对象，而后再把它绑定到某个具体的对象中。若是UnboundMethod对象调用时还没有绑定，则会引起异常。class Double def get_value  2 * @side end   def initialize(side)   @side = side  endenda = Double.instance_method(:get_value) #返回一个UnboundMethod对象s = Double.new(50)b = a.bind(s)puts b.call执行结果为：100看下面一个更具体的例子：class CommandInterpreterdef do_2() print “This is 2”; end def do_1() print “This is 1”; end def do_4() print “This is 4”; end def do_3() print “This is 3”; end   Dispatcher = {   ?2 => instance_method(:do_2),   ?1 => instance_method(:do_1),   ?4 => instance_method(:do_4),   ?3 => instance_method(:do_3) } def interpret(string)   string.each_byte {|i| Dispatcher[i].bind(self).call }  endendinterpreter = CommandInterpreter.newinterpreter.interpret(’1234′)执行结果为：This is 1This is 2This is 3This is 43. 使用eval方法咱们还可使用eval方法实现方法动态调用。eval方法在Kernel模块中定义，有多种变体如class_eval，module_eval，instance_eval等。Eval方法将分析其后的字符串参数并把这个字符串参数做为Ruby代码执行。str = “Hello”eval “str + ‘ World!’” => Hello World!sentence = %q{“This is a test!”.length}eval sentence => 15当咱们在使用eval方法时，咱们能够经过eval方法的第二个参数指明eval所运行代码的上下文环境，这个参数能够是Binding类对象或Proc类对象。Binding类封装了代码在某一环境运行的上下文，能够供之后使用。class BindingTest def initialize(n)   @value = n end def getBinding   return binding() #使用Kernel#binding方法返回一个Binding对象  endendobj1 = BindingTest.new(10)binding1 = obj1.getBindingobj2 = BindingTest.new(“Binding Test”)binding2 = obj2.getBindingputs eval(“@value”, binding1)  #=> 10puts eval(“@value”, binding2)  #=> Binding Testputs eval(“@value”)     #=> nil能够看到上述代码中，@value在binding1所指明的上下文环境中值为10，在binding2所指明的上下文环境中值为Binding Test。当eval方法不提供binding参数时，在当前上下文环境中@value并未定义，值为nil。