Wir nutzen Cookies, um das allgemeine Benutzerelebnis zu verbessern. Mit der Nutzung unseres Wikis stimmst du der Nutzung von Cookies zu.

Konstanten

Im Unterschied zu den meisten anderen Programmiersprachen kennt Scratch keine Konstanten, sondern lediglich Variablen und Variablenlisten. Dieser Artikel soll zeigen, dass es sehr sinnvoll und hilfreich sein kann, dennoch einzelne Variablen im Sinne von Konstanten zu verwenden.

Der Unterschied zwischen Variablen und Konstanten

Wie Variablen sind auch Konstanten vom Programmierer mit einem frei zu wählenden Namen definierbare Speicherzellen, die einen bestimmten Wert annehmen können. Der entscheidende Unterschied wird aber bereits durch die Bezeichnung deutlich. Im Gegensatz zu Variablen, deren Wert variabel ist, also beliebig oft geändert werden kann, können Konstanten nur ein einziges Mal, nämlich bei ihrer Erstellung mit einem Wert initialisiert werden. Dieser Wert bleibt dann während des gesamten Programmablaufs konstant, also völlig unveränderlich.

In anderen Programmiersprachen gibt es dafür ein spezielles Schlüsselwort (z.B. const), das einer Variablenerstellung vorangestellt wird, um zu kennzeichnen, dass diese Speicherzelle nicht mehr verändert werden kann. Versucht man im Programmcode dann doch einmal, einer derart gekennzeichneten Konstanten einen neuen Wert zuzuweisen, führt dies üblicherweise zu einer Fehlermeldung und einem Programmabbruch.

Wozu dienen Konstanten?

Auf den ersten Blick scheint es recht nutzlos zu sein, einer benannten Speicherzelle nur ein einziges Mal einen Wert zuweisen zu können. Man könnte diesen Wert im Programmcode ja auch gleich direkt verwenden.

Kostanten haben aber gleich mehrere entscheidende Vorteile:

Konstanten versehen nichtssagende Zahlenwerte mit "sprechenden" Namen

Besonders in den Bereichen der Mathematik und Physik gibt es jede Menge konstanter Zahlen, die in unterschiedlichen Formeln eine besondere Bedeutung haben. Meist enthalten diese Zahlen eine endlose Anzahl an Nachkommastellen, wie z.B. die Kreiszahl 3,141592653589793238462643383279..., die für so ziemlich alle Berechnungen von runden Formen und Körpern benötigt wird und unter dem Namen Pi bekannt ist. Selbst dieser zuvor genannte Wert mit dreißig Nachkommastellen ist schon gerundet und wird bei der Verwendung in Formeln zu einem zwar sehr kleinen, aber dennoch vorhandenen Rundungsfehler im Ergebnis der Berechnungen führen. Üblicherweise verkürzt man die Länge von Pi sogar noch weiter, da es oft überhaupt nicht notwendig ist, so extrem genaue Ergebnisse zu erhalten. Meistens reicht ein sehr grober Näherungswert, wie z.B. 3,14159 problemlos aus, um Umfang, Fläche oder Volumen eines runden Körpers sehr genau zu bestimmen. Geht es dagegen um die astronomische Berechnung (z.B. Planetenbahnen), kann ein auf dreißig Nachkommastellen gerundeter Pi-Wert schon zu Abweichungen von Millionen Kilometern führen.

Die Zahl Pi ist anhand ihrer ersten Stellen 3,14 noch sehr einfach zu erkennen, da sie so ziemlich jedem Menschen geläufig ist, der im Mathematik-Unterricht schon einmal mit Berechnungen an Kreisen zu tun hatte.

Schwieriger ist es dagegen bei vielen anderen konstanten Größen. Was verbirgt sich z.B. hinter folgenden Zahlen?

  • 299792458 - ist die Lichtgeschwindigkeit (in m/s). Sie wird als physikalische Größe mit c benannt.
  • 2,71828... - ist die Eulersche Zahl und wird mit e abgekürzt. e ist die Basis des natürlichen Logarithmus. Logarithmen werden für die Berechnung von Wachstums- und Zerfallsprozessen, aber auch in der Zins- und Zinseszinsrechnung benötigt.
  • 9,81... - ist die Erdbeschleunigung (in m/s^2). Sie wird für alle Berechnungen benötigt, die mit Fall- oder Wurfbahnen zu tun haben. Dieser Wert ist zwar überall auf der Erdoberfläche leicht unterschiedlich, kann aber als "lokale" Konstante betrachtet werden.

Konstanten machen Formeln verständlicher

Egal, ob eine solche Zahl mit fünf oder mit dreißig Stellen in eine Berechnungsformel eingetragen wird - sie macht die Formel länger und damit unübersichtlich und oftmals auch unverständlich. Vergleiche hierzu die folgenden beiden Skripte:

Wenn die grüne Flagge angeklickt
frage [Wie groß ist der Kreisradius in cm] und warte
setze [Radius v] auf (Antwort)
setze [Umfang v] auf ((2) * ((3.14159) * (Radius)))
setze [Fläche v] auf ((3.14159) * ((Radius) * (Radius)))

