凌川__ http://kaichuan-zhang.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 变量一定要有类型吗（二） 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/56665  发表时间: 2007年03月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

变量一定要有类型吗（二）



变量一定要有类型吗？不一定。

在《The Ruby Way 2nd》一书中，1.2.3节 Constants, Variables, and Types
“In Ruby, variables do not have types, but the objects they refer to still have types. ” 在Ruby中，变量没有类型，但变量引用的对象有类型。
1.5.2节 Perspectives in Programming
“In Ruby, variables don't have classes; only values have classes.” Ruby里, 变量没有类别；只有值才有类别。

《The Ruby Way 2nd》所描述是真的吗？口说无凭，程序为证。 
a=5
puts  "a = #{a},  #{a.class}"   # => a = 5,  Fixnum

a="hh"    # a: 5 --> "hh"
puts  "a = #{a},  #{a.class}"   # => a = hh,  String

变量a只是一个符号，当a指向一个表达式的时候，那个表达式的值也许是Fixnum，也许是String。变量a并没有什么事先预定的类型；而且变量a在事后也不会固定在什么具体的类型上。 
a = x==nil ? 2 : x**2 < x<<2  ? 2.0 : ""
puts a.class

你能告诉我，变量a是什么类型吗？你如果问我，我只能说：
假设x = 2，程序输出为Float；
假设x = 4，程序输出为String；
假如x 是一个无返回值的方法，程序输出为Fixnum。

Gödel在证明不完备性定理时，用一个正整数指代某个数值；用另一个正整数指代某个运算符；而且，公式也用正整数指代；定理也用正整数指代…正整数只是符号，数值、运算符、公式、定理有区别，正整数没有类型差别。

变量只是符号，变量没有类型你如果不能接受，那么，我们自小熟悉的正整数只是代表不同类事物的符号，也许会让你发疯。

完备性、一致性、可证性似乎与主题不相关，其实，计算机编程语言是形式数学的直接产物。最初的LISP语言哪里有变量类型的概念，从C一路走来，到C++，到Java，变量的概念中塞入了太多的东西。一个子类拥有许许多多的内容，它父类的父类，最初的根类，只是一个符号。

你也许认为，变量有类型拓展了我们表达事物的能力，可事实是，如今Java程序、C++程序所作的并没有超越Turing当初的构想。假如某个语言因为变量有类型而实现了智能化，请你一定，一定要mail me。

人们在编程语言的道路上行走了几十年，跌跌绊绊，缝缝补补，没能见到希望中的曙光。这一切的努力是有意义的，但也许应该回到起初的地方，认真审视，重新选择方向。Ruby是一个值得去做的尝试。

A). Rails框架充分发挥了Ruby的动态性，继承ActiveRecord时，数据库中的表将被映射为一个Ruby类，你不用操心字段值的类型。在Java及其上的框架中则作不到。

B).假设有一个Java EE 项目，几个人分别在PowerDesigner里定义了几百甚至上千张表，连接上数据库，PowerDesigner 帮你自动在库中生成了这些表；在Hibernate 里SessionFactory创建JDBC连接， MyEclipse 为你自动生成了每张表相应的JavaBean。你现在要将表中的内容显示在前端网页表格中，不是很难，可问题是，每个表有几个字段，十几个字段，甚至更多，你显示的时候不仅要考虑到getXXX（），还要顾及到返回类型，有些字段又没有定义缺省值，上万个字段实在是无休止的折磨。假设出现在生活中，你只能无奈地写一个Java类，定义成静态方法，是为了直接调用。都是类型惹得祸。 
//package com.lilytech.hr.rsgl;
/*
 * Created on 2006-4-21
 *
 */

/**
 * @author Kaichuan Zhang
 *
 */
public class Wrap {
	public static String tostring(Object obj){
		try{
			return (obj!=null)?obj.toString():"";
		}catch(Exception err){
			return "";
		}	
	}
	
	public static String tostring(long obj){		
		try{
			return (new Long(obj)).toString();
		}catch(Exception err){
			return "";
		}	
	}
	
