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

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

千月星跡

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

目录视图
摘要视图
订阅

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

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

ruby class include c math object

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

串联: ru by

>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]

ary[0,2]

[1, 2]

ary[0..1]

[1, 2]

ary[-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]

h["2"]

"4"

h[5]

nil

h[5] = 10     # appending value

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

h.delete 1   # deleting value

h[1]

nil

{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}

可以用 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"

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)

我们的新方法看起来不属于任何类,但实际上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

nil

ruby> test2.size

在这个例子里, 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

ruby> $foo

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

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

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

nil

ruby> $x = 5

$x is now 5

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

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

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

ruby> i

   #<InstTest:0x83678 @foo=2>

ruby> i.set_bar(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

   "local-variable"

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

nil

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

ruby> bar=0

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

   #<Proc:0x8deb0>

ruby> p2 = proc{bar}

   #<Proc:0x8dce8>

ruby> p1.call(5)

ruby> bar

ruby> p2.call

注意开始的 " 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

ruby> writer.call(2)

ruby> reader.call

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

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)

ruby> reader_1.call

ruby> reader_2.call

类常量

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

ruby>fluid=30

ruby>fluid=31

ruby>Solid=32

ruby>Solid=33

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

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

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

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

ruby> showConstants

101 102 103

nil

ruby> C1=99 # not really a good idea

ruby> C1

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

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.

异常处理:

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

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.

分享到：

查看评论

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> var = " abc "
" abc "
ruby> "1234#{var}5678"
ERR:undefined local variable or method 'var' for main:Object

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

1楼 GreenLearner 2009-11-03 16:08发表 [回复]: ruby> var = " abc "
" abc "
ruby> "1234#{var}5678"
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)
测试&&品质(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客服微博客服论坛反馈联系邮箱：webmaster@csdn.net 服务热线：400-600-2320

京 ICP 证 070598 号

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

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

(整理)Ruby的基础知识相关推荐

初一计算机基础知识试题及答案,【2017年整理】计算机基础知识试题及答案.doc...
[2017年整理]计算机基础知识试题及答案 (一)单选题(40)1．在资源管理器窗口中,被选中的文件或文件夹会____B___.A．加框显示 B．反像显示C．加亮显示 D．闪烁显示2．在Windows ...
html语言需要dw吗,HTML笔记整理1 -- HTML基础知识与DW简单使用
HTML笔记整理1 -- HTML基础知识与DW简单使用概念客户端和服务器端文件名.基本名.扩展名资源文件和站点什么是HTML关于W3CW3C的规范网站与网页基本概念网页的制作网页的基本框架通过记事本 ...
dw边框弧度设置_笔记整理1 -- HTML基础知识与DW简单使用
笔记整理1 -- HTML基础知识与DW简单使用笔记整理1 -- HTML基础知识与DW简单使用概念客户端和服务器端文件名.基本名.扩展名资源文件和站点什么是HTML 关于W3C W3C的 ...
阿里深资架构师整理的Java 基础知识小抄赶紧收藏
本篇算是 Java 的基础知识小抄吧,之所以说小抄是因为觉得涵盖不是很细很全,但是基本的内容都有,当然后头还会继续完善,只是不会再用笔记录了!按照现在的习惯,先附上一张思维导图: 1. 安装与环境配置 ...
终于有华为高工整理网工基础知识完整版，看完就入门
前言网络工程师是通过学习和训练,掌握网络技术的理论知识和操作技能的网络技术人员.根据招聘网站最新一年数据统计,网络工程师月平均工资可以达到12.3K,而2021年较2020年增长了18%. 网络工程 ...
java中计算机基础知识_整理一些计算机基础知识！
为了使不同计算机厂家生产的计算机能够相互通信,以便在更大的范围内建立计算机网络,国际标准化组织(ISO)在1978年提出了"开放系统互联参考模型",即著名的OSI/RM模型(Ope ...
hrrn算法java_整理一些计算机基础知识！(不定期更新)
1.网络层次划分为了使不同计算机厂家生产的计算机能够相互通信,以便在更大的范围内建立计算机网络,国际标准化组织(ISO)在1978年提出了"开放系统互联参考模型",即著名的OSI ...
整理一些计算机基础知识！ 1
本文来自云栖社区官方钉群"Python技术进阶",了解相关信息可以关注"Python技术进阶". 1.网络层次划分为了使不同计算机厂家生产的计算机能够相互通信 ...
呕心沥血整理的python基础知识与练习题【你值得拥有！！！！】
一.基础语法 1.输入与输出(hellw word) # 国际化输出 print("hello word") print("word",end=" & ...

(整理)Ruby的基础知识

更多

千月星跡

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

(整理)Ruby的基础知识相关推荐

最新文章

热门文章