ruby语法

 

（一）Ruby中一切都是对象，包括一个常数.
比如可以用.class属性来查看一个对象的类型，你可以看下1.class，会发现常数1的类型是Fixnum，1不过是Fixnum的一个实例。还可以使用-37这个Fixnum的实例方法abs来取得绝对值：-37.abs()会返回37
又如输入一个1.1.class，会返回Float。

（二）Ruby语法
Ruby中的类以class开始 以end结束，类名首字母的约定是大写。
Ruby中的方法以def开始 以end结束，方法名首字母的约定是小写。
Ruby中的局部变量名首字母的约定是小写。
Ruby中的构造函数名称为initialize。
Ruby中的成员变量(实例变量)前导@符，在initialize里进行声明与初始化。
Ruby中的属性用attr_writer和attr_reader声明，分别对应c#的set,get，使用了attr_accessor是可读也可写
Ruby中的全局变量前导$符。
Ruby中的常数（常量）用大写字母开头，约定是全部大写。

Ruby中任何的表达式都会返回值，sample

class Rectangle
  def initialize(wdth, hgt)
    @width = wdth
    @height = hgt
  end
  def width=(wdth)
    @width = wdth
  end
  
end

r = Rectangle.new(2,3)
puts r.width = 5 #output 5
puts r.width # error! because the width not support read

继续补充下attr_accessor的使用，sample

class Rectangle
  attr_accessor :width
  attr_accessor :height
  attr_accessor :width2
  attr_accessor :height2
  
  def initialize(wdth, hgt)
    @width = wdth
    @height = hgt
  end
  
  def area()
    return @width * @height
  end
  
  def area2()
    return @width2 * @height2
  end
  
  
end

r = Rectangle.new(2,3)
r.width = 5 # give samename's variable value
r.height = 5 
puts r.area() #outputs is 25  

r.width2 = 6 # not samename's variable  create
r.height2 = 6 
puts r.area2() # outputs is 36

上面的代码说明了，在使用attr_accessor的时候，会寻找是否有同名的成员变量，如果有则访问同名成员变量，如果没有会默认创建一个前导@的成员变量

 （三）神奇的操作符重载
Ruby支持操作符重载，而且很神奇！

class Rectangle
  attr_accessor :width
  attr_accessor :height
  
  def initialize(wdth, hgt)
    @width = wdth
    @height = hgt
  end
  
  def area()
    return @width * @height
  end
  
  def +(addRectangle)
    return self.area + addRectangle.area
  end

end

r1 = Rectangle.new(2,2)
r2 = Rectangle.new(3,3)
puts r1+r2 # operator override
puts r1+(r2)
puts r1.+(r2) # standard function calling format

神奇吧，其实把+号理解为一个函数的名字最好不过了，就像最后一个写法，哈哈。

（四）参数的传递
参数的传递中有默认值与可变长参数两个比较有特点的地方，其他语言有的，ruby也有。

1.参数的默认值
默认值的设置很简单，与其他语言一样，sample

class Rectangle
  attr_accessor :width
  attr_accessor :height
  
  def initialize(wdth = 2, hgt = 2)
    @width = wdth
    @height = hgt
  end
  
  def area()
    return @width * @height
  end

end

r1 = Rectangle.new
puts r1.area

看到了吧，使用默认值了

2.可选参数，可变长参数 sample

class ParamSample
  def sayHello(*names)
      puts names.class
      puts "Hello #{names.join(",")}!"
  end
  
end

ps = ParamSample.new
ps.sayHello #output Array Hello !
ps.sayHello("lee","snake") #output Array Hello lee,snake!

可以看出，可变长参数前缀*号，可变长参数的实质是一个Array，呵呵。

 

 

 

（一）类变量以及类方法
sample code

class BankAccount
  @@interestRate = 6.5
  def BankAccount.getInterestRate()
    @@interestRate
  end
  attr_accessor :balance
  def initialize(bal)
    @balance = bal
  end
end

puts BankAccount.getInterestRate()

以上代码中描述了如何定义类变量以及如何访问类变量

 

 

 

Ruby的成员访问修饰关键字分为三种，与c#一样。
1 private 只能为该对象所调用的方法
2 protected 只能为该对象及其子对象所调用的方法
3 public 可以让任何对象所调用的方法

与c#不同的是，ruby的访问修饰符从定义处开始起作用，直到下一个访问修饰符出现时终止，比如

class Greeter
  def initialize
  end
    
  private
  def sayhi()
    puts "hi"
  end
  
  def saybye()
    puts "bye"
  end
  
  public
  def say()
    sayhi
    saybye
  end
  
end

g = Greeter.new
g.say # output hi bye
g.sayhi # error because the sayhi isn't publics member

initialize默认就是private的 其他方法默认是public的 成员变量和类变量默认是private的 要用attr_reader或attr_accessor来增加读写控制

 

 

 

Ruby之旅(六) 模块以及类的多继承

