Språket Ruby

Kildekodeoppsett

a = 1

b = 2; c = 3

d = 4 + 5 +      # no '\' needed
    6 + 7

e = 8 + 9   \
    + 10         # '\' needed

echo 'print "Hello\n"' | ruby

BEGIN og END blokker

BEGIN {
  begin kode
}

END {
  end kode
}

Generell avgrenset innput

Generell avgrenset innput Type Mening Se side %q Enkelt-sitert streng 202 %Q, % Dobbelt-sitert streng 202 %w En Array med elementer 204 %r Regulært uttrykk 205 %x Skallommando 218

%q/this is a string/
%q-string-
%q(a (nested) string)

%q{def fred(a)
     a.each { |i| puts i }
   end}

De grunnleggende typene

Hel- og flyttall

123456                    # Fixnum
123_456                   # Fixnum (understrekningstegn ignoreres)
-543                      # Negativ Fixnum
123_456_789_123_345_789   # Bignum
0xaabb                    # Heksadecimal
0377                      # Oktal
-0b1010                   # Binært (negetert)
0b001_001                 # Binært
?a                        # tegnkode
?A                        # stor bokstav
?\C-a                     # kontroll a = A - 0x40
?\C-A                     # hvorvidt det er store eller små bokstaver ignoreres for kontrolltegn
?\M-a                     # meta setter bit 7
?\M-\C-a                  # meta og kontroll a

Strenger

Substitusjon i dobbelt-siterte strenger \a Bjelle/alarm (0x07) \nnn Oktal nnn \b Slettetast/backspace (0x08) \xnn Heksidesimal nn \e Escape (0x1b) \cx Control-x \f Formfeed (0x0c) \C-x Control-x \n Linjeskift/newline (0x0a) \M-x Meta-x \r Return (0x0d) \M-\C-x Meta-control-x \s Mellomrom/space (0x20) \x x \t Tab (0x09) #{expr} Verdien til expr \v Vertikal tab (0x0b)

a = 123
print <<HERE
Double quoted \
here document.
Sum = #{a + 1}
HERE

print <<-'THERE'
    This is single quoted.
    The above used #{a + 1}
    THERE

Double quoted here document.
Sum = 124
    This is single quoted.
    The above used #{a + 1}

for i in 1.
  print 'hello'.id, " "
end

537763324 537763034 537763004

Rekker

Tabeller

arr = [ fred, 10, 3.14, "This is a string", barney("pebbles"), ]

Hashtabeller

colors = { "red"   => 0xf00,
           "green" => 0x0f0,
           "blue"  => 0x00f
         }

Krav til en hashtabellnøkkel

Symboler

:Object
:myVariable

Regulære uttrykk

/pattern/
/pattern/options
%r{pattern}
%r{pattern}options
Regexp.new( 'pattern' [, options
            ] )

Opsjoner til regulære uttrykk

Mønstre i regulære uttrykk

vanlige tegn

