ruby语法基础

这篇会写的比较乱主要做记录用

ruby大小写敏感，也就是说end跟END这两个方法是不一样的。

---

a + b 被解释为 a+b （这是一个局部变量）
a +b 被解释为 a(+b) （这是一个方法调用）

---

打印多行字符串

print < 这是第行
第二行
test

---

构造函数与析构函数

BEGIN{
};#构造函数

END{
};析构函数

---

注释

ruby注释用#

也可以用下面这种

=begin
这是注释。
这也是注释。
这也是注释。
这还是注释。
=end

---

数据类型

Ruby支持的数据类型包括基本的Number、String、Ranges、Symbols，以及true、false和nil这几个特殊值，同时还有两种重要的数据结构Array和Hash。

ruby数据赋值和python一样，不用事先声明数据类型。

a=1 #int类型
a=‘1’ #stringl类型

hash就相当于python中的字典
demo = {“age”==>12,“name”=“tom”}
puts demo[age]即可读取值

H = {“a”: “January”}
puts H[:a]

这样也可以创建hash

---

字符串替换

可以使用序列 #{ expr } 替换任意 Ruby 表达式的值为一个字符串。在这里，expr 可以是任意的 Ruby 表达式。

puts "相乘 : #{24*60*60}"

输出为
相乘 : 86400

nam = tom
puts "#{nam}"",ok"

输出为
tom,ok

---

变量类型

Ruby 提供了四种类型的变量：

局部变量：就类似于python的局部变量比如函数中的某个变量开始的符号为_或者小写字母,例如_test。

实例变量：就是传入类的可操作的变量。类似于python中的

def __init__(self,blog_list,name_list):
       self.out = []
       self.flag = 0
       self.url_list = blog_list
       self.name_list = name_list

但是ruby中就会用下面这个代码来表述:

class Customer
  def initialize(id, name, addr)
     @ cust_id=id
     @cust_name=name
     @cust_addr=addr
  end

类变量：类似于类中的全局变量。所有的对象都可以调用，且对于所有的对象来说都共享。类变量在变量名之前放置符号(@@)。

全局变量：就是普通的全局变量,符号为$。

---

函数

函数一定是def开头，end结尾且方法名总是以小写字母开头。

---

类

类是以class开头end结尾，创建对象时，要是用new函数。调用的话只能调用类中的方法，不能直接调用值。类的名字必须大写字母开头。

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

class Customer
  @@no_of_customers=0
  def initialize(id, name, addr)
     @cust_id=id
     @cust_name=name
     @cust_addr=addr
  end
end

类似于python中类的值的初始化。

---

条件判断if else等

unless conditional then
  code
else
  code 
end

unless式和 if式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。

if …else跟python的差不多，只是少了冒号。

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

---

遍历

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

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

each的这种用法几乎完全等于for … in …。

exp：

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

for i in (0...5)
   puts "局部变量的值为 #{i}"
end

上面两块代码含义完全相同。

---

方法

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

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

看看代码一目了然，跟python区别就是，调用函数的时候不用加括号。

---

块

def test
  puts "在 test 方法内"
  yield
  puts "你又回到了 test 方法内"
  yield
end
test {puts "你在块内"}

函数只能调用跟函数名字相同的块。例如上述代码，test函数只能调用test块。调用的时候用yield调用。

模块

跟python的import很类似，不过被使用的命令是require或者include。

• require
  放在文件开始的时候，表示将目标文件中的module请求到本文件并有权力去使用，几乎等于python中import。

• include
  这是ruby的class中倘若想嵌入一个module，就要使用include。

exp：

$LOAD_PATH << '.' #将模块的寻找地址定为当前目录
require "support" #申请加载模块support

class Decade
include Week #申请嵌入模块Week
  no_of_yrs=10
  def no_of_months
     puts Week::FIRST_DAY #调用Week中的变量
     number=10*12
     puts number
  end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month #调用Week中的函数
Week.weeks_in_year
d1.no_of_months

上面的例子就很清楚的讲述了调用语法。

参数的接收与输出

• gets
  相当于python中的input

puts "Enter a value :"
val = gets
puts val

• putc
  一次输出一个字符到屏幕上，而puts一次输出所有字符。

demo = "abc"
putc demo
#输出为a

• print
  不换行输出，其他跟puts一样。

demo = "abc"
demo1 = "edf"
print demo
print demo1
#输出为abcdef

-puts
输出一串字符并换行。

demo = "abc"
demo1 = "edf"
puts demo
puts demo1
#输出为
abc
def

文件操作

• File.open
  打开文件，可以与块进行互动。

File.open("filename", "mode") do |aFile|
  #... process the file
end

r+相当于是在文件的最前方加数据。
w+相当于清空数据再重写。
a+相当于是在文件的后面加数据。

• FIle.new
  打开文件，但无法与block互动。

• sysread

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

sysread在上述代码块中的含义是，读取input.txt中的前二十个字符，且此时文件指针在21的这个位置。

• syswrite

aFile = File.new("input.txt", "w+")
if aFile
  aFile.syswrite("1")
else
  puts "Unable to open file!"
end

删除input.txt中所有数据并写入一个1.

• IO.foreach

IO.foreach("input.txt"){|block| puts block}

将input中的数据给block，并逐行输出。

---

继承与super函数

继承的语法是

        def add
            puts "c"


end

class B <A
    def add
        puts "a"
        super
        puts "b" end ```

上述代码表示B继承A，A是B的父类。

super表示继承父类的add函数。

如果一个类中有include，也就是包含了一个module，那么这个类就相当于继承了module，也可以用super函数来调用module中的同名函数。

super的运行逻辑是，现运行自身的代码，直到遇见super，这时候运行父类中这个函数的代码，运行结束后继续运行子类的函数中的代码。

还是上述的代码图，倘若调用子类中的add函数，那么将会输出

a
c
b

当A类既继承module 又继承class的时候，module的优先级比class高，也就是最终继承的其实是module。

     p 'B a 1'    end  end
    module M    def a
     p 'M a 1'
    #super
     p 'M a END'    end  end
    class A    include M    def a
     p 'a 1'    end    def a
     p 'a 2'
     super
     p 'a 2 END'    end  end
    b = A.new  b.a

上述代码最终输出为