Ruby学习笔记-基础语法

#!/usr/bin/ruby -w

# puts "test words!"


################Here Document
# print <<EOF

# 第一种创建here document 的方法。
# 多行字符串，类似前端中的 pre?

# EOF

# print <<"EOF"
# 	第二种创建here document 的方法。
# 	多行字符串
# EOF






###数据类型

# # print("a".ord) #小写字母a的字符编码
# # print("\n")
# # print("A".ord) 
# #如以下的0,1_000_000,0xa等 
# a1=0 
 
# #带千分符的整型 
# a2=1_000_000 
 
# #其它进制的表示 
# a3=0xa 
# puts a1
# puts a2 
# puts a3 

######   #{表达式} 将自动计算 会自动从 { 开始,找到下一个 } 结束
# #   puts "相乘:10*10*10"
# puts "相乘:#{10*10*10}"


# name = "Ruby"
# puts name
# puts "#{name+",OK"}"
# puts "#{1+2}"


#数组遍历
# ary = [ "fred", 10, 3.14, "This is a string", "last element", ]
# ary.each do |i|
#     puts i
# end

# puts ary[3]
# puts ary[0]

# #哈希类型 大括号内放置 键值对： 键 ==> 值 ，逗号隔开
# hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
# hsh.each do |key, value|
#     print key, " is ", value, "\n"
# end

# hsh = peopleInfo =  { "Jack" => 21, "Jane" => 23, "Mike" => 40 }
# hsh.each do |key, value|
#     print key, " is ", value, " years old\n"
# end


# #范围类型范围 (1..5) 意味着它包含值 1, 2, 3, 4, 5，范围 (1...5) 意味着它包含值 1, 2, 3, 4 。 两点包头包尾，三点包头不包尾
# (10..15).each do |n|
#     print n, ' '
# print "\n"
# end
# print "\n"

# (10...15).each do |n|
#     print n, ' '
# print "\n"
# end


############### Ruby 类 和 对象
=begin
Ruby 类中的变量
Ruby 提供了四种类型的变量：

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

#
# Class Vehicle
# {
#    Number no_of_wheels
#    Number horsepower
#    Characters type_of_tank
#    Number Capacity

#    Function speeding
#    {
   	
#    }

#    Function driving
#    {
   
#    }

#    Function halting
#    {
   	
#    }
# }
# end


# Class Customer{
# 	#实例变量
# 	@@no_of_customer = 0
# 	# def initialize(id,name,addr)
# 	# 	@cust_id = id
# 	# 	@cust_name = name
# 	# 	@cust_addr = addr
# 	# end

# 	def putsHello
# 		pust "testPuts hello"
# 	end

# 	# def putsInfo
# 	# 	puts @cust_id
# 	# end
# }


# cust1 = Customer. new
# curt1.hello

# # cust2 = Customer.new("2","Jane","Shanghai")

 
# class Sample
#    def hello
#       puts "Hello Ruby!"
#    end
# end
 
# # 使用上面的类来创建对象
# object = Sample. new
# object.hello


## Ruby 变量
# class Customer
# 	@@no_of_customer = 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_customer += 1
# 		puts "一共输入信息有 #@@no_of_customer 个;"
# 	end
# end

# cust1 = Customer.new("1", "John", "Beijing")
# cust2 = Customer.new("2", "Poul", "Shanghai")


# cust1.display_details()
# cust1.total_no_of_customers()

# cust2.display_details()
# cust2.total_no_of_customers()

# $global_variable1 = 100 #全局变量
# class Class1
# 	def print_globalV1
# 		puts "全局变量在 class1 中的值为 #$global_variable1"
# 		$global_variable1 += 100
# 		puts "修改后的全局变量 #$global_variable1"
# 	end
# end

# class Class2
# 	def print_globalV1
# 		puts "class2 #$global_variable1"
# 	end
# end

# c1 = Class1.new()
# c1.print_globalV1
# c2 = Class2.new
# c2.print_globalV1

#### Ruby 运算符
=begin
对于每个运算符（+ - * / % ** & | ^ << >> && ||），都有一个相对应的缩写赋值运算符（+= -= 等等）
=end

