File.atime("c:\\test.txt")

=>2013-02-04 18:40:21 +0800

返回文件名filename中的扩展名部分(跟在最后的"."之后的部分)。目录名中的"."和文件名头上的"."不会被看作扩展名的一部分。若filename中不含扩展名则返回空字符串。

File.extname("c:/test.txt")        

"r", RDONLY: 以读取模式打开文件.

File.delete("c:\\test.txt")

=>1

File.expand_path(("c:/test.txt")

=>"c:/test.txt"

File.expand_path((".")

=>"c:/Sites"

File.expand_path(("..")

=>"c:/"

File.fnmatch("*", "c:/test.txt")

=>true

File.fnmatch("c:/*", "c:/test.txt")

flags中可以任意使用下列常数(定义在File::Constants模块中)中的若干个来改变模式匹配的运作情况。flags的默认值为0(不指定标识)。

File.ftype("c:/test.txt")

=>"file"

a="c:/"

b="test.txt"

c=File.join(a, b)

=>"c:/test.txt"

File.link("c:/test.txt", "c:/test1.txt")

=>0

(在c:下生成新文件test1.txt)

File.split("c:/test.txt")

=>["c:","test.text"]

myfile = File.new("c:/test.txt")

myflie.atime

=>2013-02-04 18:40:21 +0800

myfile.chmod(112211)

=>0

myfile.flock(File::LOCK_SH)

=>0

myfile.path

=>"c:/test.txt"

myfile.lstat

=> #<File::Stat dev=0x0 ..... +0800?

myfile.truncate(10240)

=>0

File::PATH_SEPARATOR

哈哈，n久前就有人跟我说这个文章了，说实话，一直懒得看，今天有时间，咱也搞个辩论，直接copy过来，红色的是个人意见。

让测试团队慢慢死去！

让我们先由2个问题引出今天的话题，第一，为什么选择做测试？第二，做测试的发展又如何？

第一个问题，你为什么要选择做测试，我敢说十个人有九个不会说实话，什么测试能够让我开阔视野啦，测试同样也需要很好的技术啦，，，全是虚伪的借口。真正地答案只有一个，测试的收入高，要求低！(注意是相对你的能力比来说收入算高，因为你要是选择做开发，肯定不如现在的收入)不管你愿不愿意承认你都得承认，这是绝大部分测试入这一行的原因。

第一个问题的答案决定了一个事实，测试团队的发展永远不可能像开发团队一样，随着公司的发展而发展，为什么呢？成本！ 世界上没有傻逼的公司，你的公司之所以能够存在，是因为它善于控制成本。站在管理层来看，测试团队是一个"显著"消耗成本而又不"显著"创造价值的团队。

第二个问题，测试的发展如何？既然我们的收入又不低，那么干的就得比人家多，你说是不。人家一天接一个客人，咱就得接三个。作为测试的你，是不是有同感？

那么，第二个问题的答案是什么呢？答案就是这篇文章的title，测试团队将慢慢死去！就像《黑天鹅》的作者塔勒布所讲的，这个世界是由一系列不可能发生的事件组成的。测试团队死去这件事情随时可能发生，你要做的，是要提前做好准备！

我喜欢描述这样一个场景，一线测试工程师对着电脑在干活儿，左边的高层管理着指着他的鼻子说"别再跟我要head count，我要控制成本！",右边的中层管理着指着他的鼻子说"去给我拓展业务，我要创造业绩！"，中间的你，那一脸苦逼的表情，还用我描述吗？

我认为，测试团队的发展大概要经过这样三个阶段。

第一阶段，公司快速扩张，不计研发成本，当然测试也不例外，每天都在非常happy的招人中。。。。

第二阶段，经过第一阶段的快速扩张，你的测试团队积累了大量的高级测试工程师，成本已经开始进入高层的考虑范围，技术部开始考虑适度控制成本，而此时，控制最厉害的，肯定是测试团队，当然裁员首先也会从测试团队开始。如果你幸运的没有被裁掉，不要盲目乐观，还有第三阶段。

第三阶段，(我认为我所在的公司正处于这个阶段)严格控制测试成本，老大们开始考虑将测试工作向上游转移。此时大量的词汇开始进入我们的KPI，什么推动单元测试，推动开发自测，控制提交测试质量，等等，等等。

讲到这里，今天的关键就出现了，如何将测试的工作向上游转移呢？答案就是第四阶段，让测试团队慢慢死去。。。。

节省测试成本的最好方式就是把自己干掉！没错！下面我说说方法。

测试团队当中，首先应该干掉的是纯手工测试工程师，因为他们的性价比是最低的(有些公司这个时候会选择测试外包)。然后，开发测试工程师当中出色的那部分，会加入开发团队当中，不出色的将被淘汰。他们有一项艰巨的任务，那就是，以开发自测为基础，为开发团队建立起一套完整的基于风险的质量控制体系。开发做测试不是能力问题，而是思想，思想却是最难以改变的。这也是好多人天天说要推动开发自测却没有进展的原因，没有认识到改变别人思想的工作有多难！我提的办法呢一石二鸟。开发测试工程师转入开发团队，既能节省测试成本，又可以帮助开发转变思想，以一带二，以一带三，逐步完成开发团队，全民皆测试的目标！

那么最后，测试团队中还剩什么呢？只会剩测试工具组。他们为全公司提供测试工具，平台和流程方面的支持。极少量的团队会保留纯手工测试工程师。但是，你绝对不应该看到"开发测试工程师"这个title，因为他们已经成为了开发团队中的一员，一起开发，一起测试。。。

（恩，我最讨厌title了，每个人都是不同的role，挂上一个title就不用干别的吗，最起码，一个测试人员，除了测试这个role，还有质量管理这个role，需求人员这个role，文档人员这个role，模拟客户这个role，。。。别提title，sb才觉得自己是什么title就干什么活呢）

插一段说明，我觉得不必说，但有些人会这么想的。有人会说测试团队应该保留一些测试职位，负责集成测试，系统测试和性能测试。这样说的人很多，但绝对没有过实践经验。为什么呢？ 没有与开发天天在一起讨论问题，功能测试这个阶段，怎么能做好集成，系统测试呢？ 不要妄想了，这些工作也会由开发团队完成。你可能会觉得开发工程师怎么会做呢？ 他们为什么不会做呢？别忘了那些转入开发团队的开发测试工程师有一项艰巨的任务，"以开发自测为基础，为开发团队建立起一套完整的基于风险的质量控制体系",其中就包括测试分工这些在测试团队习以为常的工作。我相信，开发暴发出来的测试能力是你想象不到的。

接下来可能要转换一下角度，站在开发角度来看，他们愿意接受这样一个变化吗？答案是不一定，但只有开发负责人愿意就没问题。我不刻意想学习google,facebook那种模式，但我想说，开发懂测试是一个必然趋势，如果你不想像测试一样被淘汰的话，还是接受吧。

测试是一个矛盾体，我们过去，现在，将来一直会做的事情就是让自己死掉(提升开发测试比，开发自测，等等，这些工作我们不是一直在做吗？)。

作为测试的你，能做什么呢？如果你不懂开发，要赶紧去学开发，学设计。如果你懂开发，那就还是要学开发，学设计，技术没有止境。有人跟我说"你过于强调技术，其实测试思想才是最重要的",我认可这种看法，但不完全同意。因为技术能力会束缚你的测试思想，同样也会拓宽你的测试思想。试想都不懂tcp/http协议，怎么测试web server呢？ 

空谈误国，实干兴邦，牢牢把握技术才是王道！

上面这篇文章是前阶段淘宝前辈邓悟写的，感觉有一定道理，就拿过来跟大家分享下（已得到前辈同意）；关于测试团队的前三个阶段发展的论述比较赞同，感觉现在好多大公司的确也有这种趋势；

对于第四个阶段不发表评论，感觉测试职位只是一种合理分工的产物，如果这种分工方式对于公司来说成本相对较低，公司当然会保留；

对于前辈说的这种可能对于国内大多数公司感觉暂时不太可能（未来就不做猜测了），当然像淘宝这样的公司要另说；对于前辈说的“技术”，我的看法也是多多益善，但是人的精力毕竟有限，要结合实际工作做取舍。

原文链接：http://blog.sina.com.cn/s/blog_71ad0d3f0101bytk.html

若带块时，将以生成的IO对象为参数来运行该块，并返回其结果。在块得到运行以后，生成的管道将会自动关闭。

当命令名为"-"时，Ruby将运行fork(2)来建立一个连接到子进程的输入输出的管线。

IO.read(path,[length,[offset]]) 

IO.read("c:\\test.txt")

=>"test1\ntest2\ntest3\n"

newfile = IO.systemopen("c:\\test.txt","r+")

=>3

newff = IO.new(newfile)

=>#<IO:fd 4>

newff <<1<<"test"<<"\n"

new1 = newff.binmode

new2 = newff.clone

new2.close

new2.close_read

new2.close_write

new.closed?

newfile.flush

若将某字符串传给第二参数的话，将使用读入的数据来覆盖该字符串对象，并返回读入的数据。

从IO读入最多maxlen的数据，并返回读入的字符串。

newfile.SEEK_CUR

newfile.SEEK_END

newfile.SEEK_SET

哈希表(也叫散列表)的类.通过哈希表,您可以将一个任意类型的对象同另一个任意类型的对象联系起来.

可以使用下列哈希表表达式来生成哈希表： {a=>b, ... } (key=>value)

通常使用Object#hash方法来计算哈希表的值,而使用Object#eql?方法来判定索引是否相同.

h = Hash.new {|hash, key| hash[key] = "foo"}

puts h[1]

=>"foo"

h[2]="fool"

h[2]

=>"fool"

h.store(3,"test")

h[3]

=>"test"

h.clear

=>{}

b=h.clone

b[1]

=>"foo"

h.default

=>nil

h.default("123")

=>foo

h("123")

="foo"

h.default="test"

h.default

=>"test"

h[10]

=>"test"

h

=> {1=>"test",2="test",3=>"test"}

h.delete(2)

h

=> {1=>"test",3=>"test"}

合并两个hash表。当self和other中包含相同索引时将按照下列两种方式来处理: 若带块则调用该块,然后由用户选择使用哪个值;不带块的话则通常使用other的值.

生成方法：

afile=File::Stat.new("c:\\test.jpg")

=> $<Fiel::Stat dev=0x2.........+0800>

生成并返回一个File::Stat对象. 

bfile=File::Stat

=>File::Stat

cfile=b.new("c:\\test.jpg")

=> $<Fiel::Stat dev=0x2.........+0800>

afile<=>cfile

=>0

afile.ftype

=>"file"

afile.dev

=>2

afile.dev_major

=>nil

Dir.pwd

=>"c:/"

Dir.chdir("c:\\Sites")

=>0

Dir.pwd

=>"c:/Sites"

Dir.delete("c:\\test")

=>0

Dir.entries("c:\\Sites")

=>[".", "..", "chromedriver.log", "todo"]

a.close

=>nil

a.tell

IOError: closed directory

a.each {|item| puts item}

.

..

chromedriver.log

todo

=> #<Dir:c:\Sites>

a.path

=>"c:\\Sites"

a.pos

=>4

a.seek(2)

=> #<Dir:c:\Sites>

a.tell

=> 2

a.read

=>"chromedriver.log"

a.rewind

=> #<Dir:c:\Sites>

a.tell

=>0

a=Array[1,2,3]

=>[1,2,3]

a=Array.new(5,1)

=>[1,1,1,1,1]

b=Array.new(a)

=>[1,1,1,1,1]

a==b

=>true

=>2

a[-1]

=>3

=>[2,3]

a[-1..3]

=>[3]

=>[2,3]

a[-1,2]

=>[3]

a

=>[1,6]

将self和other的内容连起来后生成新数组并返回该数组。若other并非数组时则使用other.to_ary的返回值。若该返回值依然不是数组时，则引发TypeError异常。

a=[1,2]

b=[3,4]

a+b

=>[1,2,3,4]

a=[1, 2, 3] 

a*3  

=> [1, 2, 3, 1, 2, 3, 1, 2, 3]

若times为字符串，则其动作等同于self.join(times)。

a*"a"

=>"1a2a3a"

集合的补集运算。从self中删除other的元素后生成一个新数组并返回该数组。重复元素将被清除。

a<<5<<6<<7

=>[1,2,3,5,5,6,7]

a.assoc(15)

=>nil

a=[1,2,3]

a.delete_if{|x|x=false}

=>[1,2,3]

a.delete_if{|x|x=true}

=>[]

1

2

3

=>[1,2,3]

a=[1, 2, 3]

a.fetch(1)

=>2

a.first

=>1

a.first(2)

=>[1,2]

a=[1, [2, 3, [4], 5]]

a.flatten   

=> [1, 2, 3, 4, 5]

=>0

在索引为nth的元素前面插入第2参数以后的值。返回self。

=>3

a.size

=>3

=>[1,2,3,4]

=>[4,5]

p [1, 0, 0, 1, 0].rindex(1)   

=> 3

对数组内容进行排序。若带块调用时，将把2个参数传给块，然后使用块的计算结果进行比较。若没有块时，使用<=>操作符进行比较。sort将生成一个经过排序的新数组并返回它。sort!的对self的排序过程具有破环性。

将self看作是由行和列构成的矩阵，然后进行行列互调(将行和列互换)。生成一个新数组并返回它。若原数组为空，则生成空数组并返回它。

包含的模块为Kernel。

定义的方法有：

两个对象对象是否相等

两个对象是否不等

对象是否为子类

对象的父类

克隆对象

克隆对象的内容

将对象输出到 out

等同于 ==

将参数所指模块的实例方法追加为self的特殊方法.返回self.

返回与各个对象对应的唯一的整数.

取得并返回对象的实例变量的值.

将val的值赋值给对象的实例变量并返回该值.

标准输入。$stdin的默认值。

标准输出。$stdout的默认值。

标准错误输出。$stderr的默认值。

表示环境变量的(伪)哈希表。若改变该哈希表的值时，将作为子进程环境而被继承下来。

所有以`$'开头的变量

全局变量中的内部变量(本网页介绍的变量)

内部变量中,形如"`$' + 1位数字或符号"的变量

内部变量中,由命令行选项设定的变量,形如"`$-' +1个选项字符"

根据变量值的作用域的不同,大致将内部变量划分如下：

gets或readline最后读入的字符串.若遇到EOF则为nil.

在当前作用域中,正则表达式最后一次匹配成功的字符串.若最后一次匹配失败,则为nil.

分别存储着最后一次模型匹配成功时与第n个括号相匹配的值.若没有相应的括号时,其值为nil.

内部函数print、puts或p等的默认输出对象。初始值为STDOUT。若指定了-i[extension]选项的话，则将使用与读取源同名的文件。

标准输入，标准输出，标准错误输出

把字符串str当做外部命令来运行,并以字符串方式返回命令的输出。

调用 arg.to_ary 或 arg.to_a 将参数转为数组并返回结果

a=Array("test")

a.class

=> Array

将参数变为浮点数(Float)并返回结果.

puts Float("10")    

=> 10.0

将参数变为整数(Fixnum,Bignum)并返回结果.对数值,字符串以外的对象使用to_i方法。

puts Integer("0d10") 

=> 10

调用arg.to_s将参数变为字符串并返回结果。

以非正常方式结束Ruby程序的运行。

在解释器结束工作之前执行指定的块。除去at_exit是个方法这点差异之外，它与END块所进行工作基本相同。

可以autoload任何类／模块的常数。

生成并返回Binding对象。该对象包含变量、方法等的环境信息，它通常用作Eval的第二参数。

运行块并返回它的值。若在块的运行过程中，遇到与tag同名的throw的话，将把throw的第二参数的值作为返回值。

将内部变量$_末尾的字符去掉(若末尾是"\r\n"则去掉2个字符)。chop不改变内部变量$_的内容，chop！改变内部变量$_的内容。

把字符串expr当作Ruby程序来运行并返回其结果。若给第二参数传递Proc对象或Binding对象的话，将在生成该对象的环境中对字符串进行计算。

执行由command指定的命令.该命令将变成进程执行的代码,所以一旦启动成功,就不会再从该函数中返回.若启动失败,控制权重新回归ruby解释器,然后会引发Errno::EXXX异常.

终止Ruby程序的运行.若向status传递了一个整数的话,该整数就将成为Ruby命令的结束状态值.默认的结束状态值是0.

使用fork(2)系统调用来制作进程的拷贝.若在父进程中将返回子进程的进程ID,若在子进程中则返回nil.若指定一个块之后再进行调用,则会在生成的子进程中对该块进行计算.

Ruby解释器在运行时,会把从参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(可以使用内部变量$<或ARGF访问该虚拟文件),然后从该虚拟文件中读入一行,并返回字符串.若到达文件尾部时返回nil.

使用rs指定的字符串作为行的切分符号.rs的默认值取自内部变量$/.读入的字符串也被存入内部变量$_中.

若将rs设为nil的话,则意味着读入文件的全部内容而忽略行的切分.若设为空字符串""的话,会把连续的换行当做行的切分符(段落模式).

readline的功能与gets相同,但是当它遇到文件结尾时会引发EOFError异常.

在内部变量$_所包含的字符串中,将符合pattern的部分替换为replace,然后返回结果.若省略参数replace时,该方法将演变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.

若某方法带块则返回真,否则返回伪。

若加载成功则返回true,若失败则引发LoadError异常.

打开file并返回File对象.mode可以是下列，省略时默认为"r".

可在上述任意一项后面添加"b"(如"r+b")标志.此时,将以二进制方式打开文件(只限于以文本/二进制方式来区分文件的系统).

当open与块同时被调用时，open将打开文件并执行块，当块的运行终止后就关闭文件。此时返回块的计算结果。请看下例。

依次输出mesg和换行符到$stderr之中。若内部变量$VERBOSE为nil时，则不会输出。

print "stop\n" unless valid(passwd)

sleep(60) while io_not_ready?

print(f.gets) until f.eof?

next将跳转到最内侧循环的头部

redo不检查循环条件，重新开始当前循环。

retry，意味着重启迭代器

return结束方法的运行，且把表达式的值设定为方法的返回值。若给出了2个以上的表达式，则将把这些表达式化为一个数组，然后把该数组设定为方法的返回值。若省略表达式，将返回值设为nil。

我们把类似字符串“hello world”这样可以直接写入Ruby程序中的值叫做字面值。

123 整数

-12 带符号的整数

1.2 浮点数

?a a的AscII码

"this is a string expression\n" 字符串

'a' 字符

'aaa' 字符串  

在被单引号括起来的字符串中，除了\\(反斜线本身)、\'(单引号)和行尾的\(忽略换行)以外，不会对字符串内容作任何处理。

字符串中，以\来处理的字符有：

\t Tab

\n 换行

\r 回车

\f 换页

\b 退格

\e Esc

\s 空白

\\ \

\' '

字符串中，以%来处理：

实例：

%(()) => "()"

%w(foo bar baz) => ['foo', 'bar', 'baz']

字符串中，以展开式来处理：

"my name is #$ruby" #=> "my name is RUBY"

在以双引号(")括起来的字符串表达式、命令字符串以及正则表达式中，可以使用“#{表达式}”把表达式的内容(以字符串的形式)嵌入其中。若表达式是以($,@)开始的变量的话，则可以省略{}部分，只使用“#变量名”的形式即可.

等同于：

print "  the string\n  next line\n"

可以当作一个整体进行应用：

被/括起来的部分就是正则表达式，例如：/Ruby/i

被[]括起来的部分就是数组表达式，例如：[1, 2, 3]

被{}括起来的部分就是哈希表达式，例如：{1=>2, 2=>4, 3=>6}

范围表达式两端都是数值字面值时，每次计算都将返回同一个对象。除此以外，每次计算时都会返回新的范围对象。例如： [1..9]

符号应用的语法如下：

指定给Symbol字面值的操作符，必须是那些可以作为方法进行再定义的操作符

标识符首位是小写字母或“_”，则该变量就是局部变量。

局部变量的作用域起始于声明处，结束于该声明所在的块、方法定义、类／模块定义的结尾。

但也有例外。若块已经变成过程对象的话，则局部变量将一直持续到该过程对象终结为止。若多个过程对象引用同一个作用域的话，局部变量将被这些对象所共享。

以@开始的变量是实例变量，它属于特定的对象。可以在类或子类的方法中引用实例变量。若引用尚未被初始化的实例变量的话，其值为nil。

以@@开始的变量是类变量。在类的定义中定义类变量，可以在类的特殊方法、实例方法等处对类变量进行引用／赋值。类变量可以被当作被类、子类以及它们的实例所共享的限制性全局变量。

以$开始的变量是全局变量，可以在程序的任何地方加以引用(因此需要特别留意)。全局变量无需变量声明。引用尚未初始化的全局变量时，其值为 nil。

除普通的变量之外，还有一种叫做伪变量的特殊变量。

self 当前方法的执行主体

伪变量的值不可改变，若对伪变量赋值将引发语法错误。

以大写字母([A-Z])开始的标识符是常数.常数的定义(和初始化)由赋值过程完成.不能在方法中对常数进行定义.若对已定义的常数进行赋值的话,会出现警告信息.若引用未定义的常数的话,则会引发NameError异常.

类变量可以重复赋值，常数不能。

类变量不能在类的外部直接引用，只能在其继承类中引用／赋值。

常熟可以在类的外部直接引用。

在ruby中，将表达式连接起来就构成程序。

使用分号(;)或换行将表达式分隔开来。但反斜线后出现的换行并非分隔符，它表示该行将继续下去。

例:

puts "hello \

world!\n"

Ruby的表达式包括:变量和常数、各种字面值、相关计算和赋值、if或while等控制结构、方法调用、类/方法的定义。还可以使用括号将表达式括起来进行群组化。

Ruby以#开始的行当作注释行来处理。 字符串内部和数值字面值中的“#”除外。

# this is a comment line

行首为=begin的行开始到行首为=end的行为止的部分就是内嵌文档，这部分代码被忽略，一般用于较长的解释

下列词语就是Ruby的保留字：

保留字不可用作类名和变量名。

Ruby所能处理的都是对象。

Ruby操作对象时的办法只有一种，那就是方法调用。

对象所属的类决定了对象所包含的方法，对象是类的“实例”。

类决定了其对象的方法，对象调用方法的方式是：类+方法名。

类能继承父类的方法，这是一种继承关系。

而引入的模块，是一个包含了完整的方法的非类。

调用方法时可以传递其他对象，这些其他对象就是“参数”。可接受的参数是在定义方法时确定的，不可改变。

类本身也可以看作是一个对象。例如：查询某方法是否存在，定义方法或者取消方法。

当代码中有BEGIN/END圈起的代码块，会被先执行。

"option"指命令行选项。

"--"则显式地表明选项字符串到此结束。

"programfile"是装载Ruby脚本的文件。若省略不写或者写成"-"时,Ruby会把标准输入当做Ruby脚本进行处理。

argument中的字符串将变成内部常数ARGV的初始值。

常用的option有：

额外执行一行代码，可以有多个-e出现

例如：ruby -e "5.times do |i|; puts i; end"

打开warning信息/设置warning的级别

版本信息

一种是先查找到editor所在的iframe，然后使用send_keys的方法来发送字符串，需要注意的是，包含该iframe的窗口必须是在所有的窗口最上方.

另外一种方式是书写一段javascript语句，通过对browser进行内容输入，这种方法最常见

例如CKEditor

这个例子就是向iframe直接通过send_keys发送字符

向browser发送Enter键，等于在当前页面敲击回车，作用于当前焦点处：

向指定的element发送多个键值：

也可以overide一些元素的click事件：