重游5460

今天在qq上遇到了大学时的室友，批评俺不上5460。细想起来确实好久没到过5460呢，心存一丝的歉意。在上面逛了一个多小时，感觉同学们变化很大，发现一部分婚纱照，给人不小惊喜。室友说快“升级”呢。小崽的名字都起好呢，在这里祝小宝宝健健康康！

　　以前有人说，毕业后5年就会产生差距。现在回过头来想确实自己还要努力。。

平时收集的rails资料

/*不断更新中。。。
一、views

1. view 笔记　（对view的常用组件进行了介绍)

二、models

1. Active Record 基础(1-14)

三、controllers

1. active controller (比较全面）
   
2. How　to　Pagination

四、实例文档

1. agile-web-development-with-rails(中文版)
   
2. Depot项目文档列表

hamster 启动之layout

1、hamster 启动过程")首先是找到public\index.html ("method="post"action="/permission/login") 登录的request　被router 解析以后，找到相关的consroller，rails 会缺省在
app/views/layouts 目录下面找constroller_name.rhtm(.rxml)的文件（实际上是个layouts template)
if 存在 controller 对应的layouts 它将和action 对应的template 组合输出，如查没有ation 对应的template,layout也不会单独输出(如：采用render_text 输出就不会与layout结合)。有个特殊的layout--applicaton (所有controller的layout)
exp:
class PermissionController <>
layout 'framework',:except=>[:login]
#表示除login action 外都使用 framework.rhtml 做为layout.实际上在
view\permission\login.rhtml的存在。（与public\index.html类似），action logout
所现示的效查为 framework+logout.rhtml 的效果总给。
def login
case @request.method
when :post
if @session[:account] = Account.authenticate(@params[:account_login], @params[:account_password])
flash['notice'] = "登录成功"
redirect_to '/welcome'
下面是login.rhtml对 flash['notice']的引用。

<%= @flash['notice'] %>

，实际上login.rhtml的
值还是融合在layout-applicaton 里。（也就是默认的）

<%= @content_for_layout %>

instance variable:@content_for_layout，它是一个String object，包含的是controller所递交的内容，controller在request被解析以后，进行rendering（递交），递交的内容来源于 template，也有可能来源于action本身，但总的说来，controller进行的递交操作会把数据传递到 @content_for_layout，这个instance variable里面，并且以String object形式存在，实际上它就是具体的html代码（template中的html），或者经过render（action中render_text 方法的返回值）的任何字符串。

Rails 笔记之Rails and Request URLs

1. Rails and Request URLssay:对应的是controller.
   hello:只是say controller 里的一个action。
   流程如下：
   
   
   
   对应的目录结构
   
   2、view
   .rhtml 后缀告诉 Rails，需要借助ERb 系统对文件的内容进行扩展??ERb 就是用于将 Ruby 代码嵌入模板文件的。 (也就类似jsp或php之类）
   　 action 里的实例变量可以在.rhtml里直接使用。
   　链接页面可作用 link_to 把各action 进行关联起来，如：
   　<%=link_to "GoodBye!",:action=>"goodbay"%>
   h()方法，把动态内容转换成html 里保证里的内容不会乱。
   

爱上rails 的原因

rails与j2ee

rails 的架构图rails小抄

Symbol 的解读

之前对 Symbol 一直不是很理解，ruby手册上也讲的一不多，今天在
stikipad看到比较详细的说明，下面是根据它的做的总结：
1、产生Symbol的原因
　　全归因于“一切皆对象",如在参数 keyword,enumerated values它可能需要的只是字符串而已，跟本不需要它具有string类的功能。从而也能节省大量的内存.
puts Symbol.all_symbols #返回系统中定义的Symbol
2、Symbol 意义
　　一个不可以改变字符串，而非字符串对象（也不具有String 的相关方法)
exp:
(:action).length
　　　提示：NoMethodError:undefined method'length'for:action:Symbol
可用to_s把Symbol 转换成String 对象
puts :action.to_s.length #=>6
3、Symbol的用途
　　只需要个字符串，且没有改变值的需求，且用不到String的相关方法，则可以用Symbol取代 String object.如：
　　参数的keyword
enumerated values
map/hash table 的key
请理解下面的代码

//in C
enum Color { Red, Blue, Green };

Color fgclr =  Color.Red;

//in Ruby
fgclr = :red
puts fgclr
puts fgclr.to_s

bgclr1 = "blue".to_sym
bgclr2 = :blue
puts bgclr1 == bgclr2

好像在新版中情况又不一样呢，见http://redhanded.hobix.com





require load and include 的区别

　require 、load的功能相同，都是用来载入新的程序库区别在于：
　1、require 可以省略".rb",且只是在第一次时载入后。后继的忽略。
　2、load 要求全名，且每一次都重新载入（理解为实时更新吧）。

　ruby 把载入的信息存在$:系统全局全变上，可用ruby -I来加载。 是不是想起了 java class path

　谈到include就不得不说起模块，模块是方法与常量的集合，主要是扩展ruby的程序，（也就是为了实现有限制的多重继承吧，Matz称它为"带实现共享的单继承"）另外使用模块是对类的mixin(混合插入)特征，也做到了名字空间的管理，减少书写的长度
　例：
　　puts Math::PI
或
　　include Math
puts PI

ruby 笔记之初级教程

一、单态方法　
　　对象a、b同属于一个类，但是对象表可以重载类的一些方法，因而他们有不同的行为。即一个仅属于某个对象的方法叫单态方法。
　　:)本人也没太明的单态方法的意义。

二、模块

• 模块不可以有实体，模块不可以有子类，模块由module..end定义
• 将相近的方法和实体放在一个相对集中的域里，如Math
  Math.sqrt(2)
  Math::PI　　＃::告诉ruby到那里去找PI
  如果想省掉::,直接调用常数
  include Math #感觉有点C
  sqrt(2)
  PI
• 糅和(mixin)，获得多重继承的基本功能却可通过简单的树结构表述类关系。

三、过程方法

1. 一个对象可以等于一段代码
   quux=proc{
   print "test\n"
   }
   quux.call =>"test"
2. 可以当做参数调用。
   def run (p)
   print "About to call a procedure..\n"
   p.call
   end
   run quux

ruby笔记之标准类型

一、数字

1. Ruby支持整数和浮点数，整数可以是任意长度
2. 一定范围内的整数以二进制存放，它们属于fixnum类型，当超出这个范围时则自动转换为bignum类型
3. 表达方式：符号＋一串字符，数字串中的下划线会被忽略，（前缀包括：0表示八进制, 0x表示十六进制, 0b表示二进制）123_456_789_123_345_789 # Bignum
   0xaabb # 十六进制
4. 也可以通过在前面加上问号来得到ASCII码字符对应的整数值和转义序列的值
   ?a # 普通字符
   ?\n # 换行符 (0x0a)
   ?\C-a # CTRL+a (0x01)
   ?\M-a # ALT+a
   ?\M-\C-a # CTRL+ALT+a
   ?\C-? # 删除键
5. 一个带小数点的数字字面值被转换成Float对象
6. 所有的数字都是对象,不存在相应的函数而是方法
   exp:
   数字的绝对值是aNumber.abs而不是abs(aNumber)
7. 整数有用的迭代器
   3.times { print "X " } => X X X 1.upto(5) { |i| print i, " " } =>1 2 3 4 5 99.downto(95) { |i| print i, " " }=>99 98 97 96 95 50.step(80, 5) { |i| print i, " " }=>50 55 60 65 70 75 80

二、字符串

1. Ruby的字符串是8位字节的简单序列，字符串是String类的对象
2. 注意转换机制(注意单引号与双引号的区别），如：
   单引号中两个相连的反斜线被替换成一个反斜线，，一个反斜线后跟一个单引号被替换成一个单引号
   'escape using "\\"' >> 转义为"\" 'That\'s right' >> That's right
   
3. 双引号支持多义的转义
   "\n"
   #{expr}序列来替代任何的Ruby表达式的值 ,(全局变量、类变量或者实例变量，那么可以省略大括号)
   "Seconds/day: #{24*60*60}" >> Seconds/day: 86400 "#{'Ho! '*3}Merry Christmas" >> Ho! Ho! Ho! Merry Christmas "This is line #$." >> This is line 3
4. here document来创建一个字符串,end_of_string 为结束符号
   aString = <<END_OF_STRING The body of the string is the input lines up to one ending with the same text that followed the '<<' END_OF_STRING
5. %q和%Q分别把字符串分隔成单引号和双引号字符串(即%q与%Q后面的符号具有',"的功能）
   %q/general single-quoted string/ >> general single-quoted string
6. String 常用功能
   String#split：把行分解成字段
   String#chomp:去掉换行符
   String#squeeze：剪除被重复输入的字符
   String#scan:以指定想让块匹配的模式
   exp:
   /jazz/j00132.mp3 | 3:45 | Fats Waller | Ain't Misbehavin'
   /jazz/j00319.mp3 | 2:58 | Louis Armstrong | Wonderful World
   #文件格式如上，要进行分解
   songs = SongList.new
   songFile.each do |line|
   file, length, name, title = line.chomp.split(/\s*\|\s*/)＃先chomp,后再分解，/\s*表示任字符
   name.squeeze!(" ")＃替换空格
   mins, secs = length.scan(/\d+/)＃这里用scan匹配模式
   songs.append Song.new(title, name, mins.to_i*60+secs.to_i)
   end
   

