RGSS für Dummköpfe/Blocks und Methoden

Aus Scientia
Version vom 15. August 2013, 05:04 Uhr von Playm (Diskussion | Beiträge)

(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)
Wechseln zu: Navigation, Suche
RGSS für Dummköpfe Schwierigkeitsgrad Stern.png
Autor Max Jet
Thematik RGSS
Vorraussetzungen Programme: keine

Fähigkeiten: keine

Andere Teile

Blocks

Ein Block ist nur eine Gruppe von miteinander verbundenen Anweisungen für deinen Computern, nur ein paar Code Zeilen, die von etwas umschlossen werden. Stell dir einen Block einfach als eine Liste von Anweisungen vor, oder besser noch, als eine Kiste mit mehreren Kisten darin. So kannst du dir das auch vorstellen.

  • Kommando 1
  • Kommando 2
  • Kommando 3
  • Kommando 3 : 1
  • Kommando 3: 2
  • Kommando 3 : 2 : 1
  • Kommando 3 : 2 : 2
  • Kommando 3 : 3
  • Kommando 4
  • Kommando 4 : 1
  • Kommando 4 : 2
  • Kommando 5
  • Berechne Summe für 1 und 2 Festlegung Summe (benötige x, y)
  • Berechne Multiplikation für 3 und 5 - Ruf auf Antwort_ist
  • Berechne Summe für 0 und 10 - print x + y
  • Berechne Subtraktion für 4 und 1
  • Berechne Subtraktion für 9 und 3 Festlegung Subtraktion
  • falls 1>2 - Ruf auf Antwort_ist
  • Berechne Summe für 3 & 1 - print a - y
  • Print „Inside if!“
  • Berechne Multiplikation für 9 und 10 Festlegung Multiplikation (req u,v)
  • Rufe auf Antwort_ist - Ruf auf Antwort_ist
  • Print „Du bist ein Verlierer!“ - print u*v
  • Beende Programm

Festlegung Antwort_ist (benöt. Nichts) Print „Antwort_ist“

Blöcke müssen aber nicht unbedingt in Reihenfolge stehen.

Das ist ein einfaches (nicht funktionstüchtiges) Programm, dass in etwa, wie ein Taschenrechner funktioniert. Die einzelnen Absätze zeigen einfach Blöcke. Das ganze an sich zeigt die „Page“, also die Seite wo das Programm geschrieben wurde. Auf der linken Seite stehen ein paar Befehle, die meistens etwas aufrufen. Außerdem gibt es da noch den „if Command“, der immer den Wert „false“ hat und zuletzt noch ein print Befehl, sowie ein Befehl zum schließen des Programms. Das wären die Ergebnise: 

Antwort ist: 3 
Antwort ist: 15 
Antwort ist: 10 
Antwort ist: 3 
Antwort ist: 6 
Antwort ist: 90 
Antwort ist: "Antwort ist!"

Genau, wie ich vorher gesagt habe, ein Block ist nichts weiter, als mehrere Zeilen von Codes, die zusammen gruppiert wurden. Die „control flow statements“, die wir in einem früheren Tutorial besprochen haben, besitzen ihren eigenen Block, mit „end“ abgeschlossen wurde. 

if kuh 
  # Hier beginnt der Block 
  p "kuh ist wahr!" 
  p "Das ist so super!" 
  x = 2 
  p x 
  # und hier endet er 
end

Alle „print“ Befehle (In die Zuweisungen) formen den Block für das „if“, also falls. Wie du sehen kannst, besteht dieser Block aus einer Reihe von „print“ Befehlen und einer Zuweisung, alles zusammen gruppiert. Sie werden nur ausgeführt, wenn die Variable Kuh den Wert wahr, also „true“ besitzt. Die Befehle in diesem Block verhalten sich wie ein Freundeskreis, die alles zusammen unternehmen. Entweder werden alle Befehle ausgeführt, oder gar nicht.