Der einzugebende Kreisradius ist der Abstand zwischen dem Mittelpunkt des Kreises und dem Rand. Daraus werden dann Umfang und Fläche berechnet. Im Skript wird der Wert von Pi gleich zweimal verwendet. Schon mit der Beschränkung auf nur fünf Nachkommastellen wird die Formel rein optisch länger und dadurch schwerer zu lesen. Soll die Genauigkeit der Berechnung irgendwann gesteigert werden, müssen darüber hinaus selbst in diesem kurzen Skript bereits zwei Stellen in identischer Weise angepasst werden. In komplexeren Projekten können es leicht dutzende oder gar hunderte anzupassende Stellen über eine Vielzahl von Figuren hinweg werden. Damit besteht ganz automatisch ein enormes Risiko, eine dieser Stellen zu übersehen.

In der folgenden Abwandlung dieses Skripts wird die neue Variable PI dagegen gleich zu Beginn des Skripts mit einem bereits sehr viel genaueren Wert von Pi initialisiert und in den beiden Berechnungen für Umfang und Fläche nur noch mit ihrer Variablenbezeichnung verwendet. Diese Formeln kennt man aus dem Matheunterricht und erkennt sie somit sehr leicht wieder. Werden zu einem späteren Zeitpunkt noch genauere Berechnungen notwendig, reicht es aus, die Variable PI in dieser ersten Zeile um ein paar Stellen zu verlängern.

Wenn die grüne Flagge angeklickt
setze [PI v] auf [3.141592653589793]
frage [Wie groß ist der Kreisradius in cm] und warte
setze [Radius v] auf (Antwort)
setze [Umfang v] auf ((2) * ((PI) * (Radius)))
setze [Fläche v] auf ((PI) * ((Radius) * (Radius)))

PI wird in diesem Fall nicht als Variable, sondern als Konstante verwendet, obwohl sie natürlich im Skript jederzeit veränderbar bleibt. Die in Scratch nicht vorhandenen Einschränkungen zur Veränderung von Konstanten, müssen hier vom Programmierer durch eiserne "Disziplin" ausgeglichen werden, indem er diese speziellen Variablen gleich zu Beginn des Programmablaufs anlegt und anschließend in den Skripten nur noch ausliest, aber nicht mehr verändert.

Konstanten helfen dabei, den eigenen und besonders fremden Scratch-Code zu verstehen

Auch ohne dass eine physikalische oder mathematische Größe dahintersteckt, bietet es sich zur Verbesserung der Verständlichkeit der eigenen Skripte an, statt mit festen Zahlenwerte mit "konstanten" Variablen zu arbeiten. Dies soll an einem Beispiel verdeutlicht werden, wie es in einem Spiel mit sowohl vertikal als auch horizontal scrollendem Hintergrund vorkommen kann:

gehe zu x: ((1200) - (Scroll-X)) y: ((900) - (Scroll-Y))

Mit diesem Block soll eine Figur entsprechend der aktuellen horizontalen (Scroll-X) und vertikalen (Scroll-Y) Position innerhalb des Spielfelds positioniert werden - aber wo genau? Was haben die Werte 1200 und 900 zu bedeuten? Demjenigen, der dieses Projekt entwickelt hat, werden die Zahlen etwas sagen, aber für andere Scratcher scheinen diese beiden Zahlen zunächst mal vom Himmel gefallen zu sein.

gehe zu x: (((5) * (240)) - (Scroll-X)) y: (((5) * (180)) - (Scroll-Y))

Durch die Auteilung der beiden Zahlen in ihre Herleitungsfaktoren wird es schon ein wenig deutlicher. Die Zahl 240 lässt sofort an die halbe Breite der Bühne denken. Ebenso lässt die 180 einen Zusammenhang mit der halben Bühnenhöhe erahnen. Welche Bedeutung hat aber der in beiden Fällen enthaltene Faktor 5? Sind das zwei unterschiedliche Faktoren, die hier nur zufällig beide auf 5 stehen, oder handelt es sich um den gleichen Faktor?

setze [FELDBREITE v] auf [5]
setze [FELDHÖHE v] auf [5]
setze [BÜHNENBREITE v] auf [480]
setze [BÜHNENHÖHE v] auf [360]
gehe zu x: (((FELDBREITE) * ((BÜHNENBREITE) / (2))) - (Scroll-X)) y: (((FELDHÖHE) * ((BÜHNENHÖHE) / (2))) - (Scroll-Y))

Aus der dritten Abwandlung dieses Skripts sollte es nun deutlich genug werden: Die 240 steht tatsächlich für die halbe Bühnenbreite und die 180 für die halbe Bühnenhöhe. Bei den beiden 5ern handelt es sich um unterschiedliche Faktoren, nämlich die Ausdehnungen des Hintergrund-Feldes, das in diesem speziellen Fall eine Breite und eine Höhe von jeweils 5 Hintergrund-Flächen hat. Durch die beiden Berechnungen im x- und y-Feld des gehe zu-Blocks soll die Figur in Relation zur Spielfeldmitte dieses 5x5 Felder großen Hintergrundes positioniert werden.

