(整理)Ruby的基础知识

xzyxuanyuan0我的：收件箱资源博客空间设置|帮助|退出

• 首页
• 业界
• 移动
• 云计算
• 研发
• 论坛
• 博客
• 下载

• 更多

千月星跡

アイをも求めて彷徨っている孤独なヒーロー

• 目录视图
• 摘要视图
• 订阅

【免费有礼】欧美最新网络营销技巧分享        博客导入工具      【限时优惠】第五届云计算大会社区门票抢购 
探究云计算数据中心节能增效之道      专访邓凡平：Android开发路上的快速学习之道      CSDN博客第二期最佳移动开发博主评选

分类： Ruby2008-01-30 13:32 1192人阅读 评论(5) 收藏 举报

rubyclassincludecmathobject

 

Ruby 基础知识整理

Ruby是面向对象的编程语言，她追求的是“简便快捷的面向对象编程”。Ruby是解释型语言，因此不需编译即可快捷地编程。同时Ruby具有类似 Perl的强大的文本处理功能，她可并不只是个玩具，您可以用她来进行实用的编程。此外，您还可以很方便地使用C语言来扩展Ruby的功能，因此可以把她当作各种库的前端来使用。

若您曾经“想要一种简单的面向对象的语言”，或者认为“Perl的功能虽然好用，但它的语法真让人受不了”，又或者觉得“lisp系列语言的思想不错，但到处都是括号真让人讨厌，最起码算式应该按照通常的样式书写”。那么，Ruby或许能让您满意。

归纳以来，Ruby有以下优点。

1解释器 
Ruby是解释型语言，其程序无需编译即可轻松执行。 
2变量无类型 
Ruby的变量没有类型，因此不必为静态的类型匹配而烦恼。相应地，错误检查功能也变弱了。 
3不需要变量声明 
所有变量均无需声明即可立即使用。另外，从变量名即可判断出是何种变量（局部变量，全局变量，实例变量）。

foo:局部变量

$foo:全局变量

@foo:类属性

Foo:常数

4语法简单 
语法比较简单，类似Algol系语法。 
5不需要内存管理 
具有垃圾回收（Garbage Collect，GC）功能，能自动回收不再使用的对象。 
6一切都是对象 
Ruby从一开始就被设计成纯粹的面向对象语言，因此以整数等基本数据类型为首的所有东西都是对象，它们都有发送信息的统一接口。 
类，继承，方法 
Ruby当然具有面向对象语言的基本功能。 
7特殊方法 
可向某对象添加方法。例如，可以把GUI按钮被按下时的动作作为方法记述下来，还可以用它来进行原型库（prototypebase）的面向对象编程（有人这么干吧）。 
用模块进行混合插入（Mixin） 
Ruby故意舍弃了多重继承，但拥有混合插入功能。使用模块来超越类的界限来共享数据和方法等。 
8迭代器 
该功能可以将循环抽象化。 
9闭包 
可以将某过程片段对象化。对象化后的该过程片段就称作闭包。 
10功能强大的字符串操作／正则表达式 
以Perl为样板创造出了功能强大的字符串操作和正则表达式检索功能。 
11拥有超长整数 
添加超长整数功能后，可以计算非常大的整数。例如计算400的阶乘也轻而易举。 
12具有错误处理功能 
错误处理功能可以使您编写代码处理出错情况。 
13可以直接访问OS 
Ruby可以使用（UNIX的）绝大部分的系统调用。单独使用Ruby也可以进行系统编程。 
14动态加载 
若OS支持的话，可以在运行时读入对象文件。 
但Ruby也有下列缺点。 
15Ruby On Rails，优点是不像Struts那样需要大量的配置文件，一切都采取默认的配置，包括访问路径，uri等，而这也是它的缺点，不能灵活的配置。

 

语言特征介绍:

字符串

Ruby将字符串像数字一样处理.我们用单引号('...')或双引号("...")将它们括起来. 单引号和双引号在某些情况下有不同的作用.一个由双引号括起来的字符串允许字符由一个前置的斜杠引出,而且可以用#{}内嵌表达式.而单引号括起来的字符串并不会对字符串作任何解释;你看到的是什么便是什么. 用+把几个串连起来,用*把一个串重复好几遍。

串联: ruby

