Programmering i Ruby

Den Pragmatiske Programmerers Veiledning

Forrige < Innhold ^
Neste >

Ruby sin omverden



Det nå en gang slik, at vår applikasjoner dessverre må ut i og hanskes med den store, stygge verdenen. I dette kapittelet ser vi nærmere på hvordan Ruby samhandler med miljøet rundt. Brukere av Microsoft Windows vil muligens ønske å ta en titt på den plattformspesifikke informasjonen som begynner på side 163.

Kommandolinje argumenter

``In the Beginning was the Command Line.''[Tittelen til et fantastisk essay skrevet av Neal Stephenson (tilgjengelig på http://www.spack.org/essays/commandline.html).] Uavhenging av systemet som Ruby blir utplassert på, om det så er en kraftig vitenskapelig grafisk arbeidsstasjon fra øverste hylle eller en personlig data assisten, så må du starte Ruby sin fortolker på et vis, og det gir oss muligheten til å angi kommandoline argumenter.

En kommandolinje argumenter til Ruby fortolkeren består av tre hoveddeler: opsjoner til selve Ruby fortolkeren, navnet på et eventuelt program som skal kjøres og, om ønskelig, argumenter som skal sendes til det programmet.

ruby [
            opsjoner
            ] [--] [
            programfil
            ] [
            argumenter
            ]

Opsjonene til Ruby avsluttes av det første ordet på kommandolinjen som ikke starter med en bindestrek, eller av det spesielle flagget ``--'' (to bindestreker).

Hvis det ikke er noe filnavn i kommandolinjen, eller filnavnet er en enkelt bindestrek (-), leser Ruby kildekoden fra standard innput.

Argumenter til selve programmet følger etter programnavnet. For eksempel:

% ruby -w - "Hello World"

vil slå på advarsler (warnings), lese et program fra standard innput og gi den siterte tekststrengen "Hello World" inn som et argument til programmet.

Kommandolinje opsjoner

-0[oktal]
' Nummer ``0'' flagget spesifierer tegnet som skal brukes for å separere poster fra hverandre (\0, hvis det ikke følger flere sifre). -00 indikerer paragrafmodus: postene separeres av to påfølgende standard postseparatortegn. -0777 leser hele filen på en gang (siden det er et ulovlig tegn). Setter $/ variabelen.

-a
' Automatisk oppdelingsmodus når brukt i sammenheng med -n eller -p. Det er ekvivalent til å utføre $F=$_.split før hver iterasjon.

-C katalog
' Endrer arbeidskatalog til katalog før programmet kjøres.

-c
' Sjekker kun syntaksen. Kjører ikke programmet.

--copyright
Skriver ut en notis om opphavsretten og avslutter.

-d, --debug
' Setter $DEBUG variabelen til sann (true). Dette kan du bruke i programmene dine for å slå på ekstra sporing av programutførelsen.

-e 'kommando'
' Utfører kommando som en linje av Ruby kildekode. Flere -e'er er tillatt og behandles som om de var flere linjer i et og samme program. Dersom programfil er utelatt når -e brukes, stoppes all utføring etter at alle -e kommandoene har blitt kjørt.

-F mønster
' Angir innput feltseparatoren ($;) som skal brukes som standard for split() (påvirker -a).

-h, --help
' Viser en kort "hjelp" side.

-I kataloger
' Spesifiserer kataloger som må settes inn på fronten av $LOAD_PATH ($:). Man kan ha flere -I opsjoner, samt ha flere kataloger spesifiser i hver -I. Katalogene separeres med ``:'' på Unix-lignende systemer og med ``;'' på DOS/Windows systemer.

-i [endelse]
' Endrer selve filene angitt i ARGV. For hver fil navngitt i ARGV, vil det du skriver til standard utput bli lagret tilbake som innholdet i den filen. En sikkerhetskopi av den gamle filen vil bli laget dersom endelse er angitt.
% ruby -pi.bak -e "gsub(/Perl/, 'Ruby')" *.txt

-K kcode
' Spesiferer tegnsettet som skal brukes. Denne opsjonen er nyttigst når Ruby brukes for prosessering i forbindelse med japansk. kcode kan være en av: e, E for EUC; s, S for SJIS; u, U for UTF-8; eller a, A, n, N for ASCII.

-l
' Slår på automatisk prosessering av linje endene. Setter $\ til verdien i $/ og fjerner linjeskift tegn av innput linjene automatisk.

-n
' Antar at du ønsker en ``while gets; ...; end'' løkke rundt programmet ditt. For eksempek kunne en enkel grep komando implementeres som:
% ruby -n -e "print if /wombat/"  *.txt

-p
' Plasserer programkoden din inne i løkken ``while gets; ...; print; end.''
% ruby -p -e "$_.downcase!" *.txt
-r library
' require det angitte biblioteket før kjøring starter.

-S
' Leter etter progframfilen ved hjelp av miljøvariablen RUBYPATH eller PATH.

-s
' Eventuelle kommandolinje opsjoner som kommer etter programfilen, men før eventuelle filnavn argumenter eller en --, fjernes i fra ARGV og settes inn i en global variabel med navnet til opsjonen. I det følgende eksempel, vil effekten være at variabelen $opt settes til ``electric''.

% ruby -s prog -opt=electric ./mydata

-T[level]
' Setter trygghetsnivået, hvilket blant annet slår på 'tainted' sjekking (se side 257. Setter $SAFE variabelen.

-v, --verbose
' Slår på ordrik(??) modus og skriver ut versjonsnummeret. I ordrik modus blir kompileringsadvarsler skrevet ut. Hvis det ikke er noe programfilnavn på kommandolinjen, avslutter Ruby.

--version
Viser versjonsnummeret til Ruby og avslutter.

-w
' Slår på ordrik modus. I motsetning til -v, leses programmet fra standard innput dersom det ikke angis noen programfiler på kommandolinjen. We anbefaler deg å kjøre Ruby programmene dine med -w.

-X katalog
' Endrer arbeidskatalogen til katalog før utførelse. Samme som -C katalog.

-x [katalog]
' Fjerner teksten før #!ruby linjen og endrer arbeidskatalogen til katalog dersom den er gitt.

-y, --yydebug
' Slår på yacc debugging i parseren (dette gir alt for mye informasjon).

ARGV

Eventuelle kommandolinje argumener som kommer etter programfilnavnet er tilgjengelig i ditt Ruby program i den globale tabellen ARGV. For eksempel vil det å kalle Ruby slik:

% ruby -w ptest "Hello World" a1 1.6180

gjøre at ARGV tabellen inneholder ["Hello World", a1, 1.6180]. Her er det en liten felle for alle dere som pleier å programmere i C---ARGV[0] er det første argumentet til programmet, ikke selve programnavnet. Navnet på det programmet som kjøres er tilgjengelig i den globale variabelen $0.

Program terminering

Metoden Kernel#exit terminerer programmet ditt og returnerer en statusverdi tilbake til operativsystemet. Men, i motsetning til noen språk, avslutter exit ikke programmet umiddelbart. Kernel#exit kaster først et SystemExit unntak, som du kan fange opp, og deretter gjør metoden ymse opprydningsarbeid, slik som å kjøre eventuelle registrerte at_exit metoder og sluttbehandling av objekter. Titt i referansen til Kernel#exit som begynner på side 415 for ytterlige detaljer.

Miljøvariabler

Du har mulighet til å få fatt i operativsystemets miljøvariabler ved hjelp av den forhåndsdefinerte variabelen ENV, som har samme metodene som en Hash. [ENV er egentlig ikke en hashtabell, men hvis du har behov for det, kan du gjøre den om til en Hash ved å bruke ENV#to_hash.]

Verdiene til noen miljøvariabler leses av Ruby når fortolkeren starter opp. Disse variablene påvirker hvordan fortolkeren oppfører seg, som vist i tabell 13.1 på side 139.
Miljøvariabler som Ruby bruker
Variabelnavn Beskrivelse
RUBYOPT Ytterlige kommandolinje opsjoner til Ruby. Ruby ser her etter etter at de virkelige kommandolinje opsjonene har blitt lest inn ($SAFE må være 0).
RUBYLIB Ytterlige søkestier for Ruby programmer ($SAFE må være 0).
RUBYPATH Sammen med -S opsjonen, søkesti for Ruby programmer (PATH er standard).
RUBYSHELL Skall som skal brukes når en prosess startes; hvis denne ikke er satt, vil Ruby også sjekke SHELL eller COMSPEC.
DLN_LIBRARY_PATH Søkesti for dynamisk lasting av moduler.
RUBYLIB_PREFIX (Kun Windows) Radbrekk RUBYLIB søkestien ved å prefikse denne strengen på hver komponent.

Skriving til miljøvariabler

Et Ruby program kan skrive til ENV objektet, som på de fleste systemene endrer de tilsvarende miljøvariablene. Men denne endringen er lokal til prosessen som gjør det og til eventuelle barneprosesser som lages. Denne arvingen av miljøvariabler illustreres i det følgende kodeeksempelet. En subprosess endrer en miljøvariabel og denne endringen blir synlig i en annen prosess som den starter. Men endringen er ikke synlig i den opprinnelig forelderprosessen. (Dette beviser også at foreldre aldri vet helt hva barna deres gjør.)

puts "In parent, term = #{ENV['TERM']}"
fork do
  puts "Start of child 1, term = #{ENV['TERM']}"
  ENV['TERM'] = "ansi"
  fork do
    puts "Start of child 2, term = #{ENV['TERM']}"
  end
  Process.wait
  puts "End of child 1, term = #{ENV['TERM']}"
end
Process.wait
puts "Back in parent, term = #{ENV['TERM']}"
produserer:
In parent, term = xterm
Start of child 1, term = xterm
Start of child 2, term = ansi
End of child 1, term = ansi
Back in parent, term = xterm

Hvor finner Ruby sine moduler?

Du bruker require eller load for å hente en biblioteksmodul inn i ditt Ruby program. Noen av disse modulene følger med Ruby, noen har du installert i fra Rubys Applikasjons Arkiv (RAA) og noen har du skrevet selv. Hvordan finner Ruby disse?

Når Ruby bygges for din spesifikke maskin, predefineres et sett med standard kataloger som skal holde bibliotek ting og tang. Hvor disse blir å finne, spørs på maskinen det gjelder. Du kan finne ut av dette fra kommandolinjen med noe slik som dette:

% ruby -e 'puts $:'

På en typisk Linux boks, vil du sannsynligvis få noe omtrent slik tilbake:

/usr/local/lib/ruby/site_ruby/1.6/i686-linux
/usr/local/lib/ruby/site_ruby/1.6
/usr/local/lib/ruby/site_ruby
/usr/local/lib/ruby/1.6/i686-linux
/usr/local/lib/ruby/1.6
.

Katalogene kalt site_ruby er ment å inneholde moduler og utvidelser som du har lagt til. De arkitekturavhengige katalogene (i686-linux i dette tilfellet) inneholder kjørbare filer og andre ting som er spesifikke til denne ene maskinen. Alle disse katalogene blir automatisk inkluders i Ruby sin søken etter moduler.

Noen ganger er dette ikke nok. Kanskje du arbeider med et stort prosjekt skrevet i Ruby, og du og dine kollegaer har skrevet et betydelig bibliotek av Ruby kode. Du ønsker at alle på laget skal ha tilgang til all denne koden. Du har et par valgmuligheter for hvordan du kan gjøre dette. Hvis programmet ditt kjører med trygghetsnivå null (titt i kapittel 20 som starter på side 253, kan du sette miljøvariabelen RUBYLIB til å liste opp en eller flere av de katalogene som skal søkes i. [Separatortegnet er platformavhengig. For Windows er det semikolon; for Unix, kolon.] Hvis ditt program ikke er setuid, kan du bruke kommandolinje parameteren -I for å få til det samme.

Til sist nevner vi at variabelen $: er en tabell over steder for å søke etter lastede filer. Variabelen initialiseres til listen over standardkatalogene, samt eventuelle andre du spesiferer ved hjelp av RUBYLIB eller -I. Du kan også alltids legge til flere kataloger til denne tabellen i fra ditt eget program under kjøring.

Kompilering- og lenkingsmiljø

Når Ruby kompileres for en spesifikk arkitektur, blir alle de relevante innstillingene som ble brukt under byggingen (inklusive arkitekturen til maskinen den ble kompilert på, kompileringsopsjoner, stien til kildekoden og så videre) nedtegnet i modulen Config som er å finne i biblioteksfilen ``rbconfig.rb''. Etter innstallering kan etthvert Ruby program bruke denne modulen for å få detaljert informasjon om hvordan Ruby ble kompilert.

require "rbconfig.rb"
include Config
CONFIG["host"] » "i686-pc-linux"
CONFIG["LDFLAGS"] » "-rdynamic"

Utvidelser til Ruby bruker denne konfigurasjonsfilen for å kompilere og lenke korrekt på en gitt arkitektur. Se i kapittel 17 som begynner på side 169 og referansen til mkmf som begynner på side 451(??) for mer detaljer.

( In progress translation to Norwegian by NorwayRUG. $Revision: 1.8 $ )
$Log: rubyworld.xml,v $
Revision 1.8  2002/08/11 06:48:45  kent
Første oversettelseskladd ferdig.

Revision 1.7  2002/08/10 16:24:24  kent
Nesten frem til Build Environment.

Revision 1.6  2002/08/10 14:30:31  kent
Frem til ARGV.

Revision 1.5  2002/08/10 13:59:14  kent
Fikset noen tag feil og fortsatte litt til.

Revision 1.4  2002/08/10 12:48:43  kent
Påbegynt oversettelse.


Forrige < Innhold ^
Neste >

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide".
Translation to norwegian by Norway Ruby User Group.
Copyright for the english original authored by David Thomas and Andrew Hunt:
Copyright © 2001 Addison Wesley Longman, Inc.
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at
http://www.opencontent.org/openpub/).

(Please note that the license for the original has changed from the above. The above is the license of the original version that was used as a foundation for the translation efforts.)

Copyright for the norwegian translation:
Copyright © 2002 Norway Ruby User Group.
This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at
http://www.opencontent.org/openpub/).
Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.
Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.