Ruby Spickzettel

 

Case-Konstrukt
--------------

i = 10
case i
  when 10, 20, 30
    puts "i ist 10 oder 20 oder 30"
  when 1
    puts "i ist 1"
  else
    puts "i ist irgendwas anderes"
end



Modusstring Dateioperationen
----------------------------

r   - nur lesen
r+  - nur lesen, beginnt am Anfang der Datei
w   - nur schreiben
w+  - lesen + schreiben
a   - schreiben anhängend (append)
a+  - lesen + schreiben am Ende
b   - Binärmodus, nur für Dos/Windows (z.B. wb, rb)

Globale Variablen
-----------------

Exceptions:
$!  Exception Information Message.

$@  Backtrace of the last Exception.


Reguläre Ausdrücke:
$&  gefundenes Suchmuster der letzten Aktion. 
    nil, wenn nicht gefunden.

$`  String, der dem Gefundenen vorausgeht.

$'  String, der dem Gefundenen folgt

$+  Übereinstimmung der letzten Klammer(?)

$1, 
$2,...  Teilstrings, die durch Klammern im Suchmuster
        getrennt sind.

$~  Information der letzten Musteraktion. $1 - $9 werden
    hieraus abgeleitet und eine Änderung von bspw. $~[3]
    ändert $3. Die Variable ist lokal zum aktuellen 
    Gültigkeitsbereich

$=  Groß/Kleinschreibung berücksichtigen. Ein Wert ungleich
    nil führt dazu, das sie nicht berücksichtigt wird. 
    Default ist nil.


IO:

$/  Input Record Separator, \n default, wenn nil, dann
    wird das gesamte File mit einmal eingelesen.

$\  Output Record Separator für print und io#write. 
    Default ist nil.

$,  Output Field Separator für print und Array#join

$;  Default Separator für String#split.
$-F

$.  Current input line Number, des zuletzt gelesenen Files.

$<  Aktuelles Input File. stdin, wenn kein File übergeben.
ARGF

$>  Aktuelles Output File. stdout ist default.

$_  Zuletzt gelesene Zeile des Input Files. 
    (gets oder readline)
    nil, wenn eof.

$stdin  Standard Input

$stdout Standard Output

$stderr Standard Error

$defout Default Output


Environment:

$0  Filename des Ruby-Skripts

$*  Command line arguments, welche dem Skript übergeben
    wurden. (Array)
ARGV

$$  Prozess Nummer des Ruby-Skripts.

$:          Array, welches alle Suchpfade beinhaltet, 
$LOAD_PATH  wo load und require suchen.
$-I

$"  Array, Liste von allen geladenen Modulen, die durch
    require geladen wurden. Require nutzt diese, um Module
    nicht doppelt zu laden.

$VERBOSE  Verbose Flag, welches durch -v gesetzt wird
$-v

$DEBUG  Status des -d Switches
$-d

$-a  Wahr, wenn -a gesetzt wurde

$-i  Wenn -i gewählt, dann steht hier die extension

$-l  Option -l ist gesetzt.

$-p  Option -p ist gesetzt.

$?   Exitcode eines externen Programmes, welches mit `cmd` 
     ausgeführt wurde. Sollte mit $?.to_i >> 8 korrigiert 
     werden. 0 entspricht keinem Fehler unter Linux.


Prozess:
$?  Status des zuletzt gestarteten Child-Prozesses


Standard-Objekte:
ENV  Ein Hash, mit dem man auf alle Environment-Variablen Zugriff hat.
Bsp: ENV["PATH"] = '/usr/bin'

false  Der Wert false
nil    Der Wert unitialisiert
self   Der Empfänger der aktuellen Methode
true   Der Wert true	


Globale Konstanten
------------------

TRUE    true
FALSE   false
NIL     nil
STDIN   stdin, default value for $stdin
STDOUT  stdout
STDERR  stderr
ENV     Environment Variablen, hash
ARGF    Alias zu $<
ARGV    Alias zu $*
DATA    ?
VERSION            Ruby Version String
RUBY_RELEASE_DATE  Release String
RUBY_PLATFORM      Platform 

Kommentare
----------

# Comment

=begin
Comment
...

=end

i18n / Zeichensätze
-------------------

Jeder String und jedes IO-Objekt hat eine Eigenschaft Zeichensatz hinterlegt.
Dieser wird verwendet, um den Bytestrom richtig zu intepretieren. 

String (Bytestrom) auf Basis eines Zeichensatzes interpretieren
* str.force_encoding( "utf-8" )

String in einen anderen Zeichensatz umwandeln/konvertieren
* str.encode( "iso-8859-15" )

String auf Basis eines Zeichensatzes intepretieren und dann konvertieren
* str.encode( <Ziel-Zeichensatz>, <Interpretation von str> )
* str.encode( "iso-8859-15", "utf-8") ist identich mit 
  str.force_encoding( "utf-8" ).encode( "iso-8859-15" )

Dateizugriffe
* File.readlines( filename, :encoding =>  "iso-8859-15")
* File.open( filename, :encodign => "iso-8859-15" )

Exeptions: Wird im Bytestrom eine Sequenz gefunden, die nicht zum aktuellen
Zeichensatz passt, wird eine Exeption abgeworfen. Will man das nicht und 
stattdessen solche Zeichen mit einer Vorgabe ersetzen, dann geht das so:
* s.encode( "utf-8", :undef => :replace, :replace => "??" )


Datei-Zugriffe
-------------

f = File.open( filename, "r" )  # lesend (r+ = read/write)
f = File.open( filename, "w" )  # überschreibend (w+ = read/write)
f = File.open( filename, "a" )  # anhängend schreibend (a+ = read/write)
f = File.open( filename, "rb" ) # lesend binär
f = File.open( filename, "w", 0660 ) # schreibend, wenn nicht existiert, dann 
                                     # neu anlegen mit 0660 Rechten. 
                                     # Achtung: Wird mit umask maskiert.
                                     # Wenn File bereits vorhanden, keine Änderung
                                     # der Rechte
f.close() # File schließen

Modes: r, r+, w, w+, rb, wb, a, a+

File.open( filename, "w" ) do |f|
  f.puts "Foobar"
end

File.foreach( filename ) do |line|
  puts line
end

arr = File.readlines( filename, :encoding => "utf-8" ) # Alle Zeilen lesen

fn = File.join( dirname, dirname, ... , filename )

Dir.foreach( path ) do |file| ... end  # Verzeichnis alle Dateien/Ordner

Dir.mkdir( dir ) # Verzeichnis erstellen

File.file?() # ist es ein File
File.directory?()  # ist es ein Verzeichnis

Klassen
-------

class MyClass
  Constant1 = "Foobar"
  @@class_info = "Klassenvariable"

  def self.classMethod
    puts @@class_info
    # Bei Vererbung verhält sich self.Classmethod anders, als MyClass.ClassMethod
  end

  def initialize..
    #Objekt-Inititialisierung durch Aufruf von MyClass.new
  end

  def public_methods...
    @instanz_variable = "Objektdaten"

  private
    def privat_methods...


  private_class_method :classMethod

  attr_accessor :x, :y ...

  attr_reader :x, :y

  attr_writer :x, :y
end



Module
------

module Config
  Debug = true
  Path = "/etc" 
end

if Config::Debug ...

--

Array
-----

a = [ "first", "second" ]

a[0]  # -> "first"

a.pop # -> "second"  Element wird entfernt

a.push( "second" )  # Wird hinten angefügt

a << "third"  # identisch mit push

a.each do |element|
  puts element
end

a.each_index |i|
  puts a[i]
end

puts a.join( "\n" )   #Array als String zusammenfügen
                      #hier mit Zeilenschaltung separiert

String
------

s = "Hello\n"

s.chomp   #return string ohne Zeilenschaltung "\n" und auch "\r\n" wird entfernt
s.chomp!  #verändert s in "Hello"