>word = "fo" + "o"

   "foo"

重复:

word = word * 2

   "foofoo"

抽取字符(注意:在Ruby里,字符被视为整数):

word[0]

   102            # 102 is ASCII code of `f'

word[-1]

   111            # 111 is ASCII code of `o'

(负的索引指从字符串尾算起的偏移量,而不是从串头.)

提取子串:

herb = "parsley"

   "parsley"

herb[0,1]

   "p"

herb[-2,2]

   "ey"

herb[0..3]

   "pars"

herb[-5..-2]

   "rsle"

检查相等:

 "foo" == "foo"

   true

"foo" == "bar"

   false

数组

通过在方括号里列出元素并用逗号将它们相互隔开来创建一个数组。Ruby的数组可以适应不同的对象类型。

ary = [1, 2, "3"]

一．             创建数组：Array.new( anInteger=0, anObject=nil )

Array.new»[]Array.new(2)»[nil, nil]Array.new(5, "A")»["A", "A", "A", "A", "A"]Array.new(2, Hash.new)»[{}, {}]

 

就像前面提到的字符串一样.数组也可以相乘或相加：

ary + ["foo", "bar"]

   [1, 2, "3", "foo", "bar"]

ary * 2

   [1, 2, "3", 1, 2, "3"]

我们可用索引来访问数组的任意一部分.

ary[0]

   1

ary[0,2]

   [1, 2]

ary[0..1]

   [1, 2]

ary[-2]

   2

ary[-2,2]

   [2, "3"]

ary[-2..-1]

   [2, "3"]

(负数索引表示到数组末尾的偏移,而不是从开头算起.)

 

数组可以和字符串互相转化,分别使用join和split：

str = ary.join(":")

   "1:2:3"

str.split(":")

   ["1", "2", "3"]

 

哈希表

一个关联数组不通过连续的数字索引来访问,而是通过任何类型的主键(key)访问.这样的数组有时被叫作哈希(hash)或者字典(dictionary).在Ruby里,我们趋向于用哈希这个术语.将一对对的元素用逗号分隔开,并用大括号({})括起来,这样就组成了一个哈希表.你用一个关键字在哈希表里进行搜索,就像你在数组里用索引来提取数据一样.

h = {1 => 2, "2" => "4"}

   {1=>2, "2"=>"4"}

h[1]

   2

h["2"]

   "4"

h[5]

   nil

h[5] = 10     # appending value

   10

h

   {5=>10, 1=>2, "2"=>"4"}

h.delete 1   # deleting value

   2

h[1]

   nil

h

   {5=>10, "2"=>"4"}

 

流程控制

条件控制语句

一．If语句

二．Case语句

循环控制语句

三．Loop语句

四．While语句

五．For语句

第一,和C一样break从循环中完全退出.第二, next 跳到下一次循环迭代的开始(对应于C的 continue ).第三,Ruby有redo,它可以重新开始现在的迭代. 第四种方法是由循环内跳出的方法是 returen. return的结果是不仅从循环中跳出,而且会从含循环的方法中跳出.如果有参数,它会返回给方法调用,不然就返回nil.

 

 

迭代器

Ruby的String类型有很多有用的迭代器:

"abc".each_byte{|c| printf "<%c>", c}; print "/n"

<a><b><c>

each_byte 是个用于字符串中每个字符的迭代器.每个字符串由局部变量c代替.

String的另一个迭代器是 each_line.

"a/nb/nc/n".each_line{|l| print l}

a

b

c

可以用retry流程控制语句连接迭代循环,它会从头执行当前循环的迭代.

c=0

for i in 0..4

       print i

       if i == 2 and c == 0

         c = 1

         print "/n"

         retry

       end

     end; print "/n"

012

01234

yield有时会在一个迭代器的定义中出现. yield将流程控制移至传递给迭代器的代码域。下面的例子定义了一个repeat迭代器,会依参数的设置执行多次代码域。

def repeat(num)

       while num > 0

         yield

         num -= 1

       end

     end

repeat(3) { print "foo/n" }

foo

foo

foo

 

类

在Ruby里,一个类的定义是在关键字class和end之间的一段代码.在域中的def开始定义类的一个方法,它对应于此类中中的某些特定的对象方法.

class Dog

       def speak

         print "Bow Wow/n"

       end