三、区间

1. 区间存在于任何地方，如：1到12月。ruby用区间实现了3个不同的特性：序列，条件，间隔。
2. ".."：两个点号创建一个闭区间，"..."：而三个点号创建一个右开区间(即右边界不取值）
   exp:0..anArray.length-1 等同于 0...anArray.length
3. to_a 把区间转换成列表
   exp: ('bar'..'bat').to_a >> ["bar", "bas", "bat"]
4. 区间的共它的用法
   digits = 0..9
   digits.include?(5) >> true
   digits.min >> 0
   digits.max >> 9
   digits.reject {|i| i < 5 } >> [5, 6, 7, 8, 9]
   digits.each do |digit|
   dial(digit)
   end
5. ruby能把基于自己定义的对象的区间，要求：这个对象必须能够响应succ方法来返回序列中的下一个对象，并且这个对象必须能够使用<=>运算符来被比较，即常规的比较运算符，
6. 间隔测试
   puts (1..10).include?(3.14)＝＞ ture
   puts (1..10) === 3.14　＝＞ ture

四、正则表达式

1. 正则表达式是Regexp类型的对象，可以使用构造器显式地创建一个正则表达式，也可以使用字面值形式/pattern/和%r\pattern\来创建
2. 用Regxp#match(aString)的形式或者匹配运算符=~（正匹配）和!~（负匹配）来匹配字符串了。匹配运算符在String和Regexp中都有定义，如果两个操作数都是字符串，则右边的那个要被转换成正则表达式
   exp:
   a = "Fats Waller"
   a =~ /a/ >> 1
   a =~ /z/ >> nil
   a =~ "ll" >> 7
3. 上面返回的是匹配字符的位置，其它
   $&接受被模式匹配到的字符串部分
   $`接受匹配之前的字符串部分
   $'接受之后的字符串。
   exp:下面的方法后继都会用到
   def showRE(a,re)
   if a =~ re
   "#{$`}<<#{$&}>>#{$'}" ＃返回前、中、后
   else
   "no match"
   end
   end
   