	public static String tostring(double obj){		
		try{
			return (new Double(obj)).toString();
		}catch(Exception err){
			return "";
		}	
	}
	
	public static String tostring(boolean obj){			
		try{
			return (new Boolean(obj)).toString();
		}catch(Exception err){
			return "";
		}	
	}
}

一门语言的变量有无类型，对于其上的框架之影响，如你在A). 与B).比较中所见。

结语：像Java，C++这样的静态语言需要变量有类型。而对于Ruby这样的动态语言，变量未必需要有类型。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 01 Mar 2007 07:05:38 +0800 http://kaichuan-zhang.javaeye.com/blog/56665 http://kaichuan-zhang.javaeye.com/blog/56665 变量一定要有类型吗（一） 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/56664  发表时间: 2007年03月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

先讨论一下Ruby是不是强类型。


1）.在《Beyond Java》September 2005 一书 6.1.2节Typing 中，Bruce Tate举例
irb(main):015:0> "fish"+4
TypeError: cannot convert Fixnum into String
from (irb):15:in‘+’
from (irb):15
从而得出结论：
引用
That means Ruby is strongly typed.


我们知道，Ruby是动态语言，在运行中边解释、边检测、边执行，检测类型匹配吗？不是检测类型匹配，而是检测语法。
String类的‘+’是一个方法，但是，Ruby从来不拒绝你重写方法。 
class String
  alias : old_plus :+
  def +(other)
    self.old_plus(other.to_s)    
  end  
end

puts "fish"+4       # => fish4
puts '1 ' + 2.3      # => 1 2.3



2）.Bruce Tate 在“跨越边界: Java 模型以外的类型策略”2006 年 6 月 一文中写到：
引用
...这两种语言都 倾向于 强类型...


这两种语言是指Java和 Ruby，他给出了一行Ruby代码来说明；

1 + "hello"
会收到以下错误消息：
TypeError: String can't be coerced into Fixnum
from (irb):3:in '+'
from (irb):3


字面值1是Fixnum类的实例对象，让我们重写Fixnum类的‘+’方法，使得‘+’的语法不再出错； 

class Fixnum
  alias : old_plus :+
  def +(other)
    (other.class.eql?String) ? (self.to_s << other) : (old_plus(other))    
  end  
end

puts  1 + "hello"  # => 1hello
puts  1 + " 2.3"   # => 1 2.3




3）. Ruby是简单的，我们可以只管按照别人说的去使用；Ruby也是灵活而复杂的，我们可以按照自己的需求去使用； 
require "another_plus3"

puts  'he'+1        # => he1
puts '1.5'+2        # => 3.5
puts 1+" he"        # => 1 he

puts 1 + " 2.3"    # => 3.3
puts 1 + 2.3      # => 3.3

puts 1.6 * "2.7"   # => 4.32
puts 1 -"2.3"    # => -1.3

类型错误根本不存在，如果语法错误算是强类型，我无言。Bruce Tate是大牛，他断言Ruby是强类型，国内的牛们也跟着如是说。
在1）.中, Bruce Tate断言Ruby是强类型；
在2）.中, Bruce Tate认为Ruby 倾向于 强类型。

后文“变量一定要有类型吗（二）”将更进一步说明。 


#another_plus3.rb

class String

  alias : old_plus :+
  def +(other)    
    (Float(self)) + (Float(other))  rescue  (self.to_s).old_plus(other.to_s)     
  end  
  
  def coerce(other)
    case other
      when Integer : return other, Integer(self)  rescue  return Float(other), Float(self)
      when Float : return other, Float(self)
      else super
    end
  end
  
end

class Fixnum
  alias : old_plus :+
  def +(other)
    (other.class.eql?String)?(old_plus(Float(other)) rescue self.to_s<<other):(old_plus(other))      
  end  
end

class Float
  alias : old_plus :+
  def +(other)
    (other.class.eql?String)?(old_plus(Float(other)) rescue self.to_s<<other):(old_plus(other))    
  end  
end


========
题外话

