id int not null auto_increment,
    foo varchar(100) not null,
    bar text not null,
    primary key (id)
) Type=MyISAM CHARACTER SET utf8;


这里创建表类型时要使用MyISAM类型,因为只有MyISAM类型才支持完整的utf8.最后设置编码utf8.

1.dbi操作数据库
	如果你本地编码时gbk的话,首先要默认类Iconv进行转换.
		require 'iconv'
		def gb2u str
			conv = Iconv.new("UTF-8", "GBK")
			str = conv.iconv(str)
			str << conv.iconv(nil)
			conv.close

			str
		end

	插入代码:
		DBI.connect('DBI:Mysql:test:localhost', 'mysql', '') { |dbh|
	 		dbh.execute 'SET NAMES utf8'  #这里要指明代码
     			1.upto(13) { |i|
	  			st.execute("insert into samples(foo, bar) values('#{gb2u('一')}#{i}', '#{gb2u('二')}')")
	  		}
     		}



2.activerecord
	activerecord是对dbi的包装.(也更神,呵呵!)
	代码:
		require     'rubygems'
		require_gem 'activerecord' #因为我是gem的安装

		ActiveRecord::Base.establish_connection(
			:adapter =>  "mysql",
			:host     => "localhost",
			:database => "test",
			:username => "mysql",
			:password => "",
			:encoding => "utf8") #编码只需这里指明

		#指明表
		class Mytab < ActiveRecord::Base
			set_table_name 'samples'
		end

		#插入数据
		tab = Mytab.new
		tab.foo= gb2u('一')
		tab.bar = gb2u('二')
		tab.save

		#查询数据
		data = Mytab.find(:all)
		data.each { |line| 
			puts "['#{line[:id]}', '#{line[:foo]}, '#{line[:bar]}]" 
		}

    def initialize(name, artist, duration)
    	@name     = name
   	@artist   = artist
    	@duration = duration

	@plays    = 0		##对象变量
    end

    def to_s
    	"Song: #@name--#@artist (#@duration)"
    end

  def name	##函数式的公开所有变量
    @name
  end
  def artist
    @artist
  end
  def duration
    @duration
  end

  def call_block
    puts "Start of method"
    yield					##执行传入的参数.这里为"In the block"
    yield
    puts "End of method"
  end

  call_block { puts "In the block" }

##############################################

  "gin joint".length	#所有都是以Object为root
  "Rick".index("c")
  -1942.abs
  sam.play(song)

song1 = Song.new("Ruby Tuesday")
song2 = Song.new("Enveloped in Python")
# and so on

    本质上来说，一个闭包是一块代码，它们能作为参数传递给一个方法调用。我将通过一个简单的例子来阐述这个观点。假设我们有一个包含一些雇员对象的列表，然后我想列出职位为经理的员工，这样的员工可以通过IsManager判断。在C#里，我们可能会写出下面类似的代码：

  public static IList Managers(IList emps) {
    IList result = new ArrayList();
    foreach(Employee e in emps)
      if (e.IsManager) result.Add(e);
    return result;
  }

    在一种支持闭包的语言中，比如Ruby，我们可以这样写：

  def managers(emps)
	return emps.select {|e| e.isManager}
  end
  

    select是Ruby中定义的集合结构中的一个方法，它接受一个block，也就是闭包，作为一个参数。在Ruby中，闭包写在一对大括号中（不止这一种方法，另一种为do .. end）。如果这个块也接受参数，你可以将这些参数放到两个竖线之间。select方法循环迭代给定的数组，对每个元素执行给定的block，然后将每次执行block返回true的元素组成一个新的数组再返回。

    现在，如果你是C程序员你也许要想，通过函数指针也可以实现，如果你是JAVA程序员，你可能回想我可以用匿名内类来实现，而一个C#者则会想到代理（delegate）。这些机制和闭包类似，但是它们和闭包之间有两个明显得区别。

    第一个是形式上的不同（The first one is a formal difference）。闭包可以引用它定义时候可见的变量。看看下面的方法：

def highPaid(emps)
	threshold = 150
	return emps.select {|e| e.salary > threshold}
end
  

    注意select的block代码中引用了在包含它的方法中的局部变量，而其它不支持真正闭包的语言使用其它方法达到类似功能的方法则不能这样做。闭包还允许你做更有趣的事情，比如下面方法：

def paidMore(amount)
	return Proc.new {|e| e.salary > amount}
end

    这个方法返回一个闭包，实际上它返回一个依赖于传给它的参数的闭包。我可以用一个参数创建一个这样的方法，然后再把它赋给另一个变量。

highPaid = paidMore(150)

    变量 highPaid 包含了一段代码（在Ruby中是一个Proc对象），这段代码将判断一个对象的salary属性是否大于150。我们可以这样使用这个方法：

john = Employee.new
john.salary = 200
print highPaid.call(john)
  

      表达式highPaid.call(john)调用我之前定义的代码，这时候此代码中的amount已经在创建这方法的时候绑定为150。即使现在我执行print 的时候，150已经不在它的范围内了，但是amount和150之间的绑定依然存在。

    所以，闭包的第一个关键点是闭包是一段代码加上和定义它的环境之间的绑定（they are a block of code plus the bindings to the environment they came from）。这是闭包和函数指针等其它相似技术的不同点（java匿名内类可以访问局部变量，但是只有当这些内类是final的时候才行）。

    第二个不同点不是定义形式的不同，但是也同样重要。（The second difference is less of a defined formal difference, but is just as important, if not more so in practice）。支持闭包的语言允许你用很少的语法去定义一个闭包，尽管这点可能不是很重要的一点，但我相信这点是至关重要的－这是使得人们能很自然的使用闭包的关键点。看看Lisp，Smalltalk和Ruby，闭包遍布各处－比其它语言中类似的使用多很多。绑定局部变量是它的特点之一，但我想最大的原因是使用闭包的语法和符号非常简单和清楚。

    一个很好的相关例子是从Smalltalk程序员到JAVA程序员，开始时很多人，包括我，试验性的将在Smalltalk中使用闭包的地方在Java中使用匿名内类来实现。但结果使得代码变得混乱难看，所以我们不得不放弃。

   我在Ruby经常使用闭包，但我不打算创建Proc对象，然后传来传去。大多数时间我用闭包来处理前面我提到的select等基于集合对象的方法。闭包另一个重要用途是'execute around method'，比如处理一个文件：

File.open(filename) {|f| doSomethingWithFile(f)}

   这里open方法打开一个文件，然后执行给定的block，然后关闭它。这样处理非常方便，尤其是对事务（要求commit或者rollback），或者其它的你需要在处理结束时候作一些收尾处理的事情。我在我的xml文档转换中广泛使用这个优点。

   闭包的这些用法显然远不如用Lisp语言的人遇到的多，即使我，在使用没有闭包支持的语言的时候，也会想念这些东西。闭包就像一些你第一眼见到觉得不怎么样的东西，但你很快就会喜欢上它们。