4. 模式，任何一个表达式都包含一个模式，它用来把正则表达式和字任串匹配
   模式中除了., |, (, ), [, {, +, \, ^, $, *,和？以外的字任都匹配它自己
   如果要匹配这些特殊的字符就需要加上反斜线做前缀，分析上面例字
   /\s*\|\s*/,在\s与|之前都加了/做前缀。
   showRE('kangaroo', /angar/) >> k<<angar>>oo
   showRE('!@%&-_=+', /%&/) >> !@<<%&>>-_=+
   showRE('yes | no', /\|/) >> yes <<|>> no
   
5. \后跟一个字母或数字表示一个特定的结构如\s表示字符等。
6. 锚点　一个正则表达式总是返回找到模式的第一个匹配，如何改变？
   模式^和$分别用来匹配行首和行尾
   序列\A匹配字符串开始的位置，\z和\Z匹配字符串结尾的位置
   \b和\B分别匹配字边界和非字边界
   showRE("this is\nthe time", /^the/) >> this is\n<<the>> time
   showRE("this is\nthe time", /is$/) >> this <<is>>\nthe time
   showRE("this is\nthe time", /\Athis/) >> <<this>> is\nthe time

五、字符类

1. 这里的字符类不是面向对象的类，只表示这些这字符属于一个特殊的种类
2. 字符类是用方括号扩起来的字符的集合：[characters]匹配方括号中的所有单字符。[aeiou]匹配元音，[,.:'!?]匹配标点符号等等
   showRE('It costs $12.', /[aeiou]/) >> It c<<o>>sts $12.
3. 在方括号中的序列c1-c2表示在c1-c2之间也包括c1和c2的所有字符
   a = 'Gamma [Design Patterns-page 123]'
   showRE(a, /[]]/) >> Gamma [Design Patterns-page 123<<]>>
   showRE(a, /[B-F]/) >> Gamma [<<D>>esign Patterns-page 123]
   showRE(a, /[-]/) >> Gamma [Design Patterns<<->>page 123]
   showRE(a, /[0-9]/) >> Gamma [Design Patterns-page <<1>>23]
4. 紧跟在开括号([)后的是字符^，这表示这个字符类的否定：[^a-z]匹配任何不是小写字母的字符。
5. 字符类缩写
   序列 形如 [ ... ] 含义
   \d [0-9] Digit character
   \D [^0-9] Nondigit
   \s [\s\t\r\n\f] Whitespace character 匹配一个单空白符
   \S [^\s\t\r\n\f] Nonwhitespace character
   \w [A-Za-z0-9_] Word character
   \W [^A-Za-z0-9_] Nonword character
6. 重复
   r * 匹配0个或多个r的出现
   r + 匹配一个或多个r的出现
   r ? 匹配0个或1个r的出现
   r {m,n} 匹配最少m最多n个r的出现
   r {m,} 匹配最少m个r的出现
   
   重复结构有高优先权：即它们仅和模式中的直接正则表达式前驱捆绑
   /ab+/匹配一个"a"后跟一个活着多个"b"，而不是"ab"的序列
   /a*/会匹配任何字符串：0个或者多个"a"的任意字符串。　
   exp:
   a = "The moon is made of cheese"
   showRE(a, /\w+/) >> <<The>> moon is made of cheese
   showRE(a, /\s.*\s/) >> The<< moon is made of >>cheese
   showRE(a, /\s.*?\s/) >> The<< moon >>is made of cheese
   showRE(a, /[aeiou]{2,99}/) >> The m<<oo>>n is made of cheese
   showRE(a, /mo?o/) >> The <<moo>>n is made of cheese
7. 替换
   "|"既匹配它前面的正则表达式或者匹配后面的
   a = "red ball blue sky"
   showRE(a, /d|e/) >> r<<e>>d ball blue sky
   showRE(a, /al|lu/) >> red b<<al>>l blue sky
   showRE(a, /red ball|angry sky/) >> <<red ball>> blue sky
8. 分组
   圆括号把正则表达式分组，组中的内容被当作一个单独的正则表达式
   showRE('banana', /(an)+/) >> b<<anan>>a
   # 匹配重复的字母
   showRE('He said "Hello"', /(\w)\1/) >> He said "He<<ll>>o"
   # 匹配重复的子字符串
   showRE('Mississippi', /(\w+)\1/) >> M<<ississ>>ippi
9. 基于模式的替换
   你是否想过，大小写替换。
   方法String#sub和String#gsub都在字符串中搜索匹配第一个参数的部分，然后用第二个参数来替换它们。String#sub只替换一次，而String#gsub替换所有找到的匹配。都返回一个包含了替换的新的字符串的拷贝。进化版本是String#sub!和 String#gsub!
   a = "the quick brown fox"
   a.sub(/[aeiou]/, '*') >> "th* quick brown fox"
   a.gsub(/[aeiou]/, '*') >> "th* q**ck br*wn f*x"
   a.sub(/\s\S+/, '') >> "the brown fox"
   a.gsub(/\s\S+/, '') >> "the"
   第二个参数可以是代码块
   a = "the quick brown fox"
   a.sub (/^./) { $&.upcase } >> "The quick brown fox"
   a.gsub(/[aeiou]/) { $&.upcase } >> "thE qUIck brOwn fOx"
10. 反斜线序列用在替换中
    \& 后面的匹配
    \+ 后面的匹配组
    \` 匹配前面的字符串
    \' 匹配后面的字符串
    \\ 反斜线的字面值
11. 面向对象的正则表达式
    正则表达式的字面值创建Regexp类
    re = /cat/
    re.type >> Regexp
    方法Regexp#match从字符串中匹配一个正则表达式，如果不成功，方法返回nil，如果成功，返回MatchData类的一个实例
    exp:
    e = /(\d+):(\d+)/ # match a time hh:mm
    md = re.match("Time: 12:34am")
    md.type >> MatchData
    md[0] # == $& >> "12:34"
    md[1] # == $1 >> "12"
    md[2] # == $2 >> "34"
    md.pre_match # == $` >> "Time: "
    md.post_match # == $' >> "am"
    

原电子文档：http://www.moer.net

ruby笔记之容器，代码块，迭代器

一、容器
　　1、回忆一下array 与hash 的区别
把操作符右边的值赋给该位置的元素。中间所产生的空隙用nil来填补。
　　2、array 的用法（好像这都是ruby所特有的，不知是否有眼前一亮的感觉）
a = [ 1, 3, 5, 7, 9 ]
a[1, 3] >> [3, 5, 7]
a[1..3] >> [3, 5, 7] 　＃这间的对象
a[1...3] >> [3, 5]　　＃3个点，不包括结束点　
　　[]=操作符
a = [ 1, 3, 5, 7, 9 ] >> [1, 3, 5, 7, 9]
a[1] = 'bat' >> [1, "bat", 5, 7, 9]
a[-3] = 'cat' >> [1, "bat", "cat", 7, 9]
a[3] = [ 9, 8 ] >> [1, "bat", "cat", [9, 8], 9]
a[6] = 99 >> [1, "bat", "cat", [9, 8], 9, nil, 99]
　　把操作符右边的值赋给该位置的元素。中间所产生的空隙用nil来填补。
　　　　另外：
a = [ 1, 3, 5, 7, 9 ] >> [1, 3, 5, 7, 9]
a[2, 2] = 'cat' >> [1, 3, "cat", 9]
a[2, 0] = 'dog' >> [1, 3, "dog", "cat", 9]
a[1, 1] = [ 9, 8, 7 ] >> [1, 9, 8, 7, "dog", "cat", 9]
a[0..3] = [] >> ["dog", "cat", 9]
a[5] = 99 >> ["dog", "cat", 9, nil, nil, 99]
[]=的索引有两个数（开始和长度）或者是一个区间（如何区分是长度还是区间？），那么在原始数组中的对应元素就会被操作符右边的值代替；如果索引的长度为0，那么右边的值就插入到开 始位置前面，不删除元素；如果右边也是一个数组，它的元素代替原始数组的元素；如果索引所选择的元素数目和右边的不一样，那么就自动调整数组的大小来适 应。
二　迭代器
　　迭代器和代码块是Ruby最有趣的特性中的两个
　　find
代码块：
　def threeTimes
　　yield　＃等同于 puts "Hello"
　　yield
　　yield
　end
threeTimes { puts "Hello" }
　　这里 的代码块是puts "Hello"这条语句，而方法是threeTimes，当语句执行到threeTimes { puts "Hello"}这行 时，puts "Hello"不是马上被执行，而是由Ruby先保存puts "Hello"这条语句和threeTimes的关系，然后进入到 threeTimes中，遇到第一条yield语句的时候调用并执行puts "Hello"语句，执行完毕后返回到第一条yield语句的后面也就是第 二条yield语句，直到三条yield语句都被执行了，才返回到threeTimes{puts "Hello"}这条语句后）
　　1、代码块出现在方法调用的代码附近，与方法的最后一个参数处在同一行(见上）
　　2、代码块中的代码并不被执行，而是ruby save 代码块出现的上下文关系（局部变量、当前　　　　对象等等），然后进入到方法中。
　　3、方法中通过yield语句来调用，感觉代码块就是一个方法一样，能具有特定的功能。
　　4、最络的功能是代码块能传递参数，还可以取的返回值　
exp:
def fibUpTo(max)
i1, i2 = 1, 1 # 并行赋值
while i1 <= max
yield i1
i1, i2 = i2, i1+i2
end
end
fibUpTo(1000) { |f| print f, " " }
5、如果代码块只有一个参数那么yield传递来的多个参数会转换成一个数组
6、再回过头来想想
　　　　result=@song.find{|aSong|key==aSong.name}
附上find 的实现是不是好懂了点
class Array
def find
for i in 0...size
value = self[i]
return value if yield(value)
end
return nil
end
end　　　
　　each　
它所做的就是连续返回集合中的元素
　　[ 1, 3, 5 ].each { |i| puts i }　　
collect
它从集合中取得每一个元素然后传递给代码块。代码块返回的结果用来生成一个新的数组
["H", "A", "L"].collect { |x| x.succ } >> ["I", "B", "M"]

ruby笔记之类、对象、变量

1、class initialize 方法，在创建实例时new方法中的所有参数传递过来。
2、命名规则
　 类：首字母大小 exp: class Song
方法：全小写， exp:def initialize(name,artist,duration)
类变量：＠＠开头
类方法：方法名前加上类名和一个点号(".")
常量：大写字母开头
3、object class 的方法（约35个）
　 a1Song.inspect # 返回对象的id和其所有实例变量
a1Song.to_s #转换为字符,返回对象id,当然可以在类中重载to_s
　　　　　　　　def to_s
　　　　　　　　"Song:#{@name}--#{@artist}(#{@duration}) "
　　　　　　　 end
　 a1Song.to_i
4、继承和消息
　 继承和混合 　　
c++：支持多重继承 　　
java:单继承 　　
ruby:拥有单继承的简练与多多重继承的强在。 　　　　　
只允许有一个直接的父类 ,可以包含任意多个混合的功能　（不是太明白）
5、对象与属性 　　　
类的所有对象（属性）default 是私有的。即：其它对象不可以访问本对象的实例变量。 　只能通过方法来访问。java中常用get**与set**在ruby 中可以得到简)
attr_reader:name,:artist,:duration #类似java get 之类
attr_writer:name,:artist,:duration #类同于java set 之类 　　
　可写属性
def duration=(new Duration)　　＃注意方法名为 duration=
@duration=new Duration
end
　上面与att_writer:duration 实现的功能一样。
　虚拟属性
　 def durationlnMinutes
@duration/60.0 #转换成 分钟
end
def durationlnMinutes=(value) # attr_writer 实际上的实现方式与此相同
@duration=(value*60).to_i #转换intger
end
　上面实际上是对duration 与　durationlnMinutes　之间进行的一个换算，对外部而言，它们之间没有什么区别，但是并没有和它对应的实例变量。
　上述为统一访问原则(uniform acces principle)

7 、类变量和类方法
　　 类变量在类的所有对象中是共享的(java static),并且可能被类方法访问到。与全局变量和实例变量不同的是在使用前必须要初始化。
　　　exp:
class Song
@@plays = 0
对于一个类和它的实例来说，类变量是私有的，如果想在外部访问它，就需要写一个访问方法。（类方法与实例方法都可以）
　　类方法：不依赖于任何实例对象的方法.
exp: aSong = Song.new(....)
　　单例模式
　　　　class Logger
private_class_method :new　　＃防止其它人调用default构造器
@@logger = nil
def Logger.create
@@logger = new unless @@logger 　# unlee 没太明白
@@logger
end
end

8、访问控制
　　 公有方法pubic methods　（方法的defualt,除initialize外）
　　保护方法protected methods 可以被定义它的类和其子类的对象访问，访问只限于家族内
　　私有方法private methods 不能被外界调用，因为调用私有方法时无法指定对象，所以只能 在定义它的类和类直接派生的对象中使用　
注： "protected"和"private"两者的区别非常微妙，在ruby中两者间的区别甚至要超出其它大多数面向对象语言。如果一个方法是保护的，它可以在定义它的类或者子类的实例中调用。如果一个方法是私有的，则只能在调用它的对象的上下文处调用，不可能直接调用另一个对象的私有方法，即便这个对象和该对象都是同一个类的实例。
　　　ruby和其它oo语言不同在于，访问控制是动态的，只有你的代码执行受限的方法时才会得到访问违例。
　　　设定方法：
　　　　　1、在定义方法前说明
private # 随后的方法是 'private'
def method3 # 这里是 'private'
#...
end
2、作为参数列在访问控制后面
　　　　　　 public :method1, :method4
　　　　　　　　　　　　　　　　　
　　

ruby 笔记之Ruby的新特性

一、相关定义
def saygoodnight (name)
#result="good night\n"+name
#result="good night\n #{name}"
#return result
"good night\n #{name}"
end
# puts syagoodnight
puts saygoodnight("yao")

分析：
　　1、定义方法　def ..end ，出没有出现其它语言中的"{｝"，更加简洁
　　2、变量result 没有定义类型，系统自动处理
　　3、Ruby注释开始于#号，结束在行尾。
　　4、在""下，它与C类似要做更多的处理如：替换以"\"开头的，如："\n","#"符号。
　　5、ruby 使用一约定的方法来规定变量的命名，主要体显在名称的第一个字符上。
　　　局部变量、方法参数和方法名称应该用一个小写字母开头或者一个下划线；
　　　全局变量用美元符作为前缀($)，
　　　而实例变量用@开头，
　　　类变量用两个@开头；最后，类名、模块名和常量应该大写字母开头。
二、数组与哈希
　　都是有序集合，都是保存对象的集合，可以通键来访问无素，数组的键是个整数（从0开始），而哈希　支持任何对象做为键，对访问元素来说，数组的效率高，但哈希却更灵活。数组和哈希都可以容纳不同类型的对象。

三、控制结构
　　在ruby中，所有的控制结构都没有大括号，用end表示一段主体的结束。
如：

if radiation>3000
puts "Danger,Will Robinson"
end
可以表示为更简洁的
　puts "Danger,Will Robinson" if radiation>3000

四、正则表达式
　　一个正则表达式就是在一个字符串中用来匹配的特定的模式字符。在Ruby中，用两个斜线括住的模式来显式地创建一正则表达式(/pattern/)，而且，由于Ruby之所以为Ruby的原因，正则表达式当然的也是对象，并且能被处理。
常见如下：
　　/\d\d:\d\d:\d\d/ # 类似12:34:56这样的时间
/Perl.*Python/ # Perl,0或者更多的字符,然后是Python
/Perl\s+Python/ # Perl,1个或者更多空格,然后是Python
/Ruby (Perl|Python)/ # Ruby,1个空格,然后是Perl或者Python
"\d"　匹配所有的数字
"\s" 匹配空白字符（空格、Tab、换行符等
"."（一个点号）匹配任意字符。
另外：=~, 回它开始的位置，否则返回nil
if line =~ /Perl|Python/
puts "Scripting language mentioned: #{line}"
end
五、代码块和迭代器
　　def callBlock
　　yield
　　　yield
　　end
　　callBlock { puts "In the block" }
　　上面代码可以理解为：blocks(puts..)在方法cellblock 被yield 调用。代码块和方法当成是协同工作的关系，在它们之间控制在来回交换。当然yield 也可以与blocks进行交互（参数传递）见下：
a = %w( ant bee cat dog elk ) # 创建一个数组
a.each { |animal| puts animal } # 迭代所有的内容

# 在Array类中　 each　的实现大致如下：
def each
for each element
yield(element)
end
end
其它类似的实现
5.times { print "*" }
3.upto(6) {|i| print i }
('a'..'e').each {|char| print char }
六、读写
　 输出：
　 puts：自动换行
　 print:在同一行输出
　 printf:按格式输出，与c相似　
　　如：printf "Number: %5.2f, String: %s", 1.23, "hello"
　录入：
　 line=gets
print line
注：gets例程有一个附带效果，它除了返回读取的行，还把它储存到全局变量$_中，这个变量很特殊，在很多环境中它作为默认变量使。如果你调用print而没 有带参数，它显示$_的内容；如果你写一个if或者while语句时仅仅使用一个正则表达式作为条件，那么这个表达式匹配的对象是$_。尽管一些纯粹主义 者把这看作是令人讨厌的野蛮行径，但是这些简写确实又能帮助我们写出简洁的程序来。如下：
while gets # assigns line to $_
if /\d./ # matches against $_ 以数字开头的
print # prints $_
end
end
原电子文档：http://www.moer.net

重温历史－<<东京审判>>

今天晚上在家里安表的看完呢<<东京审判>>，我认为它是一部想每个中国人都值得一看的历史片。我一直对日本人没有什么好感，感觉他们是那么的傲慢，死不认错，在法庭上不停的狡辩。松井石根所冒出的“哥弟论”更是愤怒！节选一段对白:
“南京没有发生大屠杀！季南检察官所说的、日本皇军对中国俘虏、平民、妇女实施了所谓的有组织且残忍的屠杀奸淫的这些指控，全部都是诬蔑！而且超过军事上需要破坏房屋财产等指控也都是谎言！”“…我始终坚信，日中之间的战争是所谓的‘亚洲大家庭’中兄弟之间的争吵，日本不可避免的要使用……一点点……强硬手段。”“这同哥哥经过长期忍耐后赶走不听话的弟弟没有什么两样。采取这一行动的的目的在于促使中国回心转意。哥哥对弟弟态度可能有点粗暴，但哥哥的出发点是好的，是为弟弟好，哥哥是爱弟弟的！”远东国际军事法庭首席检察官季南冷笑了道：“那我倒要请问，‘弟弟’对‘哥哥’的爱反应如何？”松井石根有些尴尬：“这个、‘弟弟’没有理解这一点，对、对‘哥哥’的爱一点儿也不感到高兴。
最后东条英机的嚣张更是让人气愤，而做为一个甲战犯供在靖国神社真是国人的耻辱！
季南：“你认为作为首相发动战争，在道德和法律上都没有错吗？”东条英机左手撑在桌子上，挺起胸膛，对着季南强硬地：“完全没有任何过错！以前、现在还有将来，我都认为那都是正当的！”
最后我很欣赏”梅“的风格，特别是在开始为坐座顺序与最后投票他都是在力争，正如他所说的“我己尽力呢”

十张叫做幸福的照片

转摘：TechWeb 论坛，觉得很经典所以收藏起来，慢慢品尝！

我们总是抱怨生活的压力太大,
工作,家庭,金钱,甚至爱情,
本来该是生活的快乐所在,
却变成了背上的枷锁.
习惯面无表情的生活,习惯让自己的心很硬很硬.
甚至忘记了这个世界上还有一种东西叫幸福.
其实,幸福很简单,
如果你不那么匆匆,
如果你用爱的目光,
如果你有足够的宽容,
幸福真的离我们很近.
那么，什么才是幸福呢：幸福就是可以把握住现在的拥有
看了下面的图，你是否也能感受到幸福的所在.

第一张 爱情
沉醉于爱情中的人是幸福的.
长长的人生之路,有你的陪伴,扶持,足够了



第二张,依旧是爱情

有人说爱情是一杯茶,时间一久就淡了.
我说爱情更像是一个煲,时间越长越有滋味




第三张 母爱

如果整个世界都抛弃了你,
至少还有母亲不会放弃你.
还记得儿时母亲的怀抱就是我最美的天堂





第四张 纯真

这样的笑,这样的幸福,只有孩子才有

第五张 希望

如果你有希望，也是幸福
等待中的幸福最美好





第六张 分享

和别人分享欢乐的同时，你拥有的也是幸福




第七张 自然

看到这张照片,我有一种莫名的感动,
想起小的时候淋雨的情景,
和大自然如此的接近,烦恼不见了.
窗外正飘洒的细雨,有出去淋雨的冲动



第八张 野花

是的,幸福就是一朵野花,
用自己的生命展示美丽,这就是幸福



第九张 求知

这是一张老照片,初看的时候感觉心酸,
逐渐的,发现了求知的力量,
破旧的教室,打满补丁的衣裳,
却掩盖不了心中对知识的渴望,
比起那些一坐进教室就头疼的城里 孩子来讲,
他们就是幸福的



第十张 孩子

他们是落入凡间的精灵,那是可以让人忘记烦恼的笑

感谢恩师

今天给大学的杨博发了个祝福的短信。很过意不去，虽在同一个城市之下也没有去看望一下（自己在不停的找n个不去的理由，惭愧!），非常感谢杨博给我在外做项目的机会，当然还有其它的关照，现在还忘不了您带我们到餐馆改善火食的情形。我还要感以下老师。
高中时的李老师、樊老师、余老师，三位非常有才气的专业老师，虽然你们现在都离开了教育战线，感谢你们对我专业上的帮助。感谢周老师（高三的班主任）没有您，我可能就入不了大学，感谢您对我语文上的帮助与鼓舞（不知您身体好些没？）。
感谢初中的陈老师，感谢您在寒冷的冬天把我打"醒"(当时犯了一个很大的错误），后面是您把我叫到家里，亲自给我理头，给我莫大的鼓舞（那是当学生以来的最高待遇），是您教我“是金子在那里都会发光”，这句话我将永记于心！
我一直在安慰自己，等在外面混出点明堂的时候，再回去拜访各位恩师。也是一种虚荣心在做怪。
　各位恩师，祝你们节日愉快！
　　　　　　　　　身体健康！
　
　　　　　　　　　　　　　　　　　　　　　　　　　　　

如何通过blog 来学习

今天观看了CSDN Blog 学习之"道"，谈话嘉宾为csdn blog 的产品经理陈瑞江，其中主要谈了对E-learning的展望与如何能过以blog为中心进行学习，受其启发，（从中得知，也行本人学习计划一只不能很好的执行，是没有引入过程管理的原因吧 :)）关于如何通过blog学习陈讲了以下几点：
1、制定学习目标，制定学习目标要按的smart原则
　　目标是具体的(Specific)，目标是可以度量的(Measurable)、目标是可以达到的(Attainable)、目标是相关的(Relevant)有结果导向，有时间限制的(Time-based)。
2、在实现学习目标时，引用学习过程管理（与项目管理类似）
　　制定好的计划－>按计划去执行－>检查与调整学习计划－＞分析与总结学习计划　
　　（就是项目管理中的进度管理）
根据以上分析个人情况得出。
　1、没有按smart原则来制定学习计划。（大太，不可度量等，没细化）
　2、制定学习计划后，没有根据自己实际情况做相关的调整，也有事后的总结与分析。
　

你是否考虑要换个工作？

你什么时候该考虑换个工作了 ? "
如果符合下面的条件，你该考虑换工作了：

* 你发现自己没有成长的空间了。
* 你发现这种状况以后不太可能得到好转。
* 你的工作不再具有挑战性。
* 你的兴趣不在你现在的工作上。
* 你希望你的事业有所突破。

如果符合下面的因素，换工作可能解决不了你的问题：

* 你离开不过是在另一个公司找一个相同的职位。
* 你经常抱怨或者感到沮丧，无论在哪个公司或者哪个职位。
* 你理想化另一个公司，选择跳?"
----------
我也是在痛苦中的挣扎，选择离开还是继续？离我做决定的时间越来越短呢。

秋意浓浓

今天长沙天气一下降到19度，早晨起来也感觉到几丝的凉意，小禹也物别的多加了衣服！

一个很精彩的比喻

一个SQA的工作日记??希赛网软件工程频道软件质量栏目: "项目组就像是一家餐馆，项目经理是当班经理，他决定做什么，有多少人多少资源来做多大，有多大的风险；系统架构设计师就是主厨，他设计具体做法；程序员就是厨师，配置管理员、系统集成人员、数据库管理员等角色是厨房里面的服务人员。而 SQA 和测试工程师更像是第三方的检查人员， SQA 检查的是制作流程是否正确，材料是否使用正确，卫生是否做好了，他检查所有人的工作，包括项目经理。 SQA 虽然没有决定权，但是他?"

设置blog地图的几中方法。

国内：
　　blog map
　　具体的操作方法见天伦之乐上的介绍。测试几次在firefox下不能正常的显示地图。
　　51ditu　
具体操作：选择城市、标注位置、制制代码
　　国内两个相比，我个人比较反推荐51ditu。它操作简单不需注册，对firefox支持很好，另外它本身就是地图的提供商所以速度还可以。
国外：
　　wikimapia
　引用的是google 地图。对ie/firefox都支持。
　　　操作方法：
　　　　右上角，选择language－>chinese.
　　　　选择 wikimapia ->search city ,搜索你所在的城市，放大至，你所在的地方。
　　　　选择 wikimapia ->map on you page ，可以调整大小。然后把之间的一段代码放到你的blog中就可以呢。具体效果在我blog中有。
　　　google map
操作略显专业点，需要注册后得到key,然后用js来调用。具体实现方式不在详述。下面例几个链接。
google maps api 第2版文档（中文）

K_Reverter的网页开发空间

有兴趣的朋友可以试试。有什么问题可以留言给我