Ruby入门学习之三

  ~_~学习Ruby第三天。主要内容为 Exception、Numeric类、Array类、String类。

    1 Exception

puts("-----------------------begin rescue end--------------------")
#获取文件的行数、单词数、字节数
ltotal = 0				
wtotal = 0
ctotal = 0
ARGV.each{|file|
  begin 
    input = open(file)
    l = 0
    w = 0
    c = 0
    while line = input.gets
      l += 1
      c += line.size
      line.sub!(/^\s+/,"")
      ary = line.split(/\s+/).size
      w += ary.size
    end
    input.close
    printf("%8d %8d %8d %s\n",l,w,c,file)
    ltotal += l
    ctotal += c
    wtotal += w
  rescue => ex
    print ex.message,"\n"
  end
}
printf("%8d %8d %8d %s\n",ltotal,wtotal,ctotal,"total")
puts("-----------------------begin rescue ensure end--------------------")
#copy操作
def copy(from,to)
  src = open(from)
  begin 
    dst = open(to,"w")
    data = src.read
    dst.write(data)
    dst.close
  rescue 
  ensure
    src.close
  end
end
#read操作
def read(file)
  begin 
    input = open(file)
    while line = input.gets
      print line
    end
  rescue 

  ensure
    input.close
  end
end
copy("a.txt","b.txt")
read("b.txt")
puts "\n"
p n = Integer("abc") rescue 0
p n = Integer("1") rescue 0
puts("-----------------------catch throw--------------------")
def test_throw
  throw :test
end

catch(:test){
  puts "aaa"			#会输出
  test_throw
  puts "bbb"			#不会输出
}

catch(:exit){
  val = 10
  loop{
    puts "外层循环"
    loop{
      val -= 1
      if val == 0
        throw :exit
      end
      print "内层循环",val,"\n"
    }
  }
}

   Ruby的Exception处理的begin~rescue~ensure~end部分与java的try~catch~finally相似

   不同之处在于Ruby的throw、catch有点像goto语句

 

    2 Numeric

 

puts("-----------------------Integer--------------------")
p 2 ** 1000				#**表示幂乘
puts("-----------------------数值常数-------------------")
p 1_23_45
p 0x10				#十六进制
p 010				#八进制
p 0b10				#二进制
p 0d10				#十进制
p 10				#十进制
p 1_234.0e-4			#浮点数
p ?a				#a的ASCII码
p ?\t				#TAB键的ASCII码
p ?\C-a				#Ctrl+a的指令码
puts("-----------------------练习------------------------")
def cels2fahr(num)
  num * 9 / 5.0 + 32
end
p cels2fahr(23)			#=>73.4

def fahr2cels(num)
  (num - 32) * 5.0 / 9.0
end
p fahr2cels(73.4)		#=>23.0
for i in 1..100
  printf("%d %f\n",i,fahr2cels(i))
end

def dice(m)
  rand(m) + 1
end
p dice(6)

def prime?(num)
  if num == 2 || num ==3 || num == 5
    return true
  end
  j = Math.sqrt(num).to_i
 
  for i in 2..j
    if num % i ==0
      return false
    end
  end
  
  if i >= j
    return true
  end
end
p prime?(6)

    Numeric类的架构为 Numeric ->Integer + Float, Integer->Fixnum + Bignum

 

 

   3 Array

=begin 
2012-5-8 18:08
=end
puts("-----------------------建立数组--------------------")
a = Array.new
p a
a = Array.new(5)
p a
a = Array.new(5,"ruby")
p a 

lang = %w(abc def hi)
p lang
lang = %w<abc def hi>
p lang 
lang = %w|abc def hi|
p lang

color_table = {"white" => "#FFF","black" => "#000"}
p color_table.to_a

p "abc def ghi jkl mno pqr stu".split()
puts("----------------------索引的用法---------------------")
alpha = ["a","b","c","d","e"]
p alpha[2]				#检索一个元素
p alpha[2..4]				#检索多个连续元素
p alpha[2,3]				#检索多个连续元素

alpha[2] = "z"				#修改一个元素
p alpha
alpha[2..4] = ["x","y","z"]		#修改多个连续元素
p alpha
alpha[2,3] = ["X","Y","Z"]		#修改多个连续元素
p alpha

alpha[2,0] = ["A","B","C"]		#插入元素
p alpha