假设若干年后，有一篇搜索引擎报告指出：
A)21世纪初期，网络信息以中文和英文居多；
B)其中中文信息多数是英文信息的跟风之作，
从发布时间得出，英文信息居前；
从信息不确切度得出，中文信息没有经过中文世界的思维、理解与吸收，英文信息如何错误，中文信息也有相似度极高的错误...
...

我衷心地希望与你，一起唱和出中文技术论坛自身的弦音。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 01 Mar 2007 06:30:00 +0800 http://kaichuan-zhang.javaeye.com/blog/56664 http://kaichuan-zhang.javaeye.com/blog/56664 8.4 迭代器、代码块、闭包 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54178  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

先看一句代码：

ruby 代码 

  1. (1..9).each {|i| print  i  if  i<7}    # =>123456  

迭代器each 是数组类的一个方法；大括号{  }里的代码是代码块，简称块。你可以用大括号{  }将代码组织成块，也可以用 do…end将代码组织成块。大括号{  }的优先级高于do…end。


我们来写一个最简单的块；

ruby 代码
  1. #E8.4-1.rb   
  2.   
  3. def one_block   
  4.   yield  
  5.   yield  
  6.   yield  
  7. end  
  8.   
  9. one_block { puts "This is a block. " }  

运行结果：
This is a block.
This is a block.
This is a block.


从程序 E8.4-1.rb 可以看到调用一个块要用关键字yield。每一次 yield，块就被调用一次。yield 还可以带参数调用块，看程序 E8.4-2.rb ：

 ruby 代码

  1. #E8.4-2.rb   
  2.   
  3. def  one_block   
  4.   for num in 1..3   
  5.     yield(num)   
  6.   end  
  7. end  
  8.   
  9. one_block  do |i|   
  10.   puts "This is  block #{i}. "    
  11. end  

运行结果：
This is  block 1.
This is  block 2.
This is  block 3.


一个块可以接收yield 传来的参数，还可以将结果返回给调用它的方法。到目前为止，实在看不出使用代码块的优势，可以把块里的代码直接写在方法中。如果我们还没有决定块里写什么代码，又或者块里的代码会随着不同的情形而变化，那么就看出代码块的灵活性了。

 ruby 代码

  1. #E8.4-3.rb   
  2.   
  3. def do_something   
  4.    yield     
  5. end  
  6.   
  7. do_something do  
  8.   (1..9).each {|i| print  i  if  i<5}   
  9.   puts   
  10. end  
  11.   
  12. do_something do  
  13.   3.times { print  "Hi!" }    
  14.   puts   
  15. end  

运行结果：
>ruby E8.4-3.rb
1234
Hi!Hi!Hi!
>Exit code: 0


两次使用方法do_something，第一次do_something遇到yield，调用了代码块{ 输出1..9中小于5的数 } ；在程序的另一处do_something的时候，我们希望做一些不同的事，所以我们写了一个不同于前一次的代码块{ 输出3次“Hi!”}。

这是一个简单的例子，但是你能发现其中的技巧：先写出方法的大致框架，调用方法的时候才告诉方法要作什么。
虽然与代码块有关联的方法不都是迭代器，但是，迭代器确实是一个与代码块有关联的方法。让我们为数组类增加一个迭代器 one_by_one；

ruby 代码
  1. #E8.4-6.rb   
  2.   
  3. class Array     
  4.   def  one_by_one    
  5.     for i in 0...size     
  6.       yield(self[i] )     
  7.     end    
  8.     puts       
  9.   end     
  10. end  
  11.   
  12. arr = [1,3,5,7,9]   
  13. arr.one_by_one {|k| print  k ,  ", "}    # =>  1, 3, 5, 7, 9,   
  14. arr.one_by_one {|h| print h*h,  ", "}    # =>  1, 9, 25, 49, 81,  

 

代码块是一段代码，相当于一个匿名方法，被调用它的方法所调用。如果我们不仅仅想调用代码块，还想把代码块作为参数传递给其它方法，就要使用闭包了。闭包也是一段代码，一个代码块，而且能够共享其它方法的局部变量。
闭包既然是一段代码，也就有自己的状态，属性，作用范围，也就是一个可以通过变量引用的对象，我们称之为过程对象。一个过程对象用Proc.new创建，用call方法来调用。