#一些特殊的比较运算符 <=>	
#===	用于测试 case 语句的 when 子句内的相等。
#.eql?	如果接收器和参数具有相同的类型和相等的值，则返回 true。
#equal?	如果接收器和参数具有相同的对象 id，则返回 true。
# puts 1.eql?(1.0)

#Ruby defined? 运算符
#defined? variable # 如果 variable 已经初始化，则为 True

 

# Ruby条件判断
# ## if...else 语句：if 表达式用于条件执行。值 false 和 nil 为假，其他值都为真。请注意，Ruby 使用 elsif，不是使用 else if 和 elif。

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


# #Ruby 循环
# $i = 0
# $num = 5


####while 语句
# while $i < $num do 
# 	puts("在循环语句语句中i = #{$i}")
# 	$i += 1
# end

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

###until 语句:可以理解为知道...时不再操作
# until $i > $num do 
# 	puts ("在循环语句中 i = #{$i}")
# 	$i += 1
# end

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


#Ruby 方法
### 位置传参
# def testMethod(a1 = "书籍1",a2 = "书籍2")
# 	puts("书籍1为 #{a1}")
# 	puts("书籍2为 #{a2}")
# 	return a1
# end

# testMethod "Ruby入门","Ruby放弃" #位置传参
# testMethod #不传参，默认

# returnBook = testMethod
# puts "返回的书籍为，#{returnBook}"

### 动态传参,
# def sample(*params)
# 	puts "参数个数为 #{params.length}"
# 	for i in 0...params.length
# 		puts "参数值分别为 #{params[i]}"
# 	end
# end
# sample "Jason","1","2","testParams"

# Ruby alias 语句
# 这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义。
# 为编号的全局变量（$1, $2,...）起别名是被禁止的。重写内置的全局变量可能会导致严重的问题。
# alias 方法名 方法名
# alias 全局变量 全局变量


#Ruby 块
# 块中的代码总是包含在大括号 {} 内。
# 块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test，那么您要使用函数 test 来调用这个块。

#yield语句
# def testYield
# 	puts "testYield 方法内"
# 	yield
# 	puts "又回到testYield方法内"
# 	yield
# end
# testYield {puts "你在块内"}  #块名 与 块代码

#yield 带有参数
##多个参数 yield a, b  和  test {|a, b| statement}

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


###################### BEGIN END 及 注释
# puts "主程序，中间执行"

# END {
# 	puts "最后执行"
# }

# BEGIN {
# 	puts "最先执行\n";
# }



#模块 ： 函数名称相同，但是功能不同 ：方法重构？
# 一种把方法、类和常量组合在一起的方式。模块（Module）为您提供了两大好处。
# 模块提供了一个命名空间和避免名字冲突。
# 模块实现了 mixin 装置。


#require 语句
#require filename #文件名.rb 不是必须的


#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


#数组
# names = Array.new(4, "mac") 
# puts "#{names}"

# nums = Array.new(10) { |e| e = e * 2 }
# puts "#{nums}" #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


# digits = Array(0..9)
# puts "#{digits}"

# #数组内置方法at 等...
# digits = Array(1..10) 
# num = digits.at(6)
# puts "#{num}"



#日期 & 时间（Date & Time）
# time1 = Time.new
# time2 = Time.now

# puts "当前时间:" + time1.inspect
# puts "当前时间:" + time2.inspect
# 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"：时区名称

#迭代器
# ##each 迭代器:each 迭代器返回数组或哈希的所有元素。
# arr1 = [1,2,3,4,5,6]
# # arr1.each do |i|
# # 	puts i
# # end

# ##collect 迭代器:总是与一个块关联。collect 方法返回整个集合，不管它是数组或者是哈希
# arr2 = Array.new
# arr2 = arr1.collect{ |x|x}
# puts arr2




# 输入与输出 （IO操作）
#puts gets putc
# puts "输入任意内容继续:"
# val = gets
# print "你输入的内容为：" + val

# str  = "123456"
# putc str #1

