Ruby初学

资料

人工智能 vscode搭建ruby IDE（mac os）

命令行选项

# -*- coding: UTF-8 -*-

选项	描述
-a	与 -n 或 -p 一起使用时，可以打开自动拆分模式(auto split mode)。请查看 -n 和 -p 选项。
-c	只检查语法，不执行程序。
-C dir	在执行前改变目录（等价于 -X）。
-d	启用调试模式（等价于 -debug）。
-F pat	指定 pat 作为默认的分离模式（$;）。
-e prog	指定 prog 作为程序在命令行中执行。可以指定多个 -e 选项，用来执行多个程序。
-h	显示命令行选项的一个概览。
-i [ ext]	把文件内容重写为程序输出。原始文件会被加上扩展名 ext 保存下来。如果未指定 ext，原始文件会被删除。
-I dir	添加 dir 作为加载库的目录。
-K [ kcode]	指定多字节字符集编码。e 或 E 对应 EUC（extended Unix code），s 或 S 对应 SJIS（Shift-JIS），u 或 U 对应 UTF-8，a、A、n 或 N 对应 ASCII。
-l	启用自动行尾处理。从输入行取消一个换行符，并向输出行追加一个换行符。
-n	把代码放置在一个输入循环中（就像在 while gets; ... end 中一样）。
-0[ octal]	设置默认的记录分隔符（$/）为八进制。如果未指定 octal 则默认为 \0。
-p	把代码放置在一个输入循环中。在每次迭代后输出变量 $_ 的值。
-r lib	使用 require 来加载 lib 作为执行前的库。
-s	解读程序名称和文件名参数之间的匹配模式 -xxx 的任何参数作为开关，并定义相应的变量。
-T [level]	设置安全级别，执行不纯度测试（如果未指定 level，则默认值为 1）。
-v	显示版本，并启用冗余模式。
-w	启用冗余模式。如果未指定程序文件，则从 STDIN 读取。
-x [dir]	删除 #!ruby 行之前的文本。如果指定了 dir，则把目录改变为 dir。
-X dir	在执行前改变目录（等价于 -C）。
-y	启用解析器调试模式。
--copyright	显示版权声明。
--debug	启用调试模式（等价于 -d）。
--help	显示命令行选项的一个概览（等价于 -h）。
--version	显示版本。
--verbose	启用冗余模式（等价于 -v）。设置 $VERBOSE 为 true。
--yydebug	启用解析器调试模式（等价于 -y）。


$ ruby -ne 'print if /Ruby/' /usr/share/bin
$ ruby -n -e 'print if /Ruby/' /usr/share/bin

Ruby环境变量

变量	描述
DLN_LIBRARY_PATH	动态加载模块搜索的路径。
HOME	当没有参数传递给 Dir::chdir 时，要移动到的目录。也用于 File::expand_path 来扩展 "~"。
LOGDIR	当没有参数传递给 Dir::chdir 且未设置环境变量 HOME 时，要移动到的目录。
PATH	执行子进程的搜索路径，以及在指定 -S 选项后，Ruby 程序的搜索路径。每个路径用冒号分隔（在 DOS 和 Windows 中用分号分隔）。
RUBYLIB	库的搜索路径。每个路径用冒号分隔（在 DOS 和 Windows 中用分号分隔）。
RUBYLIB_PREFIX	用于修改 RUBYLIB 搜索路径，通过使用格式 path1;path2 或 path1path2，把库的前缀 path1 替换为 path2。
RUBYOPT	传给 Ruby 解释器的命令行选项。在 taint 模式时被忽略（其中，$SAFE 大于 0）。
RUBYPATH	指定 -S 选项后，Ruby 程序的搜索路径。优先级高于 PATH。在 taint 模式时被忽略（其中，$SAFE 大于 0）。
RUBYSHELL	指定执行命令时所使用的 shell。如果未设置该环境变量，则使用 SHELL 或 COMSPEC。

flannery@zhaojiandeMacBook-Pro ~ % env
TMPDIR=/var/folders/8t/r_gk70xd7d9fqxj_5wl59r980000gn/T/
__CFBundleIdentifier=com.apple.Terminal
XPC_FLAGS=0x0
TERM=xterm-256color
SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.AVf165uprV/Listeners
XPC_SERVICE_NAME=0
TERM_PROGRAM=Apple_Terminal
TERM_PROGRAM_VERSION=440
TERM_SESSION_ID=16964F41-774F-4748-8CF8-B885262DDE81
SHELL=/bin/zsh
HOME=/Users/flannery
LOGNAME=flannery
USER=flannery
PATH=/Users/flannery/bin:/Users/flannery/bin:/usr/local/sbin:/usr/local/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Applications/VMware Fusion.app/Contents/Public:/Library/Apple/usr/bin:/Users/flannery/Library/Android/flutter/bin:/Users/flannery/Library/Android/sdk/tools:/Users/flannery/Library/Android/sdk/platform-tools:/Users/flannery/Library/Android/sdk/ndk/20.0.5594570:/Users/flannery/Library/Android/sdk/cmake/3.10.2.4988404/bin
SHLVL=1
PWD=/Users/flannery
OLDPWD=/Users/flannery
PUB_HOSTED_URL=https://pub.flutter-io.cn
FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn
HOMEBREW_BOTTLE_DOMAIN=https://mirrors.ustc.edu.cn/homebrew-bottles
REPO_URL=https://mirrors.tuna.tsinghua.edu.cn/git/git-repo/
USE_CCACHE=1
LANG=zh_CN.UTF-8
_=/usr/bin/env

Ruby 程序中的空白
a + b 被解释为 a+b （这是一个局部变量）
a +b 被解释为 a(+b) （这是一个方法调用）

保留字

BEGIN	do	next	then
END	else	nil	true
alias	elsif	not	undef
and	end	or	unless
begin	ensure	redo	until
break	false	rescue	when
case	for	retry	while
class	if	return	while
def	in	self	__FILE__
defined?	module	super	__LINE__

#!/usr/bin/ruby -w -d
# -*- coding: UTF-8 -*- 
# 中文编码

puts "Hello, Ruby!";



puts "start Here Document";
print <<EOF
    这是第一种方式创建here document
    多行字符串
EOF

print <<"EOF"    # 与上面相同
    这是第二种方式创建here document
    多行字符串
EOF

print <<`EOC` # 执行命令
    echo hi there
    echo lo there
EOC

print <<"foo", <<"bar" #您可以把它们进行堆叠
    I said foo.
foo
    I Said bar.
bar
puts "end Here Document";

END {
    puts "Ruby END语句， 在程序运行之后执行"
}

puts "Ruby BEGIN语句"
BEGIN {
    puts "初始化 Rub 程序， 在程序运行之前执行"
}

puts "Ruby注释"
# 我是注释
=begin
这是注释
这是注释
这是注释
=end

# 数据类型
puts "整型"
# 123                  # Fixnum 十进制
# 1_234                # Fixnum 带有下划线的十进制
# -500                 # 负的 Fixnum
# 0377                 # 八进制
# 0xff                 # 十六进制
# 0b1011               # 二进制
# "a".ord              # "a" 的字符编码
# ?\n                  # 换行符（0x0a）的编码
# 12345678901234567890 # 大数

#整型 Integer 以下是一些整型字面量 
#字面量（literal）：代码中能见到的值，数值，bool值，字符串等都叫字面量 
#如以下的0,1_000_000,0xa等 
a1=0 
 
#带千分符的整型 
a2=1_000_000 
 
#其它进制的表示 
a3=0xa 
puts a1,a2 
puts a3 
 
#puts print 都是向控制台打印字符，其中puts带回车换行符 
=begin 
这是注释，称作：嵌入式文档注释 
类似C#中的/**/ 
=end


puts "浮点型"
# 123.4                # 浮点值
# 1.0e6                # 科学记数法
# 4E20                 # 不是必需的
# 4e+20                # 指数前的符号
 
#浮点型 
f1=0.0 
f2=2.1 
f3=1000000.1 
puts f3

puts "算术操作 加减乘除操作符：+-*/；指数操作符为**"
# 指数算术
puts 2**(1/4)#1与4的商为0，然后2的0次方为1 
puts 16**(1/4.0)#1与4.0的商为0.25（四分之一），然后开四次方根

puts "字符串类型"
puts 'escape using "\\"';
puts 'That\'s right';

puts "\#\{ expr \} 替换任意 Ruby 表达式的值为一个字符串"
puts "相乘 : #{24*60*60}"
name = "Ruby"
puts name
puts "#{name+",ok"}"


puts "转义字符"
# 符号	表示的字符
# \n	换行符 (0x0a)
# \r	回车符 (0x0d)
# \f	换页符 (0x0c)
# \b	退格键 (0x08)
# \a	报警符 Bell (0x07)
# \e	转义符 (0x1b)
# \s	空格符 (0x20)
# \nnn	八进制表示法 (n 是 0-7)
# \xnn	十六进制表示法 (n 是 0-9、a-f 或 A-F)
# \cx, \C-x	Control-x
# \M-x	Meta-x (c | 0x80)
# \M-\C-x	Meta-Control-x
# \x	字符 x