ruby除了支持class外还支持module，module的作用有两个：
1 当作一组方法和常数的命名空间 防止命名冲突
2 可以被类mixin(混入)，mixin module的类的实例则拥有了模块的方法。

不同的类混入了同样的模块，则可以拥有同样的功能，而无须去继承某个父类。

可以通过include一个module来实现c++中的多继承。

module CircularModule
  PI = 3.1415926
  def calculate(diamiter)
    return diamiter * PI
  end
end
  
class Circular
  include CircularModule
end
  
c = Circular.new
puts c.calculate(5) # output 15.707963

可以看出来，使用include包含了一个模块后，该类就会包含模块中的方法和常数，方法用 对象名.方法名 ，常数用 类名::常数 。

ruby - 加密与编码

md5

require 'md5'
puts MD5.hexdigest('')

sha1

require 'digest/sha1'
puts Digest::SHA1.hexdigest('') 

base64

require 'base64'
code = Base64.encode64('hallo')
source = Base64.decode64(code)

uri

src = 'abc编码asdf'
code = URI.encode src
src = URI.decode code
puts code
puts src

GBK和UTF-8的转换

用GBK而不要用GB2312，因为GBK不仅包含简体中文，还包括繁体中文等，是一个大字符集。

# utf8 to gbk
def u2g(ucode)
  begin
    "#{Iconv.conv('gbk','utf-8',ucode)}"
  rescue
     " #{ucode} " #如果转换不成功 则不转换 并在字串两边加入空格 避免构造出错误的sql字符串
  end
end

这是一个比较不错的从utf-8转换为gbk编码的方法 在网络上抓取的信息 可使用这个方法转换


RUBY DBI
ruby和sqlserver交互的时候 使用dbi是一个不错的选择
dbi有两个比较重要的方法，一个是execute方法，会返回一个结果集，一个是do方法，do方法不会返回结果集，也不会返回受影响的行数，do方法是提交一个事务，而commit方法可以将之前所有使用do方法提交的事务执行，commit会返回受影响的行数。

需要注意的是，如果使用do方法插入一条数据，而没有commit直接disconnect了，将会导致这条数据插入数据库又被删除，因为你这个时候再插入一条新的数据发现，自增长的主键，被空出一个位置来，比如从3一下跳到了5，所以不要忘记commit。

Net::HTTP
Net::HTTP::new方法可以支持4个参数的重载，比如
req = Net::HTTP.new 'xxxxxx.com',80,'proxy.com',8080
第三个和第四个参数是指定代理服务器
第二个参数指定端口 不写的话默认80


File类的某些方法需要包括'win32/file'
有些方法不能使用，是因为没有包含win32/file库

require 'win32/file'
File.archive? 'c:/boot.ini'

请求URI的时候 使用URI::encode转换一下
从uri读到的数据写入本地的时候 使用binmode模式

require 'open-uri'
uri = 'http://xxx.com/中文.rar'
data = open(URI::encode(uri)){|f| f.read}
file = File.new uri[uri.rindex('/') + 1..uri.length-1], 'w+'
file.binmode
file << data
file.flush
file.close

执行sql语句的时候 务必替换特殊字符

name = "lee's book"
sql = "update tb_files set [name] = #{name.gsub("'","''")}"

RUBY脚本后缀名改为.rbw即可在执行时不显示控制台

ruby奇技淫巧 之 利用Fixnum的upto和downto方法来遍历数组

arr = "1,2,3".split(',')
arr.map!{|item| item = item.to_i} #一般可以用map!方法来改变原数组内容
0.upto(arr.length-1){|idx|arr[idx] = arr[idx].to_s} #再将数组内容改回字符串形式 使用upto方法

fixnum对象的upto和downto方法，可以很方便的作为访问一个数组的索引。

其实也可以这样做

(0..arr.length-1).each{|n| arr[n] = arr[n].to_i}

总之ruby是想怎么写就怎么写 非常方便

我们经常能看到ruby函数的参数前面有带*号，
 def my_open(*args)
 end
这是什么意思呢？
其实也很简单，它的意思是接收任意个参数，并把这些参数组装成一个
名称为args数组。

 def my_open(*args)
  puts(args.length)
 end
 
 my_open("test.rb","w") 
    
    我们可以看到输出的结果是2，这说明了args是一个带有两个元素的

 

 

 

Ruby函数参数（二）

上次说到了方法参数前带*的用法，这次我们说说前面带&的用法。
对这个符号的理解，首先要理解ruby中关于block的概念。
例子：

class Person
   def initialize(&action)
      @action = action
   end

   def say
      @action.call
   end

   def say2
     @action.call
   end
end

p = Person.new{puts("hello world")}
p.say  ---------hello world
p.say2 ---------hello world

在调用say和say2的时候，它们中的@action.call执行了block中的代码也就是puts("hello world")。

可以这么理解，yield提供的是方法级别上执行block中的代码的能力，而&却可以提供
类中各个方法执行相同block代码的能力。也就是上面例子中say，say2都执行了puts("hello world"）。