ruby 语法

hello ruby

新建一个test.rb文件，在里面加一条 puts 'hello ruby'，终端执行，ruby test.rb 就会看到 => #hello ruby

ruby 字符串插入

name = "ruby"
puts "你好吗，#{name}"  
=> # 你好吗，ruby
# 类似与js ES6的 "你好吗 ${name}"

任何语言都通用的数据类型

String 字符串 "abc"
Number 数值 123123
Array. 数组 [1,2,3]
Hash #类似js的对象，key:value

{
   "name": "dashi",
   "birth": "1982-9-16"
}

方法

您可以定义一个接受参数的方法，如下所示：

def method_name (var1, var2)
   expr..
end

您可以为参数设置默认值，如果方法调用时未传递必需的参数则使用默认值：

def method_name (var1=value1, var2=value2)
   expr..
end

当您要调用方法时，只需要使用方法名即可，如下所示：

method_name 25, 30

使用带参数方法最大的缺点是调用方法时需要记住参数个数。例如，如果您向一个接受三个参数的方法只传递了两个参数，Ruby 会显示错误。

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

Ruby 中的每个方法默认都会返回一个值。这个返回的值是最后一个语句的值。

块和函数

当方法定义在类的外部，方法默认标记为 private。另一方面，如果方法定义在类中的，则默认标记为 public。

方法默认的可见性和 private 标记可通过模块（Module）的 public 或 private 改变。

当你想要访问类的方法时，您首先需要实例化类。然后，使用对象，您可以访问类的任何成员。

定义一个函数并调用

def test
 puts "hello ruby"
end
test # => hello ruby

函数定义参数

def test(var1 = "hello",var2 = "ruby")
 puts "#{var1} #{var2}"
end
test # => hello ruby
test("hello","rails") #=>hello rails

函数和块

def test(var1 = "hello",var2 = "ruby")
 puts "#{var1} #{var2}"
 yield
end
test {puts "hello cwh"} 
#=> hello rails
#=> hello cwh

def test(var1 = "hello",var2 = "ruby")
 puts "#{var1} #{var2}"
 yield "hello cwh"
end
test {|e| puts e} 
#=> hello rails
#=> hello cwh

块有多种定义方法

test do 
 xxxx
end

test { |接受的参数| xxxx }
# 以上方法都可以用yield来调用


# 或者 通过参数传递来调用，但是block必须是最后一个参数
def test (&block)
 &block.call
end

一个官方例子

give "我", :what => '咖啡', :count => '2', :unit => '杯' do
  "味道不错哟!"
end

#其实就是
give( 
"我" ,
{ :what => '咖啡', :count => '2' }
do "味道不错哟!" end ),

变量

常量，一般大写开头，例如： ANDROID_SYSTEM = 'android'
$开头：全局变量（Global variable）。
@开头：实例变量（Instance variable）。
@@开头：类变量（Class variable）类变量被共享在整个继承链中

面向对象

类的变量

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

initialize 方法

为了在类的外部读取类中已定义的变量，我们可以通过定义访问器(getter)方法来访问。下面的实例演示了访问器方法的用法：

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end
# 一但创建对象时候，就会触发

访问器(getter)

class Box
   # 构造函数
   def initialize(w,h)
      @width, @height = w, h
   end
 
   # 访问器方法
   def printWidth
      @width
   end
 
   def printHeight
      @height
   end
end
 
# 创建对象，初始化盒子的高度与宽度
box = Box.new(10, 20)
 
# 使用访问器方法
x = box.printWidth()
y = box.printHeight()
 
puts "盒子宽度 : #{x}"
puts "盒子高度 : #{y}"

#=>盒子宽度 : 10
#=>盒子高度 : 20

设置器(setter)

# 定义类
class Box
   # 构造器方法
   def initialize(w,h)
      @width, @height = w, h
   end
 
   # 访问器方法
   def getWidth
      @width
   end
   def getHeight
      @height
   end
 
   # 设置器方法
   def setWidth=(value)
      @width = value
   end
   def setHeight=(value)
      @height = value
   end
end
 
# 创建对象
box = Box.new(10, 20)
 
# 使用设置器方法
box.setWidth = 30
box.setHeight = 50
 
# 使用访问器方法
x = box.getWidth()
y = box.getHeight()
 
puts "盒子宽度 : #{x}"
puts "盒子高度 : #{y}"

#=>盒子宽度 : 30
#=>盒子高度 : 50

这集中方法比较常用所以 attr_accessor :variable_name,ttr_reader :variable_name、attr_writer :variable_name 三种属性声明方法,其中：accessor=reader+writer。

实例方法

实例方法的定义与其他方法的定义一样，都是使用 def 关键字，但它们只能通过类实例来使用，如下面实例所示。它们的功能不限于访问实例变量，也能按照您的需求做更多其他的任务。

# 定义类
class Box
   # 构造方法
   def initialize(w,h)
      @width, @height = w, h
   end
   # 实例方法
   def getArea
      @width * @height
   end
end
 
# 创建对象
box = Box.new(10, 20)
 
# 调用实例方法
a = box.getArea()
puts "Area of the box is : #{a}"

#=>Area of the box is : 200

类方法和类变量

类变量是所有实例中的共享变量。@@
类方法配合类变量使用。

class Box
   # 初始化类变量
   @@count = 0
   def initialize(w,h)
      # 给实例变量赋值
      @width, @height = w, h
 
      @@count += 1
   end
 
   def self.printCount()
      puts "Box count is : #@@count"
   end
end
 
# 创建两个对象
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)
 
# 调用类方法来输出盒子计数
Box.printCount()
#=>Box.printCount()

ps：实例方法和类方法不同就是实例方法要new 类方法不用new。

访问控制

Public 方法： Public 方法可被任意对象调用。默认情况下，方法都是 - public 的，除了 initialize 方法总是 private 的。
Private 方法： Private 方法不能从类外部访问或查看。只有类方法可以访问私有成员。
Protected 方法： Protected 方法只能被类及其子类的对象调用。访问也只能在类及其子类内部进行。

类的继承

弄一个新累，继承一个旧类。
新的叫子类，旧的叫父类。

重载

子类改变了父类的某方法代码，没事的，你只要创建对象的时候new子类就好了。