end

既然我们已有了Dog类,我们就可以用它来创造一只狗:

pochi = Dog.new

pochi.speak

 

继承和重载

class Bird

       def preen

         print "I am cleaning my feathers."

       end

       def fly

         print "I am flying."

       end

 end

 class Penguin<Bird

       def fly

         fail "Sorry. I'd rather swim."

       end

 end

在子类里,我们可以通过重载父类方法来改变实体的行为.

class Human

    |   def identify

    |     print "I'm a person./n"

    |   end

    |   def train_toll(age)

    |     if age < 12

    |       print "Reduced fare./n";

    |     else

    |       print "Normal fare./n";

    |     end

    |   end

    | end

   nil

ruby> Human.new.identify

I'm a person.

   nil

ruby> class Student1<Human

    |   def identify

    |     print "I'm a student./n"

    |   end

    | end

   nil

ruby> Student1.new.identify

I'm a student.

如果我们只是想增强父类的 identify 方法而不是完全地替代它,就可以用 super.

class Student2<Human

    |   def identify

    |     super

    |     print "I'm a student too./n"

    |   end

    | end

   nil

ruby> Student2.new.identify

I'm a human.

I'm a student too.

super 也可以让我们向原有的方法传递参数.

class Dishonest<Human

    |   def train_toll(age)

    |     super(11) # we want a cheap fare.

    |   end

    | end

   nil

ruby> Dishonest.new.train_toll(25)

Reduced fare. 

   nil

ruby> class Honest<Human

    |   def train_toll(age)

    |     super(age) # pass the argument we were given

    |   end

    | end

   nil

ruby> Honest.new.train_toll(25)

Normal fare. 

 

当我们在"最高层"而不是在一个类的定义里定义一个方法时会发生什么.

def square(n)

    |   n * n

    | end

   nil

ruby> square(5)

   25

我们的新方法看起来不属于任何类,但实际上Ruby将其分给Object类,也就是所有其它类的父类.因此,所有对象现在都可以使用这一方法.这本应是正确的,但有个小陷阱:它是所有类的私有(private)方法.我们将在下面讨论这是什么意思,但一个结果是它只能以函数的风格调用,像这样:

class Foo

    |   def fourth_power_of(x)

    |     square(x) * square(x)

    |   end

    | end

 nil

ruby> Foo.new.fourth_power_of 10

 10000

我们不允许向一个对象明确地运用这一方法:

"fish".square(5)

ERR: (eval):1: private method `square' called for "fish":String

 

私有方法

class Test

    |   def times_two(a)

    |     print a," times two is ",engine(a),"/n"

    |   end

    |   def engine(b)

    |     b*2

    |   end

    |   private:engine # this hides engine from users

    | end

   Test

ruby> test = Test.new

   #<Test:0x4017181c>

ruby> test.engine(6)

ERR: (eval):1: private method `engine' called for #<Test:0x4017181c>

ruby> test.times_two(6)

6 times two is 12.

 

为实例添加新的方法

实例的行为取决于其类,但很多时候我们知道一个特定的实体需要特定的行为.在很多语言里,我们必须陷入另外再定义一个类的麻烦里,即使它只是用来接着实体化一次.在Ruby里,我们可以赋予任何对象属于其自身的方法.

class SingletonTest

    |   def size

    |     print "25/n"

    |   end

    | end

   nil

ruby> test1 = SingletonTest.new

   #<SingletonTest:0xbc468>

ruby> test2 = SingletonTest.new

   #<SingletonTest:0xbae20>

ruby> def test2.size

    |   print "10/n"

    | end

   nil

ruby> test1.size

25

   nil

ruby> test2.size

10

在这个例子里,test1和test2属于相同的类,但test2已被赋给一个重载的size方法,因而他们有不同的行为.一个仅属于某个对象的方法叫做单态方法.

单态方法常常用于图形用户界面(GUI)的元素的设计,在那里当不同的按钮被压下时将会激发不同的事件.

模块

Ruby的模块非常类似类,除了:

l         模块不可以有实体

l         模块不可以有子类

l         模块由module...end定义.

实际上...模块的'模块类'是'类的类'这个类的父类.搞懂了吗?不懂?让我们继续看下去吧.

