Kaltstart Ruby

Hier gibt es die Grundlagen der Ruby Programmierung. Von einfachen Methoden bis hin zu Klassen und default Parametern.

Zunächst muss man sich Rubymine installieren, welches man als Student kostenlos bekommt. Jetbrains Student

Den Testserver gibt es ab dem Hackathon RoboHack hier zum Download.

 

Vom Taschenrechner zum Hackathon

Beim ersten Start von Rubymine befindet man sich im Startbildschirm wo wir ein Projekt von Version Control auschecken wollen.

01

Genauer gesagt von Git.

02

Während dem Folgen der Dialoge benötigt man die Url zum Projekt: git@fuersts1.homeip.net:Hackathon-Framework.

03

04

 

Jetzt haben wir ein vorbereitetes Projekt aus Git in RubyMine geladen und wir können Anfangen unseren Code einzufügen. Ich empfehle stark sich die Features rund um die Git-Integration mal genauer anzuschauen.

Der Taschenrechner

Dazu erstellen wir uns zuerst eine eigene Klasse.

05

Ich gebe der Klasse den Namen MyClient, da wir sie später zu einem Client für einen Hackathon ausbauen werden. Nach Durchlaufen des kurzen Dialogs sollte die Klasse wie folgt aussehen, falls nicht, bitte anpassen.

06

Bevor wir die Kasse sinnvoll Instanziieren können, müssen wir allerdings noch ein paar Sprachfeatures von Ruby lernen. Und ist da besser geeignet als ein ganz simpler Taschenrechner. Wir wollen 2 Zahlen in die Konsole eingeben und diese anschließend addieren und das Ergebnis ausgeben.

if __FILE__ == $0
  a = 1
  b = 7
  puts "#{a} + #{b} = #{a + b}"
end

Mit if __FILE_ == $0 wird sichergestellt, dass der Code nur ausgeführt wird, wenn wir dieses Skript direkt starten. Das ist wichtig, falls wir unser aktuelles Skript in ein anderes inkludieren möchten (require-Schlüsselwort kommt später).

Das Anlegen und Zuweisen von Werten an Variablen funktioniert kinderleicht, einfach mit a = 1.

Die Ausgabe auf der Konsole funktioniert mittels puts, wobei man mit #{variable} in Strings mit doppelten Anführungszeichen vorher angelegte Variablen nutzen kann.

Mal Schauen ob das Programm tut, was wir erwarten. Dazu führen wir es einfach aus.

07

Und siehe da die Ausgabe lautet 1 + 7 = 8. Perfekt.

 

Naja, noch ist der Taschenrechner nicht sehr interaktiv, dazu ersetzen wir einfach mal die 1 und die 7 durch ein gets.

if __FILE__ == $0
  a = gets
  b = gets
  puts "#{a} + #{b} = #{a + b}"
end

Wer schnell im Ausführen ist, wird Feststelen, dass die Eingabe nicht, wie gewünscht ist. Und man erst mal wissen muss, dass man etwas eingeben muss.

1
2
1
+ 2
= 1
2

Warum ist die Ausgabe auf einmal so komisch? Das liegt daran, dass Ruby die Angewohnheit hat zum gets auch den Zeilenumbruch dazu zu zählen, wir müssen ihn also händisch entfernen. Dabei hilft die chomp Methode.

if __FILE__ == $0
  a = gets.chomp
  b = gets.chomp
  puts "#{a} + #{b} = #{a + b}"
end

Schon besser:

1
2
1 + 2 = 12

Halt 1 + 2 = 12? Da stimmt doch was nicht! Nun ja wir haben 2 Strings addiert, das bedeutet eine einfache Konkatenation. Unter dem Gesichtspunkt verhält sich unser Programm also richtig, wir haben uns nur ungeschickt ausgedrückt. Wir müssen ruby mittels to_i einfach mitteilen, dass wir hier bitte einen Integer möchten.

if __FILE__ == $0
  a = gets.chomp.to_i
  b = gets.chomp.to_i
  puts "#{a} + #{b} = #{a + b}"
end

Die Ausgabe ist nun wie gewünscht:

1
2
1 + 2 = 3

So ein Taschenrechner ist zwar toll für den Anfang, aber auf dauer etwas langweilig, also auf geht es an die Hackathon Programmierung.

 

Auf zum Hackathon

Dazu widmen wir uns zunächst der Klasse MyClient.

Dort definieren wir eine Methode zur Initialisierung, die den eigenen Namen, einen Host und Port als Parameter erwartet, jedoch auch ohne Letztere auskommt.

class MyClient
  def initialize(name, host = 'localhost', port = 25555)

  end
end

Ist doch recht intuitiv in der Schreibweise. Mittels host = ‚localhost‘ teilen wir Ruby mit, dass der Parameter optional ist und es doch der Variable ‚localhost‘ zuweisen soll, wenn wir den Parameter beim Aufruf nicht angeben.