alpha = %W(a b c d e f)
p alpha.values_at(1,3,5)		#多个索引建立数组
puts("--------------------集合操作数组-----------------------")
set01 = [1,2,3,4,5]
set02 = [1,2,3]
p set01 & set02				#集合交集
p set01 | set02				#集合并集
p set01 - set02				#集合差
p set01 + set02				#集合连接
puts("-------------------list操作数组------------------------")
stack = [1,2,3,4,5]
p stack.push(6)
p stack.pop
p stack.last
p stack.unshift(0)
p stack.shift
p stack.first
puts("------------------数组主要方法-------------------------")
=begin 
数据加入数组
=end
a = [1,2,3,4,5]

a.unshift(0)				#前端加入元素
p a

a.push(6)				#后端加入元素
p a
a << 6
p a

a.concat([7,8])				#连接两个数组 破坏性方法
p a
p a + [7,8]				#连接两个数组 非破坏性方法

a[0..2] = 9
p a
a[0..2] = [1,2]
p a
=begin 
删除数组元素
=end
a = [1,nil,2,nil,3,4,5]
b = a
a.compact!				#破坏性方法
p a
p b

a = [1,nil,2,nil,3,4,5]			#非破坏性方法
b = a
p a.compact
p b

a = [1,2,3,3,4]
a.delete(3)
p a
a.delete_at(2)
p a
a.delete_if{|item|
  item >= 2
}
p a

a = [1,2,3,4]
a.slice!(0,2)
p a

a = [1,2,3,2,2]
a.uniq!
p a

a = [1,2,3,4]
a.shift
p a 
a.pop
p a
=begin 
替换数组元素 
=end
a = [1,2,3,4,5]
p a
a.collect!{|item|
  item * 2
}
p a
a.map!{|item|
  item / 2
}
p a

a.fill(9,1..3)
p a 
a.fill(8,1,3)
p a
a.fill(7,1)
p a
a.fill(0)
p a

a = [[1,2],[3,[4,5]],6]
a.flatten!
p a

a.reverse!
p a

a.sort!
p a

=begin 
小心初始化
=end
a = Array.new(3,[0,0,0])
a[0][1] = 1
p a					#=>[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

a = Array.new(3){
  [0,0,0]
}
a[0][1] = 1
p a					#=>[[0, 1, 0], [0, 0, 0], [0, 0, 0]]
#并行处理多个数组 zip 方法
a1 = [1,2,3]
a2 = [11,22,33]
a3 = [111,222,333]
result = []
a1.zip(a2,a3){|a,b,c|
  result << a + b + c
}
p result
puts("--------------------练习-------------------------")
a = Array.new(100){|index|
  index + 1
}
p a
b = a.collect{|item|
  item * 100
}
p b

c = a.reject{|item|
  item % 3 != 0
}
p c
p a
a.reverse!
p a
a.sort!{|x,y|
  x <=> y
}
p a
a = a.sort_by{|i|
  -i
}
p a

a = [1,2,"a",3," "]
result = 0
a.each{|item|
  if Numeric === item
    result += item
  end
}
p result

a = Array.new(100){|i|
  rand(100) + 1
}
p a

ary = Array.new(100){|i|
  i + 1
}
result = Array.new
10.times{|i|
  result << ary[(i * 10)..(i * 10 + 9)]
}
p result
puts("-----------------------------")
def cal(num1,num2)
  result = []
  num1.size.times{|i|
    result << num1[i] + num2[i]
  }
  return result
end
def sum_array(num1,num2)
  if num1.size < num2.size
    cal(num1,num2)
  else
    cal(num2,num1)
  end
end
p sum_array([1,2],[3,4,5])
p sum_array([1,2,2,8],[3,4,5])
puts("-----------------------------")
def fun(ary)
  ary_size = ary.size
  if ary_size % 2 != 0
    return false
  end
  stack = []
  ary.each{|item|
    if item == "{" || item == "["
      stack.push(item)
      p stack
    else 
      s = stack.pop
      if item == "}" && s != "{" || item == "]" && s != "["
        return false
      end
      
    end
    
  }
  p stack.size 
  if stack.size == 0 
    return true
  else 
    return false
  end

end

p fun(["{","}"])
p fun(["{","]","[","}"])

  这部分需要注意的是 破坏性方法 与 非破坏性方法

  所谓 破坏性方法指的是该方法会改变原来的对象，指向该对象的所有引用调用该对象时已经不再为原来的对象。Ruby中一般方法后面加有!均为破坏性方法。

   还有需要注意的是 迭代器部分

Array的迭代器有collect，map（功能与collect一样），each，都是对数组中元素一一进行操作，非下标。

Array.new(100){|i|i + 1}中的i为下标。

 

4 String

 

=begin 
字符串操作
=end
#建立字符串方法
moji = "字符串"
str1 = "这也是#{moji}"	#=>"这也是字符串"
p str1
str2 = '这也是#{moji}'	#=>"这也是#{moji}"
p str2
desc = %Q{Ruby "dsds"}
p desc
str = %q{dds'ds'}
p str