Alle tegn, med unntak av ., |, (, ), [, \, ^, {, +, $, * og ?, slår ut på seg selv. For å treffe på et av disse spesielle tegnene, plasser en backslah foran tegnet.

^

Slår ut på begynnelsen til en linje.

$

Slår ut på slutten av en linje.

\A

Slår ut på begynnelsen av strengen.

\z

Slår ut på slutten av strengen.

\Z

Slår ut på slutten av strengen med mindre strengen slutter med et ``\n''-tegn, da slår det ut rett før ``\n''-tegnet.

\b, \B

Slår ut på respektivt ord- og ikke-ord-grenser.

[ tegn ]

En tegnklasse slår ut på hvilket som helst av tegnene mellom firkantparentesene. Tegnene |, (, ), [, ^, $, *, og ? som har spesiell betydning andre steder i mønstre, mister deres særegne signifikans mellom firkantparenteser. Sekvensene \ nnn, \x nn, \c x, \C- x, \M- x og \M-\C- x fungerer som vist i tabell 18.2 på side 203. Sekvensene \d, \D, \s, \S, \w og \W er kortformer for grupper av tegn, som vist i tabell 5.1 på side 59. Sekvensen c₁-c₂ representerer alle tegn fra og med c₁ til og med c₂. Literale ] eller - tegn må komme umiddelbart etter den åpnende firkantparentesen. En oppoverpil (^) umiddelbart etter den første åpnende firkantparentesen negeterer betydningen til mønsteret---det slår ut på et hvert tegn som ikke er i tegnklassen.

\d, \s, \w

Dette er kortformer for tegnklasser som slår ut på respektivt sifre, mellomromstegn og ordbokstaver. De negeterte formene \D, \S, and \W slår ut på tegn som ikke er sifre, mellomromstegn eller ordbokstaver. Disse forkortelsene summeres i tabell 5.1 på side 59.

. (punktum)

Utenfor firkantparenteser slår punktum ut på et hvert tegn med unntak av linjeskift. (Med /m-opsjonen slår den også ut på linjeskift).

re *

Slår ut på null eller flere forekomster av re.

re +

Slår ut på en eller flere forekomster av re.

re {m,n}

Slår ut på minst ``m'' og maksimalt ``n'' forekomster av re.

re ?

Slår ut på null eller ingen forekomst av re. Modifikatorene *, + og {m,n} er grådige til vanlig. Legg til et spørsmålstegn for å gjøre dem slik at de slår ut på minst mulig.

re1 | re2

(...)

Parenteser brukes for å gruppere regulære uttrykk. For eksempel slår mønsteret /abc+/ ut på en streng som inneholder en ``a,'' en ``b,'' og en eller flere``c''-er. Derimot slår /(abc)+/ ut på en eller flere sekvenser av ``abc''. Parenteser brukes også for å samle resultatene fra sammenligningene. For hver åpnende parentes lagrer Ruby resultatet til delen av sammenligningen mellom den og den korresponderende lukkende parentesen som påfølgende grupper. Inne i samme mønster referer \1 til hva den første gruppen slo ut på, \2 hva den andre gruppen slo ut på og så videre. På utsiden av mønsteret har de spesielle variablene $1, $2 og så videre, samme nytten.

Substitusjoner

#{...}

Utfører et uttrykkssubstitusjoner, akkurat som med med strenger. Vanligvis blir substitusjonen utført hver gang literalen til et regulært uttrykk evalueres. Med /o-opsjonen utføres substitusjonen kun første gang.

\0, \1, \2, ... \9, \&, \`, \', \+

Substituerer inn delresultatet til det nte grupperte subuttrykket, hele resultatet, delen før utslaget, delen etter utslaget eller den høyeste gruppen.

Utvidelser

(?# kommentar)

Setter inn en kommentar i mønsteret. Innholdet ignoreres under sammenligning.

(?:re)

Grupperer re uten å generere tilbakereferanser. Dette er ofte nytting når du trenger å gruppere flere konstruksjoner men ikke ønsker at gruppen skal tilordne en verdi til $1 eller lignende. I eksempelet som følger slår begge mønstrene ut på en dato med enten kolon eller mellomrom mellom måneden, dagen og året. Den første varianten lagrer separeringstegnene i $2 og $4, mens den andre varianten ikke lagrer separatorene i en ekstern variabel.

date = "12/25/01"
date =~ %r{(\d+)(/|:)(\d+)(/|:)(\d+)}
[$1,$2,$3,$4,$5]	»	["12", "/", "25", "/", "01"]
date =~ %r{(\d+)(?:/|:)(\d+)(?:/|:)(\d+)}
[$1,$2,$3]	»	["12", "25", "01"]

(?=re)

Slår ut på re på dette punktet men forbruker ikke det den slår ut på (dette er også kjent som ``zero-width positive lookahead''). Dette lar deg se framover i strengen etter konteksten til en sammenligning uten å påvirke $&. I dette eksempelet slår scan metoden ut på ord som følges av et komma, men selve kommategnene blir ikke inkludert i resultatet.

str = "red, white, and blue"
str.scan(/[a-z]+(?=,)/)	»	["red", "white"]

(?!re)

Slår ut hvis re ikke slår ut på dette punktet. Forbruker ikke det som passer (zero-width negative lookahead). For eksempel passer /hot(?!dog)(\w+)/ på et hvert ord som inneholder bokstavene ``hot'' som ikke følges av ``dog'' og ved sammenligning returneres slutten av ordet i $1.

(?>re)

Nøster et uavhengig regulært uttrykk inne i det første regulære uttrykket. Dette uttrykket er ankret fast til den gjeldende utslagsposisonen. Dersom uttrykket forbuker tegn vil disse ikke lenger være tilgjengelig for det regulære uttrykket som er på et høyere nivå. Derfor kan man ikke gå tilbake når man bruker denne konstruksjonen, som kan hjelpe på ytelse. For eksempel tar mønsteret /a.*b.*a/ eksponensiell tid når man sammenligner med en streng som har en ``a'' fulgt av en mengde ``b''-er, uten en avsluttende ``a.'' Men dette kan unngås dersom man bruker et nøstet regulært uttrykk som /a(?>.*b).*a/. I denne formen vil det nøstede uttrykket spise opp alt den kan i fra innputstrenget opp til den siste ``b.'' Når sjekken for en etterfølgende ``a'' så feiler, er det ikke nødvendig å gå tilbake og sammenligningen feiler umiddelbart.

require "benchmark" include Benchmark str = "a" + ("b" * 5000) bm(8) do |test|   test.report("Normal:") { str =~ /a.*b.*a/ }   test.report("Nested:") { str =~ /a(?>.*b).*a/ } end

produserer:

user     system      total        real Normal:   4.170000   0.000000   4.170000 (  4.150970) Nested:   0.000000   0.000000   0.000000 (  0.001529)

(?imx)

Slår på den korresponderende ``i'', ``m'' eller ``x'' opsjonen. Dersom den brukes i en gruppe er effekten begrenset til gruppen.

(?-imx)

Slår av ``i'', ``m'' eller ``x'' opsjonen.

(?imx:re)

Slår på ``i'', ``m'' eller ``x'' opsjonen for re.

(?-imx:re)

Slår av ``i'', ``m'' eller ``x'' opsjonen for re.

Navn

Reserverte ord __FILE__ and def end in or self unless __LINE__ begin defined? ensure module redo super until BEGIN break do false next rescue then when END case else for nil retry true while alias class elsif if not return undef yield

fred  anObject  _x  three_two_one

@name  @_  @Size

@@name  @@_  @@Size

module Math
  PI = 3.1415926
end
class BigBlob

$params  $PROGRAM  $!  $_  $-a  $-.

Tvetydighet mellom variabler og metoder

def a
  print "Function 'a' called\n"
  99
end

for i in 1..2
  if i == 2
    print "a=", a, "\n"
  else
    a = 1
    print "a=", a, "\n"
  end
end

a=1
Function 'a' called
a=99

a = 1 if false; a

Variabler og konstanter

MY_CONST = 1
MY_CONST = 2   # generates a warning

prog.rb:2: warning: already initialized constant MY_CONST

Konstanters og variablers skop

class Song
  @@count = 0
  def initialize
    @@count += 1
  end
  def Song.getCount
    @@count
  end
end

class Holder
  @@var = 99
  def Holder.var=(val)
    @@var = val
  end
end

a = Holder.new
def a.var
  @@var
end

a = [ 1, 2, 3 ]
a.each { |i|  puts i  }  # i local to block
a.each { |$i| puts $i }  # assigns to global $i
a.each { |@i| puts @i }  # assigns to instance variable @i
a.each { |I|  puts I  }  # generates warning assigning to constant
a.each { |b.meth| }      # invokes meth= in object b
sum = 0
var = nil
a.each { |var| sum += var }  # uses sum and var from enclosing scope

Forhåndsdefinerte variabler

Unntaksinformasjon

Variabler for mønstergjenkjenning

Innput/Utput variabler

Miljøvariabler

Standard Objects

Globale konstanter

Uttrykk

Enkelttermer

• Literal. Ruby literaler er numre, strenger, tabeller, hashtabeller, rekker, symboler og regulære uttrykk skrevet rett inn i kildekoden. Beskrivelsen av disse starter på side 201

• Skallkommando. En skallkommando er en streng avgrenset av backquotes (`) eller en generell avgrenset streng (side 200) som starter med %x. Verdien strengen returnerer er standard utput fra kjøringen av kommandoen som strengen utgjør i operativsystemets standard skall. Kjøringen setter også variabelen $? til skallkommandoens avslutningskode.

  filter = "*.c" files = `ls #{filter}` files = %x{ls #{filter}}

• Symbol-generator. Et Symbol-objekt lages ved å sette et kolontegn foran et operator-, variabel-, konstant-, metode-, klasse- eller modulnavn. Symbolet vil være unikt for hvert forskjellig navn, men refererer ikke til en spesifikk instans av navnet, så symbolet til (for eksempel) :fred vil være det samme uansett kontekst. Et symbol ligner på konseptet atomer i andre høynivå språk.

• Variabelreferanse eller konstantreferanse. En variabel refereres til ved å sitere dens navn. Avhengig av skop (se side 211) refereres en konstant ved enten å sitere dens navn eller ved å kvalifisere navnet, ved hjelp av navnet til klassen eller modulen som inneholder konstanten og skop-operatoren (``::'').

  barney    # variabelreferanse APP_NAMR  # konstantreferanse Math::PI  # kvalifisert konstantreferanse

• Metodekall. De forskjellige måtene metoder kan kalles på beskrives på side 227 og utover.

Operatoruttrykk

Ruby operatorer (fra høy til lav presedens) Metode Operator Beskrivelse Ja [ ]  [ ]= Elementreferanse, sett av elementer Ja ** Opphøying i potens (Exponentiation). Ja !  ~  +  -- Negetering (not), komplement, unær pluss og unær minus (metodenavn for de to siste er +@ and -@) Ja *  /  % Multiplisere, dividere og rest-operator (modulo). Ja +  -- Pluss og minus Ja >>  << Bitshift mot høyre og venstre Ja & Bitvis `og'-operator Ja ^  | Bitvis ekslusiv `eller' (XOR) og vanlig `eller' (OR) Ja <=  <  >  >= Sammenligningsoperatorer Ja <=>  ==  ===  !=  =~  !~ Operatorer for likhets- og mønstersammenligning (!= og !~ kan ikke defineres som metoder) && Logisk `og' || Logisk `eller' ..  ... Rekke (inklusiv og eksklusiv) ? : Ternær if-then-else konstruksjon =  %=  { /=  --=  +=  |= &=  >>=  <<=  *=  &&=  ||=  **= Tilordning defined? Sjekk om symbol er definert not Logisk negetering or  and Logisk komposisjon if  unless  while  until Uttrykksmodifikatorer begin/end Blokkuttrykk

Mer om tilordning

a, b, c = 1, "cat", [ 3, 4, 5 ]

anObj = A.new
anObj.value = "hello"   # ekvivalent med anObj.value=("hello")

Kobling mellom elementreferanse og metodekall Elementreferanse Faktisk metodekall anObj[] = "one" anObj.[]=("one") anObj[1] = "two" anObj.[]=(1, "two") anObj["a", /^cat/] = "three" anObj.[]=("a", /^cat/, "three")

Parallell tilordning

1. Dersom siste r-verdi har en stjerne (*) foran seg og er en Array så blir r-verdien byttet ut med elementene i tabellen, med hvert element som en egen r-verdi.
2. Dersom tilordningen inneholder flere l-verdier og en r-verdi, så blir r-verdien gjort om til en Array som ekspanderes til et sett av r-verdier slik som i (1).
3. Påfølgende r-verdier tilordnes til l-verdiene. Denne tilordningen skjer i effekt i parallell, slik at (for eksempel) a,b=b,a bytter om på verdiene i ``a'' og ``b.''
4. Dersom det er flere l-verdier enn r-verdier vil de øvrige bli tilordnet med nil.
5. Dersom det er flere r-verdier enn l-verdier vil de overflødige r-verdiene ignoreres.
6. Disse reglene endrer seg litt dersom siste l-verdi har en stjerne (*) foran seg. Denne l-verdien vil alltid motta en Array under tilordning. Tabellen vil inneholde den r-verdien som normalt ville blitt tilordnet til denne l-verdien, og eventuelt de øvrige ekstra r-verdiene.
7. Dersom en l-verdi er en liste omgitt av parenteser vil den bli behandles tom et nøstet tilordningsuttrykk, og listen tilordnes ut fra de korresponderende r-verdiene som beskrevet i disse reglene.

Blokkuttrykk

begin
  kropp
end

Boolske uttrykk

Sannhetsverdier

And, or, not og defined?

expr1  and  expr2
expr1  &&   expr2

expr1  or  expr2
expr1  ||  expr2

Sammenligningsoperatorer

Rekker i boolske uttrykk

if  expr1 .. expr2
while  expr1 ... expr2

Figur 18.1: Tilstandsoverganger for boolske rekker

Regulære uttrykk i boolske uttrykk

if /re/ ...

if $_ =~ /re/ ...

If- og unless-uttrykk

if boolsk-uttrykk [then]
  body
elsif boolsk-uttrykk [then]
  body
else
  body
end

unless boolsk-uttrykk [then]
  body
else
  body
end

If- og unless-modifikatorer

uttrykk if     boolsk-uttrykk
uttrykk unless boolsk-uttrykk

Ternæroperator

boolsk-uttrykk ? expr1 : expr2

Case-uttrykk

case target
  when [
            comparison
            ]+
             [then]
    body
  when [
            comparison
            ]+
             [then]
    body
  ...
[ else
    body ]
 end

Løkker

while boolsk-uttrykk [do]
  body
end

until boolsk-uttrykk [do]
  body
end

for [
            name
            ]+
             in uttrykk [do]
  body
end

uttrykk.each do | [
            name
            ]+
             |
  body
end

While- og until-modifikatorer

uttrykk while boolsk-uttrykk
uttrykk until boolsk-uttrykk

Break, redo, next og retry

Metodedefinisjon

  def defname [( [
            arg [=val
            ]
            ]*
             [, *vararg
            ] [, &blockarg
            ] )]
    body
  end

                

defname 
                
 <-
                
 methodname 
              
              

                

                
        
                
 expr.methodname

              
            

class MyClass
  def MyClass.method      # definition
  end
end

MyClass.method            # call

anObject = Object.new
def anObject.method       # definition
end
anObject.method           # call

def (1.class).fred        # receiver may be an expression
end
Fixnum.fred               # call

Argumenter til metoder

Kalle en metode

  


                

  [
                  receiver. ] name  [ parameters ] [ block ]
                
              
              

                

                  [
                  receiver::] name [ parameters ] [ block ]
                
              
              

                

              
              

                

                  parameters 
                
 <-
                
 ( [
                  param
                  ]*
                   [, hashlist
                  ] [*array
                  ] [&aProc
                  ] ) 
              
              

                

              
              

                

                  block 
                
 <-
                
 { blockbody }     
              
              

                

                
        
                
 do blockbody end
  
              
            
                      

def regular(a, b, *c)
  # ..
end
regular 1, 2, 3, 4
regular(1, 2, 3, 4)
regular(1, *[2, 3, 4])

aProc   = proc { 99 }
anArray = [ 98, 97, 96 ]

def block
  yield
end
block { }
block do
      end
block(&aProc)

def all(a, b, c, *d, &e)
  puts "a = #{a}"
  puts "b = #{b}"
  puts "c = #{c}"
  puts "d = #{d}"
  puts "block = #{yield(e)}"
end

all('test', 1 => 'cat', 2 => 'dog', *anArray, &aProc)

a = test
b = {1=>"cat", 2=>"dog"}
c = 98
d = [97, 96]
block = 99

Foo.Bar()         #  method call
Foo.Bar           #  method call
Foo::Bar()        #  method call
Foo::Bar          #  constant access

return [
            expr
            ]*
            

super

super  [ ( [
            param
            ]*
             [*array
            ] ) ]  [
            block
            ]

Operator-metoder

expr1 operator
operator expr1
expr1 operator expr2

(expr1).operator(expr2)

Tilordne attributter

receiver.attrname = rvalue

Elementreferanse-operator

receiver [
              expr
              ]+
               
receiver [
              expr
              ]+
                = rvalue

Aliasing

alias newName oldName

Klassedefinisjon

class classname  [< superexpr
            ]
  body
end

class << anObject
  body
end

• Metodedefinisjoner vil registrere metodene i en tabell i klasseobjektet.
• Nøstede klasse- og moduldefinisjoner lagres i konstanter i klassen og ikke som globale konstanter. Disse nøstede klassene og modulene kan man få tak i fra utsiden av den definerende klassen ved å bruke ``::'' for å kvalifisere navnene deres.

  module NameSpace   class Example     CONST = 123   end end obj = NameSpace::Example.new a = NameSpace::Example::CONST

• Metoden Module#include legger de angitte modulene som anonyme superklasser til klassen som defineres.

Instansiere objekter av klasser

obj = classexpr.new [ ( [
            args
            ]*
             ) ]

• Lager et instansobjekt av klassen som mottakeren angir (classexpr i syntakseksempelet).
• Setter det objektets type til å være mottakeren.
• Kaller instansmetoden initialize i det nylagede objektet og videresender eventuelle argumenter som ble gitt til new.

Deklarere klasseattributter

class name
  attr attribute  [, writable
            ]
  attr_reader     [
            attribute
            ]+
            
  attr_writer     [
            attribute
            ]+
            
  attr_accessor   [
            attribute
            ]+
            
end

Moduldefinisjoner

module name
  body
end

module Mod
  CONST = 1
  def Mod.method1    # module method
    CONST + 1
  end
end

Mixin---inkludere moduler

class|module name
  include expr
end

Modulfunksjoner

module Math
  def sin(x)
    #
  end
end

# Eneste måten å få tak i Math.sin er...
include Math
sin(1)

module Math
  def sin(x)
    #
  end
  module_function :sin
end

Math.sin(1)
include Math
sin(1)

Tilgangskontroll

• Public. Tilgjengelig for alle.
• Protected. Kan kun kalles av objekter av den definerende klassen og dens subklasser.
• Private. Kan kun kalles i funksjonell form (det v il si, med en implistitt self som mottaker). Private metoder kan derfor kun kalles i fra den definerende klassen og direkte arvtakere inne i fra et og samme objekt.

private    [
            aSymbol
            ]*
            
protected  [
            aSymbol
            ]*
            
public     [
            aSymbol
            ]*
            

1. Uten noen argumenter, setter de tre funksjonene den gjeldende standard tilgangskontroll for de påfølgende metodene som defineres.
2. Med argumenter, setter funksjonene tilgangskontrollen på de angitte metodene og konstantene.

Blokker, tillukninger (closures) og Proc-objekter

invocation  do  | a1, a2, ... |
end

invocation  {   | a1, a2, ... |
}

Proc-objekter

Unntak

Heve unntak

raise
raise aString
raise thing [, aString [
            aStackTrace
            ]
            ]

Håndtere unntak

  begin
    code...
    code...
[rescue  [parm]*
             [=> var
            ] [then]
    error handling code... ]*
            
[else
    no exception code...
            ]
[ensure
    always executed code...
            ]
  end

Prøve en blokk på nytt

Catch og throw

catch ( aSymbol | aString )  do
  block...
end

throw( aSymbol | aString [, anObject
            ] )

$Log: language.xml,v $
Revision 1.18  2003/08/04 16:07:10  kent
Første utkast til language.