Als Nächstes wollen wir einen Client erstellen ihm sagen, wie wir heißen, und schauen, was der Server antwortet.

Dazu müssen wir zunächst die bereits implementierte Klasse Client inkludieren, indem wir an den Anfang der eigenen Datei

require_relative '../ruby-impl/Client'

hinzufügen.

Anschließend wird die initialize Methode von MyClient implementiert. ‚localhost‘ sollte beim Hackathon durch die IP des Spielservers ersetzt werden.

def initialize(name, host = 'localhost', port = 25555)
  client = Client.new host, port
  client.send_name(name)
  puts client.read_map
end

Mittels Client.new erzeugen wir eine neue Instanz von Client und geben ihr eine Gegenstelle, um sich zu verbinden. Anschließend senden wir unseren Namen und geben die Antwort des Servers aus.

Wenn wir jetzt das Programm ausführen, passiert noch nichts. Das sollten wir schnell ändern, indem wir den Taschenrechner Code ersetzen durch Abfragen unseres Namens, und instanziieren von MyClient.

if __FILE__ == $0
  puts 'Gib deinen Namen ein: '
  name = gets.chomp
  my_client = MyClient.new name
end

Man kann man die Parameter für den Server weglassen, da sie ja eine Initialisierung in der initialize Methode besitzen.

Zeit kurz inne zu halten und zu schauen, wie das gesamte Programm aussieht und was die Ausgabe ist.

require_relative '../ruby-impl/Client'

class MyClient
  def initialize(name, host = 'localhost', port = 25555)
    client = Client.new host, port
    client.send_name(name)
    puts client.read_map
  end
end

if __FILE__ == $0
  puts 'Gib deinen Namen ein: '
  name = gets.chomp
  my_client = MyClient.new name
end

Gib deinen Namen ein:
Michael
{„scene“=>[]}

 

Sieht schon gut aus. Aber wir bekommen nur eine Antwort des Servers, mal schauen, ob wir das verbessern können. Dazu senden wir dem Server einfach immer einen Ping in einer Dauerschleife nach puts client.read_map

while true
  client.send_ping
  puts client.read_map
end

Viel besser…
Gib deinen Namen ein:
Michael
{„scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}
{„ping“=>“pong“, „scene“=>[]}

Wobei das noch nicht sehr viel kann. Versuchen wir mal mit dem Ergebnis des Ping zu arbeiten. Wir wollen nun das Programm beenden, wenn in der „scene“ etwas anderes steht als ein leeres Array. Dazu modifizieren wir die while Schleife und lesen den Wert ‚Scene‘ aus und schauen ob die Arraylänge > 0 ist.

while true
  client.send_ping
  result = client.read_map
  if result['scene'].length > 0
    exit 0
  end
end

Zum Testen müssen wir das Skript nun 2 Mal starten, da der Server bei nur einem verbundenem Client die Füße stillhält und nichts tut.

Zum Schluss noch einmal das komplette Programm und die erwartete Ausgabe. (Wenn man den MyClient 2-mal startet und bei beiden einen Namen eingibt.)

require_relative '../ruby-impl/Client'

class MyClient
  def initialize(name, host = 'localhost', port = 25555)
    client = Client.new host, port
    client.send_name(name)
    puts client.read_map
    while true
      client.send_ping
      result = client.read_map
      if result['scene'].length > 0
        exit 0
      end
    end
  end
end

if __FILE__ == $0
  puts 'Gib deinen Namen ein: '
  name = gets.chomp
  my_client = MyClient.new name
end

Gib deinen Namen ein:
Michael
{„scene“=>[]}

Jetzt sind alle wichtigen Konzepte der Sprache Ruby vermittelt, die man für einen Hackathon benötigt. Wer sich mit Programmierparadigmen auskennt, dem sei gesagt, dass Ruby sich des Ducktyping bedient.
Weitere Schritte zu einem Erfolgreichen Hackathon findest du unter Hackathon Essentials.

 

One MoreThing

Der Code sollte vielleicht auch auf Github landen nicht wahr? Dazu erstellt man ein Projekt auf Github und kopiert die clone URL.

Anschließend öffnet man im Projektordner eine Konsole und gibt

git remote set-url origin https://github.com/penguinmenac3/Hackathon-Framework.git

ein. Wobei man die URL durch seine eigene ersetzt.

09

Als Letztes gestehen (commit) wir noch unsere Änderungen in RubyMine. Dazu machen wir einen Rechstsklick auf MyClient und wählen „git->add“ und anschließend noch mal „git->Commit Directory“. Im Anschluss wie gezeigt dem Dialog folgen.

10

Im nächsten Dialog einfach den Push bestätigen, evtl. müssen noch Nutzerdaten für Github angegeben werden.

Geschafft. Alles ist sicher auf Github.

Schreibe einen Kommentar