puts "\n\n数组"
# （1）数组通过[]索引访问
# （2）通过赋值操作插入、删除、替换元素
# （3）通过+，－号进行合并和删除元素，且集合做为新集合出现
# （4）通过<<号向原数据追加元素
# （5）通过*号重复数组元素
# （6）通过｜和&符号做并集和交集操作（注意顺序）
ary = [ "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
    print i, ' '
end

puts "\n哈希类型"
hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
    print key, " is ", value, "\n"
end

puts "\n 范围类型"
(10..15).each do |n|
    print n, ' + '
end


puts "\n类和对象"

puts '局部变量：局部变量是在方法中定义的变量。局部变量在方法外是不可用的。在后续的章节中，您将看到有关方法的更多细节。局部变量以小写字母或 _ 开始。'
puts '实例变量：实例变量可以跨任何特定的实例或对象中的方法使用。这意味着，实例变量可以从对象到对象的改变。实例变量在变量名之前放置符号（@）。'
puts '类变量：类变量可以跨不同的对象使用。类变量属于类，且是类的一个属性。类变量在变量名之前放置符号（@@）。'
puts '全局变量：类变量不能跨类使用。如果您想要有一个可以跨类使用的变量，您需要定义全局变量。全局变量总是以美元符号（$）开始。'

class Sample
    def hello
        puts "Hello Ruby!"
    end

end
s=Sample.new()
s.hello()

class Customer
    @@no_of_customers=0     # 类变量 类似static
    def initialize(id, name, addr)
        @cust_id=id      # 实例变量 相当于累类的局部变量
        @cust_name=name
        @cust_addr=addr
    end
    def display_details()
        puts "Customer id      #@cust_id"
        puts "Customer name    #@cust_name"
        puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
        @@no_of_customers += 1
        puts "Toatal number of customers: #@@no_of_customers"
    end
end

# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "poul", "New Empire road, Khandala")
# 调用方法
cust1.display_details()
cust1.total_no_of_customers()
cust2.display_details()
cust2.total_no_of_customers()

puts "\n Ruby变量"
puts 'Ruby 支持五种类型的变量。'
puts '  一般小写字母、下划线开头：变量（Variable）。'
puts '  $开头：全局变量（Global variable）。'
puts '  @开头：实例变量（Instance variable）。'
puts '  @@开头：类变量（Class variable）类变量被共享在整个继承链中'
puts '  大写字母开头：常数（Constant）。'

$global_variable = 10 # 全局变量
class Class1
    def print_global
        puts "全局变量在 Class1 中输出为 #$global_variable"
    end
end
class Class2
    def print_global
        puts "全局变量在 Class2 中输出为 #$global_variable"
    end
end
class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global 

puts "\n 实例变量"
class Customer3 
    def initialize(id, name, addr)
        @cust_id=id
        @cust_name=name
        @cust_addr=addr
    end
    def display_details()
        puts "Customer id #@cust_id"
        puts "Customer name #@cust_name"
        puts "Customer address #@cust_addr"
    end
end
# 创建对象
# 创建对象
cust3_1=Customer3.new("1", "John", "Wisdom Apartments, Ludhiya")
cust3_2=Customer3.new("2", "Poul", "New Empire road, Khandala")
 
# 调用方法
cust3_1.display_details()
cust3_2.display_details()

puts "\n 类变量"
class Customer4
    @@no_of_customers=0
    def initialize(id, name, addr)
        @cust_id=id
        @cust_name=name
        @cust_addr=addr
    end
    def display_details()
        puts "Customer id #@cust_id"
        puts "Customer name #@cust_name"
        puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
        @@no_of_customers += 1
        puts "Total number of customers: #@@no_of_customers"
    end
end

# 创建对象
cust1=Customer4.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer4.new("2", "Poul", "New Empire road, Khandala")
 
# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()

puts "\n 局部变量"
puts "_开头"

puts "\n 常量"
class Example
    VAR1 = 100
    VAR2 = 200
    def show
        puts "第一个常量的值为 #{VAR1}"
        puts "第二个常量的值为 #{VAR2}"
    end
end
# 创建对象
object=Example.new()
object.show

puts "\n 伪常量"
puts "self: 当前方法的接收器对象。"
puts "true: 代表 true 的值。"
puts "false: 代表 false 的值。"
puts "nil: 代表 undefined 的值。"
puts "__FILE__: 当前源文件的名称。"
puts "__LINE__: 当前行在源文件中的编号。"


puts "\n Ruby运算符"
puts "运算符	描述	实例"
puts "+	加法 - 把运算符两边的操作数相加	a + b 将得到 30"
puts "-	减法 - 把左操作数减去右操作数	a - b 将得到 -10"
puts "*	乘法 - 把运算符两边的操作数相乘	a * b 将得到 200"
puts "/	除法 - 把左操作数除以右操作数	b / a 将得到 2"
puts "%	求模 - 把左操作数除以右操作数，返回余数	b % a 将得到 0"
puts "**	指数 - 执行指数计算	a**b 将得到 10 的 20 次方"

puts "\n 比较运算符"
puts "运算符	描述	实例"
puts "==	检查两个操作数的值是否相等，如果相等则条件为真。	(a == b) 不为真。"
puts "!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(a != b) 为真。"
puts ">	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(a > b) 不为真。"
puts "<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(a < b) 为真。"
puts ">=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(a >= b) 不为真。"
puts "<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(a <= b) 为真。"
puts "<=>	联合比较运算符。如果第一个操作数等于第二个操作数则返回 0，如果第一个操作数大于第二个操作数则返回 1，如果第一个操作数小于第二个操作数则返回 -1。	(a <=> b) 返回 -1。"
puts "===	用于测试 case 语句的 when 子句内的相等。	(1...10) === 5 返回 true。"
puts ".eql?	如果接收器和参数具有相同的类型和相等的值，则返回 true。	1 == 1.0 返回 true，但是 1.eql?(1.0) 返回 false。"
puts "equal?	如果接收器和参数具有相同的对象 id，则返回 true。	如果 aObj 是 bObj 的副本，那么 aObj == bObj 返回 true，a.equal?bObj 返回 false，但是 a.equal?aObj 返回 true。"

puts "\n 赋值运算符"
puts "运算符	描述	实例"
puts "=	简单的赋值运算符，把右操作数的值赋给左操作数	c = a + b 将把 a + b 的值赋给 c"
puts "+=	加且赋值运算符，把右操作数加上左操作数的结果赋值给左操作数	c += a 相当于 c = c + a"
puts "-=	减且赋值运算符，把左操作数减去右操作数的结果赋值给左操作数	c -= a 相当于 c = c - a"
puts "*=	乘且赋值运算符，把右操作数乘以左操作数的结果赋值给左操作数	c *= a 相当于 c = c * a"
puts "/=	除且赋值运算符，把左操作数除以右操作数的结果赋值给左操作数	c /= a 相当于 c = c / a"
puts "%=	求模且赋值运算符，求两个操作数的模赋值给左操作数	c %= a 相当于 c = c % a"
puts "**=	指数且赋值运算符，执行指数计算，并赋值给左操作数	c **= a 相当于 c = c ** a"

puts "\n 并行赋值"
a, b, c = 10, 20, 30
print a,' ',b,' ', c


puts "\n Ruby位运算符"
puts "运算符	描述	实例"
puts "&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(a & b) 将得到 12，即为 0000 1100"
puts "|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(a | b) 将得到 61，即为 0011 1101"
puts "^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(a ^ b) 将得到 49，即为 0011 0001"
puts "~	二进制补码运算符是一元运算符，具有\'翻转\'位效果，即0变成1，1变成0。	(~a ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。"
puts "<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	a << 2 将得到 240，即为 1111 0000"
puts ">>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	a >> 2 将得到 15，即为 0000 1111puts \""



puts "逻辑运算符"
puts "运算符	描述	实例"
puts "and	称为逻辑与运算符。如果两个操作数都为真，则条件为真。	(a and b) 为真。"
puts "or	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(a or b) 为真。"
puts "&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(a && b) 为真。"
puts "||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(a || b) 为真。"
puts "!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(a && b) 为假。"
puts "not	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	not(a && b) 为假。"


puts "\n Ruby 三元运算符"
puts "运算符	描述	实例"
puts "? :	条件表达式	如果条件为真 ? 则值为 X : 否则值为 Y"

puts "\n Ruby 范围运算符"
puts "运算符	描述	实例"
puts "..	创建一个从开始点到结束点的范围（包含结束点）	1..10 创建从 1 到 10 的范围"
puts "...	创建一个从开始点到结束点的范围（不包含结束点）	1...10 创建从 1 到 9 的范围"


puts "\nRuby defined? 运算符"
puts "defined? 是一个特殊的运算符，以方法调用的形式来判断传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 nil。"
puts "下面是 defined? 运算符的各种用法："
puts "用法 1"
puts "defined? variable # 如果 variable 已经初始化，则为 True"
puts "例如："
puts ""
puts "foo = 42"
puts "defined? foo    # => \"local-variable\""
puts "defined? $_     # => \"global-variable\""
puts "defined? bar    # => nil（未定义）"
puts foo = 42
puts defined? foo
puts defined? $_
puts defined? bar



puts "用法 2"
puts "defined? method_call # 如果方法已经定义，则为 True"
puts "例如："
puts ""
puts "defined? puts        # => \"method\""
puts "defined? puts(bar)   # => nil（在这里 bar 未定义）"
puts "defined? unpack      # => nil（在这里未定义）"
puts "用法 3"
puts "# 如果存在可被 super 用户调用的方法，则为 True"
puts "defined? super"
puts "例如："
puts ""
puts "defined? super     # => \"super\"（如果可被调用）"
puts "defined? super     # => nil（如果不可被调用）"
puts "用法 4"
puts "defined? yield   # 如果已传递代码块，则为 True"
puts "例如："
puts ""
puts "defined? yield    # => \"yield\"（如果已传递块）"
puts "defined? yield    # => nil（如果未传递块）"


puts "Ruby点运算符. 和 双冒号运算法 ':'"
puts "你可以通过在方法名称前加上类或模块名称和 . 来调用类或模块中的方法。你可以使用类或模块名称和两个冒号 :: 来引用类或模块中的常量。"
puts ":: 是一元运算符，允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。"
puts "请记住：在 Ruby 中，类和方法也可以被当作常量。"
puts "你只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。"
puts "如果 :: 前的表达式为类或模块名称，则返回该类或模块内对应的常量值；如果 :: 前未没有前缀表达式，则返回主Object类中对应的常量值。"

MR_COUNT = 0 # 定义在主Object类上的常量
module Foo
    MR_COUNT = 0
    ::MR_COUNT = 1 # 设置全局计数为1
    MR_COUNT = 2   # 设置局部计数为2
end
puts MR_COUNT      # 这是全局变量
puts Foo::MR_COUNT # 这是“Foo”的局部变量

CONST = ' out there'
class Inside_one
    CONST = proc {'in there'}
    def where_is_my_CONST
        ::CONST + ' inside one'
    end
end
class Inside_two
    CONST = ' inside two'
    def where_is_my_CONST
        CONST
    end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

puts "\nRuby 优先级"
puts "      方法	运算符	描述"
puts "      是	::	常量解析运算符"
puts "      是	[ ] [ ]=	元素引用、元素集合"
puts "      是	**	指数"
puts "      是	! ~ + -	非、补、一元加、一元减（最后两个的方法名为 +@ 和 -@）"
puts "      是	* / %	乘法、除法、求模"
puts "      是	+ -	加法和减法"
puts "      是	>> <<	位右移、位左移"
puts "      是	&	位与"
puts "      是	^ |	位异或、位或"
puts "      是	<= < > >=	比较运算符"
puts "      是	<=> == === != =~ !~	相等和模式匹配运算符（!= 和 !~ 不能被定义为方法）"
puts "      &&	逻辑与"
puts "      ||	逻辑或"
puts "      .. ...	范围（包含、不包含）"
puts "      ? :	三元 if-then-else"
puts "      = %= { /= -= += |= &= >>= <<= *= &&= ||= **=	赋值"
puts "      defined?	检查指定符号是否已定义"
puts "      not	逻辑否定"
puts "      or and	逻辑组成"

puts "\nRuby if..else语句"
x=1
if x > 2
   puts "x 大于 2"
elsif x <= 2 and x!=0
   puts "x 是 1"
else
   puts "无法得知 x 的值"
end


puts "\nif修饰符 if修饰词组表示当 if 右边之条件成立时才执行 if 左边的式子。即如果 conditional 为真，则执行 code。"
$debug=1
print "debug\n" if $debug


puts "\nRuby unless 语句"
x=1
unless x>2
   puts "x 小于 2"
else
  puts "x 大于 2"
end

puts "\nRuby unless 修饰符"
$var =  1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var
 
$var = false
print "3 -- 这一行输出\n" unless $var

puts "\nRuby case 语句"
# case expr0
# when expr1, expr2
#    stmt1
# when expr3, expr4
#    stmt2
# else
#    stmt3
# end

# _tmp = expr0
# if expr1 === _tmp || expr2 === _tmp
#    stmt1
# elsif expr3 === _tmp || expr4 === _tmp
#    stmt2
# else
#    stmt3
# end
$age =  5
case $age
when 0 .. 2
    puts "婴儿"
when 3 .. 6
    puts "小孩"
when 7 .. 12
    puts "child"
when 13 .. 18
    puts "少年"
else
    puts "其他年龄段的"
end

foo = false
bar = true
quu = false
 
case
when foo then puts 'foo is true'
when bar then puts 'bar is true'
when quu then puts 'quu is true'
end

puts "\nRuby while 语句"
$i = 0
$num = 5
while $i < $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1
end

puts "\nRuby while 修饰符"
$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1
end while $i < $num

puts "\nRuby until 语句"
$i = 0
$num = 5
until $i > $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1;
end


puts "\nRuby until 修饰符"
$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1;
end until $i > $num

puts "\nRuby for 语句"
for i in 0..5
    puts "局部变量的值为 #{i}"
end

(0..5).each do |i|
    puts "局部变量的值为 #{i}"
end

puts "\nRuby break 语句"
for i in 0..5
    if i > 2 then
       break
    end
    puts "局部变量的值为 #{i}"
end

puts "\nRuby next 语句"
for i in 0..5
    if i < 2 then
       next
    end
    puts "局部变量的值为 #{i}"
end

puts "\nRuby redo 语句 重新开始最内部循环的该次迭代，不检查循环条件。如果在块内调用，则重新开始 yield 或 call。"
# for i in 0..5
#     if i > 3 then
#        puts "局部变量的值为 #{i}"
#        redo
#     end
# end

puts "\nRuby retry 语句"
#for i in 1..5
#     retry if  i > 2
#     puts "局部变量的值为 #{i}"
#end

puts "语法"
puts "def method_name [( [arg [= default]]...[, * arg [, &expr ]])]"
puts "   expr.."
puts "end"
puts "所以，您可以定义一个简单的方法，如下所示："
puts ""
puts "def method_name "
puts "   expr.."
puts "end"
puts "您可以定义一个接受参数的方法，如下所示："
puts ""
puts "def method_name (var1, var2)"
puts "   expr.."
puts "end"
puts "您可以为参数设置默认值，如果方法调用时未传递必需的参数则使用默认值："
puts ""
puts "def method_name (var1=value1, var2=value2)"
puts "   expr.."
puts "end"

def test(a1="Ruby", a2="Perl")
    puts "编程语言为 #{a1}"
    puts "编程语言为 #{a2}"
end
 test "C", "C++"
 test

 puts "\n从方法返回值"
 def test
    i = 100
    j = 10
    k = 'x'
 end
 puts test

 puts "\nRuby return 语句"
 def test
    i = 100
    j = 200
    k = 300
 return i, j, k
 end
 var = test
 puts var
 print var[0], ' --- ', var[1] , ' --- ', var[2]
 puts

puts "\n可变数量的参数"
def sample (*test)
    puts "参数个数为 #{test.length}"
    for i in 0...test.length
       puts "参数值为 #{test[i]}"
    end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

puts "\n类方法"
class Accounts
    def reading_charge
    end
    def Accounts.return_date
    end
end


puts "\nRuby alias 语句"
# alias foo bar
# alias $MATCH $&

puts "\nRuby undef 语句"
# undef bar

puts "\nRuby块"
puts "您已经知道 Ruby 如何定义方法以及您如何调用方法。类似地，Ruby 有一个块的概念。"
puts "    块由大量的代码组成。"
puts "    您需要给块取个名称。"
puts "    块中的代码总是包含在大括号 {} 内。"
puts "    块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test，那么您要使用函数 test 来调用这个块。"
puts "    您可以使用 yield 语句来调用块。"

puts "\nyield语句 使用一个简单的 yield 语句来调用块"
def test
    puts "在 test 方法内"
    yield
    puts "你又回到了 test 方法内"
    yield
end
test {puts "你在块内"}

def test
    yield 5
    puts "在 test 方法内"
    yield 100
end
test {|i| puts "你在块 #{i} 内"}


puts "\n块和方法"
def test
    yield
end
test{ puts "Hello world"}


def test(&block)
    block.call
end
test { puts "Hello World!"}


puts "\nRuby 模块（Module）"
puts "模块（Module）是一种把方法、类和常量组合在一起的方式。模块（Module）为您提供了两大好处。"
puts "        模块提供了一个命名空间和避免名字冲突。"
puts "        模块实现了 mixin 装置。"
puts "模块（Module）定义了一个命名空间，相当于一个沙盒，在里边您的方法和常量不会与其他地方的方法常量冲突。"
puts "模块类似与类，但有以下不同："
puts "        模块不能实例化"
puts "        模块没有子类"
puts "        模块只能被另一个模块定义"

module Trig
    PI = 3.1415
    def Trig.sin(x)
        # ..
    end
    def Trig.cos(x)
        #..
    end
end

module Moral
    VERY_BAD = 0
    BAD = 1
    def Moral.sin(badness)
        #..
    end
end

puts "Ruby require语句"
# #LOAD_PATH << "."
# require 'trig.rb'
# require 'moral'
# y = Trig.sin(Trig::PI/4)
# wrongdoing = Moral.sin(Moral::VERY_BAD)

puts "Ruby include 语句"
$LOAD_PATH << '.'
require "support"
class Decade
include Week
    no_of_yrs=10
    def no_of_months
        puts Week::FIRST_DAY
        number=10*12
        puts number
    end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months


puts "\nRuby中的Minxins"
module AA
    def a1
    end
    def a2
    end
end

module BB
    def b1
    end
    def b2
    end
end

class Sample2
include AA
include BB
    def s1
    end
end

samp = Sample2.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

puts "\n字符串的公共方法"
puts " 序号	方法 & 描述"
puts " 1	str \% arg          使用格式规范格式化字符串。如果 arg 包含一个以上的替代，那么 arg 必须是一个数组。如需了解更多格式规范的信息，请查看\"内核模块\"下的 sprintf。"
puts " 2	str * integer	   返回一个包含 integer 个 str 的新的字符串。换句话说，str 被重复了 integer 次。"
puts " 3	str + other_str	   连接 other_str 到 str。"
puts " 4	str << obj         连接一个对象到字符串。如果对象是范围为 0.255 之间的固定数字 Fixnum，则它会被转换为一个字符。把它与 concat 进行比较。"
puts " 5	str <=> other_str  把 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。比较是区分大小写的。"
puts " 6	str == obj         检查 str 和 obj 的相等性。如果 obj 不是字符串，则返回 false，如果 str <=> obj，则返回 true，返回 0。"
puts " 7	str =~ obj         根据正则表达式模式 obj 匹配 str。返回匹配开始的位置，否则返回 false。"
puts " 8	str[position] # 注意返回的是ASCII码而不是字符 str[start, length]  str[start..end]  str[start...end]  使用索引截取子串"
puts " 9	str.capitalize     把字符串转换为大写字母显示。"
puts " 10	str.capitalize!    与 capitalize 相同，但是 str 会发生变化并返回。"
puts " 11	str.casecmp        不区分大小写的字符串比较。"
puts " 12	str.center         居中字符串。"
puts " 13	str.chomp          从字符串末尾移除记录分隔符（$/），通常是 \n。如果没有记录分隔符，则不进行任何操作。"
puts " 14	str.chomp!         与 chomp 相同，但是 str 会发生变化并返回。"
puts " 15	str.chop           移除 str 中的最后一个字符。"
puts " 16	str.chop!          与 chop 相同，但是 str 会发生变化并返回。"
puts " 17	str.concat(other_str)  连接 other_str 到 str。"
puts " 18	str.count(str, ...)    给一个或多个字符集计数。如果有多个字符集，则给这些集合的交集计数。"
puts " 19	str.crypt(other_str)   对 str 应用单向加密哈希。参数是两个字符长的字符串，每个字符的范围为 a.z、 A.Z、 0.9、 . 或 /。"
puts " 20	str.delete(other_str, ...)   返回 str 的副本，参数交集中的所有字符会被删除。"
puts " 21	str.delete!(other_str, ...)  与 delete 相同，但是 str 会发生变化并返回。"
puts " 22	str.downcase       返回 str 的副本，所有的大写字母会被替换为小写字母。"
puts " 23	str.downcase!      与 downcase 相同，但是 str 会发生变化并返回。"
puts " 24	str.dump           返回 str 的版本，所有的非打印字符被替换为 \nnn 符号，所有的特殊字符被转义。"
puts " 25	str.each(separator=$/) { |substr| block }    使用参数作为记录分隔符（默认是 $/）分隔 str，传递每个子字符串给被提供的块。"
puts " 26	str.each_byte { |fixnum| block }    传递 str 的每个字节给 block，以字节的十进制表示法返回每个字节。"
puts " 27	str.each_line(separator=$/) { |substr| block }   使用参数作为记录分隔符（默认是 $/）分隔 str，传递每个子字符串给被提供的 block。"
puts " 28	str.empty?     如果 str 为空（即长度为 0），则返回 true。"
puts " 29	str.eql?(other)    如果两个字符串有相同的长度和内容，则这两个字符串相等。"
puts " 30	str.gsub(pattern, replacement) [or] str.gsub(pattern) { |match| block }  返回 str 的副本，pattern 的所有出现都替换为 replacement 或 block 的值。pattern 通常是一个正则表达式 Regexp；如果是一个字符串 String，则没有正则表达式元字符被解释（即，/\d/ 将匹配一个数字，但 '\d' 将匹配一个反斜杠后跟一个 'd'）。"
puts " 31	str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]  使用下列的参数引用 str：参数为一个 Fixnum，则返回 fixnum 的字符编码；参数为两个 Fixnum，则返回一个从偏移（第一个 fixnum）开始截至到长度（第二个 fixnum）为止的子字符串；参数为 range，则返回该范围内的一个子字符串；参数为 regexp，则返回匹配字符串的部分；参数为带有 fixnum 的 regexp，则返回 fixnum 位置的匹配数据；参数为 other_str，则返回匹配 other_str 的子字符串。一个负数的 Fixnum 从字符串的末尾 -1 开始。"
puts " 32	str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] =new_str [or] str[regexp, fixnum] =new_str [or] str[other_str] = new_str ] 替换整个字符串或部分字符串。与 slice! 同义。"
puts " 33	str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block }  执行 String#gsub 的替换，返回 str，如果没有替换被执行则返回 nil。"
puts " 34	str.hash  返回一个基于字符串长度和内容的哈希。"
puts " 35	str.hex  把 str 的前导字符当作十六进制数字的字符串（一个可选的符号和一个可选的 0x），并返回相对应的数字。如果错误则返回零。"
puts " 36	str.include? other_str [or] str.include? fixnum  如果 str 包含给定的字符串或字符，则返回 true。"
puts " 37	str.index(substring [, offset]) [or] str.index(fixnum [, offset]) [or] str.index(regexp [, offset]) 返回给定子字符串、字符（fixnum）或模式（regexp）在 str 中第一次出现的索引。如果未找到则返回 nil。如果提供了第二个参数，则指定在字符串中开始搜索的位置。"
puts " 38	str.insert(index, other_str) 在给定索引的字符前插入 other_str，修改 str。负值索引从字符串的末尾开始计数，并在给定字符后插入。其意图是在给定的索引处开始插入一个字符串。"
puts " 39	str.inspect 返回 str 的可打印版本，带有转义的特殊字符。"
puts " 40	str.intern [or] str.to_sym 返回与 str 相对应的符号，如果之前不存在，则创建符号。"
puts " 41	str.length 返回 str 的长度。把它与 size 进行比较。"
puts " 42	str.ljust(integer, padstr=' ')  如果 integer 大于 str 的长度，则返回长度为 integer 的新字符串，新字符串以 str 左对齐，并以 padstr 作为填充。否则，返回 str。"
puts " 43	str.lstrip  返回 str 的副本，移除了前导的空格。"
puts " 44	str.lstrip!  从 str 中移除前导的空格，如果没有变化则返回 nil。"
puts " 45	str.match(pattern)  如果 pattern 不是正则表达式，则把 pattern 转换为正则表达式 Regexp，然后在 str 上调用它的匹配方法。"
puts " 46	str.oct  把 str 的前导字符当作十进制数字的字符串（一个可选的符号），并返回相对应的数字。如果转换失败，则返回 0。"
puts " 47	str.replace(other_str)  把 str 中的内容替换为 other_str 中的相对应的值。"
puts " 48	str.reverse  返回一个新字符串，新字符串是 str 的倒序。"
puts " 49	str.reverse!  逆转 str，str 会发生变化并返回。"
puts " 50	str.rindex(substring [, fixnum]) [or] str.rindex(fixnum [, fixnum]) [or]  str.rindex(regexp [, fixnum])  返回给定子字符串、字符（fixnum）或模式（regexp）在 str 中最后一次出现的索引。如果未找到则返回 nil。如果提供了第二个参数，则指定在字符串中结束搜索的位置。超出该点的字符将不被考虑。"
puts " 51	str.rjust(integer, padstr=' ')  如果 integer 大于 str 的长度，则返回长度为 integer 的新字符串，新字符串以 str 右对齐，并以 padstr 作为填充。否则，返回 str。"
puts " 52	str.rstrip  返回 str 的副本，移除了尾随的空格。"
puts " 53	str.rstrip!  从 str 中移除尾随的空格，如果没有变化则返回 nil。"
puts " 54	str.scan(pattern) [or] str.scan(pattern) { |match, ...| block } 两种形式匹配 pattern（可以是一个正则表达式 Regexp 或一个字符串 String）遍历 str。针对每个匹配，会生成一个结果，结果会添加到结果数组中或传递给 block。如果 pattern 不包含分组，则每个独立的结果由匹配的字符串、$& 组成。如果 pattern 包含分组，每个独立的结果是一个包含每个分组入口的数组。"
puts " 55	str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or] str.slice(range) [or] str.slice(regexp) [or] str.slice(regexp, fixnum) [or] str.slice(other_str) See str[fixnum], etc. str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str) 从 str 中删除指定的部分，并返回删除的部分。如果值超出范围，参数带有 Fixnum 的形式，将生成一个 IndexError。参数为 range 的形式，将生成一个 RangeError，参数为 Regexp 和 String 的形式，将忽略执行动作。"
puts " 56	str.split(pattern=$;, [limit]) 基于分隔符，把 str 分成子字符串，并返回这些子字符串的数组。"

puts " 如果 pattern 是一个字符串 String，那么在分割 str 时，它将作为分隔符使用。如果 pattern 是一个单一的空格，那么 str 是基于空格进行分割，会忽略前导空格和连续空格字符。"
puts " 如果 pattern 是一个正则表达式 Regexp，则 str 在 pattern 匹配的地方被分割。当 pattern 匹配一个零长度的字符串时，str 被分割成单个字符。"
puts " 如果省略了 pattern 参数，则使用 $; 的值。如果 $; 为 nil（默认的），str 基于空格进行分割，就像是指定了 ` ` 作为分隔符一样。"
puts " 如果省略了 limit 参数，会抑制尾随的 null 字段。如果 limit 是一个正数，则最多返回该数量的字段（如果 limit 为 1，则返回整个字符串作为数组中的唯一入口）。如果 limit 是一个负数，则返回的字段数量不限制，且不抑制尾随的 null 字段。"
puts " 57	str.squeeze([other_str]*) 使用为 String#count 描述的程序从 other_str 参数建立一系列字符。返回一个新的字符串，其中集合中出现的相同的字符会被替换为单个字符。如果没有给出参数，则所有相同的字符都被替换为单个字符。"
puts " 58	str.squeeze!([other_str]*) 与 squeeze 相同，但是 str 会发生变化并返回，如果没有变化则返回 nil。"
puts " 59	str.strip 返回 str 的副本，移除了前导的空格和尾随的空格。"
puts " 60	str.strip!  从 str 中移除前导的空格和尾随的空格，如果没有变化则返回 nil。"
puts " 61	str.sub(pattern, replacement) [or] str.sub(pattern) { |match| block } 返回 str 的副本，pattern 的第一次出现会被替换为 replacement 或 block 的值。pattern 通常是一个正则表达式 Regexp；如果是一个字符串 String，则没有正则表达式元字符被解释。"
puts " 62	str.sub!(pattern, replacement) [or] str.sub!(pattern) { |match| block } 执行 String#sub 替换，并返回 str，如果没有替换执行，则返回 nil。"
puts " 63	str.succ [or] str.next 返回 str 的继承。"
puts " 64	str.succ! [or] str.next! 相当于 String#succ，但是 str 会发生变化并返回。"
puts " 65	str.sum(n=16) 返回 str 中字符的 n-bit 校验和，其中 n 是可选的 Fixnum 参数，默认为 16。结果是简单地把 str 中每个字符的二进制值的总和，以 2n - 1 为模。这不是一个特别好的校验和。"
puts " 66	str.swapcase 返回 str 的副本，所有的大写字母转换为小写字母，所有的小写字母转换为大写字母。"
puts " 67	str.swapcase! 相当于 String#swapcase，但是 str 会发生变化并返回，如果没有变化则返回 nil。"
puts " 68	str.to_f 返回把 str 中的前导字符解释为浮点数的结果。超出有效数字的末尾的多余字符会被忽略。如果在 str 的开头没有有效数字，则返回 0.0。该方法不会生成异常。"
puts " 69	str.to_i(base=10) 返回把 str 中的前导字符解释为整数基数（基数为 2、 8、 10 或 16）的结果。超出有效数字的末尾的多余字符会被忽略。如果在 str 的开头没有有效数字，则返回 0。该方法不会生成异常。"
puts " 70	str.to_s [or] str.to_str 返回接收的值。"
puts " 71	str.tr(from_str, to_str) 返回 str 的副本，把 from_str 中的字符替换为 to_str 中相对应的字符。如果 to_str 比 from_str 短，那么它会以最后一个字符进行填充。两个字符串都可以使用 c1.c2 符号表示字符的范围。如果 from_str 以 ^ 开头，则表示除了所列出的字符以外的所有字符。"
puts " 72	str.tr!(from_str, to_str)  相当于 String#tr，但是 str 会发生变化并返回，如果没有变化则返回 nil。"
puts " 73	str.tr_s(from_str, to_str)  把 str 按照 String#tr 描述的规则进行处理，然后移除会影响翻译的重复字符。"
puts " 74	str.tr_s!(from_str, to_str)  相当于 String#tr_s，但是 str 会发生变化并返回，如果没有变化则返回 nil。"
puts " 75	str.unpack(format)  根据 format 字符串解码 str（可能包含二进制数据），返回被提取的每个值的数组。format 字符由一系列单字符指令组成。每个指令后可以跟着一个数字，表示重复该指令的次数。星号（*）将使用所有剩余的元素。指令 sSiIlL 每个后可能都跟着一个下划线（_），为指定类型使用底层平台的本地尺寸大小，否则使用独立于平台的一致的尺寸大小。format 字符串中的空格会被忽略。"
puts " 76	str.upcase  返回 str 的副本，所有的小写字母会被替换为大写字母。操作是环境不敏感的，只有字符 a 到 z 会受影响。"
puts " 77	str.upcase! 改变 str 的内容为大写，如果没有变化则返回 nil。"
puts " 78	str.upto(other_str) { |s| block }  遍历连续值，以 str 开始，以 other_str 结束（包含），轮流传递每个值给 block。String#succ 方法用于生成每个值。"

Array数组

#!/usr/bin/ruby -w -d
# -*- coding: UTF-8 -*- 
# 中文编码

puts "Hello world!"

puts "Start"
names = Array.new
puts names, names.length

names = Array.new(20)
puts names.length

names = Array.new(4, "mac")
print names, ' '

names = Array.new(10) { |e| e = e * 2 }
print names , "\n"

names = Array.[](1, 2, 3, 4.5)
print names, "\n"

names = Array[1, 2, 3, 4.5]
print names, "\n"

names = Array(0..9)
print names, "\n"

puts "数组内建方法"
digits = Array(0..9)
num = digits.at(6)
puts "#{num}"


puts "序号	方法 & 描述"
puts "1	array & other_array"
puts "返回一个新的数组，包含两个数组中共同的元素，没有重复。"
puts "2	array * int [or] array * str"
puts "返回一个新的数组，新数组通过连接 self 的 int 副本创建的。带有 String 参数时，相当于 self.join(str)。"
puts "3	array + other_array"
puts "返回一个新的数组，新数组通过连接两个数组产生第三个数组创建的。"
puts "4	array - other_array"
puts "返回一个新的数组，新数组是从初始数组中移除了在 other_array 中出现的项的副本。"
puts "5	str <=> other_str"
puts "把 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。比较是区分大小写的。"
puts "6	array | other_array"
puts "通过把 other_array 加入 array 中，移除重复项，返回一个新的数组。"
puts "7	array << obj"
puts "把给定的对象附加到数组的末尾。该表达式返回数组本身，所以几个附加可以连在一起。"
puts "8	array <=> other_array"
puts "如果数组小于、等于或大于 other_array，则返回一个整数（-1、 0 或 +1）。"
puts "9	array == other_array"
puts "如果两个数组包含相同的元素个数，且每个元素与另一个数组中相对应的元素相等（根据 Object.==），那么这两个数组相等。"
puts "10	array[index] [or] array[start, length] [or]"
puts "array[range] [or] array.slice(index) [or]"
puts "array.slice(start, length) [or] array.slice(range)"
puts "返回索引为 index 的元素，或者返回从 start 开始直至 length 个元素的子数组，或者返回 range 指定的子数组。负值索引从数组末尾开始计数（-1 是最后一个元素）。如果 index（或开始索引）超出范围，则返回 nil。"
puts "11	array[index] = obj [or]"
puts "array[start, length] = obj or an_array or nil [or]"
puts "array[range] = obj or an_array or nil"
puts "设置索引为 index 的元素，或者替换从 start 开始直至 length 个元素的子数组，或者替换 range 指定的子数组。如果索引大于数组的当前容量，那么数组会自动增长。负值索引从数组末尾开始计数。如果 length 为零则插入元素。如果在第二种或第三种形式中使用了 nil，则从 self 删除元素。"
puts "12	array.abbrev(pattern = nil)"
puts "为 self 中的字符串计算明确的缩写集合。如果传递一个模式或一个字符串，只考虑当字符串匹配模式或者以该字符串开始时的情况。"
puts "13	array.assoc(obj)"
puts "搜索一个数组，其元素也是数组，使用 obj.== 把 obj 与每个包含的数组的第一个元素进行比较。如果匹配则返回第一个包含的数组，如果未找到匹配则返回 nil。"
puts "14	array.at(index)"
puts "返回索引为 index 的元素。一个负值索引从 self 的末尾开始计数。如果索引超出范围则返回 nil。"
puts "15	array.clear"
puts "从数组中移除所有的元素。"
puts "16	array.collect { |item| block } [or]"
puts "array.map { |item| block }"
puts "为 self 中的每个元素调用一次 block。创建一个新的数组，包含 block 返回的值。"
puts "17	array.collect! { |item| block } [or]"
puts "array.map! { |item| block }"
puts "为 self 中的每个元素调用一次 block，把元素替换为 block 返回的值。"
puts "18	array.compact"
puts "返回 self 的副本，移除了所有的 nil 元素。"
puts "19	array.compact!"
puts "从数组中移除所有的 nil 元素。如果没有变化则返回 nil。"
puts "20	array.concat(other_array)"
puts "追加 other_array 中的元素到 self 中。"
puts "21	array.delete(obj) [or]"
puts "array.delete(obj) { block }"
puts "从 self 中删除等于 obj 的项。如果未找到相等项，则返回 nil。如果未找到相等项且给出了可选的代码 block，则返回 block 的结果。"
puts "22	array.delete_at(index)"
puts "删除指定的 index 处的元素，并返回该元素。如果 index 超出范围，则返回 nil。"
puts "23	array.delete_if { |item| block }"
puts "当 block 为 true 时，删除 self 的每个元素。"
puts "24	array.each { |item| block }"
puts "为 self 中的每个元素调用一次 block，传递该元素作为参数。"
puts "25	array.each_index { |index| block }"
puts "与 Array#each 相同，但是传递元素的 index，而不是传递元素本身。"
puts "26	array.empty?"
puts "如果数组本身没有包含元素，则返回 true。"
puts "27	array.eql?(other)"
puts "如果 array 和 other 是相同的对象，或者两个数组带有相同的内容，则返回 true。"
puts "28	array.fetch(index) [or]"
puts "array.fetch(index, default) [or]"
puts "array.fetch(index) { |index| block }"
puts "尝试返回位置 index 处的元素。如果 index 位于数组外部，则第一种形式会抛出 IndexError 异常，第二种形式会返回 default，第三种形式会返回调用 block 传入 index 的值。负值的 index 从数组末尾开始计数。"
puts "29	array.fill(obj) [or]"
puts "array.fill(obj, start [, length]) [or]"
puts "array.fill(obj, range) [or]"
puts "array.fill { |index| block } [or]"
puts "array.fill(start [, length] ) { |index| block } [or]"
puts "array.fill(range) { |index| block }"
puts "前面三种形式设置 self 的被选元素为 obj。以 nil 开头相当于零。nil 的长度相当于 self.length。最后三种形式用 block 的值填充数组。block 通过带有被填充的每个元素的绝对索引来传递。"
puts "30	array.first [or]"
puts "array.first(n)"
puts "返回数组的第一个元素或前 n 个元素。如果数组为空，则第一种形式返回 nil，第二种形式返回一个空的数组。"
puts "31	array.flatten"
puts "返回一个新的数组，新数组是一个一维的扁平化的数组（递归）。"
puts "32	array.flatten!"
puts "把 array 进行扁平化。如果没有变化则返回 nil。（数组不包含子数组。）"
puts "33	array.frozen?"
puts "如果 array 被冻结（或排序时暂时冻结），则返回 true。"
puts "34	array.hash"
puts "计算数组的哈希代码。两个具有相同内容的数组将具有相同的哈希代码。"
puts "35	array.include?(obj)"
puts "如果 self 中包含 obj，则返回 true，否则返回 false。"
puts "36	array.index(obj)"
puts "返回 self 中第一个等于 obj 的对象的 index。如果未找到匹配则返回 nil。"
puts "37	array.indexes(i1, i2, ... iN) [or]"
puts "array.indices(i1, i2, ... iN)"
puts "该方法在 Ruby 的最新版本中被废弃，所以请使用 Array#values_at。"
puts "38	array.indices(i1, i2, ... iN) [or]"
puts "array.indexes(i1, i2, ... iN)"
puts "该方法在 Ruby 的最新版本中被废弃，所以请使用 Array#values_at。"
puts "39	array.insert(index, obj...)"
puts "在给定的 index 的元素前插入给定的值，index 可以是负值。"
puts "40	array.inspect"
puts "创建一个数组的可打印版本。"
puts "41	array.join(sep=$,)"
puts "返回一个字符串，通过把数组的每个元素转换为字符串，并使用 sep 分隔进行创建的。"
puts "42	array.last [or] array.last(n)"
puts "返回 self 的最后一个元素。如果数组为空，则第一种形式返回 nil。"
puts "43	array.length"
puts "返回 self 中元素的个数。可能为零。"
puts "44	array.map { |item| block } [or]"
puts "array.collect { |item| block }"
puts "为 self 的每个元素调用一次 block。创建一个新的数组，包含 block 返回的值。"
puts "45	array.map! { |item| block } [or]"
puts "array.collect! { |item| block }"
puts "为 array 的每个元素调用一次 block，把元素替换为 block 返回的值。"
puts "46	array.nitems"
puts "返回 self 中 non-nil 元素的个数。可能为零。"
puts "47	array.pack(aTemplateString)"
puts "根据 aTemplateString 中的指令，把数组的内容压缩为二进制序列。指令 A、 a 和 Z 后可以跟一个表示结果字段宽度的数字。剩余的指令也可以带有一个表示要转换的数组元素个数的数字。如果数字是一个星号（*），则所有剩余的数组元素都将被转换。任何指令后都可以跟一个下划线（_），表示指定类型使用底层平台的本地尺寸大小，否则使用独立于平台的一致的尺寸大小。在模板字符串中空格会被忽略。"
puts "48	array.pop"
puts "从 array 中移除最后一个元素，并返回该元素。如果 array 为空则返回 nil。"
puts "49	array.push(obj, ...)"
puts "把给定的 obj 附加到数组的末尾。该表达式返回数组本身，所以几个附加可以连在一起。"
puts "50	array.rassoc(key)"
puts "搜索一个数组，其元素也是数组，使用 == 把 key 与每个包含的数组的第二个元素进行比较。如果匹配则返回第一个包含的数组。"
puts "51	array.reject { |item| block }"
puts "返回一个新的数组，包含当 block 不为 true 时的数组项。"
puts "52	array.reject! { |item| block }"
puts "当 block 为真时，从 array 删除元素，如果没有变化则返回 nil。相当于 Array#delete_if。"
puts "53	array.replace(other_array)"
puts "把 array 的内容替换为 other_array 的内容，必要的时候进行截断或扩充。"
puts "54	array.reverse"
puts "返回一个新的数组，包含倒序排列的数组元素。"
puts "55	array.reverse!"
puts "把 array 进行逆转。"
puts "56	array.reverse_each {|item| block }"
puts "与 Array#each 相同，但是把 array 进行逆转。"
puts "57	array.rindex(obj)"
puts "返回 array 中最后一个等于 obj 的对象的索引。如果未找到匹配，则返回 nil。"
puts "58	array.select {|item| block }"
puts "调用从数组传入连续元素的 block，返回一个数组，包含 block 返回 true 值时的元素。"
puts "59	array.shift"
puts "返回 self 的第一个元素，并移除该元素（把所有的其他元素下移一位）。如果数组为空，则返回 nil。"
puts "60	array.size"
puts "返回 array 的长度（元素的个数）。length 的别名。"
puts "61	array.slice(index) [or] array.slice(start, length) [or]"
puts "array.slice(range) [or] array[index] [or]"
puts "array[start, length] [or] array[range]"
puts "返回索引为 index 的元素，或者返回从 start 开始直至 length 个元素的子数组，或者返回 range 指定的子数组。负值索引从数组末尾开始计数（-1 是最后一个元素）。如果 index（或开始索引）超出范围，则返回 nil。"
puts "62	array.slice!(index) [or] array.slice!(start, length) [or]"
puts "array.slice!(range)"
puts "删除 index（长度是可选的）或 range 指定的元素。返回被删除的对象、子数组，如果 index 超出范围，则返回 nil。"
puts "63	array.sort [or] array.sort { | a,b | block }"
puts "返回一个排序的数组。"
puts "64	array.sort! [or] array.sort! { | a,b | block }"
puts "把数组进行排序。"
puts "65	array.to_a"
puts "返回 self。如果在 Array 的子类上调用，则把接收参数转换为一个 Array 对象。"
puts "66	array.to_ary"
puts "返回 self。"
puts "67	array.to_s"
puts "返回 self.join。"
puts "68	array.transpose"
puts "假设 self 是数组的数组，且置换行和列。"
puts "69	array.uniq"
puts "返回一个新的数组，移除了 array 中的重复值。"
puts "70	array.uniq!"
puts "从 self 中移除重复元素。如果没有变化（也就是说，未找到重复），则返回 nil。"
puts "71	array.unshift(obj, ...)"
puts "把对象前置在数组的前面，其他元素上移一位。"
puts "72	array.values_at(selector,...)"
puts "返回一个数组，包含 self 中与给定的 selector（一个或多个）相对应的元素。选择器可以是整数索引或者范围。"
puts "73	array.zip(arg, ...) [or]"
puts "array.zip(arg, ...){ | arr | block }"
puts "把任何参数转换为数组，然后把 array 的元素与每个参数中相对应的元素合并。"




puts "\n数组 pack 指令"
puts " 指令	描述"
puts " @	移动到绝对位置。"
puts " A	ASCII 字符串（填充 space，count 是宽度）。"
puts " a	ASCII 字符串（填充 null，count 是宽度）。"
puts " B	位字符串（降序）"
puts " b	位字符串（升序）。"
puts " C	无符号字符。"
puts " c	字符。"
puts " D, d	双精度浮点数，原生格式。"
puts " E	双精度浮点数，little-endian 字节顺序。"
puts " e	单精度浮点数，little-endian 字节顺序。"
puts " F, f	单精度浮点数，原生格式。"
puts " G	双精度浮点数，network（big-endian）字节顺序。"
puts " g	单精度浮点数，network（big-endian）字节顺序。"
puts " H	十六进制字符串（高位优先）。"
puts " h	十六进制字符串（低位优先）。"
puts " I	无符号整数。"
puts " i	整数。"
puts " L	无符号 long。"
puts " l	Long。"
puts " M	引用可打印的，MIME 编码。"
puts " m	Base64 编码字符串。"
puts " N	Long，network（big-endian）字节顺序。"
puts " n	Short，network（big-endian）字节顺序。"
puts " P	指向一个结构（固定长度的字符串）。"
puts " p	指向一个空结束字符串。"
puts " Q, q	64 位数字。"
puts " S	无符号 short。"
puts " s	Short。"
puts " U	UTF-8。"
puts " u	UU 编码字符串。"
puts " V	Long，little-endian 字节顺序。"
puts " v	Short，little-endian 字节顺序。"
puts " w	BER 压缩的整数 \fnm。"
puts " X	向后跳过一个字节。"
puts " x	Null 字节。"
puts " Z	与 a 相同，除了 null 会被加上 *。"


puts "实例"
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"

puts "End"

Hash哈希

#!/usr/bin/ruby -w -d
# -*- coding: UTF-8 -*- 
# 中文编码

puts "Hello World!", "Start"
months = Hash.new
puts months

puts "创建带默认值的"
months = Hash.new("month")  
puts months
months = Hash.new "month"
puts months

puts "找到返回， 找不到返回默认值"
puts "#{months[0]}"
puts "#{months[72]}"

H = Hash["a"=>100, "b"=>200]
puts "#{H['a']}"
puts "#{H['b']}"

puts "哈希内置方法"
puts "Hash[[key =>|, value]* ] or"
puts "Hash.new [or] Hash.new(obj) [or]"
puts "Hash.new { |hash, key| block }"
$, = ", "
months = Hash.new("month")
months = {"1"=>"January", "2"=>"February"}
keys = months.keys
puts "#{keys}"

puts "序号	方法 & 描述"
puts "1	hash == other_hash"
puts "检查两个哈希是否具有相同的键值对个数，键值对是否相互匹配，来判断两个哈希是否相等。"
puts "2	hash[key]"
puts "使用键，从哈希引用值。如果未找到键，则返回默认值。"
puts "3	hash[key]=value"
puts "把 value 给定的值与 key 给定的键进行关联。"
puts "4	hash.clear"
puts "从哈希中移除所有的键值对。"
puts "5	hash.default(key = nil)"
puts "返回 hash 的默认值，如果未通过 default= 进行设置，则返回 nil。（如果键在 hash 中不存在，则 [] 返回一个默认值。）"
puts "6	hash.default = obj"
puts "为 hash 设置默认值。"
puts "7	hash.default_proc"
puts "如果 hash 通过块来创建，则返回块。"
puts "8	hash.delete(key) [or]"
puts "array.delete(key) { |key| block }"
puts "通过 key 从 hash 中删除键值对。如果使用了块 且未找到匹配的键值对，则返回块的结果。把它与 delete_if 进行比较。"
puts "9	hash.delete_if { |key,value| block }"
puts "block 为 true 的每个块，从 hash 中删除键值对。"
puts "10	hash.each { |key,value| block }"
puts "遍历 hash，为每个 key 调用一次 block，传递 key-value 作为一个二元素数组。"
puts "11	hash.each_key { |key| block }"
puts "遍历 hash，为每个 key 调用一次 block，传递 key 作为参数。"
puts "12	hash.each_key { |key_value_array| block }"
puts "遍历 hash，为每个 key 调用一次 block，传递 key 和 value 作为参数。"
puts "13	hash.each_value { |value| block }"
puts "遍历 hash，为每个 key 调用一次 block，传递 value 作为参数。"
puts "14	hash.empty?"
puts "检查 hash 是否为空（不包含键值对），返回 true 或 false。"
puts "15	hash.fetch(key [, default] ) [or]"
puts "hash.fetch(key) { | key | block }"
puts "通过给定的 key 从 hash 返回值。如果未找到 key，且未提供其他参数，则抛出 IndexError 异常；如果给出了 default，则返回 default；如果指定了可选的 block，则返回 block 的结果。"
puts "16	hash.has_key?(key) [or] hash.include?(key) [or]"
puts "hash.key?(key) [or] hash.member?(key)"
puts "检查给定的 key 是否存在于哈希中，返回 true 或 false。"
puts "17	hash.has_value?(value)"
puts "检查哈希是否包含给定的 value。"
puts "18	hash.index(value)"
puts "为给定的 value 返回哈希中的 key，如果未找到匹配值则返回 nil。"
puts "19	hash.indexes(keys)"
puts "返回一个新的数组，由给定的键的值组成。找不到的键将插入默认值。该方法已被废弃，请使用 select。"
puts "20	hash.indices(keys)"
puts "返回一个新的数组，由给定的键的值组成。找不到的键将插入默认值。该方法已被废弃，请使用 select。"
puts "21	hash.inspect"
puts "返回哈希的打印字符串版本。"
puts "22	hash.invert"
puts "创建一个新的 hash，倒置 hash 中的 keys 和 values。也就是说，在新的哈希中，hash 中的键将变成值，值将变成键。"
puts "23	hash.keys"
puts "创建一个新的数组，带有 hash 中的键。"
puts "24	hash.length"
puts "以整数形式返回 hash 的大小或长度。"
puts "25	hash.merge(other_hash) [or]"
puts "hash.merge(other_hash) { |key, oldval, newval| block }"
puts "返回一个新的哈希，包含 hash 和 other_hash 的内容，重写 hash 中与 other_hash 带有重复键的键值对。"
puts "26	hash.merge!(other_hash) [or]"
puts "hash.merge!(other_hash) { |key, oldval, newval| block }"
puts "与 merge 相同，但实际上 hash 发生了变化。"
puts "27	hash.rehash"
puts "基于每个 key 的当前值重新建立 hash。如果插入后值发生了改变，该方法会重新索引 hash。"
puts "28	hash.reject { |key, value| block }"
puts "类似 delete_if, 但作用在一个拷贝的哈希上。相等于 hsh.dup.delete_if。"
puts "29	hash.reject! { |key, value| block }"
puts "相等于 delete_if, 但是如果没有修改，返回 nil。"
puts "30	hash.replace(other_hash)"
puts "把 hash 的内容替换为 other_hash 的内容。"
puts "31	hash.select { |key, value| block }"
puts "返回一个新的数组，由 block 返回 true 的 hash 中的键值对组成。"
puts "32	hash.shift"
puts "从 hash 中移除一个键值对，并把该键值对作为二元素数组返回。"
puts "33	hash.size"
puts "以整数形式返回 hash 的 size 或 length。"
puts "34	hash.sort"
puts "把 hash 转换为一个包含键值对数组的二维数组，然后进行排序。"
puts "35	hash.store(key, value)"
puts "存储 hash 中的一个键值对。"
puts "36	hash.to_a"
puts "从 hash 中创建一个二维数组。每个键值对转换为一个数组，所有这些数组都存储在一个数组中。"
puts "37	hash.to_hash"
puts "返回 hash（self）。"
puts "38	hash.to_s"
puts "把 hash 转换为一个数组，然后把该数组转换为一个字符串。"
puts "39	hash.update(other_hash) [or]"
puts "hash.update(other_hash) {|key, oldval, newval| block}"
puts "返回一个新的哈希，包含 hash 和 other_hash 的内容，重写 hash 中与 other_hash 带有重复键的键值对。"
puts "40	hash.value?(value)"
puts "检查 hash 是否包含给定的 value。"
puts "41	hash.values"
puts "返回一个新的数组，包含 hash 的所有值。"
puts "42	hash.values_at(obj, ...)"
puts "返回一个新的数组，包含 hash 中与给定的键相关的值。"

puts "End"

日期和时间

#!/usr/bin/ruby -w
# -*- coding: UTF-8 -*-

time1 = Time.new
puts "当前时间："+time1.inspect

# Time.noew 功能相同
time2 = Time.now
puts "当前时间："+time2.inspect

puts "获取 Date & Time 组件"
time = Time.new
 
# Time 的组件
puts "当前时间 : " + time.inspect
puts time.year    # => 日期的年份
puts time.month   # => 日期的月份（1 到 12）
puts time.day     # => 一个月中的第几天（1 到 31）
puts time.wday    # => 一周中的星期几（0 是星期日）
puts time.yday    # => 365：一年中的第几天
puts time.hour    # => 23：24 小时制
puts time.min     # => 59
puts time.sec     # => 59
puts time.usec    # => 999999：微秒
puts time.zone    # => "UTC"：时区名称


puts "Time.utc、Time.gm 和 Time.local 函数"
# July 8, 2008
puts Time.local(2008, 7, 8).inspect
# July 8, 2008, 09:10am，本地时间
puts Time.local(2008, 7, 8, 9, 10).inspect
# July 8, 2008, 09:10 UTC
puts Time.utc(2008, 7, 8, 9, 10)  .inspect
# July 8, 2008, 09:10:11 GMT （与 UTC 相同）
puts Time.gm(2008, 7, 8, 9, 10, 11).inspect


time = Time.new
values = time.to_a
p values
puts Time.utc(*values)

puts "返回从纪元以来的秒数"
puts "time = Time.now.to_i"  
puts "把秒数转换为 Time 对象"
puts "Time.at(time)"
puts "返回从纪元以来的秒数，包含微妙"
puts "time = Time.now.to_f"


puts "时区和夏令时"
time = Time.new
 
# 这里是解释
puts time.zone       # => "UTC"：返回时区
puts time.utc_offset # => 0：UTC 是相对于 UTC 的 0 秒偏移
puts time.zone       # => "PST"（或其他时区）
puts time.isdst      # => false：如果 UTC 没有 DST（夏令时）
puts time.utc?       # => true：如果在 UTC 时区
puts time.localtime  # 转换为本地时区
puts time.gmtime     # 转换回 UTC
puts time.getlocal   # 返回本地区中的一个新的 Time 对象
puts time.getutc     # 返回 UTC 中的一个新的 Time 对象

puts "格式化时间和日期"
time = Time.new 
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")

puts "时间格式化指令"
puts "指令	描述"
puts "%a	星期几名称的缩写（比如 Sun）。"
puts "%A	星期几名称的全称（比如 Sunday）。"
puts "%b	月份名称的缩写（比如 Jan）。"
puts "%B	月份名称的全称（比如 January）。"
puts "%c	优选的本地日期和时间表示法。"
puts "%d	一个月中的第几天（01 到 31）。"
puts "%H	一天中的第几小时，24 小时制（00 到 23）。"
puts "%I	一天中的第几小时，12 小时制（01 到 12）。"
puts "%j	一年中的第几天（001 到 366）。"
puts "%m	一年中的第几月（01 到 12）。"
puts "%M	小时中的第几分钟（00 到 59）。"
puts "%p	子午线指示（AM 或 PM）。"
puts "%S	分钟中的第几秒（00 或 60）。"
puts "%U	当前年中的周数，从第一个星期日（作为第一周的第一天）开始（00 到 53）。"
puts "%W	当前年中的周数，从第一个星期一（作为第一周的第一天）开始（00 到 53）。"
puts "%w	一星期中的第几天（Sunday 是 0，0 到 6）。"
puts "%x	只有日期没有时间的优先表示法。"
puts "%X	只有时间没有日期的优先表示法。"
puts "%y	不带世纪的年份表示（00 到 99）。"
puts "%Y	带有世纪的年份。"
puts "%Z	时区名称。"
puts "%%	% 字符。"

puts "时间算法"
now = Time.now           # 当前时间
puts now
 
past = now - 10          # 10 秒之前。Time - number => Time
puts past
 
future = now + 10        # 从现在开始 10 秒之后。Time + number => Time
puts future
 
diff = future - now      # => 10  Time - Time => 秒数
puts diff

范围(Range)

 #!/usr/bin/ruby
 
$, =", "   # Array 值分隔符
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a
 
puts "#{range1}"
puts "#{range2}"

puts (1..5)        #==> 1, 2, 3, 4, 5
puts (1...5)       #==> 1, 2, 3, 4
puts ('a'..'d')    #==> 'a', 'b', 'c', 'd'

# 指定范围
digits = 0..9
 
puts digits.include?(5)
ret = digits.min
puts "最小值为 #{ret}"
 
ret = digits.max
puts "最大值为 #{ret}"
 
ret = digits.reject {|i| i < 5 }
puts "不符合条件的有 #{ret}"
 
digits.each do |digit|
   puts "在循环中 #{digit}"
end


puts "作为条件的范围"
# while gets
#     print if /start/../end/
# end

score = 70
 
result = case score
when 0..40
    "糟糕的分数"
when 41..60
    "快要及格"
when 61..70
    "及格分数"
when 71..100
       "良好分数"
else
    "错误的分数"
end
 
puts result


puts "作为间隔的范围"
if ((1..10) === 5)
    puts "5 在 (1..10)"
end
 
if (('a'..'j') === 'c')
  puts "c 在 ('a'..'j')"
end
 
if (('a'..'j') === 'z')
  puts "z 在 ('a'..'j')"
end

迭代遍历

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
    print i
end

puts ''

a = [1,2,3,4,5]
b = Array.new
b = a.collect { |x| x }
print b 
puts  ''

b = a.collect{|x| 10*x}
print b
puts

sum = 0
cutcome = {"block1" => 1000, "book2" => 1000, "book3" => 4000}
cutcome.each{|item, price| sum += price}
puts "sum = " + sum.to_s
sum = 0
cutcome.each { |pair| sum += pair[1] }
puts "sum = " + sum.to_s

文件的输入与输出

#!/usr/bin/ruby
 
val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

puts "gets语句"
puts "Enter a value :"
# val = gets
# puts val

puts "putc语句"
# str="Hello Ruby!"
# putc str

print "Hello World"
print "Good Morning"

puts "模式	描述"
puts "r	只读模式。文件指针被放置在文件的开头。这是默认模式。"
puts "r+	读写模式。文件指针被放置在文件的开头。"
puts "w	只写模式。如果文件存在，则重写文件。如果文件不存在，则创建一个新文件用于写入。"
puts "w+	读写模式。如果文件存在，则重写已存在的文件。如果文件不存在，则创建一个新文件用于读写。"
puts "a	只写模式。如果文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。如果文件不存在，则创建一个新文件用于写入。"
puts "a+	读写模式。如果文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。如果文件不存在，则创建一个新文件用于读写。"

File.open("file.rb", "r") do |aFile|
    if aFile
        content = aFile.sysread(20000)
        puts content
    else
        puts "Unable to open file!"
    end
end

aFile = File.new("file.rb", "r")
if aFile
   content = aFile.sysread(200)
   puts content
else
   puts "Unable to open file!"
end

aFile = File.new("file.rb", "r+")
if aFile
    aFile.syswrite("ABCDEFs a s\nimple text fil\ne for testin\ng purpose.")
else 
    puts "Uable to open file!"
end

puts "each_byte方法"
aFile = File.new("file.rb", "r+")
if aFile
    aFile.syswrite("ABCDEF")
    aFile.rewind
    aFile.each_byte { |ch| putc ch; putc ?. }
else 
    puts "Unable to open file!"
end

puts "\nIO.readlines"
arr = IO.readlines("file.rb")
puts arr[0]
puts arr[1]

puts "\nIO.foreach"
# IO.foreach("file.rb"){|block| puts block}

puts "重命名和删除文件"
# File.name("test1.txt", "text2.txt")
# File.delete("text2.txt")

puts "文件模式与所有权"
# file = File.new( "test.txt", "w" )
# file.chmod( 0755 )

puts "掩码	描述"
puts "0700	rwx 掩码，针对所有者"
puts "0400	r ，针对所有者"
puts "0200	w ，针对所有者"
puts "0100	x ，针对所有者"
puts "0070	rwx 掩码，针对所属组"
puts "0040	r ，针对所属组"
puts "0020	w ，针对所属组"
puts "0010	x ，针对所属组"
puts "0007	rwx 掩码，针对其他人"
puts "0004	r ，针对其他人"
puts "0002	w ，针对其他人"
puts "0001	x ，针对其他人"
puts "4000	执行时设置用户 ID"
puts "2000	执行时设置所属组 ID"
puts "1000	保存交换文本，甚至在使用后也会保存"



puts "文件查询"
# File.open("file.rb") if File::exists?{"file.rb"}
# File.file? {"text.txt"}
puts "一个目录"
# File::directory?("/usr/local/bin") # => true
# File::directory("file.rb")
# File.readable?("test.txt")
# File.writeble?("test.txt")
# File.executable?("test.txt")
# File.zero?("test.txt")
# File.size?("text.txt")
# File::ftype("test.txt")
# File::ctiime("test.txt")
# File::mtime("text.txt")
# File::atime("text.txt")

puts "Ruby中的目录"
# Dir.chdir("/usr/bin")
# puts Dir.pwd
# puts Dir.entries("/usr/bin").join(' ')
# Dir.foreach("/usr/bin") do |entry|
    # puts entry
# end

puts "创建目录"
# Dir.mkdir("myNewidr")
# Dir.mkdir("mynewdir", 755)

puts "删除目录"
# Dir.delete("testdir")

puts "创建文件&临时目录"
# require 'tmpdir'
# tempfilename = File.join(Dir.tmpdir, "tingtong")
# tempfile = File.new(tempfilename, "w")
# tempfile.puts "This is a temporary file"
# tempfile.close
# File.delete(tempfilename)

require 'tempfile'
# f = empfile.new('tingtong')
# f.puts "Hello"
# puts f.path
# f.close

puts "Ruby File 类和方法"
puts " 序号	方法 & 描述"
puts " 1	File::atime( path)"
puts " 返回 path 的最后访问时间。"
puts " 2	File::basename( path[, suffix])"
puts " 返回 path 末尾的文件名。如果指定了 suffix，则它会从文件名末尾被删除。"
puts " 例如：File.basename(\"/home/users/bin/ruby.exe\") #=> \"ruby.exe\""
puts " 3	File::blockdev?( path)"
puts " 如果 path 是一个块设备，则返回 true。"
puts " 4	File::chardev?( path)"
puts " 如果 path 是一个字符设备，则返回 true。"
puts " 5	File::chmod( mode, path...)"
puts " 改变指定文件的权限模式。"
puts " 6	File::chown( owner, group, path...)"
puts " 改变指定文件的所有者和所属组。"
puts " 7	File::ctime( path)"
puts " 返回 path 的最后一个 inode 更改时间。"
puts " 8	File::delete( path...)"
puts " File::unlink( path...)"
puts " 删除指定的文件。"
puts " 9	File::directory?( path)"
puts " 如果 path 是一个目录，则返回 true。"
puts " 10	File::dirname( path)"
puts " 返回 path 的目录部分，不包括最后的文件名。"
puts " 11	File::executable?( path)"
puts " 如果 path 是可执行的，则返回 true。"
puts " 12	File::executable_real?( path)"
puts " 如果 path 通过真正的用户权限是可执行的，则返回 true。"
puts " 13	File::exist?( path)"
puts " 如果 path 存在，则返回 true。"
puts " 1	File::expand_path( path[, dir])"
puts " 返回 path 的绝对路径，扩展 ~ 为进程所有者的主目录，~user 为用户的主目录。相对路径是相对于 dir 指定的目录，如果 dir 被省略则相对于当前工作目录。"
puts " 14	File::file?( path)"
puts " 如果 path 是一个普通文件，则返回 true。"
puts " 15	File::ftype( path)"
puts " 返回下列其中一个字符串，表示文件类型："
puts " file - 普通文件"
puts " directory - 目录"
puts " characterSpecial - 字符特殊文件"
puts " blockSpecial - 块特殊文件"
puts " fifo - 命名管道（FIFO）"
puts " link - 符号链接"
puts " socket - Socket"
puts " unknown - 未知的文件类型"
puts " 16	File::grpowned?( path)"
puts " 如果 path 由用户的所属组所有，则返回 true。"
puts " 17	File::join( item...)"
puts " 返回一个字符串，由指定的项连接在一起，并使用 File::Separator 进行分隔。"
puts " 例如：File::join(\" \", \"home\", \"usrs\", \"bin\") # => \"/home/usrs/bin\""
puts " 18	File::link( old, new)"
puts " 创建一个到文件 old 的硬链接。"
puts " 19	File::lstat( path)"
puts " 与 stat 相同，但是它返回自身符号链接上的信息，而不是所指向的文件。"
puts " 20	File::mtime( path)"
puts " 返回 path 的最后一次修改时间。"
puts " 21	File::new( path[, mode=\"r\"])"
puts " File::open( path[, mode=\"r\"])"
puts " File::open( path[, mode=\"r\"]) {|f| ...}"
puts " 打开文件。如果指定了块，则通过传递新文件作为参数来执行块。当块退出时，文件会自动关闭。这些方法有别于 Kernel.open，即使 path 是以 | 开头，后续的字符串也不会作为命令运行。"
puts " 22	File::owned?( path)"
puts " 如果 path 由有效的用户所有，则返回 true。"
puts " 23	File::pipe?( path)"
puts " 如果 path 是一个管道，则返回 true。"
puts " 24	File::readable?( path)"
puts " 如果 path 是可读的，则返回 true。"
puts " 25	File::readable_real?( path)"
puts " 如果 path 通过真正的用户权限是可读的，则返回 true。"
puts " 25	File::readlink( path)"
puts " 返回 path 所指向的文件。"
puts " 26	File::rename( old, new)"
puts " 改变文件名 old 为 new。"
puts " 27	File::setgid?( path)"
puts " 如果设置了 path 的 set-group-id 权限位，则返回 true。"
puts " 28	File::setuid?( path)"
puts " 如果设置了 path 的 set-user-id 权限位，则返回 true。"
puts " 29	File::size( path)"
puts " 返回 path 的文件大小。"
puts " 30	File::size?( path)"
puts " 返回 path 的文件大小，如果为 0 则返回 nil。"
puts " 31	File::socket?( path)"
puts " 如果 path 是一个 socket，则返回 true。"
puts " 32	File::split( path)"
puts " 返回一个数组，包含 path 的内容，path 被分成 File::dirname(path) 和 File::basename(path)。"
puts " 33	File::stat( path)"
puts " 返回 path 上带有信息的 File::Stat 对象。"
puts " 34	File::sticky?( path)"
puts " 如果设置了 path 的 sticky 位，则返回 true。"
puts " 35	File::symlink( old, new)"
puts " 创建一个指向文件 old 的符号链接。"
puts " 36	File::symlink?( path)"
puts " 如果 path 是一个符号链接，则返回 true。"
puts " 37	File::truncate( path, len)"
puts " 截断指定的文件为 len 字节。"
puts " 38	File::unlink( path...)"
puts " 删除 path 给定的文件。"
puts " 39	File::umask([ mask])"
puts " 如果未指定参数，则为该进程返回当前的 umask。如果指定了一个参数，则设置了 umask，并返回旧的 umask。"
puts " 40	File::utime( atime, mtime, path...)"
puts " 改变指定文件的访问和修改时间。"
puts " 41	File::writable?( path)"
puts " 如果 path 是可写的，则返回 true。"
puts " 42	File::writable_real?( path)"
puts " 如果 path 通过真正的用户权限是可写的，则返回 true。"
puts " 43	File::zero?( path)"
puts " 如果 path 的文件大小是 0，则返回 true。"
puts " "
puts " "



puts "序号	方法 & 描述"
puts "1	f.atime"
puts "返回 f 的最后访问时间。"
puts "2	f.chmode( mode)"
puts "改变 f 的权限模式。"
puts "3	f.chown( owner, group)"
puts "改变 f 的所有者和所属组。"
puts "4	f.ctime"
puts "返回 f 的最后一个 inode 更改时间。"
puts "5	f.flock( op)"
puts "调用 flock(2)。op 可以是 0 或一个逻辑值或 File 类常量 LOCK_EX、LOCK_NB、LOCK_SH 和 LOCK_UN。"
puts "6	f.lstat"
puts "与 stat 相同，但是它返回自身符号链接上的信息，而不是所指向的文件。"
puts "7	f.mtime"
puts "返回 f 的最后修改时间。"
puts "8	f.path"
puts "返回用于创建 f 的路径名。"
puts "9	f.reopen( path[, mode=\"r\"])"
puts "重新打开文件。"
puts "10	f.truncate( len)"
puts "截断 f 为 len 字节。"


puts "Ruby Dir 类和方法"
类方法
puts "序号	方法 & 描述"
puts "1	Dir[pat]"
puts "Dir::glob( pat)"
puts "返回一个数组，包含与指定的通配符模式 pat 匹配的文件名："
puts "* - 匹配包含 null 字符串的任意字符串"
puts "** - 递归地匹配任意字符串"
puts "? - 匹配任意单个字符"
puts "[...] - 匹配封闭字符中的任意一个"
puts "{a,b...} - 匹配字符串中的任意一个"
puts "Dir[\"foo.*\"] # 匹配 \"foo.c\"、 \"foo.rb\" 等等"
puts "Dir[\"foo.?\"] # 匹配 \"foo.c\"、 \"foo.h\" 等等"
puts "2	Dir::chdir( path)"
puts "改变当前目录。"
puts "3	Dir::chroot( path)"
puts "改变根目录（只允许超级用户）。并不是在所有的平台上都可用。"
puts "4	Dir::delete( path)"
puts "删除 path 指定的目录。目录必须是空的。"
puts "5	Dir::entries( path)"
puts "返回一个数组，包含目录 path 中的文件名。"
puts "6	Dir::foreach( path) {| f| ...}"
puts "为 path 指定的目录中的每个文件执行一次块。"
puts "7	Dir::getwd"
puts "Dir::pwd"
puts "返回当前目录。"
puts "8	Dir::mkdir( path[, mode=0777])"
puts "创建 path 指定的目录。权限模式可被 File::umask 的值修改，在 Win32 的平台上会被忽略。"
puts "9	Dir::new( path)"
puts "Dir::open( path)"
puts "Dir::open( path) {| dir| ...}"
puts "返回 path 的新目录对象。如果 open 给出一个块，则新目录对象会传到该块，块会在终止前关闭目录对象。"
puts "10	Dir::pwd"
puts "参见 Dir::getwd。"
puts "11	Dir::rmdir( path)"
puts "Dir::unlink( path)"
puts "Dir::delete( path)"
puts "删除 path 指定的目录。目录必须是空的。"



实例方法
假设 d 是 Dir 类的一个实例：

puts "序号	方法 & 描述"
puts "1	d.close"
puts "关闭目录流。"
puts "2	d.each {| f| ...}"
puts "为 d 中的每一个条目执行一次块。"
puts "3	d.pos"
puts "d.tell"
puts "返回 d 中的当前位置。"
puts "4	d.pos= offset"
puts "设置目录流中的位置。"
puts "5	d.pos= pos"
puts "d.seek(pos)"
puts "移动到 d 中的某个位置。pos 必须是一个由 d.pos 返回的值或 0。"
puts "6	d.read"
puts "返回 d 的下一个条目。"
puts "7	d.rewind"
puts "移动 d 中的位置到第一个条目。"
puts "8	d.seek(po s)"
puts "参见 d.pos=pos。"
puts "9	d.tell"
puts "参见 d.pos。"

Exception异常

#!/usr/bin/ruby

begin
    file = open("/unexistant_file")
    if file
       puts "File opened successfully"
    end
 rescue
       file = STDIN
 end
 puts
 puts file, "==", STDIN, "\n"


puts "使用retry语句"


begin
    file = open("/unexistant_file")
    if file
       puts "File opened successfully"
    end
 rescue
    fname = "existant_file"
    puts fname
   #  retry
end



# raise 
# 或
# raise "Error Message" 
# 或
# raise ExceptionType, "Error Message"
# 或
# raise ExceptionType, "Error Message" condition
begin  
   puts 'I am before the raise.'  
   raise 'An error has occurred.'  
   puts 'I am after the raise.'  
rescue  
   puts 'I am rescued.'  
end  
puts 'I am after the begin block.'

begin  
   raise 'A test exception.'  
 rescue Exception => e  
   puts e.message  
   puts e.backtrace.inspect  
 end


 使用 ensure 语句
 begin
   raise 'A test exception.'
 rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
 ensure
   puts "Ensuring execution"
 end

 使用 else 语句
begin
   # 抛出 'A test exception.'
   puts "I'm not raising exception"
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
  puts "Ensuring execution"
end


Catch 和 Throw
raise 和 rescue 的异常机制能在发生错误时放弃执行，有时候需要在正常处理时跳出一些深层嵌套的结构。此时 catch 和 throw 就派上用场了。
catch 定义了一个使用给定的名称（可以是 Symbol 或 String）作为标签的块。块会正常执行直到遇到一个 throw。

def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end
 
catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # 处理信息
end
promptAndGet("Name:")


类 Exception
Interrupt
NoMemoryError
SignalException
ScriptError
StandardError
SystemExit

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

File.open(path, "w") do |file|
begin
    # 写出数据 ...
rescue
    # 发生错误
    raise FileSaveError.new($!)
end
end