Die „while loop“ (während Schleife), hat ebenfalls einen Block, der ausgeführt wird, während eine Bedingung erfüllt bleibt. Das gleiche gilt für die anderen Schleifen, oder „loops“ (Der „for loop“ zum Beispiel wird immer und immer wieder mit unterschiedlichen Werten ausgeführt.

Der Kontrollfluss deines Programms ist aber nicht der einzige Sinn deines Blocks. Du kannst auch einen benannten Block nehmen und ihn aufrufen wann immer du willst. Ein benannter Block wird Methode oder Funktion genannt und ist sehr nützlich. Wenn du zum Beispiel den gleichen Code an verschiedenen Stellen in deinem Programm verwendest, musst du ihn einfach nur erstellen, ihm einen Namen geben und dann immer aufrufen, wenn du magst.

Weiterhin kannst du Werte an diesen Blokc weitergeben (send). Ein Beispiel: Ein Block kann einen Namen akkzeptieren und eine Grußnachricht anzeigen. In etwa so: 

def greetings (name) 
  p "Hallo " + name 
  p "Wie geht es dir heute?" 
end

Die 'def' Sache, die Definition, ist nur ein Schlüsselbegriff, das dem Programm sagt, dass wir eine Methode (also einen benannten Block) definieren (def steht für definieren). Die Art und Weise Methoden zu erstellen variiert von Programmiersprache zu Programmiersprache, aber in Ruby nutzt man dazu oft „def“. Als nächstes siehst du „greetings“ (Grüße), den Namen des Blocks, den wir auch später benutzen um ihn selbst aufzurufen. Zwischen den daraufhin folgenden Klammern befindet sich die Varaible oder die Werte, welche die Methode braucht, oder wonach sie fragt. Name stellt die Variable dar, welche alles akkzeptiert, was an die Funktion gesendet wird. Der eigentliche Block beginnt erst nach dem ) und mit dem Anzeigebefehl p "Hallo" + name. Du kannst die Methode auch so aufrufen: 

greetings("String")

Bei "String" könnte es sich um jedwege Art von Strin handeln, wie etwa „Alex“, „Sephiroth“, oder wasauchimmer. Stell dir nun vor du wärest der Ruby Auswerter (oder der RPG maker) und wirst darum gebeten diesen Befehl zu lesen. (greetings("String")), sowie ihn auszuführen. Das müsstest du dafür tun.


  • Such nach einer Methode (Block) mit dem Namen „greetings“ indem du nach „def greetings suchst“
  • Die „greetings“ Methode akkzeptiert „strings“, also sendest du den String in den Klammern an den Aufruf „call“.
  • Wie sendet man einen Wert? Nun, du siehst, dass greetings derart definiert wird: (def greetings(name)). Alles was du nun machst ist eine Variable mit dem Namen „name“ zu schaffen und ihm dem „String“ zuzuweisen. (So, wie einen Namen machen = „String“)
  • Nun betrittst du den greetings Block.
  • Du wirst gebeten folgendes anzuzeigen (p): "Hello " + name. Da der Wert von name nun „String“ ist, wird "Hello String" angezeigt.
  • Du wirst gebeten "How are you doing today?" anzuzeigen, was du auch machst.
  • Du findest 'end' in der folgenden Zeile, was dir zeigt, dass die methode dort endet, also gehst du zurück zu greetings("String") (Der Befehl, der die Methode aufgerufen hat) und führst aus, was auch immer folgen mag.


Wenn du das alles nicht verstehst, gerat nicht in Panik, alles wird deutlicher, wenn wir die Beispiele sehen werden. Merke einfach nur, dass wir zwei Zeilen eines Scripts aufgerufen haben, obwohl wir nur eine schrieben. Du kannst ebensogut eine Batzillion Zeilen eines Scripts aufrufen, indem du nur eine einzige schreibst. Hilft dir dein Programm zu ordnen. Greetings kannst du immer wieder aufrufen, so oft und so viel du willst. Lass uns jetzt verstehen, wie das Beispiel oben funktioniert. Sieh noch einmal hoch ^.


