ruby的基本类型

ruby的基本类型包括数字，字符串，数组，符号，散了表，区间和正则表达式，这些基本类型都是以类的形式定义的

数字：

ruby中的数字分为整形(Integer)、浮点数(Float)、复数(Complex)这三种。其中整数又分为定整数(Fixnum)和大整数(Bignum)。

Integer

整数的书写例子：

#书写整数时，可根据需要在数字之间任意加入下划线而不会影响数字的值
a=123_456_789
puts a  #=>123456789
puts 0b100100  #二进制 =>36
puts 0123 #八进制 =>83
puts 0xa0 #十六进制 =>160

 

运算方法为

+,-,*,/  加减乘除

% 取模运算 4%3=>1

| , &, ^   按位与，按位或，按位异或

<<,>> 左右移位运算

<=> 比较整数大小，前者大于后者返回1，相等返回0，小于返回-1

常用方法

abs  返回数字的绝对值

chr  返回数字对应的ASCII编码对应的符号

times 循环整数此说的迭代方法  例：3.times{ |i| puts i  }

downto 从大到小进行迭代，使用方法如： 5.downto(1){ |i|  puts i }   输出： 5 4 3 2 1

upto 从小到大进行迭代，使用方法如： 2.upto(5){ |i| puts i }  输出： 2 3 4 5

to_s 将正说变为字符串类型

Float

浮点数的运算与整数类似，但有几个特殊的方法

ceil  返回比浮点数大的最小整数

floor  返回比浮点数小的最大整数

round 对浮点数四舍五入为一个整数

to_i  返回截取掉小数点后面数字后的整数

 

Ruby内置有一个Math的模块，包含常见的数字相关运算的支持。

 

字符串String

ruby中通常使用单引号或者双引号包含 例如：

str = "this is a string"
str = 'this is a string

 

还可以使用%，%q,%Q表示法 例如：

puts %{test\t,"this is a test"}
puts %q{test\t,this ia a "test"}
puts %Q{test\t,this is a 'test'}

输出

test        ,"this is a test"
test\t,this ia a "test"
test        ,this is a 'test'

可以看出，%q是不支持转义字符的

ruby还提供了一个称为here文档的字符串标示方法，适合显示多行的大段文字 例如：

str = <<here
输入多行文本
输入多行文本
输入多行文本
输入多行文本
here

 输出

输入多行文本
输入多行文本
输入多行文本
输入多行文本

 字符串的基本操作

puts "abcdfe"[0]   #输出第0位的字符
puts "abcdfe"[0,2] #输出第0为到第0+2-1位的字符串
puts "abcdfe"[0..2] #输出第0位到第2位的字符串
puts "abcdfe"[0]="2" #将第0位的字符替换为2
puts "abcdfe"*2  #返回原来字符串重复2次后的新字符串
puts "abcdfe"+"hello" #将原来的字符串后面加上hello
puts "abcdfe"<<"hello" #同上

 输出：

a
ab
abc
2
abcdfeabcdfe
abcdfehello
abcdfehello

 字符串的常用方法

str = "abcdef"
str.length
str.size
str.concat(obj) #追加字符串，如果obj为数字并且在0-255之间则运算前自动转换为一个相应的字符
str.capitalize #将字符串首字母大写，其他字符小写
str.delete("abf")
str.each_byte { |fixnum|  puts fixnum} #对字符串的每个字节进行迭代
str.each_char { |cstr| puts cstr } #对字符进行迭代
str.each_line { |substr|  } #对每行进行迭代
str.strip #去除字符串首尾的非可见字符，返回新字符串.非破坏形方法
str.downcase #字符串转换为小写
str.upcase #字符串转换为大写
str.include?(string) #如果字符串包含string则返回true，否则返回false
str.index(string) #返回字符串string首次出现的位置，rindex方法从后开始检索
str.reverse #将字符串顺序反转
str.split(pattern) #基于分隔符pattern将字符串str分割成若干子字符串，以数组形式返回
str.scan(pattern) #检索出str中所有匹配pattern的子字符串，并以数组的形式返回

 

符号Symbo l

符号是Symbol类的实例，通常情况下，使用冒号加上一个标示符即可创建一个符号。

:"a symbol"
:"()22"

 符号不同于字符串的地方是：相同标示符在任何地方均引用的是一个相同的实例。而相同的字符串则可能是不同的对象

符号的优点是内存消耗较少，适合于需要保证名称和变量一一对应的情况。实际使用中，如枚举值，关键字都会选择符号

 

可枚举模块的一些方法

#enum.all?{|obj| block} 判断是否集合中所有元素都满足某个条件
[1,2,3,4].all? { |i| i>2  } #返回false
#enum.any?{|obj| block} 判断是否集合中有任意一个元素满足条件
[1,2,3,4].any? { |i| i>3  } #true
#enum.collect{|obj| block} 集合中的每个元素调用block的结果，以数组的形式返回
[1,2,3,4].collect { |i| i+1  } #[2,3,4,5]
#enum.each_with_index{|obj,i|block} obj为集合中的元素，i为该元素的下标
[0,1,2,3].each_with_index { |obj,i|puts "#{obj}--#{i}"  }
#enum.find(ifnone=nik){|ojb| block} 返回第一个条件成立的元素
[0,1,2,3].find { |obj| obj=3  }
#enum.find_all{|obj| block} 找出所有符合条件的元素，返回一个数组
[0,1,2,3].find_all { |obj| obj>1  } #[2,3]
#enum.include?(obj) 检测集合中是否包含obj
[0,1,2,3].include?(1) #true
#enum.inject(initial=nil){|memo,obj|block} 每一步memo参数都会被设置为block的结果，传入下一步运算
[1,2,3,4].inject { |memo,obj| memo+obj  } #返回10
#enum.partition{|obj| block} 按照某个条件分割为俩个数组并返回
[1,2,3,4].partition { |i| i>2  } #返回[[1,2],[3,4]]
#enum.max 返回集合中最大的元素
[1,2,3,4].max #4
#enum.max{|a,b| block} 自定义比较内容
puts [1,2,3,4].max { |a,b| a<=>b  }
#enum.min和enum.min{|a,b| block} 参考如上
#enum.sort,enum.sort{|a,b| block} 给集合排序 默认是按照小>大的顺序
[4,3,2,1].sort #[1,2,3,4]
#enum.sort_by{|obj| block}根据某种规则对集合中的元素进行排序
["str","strstr","strstrstr"].sort_by { |obj| obj.length  }

 关于Array

创建数组对象最标准的方式是：a = Array.new

或者 a = Array.new(5) 创建包含5个nil元素的数组

或者a = Array.new(5,1) 创建包含5个1的数组

最简单的方式是a = [] 或者 a = [1,1,1,1]

或者使用%w，可以创建不包含空格的数组

如：%w(tt ww kk ss) 返回  ["tt","ww","kk","ss"]

Array还具有并行赋值的能力，把等号右边的元素依次赋值给左边

如：

a,b,c = ["string",20,[1,2]]
puts "#{a} #{b} #{c}"

 输出

string 20 [1, 2]

 

 

 

评论

2 楼 lliiqiang 2014-09-02  

分析很难,好的规则持久，靠某个方法条件局限不能证明长久

1 楼 lliiqiang 2014-09-02  

当事件发生的时候，事件多个细节证明因素要被单独分析，这样能够分析每一个包含的信息,当然假设性分析需要严密思维，假设性未必正确，但是也未必是带来危害的，有的是无亏本的.
总之科学是最客观的.