模块有两种用法.其一是将相近的方法和实体放在一个相对集中的域里.Ruby标准包里的Math模块就扮演着这一角色:

Math.sqrt(2)

   1.41421

ruby> Math::PI

   3.14159

::操作符告诉 Ruby 解释器在哪里找常数的值(可以想像,Math外的其它模块用PI表示其它的一些东西).如果我们想省掉 :: 直接调用一个模块的方法和常数,我们可以用 include:

include Math

   Object

ruby> sqrt(2)

   1.41421

ruby> PI

   3.14159

模块的另一用法是糅和(mixin).某些OO语言,包括C++,允许多重继承(multiple inheritance),即从多个的父类里继承. 现实世界里一个多重继承的
例子是闹钟:你可以想像闹钟属于钟类同是属于带蜂音器的事物类.

Ruby并未特意实现真正的多重继承,但糅和技术是一很好的替代.记得模块无法实体化或子类化;但如果我们在类定义里include一个方法,
它的方法便实际上已加入,或"糅合"进这个类.

糅合可以视为一种寻求一切我们希望得到的特定属性的方法.举个例子,如果一个类有个 each 方法,把标准库里的Enumerable模块糅合进来就自然地赋予我们 sort 和 find 两个方法.

模块的使用令到我们获得多重继承的基本功能却可通过简单的树结构表述类关系,同时也可观地简化了语言的实现(Java的设计者也做了一个类似的选择).

 

过程对象

我们总是希望对未知事件分类.当它发生时,向其它方法传递一块作为参数的代码是最容易地解决方法,也就是说我们希望像处理数据一样处理代码.

一个新的过程对象可以通过proc创建:

ruby> quux = proc {

    |   print "QUUXQUUXQUUX!!!/n"

    | }

   #<Proc:0x4017357c>

现在quux指向一个对象,像其它对象一样,它也有可以调用的行为.特别的,我们可以用call方法执行它:

ruby> quux.call

QUUXQUUXQUUX!!!

   nil

那么quux可以用做一个方法的参数吗?当然.

ruby> def run( p )

    |   print "About to call a procedure.../n"

    |   p.call

    |   print "There: finished./n"

    | end

   nil

ruby> run quux

About to call a procedure...

QUUXQUUXQUUX!!!

There: finished.

   nil

trap方法令到我们可以对任何系统信号做出我们自己的选择.

ruby> inthandler = proc{ print "^C was pressed./n" }

   #<Proc:0x401730a4>

ruby> trap "SIGINT", inthandler

   #<Proc:0x401735e0>

一般的,敲入^C将导致解释器退出.但现在一个信息被打印出来,解释器继续执行着,所以你不会丢失掉正在作业的工作.(你不会永远留在解释器里,你仍可以用 exit 或者按 ^D退出)

最后在我们开始下一节之前还应注意的一点是:在将一个过程对象捆绑到一个信号之前,不是必须给这个过程对象命名的.一个等效的匿名(anonymous)过程对象像这样

 

ruby> trap "SIGINT", proc{ print "^C was pressed./n" }

   nil

或着更简略,

ruby> trap "SIGINT", 'print "^C was pressed./n"'

   nil

这种简写为你提供了一种方便和可读性更强的写小匿名过程的路子.

变量

Ruby有三类变量,一种常量和两种严格意义上的伪变量(pseudo-variables).变量和常量都没有类型。在Ruby里我们不需要变量声明。

由首字母标识符将其分类:

$全局变量@实变量[a-z] or _局部变量[A-Z]常量

唯一的例外是Ruby的伪变量:self,它永远指向当前正执行着的对象或未初始化变量的空值(meaningless value)nil.虽然这两者的命名都像是局部变量,但 self 却是个由解释器把持的全局变量,而 nil实际上是个常量.既然只有这两种意外,他们并不会过多的干扰我们.

你并能向 self 或 nil 赋值.下面的例子中, main作为self 的值,指向最高层的对象:

ruby> self

   main

ruby> nil

   nil

全局变量

全局变量由$开头.它们可以在程序的任何位置访问到.在初始化前,全局变量有一个特殊的值nil.

ruby> $foo

   nil

ruby> $foo = 5

   5

ruby> $foo

   5