Das ist natürlich kein Ruby Code, weil es keinen Befehl namens Call (Aufrufen) gibt und require wird ebensowenig gebraucht (genau, wie req., also das Kürzel). Um genau zu sein hat require (benötigen), im Ruby eine ganz andere Bedeutung. Das ist nur ein Beispiel, dass dir zeigen soll, wie Methoden arbeiten.

Zuerst einmal rufen wir die Methode „Summe“ (also sum) auf und zwar mit den Werten 1 und 2. Das ist so, als würde man (sum(1, 2)) in Ruby schreiben. Die „sum“ Methode wird dann mit jenen Werten ausgeführt, sie werden den Variablen x und y zugewiesen und dann auf dem Bildschirm angezeigt. Bevor die Summe allerdings berechnet wird, ruft der Code eine andere Methode namens answer_is auf. Methoden kann man auch innerhalb von Methoden aufrufen. Auf die gleiche Art und Weise werden andere Methoden aufgerufen (subtract multiply) und auch mit unterschiedlichen Werten. Am Ende des Programms wird die answer_is Methode aufgerufen um "Answer is: " anzuzeigen. Merke, dass answer_is keine Variablen erfordert, weil es mit keinen Variablen operieren muss. In Ruby rufst du eine Methode auf, die keine Werte akzeptiert, indem du leere Klammern setzt (answer_is()). Du kannst natürlich auch überhaupt auf Klammern verzichten (answer_is). Beim definieren schreibst du das gleiche.

Methoden