Durch die Verwendung der vier als Konstanten verwendeten Variablen wird es für den Entwickler dieses Skripts später sehr einfach, das Spielfeld weiter auszudehnen - z.B. auf 18 x 27 Felder, wenn ihm danach sein sollte. In diesem Fall müssen nur die ersten beiden Konstanten für FELDBREITE und FELDHÖHE auf die neuen Dimensionen angepasst werden. Sofern er bei der Programmierung an allen weiteren Stellen im Projekt, an denen diese beiden Größen eine Rolle spielen, konsequent die Konstanten verwendet hatte, ist die gesamte Anpassungsarbeit damit auch schon erledigt.

Gültigkeitsbereich von Konstanten-Variablen innerhalb des Scratch-Projekts

Eine aus dem vorangegangenen Abschnitt bereits herausklingende Eigenschaft mathematischer, physikalischer aber auch aller sonstigen Konstanten ist ihre universelle Gültigkeit. Übertragen auf den Gültigkeitsbereich von Variablen innerhalb von Scratch-Projekten, kann dies damit gleichgesetzt werden, dass solchermaßen als Konstanten verwendete Variablen als "für alle Figuren" gültig definiert werden sollten, selbst wenn sie nur in einer einzigen enthaltenen Figur Verwendung finden.

Natürlich kann man einzelne oder sogar alle verwendeten Konstanten auch als lokale Variablen in einer einzelnen Figur definieren. Dies widerspricht zwar der in den meisten andern Programmiersprachen konsequent beibehaltenen Regelung, dass einmalig definierte Konstanten grundsätzlich global, also überall innerhalb des Programmcodes mit diesem Wert abgefragt werden können, ist aber in Scratch nun mal möglich und kann sogar einen Vorteil haben:

Definiert und initialisiert man die verwendeten Konstanten als lokale Variablen einer extra zu diesem Zweck angelegten Figur (in diesem Fall namens const), können alle anderen Figuren problemlos auf die enthaltenen Werte zugreifen. Der benötigte Block befindet sich in der Kategorie "Fühlen":

((([FELDBREITE v] von [const v]) * (([BÜHNENBREITE v] von [const v]) / (2))) - (Scroll-X))

((([FELDHÖHE v] von [const v]) * (([BÜHNENHÖHE v] von [const v]) / (2))) - (Scroll-X))  

Diese Vorgehensweise hat den Vorteil, dass die somit in const gekapselten Konstanten auf jedem Fall vor dem Überschreiben geschützt sind, da die anderen Figuren die lokale Variablen von const nur auslesen, aber nicht ändern können. Der Nachteil ist allerdings auch schon deutlich zu erkennen: die Berechnungsformeln werden optisch wesentlich länger.

Hervorhebung von Variablen, die als Konstanten verwendet werden

Um Konstanten in der Variablenliste des Datenbereichs deutlich hervorzuheben, bietet es sich z.B. an, diese Variablen in Großbuchstaben zu benennen. Auf diese Weise lässt sich der Unterschied zwischen Variablen und Konstanten leicht erkennen. Da die Variablenliste aber rein alphabetisch geordnet wird, werden die Konstanten entsprechend ihres Namens trotzdem zwischen die anderen Variablen einsortiert. Um sie auch noch als Gruppe innerhalb der Variablenliste zusammenzufassen, kann noch ein "Präfix" vorangestellt werden, z.B. in Form eines kleinen "c" oder "c_" (für "const) vor dem eigentlichen Konstantennamen. Der Wert von Pi würde somit in der Variablen c_PI abgelegt.

Gewöhnt man sich auch noch eine ähnliche, einheitliche Benennungskonvention für global (g_) und lokal (l_) definierte Variablen an, lassen sich damit die unterschiedlichen Gültigkeitsbereiche auch in der Variablenliste des Datenbereichs gruppenweise sortieren. Zunächst erscheinen dort sämtliche Konstanten, darunter die für alle Figuren (global) definierten Variablen, und darunter - in Abhängigkeit von der aktuell gewählten Figur - die zu ihr gehörenden lokalen Variablen.

Am Beispiel des oben beschriebenen Skripts lässt sich erkennen, wie sich die Einhaltung dieser Benennungskonvention optisch darstellt:

setze [c_FELDBREITE v] auf [5]
setze [c_FELDHÖHE v] auf [5]
setze [c_BÜHNENBREITE v] auf [480]
setze [c_BÜHNENHÖHE v] auf [360]
setze [l_Pos-X v] auf (((c_FELDBREITE) * ((c_BÜHNENBREITE) / (2))) - (g_Scroll-X))
setze [l_Pos-Y v] auf (((c_FELDHÖHE) * ((c_BÜHNENHÖHE) / (2))) - (g_Scroll-Y))
gehe zu x: (l_Pos-X) y: (l_Pos-Y)



Code zum Einbinden ins Forum:
[wiki=de:Konstanten]Konstanten[/wiki]