#打开和关闭文件
##open,new 区别：不同点是 File.open 方法可与块关联，而 File.new 方法不能。
# File.open("./test1.txt", "r") do |aFile|
#    # ... process the file
# end


# aFile = File.new("./test1.txt", "r")
# if aFile
#    content = aFile.sysread(1000)
#    puts content
# else
#    puts "Unable to open file!"
# end

# aFile = File.new("inputText.txt","a+")
# if aFile
# 	aFile.syswrite("追加文本")
# else
# 	puts "Unable to open file!"
# end

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

###IO.readlines 方法
# arr = IO.readlines("test1.txt")
# puts arr[0]
# puts arr[2]


# 重命名和删除文件  rename 和 delete
# # 重命名文件 test1.txt 为 test2.txt
# File.rename( "test1.txt", "test2.txt" )
# # 删除文件 test2.txt
# File.delete("text2.txt")
# 文件模式与所有权
# file = File.new( "test2.txt", "w" )
# file.chmod(0777)
# #检查文件是否已存在：
# File.open("file.rb") if File::exists?( "file.rb" )
# #下面的命令检查给定的文件名是否是一个目录：
# 一个目录
# puts File::directory?( "./testFloder" ) # => true
# # 一个文件
# puts File::directory?( "./support.rb" ) # => false

#检查文件是否可读、可写、可执行
# puts File.readable?( "testChmod.txt" )   # => true
# puts File.writable?( "testChmod.txt" )   # => true
# puts File.executable?( "testChmod.txt" ) # => false
# #文件是否大小为零： 即文件为空
# puts File.zero?( "testChmod.txt" )      # => true
#获取文件大小
# puts File.size?( "support.rb" )     # => 1002
#检测文件类型
# puts File::ftype( "support.rb" )     # => file
# puts File::ftype( "testFloder" )     # => directory


#Ruby 中的目录
#浏览目录:改变目录
# Dir.chdir("/usr/bin") #改变当前目录为 /usr/bin。
#获取当前路径
# puts Dir.pwd
# 获取指定目录内的文件和目录列表：
# puts Dir.entries(Dir.pwd).join(' ') #方法一
# Dir.foreach(Dir.pwd) do |entry| #方法二
#    puts entry
# end
# puts Dir["E:/RubyStudyCode/code/*"] #方法三
#创建目录#已存在会报错
# Dir.mkdir("代码创建目录测试")
#删除目录 #不存在会报错
# Dir.delete("代码创建目录测试")

# 创建文件 & 临时目录：临时文件是那些在程序执行过程中被简单地创建，但不会永久性存储的信息。
# 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)


#ruby异常 对比Python ：try except else finally 
##捕获异常方法
# begin
# 	Dir.mkdir("代码创建目录测试")
# 	# raise..
# rescue
# 	puts "xx文件夹创建失败"
# end

#retry语句: rescue 块捕获异常，然后使用 retry 语句从开头开始执行 begin 块
# begin
# 	Dir.mkdir("代码创建目录测试")
# 	puts "文件夹 代码创建目录测试 创建成功"
# 	# raise..
# rescue
# 	puts "xx文件夹创建失败"
# 	Dir.delete("代码创建目录测试")
# 	retry
# end

#raise 语句：有异常就抛出，并且不处理异常之后的代码
# 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.'

# ensure 语句 ：类似finally语句
# begin
#   raise 'A test exception.'
# rescue Exception => e
#   puts e.message
#   puts e.backtrace.inspect
# ensure
#   puts "不管有没有异常，都一定会运行到这里"
# end

#else 语句：它一般是放置在 rescue 子句之后，任意 ensure 之前。
# 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
# throw :lablename
# #.. 这不会被执行
# catch :lablename do
# #.. 在遇到一个 throw 后匹配将被执行的 catch
# end
 
# 或
# throw :lablename condition
# #.. 这不会被执行
# catch :lablename do
# #.. 在遇到一个 throw 后匹配将被执行的 catch
# end

# eg:如果用户键入 '!' 回应任何提示，使用一个 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:")

转载注明转自:https://leejason.blog.csdn.net/article/details/110477156