Metoden "Kräv" i Ruby

För att skapa återanvändbara komponenter, sådana som lätt kan användas i andra program, måste ett programmeringsspråk ha något sätt att smidigt importera den koden vid körning. I Rubin, fordra metoden används för att ladda en annan fil och köra alla dess uttalanden. Detta tjänar till att importera all klass och metod definitioner i filen. Förutom att helt enkelt köra alla uttalanden i filen, håller krävningsmetoden också koll på vilka filer som tidigare har krävts och kommer därför inte att kräva en fil två gånger.

Metoden kräver namnet på filen som krävs, som en sträng, som ett enda argument. Detta kan antingen vara en sökväg till filen, t.ex. ./lib/some_library.rb eller ett förkortat namn, t.ex. some_library. Om argumentet är en sökväg och ett fullständigt filnamn, söker metoden som krävs där för filen. Men om argumentet är ett förkortat namn kommer metoden för att söka igenom ett antal fördefinierade kataloger på ditt system efter den filen. Att använda det förkortade namnet är det vanligaste sättet att använda krävningsmetoden.

Följande exempel visar hur du använder obligatoriska uttalanden. Filen test_library.rb är i det första kodblocket. Den här filen skriver ut ett meddelande och definierar en ny klass. Det andra kodblocket är filen test_program.rb. Den här filen laddar test_library.rb fil med hjälp av det här kravet och skapar en ny TestClass objekt.

sätter "test_library ingår"
klass TestClass
def initiera
sätter "TestClass-objekt skapat"
slutet
slutet

#! / usr / bin / env ruby
kräver 'test_library.rb'
t = TestClass.new

När du skriver återanvändbara komponenter är det bäst att inte förklara många variabler i det globala omfånget utanför klasser eller metoder eller med hjälp av $ prefix. Detta för att förhindra något som heter "namnutrymme. "Om du förklarar för många namn, kan ett annat program eller bibliotek förklara samma namn och orsaka en kollision. När två helt oberoende bibliotek börjar ändra varandras variabler av misstag kommer saker att brytas - till synes slumpmässigt. Detta är ett mycket svårt fel att spåra och det är bäst att undvika det.

För att undvika namnkollisioner kan du bifoga allt i ditt bibliotek inuti en modul påstående. Detta kommer att kräva att folk hänvisar till dina klasser och din metod med ett fullt kvalificerat namn som t.ex. MyLibrary:: my_method, men det är värt det eftersom namnkollisioner vanligtvis inte kommer att inträffa. För personer som vill ha alla dina klass- och metodnamn i global omfattning kan de göra det med hjälp av inkludera påstående.

Följande exempel upprepar föregående exempel men bifogar allt i a Mitt bibliotek modul. Två versioner av my_program.rb är given; en som använder inkludera uttalande och en som inte gör det.

sätter "test_library ingår"
modul MyLibrary
klass TestClass
def initiera
sätter "TestClass-objekt skapat"
slutet
slutet
slutet

#! / usr / bin / env ruby
kräver 'test_library2.rb'
t = MyLibrary:: TestClass.new

#! / usr / bin / env ruby
kräver 'test_library2.rb'
inkludera MyLibrary
t = TestClass.new

Eftersom återanvändbara komponenter ofta flyttas runt är det också bäst att inte använda absoluta sökvägar i dina kravsamtal. En absolut väg är en väg som /home/user/code/library.rb. Du kommer att märka att filen måste finnas på den exakta platsen för att fungera. Om skriptet någonsin flyttas eller din hemkatalog ändras, kommer det att kräva uttalande att sluta fungera.

I stället för absoluta vägar är det ofta vanligt att skapa en ./lib katalog i ditt Ruby-program katalog. De ./lib katalogen läggs till i $ LOAD_PATH variabel som lagrar de kataloger där metoden kräver sökning efter Ruby-filer. Efter det, om filen my_library.rb lagras i lib-katalogen, det kan laddas in i ditt program med en enkel kräver "my_library" påstående.

Följande exempel är detsamma som det föregående test_program.rb exempel. Men det antar att test_library.rb filen lagras i ./lib katalogen och laddar den med den ovan beskrivna metoden.

#! / usr / bin / env ruby
$ LOAD_PATH << './lib'
kräver 'test_library.rb'
t = TestClass.new