应谨慎使用全局变量.由于在任何地方都可以被写因此他们相当危险.滥用全局变量会导致很难隔离臭虫;同时也视为程序的设计未经严格考虑.当你发现必须要使用全局变量时,记得给它一个不会在其它地方一不小心就用到的描述性名字(像上面那样叫$foo可能不是一个好想法).

全局变量的好处是其可以被跟踪;你可以做一个当变量值改变时被调用的过程.

ruby> trace_var :$x, proc{print "$x is now ", $x, "/n"}

   nil

ruby> $x = 5

$x is now 5

   5

当一个全局变量(改变时)作为一个过程的激发器,我们也管它叫活动变量(active variable).比如说,它可用于保持GUI显示的更新.

这里列出了一些以$打头并跟单个字符的特殊变量.比如,$$包含了Ruby解释器的进程id,它是只读的.这里是主要的系统变量以及它们的含义(细节可在Ruby的参考手册中查到):

$!最近一次的错误信息$@错误产生的位置$_gets最近读的字符串$.解释器最近读的行数(line number)$&最近一次与正则表达式匹配的字符串$~作为子表达式组的最近一次匹配$n最近匹配的第n个子表达式(和$~[n]一样)$=是否区别大小写的标志$/输入记录分隔符$/输出记录分隔符$0Ruby脚本的文件名$*命令行参数$$解释器进程ID$?最近一次执行的子进程退出状态

上面的 $_ 和 $~ 都有作用范围.它们的名字暗示其为全局的,但它们一般都是这样用的,关于它们的命名有历史上的原因.

实变量

一个实变量由@开头,它的范围限制在 self 对象内.两个不同的对象,即使属于同一个类,也可以拥有不同值的实变量.从对象外部来看,实变量不能改变甚至观察(比如, Ruby的实变量从来不是公用的),除非方法由程序员明确声明.像全局变量一样,实变量在初始前的值是nil.

Ruby的实变量用不着声明.这暗含着对象的弹性结构.实际上,每个实变量都是在第一次出现时动态加入对象的.

ruby> class InstTest

    |   def set_foo(n)

    |     @foo = n

    |   end

    |   def set_bar(n)

    |     @bar = n

    |   end

    | end

   nil

ruby> i = InstTest.new

   #<InstTest:0x83678>

ruby> i.set_foo(2)

   2

ruby> i

   #<InstTest:0x83678 @foo=2>

ruby> i.set_bar(4)

   4

ruby> i

   #<InstTest:0x83678 @foo=2, @bar=4>

注意上例中直到调用了 set_bar方法 i 才报告 @bar 的值.

局部变量

局部变量由小写字母或下划线(_)开头.局部变量不像全局和实变量一样在初始化前含nil值.

ruby> $foo

   nil

ruby> @foo

   nil

ruby> foo

