- 浏览: 242352 次
- 性别:
- 来自: ph
文章分类
最新评论
-
zrj_software:
说了等于没说,LZ能否把DLL代码给我研究下啊30729375 ...
如何在Delphi中调用.Net编写的DLL中的函数 -
reyesyang:
正在查找ruby单例模式相关资料,很有帮助,谢谢。
ruby中的单例模式 -
chaochao_pc:
您好,您的通讯工具能传输文件吗? 我在上边好像没找到!!! ...
Silverlight Socket 实现收发信息 -
huaxia524151:
谢谢,解决问题。return self.name.encode ...
Django笔记5(管理站点) -
yahon:
在flash中如何获取呢?
Flash+html--网页向FLASH传递参数
1、$variable 代表全局变量, @variable代表成员变量,@@variable代表类静态变量
2、双引号内解析表达式,"... #{expression}",对于全局标量或成员变量,花括号可省略
3、局部变量、成员方法参数、成员方法的命名约定都以小写字母或下划线开头
类名称、模块名称、常量的命名约定都以大写字母开头
一般多词组成的成员变量用下划线分割,如@test_int
一般多词组成的类名采用骆驼形式,如TestInt
4、nil的含义是null,但不同于其他语言,在ruby里nil同样是一个对象,只不过代表了nothing的含义
5、%w{word1 word2 word3 ...} 等同于['word1','word2','word3',...]
6、Hash.new({default_value}) 产生一个缺省值为default_value的hash对象,默认缺省值为nil
7、对于单执行语句的条件/循环语句,可以简化成后置形式,如
test = test + 1 if test > 10
或 test = test + 1 while test < 10
8、正则表达式判断,{subject} =~ /pattern/ ,也可以是/pattern/ =~ {subject},返回值是匹配的位置,或者nil(无匹配)
除了返回匹配结果外,还会修改全局变量$&、$`、$'、$~、$1、...、$9
$&表示匹配的字符串部分,$`表示匹配之前的部分,$'表示匹配之后的部分
$~将包含匹配相关的所有信息,$1到$9表示部分匹配的内容
字符串正则表达式替换,采用成员方法sub和gsub(替换全部),两者的使用方法有两种:
- [g]sub(/pattern/,'somestr') 用字符串somestr去替换匹配指定pattern的部分(需要注意的是somestr会先被正则表达式引擎处理)
- [g]sub(/pattern/) {|str| block} 对于匹配pattern的部分,调用对应代码块并用代码块返回的部分取代之(匹配部分会传递给代码块)
在部分匹配并替换的字符串表达里,可以用\1、\2、...代表前面匹配的部分,还可以用\&代表最近的一次匹配、\+代表最近的一次部分匹配、
\`代表匹配之前的字符串、\'代表匹配之后的字符串;另外需要注意的是,替换字符串本身会被正则表达式引擎处理,因此需要用\\\\代表一个反斜杠符\
{subject} !~ /pattern/ ,判断是否不满足某个pattern
9、代码块(Code Block),有两种表达形式{ ... } 和 do ... end,前者优先级更高,一般考虑单行用前者,多行用后者
代码块可以传递给特定函数,特定函数里用yield关键词来调用代码块,见下例
def call_block
puts "Start of method"
yield
yield
puts "End of method"
end
call_block { puts "In the block" }
将输出如下:
Start of method
In the block
In the block
End of method
代码块可以定义参数,如{|param1,param2| ... },然后在调用函数里使用yield(参数1,参数2) 来传递参数并调用代码块
10、puts输出自动换行,print输出不换行
11、类继承 class <SomeClass> < BaseClass
构造函数 initialize
父类调用super(...),与其他语言不同的是,super可以出现在构造函数以外的函数里,效果是调用父类的同名函数(用同样的参数)
属性访问声明attr_reader、attr_writer ,用ruby特有的记号(symbol,形如:some_attr)作为参数,用来声明可访问的属性
属性设置方法名称采用 def <属性名>=(参数值) 的形式
12、类方法,相当于类静态方法,定义形式为def <类名>.<方法名>(...) 或 def self.<方法名>(...)
还有种定义形式 class << self
def <方法名>(...)
end
end
13、Object成员函数dup,相当于clone
Object成员函数freeze,调用后将变为只读特性,即无法修改,如果发生修改将产生TypeError异常
14、array访问采用array[index]的方式,如果index为负数,则代表从尾部倒过来访问,array[-1]即最后一个元素
访问子数组,array[index,count] 返回一个新的子数组
还可以用array[start..end] 获取[start,end]范围的子数组,以及array[start...end] 获取[start,end)的子数组(注意:将不包含第end项)
[index]= 可以用来替换指定位置的元素
[index,count]= 可以用来替换指定范围的元素或者插入元素
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..6] = 99, 98 ! ["dog", "cat", 9, nil, nil, 99, 98]
15、并行赋值 i1, i2 = 1, 1 相当于 i1= 1 i2= 1
16、具备Enumerable特性的容器(如数组),具有下列轮询函数
.each {|element| ...} 对每个元素执行代码块
.collect {|element| ...} 对每个元素执行代码块,并用返回值组成一个新的容器返回
.inject(initial)
{|something,element| ...}
something用initial作为初值,并对每个元素执行代码块,最后返回something;如果调用的时候没有个包含
initial,something的初值设为第一个元素
17、参数透明传递 *args,如def func(*args),即无论实际调用时传递了几个参数,都包含进args数组;函数内可以再使用anotherfunc(*args) 透明的把参数传递给另一个函数
同时,在实际传递参数时,如果是func(a,b,*array_of_params)的形式,数组array_of_params将被展开,即其中的元素被一个个传递进函数,例如:
def five(a, b, c, d, e)
"I was passed #{a} #{b} #{c} #{d} #{e}"
end
five(1, 2, 3, 4, 5 ) ==> "I was passed 1 2 3 4 5"
five(1, 2, 3, *['a', 'b']) ==> "I was passed 1 2 3 a b"
five(*(10..14).to_a) ==> "I was passed 10 11 12 13 14"
18、File.open函数会根据是否传递有代码块,执行不同的逻辑
如果有代码块,那么先打开文件,以文件句柄为参数执行代码块,最后关闭文件,返回值为代码块的执行结果
如果没有代码块,那么就打开文件并返回文件句柄
通过Kernel.block_given? 方法可以检测是否在调用时传递了代码块
19、如果传递参数时最后一个参数前面加了&符号,该参数将作为代码块处理,并可以默认转型为Proc类型并赋值给其他变量
赋值给变量后,该变量(类型为Proc)可以调用call方法实现对代码块的调用,例如
songlist = SongList.new
class JukeboxButton < Button
def initialize(label, &action)
super(label)
@action = action
end
def button_pressed
@action.call(self)
end
end
start_button = JukeboxButton.new("Start") { songlist.start }
pause_button = JukeboxButton.new("Pause") { songlist.pause }
20、Proc(代码块)的闭包特性
通过lamda方法创建的代码块具备闭包特性,即保留到全局空间路径上已申明的变量集(包括self),例如:
def n_times(thing)
return lambda {|n| thing * n }
end
p1 = n_times(23)
p1.call(3) ! 69
p1.call(4) ! 92
p2 = n_times("Hello ")
p2.call(3) ! "Hello Hello Hello "
21、?代表取字符编码,如
?a => 97 # ASCII character
?\n => 10 # code for a newline (0x0a)
?\Ca => 1 # control a = ?A & 0x9f = 0x01
?\Ma => 225 # meta sets bit 7
?\M\Ca => 129 # meta and control a
?\C? => 127 # delete character
?\\ => 92 #\ character
22、字符串表达式。除了单引号、双引号以外,还可以用%q、%Q的形式
%q与单引号雷同,形如%q/test abcd/ <==> 'test abcd'
%Q与双引号雷同,形如%Q{Second/day: #{24*60*60}} <==> "Second/day: #{24*60*60}" <==> "Second/day: 86400"
%q、%Q后面的分隔符除接受[]、{}、()、<>对之外,接受相同的分隔符,如||,//,!!
除此之外,ruby还接受如下的结构构成字符串
string = <<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
23、Range. 即形如0..20、'a'..'z'、0...10000
ruby用Range对象来表示range,即只会保存range的上下范围
range的成员方法to_a 可以将Range转化成一个新的数组
自定义的类型如果要支持Range,需要实现一系列函数,举例如下:
class VU
include Comparable
attr :volume
def initialize(volume) # 0..9
@volume = volume
end
def inspect
'#' * @volume
end
# Support for ranges
def <=>(other)
self.volume <=> other.volume
end
def succ
raise(IndexError, "Volume too big") if @volume >= 9
VU.new(@volume.succ)
end
end
medium_volume = VU.new(4)..VU.new(7)
medium_volume.to_a ==〉 [####, #####, ######, #######]
medium_volume.include?(VU.new(3)) ==〉 false
Range还可以用来测试某个变量是否落在范围之内,采用=== ,例如:
(1..10) === 5 ==〉 true
(1..10) === 15 ==〉 false
(1..10) === 3.14159 ==〉 true
('a'..'j') === 'c' ==〉 true
('a'..'j') === 'z' ==〉 false
24、方法中传递hash,只要该hash位于常规参数之后,和array格式及代码块参数之前的,可以省略hash的{}号
25、成员方法重定义,例如:
class Fixnum
alias old_plus +
# Redefine addition of Fixnums. This
# is a BAD IDEA!
def +(other)
old_plus(other).succ
end
end
1 + 2 ==> 4
a = 3
a += 4 ==> 8
a + a + a ==> 26
27、和unix shell类似,可以用`command ...` 来执行命令并用返回值作为替代的字符串,同时也接受%x的形式,如%x{ls}、%x[dir]等
28、并行赋值,支持*号数组扩展,例如:
a = [1, 2, 3, 4]
b, c = a ==> b == 1, c == 2
b, *c = a ==> b == 1, c == [2, 3, 4]
b, c = 99, a ==> b == 99, c == [1, 2, 3, 4]
b, *c = 99, a ==> b == 99, c == [[1, 2, 3, 4]]
b, c = 99, *a ==> b == 99, c == 1
b, *c = 99, *a ==> b == 99, c == [1, 2, 3, 4]
并行赋值还有一个级联拓展的特性,例如:
b, (c, d), e = 1,2,3,4 ==> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = [1,2,3,4] ==> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = 1,[2,3],4 ==> b == 1, c == 2, d == 3, e == 4
b, (c, d), e = 1,[2,3,4],5 ==> b == 1, c == 2, d == 3, e == 5
b, (c,*d), e = 1,[2,3,4],5 ==> b == 1, c == 2, d == [3, 4], e == 5
29、defined? <expression> 如果表达式已定义,则返回表达式的特性;否则返回nil;如果expression是yield,且当前上下文里定义有代码块则返回"yield",否则返回nil。其他的例子如:
defined? 1 ==> "expression"
defined? dummy ==> nil
defined? printf ==> "method"
defined? String ==> "constant"
defined? $_ ==> "globalvariable"
defined? Math::PI ==> "constant"
defined? a = 1 ==> "assignment"
defined? 42.abs ==> "method"
30、and、&& 、or、||返回决定最后值的那个子表达式的值,例如:
nil and true ==> nil
false and true ==> false
99 and false ==> false
99 and nil ==> nil
99 and "cat" ==> "cat"
false or nil ==> nil
nil or false ==> false
99 or false ==> 99
因此 <var> ||= <val>,即<var> = <var> || <val>,也就是说当var为false或nil时,将var赋值为val
31、case 语句,如下:
case <target>
when <comparison> [then|:] <operation>
when <comparison> [then|:] <operation>
else <operation>
end
判断时调用 <comparison> === <target>
=== 符号不同于==,随着调用对象的不同有着不同的意义,如Range.=== obj 判断obj是否在range的范围内,Class.=== obj判断obj是否属某个class类型,RegExp.=== obj判断字符串是否匹配正则表达式,等等
32、for <element> in <container> ... 相当于<container>.each {|element| ...}
33、redo 表再次执行循环体(但不进行判断)
retry则彻底重新执行循环
注:retry还能彻底重新执行方法调用,如:
def do_until(cond)
break if cond
yield
retry
end
i = 0
do_until(i > 10) do
print i, " "
i += 1
end
produces:
0 1 2 3 4 5 6 7 8 9 10
34、loop do .. end 相当于c语言里的for(;;){..},需要用break、redo、next等进行逻辑编排和安排跳出
35、break可以提供参数,代表循环的返回值;若没有提供参数,则代表返回nil
36、代码块本身内部变量的生命期仅限于代码块内部,但如果在代码块到全局空间的上下文路径上已存在某个变量名称(哪怕变量是nil或者没有真正执行到过),而这个变量名称被用在了代码块里,那么代码块将使用这个变量,即即使代码块结束该变量的值仍然有效。例如:
x = nil
y = nil
[ 1, 2, 3 ].each do |x|
y = x + 1
end
[ x, y ] ==> [3, 4]
37、begin ... rescue [<ErrorType> [ => <exception_var> ] ] ... [raise] [else ...][ensure ...] end ruby的异常处理流程
else部分是当没有异常发生时执行的代码
ensure相当于c++的__finally
rescue里的代码可以包含retry,表示重新执行begin后面的代码,例如:
@esmtp = true
begin
# First try an extended login. If it fails because the
# server doesn't support it, fall back to a normal login
if @esmtp then
@command.ehlo(helodom)
else
@command.helo(helodom)
end
rescue ProtocolError
if @esmtp then
@esmtp = false
retry
else
raise
end
end
38、抛出异常的几个形式:
raise ==> 抛出当前异常,或者一个RuntimeError
raise "bad mp3 encoding" ==> 抛出一个RuntimeError,并将其成员message置为"bad mp3 encoding"
raise
InterfaceException, "Keyboard failure", caller ==>
抛出一个InterfaceException异常,将其成员message设为"Keyboard
failure",以及调用堆栈变量设为Kernel.caller
39、catch .. throw的用法
catch [:symbol|"string"] do
...
...
throw [:symbol|"string"] [,result]
end
当通过throw抛出标志或字符串,且该标志或字符串与catch语句里的标志/字符串时,整个catch块执行结束。如果throw提供了第二个参数(即result),result将作为整个catch块的返回值。例如:
def prompt_and_get(prompt)
print prompt
res = readline.chomp
throw :quit_requested if res == "!"
res
end
catch :quit_requested do
name = prompt_and_get("Name: ")
age = prompt_and_get("Age: ")
sex = prompt_and_get("Sex: ")
# ..
# process information
end
40、模块的Mixin特性,在调用成员方法时,搜索顺序是类自身=〉最近include的module=〉最远include的module=〉父类(继续递归,直到Object)
模块中定义的变量不会"传递"进加载该模块的代码上下文,只有函数会"传递"。例如:
a = "cat"
b = "dog"
require 'included'
a ==> "cat"
b ==> "dog"
b() ==> 2
41、load/require的区别
load会无视是否已经加载模块而去加载,require只会加载模块一次
require还可以加载二进制模块,而且属于动态执行
load只是静态执行,且只能加载文本模块
全局变量 $" 代表了通过require加载的模块集合
42、加载路径是可以动态修改的:通过全局变量$:
43、Ruby自身的线程机制并没有利用操作系统的线程服务,因此在并发处理上比较薄弱
Thread.new(param1,param2,...) {|param1,param2,...|} 创建一个Ruby线程。
需要注意的是,Ruby线程之间共享全局变量、以及从全局空间到线程代码块的上下文路径上的所有变量。因此,上述param1、param2可能会在实际执行线程之前被主线程修改(因此,考虑利用dup和freeze成员方法)
ruby线程代码块里的局部变量不会被其他ruby线程共享
还有在主ruby线程退出时,会自动删除其他ruby线程(可能会造成问题),建议在主线程里使用Thread的join方法确保结束前其他子线程都已结束
Thread的value方法可以返回该线程执行的最后一个语句的返回值
Thread.current静态方法返回当前线程
Thread.list静态方法返回当前活动的线程列表
设置线程局部变量的方法:<threadref>[<varname>]= ... <threadref>[<varname>]
44、线程的异常处理
如果Thread.abort_on_exception 静态变量为false,且ruby解释器的debug开关为关闭状态,线程产生的异常会导致线程结束,且该异常只有在调用join方法时可以捕获。例如:
threads = []
4.times do |number|
threads << Thread.new(number) do |i|
raise "Boom!" if i == 2
print "#{i}\n"
end
end
threads.each do |t|
begin
t.join
rescue RuntimeError => e
puts "Failed: #{e.message}"
end
end
produces:
0
1
3
Failed: Boom!
如果Thread.abort_on_exception 静态变量为true,或ruby解释器的debug开关为打开状态,线程产生的异常会导致所有线程终止。例如:
Thread.abort_on_exception = true
threads = []
4.times do |number|
threads << Thread.new(number) do |i|
raise "Boom!" if i == 2
print "#{i}\n"
end
end
threads.each {|t| t.join }
produces:
0
1
prog.rb:5: Boom! (RuntimeError)
from prog.rb:4:in `initialize'
from prog.rb:4:in `new'
from prog.rb:4
from prog.rb:3:in `times'
from prog.rb:3
44、Monitor可以用来解决多Ruby线程访问同一个变量的互斥问题,形式有几种:
- 继承Monitor类
- mixin进MonitorMixin
- 产生一个Monitor对象,调用对象的synchronize方法并传递进一个代码块
在互斥代码块里如果需要临时放弃访问锁,需要先获取互斥对象的条件访问变量(通过new_cond),再调用条件访问变量的wait_while (传递进一个代码块来测试条件)
45、hash可以使用任意类型对象作为key,但需要注意对象的值发生改变时(或者对象是数组时数组的元素发生改变)对象的hash值会发生改变,那么hash可能会发生索引失效的问题。解决方法是调用rehash方法。例如:
arr = [1, 2]
hash = { arr => "value" }
hash[arr] =====〉 "value"
arr[0] = 99
hash[arr] =====〉 nil
hash.rehash =====〉 {[99, 2]=>"value"}
hash[arr] =====〉 "value"
46、调优方法:
- benchmark
- profiling 。通过命令行定义-r profile或者文件里require 'profile'
47、ruby源文件里可以定义若干个begin{...} end{...},这些块分别在加载和卸载这些文件时调用
48、如果@@变量定义在全局范围,相当于定义了一个类Object的静态变量,在作用上相当于一个全局变量
49、代码块内执行return [value] 的效果相当于跳出代码块并在定义代码块的上下文(即某个方法)里执行return [value];如果该上下文已不复存在(方法执行完毕),将产生LocalJumpError或ThreadError异常。例如:
def meth1
(1..10).each do |val|
return val # returns from method
end
end
meth1 ===〉 1
===========================
def meth2(&b)
b
end
res = meth2 { return }
res.call
produces:
prog.rb:5: unexpected return (LocalJumpError)
from prog.rb:5:in `call'
from prog.rb:6
============================
def meth3
yield
end
t = Thread.new do
meth3 { return }
end
t.join
produces:
prog.rb:6: return can't jump across threads (ThreadError)
from prog.rb:9:in `join'
from prog.rb:9
注:因为代码块定义在全局空间(即主线程),但执行return的线程是副线程;因此产生了线程跳跃异常
使用Proc.new产生的Proc对象表现与代码块相当,例如:
def meth4
p = Proc.new { return 99 }
p.call
puts "Never get here"
end
meth4 ==〉 99
而用lamda或者proc产生的对象则不同,return仅仅是从代码块返回,对上下文没有影响
def meth5
p = lambda { return 99 }
res = p.call
"The block returned #{res}"
end
meth5 ==〉 "The block returned 99"
50、<obj>.respond_to? (<symbol>) 检查对象是否支持某个方法调用,如
obj.respond_to? (:to_int)
obj.respond_to?(:<<)
51、实现coerce(<other_obj>)方法可以实现double dispatch模式,即根据other_obj的类型进行动态操作符重载
coerce方法返回的是一个具有两个元素的数组,数组里第一个元素是other_obj对某个类型的转化,第二个元素是自身对某个类型的转化。例如:
class Roman
def initialize(value)
@value = value
end
def coerce(other)
if Integer === other
[ other, @value ]
else
[ Float(other), Float(@value) ]
end
end
# .. other Roman stuff
end
iv = Roman.new(4)
xi = Roman.new(11)
3 * iv ===〉 12
1.1 * xi ===〉 12.1
注:coerce是针对对象作为操作符重载函数的参数时起作用的,即上述 3 +-*/ Roman的情况,如果是Roman +-*/ 3并不适用
52、定义一个与某个对象绑定的class,相当于以对象为单位扩展功能。
class << <object>
...
end
相当于
def <object>.<method1>
...
end
def <object>.<method2>
...
end
Object类的extend方法相当于定义了一个(Mod) is basically equivalent to
class <<obj
include Mod
end
如果是在class里使用extend,相当于动态添加模块里的方法作为类静态方法,例如:
module Humor
def tickle
"hee, hee!"
end
end
class Grouchy
extend Humor
end
Grouchy.tickle ==〉 "hee, hee!"
53、在Ruby运行时中,任何类型本身在全局空间中都有一个同名常量,值是类型为Class的类对象(描述了这个类型)
比如String,全局空间里有常量String,值是类型为Class描述String类的对象
def factory(klass, *args)
klass.new(*args)
end
factory(String, "Hello") ==〉 "Hello"
factory(Dir, ".") ==〉 #<Dir:0x1c90e4>
flag = true
(flag ? Array : Hash)[1, 2, 3, 4] ==〉 [1, 2, 3, 4]
flag = false
(flag ? Array : Hash)[1, 2, 3, 4] ==〉 {1=>2, 3=>4}
另外,如果一个类型为Class的类对象还没有名字(name属性为空),且被赋值给一个常量的,那么该常量的名字就作为这个类的名称。例如:
var = Class.new
var.name
==〉 ""
Wibble = var
var.name
==〉 "Wibble"
54、运行环境其实是在一个类型为Object的对象内部,全局空间相当于对象的私有域(private:),比如定义一个全局方法其实是定义在了运行时对象的私有域(相当于private: def ...)
55、dup和clone的区别
clone复制对象的所有东西,包括frozen状态 - 复制出的产物保持和原对象一样的frozen状态
dup则不复制frozen状态 - 复制出的产物不frozen
str1 = "hello"
str1.freeze ==> "hello"
str1.frozen? ==> true
str2 = str1.clone
str2.frozen? ==> true
str3 = str1.dup
str3.frozen? ==> false
55、序列化时,一般对象可以直接利用Marshal.dump和Marshal.load去自动完成
如果要自己完成序列化过程的`,对象需要定义marshal_dump和marshal_load成员方法。marshal_dump返回一个可自动序列化的对象(该对象被自动序列化);marshal_load获得一个自动反序列化出来的对象,并通过它完成反序列化
class Special
def initialize(valuable, volatile, precious)
@valuable = valuable
@volatile = volatile
@precious = precious
end
def marshal_dump
[ @valuable, @precious ]
end
def marshal_load(variables)
@valuable = variables[0]
@precious = variables[1]
@volatile = "unknown"
end
def to_s
"#@valuable #@volatile #@precious"
end
end
obj = Special.new("Hello", "there", "World")
puts "Before: obj = #{obj}"
data = Marshal.dump(obj)
obj = Marshal.load(data)
puts "After: obj = #{obj}"
produces:
Before: obj = Hello there World
After: obj = Hello unknown World
56、YAML库可以用来将对象序列化为YAML格式,对象需要定义一个to_yaml_properties方法(返回需要序列化的属性名数组)
评论
1 楼
fireflyman
2009-08-06
1.Ruby基礎觀點-->Ruby中幾乎所有都是對象;
2.備注:#
3.語句行:
(1)每個語句以;號隔開
(2)一行一條語句
4.縮進處理:對于代碼編輯的縮進沒有要求,但是最好能達到2個字符的縮進
5.方法定義
def 方法名(參數1,參數2...)
//語句行...
//return...
end
其中()為可選擇項目
6.方法呼叫
方法名(參數1,參數2...)
如果只有一個參數,則可以這樣呼叫:方法名 參數1
7.字符串連接符號:+
8.回車換行符號:\n
9.Express Interpolation:雙引號括起來的字符串
10.Express定義:${...}
11.變量
全局變量:$打頭
實例變量:@打頭
類變量:@@打頭
12.類名,模板名,常量名必須首字母大寫
13.nil:無對象
14.數組定義:[數值1,數字2,]
15.Hash表:
a={
'key1'=>value1,
'key2'=>value2,
#...
}
a['key1']
2.備注:#
3.語句行:
(1)每個語句以;號隔開
(2)一行一條語句
4.縮進處理:對于代碼編輯的縮進沒有要求,但是最好能達到2個字符的縮進
5.方法定義
def 方法名(參數1,參數2...)
//語句行...
//return...
end
其中()為可選擇項目
6.方法呼叫
方法名(參數1,參數2...)
如果只有一個參數,則可以這樣呼叫:方法名 參數1
7.字符串連接符號:+
8.回車換行符號:\n
9.Express Interpolation:雙引號括起來的字符串
10.Express定義:${...}
11.變量
全局變量:$打頭
實例變量:@打頭
類變量:@@打頭
12.類名,模板名,常量名必須首字母大寫
13.nil:無對象
14.數組定義:[數值1,數字2,]
15.Hash表:
a={
'key1'=>value1,
'key2'=>value2,
#...
}
a['key1']
发表评论
-
ruby 连接操作 sql2005
2010-05-24 09:38 1084The following is improved versi ... -
使用Ruby DBI模块
2009-08-18 12:29 1511使用Ruby DBI模块 ... -
Symbol对象
2009-08-07 10:19 765Symbol 对象用于表现 Ruby 解释器内的名字或 ... -
ruby中的单例模式
2009-08-05 16:00 1580Singleton 模块实现了单态模式 (Singleto ... -
ruby中的观察者模式
2009-08-05 15:56 956require 'observer' class TV ... -
区别Ruby的require,load,和include
2009-08-05 15:49 932三者之间区别并不像你想的那么难,也不会像有些文章写的那么长。挺 ... -
Object and Reflection
2009-08-05 15:34 717摘自: http://anw.stikipad.com/oc ... -
Blocks, Closures and Proc Objects
2009-08-05 15:18 749Ruby 的 block 是個不錯的設計. 一個 block ... -
Enumerable模块
2009-08-05 14:59 803可枚举模块。 Enumerable mixin 是含有几 ... -
Comparable模块
2009-08-05 12:20 1018Comparable mixin 由希望对它的对象进行排序的 ... -
Proc过程对象
2009-08-05 12:04 873就是所谓的过程对象。 Proc 对象是将一组局部变量绑定到 ... -
Method对象
2009-08-05 11:36 952Method 对象是由 Object#method(: ... -
Struct对象
2009-08-04 17:50 934结构体类 Struct 是将许多属性 (atribute ... -
Range对象
2009-08-04 16:29 927Range 对象表现为一个间隔,有开始与结束的值集。 Ra ... -
ruby惯用法
2009-08-04 15:27 839Ruby有不少惯用法,这里略作一些介绍,也方便阅读他人代码: ... -
Ruby哈希表
2009-08-04 14:51 2123哈希表的建立: ... -
Ruby中的数组过滤
2009-08-04 12:19 1071数组可以算是计算机编程中用到的最多的一个数据结构了,ruby中 ... -
Ruby数组操作总结
2009-08-04 11:50 3577数组的创建 arr = Array.new num #创 ...
相关推荐
Ruby学习笔记 01 类的属性与方法 02 访问控制 03 Container(Array/Hash) 04 Iterator 05 简单数据类型 06 范围 07 方法 08 条件控制 09 异常处理
Ruby是一种面向对象的脚本语言,它以其简洁、优雅的语法和强大的功能而闻名。...通过安装Ruby和DevKit,你可以轻松地编写、编译和运行Ruby代码,同时结合学习笔记,可以深入理解Ruby语言及其生态系统。
ruby基础笔记,自学笔记,ruby基础语法非常全面ruby基础笔记,自学笔记,ruby基础语法非常全面
学习 Ruby 的旅程即将开始! Ruby 是一种功能强大、灵活的编程语言,广泛应用于 Web 开发、脚本编写和系统管理等领域。下面是学习 Ruby 的一些实用建议:首先,了解 Ruby 的基本概念和语法。 Ruby 是一种面向对象的...
从给定的文件信息中,我们可以提炼出一系列关于Ruby编程语言的重要知识点,涵盖基础语法、变量类型、...以上总结了Ruby的一些基础知识点,这些内容对于初学者掌握Ruby编程语言至关重要,同时也是进一步深入学习的基石。
这个笔记里包含了ruby的整型,字符串,浮点数,布尔等基础数据类型,还有数组,哈希hash的用法, 类的定义,函数方法,以及对象定义,其他高级用法解释,除了笔记记录的语法糖之外,还包含了一些解释性的代码,帮助...
学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及Demo源码.zip学习Ruby的笔记以及...
Ruby 学习笔记 1、简介 定义:一种简单快捷的面向对象脚本语言 开发者:松本行弘 开发时间:1995年 设计目的:A PROGRAMMER'S BEST FRIEND【程序员的最佳朋友】 文件扩展名:rb 2、语言特性 真正的面向对象编程语言 ...
笔记: Ruby会默认返回方法中的最后一个值。 如果需要返回多个值,可以用数组来实现。 可以通过强制声明return来返回值。 基础的输出方法是用puts(输出一行),print(直接打印)。 基础的输入方法是gets(读入一行,...
ruby语言跟c#的一些重要差别在于: 1.ruby是动态语言,c#是静态语言–即对象在new出来以后,ruby还可以动态... …其它地方,等学习深入了再写出来 最后上一段测试代码,展示了ruby中类的基本用法: 代码如下: class Peop
这篇学习笔记将详细介绍 `gem` 命令及其相关工具,如 RVM (Ruby Version Manager) 的使用。 首先,我们通过 `ruby -v` 命令来查看当前系统中安装的 Ruby 版本。这有助于确保我们正在使用的是正确的版本。如果需要...
单从技术而言,ruby本身确实很爽,令程序员的工作变得轻松有趣! 下面的代码演示了如何找出100以内的素数: 代码如下: using System; namespace Mersenne { class Program { static void Main(string[] args) { for ...
标题中的"ruby笔记1ruby笔记1ruby笔记1"暗示了这是一份关于Ruby编程语言的学习笔记,可能包含了作者在学习过程中的重点、难点以及心得体验。描述中的内容重复了标题,进一步强调了这是关于Ruby的深入学习记录。标签...
本资源“学习 Ruby 的笔记以及 Demo.zip”显然包含了关于Ruby编程的学习资料和一些实际示例代码,旨在帮助初学者理解并掌握Ruby的基础及进阶特性。 首先,让我们深入了解一下Ruby的核心特性: 1. 面向对象:Ruby是...
Ruby是一种纯粹的面向对象编程语言。它由日本的松本行弘(まつもとゆきひろ/Yukihiro Matsumoto)创建于1993年。 您可以在 www.ruby-lang.org 的 Ruby 邮件列表上找到松本行弘(まつもとゆきひろ/Yukihiro ...
以上是Ruby自学笔记中提及的关键知识点的详细解读,如果要学好Ruby语言,深入理解这些基础知识是非常必要的。Ruby语言的这些特性与规则构成了其独特的编程范式,使得它在动态语言领域中占有一席之地。