Ich hoffe diese kleine Einleitung hat dir eine Vorstellung von Methoden verschafft. Falls dem nicht so ist, mach dir keine Sorgen, denn mit einigen Beispielen wird alles viel klarer. Eine Methode ist ein benannter Block, der Werte akzeptieren kann und auch welche wiedergeben. In anderen Programmiersprachen werden Methoden auch als Funktionen bezeichnet (eine Methode ist im Grunde genommen ein Funktionsglied einer Klasse (class). Merk dir, dass Methoden nie ausgeführt werden, es sei denn man ruft sie explizit auf. Eine Methode die du korrekt erstelst und inmitten deines Programms setzt wird nichts tun, es sei denn du rufst sie in einem eigenständigen laufendem Teil deines Programms auf. (Anm von Max Jet: Vergleiche das mit Events auf deiner Karte bei denen steht (key is pressed). Sie werden erst ausgeführt, wenn du die Eingabetaste betätigst. Ähnlich sind die Methoden. Sie warten darauf, aufgerufen zu werden. Erst dann beginnen sie mit der Arbeit.) Stell dir Methoden als Knöpfe vor, die unterschiedliche Dinge tun. Diese Sachen werden nicht passieren, es sei denn du drückst den Knopf. Die Definition einer Methode sähe in etwa so aus: 

def name(value1, value2, value3,... etc.) 
  method's body 
end

Name ist der Name der Methode, wir werden ihn später benutzen um die Methode aufzurufen. Die Namen der Methoden sind wie Namen der Variablen, also müssen beide mit einem kleinen Buchstaben beginnen und drüfen kein Leerzeichen enthalten. value1, value2, value3,...etc werden Parameter genannt. Parameters sind Variablen, die alles akzeptieren, was du an eine Methode sendest. Du kannst so viele Parameter haben, wie du willst und du kannst ebensogut auch Methoden haben, die keinen einzigen Wert akzeptieren werden (indem du keine Klammern nutzt, oder sie leer stehen lässt def name() oder def name). Der Körper einer Methode ist der Block, der ausgeführt wird, wenn die Methode aufgerufen wird. Jeder funktionstüchtige Ruby Code ist dafür zulässig. Natürlich darfst du es auch so lang schreiben, wie du willst, denk aber daran, dass der eigentliche Sinn dein Programm in überschaubare Teile zu gliedern dadurch zunichte gemacht werden könnte. Zuviele Methoden zu haben ist allerdings auch nicht so gut (weil man sich alle so schlecht merken kann). Versuch einfach die Verhältnismäßigkeit zu bewahren. Die Erklärung von Methoden endet immer mit 'end'. Sobald das Programm darauf trifft (oder vielleicht auf ein return Befehl), kehrt es wieder zum Aufruf zurück, also die Stelle wo die Methode aufgerufen wurde und führt das eigentliche Programm einfach weiter aus. Also wie rufen wir denn jetzt Methoden auf? Einfach so!: 

name(value1, value2, value3,...etc.)

Name ist der Name der Methode, die du aufrufen willst und value1, value2, ...etc. sind die Werte, die du senden willst. Sende aber nicht mehr wertem als die Methode wirklich braucht (innerhalb der Definition), aber auch nicht weniger (Außer du gebrauchst default Werte, die ich später erklären werde). Um eine Methode aufzurufen, die keine Werte braucht, verwendest du, wie bereits gesagt, einfach nur den Namen der Methode mit leeren Klammern, oder überhaupt keinen. Die Werte können entweder direkte Werte sein (1, 4, "Hallo welt", true) oder Variablen, welche die Werte speichern. Es können auch Ausdrücke sein, auch „expressions“ genannt, (1-2, "Hallo" + var, 3 + 5 - 2, var

Dir ist bestimmt langweilig, stimmts? Willst du ein paar Beispiele sehen? Das hier gehört zu meinen liebsten! 

def abs(eine_nummer) 
  if eine_nummer >= 0 
    return eine_nummer 
  else 
    return -1 * eine_nummer 
  end 
end 
#................. 
x = abs(19) 
p x 
p abs(7 - 12) 
#=========== 
#=========== 
def sum(value, einanderer_value) 
  return value + einanderer_value 
end 
#................. 
p sum(0, 6) 
lol = sum(-1, 1) 
if sum(lol, sum(5,6)) > 14 
  p "wasauchimmer" 
end

Diese Methode zeigt den absoluten Wert an, welcher Nummer auch immer du ihr zusendest. Der absolute Wert hat kein Negativzeichen, es wird benutzt um die Größe von jemandem zu messen, oder den Abstand zwischen zwei Objekten festzulegen. Solche Werte könne nicht negativ sein! (-10 Kilometer kannst du nicht sagen..)Was diese Methode jetzt eigentlich macht, ist zu überprüfen, ob die Zahl, die sie erhalten hat größer, oder kleiner als 0 ist. So zeigen wir es auch einfach auf dem Bildschirm an. (Sie sind sowieso positiv, als ist der absolute Wert von 3 natürlich auch 3 und der absolute Wert von 9 natürlich auch 9). Wenn allerdings die Zahl kleiner als 0 ist, müssen wir das Negativzeichen entfernen. Iwr multiplizieren mit –1. (an. Von Max Jet: Es handelt sich hier nur ume ine Erläuterung des Betrages. Jegliche Zahl die wir nehmen, sei sie positiv, oder negativ legen wir einfach in seiner Entfernung von 0 auf dem Zahlenstrahl fest. Daher können wir seine linksseitige oder rechtseitige Position auf dem Zahlenstrahl vollkommen aus der Rechnung auslassen). Wir entfernen das Negativzeichen durch Multiplikation der Zahl mit –1. Das bringt uns einen positiven Wert. Wenn du das Beispiel nicht verstehst, dann schlage ich vor, dass du dir das Variablen und Kontrollfluss Tutorial noch einmal ansiehst. Die beiden „end“ am Ende des Codes betreffen die Fallaussage und die Methode.

Nun, da wir jetzt die Methode haben, rufen wir sie auf. Eine Methode aufzurufen ist total einfach:

(siehe auch Math) 

abs(number)

Zum Beispiel: 

abs(3) 
abs(-6) 
abs(2 - 6) 
abs(23545) 
abs(0) 
x = -7 
abs(x)

Hier ist noch eine mathematische Methode: 

def quadrat(irgendwas) 
  p irgendwas * irgendwas 
end 
#................. 
quadrat (3) 
quadrat (15) 
quadrat (-4)

Die Quadrat Methode multipliziert einfach den Wert it sich selbst. Dazu noch ein Beispiel: 

def sum (value, another_value) 
  p value + another_value 
end 
sum(3, 6) 
sum(1, 7)

Und ein Textbeispiel: 

def story (name, alter = 9999) 
  p "Vor langer Zeit lebte eine Idiot namens" + name + "." 
  p "Er war #{alter} Jahre alt."
end 
story ("Alex", 13) 
story("Goku", 3) 
story("ramirez") 
story("wasauchimmer")

Jene Beispiele demonstrieren einen interessanten Weg um Parameter festzulegen. Diese Methode akzeptiert einen Namen, sowie ein Alter und zeigt diese am Bildschirm an. Das „#{alter} Ding“ im zweiten p Befehl „string“ zeigt lediglich den Wert des Alters innerhalb des Textes. Ebensogut könntest du den ersten p Befehl so schreiben: Vor langer Zeit lebte ein Idiot namens #{name}."). Der Auswurf der darauf folgenden „calls“, also Aufrufe wäre Alex, dessen Alter 13 ist. Ebenso Der 3 Jahre alte Goku, der 9999 Jahre alte Ramirez und der 9999 Jahre alte wasauchimmer. Siehst du das (= 9999) nach dem alter in der Definition der Methode? Merke auch, dass wir die Metohde mit nur einem Wert aufrufen ("ramirez", und dann "wasauchimmer") ohne das wir das alter festlegen. Trotzdem sagt uns die Ausgabe, dass die beiden jeweils 9999 Jahre alt sind! Alter hat einen leeren Wert, einen sogenannten „default“ Wert. Diese wird immer gebraucht, wenn beim aufrufen der Methode dieser Wert nichts spezifiziert wird. Du kannst so viele „default“ Werte für so viele Parameter haben, wie du willst und du wirst in der Lage sein die Methode auf verschiedene Art und Weise aufzurufen. Merke einfach nur, dass du folgendes nicht machen kannst: (def something(value1 = 3, value2, value3)) oder das (def something(value1, value2 = 4, value3)), doch das kannst du machen: (def something(value1 = 2, value2 = 4, value3 = 5)) oder das (def something(value1, value2, value3 = 4, value4 = 5)). Mit anderen Worten, besitzt ein Parameter einen leeren Wert, müssen alle folgenden Parameter einen eben solchen haben, oder du bekommst eine Fehlermeldung. Also zurück zu den Beispielen: 

def fill(ein_array, ein_value) 
  for i in 0...ein_array.size 
    ein_array[i] = ein_value 
  end 
  p ein_array 
end

Diese Methode weist jedes Element eines Zahlenfelds namens ein_array einem Wert, ein,Wert zu, indem es durch die Elemente eines Zahlenfelds eine Schleife zieht und sie dem Wert zuweist. Danach zeigt es dje gefüllten Zahlefelder an. Einfach.

Return

Methoden können Werte zurückgeben und sich, wie Variablen verhalten. Wenn die Methode abs den Wert abs zurückgeben würde, anstatt ihn anzuzeigen, gäbe es viele Dinge, die wir mit dem Wert machen könnten. 

var = abs(5) 
p "WOW" if abs(-9) > 3 
abs(abs(-7)) 
p abs(22)

Anstaatt die Methode auf die Anzeige zu beschränken, können wir eine Menge Zeugs mit der Methode veranstalten, die Werte wiedergeben. Wenn du eine Variable zurückgeben willst, musst du folgendes tun: 

return value

Zwei vorherige Beispiele habe ich umgeschrieben, so dass sie Werte wiedergeben, anstatt sie anzuzeigen. 

def abs (eine_nummer) 
  if eine_nummer >= 0 
    return eine_nummer 
  else 
    return -1 * eine_nummer 
  end 
end 
x = abs(19) 
p x 
p abs(7 - 12)

def sum(value, another_value) 
  p value + another_value 
end 
#................ 
sum(3, 6) 
sum(1, 7)

Die Ausführung des Programms endet sobald auf ein „return“ Befehl getroffen wird. Du kannst mehrere haben, doch nur eines davon wird ausgeführt werden. Du kannst ebenso einfach „return“ benutzen um die laufende Methode zu verlassen, ohne wirklich etwas umzukehren. Um das zu machen schreib einfach „return“ ohne einen Wert. Meistens wird das gemacht um zu überprüfen, ob eine Bedingung für eine Methode erfüllt worden ist. Ein Beispiel: 

def alter_prüf(alter) 
  if alter < 13 
    p "Du bist zu jung für diese Methode! Sie wird gerade verlassen! " 
    return 
  end 
  p "Du bist alt genug für die Methode, yay!" 
end

Des öfteren wirst du auf Methoen treffen, die mit einem Fragezeichen enden. Ein einfaches Mittel, das benutzt wird um mehr informationen über eine Methode preiszugeben. Das ? wird benutzt um deutlich zu machen, dass die Methode einen boolean‘schen Wert wiedergibt, also entweder „true“ oder „false“. Wenn zum Beispiel eine Methode namens datei_existiert? Ein „true“ bei Existenz der Datei wiedergibt, oder andererseits ein „false“, wird eine Methode namens enthalten? „true“ wiedergeben, wenn dieses Element in einem Zahlenfeld enthalten ist und ansonsten „false“ wiedergeben. Fragen als Namen für Methoden zu nutzen ist eine gute Idee, wenn die Methode einen boolen’schen Wert wiedergibt. Es ist nur eine gute Idee. Das Fragezeichen kannst du dr eigentlich auch schenken.

rand

Ruby tritt mit ein paar eingebauten Methoden auf und eine davon nennt man „rand“ (Random, sprich Zufall). Das ist eine Methode, die eine zufällige Nummer zwischen 0 und dem Maximum –1 wiedergibt. Du kannst diese dann direkt gebrauchen und sie in einer Variable speichern. Dazu ein Beispiel: 

var = rand(10) 
if var > 5 
  p "Über 5!" 
elsif var < 5 
  p "kleiner als 5!" 
end

Zusammenfassung

Dieses Tutorial hat mich 3 Stunden Schreibarbeit gekostet (Anm. von Max Jet: Ach ja? Und was glaubst du wie lange das dauert diesen Müll zu übersetzen?!). Ich wollte es so einfach, wie möglich machen, aber ich weiß, dass es nicht ging. Methoden zu verstehen ist essentiell, also lies es dir bei Bedarf mehrfach durch! Eigentlich bin ich der Meinung, dass Methoden leicht zu verstehen sind, da sie einfach Blöcke von Codes sind, die aufgerufen werden. Du kannst Werte an Methoden weiterreichen und auch Werte weidergeben lassen. Was kann so schwer daran sein?

Im nächsten Tutorial stelle ich Klassen und das Objekt orientierte Programmieren vor. Das wird dann nicht so langweilig.

Zusammenfassung

  • Ein Block ist eine gruppierte Sammlung von Befehlen.
  • Eine Methode ist ein benannter Block, der im Programm aufgerufen werden kann.
  • „def“ wird gebraucht um Methoden zu definieren.
  • Du kannst Werte an Methoden weitergeben, Parameter akzeptieren diese.
  • Du kannst einen „default“ Wert besitzen, der vin einem Parameter benutzt wird, wenn kein Wert gesendet wird..
  • Durch den „return“ Befehl können Methoden Werte auch wiedergeben.
  • Sobald ein „return“ Befehl vorgefunden wird, wird die Methode verlassen.
  • ? wird am Ende der Methodenname oft gebraucht um darzustellen, dass diese Methode einen boolean’schen Wert wiedergibt.
  • rand(max) stellt eine beigefügte Methode dar, die eine zufällige Zahl wiedergibt.
  • Drei Augen zu besitzen macht dich zu etwas besonderem. (Anm. von Max Jet: Ein bisschen Fleiß und dieses Tutorial dazu zu benutzen um RGSS zu lernen, so dass meine Arbeit nicht verschwendet war, unterscheidet dich von den Möchtegern RMXP Profis und den Noobs. Als Noob fängt man nicht an. Man wird ein Noob durch Faulheit!)
Von „https://www.rpg-studio.org/wiki/index.php?title=RGSS_für_Dummköpfe/Blocks_und_Methoden&oldid=18986“