先看一个闭包作为参数传递给其它方法的例子；

ruby 代码
  1. #E8.4-4.rb   
  2.   
  3. def method(pr)     
  4.   puts pr.call(7)      
  5. end  
  6.   
  7. oneProc=Proc.new{|k|  k *=3 }   
  8. method(oneProc)  


运行结果：
>ruby E8.4-4.rb
21
>Exit code: 0


再看一个闭包共享其它方法局部变量的例子；

ruby 代码
  1. #E8.4-5.rb   
  2.   
  3. def method(n)   
  4.   return  Proc.new{|i|  n +=i }   
  5. end  
  6.   
  7. oneProc=method(3)   
  8. puts oneProc.call(9)        # => 12   
  9. puts oneProc.call(5)        # => 17  

方法method 返回一个Proc对象，这个对象引用了这个函数的参数：n 。即使 n这个参数在闭包被调用时已经不在自己的作用域里了，这个闭包还是可以访问 n这个参数，并且和方法method 共同拥有变量 n 。开始的时候，方法method 的变量 n是3；oneProc.call(9)的时候，oneProc更新了变量 n，把n=12传回给方法method；oneProc.call(5)的时候，oneProc取出方法method的变量 n=12，更新为n=17，传回给方法method的同时，也把n=17作为自己的返回值输出。


完整阅读，请看我写的 Ruby语言中文教程all in one    
 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 Feb 2007 06:25:50 +0800 http://kaichuan-zhang.javaeye.com/blog/54178 http://kaichuan-zhang.javaeye.com/blog/54178 8.3 正则表达式 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54177  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一本入门小书，不想涉及正则表达式，但是正则表达式与Ruby语言联系如此紧密，总让人感觉绕不开它。所以匆匆结束字符串的介绍，边学边说正则表达式。
正则表达式之强大、复杂，由来已久。自从1956年提出了“正则集代数”，正则表达式就逐渐被广泛地应用于操作系统，编程语言，算法设计，人工智能……
现在，除了Perl这样支持强大正则表达式功能的语言之外，Java，JavaScript， C# 等语言都纷纷支持正则表达式，只不过支持的程度不同。而Ruby正是一种强烈而灵活地支持正则表达式的语言。
下面，我努力尝试尽可能简单地描述Ruby中的正则表达式。
正则表达式(regular expression)描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串；将匹配的子串做替换；或者从某个串中取出符合某个条件的子串；等等。
Ruby中，可以使用构造器显式地创建一个正则表达式，也可以使用字面值形式 /正则模式/ 来创建一个正则表达式。

ruby 代码
  1. #E8.3-1.rb   
  2.   
  3. str="Hello,kaichuan,Welcome!"  
  4.   
  5. puts  str =~  /kaichuan/            # => 6       
  6. puts  str =~  /a/                  # => 7    
  7. puts  str =~  /ABC/               # => nil    



我在字符串str中找我的名字 kaichuan。找到了，在字符串str的第6个字符处。和数组一样，字符串的起始索引位置是0。
在字符串str中找小写字母a，也找到了，第一个小写字母a在字符串str的第7个字符处；在字符串str中找大写字母ABC，没有找到。
匹配一个正则表达式，用“=~” ，不能用“==”。 “=~”用来比较是否符合一个正则表达式,返回模式在字符串中被匹配到的位置，否则返回nil。
不匹配一个正则表达式，用“！~” ，不能用“！=”。 “！~”用来断言不符合一个正则表达式,返回 true,flase。

ruby 代码
  1. #E8.3-2.rb   
  2.   
  3. str="Hello,kaichuan,Welcome!"  
  4.   
  5. puts  str !~ /kaichuan/     # =>  false       
  6. puts  str !~ /a/            # =>  false      
  7. puts  str !~ /ABC/         # =>  true  



假设现在有一篇很短的文章如下：
This is windows2000 or windows98 system.
Windows system is BEST?
Windows2000 running in 12-31-2006,……
我们需要将文章中所有的windows2000 或者 windows98 换成 Windows XP,不论单词开头大小写，但是不带数字的windows不换；并且要把2006年12月31日改成当前时间，如何使用正则表达式来替换呢？
给出例程 E8.3-3.rb 之前，先学习一些烦琐的东西。

 

