Daten als Text speichern
Eine Bestenliste für deine Spiele: Nach jedem Spiel tippt der Spieler seinen Namen und seine Punkte auf einem Laptop ein, und die Liste zeigt die besten fünf. Zwischen den Läufen bleibt die Liste als JSON-Text in einer Variablenkarte namens scores erhalten, und jeder Lauf liefert dir die Liste zusätzlich als YAML, das leichter zu lesen ist.
Funktionen: TO_JSON, FROM_JSON, TO_YAML, FROM_YAML
Was du brauchst
Einen Auslöserblock mit Knopf, einen Laptop, einen E/A-Block und ein paar nicht initialisierte Variablenkarten: für jedes Spiel eine für den Auslöserblock und eine für den E/A-Block. Für die zweite Übung: eine Variablenkarte list vom Typ STRING.
Die Idee
Eine Variable lebt nur, solange ihr Programm läuft. Was bleiben soll, muss den Prozess als Karte verlassen. Ein Text ist dafür die nützlichste Form: Du kannst ihn im Dialog der Karte lesen und ändern, in ein Buch kopieren oder an einen Webdienst schicken, und eine spätere Version des Programms kann ihn noch lesen, wenn ihre Struktur ein neues Element bekommen hat – ein Schlüssel, der im Text fehlt, behält einfach seinen Standardwert.
JSON macht aus jedem Wert einen Text und wieder zurück. TO_JSON schreibt die Liste als [{"name":"Kai","points":150}], einen STRING, der in eine Variablenkarte passt. Beim nächsten Start liest FROM_JSON diesen Text zurück in ein Array desselben Typs. YAML macht dasselbe in einer Form, die Menschen leichter lesen und schreiben; c0de hat beides, TO_YAML und FROM_YAML.
Noch etwas: Die Karte muss mit dem Namen scores herauskommen, damit sie direkt wieder in den Auslöserblock kann. Ein Ergebnis darf nicht so heißen wie ein Parameter, aber WRITE kann seiner Karte jeden Namen geben.
Das Programm
PROGRAM highscores
NOOP
INCLUDE c0de/strings
NOOP
STRUCT entry
BEGIN
name STRING
points INTEGER
END STRUCT
NOOP
CONSTANT PLACES INTEGER 5
NOOP
FUNCTION add
PARAMETER scores STRING "[]"
RESULT yaml STRING
BEGIN
VARIABLE table ARRAY STRUCT entry
VARIABLE player STRING
VARIABLE points INTEGER
VARIABLE newcomer STRUCT entry
VARIABLE place INTEGER
VARIABLE count INTEGER
CALL c0de/strings/FROM_JSON
PARAMETER source scores ;
PARAMETER destination table ;
CALL CLS
CALL PRINT
PARAMETER value "Name?" ;
CALL INPUT
PARAMETER variable player ;
CALL PRINT
PARAMETER value "Points?" ;
CALL INPUT
PARAMETER variable points ;
ASSIGN newcomer.name player ;
ASSIGN newcomer.points points ;
EACH e table
BEGIN
IF e.points ≥ points ;
BEGIN
ASSIGN place place + 1 ;
END IF
END EACH
CALL INSERT
PARAMETER array table ;
PARAMETER index place ;
PARAMETER value newcomer ;
RESULT result table
CALL LEN
PARAMETER value table ;
RESULT result count
IF count > PLACES ;
BEGIN
CALL REMOVE
PARAMETER container table ;
PARAMETER index PLACES ;
RESULT result table
END IF
CALL c0de/strings/TO_JSON
PARAMETER value table ;
RESULT result scores
CALL WRITE
PARAMETER value scores ;
PARAMETER name "scores" ;
CALL c0de/strings/TO_YAML
PARAMETER value table ;
RESULT result yaml
EACH e table
BEGIN
CALL PRINT
PARAMETER value e.name ⊕ " " ⊕ e.points ;
END EACH
END FUNCTIONSo baust und startest du es
- Platziere den Laptop und den E/A-Block. Binde beide an das Programm
highscoresund die Funktionadd: Klicke mit rechts, klicke die Knöpfe, bis sie das Programm und die Funktion zeigen, und klicke auf ✔. - Stelle den Auslöserblock auf dasselbe Programm und dieselbe Funktion ein. Lege eine nicht initialisierte Variablenkarte in den Auslöserblock (für das Ergebnis
yaml) und eine in den E/A-Block (fürscores). - Drücke den Knopf. Der Laptop fragt
Name?: TippeKaiund drücke Enter, dann150fürPoints?. Der Bildschirm zeigtKai 150. - In der Ausgabe des E/A-Blocks liegt jetzt die Karte
scoresmit dem Text[{"name":"Kai","points":150}], und in der Ausgabe des Auslöserblocks die Karteyaml:
- name: Kai
points: 150- Für das nächste Spiel legst du die Karte
scoresin die Eingabe des Auslöserblocks, je eine nicht initialisierte Karte in den Auslöserblock und den E/A-Block, und drückst wieder den Knopf.
Mit fünf Einträgen in der Liste – Alex 300, Steve 200, Kai 150, Zoe 90, Sam 40 – und einem neuen Ergebnis von Mia mit 200 zeigt der Laptop:
Name?
Mia
Points?
200
Alex 300
Steve 200
Mia 200
Kai 150
Zoe 90Sam ist herausgefallen.