10.times{|i|
  10.times{|j|
    print <<"EOB"
i: #{i}
j: #{j}
i * j = #{i * j}
EOB
  }
}
#使用 Here Document(嵌入文档)
print <<"EOB"
dsda
12
EOB

#获取字符串长度
p "abc".length		#返回字节数
p "abc".size		#返回字节数
p "中国".split(//e).size #返回文字数

#检查字符串长度是不是0
p "".empty?		#true
p "foo".empty?		#false

colum = "This,is,a,big,mistake".split(/,/)
p colum
p colum.to_s

str = "This is a big mistake".unpack("a10a2a*")
p str

a = "hello"
b = "world"
c = a
a = a + b		#建立了新对象
p a			#a指向了新的对象
p c			#c所指向的对象没有变

a = "hello"
b = "world"
c = a
a << b			#并没有建立新对象
p a			#a还是指向原有的对象
p c			#c也是

str = "abcd"
p str[0]
p str[0].chr
p str[0..2]
s = "甲乙丙丁"
p s.split(//e)[0]

str = "abcd"
p str.chop		#=>"abc" chop 不管如何都会删除最后一个字符
p str.chomp		#=>"abcd"chomp 只会删除行尾的换行字符
str = "abcd\n"
p str.chop		#=>"abcd"
p str.chomp		#=>"abcd"

begin 
  file = open(ARGV[0])
  while line = file.gets
    line.chomp!
    print line
  end
rescue 
  
ensure
  file.close
end

#字符串取代 sub只取代第一次遇到的，gsub全部
str = "aaaaaaaa"
p str.sub("aa","12")	#=>"12aaaaaa"
p str.gsub("aa","12")	#=>"12121212"

#查找字符串 index从左往右 rindex从右往左
#返回值为首次的下标
str = "ababababcdcd"
p str.index("abab")	#=>0
p str.rindex("abab")	#=>4
#String与Array共有的方法
str = "abc"
str[1..3] = "C"
p str

str = "Hello,Ruby."
p str.slice!(-1).chr
p str.slice!(5..5)
p str.slice!(0,5)
p str

a = "123"
p a + "456"
p a
p a.concat("78")
p a

p a.delete!("1289")	#delete方法如果参数中含有字符串中没有的字符不会报错
p a
p a.reverse

str = " aa bb cc "
p str.strip!		#=>"aa bb cc"

str = "Ruby Language"
p str.upcase		#=>"RUBY LANGUAGE"
p str.downcase		#=>"ruby language"
p str.swapcase		#=>"rUBY lANGUAGE"
p str.capitalize	#=>"Ruby language"
#tr方法可以一次性替换多个字符 
p "abcdefg".tr("b","B")
p "abcdefg".tr("be","BE")
p "abcdefg".tr("a-d","A-D")
puts("----------------------------练习--------------------")
str = "Ruby is an object oritented programming language"
p ary = str.split()
p ary.sort
p ary.sort_by{|i|
  i.upcase
}
def begin_upcase(str)
  ary = str.split()
  result = ""
#  str.slice!(0..str.size)
  ary.collect!{|item|
     result << item.capitalize << " "
  }
  return result.to_s.chop!
end

p begin_upcase(str)

def cal_aph(str)
cal = Array.new(55,0)
for i in 0..str.size - 1
 
  if " " == str[i].chr
    cal[0] += 1
  
  elsif ('A'..'Z') === str[i].chr
    cal[str[i] - 64] += 1
  elsif ('a'..'z') === str[i].chr
    cal[str[i] - 69] += 1
  end
end

for i in 0..54
  if cal[i] != 0
    if i == 0
      print "' ':"
    elsif i <= 27
      print ("'",(i + 64).chr,"':")
    else
      print ("'",(i + 69).chr,"':")
    end
    cal[i].times{
        print("*")
      }
    print("\n")
  end
end
end

cal_aph(str)
#不用Numeric提供的方法将"1234"转化为1234
def num2astrisk(str)
  n = str.size
  result = 0
  for i in 0..n-1
    temp = 1
    (n - i - 1).times{
      temp *= 10
    }
    result += (str[i].to_i - 48) * temp
  end
  result.times{
    print "*"
  }
  return result
end
p num2astrisk("123")

#注意点
=begin 
str[i]返回的是数值
因此字符转化为数值
可以使用 Integer("1"),也可以减去相应的ascii码值
=end
p Integer("2")		#=>2

  

String类和Array类 细节问题很多。两者有一些相似的方法，两者可以进行相互的转化。:)