一些字符或字符组合在正则表达式中有特殊的意义，分别如下：
特别字符

特别字符
描述
( )
标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
[] 
范围描述符 (比如,[a - z] 表示在a 到 z 范围内的一个字母)，要匹配 [，请使用 \[。
{}
标记限定符表达式。要匹配 {，请使用 \{。
\
将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。
例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
|
指明两项之间的一个选择。要匹配 |，请使用 \|。
.
匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。

 
非打印字符

非打印字符
描述
\f
匹配一个换页符。等价于 \x0c。
\n
匹配一个换行符。等价于 \x0a。
\r
匹配一个回车符。等价于 \x0d。
\s
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S
匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t
匹配一个制表符。等价于 \x09。
\w
匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'字母或数字;相当于 [0-9A-Za-z]
\W
匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'非字母,数字
\d
匹配一个数字字符。等价于 [0-9]。 [0-9]数字;相当于 [0-9]
\D
匹配一个非数字字符。等价于 [^0-9]。非数字字符
\b
退格符 (0x08) (仅在范围描述符内部时)

 
限定符
限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。
　　* 和 + 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现非贪婪或最小匹配。

限定符
描述
*
前面元素出现0或多次。* 等价于{0,}。
例如，zo* 能匹配 "z" 以及 "zoo"。
。要匹配 * 字符，请使用 \*。
+
前面元素出现1或多次。+ 等价于 {1,}。
例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。
要匹配 + 字符，请使用 \+。
?
前面元素最多出现1次;相当于 {0,1}。
例如，”do(es)?” 可以匹配 “do” 或 “does” 中的"do" 。
要匹配 ? 字符，请使用 \?。
{n}
n 是一个非负整数。匹配确定的 n 次。
例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}
n 是一个非负整数。至少匹配n 次。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。
{n,m}
m 和 n 均为非负整数，其中n <= m。前面元素最少出现n次,最多出现m次。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。

定位符

　　用来描述字符串或单词的边界， ^ 和 $ 分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。不能对定位符使用限定符。

定位符
描述  
^
匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
$
匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
\b
匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B
  匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'

 
各种操作符的运算优先级

　　相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下：

优先级
操作符
描述
高
\
转义符
 
(), []
圆括号和方括号
 
*, +, ?, {n}, {n,}, {n,m}
限定符
 
^, $,
位置和顺序
低
|
“或”操作

正则表达式强大，但是枯燥。有一个办法，就是等你需要用的时候再来学习。

下面解释例程 E8.3-3.rb，

ruby 代码
  1. #E8.3-3.rb   
  2.   
  3. strdoc=《 DOC_EOF   
  4. This is windows2000 or windows98 system.   
  5. Windows system is BEST?   
  6. Windows2000 running in 12-31-2006,……   
  7. DOC_EOF   
  8.   
  9. re = /[w|W]indows(?:98|2000) /   
  10. strdoc.gsub!(re, "Windows XP ")    
  11. re = /[1-9][0-9]\-[1-9][0-9]\-\d\d\d\d/   
  12. time = Time.now.strftime("%m-%d-%Y")   
  13. strdoc.gsub!(re, time)     
  14. puts strdoc  

运行结果：
>ruby E8.3-3.rb
This is Windows XP or Windows XP system.
Windows system is BEST?
Windows XP running in 02-06-2007,……
>Exit code: 0


strdoc.gsub!(re, "Windows XP ")，是把字符串strdoc里所有匹配正则模式re的子串替换为 "Windows XP "。 gsub!是替换所有子串。
strdoc.gsub!(re, time)，是把字符串strdoc里所有匹配正则模式re的子串替换为字符串time。
time = Time.now.strftime("%m-%d-%Y")，取出系统当前时间，并且格式化成（ 月-日-年 ）的形式，生成一个字符串time。


完整阅读，请看我写的 Ruby语言中文教程all in one    
 

 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 Feb 2007 06:13:53 +0800 http://kaichuan-zhang.javaeye.com/blog/54177 http://kaichuan-zhang.javaeye.com/blog/54177 8.2 再说字符串 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54176  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一. 生成一个字符串
字符串是String类的对象，一般使用字面值来创建。

ruby 代码
  1. #E8.2-1.rb   
  2.   
  3. str1 = 'this is str1'   
  4. str2 = "this is str2"  
  5. str3 = %q/this is str3/   
  6. str4 = %Q/this is str4/   
  7. str5 =《EOF_STRING 
  8.   Here is string document, str5   
  9.      line one;   
  10.      line two;   
  11.      line three.   
  12.   OK   
  13. EOF_STRING 
  14.   
  15. puts str3   
  16. puts str4   
  17. puts str5   
  18.   


运行结果：
>ruby E8.2-1.rb
this is str3
this is str4
  Here is string document, str5
     line one;
     line two;
     line three.
  OK
>Exit code: 0


%q 用来生成单引号字符串；%Q用来生成双引号字符串。%q或者%Q后面跟着的是分隔符，可以是配对的!  !； /  /； <  >； (  )； [  ] ；{  }；等等。
str5是一个字符串文档，从 <<和文档结束符的下一行开始，直到遇到一个放置在行首的文档结束符，结束整个字符串文档。
一个数组可以用join 方法转换成字符串，join( ) 内的参数也是一个字符串，用来分隔数组的每个元素，例如：arr.join(", ")。

二. 字符串操作
字符串既然是String类的对象，String类的方法你都可以使用在字符串变量上，String类的方法非常多，下面略举几例。

ruby 代码
  1. #E8.2-2.rb   
  2.   
  3. str = ' this' + " is"  
  4. str += " you"  
  5. str << " string" << " ."  
  6.   
  7. puts  str*2       # =>  this is you string . this is you string .   
  8. puts  str[-12,12]  # => you string .  



三. 字符串转义
双引号括起来的字符串会有转义，例如：“\n” 表示换行。还有一些其它的转义符号，比如制表符之类。

ruby 代码
  1. #E8.2-3.rb   
  2.   
  3. str = " this is you string ."  
  4. puts  str*2                     # =>  this is you string . this is you string .   
  5.   
  6. str = " this is you string .\n"  
  7. puts  str*2                     # =>  this is you string .   
  8.                                   this is you string .   
  9. str = " \tthis is you string ."  
  10. puts  str                       # =>   this is you string .   
  11.   
  12. str = ' this\'s you string .\n'   
  13. puts  str                       # =>  this's you string .\n  


单引号括起来的字符串并不会对字符串作任何解释，你看到的是什么便是什么，有一个例外：单引号字符串里的 单引号 需要转义。

四. 字符串内嵌表达式
在双引号扩起来的字符串中，不仅可以使用各种转义符，而且可以放置任意的Ruby表达式在 #{   } 之中，这些表达式在使用这个字符串的时候被计算出值，然后放入字符串。

ruby 代码
  1. #E8.2-4.rb   
  2.   
  3. def hello(name)   
  4.     " Welcome, #{name} !"  
  5. end  
  6.   
  7. puts  hello("kaichuan")   # =>  Welcome, kaichuan !   
  8. puts  hello("Ben")       # =>  Welcome, Ben !  


字符串内嵌表达式，使得你能够更加灵活地组织代码，表现出更强、更多的动态特性。

完整阅读，请看我写的 Ruby语言中文教程all in one    
 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 Feb 2007 06:07:54 +0800 http://kaichuan-zhang.javaeye.com/blog/54176 http://kaichuan-zhang.javaeye.com/blog/54176 8.1 再说数组 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54175  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一. 建立一个数组

ruby 代码
  1. #E8.1-1.rb   
  2.   
  3. arr1=[]   
  4. arr2=Array.new  
  5. arr3=['4 ','5 ','6 ']   
  6.   
  7. print arr1,  "\n"  
  8. print arr2,  "\n"  
  9. print arr3,  "\n"  


运行结果：
>ruby E8.1-1.rb


4 5 6
>Exit code: 0

二. 访问数组元素
Ruby以整数作为下标，访问数组元素通过数组下标，数组下标称作数组索引比较好一些。

ruby 代码
  1. #E8.1-2.rb   
  2.   
  3. arr=[3,4,5,6,7,8,9]   
  4.   
  5. puts arr[0]           # => 3   
  6. puts arr.first         # => 3   
  7. puts arr[arr.length-1]  # => 9   
  8. puts arr[arr.size-1]    # => 9   
  9. puts arr.last           # => 9   
  10. puts arr[-1]            # => 9   
  11. puts arr[-2]            # => 8   
  12. print arr[1..3]   ,"\n"   # => 456   
  13. print arr[-3,2]   ,"\n"  # => 78       



数组的索引从0开始，一直到数组的长度减去1；负数表示从数组末尾开始的索引；用一对数字来索引数组，第一个数字表示开始位置，第二数字表示从开始位置起的元素数目。

三. 增加、删除数组元素
Ruby的数组大小是动态的，你能够随时增加、删除数组元素。
print arr.join(", "),"\n" 意思是：将数组arr转换成字符串输出，用", "隔开每个元素，并且换行。

ruby 代码
  1. #E8.1-3.rb   
  2.   
  3. arr=[4,5,6]        
  4. print arr.join(", "),"\n"                           # => 4, 5, 6   
  5.   
  6. arr[4] = "m"    #把4号索引位置元素赋值为"m"             
  7. print arr.join(", "),"\n"                           # => 4, 5, 6, , m   
  8. print arr[3] ,"\n"     #打印3号索引位置元素      # => nil   
  9.   
  10. arr.delete_at(3)     #删除3号索引位置元素   
  11. print arr.join(", "),"\n"                           # => 4, 5, 6, m   
  12.   
  13. arr[2] = ["a","b","c"]  #把2号索引位置元素赋值为["a","b","c"]   
  14. print arr.join(", "),"\n"                           # => 4, 5, a, b, c, m   
  15. print arr[2] ,"\n"     #打印2号索引位置元素     # => abc   
  16.   
  17. arr[0..1] = [7,"h","b"]  #把0..1号元素替换为7,"h","b"   
  18. print arr.join(", "),"\n"                           # => 7, h, b, a, b, c, m   
  19.   
  20. arr.push("b" )        #加入元素"b"   
  21. print arr.join(", "),"\n"                           # => 7, h, b, a, b, c, m, b   
  22.   
  23.   
  24. arr.delete(["a","b","c"] )    #删除元素["a","b","c"]   
  25. print arr.join(", "),"\n"                            # => 7, h, b, m, b   
  26. arr.delete("b")         #删除所有元素"b"   
  27. print arr.join(", "),"\n"                            # => 7, h, m   
  28.   
  29. arr.insert(3,"d")      #在3号索引位置插入元素"d"   
  30. print arr.join(", "),"\n"                            # => 7, h, m, d   
  31.   
  32. arr<<"f"<<2         #加入元素"f"；加入元素2   
  33. print arr.join(", "),"\n"                           # => 7, h, m, d, f, 2   
  34. arr.pop          #删除尾元素   
  35. print arr.join(", "),"\n"                           # => 7, h, m, d, f   
  36. arr.shift        #删除首元素     
  37. print arr.join(", "),"\n"                          # => h, m, d, f   
  38. arr.clear        #清空数组arr   
  39. print arr.join(", "),"\n"                          # =>    


四. 数组运算

ruby 代码
  1. #E8.1-4.rb   
  2.   
  3. aaaa=[" aa ",4,5," bb "]   
  4. bbbb=[4,1,3,2,5]   
  5.   
  6. print aaaa + bbbb    ,"\n"      # =>  aa 45 bb 41325   
  7. print aaaa * 2        ,"\n"     # =>  aa 45 bb  aa 45 bb   
  8. print bbbb - aaaa    ,"\n"      # => 132   
  9.   
  10.         #并运算；交运算   
  11. print aaaa | bbbb    ,"\n"      # =>  aa 45 bb 132   
  12. print aaaa & bbbb    ,"\n"     # => 45   
  13.   
  14.          #排序；倒置   
  15. print bbbb.sort       ,"\n"     # => 12345   
  16. print aaaa.reverse    ,"\n"     # =>  bb 54 aa  

 


完整阅读，请看我写的 Ruby语言中文教程all in one    
 

 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 Feb 2007 06:03:44 +0800 http://kaichuan-zhang.javaeye.com/blog/54175 http://kaichuan-zhang.javaeye.com/blog/54175 7.4 require 和 load 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54174  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

程序 E7.3-1.rb中先写了Me模块，然后include  Me模块，实现了Mix-in功能，但是，这样没能做到代码复用。
我将 Me模块写在文件 E7.4-1.rb中，将 Person类写在文件 E7.4-2.rb中，这时候 Student类如何使用 Me模块和 Person类呢？这里要用到require方法。
看程序 E7.4-3.rb ：

ruby 代码
  1. #E7.4-3.rb     
  2. require "E7.4-1"  
  3. require "E7.4-2"  
  4.   
  5. class Student < Person   
  6.   include Me   
  7. end  
  8.   
  9. aStudent=Student.new  
  10. aStudent.talk              # =>  I'm talking.   
  11. puts aStudent.sqrt(77,2)     # =>  8.77496438739435  



使用 require方法让你的程序文件变得简洁有力。 require方法包含另一个文件，另一个文件名需要是一个字符串。
还有一个 load 方法与require 方法相对应，也用来包含另一个文件。
看程序 E7.4-4.rb ：

ruby 代码
  1. #E7.4-4.rb     
  2. load "E7.4-1.rb"  
  3.   
  4. class Student     
  5. end  
  6.   
  7. aStudent=Student.new  
  8. aStudent.extend(Me)   
  9. puts aStudent.sqrt(100.1, 12)  # =>  10.0049987506246  



require包含文件，只加载一次，遇到同一文件时自动忽略；不同路径下的同名文件会多次加载。 load包含文件，加载多次，即使是相同路径下同一文件。
总结一下：
 require，load用于包含文件；include，extend则用于包含模块。
 require加载文件一次，load加载文件多次。
 require加载文件时可以不加后缀名，load加载文件时必须加后缀名。
 require一般情况下用于加载库文件，而load用于加载配置文件。
利用load 多次加载文件的特性，可以用来实现程序的无缝升级和系统的热部署。程序功能改变了，你只需要重新load 一次，其它代码与它再次交互的时候，这个程序实际上已经不是原来的程序了。

 

完整阅读，请看我写的 Ruby语言中文教程all in one    
 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 13 Feb 2007 05:59:55 +0800 http://kaichuan-zhang.javaeye.com/blog/54174 http://kaichuan-zhang.javaeye.com/blog/54174 7.3 糅和(Mix-in) 与多重继承 凌川__ 作者: 凌川__  链接：http://kaichuan-zhang.javaeye.com/blog/54173  发表时间: 2007年02月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

糅和，也译作混合插入，也许就称作 Mix-in 比较合适。
现实生活中，一个乒乓球不仅是球类物体，也是有弹性的物体。 C++ 支持多重继承，多重继承有时会导致继承关系的混乱，Java只提供了单继承，通过接口可以得到多重继承的优点，又没有多重继承的缺点。Ruby 也是单继承，不是通过接口，而是通过Mix-in 模块，来实现多重继承的优点。
模块的第三个作用：实现了类似多重继承的功能。

我们有一个Student类，有着Person类的属性和方法，还会做数学题——求平方根。已经有了Me模块，只要Mix-in 在Student类里就可以了。
看程序 E7.3-1.rb ：

ruby 代码

  1. #E7.3-1.rb     
  2.   
  3. module Me   
  4.   def sqrt(num, rx=1, e=1e-10)   
  5.     num*=1.0   
  6.      (num - rx*rx).abs 
  7.   end  
  8. end  
  9.   
  10. class Person    
  11.   def talk   
  12.     puts "I'm talking."       
  13.   end     
  14. end