So funktioniert es
- Der Parameter
scoreshat den Standardwert"[]", ein leeres JSON-Array. Im ersten Spiel gibt es noch keine Karte, und die Liste beginnt leer. - FROM_JSON liest den Text in
table. Der Typ der Variablen bestimmt, wie das Dokument gelesen wird: EinARRAY STRUCT entryliest ein Array von Objekten mit den Schlüsselnnameundpoints.destinationist die Variable selbst, als Referenz übergeben, darum hat FROM_JSON kein Ergebnis. - Die beiden INPUTs füllen
playerundpoints, und die Strukturnewcomerbekommt beides. - Die Liste ist vom besten Ergebnis abwärts sortiert. EACH zählt die Einträge mit mindestens so vielen Punkten wie der Neue; das ist die Stelle, an der INSERT den neuen Eintrag einfügt. Bei Gleichstand kommt er hinter den älteren Eintrag, darum steht Mia nach Steve.
- Bei mehr als
PLACESEinträgen wirft REMOVE den letzten heraus, bei Index 5. - TO_JSON schreibt die Liste in eine Zeile JSON, in der Reihenfolge der Strukturelemente. WRITE legt sie als Variablenkarte namens
scoresin den E/A-Block. Ohne nicht initialisierte Karte in einem gebundenen E/A-Block wartet der Prozess in der WRITE-Zeile. - TO_YAML schreibt dieselbe Liste im Blockstil, ein Schlüssel pro Zeile, für das Ergebnis
yaml.
Probier es selbst
- Jemand hat die Karte
scoresbearbeitet und kaputt gemacht:[{"name":"Alex","points":"lots"}]. Statt abzustürzen, soll das Programm das melden und eine neue Liste beginnen.
Lösung
PROGRAM highscoressafe
NOOP
INCLUDE c0de/strings
NOOP
STRUCT entry
BEGIN
name STRING
points INTEGER
END STRUCT
NOOP
CONSTANT PLACES INTEGER 5
NOOP
FUNCTION add
PARAMETER scores STRING "[]"
RESULT yaml STRING
BEGIN
VARIABLE table ARRAY STRUCT entry
VARIABLE player STRING
VARIABLE points INTEGER
VARIABLE newcomer STRUCT entry
VARIABLE place INTEGER
VARIABLE count INTEGER
VARIABLE problem ERROR
CALL CLS
CALL c0de/strings/FROM_JSON problem
PARAMETER source scores ;
PARAMETER destination table ;
IF problem.code ≠ 0 ;
BEGIN
CALL PRINT
PARAMETER value "? Unreadable scores, new table" ;
END IF
CALL PRINT
PARAMETER value "Name?" ;
CALL INPUT
PARAMETER variable player ;
CALL PRINT
PARAMETER value "Points?" ;
CALL INPUT
PARAMETER variable points ;
ASSIGN newcomer.name player ;
ASSIGN newcomer.points points ;
EACH e table
BEGIN
IF e.points ≥ points ;
BEGIN
ASSIGN place place + 1 ;
END IF
END EACH
CALL INSERT
PARAMETER array table ;
PARAMETER index place ;
PARAMETER value newcomer ;
RESULT result table
CALL LEN
PARAMETER value table ;
RESULT result count
IF count > PLACES ;
BEGIN
CALL REMOVE
PARAMETER container table ;
PARAMETER index PLACES ;
RESULT result table
END IF
CALL c0de/strings/TO_JSON
PARAMETER value table ;
RESULT result scores
CALL WRITE
PARAMETER value scores ;
PARAMETER name "scores" ;
CALL c0de/strings/TO_YAML
PARAMETER value table ;
RESULT result yaml
EACH e table
BEGIN
CALL PRINT
PARAMETER value e.name ⊕ " " ⊕ e.points ;
END EACH
END FUNCTIONDie Fehlervariable problem in der CALL-Zeile fängt den Fehler ab: "lots" ist kein INTEGER, also löst FROM_JSON TYPE_MISMATCH aus. Bei einem Fehler lässt FROM_JSON table unverändert, es ist also noch das leere Array. Der Laptop zeigt ? Unreadable scores, new table, und die neue Karte scores enthält nur den neuen Eintrag.
- Beginne eine Liste, die du von Hand tippst. YAML ist leichter zu tippen als JSON, weil es keine Anführungszeichen braucht: Schreib ein Programm, das eine YAML-Liste aus einem Parameter
listliest und sie als Kartescoresin den E/A-Block legt.
Lösung
PROGRAM highscoresyaml
NOOP
INCLUDE c0de/strings
NOOP
STRUCT entry
BEGIN
name STRING
points INTEGER
END STRUCT
NOOP
FUNCTION load
PARAMETER list STRING
BEGIN
VARIABLE table ARRAY STRUCT entry
VARIABLE scores STRING
CALL c0de/strings/FROM_YAML
PARAMETER source list ;
PARAMETER destination table ;
CALL c0de/strings/TO_JSON
PARAMETER value table ;
RESULT result scores
CALL WRITE
PARAMETER value scores ;
PARAMETER name "scores" ;
END FUNCTIONBinde einen E/A-Block an highscoresyaml und load, mit einer nicht initialisierten Variablenkarte darin. Gib dem Auslöserblock eine Variablenkarte list vom Typ STRING mit diesem Text – einer YAML-Liste in einer Zeile:
[{name: Alex, points: 300}, {name: Steve, points: 200}]FROM_YAML liest sie in denselben Array-Typ wie in highscores, und TO_JSON schreibt sie als JSON. Der E/A-Block bekommt die Karte scores mit [{"name":"Alex","points":300},{"name":"Steve","points":200}], fertig für den Auslöserblock von highscores.
Mehr dazu
- c0de/strings: TO_JSON, FROM_JSON, TO_YAML, FROM_YAML
- JSON und YAML in der Anleitung, und Daten und das Netzwerk für Tags und Standardwerte
- WRITE und der E/A-Block
- Variablenkarten und Ergebnisse