ERR: (eval):1: undefined local variable or method `foo' for main(Object)

对局部变量的第一次赋值做的很像一次声明.如果你指向一个未初始化的局部变量,Ruby解释器会认为那是一个方法的名字;正如上面所见错误信息的.

一般的,局部变量的范围会是

• proc{...}
• loop{...}
• def...end
• class...end
• module...end
• 整个程序(除非符合上面某个条件)

下面的例子,define?是一个检查标识符是否已定义的操作符.如果已定义它将返回标识符的描述,否则返回nil.正如你所见的,bar的范围是loop的局部变量;当loop退出时,bar无定义.

ruby> foo = 44; print foo, "/n"; defined? foo

44

   "local-variable"

ruby> loop{bar=45; print bar, "/n"; break}; defined? bar

45

   nil

一个范围内的过程对象共享这个范围内的局部变量.这里,局部变量 bar由 main和过程对象 p1, p2共享:

 

ruby> bar=0

   0

ruby> p1 = proc{|n| bar=n}

   #<Proc:0x8deb0>

ruby> p2 = proc{bar}

   #<Proc:0x8dce8>

ruby> p1.call(5)

   5

ruby> bar

   5

ruby> p2.call

   5

注意开始的"bar=0"不能省略;此赋值允许bar的范围被 p1和 p2共享.不然 p1, p2 将会分别生成并处理它们自己的局部变量 bar, 调用 p2 也将导致"未定义局部变量或方法"错误.

过程对象的强大在于它们能被作为参数传递:共享的局部变量即使传递出原范围也仍然有效.

ruby> def box

    |   contents = 15

    |   get = proc{contents}

    |   set = proc{|n| contents = n}

    |   return get, set

    | end

   nil

ruby> reader, writer = box

   [#<Proc:0x40170fc0>, #<Proc:0x40170fac>] 

ruby> reader.call

   15

ruby> writer.call(2)

   2

ruby> reader.call

   2

Ruby对待范围的办法相当聪明.显然,上面例子里 contents变量是由 reader 和 writer 共享的.我们也可以像上面那样创造多对使用box的reader-writer;每一对共享一个 contents 变量,对之间不相干扰.

ruby> reader_1, writer_1 = box

   [#<Proc:0x40172820>, #<Proc:0x4017280c>]

ruby> reader_2, writer_2 = box

   [#<Proc:0x40172668>, #<Proc:0x40172654>]

ruby> writer_1.call(99)

   99

ruby> reader_1.call

   99

ruby> reader_2.call

   15

类常量

一个常量由大写字母开头.它应最多被赋值一次.在Ruby的当前版本中,常量的再赋值只会产生警告而不是错误(non-ANSI版的eval.rb不会报告这一警告)

ruby>fluid=30

   30

ruby>fluid=31

   31

ruby>Solid=32

   32

ruby>Solid=33

   (eval):1: warning: already initialized constant Solid

   33

 

常量可以定义在类里,但不像实变量,它们可以在类的外部访问.

ruby> class ConstClass

    |   C1=101

    |   C2=102

    |   C3=103

    |   def show

    |     print C1," ",C2," ",C3,"/n"

    |   end

    | end

   nil

ruby> C1

ERR: (eval):1: uninitialized constant C1

ruby> ConstClass::C1

   101

ruby> ConstClass.new.show

101 102 103

   nil

 

常量也可以定义在模块里.

ruby> module ConstModule

    |   C1=101

    |   C2=102

    |   C3=103

    |   def showConstants

    |     print C1," ",C2," ",C3,"/n"

    |   end

    | end

   nil

ruby> C1

ERR: (eval):1: uninitialized constant C1

ruby> include ConstModule

   Object

ruby> C1

   101

ruby> showConstants

101 102 103

   nil

ruby> C1=99 # not really a good idea

   99

ruby> C1

   99

ruby> ConstModule::C1 # the module's constant is undisturbed ...

   101

ruby> ConstModule::C1=99 

ERR: (eval):1: compile error

(eval):1: parse error

ConstModule::C1=99

                ^

ruby> ConstModule::C1 # .. regardless of how we tamper with it.

   101

 

异常处理:

当一个方法结束工作时我们也许需要进行清理工作.也许一个打开的文件需要关闭,缓冲区的数据应清空等等.如果对于每一个方法这里永远只有一个退出点,我们可以心安理得地将我们的清理代码放在一个地方并知道它会被执行;但一个方法可能从多个地方返回,或者因为异常我们的清理代码被意外跳过.

begin
 file = open("/tmp/some_file", "w")
 # ... write to the file ...
 file.close
rescue
 file.close
 fail # raise an exception
end

 

在Ruby里,就像其它的现代语言,我们可以通过隔离的办法处理代码域里的异常,因此,这有着惊人的效果却又不会为程序员或以后希望读它的其它人造成过度的负担.代码域由begin开始直到遇到一个异常,这将导致转向一个由rescue标记的错误处理代码域.如果异常没发生,rescue代码就不会使用.下面的代码返回文本文件的第一行,如果有异常则返回 nil.

 

分享到： 

上一篇：Command模式

下一篇：(整理)RUBY的CGI访问

查看评论

5楼 youyang1991 2011-07-15 17:12发表 [回复]

so useful !!!

4楼 youyang1991 2011-07-15 14:58发表 [回复]

大谢楼主了！

3楼 Duallay 2011-06-20 13:54发表 [回复]

言简意赅，好，顶一个！

2楼 GreenLearner 2009-11-03 20:32发表 [回复]

ruby&gt; var = &quot; abc &quot;
&quot; abc &quot;
ruby&gt; &quot;1234#{var}5678&quot;
ERR:undefined local variable or method 'var' for main:Object

这个错误是什么原因啊，怎么改正这个错误呢？

1楼 GreenLearner 2009-11-03 16:08发表 [回复]

ruby&gt; var = &quot; abc &quot;
&quot; abc &quot;
ruby&gt; &quot;1234#{var}5678&quot;
ERR:undefined local variable or method 'var' for main:Object

发表评论

• 用 户 名：
• xzyxuanyuan

• 评论内容：
• 

  

* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场

个人资料

 
Last_Impression
 

• 访问：158409次
• 积分：4154分
• 排名：第1138名
• 原创：230篇
• 转载：137篇
• 译文：8篇
• 评论：22条

文章搜索

文章分类

• C#(4)
• C++(27)
• C++ STL(36)
• C++单体测试(10)
• C++设计模式（QT）(7)
• C语言(21)
• Offshore时代的统筹人(9)
• Qt(32)
• Ruby(6)
• VB语言(3)
• VC++多线程应用(6)
• Windows程序设计(28)
• YACC(14)
• 外语(1)
• 孙鑫VC++(7)
• 数据库系统概论(12)
• 数据结构(19)
• 测试&amp;&amp;品质(23)
• 系统分析师-论文(4)
• 职场我见(17)
• 设计模式(5)
• 重构(3)
• 项目管理(5)
• 嵌入式(31)
• 大话设计模式(23)
• 人件(14)
• 人月神话(2)

文章存档

2013年05月(2)
2013年04月(2)
2013年03月(6)
2013年02月(1)
2013年01月(7)
展开

阅读排行

• (转)国企，私企与外企利弊通观--关键时刻给应届毕业生及时点拨(9965)
• (转)国企，私企与外企利弊通观--关键时刻给应届毕业生及时点拨5(4899)
• (转) 5.3把自定义控件集成到Qt Designer中(Integrating Custom Widgets with Qt Designer)(2116)
• (转)日元汇率下跌与中国工资上涨 -- 苦于效益减少35%的中国企业(对日外包)(1987)
• (转)R语言入门(1973)
• 第2章 关系数据库(数据库系统概论)(1799)
• (转)4.2从QTableWidget继承（Subclassing QTableWidget）(1795)
• 软件质量管理(1769)
• (转)移植32位程序64位系统(1709)
• 人件--读书笔记5(1580)

评论排行

• (整理)Ruby的基础知识(5)
• 数据结构之冒泡排序(2)
• (转)char，wchar_t,TCHAR 3者的区别与联系(2)
• (转)QT事件机制(2)
• 泛型算法系列15:transform()(1)
• 泛型算法系列19:remove_if()&&remove_copy_if()(1)
• 软件测试管理和测试流程(1)
• 数据结构之快速排序(1)
• ITRON的任务管理(1)
• 复习四:C的OOP-多层继承(1)

推荐文章

最新评论

• 数据结构之冒泡排序

  zwbrs555: 好不赖，多谢

• 第七章 鼠标part2

  coding_my_life: 谢谢分享！请问这样的代码是怎么贴上去的啊？

• ITRON的任务管理

  qiaohao666666: 果断关注了~

• 泛型算法系列19:remove_if()&&remove_copy_if()

  sunmofeng: 能给我讲下remove_copy_if泛型算法吗？不懂

• (整理)Ruby的基础知识

  youyang1991: so useful !!!

• (整理)Ruby的基础知识

  youyang1991: 大谢楼主了！

• (整理)Ruby的基础知识

  Duallay: 言简意赅，好，顶一个！

• (转)QT事件机制

  也许飞:

• 泛型算法系列15:transform()

  mmd7437: 您好，请问 _DEBUG_RANGE(_First1, _Last1); _DEBU...

• (转)char，wchar_t,TCHAR 3者的区别与联系

  牛肉圆粉不加葱:

公司简介|招贤纳士|广告服务|银行汇款帐号|联系方式|版权声明|法律顾问|问题报告

QQ客服 微博客服 论坛反馈 联系邮箱：[e-mail] 服务热线：400-600-2320

京 ICP 证 070598 号

北京创新乐知信息技术有限公司 版权所有

世纪乐知(北京)网络技术有限公司 提供技术支持

江苏乐知网络技术有限公司 提供商务支持

Copyright © 1999-2012, CSDN.NET, All Rights Reserved