宽容他人，放过自己。

ruby的学习（4）

Posted on Apr 26, 2018 By anchoriteFili

Ruby 方法与其他编程语言中的函数类似。Ruby 方法用于捆绑一个或多个重复的语句到一个单元中。 方法名应以小写字母开头。如果您以大写字母作为方法名的开头，Ruby 可能会把它当作常量，从而导致不正确的解析调用。 使用带参数方法最大的缺点是调用方法时需要记住参数个数。例如，如果您向一个接受三个参数的方法只传递了两个参数，Ruby 会显示错误。

# 带有参数方法
def test(a1="Ruby", a2="Perl")
    puts "编程语言为 #{a1}"
    puts "编程语言为 #{a2}"
end

# 从方法返回值
# Ruby 中每个方法默认都会返回一个值。这个返回的值是最后一个语句的值。
def test
   i = 100
   j = 10
   k = 0
end

test "C", "C++"
test
testOne # 会报错

Ruby return 语句

Ruby 中的 return 语句用于从 Ruby 方法中返回一个或多个值。

def test
    i = 100
    j = 200
    k = 300
    return i, j, k
end

var = test
puts var

可变数量的参数

Ruby允许您声明参数变量可变的方法。

def sample (*test)
    puts "参数个数为 #{test.length}"
    for i in 0...test.length do
        puts "参数值为 #{test[i]}"
    end
end

sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

=begin
结果：
def sample (*test)
    puts "参数个数为 #{test.length}"
    for i in 0...test.length do
        puts "参数值为 #{test[i]}"
    end
end

sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"
=end

类方法

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

Ruby alias 语句

这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义。为编号的全局变量（$1,$2,…）起别名是禁止的。重写内置的全局变量可能会导致严重问题。

alias 方法名 方法名
alias 全局变量 全局变量

# 实例
alias foo bar
alias $MATCH $&

Ruby undef 语句

这个语句用于取消方法定义。undef 不能出现在方法主体内。 通过使用 undef 和 alias，类的接口可以从父类独立修改，但请注意，在自身内部方法调用时，它可能会破坏程序。

undef 方法名

Ruby 块

  • 块由大量的代码组成。
  • 您需要给块去个名称。
  • 块中的代码总是包含在大括号{}内
  • 块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为test，那么您要使用函数 test 来调用这个快。
  • 您可以使用 yield 语句来调用块。

yield 语句

=begin
使用一个简单的 yield 语句来调用块。您也将学到如果使用带有参数的 yield 语句来调用块。
=end

def test
    puts "在 test 方法内"
    yield   # 使用一个简单的 yield 语句来调用块
    puts "你又回到了 test 方法内"
    yield
end

test {puts "你在块内"}

=begin
在这里，yield 语句后跟着参数。你甚至可以传递多个参数。在块中，您可以在两个竖线之间放置一个变量来接受参数
=end

def testOne
    yield 5, 10
    puts "在 test 方法内"
    yield 100, 200
end

testOne { |i, j| puts "你在块 #{i} #{j} 内" }

BEGIN 和 END 块

每个 Ruby 源文件可以声明当文件被加载时要运行的代码块 (BEGIN块)，以及程序完成执行后要运行的代码块 (END块)。

BEGIN {
    # BEGIN 代码块
    puts "BEGIN 代码块"
}

END {
    # END 代码块
    puts "END 代码块"
}

# MAIN 代码块
puts "MAIN 代码块"

=begin
一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。
=end

=begin
BEGIN 代码块
MAIN 代码块
END 代码块
=end

Ruby 模块 (Module)

  • 模块提供了一个命名空间和避免名字冲突。
  • 模块实现了 mixin 装置。

模块定义了一个命名空间，相当于一个沙盒，在里边您的方法和常量不会与其他地方的方法常量冲突。

  • 模块不能实例化
  • 模块没有子类
  • 模块只能被另一个模块定义

模块常量命名与类常量命名类似，以大写字母开头。方法定义看起来也相似

module Moral
    VERY_BAD = 0
    BAD = 1
    def Moral.sin(badness)
        # ...
    end
end

=begin
就像类方法，当您在模块中定义一个方法时，您可以指定在模块名称后跟着一个点号，点号后根正方法名。
=end

Ruby require 语句

require 语句类似于 C 和 C++ 中的 include 语句以及 Java 中的 import 语句。如果一个第三方的程序想要使用任何已定义的模块，则可以简单地使用 Ruby require 语句来加载模块文件：

require filename

$LOAD_PATH << '.'

require 'test.rb'

=begin
在这里，我们使用 $LOAD_PATH << '.' 让 Ruby 知道必须在当前目录中搜索被引用的文件。
如果您不想使用 $LOAD_PATH，那么您可以使用 require_relative 来从一个相对目录引用文件。

注意：在这里，文件包含相同的函数名称。所以，这会在引用调用程序时导致代码模糊，但是模块避免了这种
代码模糊，而且我们可以使用模块的名称调用适当的函数。
=end

Ruby include 语句

您可以在类中嵌入模块。为了在类中嵌入模块，您可以在类中使用 include 语句。 如果模块是定义在一个单独的文件中，那么嵌入模块之前就需要使用 require 语句引用该文件。

$LOAD_PATH << '.'
require "support"

class Decade
include Week
    no_of_yrs=10
    def no_of_months
        puts Week::FIRST_DAY
        number=10*12
        puts number
    end
end

d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

Ruby 中的 Mixins

当一个类可以从多个父类继承类的特性时，该类显示为多重继承。 Ruby 不直接支持多重继承，但是 Ruby 的模块 (Module) 有另一个神奇的功能。它几乎消除了多重继承的需要，提供了一种名为 mixin的装置。 Ruby 没有真正实现多重继承机制，而是采用成为mixin技术作为替代品。将模块 include 到类定义中，

module A
    def a1
    end
    def a2
    end
end

module B
    def b1
    end
    def b2
    end
end

class Sample
include A
include B
    def s1
    end
end

samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1
  • 模块 A 由方法 a1 和 a2 组成
  • 模块 B 由方法 b1 和 b2 组成
  • 类 Sample 包含了模块 A 和 B。
  • 类 Sample 可以访问所有四个方法，即a1、a2、b1和b2

    因此，您可以看到类 Sample 继承了两个模块，您可以说类 Sample 使用了多重继承或 mixin