Modulo Rubino (modulo)

grammatica

module Identifier
   statement1
   statement2
   ...........
end

Modulo denominato costanti e le costanti di classe simile nome, che inizia con una lettera maiuscola. definizione del metodo appare come: approccio modulare simile per definire le definizioni dei metodi di classe.

Attraverso i metodi della classe, è possibile inserire il nome del modulo e un punto davanti al nome della classe del metodo da chiamare l'approccio modulare, è possibile utilizzare il nome del modulo e due punti per fare riferimento a una costante.

Esempi

#!/usr/bin/ruby

# 定义在 trig.rb 文件中的模块

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

Possiamo definire funzioni multiple con lo stesso nome ma diversi moduli funzionali:

#!/usr/bin/ruby

# 定义在 moral.rb 文件中的模块

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

Come metodi di classe, quando si definisce un metodo in un modulo, è possibile specificare il nome del modulo seguito da un punto dopo punto seguito da il nome del metodo.

Rubinorichiede dichiarazione

richiede dichiarazione è simile a C e C ++, e comprendono dichiarazioni l'istruzione import Java. Se un programma di terze parti che si desidera utilizzare uno dei moduli sono stati definiti, si può semplicemente utilizzareRubyrichiede dichiarazione di caricare file di modulo:

grammatica

require filename

Qui, l'estensione del file non.RB richiesto.

Esempi

$ LOAD_PATH << '.'

require 'trig.rb'
require 'morali'

y = Trig.sin (Trig :: PI / 4)
illeciti = Moral.sin (morale :: very_bad)

Qui, usiamo$ LOAD_PATH << '.' Lasciate rubino sapere che dobbiamo cercare il file indicato nella directory corrente.Se non si desidera utilizzare $ LOAD_PATH, è possibile utilizzarerequire_relative fare riferimento a un file da una directory relativa.

Nota: Qui, il file contiene lo stesso nome della funzione.Quindi, questo porterà a confusione quando ci si riferisce al programma chiamante, ma moduli evitare questo offuscamento del codice, e possiamo usare il nome del modulo per chiamare la funzione appropriata.

Rubinoistruzione include

È possibile incorporare un modulo in una classe. Al fine di incorporare nel modulo di classe, è possibile utilizzareincluderedichiarazioni nella tua classe:

grammatica

include modulename

Se il modulo è definito in un file separato, quindi prima è necessario utilizzare il modulo incorporatirichiedonodichiarazioni fanno riferimento al file.

Esempi

Assumendo i seguenti moduli scritti in file disupport.rb.

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

A questo punto è possibile fare riferimento al modulo nella classe, nel modo seguente:

#!/usr/bin/ruby
$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

Questo produce i seguenti risultati:

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Ruby in Mixin

Prima di leggere questa sezione, avrete bisogno di una comprensione preliminare dei concetti orientati agli oggetti.

Quando una classe può essere più di una classe genitore quando la classe di entità eredita dalla, la classe viene visualizzato come l'ereditarietà multipla.

Ruby non supporta direttamente l'ereditarietà multipla, ma il modulo di Ruby (Module) ha un altro caratteristiche fantastiche. Si elimina virtualmente la necessità di ereditarietà multipla, è previstounapparecchio denominatomixin.

Rubino in realtà non raggiungere meccanismo di ereditarietà multipla, ma ha adottato la tecnologia mixin come sostituto. I moduli comprendono la definizione della classe, l'approccio del modulo di mescolare nella classe.

Diamo un'occhiata al seguente codice di esempio, una comprensione approfondita di mixin:

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

• Un modulo è composto dal processo di a1 e a2.
• Modulo B con il metodo della composizione b1 e b2.
• classe di esempio contiene i moduli A e B.
• Classe del campione può accedere a tutti i quattro metodi, cioè, a1, a2, b1 e b2.
Così si può vedere che il campione classe eredita due moduli, si può dire che il campione di classe usare l'ereditarietà multipla omixin.
Precedente: blocco Rubino
Successivo: Rubino String (String)