10 und speichert das Ergebnis im Zähler

Es gibt jedoch eine abgekürzte Möglichkeit, dasselbe zu tun, Zuweisung mit Zusatz:

Beispiel:

  Zähler += 10; // Zähler um 10 erhöhen

Um eine Variable um 10 zu verringern:

Beispiel:

  Zähler -= 10; // Zähler um 10 verringern

Kapitel 5: String-Variablen

=============================================

Es gibt eine zweite Art von Variablen: Zeichenkettenvariablen,

auf englisch 'string' genannt.

Diese enthalten keine Zahlen, sondern Zeichenfolgen

(Buchstaben, Zahlen, Satzzeichen usw.).

Beispiel:

  Zeichenfolge (100) Name; // Ich erstelle eine String-Variable mit maximal 100 Zeichen

Um den Wert einer String-Variablen zu ändern, führen wir eine 'Zuweisung' durch

das sieht so aus:

Beispiel:

  name = "Hallo"; // name hat jetzt den Wert "Hallo"

Um den Wert einer Variablen zu ändern, geben Sie ihn einfach an

ein neuer Wert:

Beispiel:

  name = "Guten Abend"; // name hat jetzt den Wert "Guten Abend"

Sie können mehrere Zeichenfolgen mit dem "+"-Operator zusammenfügen.

Beispiel:

  name = "Gut" + "abend"; // name hat jetzt den Wert "Guten Abend"

  name = name + "meine freunde"; // name hat jetzt den Wert "Hallo meine Freunde"

Achtung: Die Länge einer String-Variablen darf 1024 Zeichen nicht überschreiten.

Um eine Zeichenfolgenvariable zu löschen, können Sie ihr eine leere Zeichenfolge zuweisen.

Beispiel:

  name = ""; // Jetzt ist der Name leer

Kapitel 6: Konvertierungen

========================

Sie können eine numerische Variable mit in eine Zeichenfolgenvariable konvertieren

der Funktion itos()

Beispiel:

  int-Zähler;

  Zeichenfolge (32) Name;

  Zähler = 12;

  name = itos(zähler); // Name enthält jetzt "12"

  name = "counter = " + itos(counter); // Name enthält jetzt "counter=12"

Umgekehrt können Sie eine Zeichenfolgenvariable in eine numerische Variable konvertieren

mit der Funktion stoi()

Beispiel:

  int-Zähler;

  Zeichenfolge (32) Name;

  name = "12";

  Zähler = stoi (Name); // Jetzt ist der Zähler gleich 12

  Zähler = stoi ("13"); // Jetzt ist der Zähler gleich 13

  Zähler = stoi("ab"); // dies gibt einen Fehler, der das Skript stoppt,

                              // weil "ab" nicht in einen Zahlenwert umgewandelt werden kann!

Kapitel 7: Bildschirmanzeigen

================================

Die Anzeige im Conversation-Fenster erfolgt mit der say()-Prozedur

Beispiel:

  sag Hallo!");

  sagen (Name);

Es ist beispielsweise nicht erlaubt, say() eine numerische Variable zu geben

das wird nicht funktionieren:

Beispiel:

  sagen (Zähler); // Error

Um den Zählerwert anzuzeigen, muss dieser zunächst in einen String umgewandelt werden:

Beispiel:

  sagen (itos(counter));

  sagen ("Zählerwert ist gleich " + itos(Zähler));

Kapitel 8: Tabellen

=========================

Anstatt eine einzelne Variable zu reservieren, können Sie ein ganzes Array von Variablen reservieren.

Beispiel:

  int[100] Zähler; // Ich erstelle 100 Zähler

Tatsächlich erstellt das obige Beispiel die folgenden 100 Zähler:

  zähler[0]

  Zähler[1]

  Zähler[2]

  Zähler[3]

  ...

  Zähler[99]

Um das Array zu löschen (alle Zähler auf Null zu setzen), verwenden Sie die clear-Anweisung:

Beispiel:

  Zähler löschen;

Sie können Werte in diesen Zählern wie folgt speichern:

Beispiel:

  Zähler[5] = 12; // speichere 12 in Zähler Nummer 5

  Zähler[5]++; // Zähler 5 um 1 erhöhen

  Zähler[i] = 13; // speichere 13 in Zähler i

Das letzte obige Beispiel gibt einen Fehler aus, wenn die Variable "i"

hat keinen Wert zwischen 0 und 99.

Kapitel 9: Die IF-Anweisung

============================

Bedingungen werden verwendet, um Variablen zu "testen".

Zum Beispiel können wir sagen "Wenn die Ding-Variable gleich 50 ist, tue dies" ...

Aber es wäre schade, nur die Gleichheit testen zu können!

Es wäre auch notwendig, testen zu können, ob die Variable kleiner als 50 ist,

kleiner oder gleich 50, größer als, größer als oder gleich...

Keine Sorge, die Skriptsprache hat alles herausgefunden (aber Sie hatten keine Zweifel, huh)

Bevor Sie sehen, wie man eine Bedingung vom Typ "if...else" schreibt,

Sie müssen also 2-3 grundlegende Symbole kennen.

Diese Symbole sind unerlässlich, um Bedingungen zu erfüllen.

Hier ist eine kleine Tabelle mit Symbolen, die Sie auswendig kennen sollten:

  Symbol Bedeutung

  ======= =============

     == ist gleich

     > ist größer als

     < ist kleiner als

     >= ist größer oder gleich

     <= ist kleiner oder gleich

     != ist anders als

Seien Sie sehr vorsichtig, es gibt 2 "=="-Symbole, um auf Gleichheit zu testen.

Ein häufiger Fehler, den Anfänger machen, besteht darin, nur ein =-Symbol zu setzen.

Davon erzähle ich etwas weiter unten.

Eine einzelne Eibe

------------

Lasst uns jetzt ohne weitere Verzögerung angreifen. Wir werden einen einfachen Test durchführen, der es dem Computer mitteilt

Schauspieler:

WENN die Variable dies ist

DANN tun Sie dies

Beispielsweise könnte man eine „Alters“-Variable testen, die Ihr Alter enthält.

Üben Sie weiter, wir testen, ob Sie volljährig sind,

d.h. wenn Ihr Alter größer oder gleich 18 ist:

Beispiel:

  wenn (Alter >= 18)

  {

    sagen ("Sie sind ein Erwachsener!");

  }

Das Symbol >= bedeutet „Größer als oder gleich“, wie wir in der vorherigen Tabelle gesehen haben.

Wenn zwischen den geschweiften Klammern nur eine Anweisung steht, werden die geschweiften Klammern optional.

Du kannst also schreiben:

Beispiel:

  wenn (Alter >= 18)

    sagen ("Sie sind ein Erwachsener!");

Wenn Sie die vorherigen Codes testen möchten, um zu sehen, wie das if funktioniert,

Es wird notwendig sein, das if innerhalb eines Startereignisses zu platzieren und die Deklaration nicht zu vergessen

eine Altersvariable, der wir den Wert unserer Wahl zuweisen.

Es mag für manche offensichtlich erscheinen, aber anscheinend war es nicht jedermanns Sache.

Also habe ich dieses Beispiel hinzugefügt:

  // Beispiel:

  eventstart()

  {

    int-Alter;

    Alter = 20;

    wenn (Alter >= 18)

      sagen ("Sie sind ein Erwachsener!");

  }

Hier ist die Variable Alter 20 wert, also das "Sie sind volljährig!" wird Angezeigt werden.

Versuchen Sie, den Anfangswert der zu sehenden Variablen zu ändern.

Setzen Sie zum Beispiel 15: Die Bedingung ist falsch, und daher "Sie sind volljährig!" wird dieses Mal nicht erscheinen.

Verwenden Sie diesen einfachen Code, um die nächsten Beispiele in diesem Kapitel zu testen.

Eine Frage der Sauberkeit

------------------------

Die Art und Weise, wie Sie die Zahnspange öffnen, ist nicht wichtig,

Ihr Programm funktioniert genauso gut, wenn Sie alles in eine Zeile schreiben.

Beispielsweise :

  if (age >= 18) { say ("Du bist erwachsen!"); }

Aber selbst wenn es möglich ist, so zu schreiben, ist es höchst unratsam!!

Wenn Sie alles in dieselbe Zeile schreiben, wird Ihr Code in der Tat schwer lesbar.

Wenn Sie es sich nicht angewöhnen, Ihren Code jetzt zu lüften,

später, wenn Sie größere Programme schreiben, werden Sie es nicht mehr finden!

Versuchen Sie also, Ihren Quellcode so darzustellen, wie ich es getan habe:

eine geschweifte Klammer in einer Zeile, dann Ihre Anweisungen (mit zwei vorangestellten Leerzeichen

um sie "nach rechts zu verschieben"), dann die schließende geschweifte Klammer in einer Zeile.

Es gibt mehrere gute Möglichkeiten, Ihren Quellcode zu präsentieren.

Es ändert nichts an der Funktionsweise des endgültigen Programms, aber es ist eine Frage

"Computer-Stil", wenn Sie so wollen. Wenn Sie den Code einer anderen Person sehen

etwas anders dargestellt ist, dass es mit einem anderen Stil kodiert.

Hauptsache, sein Code bleibt luftig und lesbar.

Das „sonst“, um „sonst“ zu sagen

-----------------------

Nachdem wir nun wissen, wie man einen einfachen Test durchführt, gehen wir etwas weiter:

Wenn der Test nicht funktioniert hat (er falsch ist), teilen wir dies dem Computer mit

andere Anweisungen auszuführen.

Auf Französisch schreiben wir daher etwas, das so aussieht:

WENN die Variable dies ist

DANN tun Sie dies

sonst mach das

Fügen Sie einfach das Wort else nach der schließenden Klammer des if hinzu.

Kleines Beispiel:

  if (age >= 18) // Wenn das Alter größer oder gleich 18 ist

  {

    sagen ("Sie sind ein Erwachsener!");

  }

  sonst // Sonst...

  {

    sagen ("Ah, das ist dumm, du bist minderjährig!");

  }

Die Dinge sind ganz einfach: Wenn die Altersvariable größer oder gleich 18 ist,

die Meldung „Sie sind volljährig!“ wird angezeigt, andernfalls wird „Sie sind minderjährig“ angezeigt.

Das „sonst wenn“, um „sonst wenn“ zu sagen

---------------------------------

Wir haben gesehen, wie man ein „if“ und ein „else“ bildet.

Es ist auch möglich, ein „sonst wenn“ zu machen.

In diesem Fall wird dem Computer gesagt:

WENN die Variable dies ist, DANN tun Sie dies

SONST, WENN die Variable dies ist, DANN tun Sie dies

sonst mach das

Übersetzung:

  if (age >= 18) // Wenn das Alter größer oder gleich 18 ist

  {

    sagen ("Sie sind ein Erwachsener!");

  }

  else if (age > 4) // Sonst, wenn das Alter mindestens größer als 4 ist

  {

    say ("Nun, du bist sowieso nicht zu jung...");

  }

  sonst // Sonst...

  {

    sagen ("Aga gaa aga gaaa gaaa"); // Babysprache, die du nicht verstehst ;o)

  }

Der Computer führt die Tests der Reihe nach durch:

Zuerst testet es das erste if: Wenn die Bedingung wahr ist, wird es ausgeführt

was steht zwischen den ersten geschweiften klammern.

Wenn nicht, geht es zu "else if" und führt erneut einen Test durch: Wenn dieser Test wahr ist,

dann führt es die entsprechenden Anweisungen in geschweiften Klammern aus.

Wenn schließlich keiner der vorherigen Tests funktioniert hat, führt es die „else“-Anweisungen aus.

Das „else“ und das „else if“ sind nicht obligatorisch. Um eine Bedingung zu stellen,

man braucht nur mindestens ein "if" (logisch könnte man sagen, sonst gibt es keine Bedingung!)

Beachten Sie, dass Sie so viele „else if“-Zeichen eingeben können, wie Sie möchten. Wir können daher schreiben:

WENN die Variable dies ist

DANN tun Sie dies

SONST, WENN die Variable dies ist, DANN tun Sie dies

SONST, WENN die Variable dies ist, DANN tun Sie dies

SONST, WENN die Variable dies ist, DANN tun Sie dies

sonst mach das

Mehrere Bedingungen auf einmal

------------------------------

Es kann auch nützlich sein, mehrere Tests gleichzeitig in Ihrem if durchzuführen.

Sie möchten beispielsweise testen, ob das Alter über 18 UND unter 25 liegt.

Dazu müssen wir neue Symbole verwenden:

  Symbol Bedeutung

  ======= =============

    &&       UND

    || WO

    ! NEIN

UND testen

-------

Wenn wir den oben erwähnten Test machen wollen, müssen wir schreiben:

Beispiel:

  wenn (Alter > 18 && Alter < 25)

Die beiden Symbole "&&" bedeuten UND.

Unsere Bedingung würde auf Französisch lauten:

"Wenn das Alter über 18 ist UND wenn das Alter unter 25 ist"

Wo sind Sie

-------

Um ein ODER zu bilden, verwenden wir die 2 Zeichen ||. Ich muss zugeben, dass dieses Zeichen

ist auf unseren Tastaturen nicht leicht zugänglich. Um es auf a zu schreiben

Auf der französischen AZERTY-Tastatur muss Alt Gr + 6 ausgeführt werden. Auf einer belgischen Tastatur

es wird notwendig sein, Alt Gr + & zu machen.

Stellen Sie sich ein dummes Programm vor, das entscheidet, ob eine Person das Recht hat

ein Bankkonto zu eröffnen. Es ist allgemein bekannt, ein Bankkonto zu eröffnen,

Es ist besser, nicht zu jung zu sein (wir werden willkürlich sagen, dass Sie haben müssen

mindestens 30 Jahre alt) oder viel Geld haben (denn auch mit 10 Jahren

wir werden dich mit offenen Armen empfangen)

Unser Test, ob der Kunde das Recht hat, ein Bankkonto zu eröffnen

könnte sein :

  if (Alter > 30 || Geld > 100000)

  {

    sagen ("Willkommen bei Scrooge Bank!");

  }

  anders

  {

    sagen ("Aus meinen Augen, Elend!");

  }

Dieser Test ist nur gültig, wenn die Person über 30 Jahre alt ist oder mehr als 100.000 Euro besitzt

Test Nr

--------

Das letzte Symbol, das wir noch testen müssen, ist das Ausrufezeichen.

In der Informatik bedeutet das Ausrufezeichen „Nein“.

Sie müssen dieses Zeichen vor Ihre Bedingung setzen, um zu sagen "Wenn dies nicht wahr ist":

Beispiel:

  wenn (!(alter < 18))

Dies könnte übersetzt werden als „Wenn die Person nicht minderjährig ist“.

Wenn wir das "!" davor hätte es das Gegenteil bedeutet: "Wenn die Person minderjährig ist".

Einige typische Anfängerfehler

--------------------------------------

Vergiss die 2 Zeichen == nicht

-----------------------------

Wenn wir testen wollen, ob die Person erst 18 Jahre alt ist, müssen wir schreiben:

Beispiel:

  wenn (Alter == 18)

  {

    sagen ("Du bist gerade erwachsen geworden!");

  }

Vergessen Sie nicht, 2 "Gleichheitszeichen" in ein if zu setzen, wie hier: ==

Zu viele Semikolons

------------------------

Ein weiterer häufiger Anfängerfehler: Sie setzen manchmal ein Semikolon

am Ende der Zeile eines if. Ein if ist jedoch eine Bedingung, und wir setzen kein Semikolon

nur am Ende einer Anweisung und nicht einer Bedingung.

Der folgende Code funktioniert nicht wie erwartet, da am Ende des if ein Semikolon steht:

Beispiel:

  wenn (Alter == 18); // Beachten Sie hier das Semikolon, das NICHT dort sein sollte

  {

    sagen ("Du bist kaum volljährig");

  }

Boolesche Werte, das Herzstück der Bedingungen

-------------------------------------

Wir werden jetzt mehr ins Detail über die Funktionsweise einer Bedingung vom Typ if...else gehen.

Tatsächlich beinhalten Bedingungen etwas, das in der Informatik Boolesche Werte genannt werden.

Es ist ein sehr wichtiges Konzept, also öffne deine Ohren (besser deine Augen)

Ein paar kleine Tests zum Verständnis

-------------------------------------------

Im Physik-Chemie-Unterricht hat mein Lehrer uns immer zum Anfangen gebracht

durch ein paar kleine Experimente, bevor ein neues Konzept eingeführt wird.

Ich werde es ihm heute ein bisschen nachmachen.

Hier ist ein sehr einfacher Quellcode, den ich Sie bitte zu testen:

Beispiel:

  Wenn wahr)

  {

    sagen ("Es ist wahr");

  }

  anders

  {

    say("Es ist falsch");

  }

Ergebnisse :

  Es ist wahr

Mais ??? Wir haben keine Bedingung in das if gesetzt, sondern nur true (true auf Französisch).

Was bedeutet es macht keinen Sinn?

Wenn ja, werden Sie es verstehen.

Führen Sie jetzt einen weiteren Test durch und ersetzen Sie das Wahre durch das Falsche:

Beispiel:

  wenn (falsch)

  {

    sagen ("Es ist wahr");

  }

  anders

  {

    say("Es ist falsch");

  }

Ergebnisse :

  Es ist falsch

Erklärungen sind erforderlich

-----------------------

In der Tat, wann immer Sie einen Test in einem if durchführen,

Dieser Test gibt wahr zurück, wenn er wahr ist, und falsch, wenn er falsch ist.

Beispielsweise :

  wenn (Alter >= 18)

Hier ist der Test, den Sie durchführen, "Alter >= 18".

Angenommen, das Alter ist 23. Dann ist der Test wahr,

und der Computer "ersetzt" irgendwie "Alter >= 18" durch wahr.

Dann bekommt der Computer (in seinem Kopf) ein "wenn (wahr)".

Wenn der Wert wahr ist, sagt der Computer, wie wir gesehen haben, dass die Bedingung

wahr ist, also zeigt es "It's true" an!

Wenn die Bedingung falsch ist, wird auf ähnliche Weise das Alter >= 18 durch falsch ersetzt.

und plötzlich ist die Bedingung falsch: Der Computer liest die Anweisungen des "sonst".

Ein Test mit einer Variablen

-------------------------

Versuchen Sie jetzt einen anderen Trick: Senden Sie das Ergebnis Ihrer Bedingung in einer Variablen,

als wäre es eine Operation (denn für den Computer ist es eine Operation!).

Beispiel:

  int-Alter;

  Hauptboolescher Wert;

  Alter = 20;

  Erwachsener = Alter >= 18;

  wenn (groß)

    sagen

("wesentlich");

  anders

    say("minor");

Wie Sie sehen, hat die Bedingung Alter >= 18 wahr zurückgegeben, weil sie wahr ist.

Unsere Hauptvariable ist also wahr.

Führen Sie den gleichen Test durch, indem Sie zum Beispiel Alter = 10 setzen. Dieses Mal wird Major falsch sein.

Diese "große" Variable ist ein boolescher Wert! Sie sehen, dass wir es deklariert haben mit:

  Hauptboolescher Wert;

Merk dir das:

Eine Variable, die die Werte false und true annimmt, wird als boolesch bezeichnet.

Boolesche Werte in Bedingungen

---------------------------------

Oft führen wir einen "if"-Test für eine boolesche Variable durch:

Beispiel:

  Hauptboolescher Wert;

  Haupt = wahr;

  wenn (groß)

  {

    sagen ("Sie sind ein Erwachsener!");

  }

  anders

  {

    sagen ("Sie sind minderjährig");

  }

Da Major wahr ist, ist die Bedingung wahr, also zeigen wir „Du bist Major!“ an.

Sehr praktisch ist, dass die Bedingung leicht von einem Menschen gelesen werden kann.

Wir sehen „if (major)“, was übersetzt werden kann als „wenn du volljährig bist“.

Tests auf booleschen Werten sind daher einfach zu lesen und zu verstehen,

solange Sie Ihren Variablen eindeutige Namen gegeben haben

wie ich es dir von Anfang an gesagt habe.

Hier ist ein weiterer imaginärer Test:

Beispiel:

  wenn (Erwachsener && Junge)

Dieser Test bedeutet "Wenn Sie volljährig sind UND Sie ein Junge sind".

Junge ist hier eine weitere boolesche Variable, die wahr ist, wenn Sie ein Junge sind,

und falsch, wenn du ... ein Mädchen bist! Gut gemacht, du hast alles!

Boolesche Werte werden verwendet, um auszudrücken, ob etwas wahr oder falsch ist.

Es ist sehr nützlich, und was ich Ihnen gerade erklärt habe, wird es Ihnen ermöglichen

Vieles später zu verstehen.

-------------------------------------------------- ------------------------------

Die „if...else“-Bedingung, die wir gerade gesehen haben, ist die Art von Bedingung, die am häufigsten verwendet wird.

Tatsächlich gibt es nicht 36 Möglichkeiten, eine Bedingung zu stellen. Das "if...else" behandelt alle Fälle.

Beispiel:

  wenn (Alter == 2)

  {

    sagen ("Hallo Baby!");

  }

  Sonst wenn (Alter == 6)

  {

    sagen ("Hallo Kind!");

  }

  Sonst wenn (Alter == 12)

  {

    sagen ("Hallo jung!");

  }

  Sonst wenn (Alter == 16)

  {

    sagen ("Hallo Teenager!");

  }

  sonst wenn (Alter == 18)

  {

    sagen ("Hallo Erwachsener!");

  }

  sonst wenn (Alter == 68)

  {

    sag ("Hallo Opa!");

  }

  anders

  {

    sagen ("Ich habe keine fertigen Sätze für Ihr Alter");

  }

-------------------------------------------------- ------------------------------

Kapitel 10: Schleifen

=========================

Was ist eine Schleife?

Es ist eine Technik, um dieselben Anweisungen mehrmals zu wiederholen.

Wie bei Bedingungen gibt es mehrere Möglichkeiten, Schleifen zu erstellen.

Am Ende läuft es darauf hinaus, dasselbe zu tun:

Wiederholen Sie die gleichen Anweisungen mehrmals.

In jedem Fall ist das Muster dasselbe:

        <----------

  Anleitung ^

  Anleitung ^

  Anleitung ^

  Anleitung ^

        -----------^

Folgendes passiert der Reihe nach:

Der Computer liest die Anweisungen von oben nach unten (wie üblich)

Dann, einmal am Ende der Schleife angekommen, startet sie wieder bei der ersten Anweisung

Dann fährt er fort, die Anweisungen von oben nach unten zu lesen ...

... Und es beginnt wieder am Anfang der Schleife.

Das Problem mit diesem System ist, dass, wenn wir es nicht stoppen,

der Computer ist in der Lage, Anweisungen endlos zu wiederholen!

Er ist keiner, der sich beschwert, weißt du, er tut, was ihm gesagt wird.

Und da finden wir... Bedingungen!

Wenn Sie eine Schleife erstellen, geben Sie immer eine Bedingung an.

Diese Bedingung bedeutet "Wiederhole die Schleife, solange diese Bedingung wahr ist".

Es gibt mehrere Möglichkeiten, wie ich es dir gesagt habe.

Lassen Sie uns ohne weitere Umschweife sehen, wie man eine "while"-Schleife durchführt.

-------------------------------------------------- ------------------------------

Die While-Schleife

---------------

So konstruieren Sie eine While-Schleife:

Beispiel:

  während (Bedingung)

  {

      // Anweisungen zum Wiederholen

  }

So einfach ist das. While bedeutet „Während“.

Also sagen wir dem Computer: "Solange die Bedingung wahr ist: Wiederhole die Anweisungen zwischen geschweiften Klammern".

Wir möchten, dass sich unsere Schleife eine bestimmte Anzahl von Malen wiederholt.

Dazu erstellen wir eine „Zähler“-Variable, die beim Start des Programms den Wert 0 hat

und dass wir schrittweise erhöhen werden.

Erinnern Sie sich an die Erhöhung? Es besteht darin, der Variablen eine 1 hinzuzufügen, indem Sie "variable++;" ausführen.

Schauen Sie sich dieses Stück Code genau an und versuchen Sie vor allem, es zu verstehen:

Beispiel:

  int-Zähler;

  Zähler = 0;

  während (Zähler < 5)

  {

    Sag Hallo!");

    Zähler++;

  }

Ergebnisse :

  Erlösung !

  Erlösung !

  Erlösung !

  Erlösung !

  Erlösung !

Dieser Code wiederholt die Anzeige von „Hi!“ 5 Mal.

Wie funktioniert es genau?

Zunächst haben wir eine Zählervariable auf 0 initialisiert. Sie ist also beim Start des Programms gleich 0.

Die While-Schleife ordnet die Wiederholung an, während der Zähler kleiner als 5 ist.

Als Zähler

zu Beginn 0 ist, treten wir in die Schleife ein.

Zeigen Sie die Phrase "Hallo!" über ein sagen.

Der Wert der Zählervariablen wird mit der Anweisung "counter++;" inkrementiert.

Der Zähler war 0 wert, jetzt ist er 1 wert.

Wir kommen am Ende der Schleife an (schließende Klammer), also gehen wir zurück zum Anfang,

auf der While-Ebene.

Wir wiederholen den While-Test: "Ist der Zähler immer noch kleiner als 5?".

Nun ja, Zähler ist 1 Also beginnen wir die Schleifenanweisungen erneut.

Und so weiter ... Der Zähler wird allmählich 0, 1, 2, 3, 4, 5 wert sein.

Wenn Zähler gleich 5 ist, ist die Bedingung "Zähler < 5" falsch.

Da die Anweisung falsch ist, verlassen wir die Schleife.

Wir konnten auch sehen, dass die Zählervariable als ansteigt

und während es durch die Schleife geht, zeigt es es in der Aussage an:

Beispiel:

  int-Zähler;

  Zähler = 0;

  während (Zähler < 5)

  {

    say ("die Zählervariable ist " + itos(counter));

    Zähler++;

  }

Die Zählervariable ist 0

Die Zählervariable ist 1 wert

Die Zählervariable ist gleich 2

Die Zählervariable ist gleich 3

Die Zählervariable ist 4

Nun, wenn Sie das verstanden haben, haben Sie alles verstanden.

Sie können Spaß daran haben, das Loop-Count-Limit zu erhöhen

 ("< 10" statt "< 5").

Vorsicht vor Endlosschleifen

------------------------------

Stellen Sie beim Erstellen einer Schleife immer sicher, dass sie stoppen kann

irgendwann! Wenn die Bedingung immer wahr ist, wird Ihr Programm niemals anhalten!

Hier ist ein Beispiel für eine Endlosschleife:

Beispiel:

  während (wahr)

  {

    say ("Endlosschleife");

  }

Erinnere dich an boolesche Werte. Hier ist die Bedingung immer wahr,

Dieses Programm druckt also ununterbrochen "Endlosschleife"!

Seien Sie also sehr vorsichtig: Vermeiden Sie unbedingt, in eine Endlosschleife zu geraten.

-------------------------------------------------- ------------------------------

Die for-Schleife

-------------

Theoretisch können Sie mit der While-Schleife alle gewünschten Schleifen ausführen.

In manchen Fällen ist es jedoch sinnvoll, ein anderes Schleifensystem zu haben

"kondensierter", schneller zu schreiben.

For-Schleifen sind in der Programmierung weit verbreitet.

Ich habe keine Statistiken zur Hand, aber ich weiß, dass Sie sie verwenden werden

sicherlich so viele für eine Weile, also müssen Sie wissen, wie man damit umgeht

diese beiden Arten von Schleifen.

Wie ich Ihnen bereits sagte, sind For-Schleifen nur eine andere Art, Dinge zu tun.

eine While-Schleife.

Hier ist ein Beispiel für eine While-Schleife, die wir zuvor gesehen haben:

Beispiel:

  int-Zähler;

  Zähler = 0;

  während (Zähler < 10)

  {

    Sag Hallo!");

    Zähler++;

  }

Hier ist nun das Äquivalent der for-Schleife:

Beispiel:

  int-Zähler;

  für (Zähler = 0; Zähler < 10; Zähler++)

  {

    Sag Hallo!");

  }

Welche Unterschiede?

Es gibt eine Menge Dinge zwischen den Klammern nach dem for (wir werden das später detailliert beschreiben)

Es gibt keinen Zähler mehr ++; in der Schleife.

Schauen wir uns an, was in den Klammern steht, denn dort steht das

der ganze Punkt der for-Schleife. Es gibt 3 komprimierte Anweisungen,

jeweils durch Semikolon getrennt:

Die erste ist die Initialisierung: diese erste Anweisung wird verwendet

um unsere Zählervariable vorzubereiten. In unserem Fall initialisieren wir die Variable auf 0.

Die zweite ist die Bedingung: Was die While-Schleife betrifft, so ist es die Bedingung, die besagt

ob die Schleife wiederholt werden soll oder nicht. Solange die Bedingung wahr ist, wird die for-Schleife fortgesetzt.

Schließlich gibt es eine Inkrementierung: Diese letzte Anweisung wird am Ende ausgeführt

jeder Runde der Schleife, um die Zählervariable zu aktualisieren.

Fast die ganze Zeit werden wir ein Inkrement machen, aber wir können auch

decrement (Variable--;) oder jede andere Operation

(Variable += 2; zum Beispiel um 2 um 2 vorrücken).

Kurz gesagt, wie Sie sehen können, ist die for-Schleife nichts anderes als eine Zusammenfassung von while.

Wissen Sie, wie man es benutzt, Sie werden es mehr als einmal brauchen!

-------------------------------------------------- ------------------------------

Kapitel 11: Grundlegende Prozeduren und Funktionen

==========================================

Was ist ein Verfahren? gut zum Beispiel "sagen", was Sie gut kennen.

Aber es gibt noch viel mehr!

Auch zwei Funktionen kennen Sie bereits: itos und stoi, die es erlauben

Konvertieren zwischen Zeichenfolge und numerischem Wert.

Tatsächlich besteht der Unterschied zwischen Prozedur und Funktion darin, dass eine Prozedur

es ist ein Befehl, während eine Funktion etwas berechnet und zurückgibt

infolge.

Wir werden uns einige allgemeine Funktionen ansehen, um zu sehen, wie es funktioniert:

d = jetzt (); // Funktion, die das heutige Datum berechnet

s = Mitte(s,a,N); // gibt N Zeichen von s zurück, beginnend beim 'a'

                        // Beispiel: mid("ABCDEF",2,3) == "BCD"

n = rnd(a,b); // gibt eine Zufallszahl zwischen a und b zurück

                        // Beispiel: rnd(1.50) == 12

Die Funktion now() ist einfach: Sie kehrt zurück

e Datum und Uhrzeit des PCs.

Wir können zum Beispiel schreiben:

Beispiel:

eventstart()

{

  date_time mein_datum;

  mein_datum = jetzt(); // füge das Datum in my_date ein

  say (itos(my_date.day, 2, "0")

        + "/"

        + itos(mein_datum.monat, 2, "0")

        + "/"

        + itos(my_date.year, 2, "0"));

}

was zum Beispiel druckt:

  12.02.2020

Mit der Funktion rnd() können Sie eine Zufallszahl ziehen, was für Spiele sehr nützlich ist.

Beispiel:

  int ich;

  i = rnd(1, 100); // wähle eine Zahl von 1 bis 100 für i

  say ("wir wählen " + itos(i));

In der Dokumentation zur Skriptsprache finden Sie Listen

aller vordefinierten Prozeduren und Funktionen.

-------------------------------------------------- ------------------------------

Kapitel 12: Der sich wiederholende Text

==================================

Hier ist ein Skript, das alle 10 Sekunden einen Text wiederholt.

eventstart()

{

  start_timer(0, 10.0);

}

Ereignistimer (int nr)

{

  sagen ("Hallo Freunde!");

  say ("Ich hoffe es geht dir gut :p");

  start_timer(0, 10.0);

}

Die Prozedur start_timer(0, 10.0); bedeutet:

"Timer Nummer 0 in 10 Sekunden auslösen"

Wenn der Event-Timer ausgeführt wird, schreibt er den Text und der start_timer löst ihn erneut aus

für in 10 Sekunden usw. ... und es wird geloopt!

Kapitel 13: mehrere Wiederholungen

=================================

Wie man eine Phase alle 10 Sekunden wiederholt

und alle 20 sekunden noch eins?

eventstart()

{

  start_timer(0, 10.0);

}

Ereignistimer (int nr)

{

  sagen ("Hallo Freunde!");

  start_timer(0, 10.0);

  say ("Ich hoffe es geht dir gut :p");

  start_timer(0, 20.0);

}

Das obige Skript ist falsch!

Allerdings wird nur der letzte start_timer für die Wiederholung verwendet.

Dieses Skript wird daher ausgeführt, wobei der erste start_timer vollständig ignoriert wird!

Es dürfen auch nicht mehrere event timer() im selben Script vorhanden sein!

Dies ist jedoch möglich:

// Wiederholungsbeispiel mit mehreren Verzweigungen

eventstart()

{

  start_timer(0, 10.0);

  start_timer(1, 20.0);

}

Ereignistimer (int nr)

{

  wenn (nr == 0)

  {

    sagen ("Hallo Freunde!");

    start_timer(0, 10.0);

  }

  sonst // nr ist gleich 1

  {

    say ("Ich hoffe es geht dir gut :p");

    start_timer(1, 20.0);

  }

}

Dieses bereits recht komplexe Beispiel zeigt mehrere weit verbreitete Techniken.

Beachten Sie zuerst die beiden start_timer, die die beiden Timer 0 und 1 starten,

die erste nach 10 Sekunden und die zweite nach 20 Sekunden.

Im Ereignis-Timer testen wir den nr-Parameter, um zu sehen, welcher Timer abgelaufen ist (die 0 oder die 1).

und basierend darauf wird eine Aktion ausgeführt.

Wenn Sie also das Beispiel richtig verstanden haben, wird der 1. Satz alle 10 Sekunden angezeigt,

und der 2. Satz alle 20 Sekunden.

Kapitel 14: Ereignisse

===========================

In früheren Kapiteln haben Sie vielleicht Skripte geschrieben, die alles ausgeführt haben

allein durch das völlige Ignorieren der Avatare.

Kommen wir nun zu einer anderen Art von Skript:

diejenigen, die mit Avataren interagieren und darauf reagieren!

In der Tat verursachen Avatare Aktionen, zum Beispiel:

- sie klicken auf das Objekt

- sie schreiben Textzeilen

etc...

Sie sollten wissen, dass ein Skript in 99 % der Fälle nichts tut, es schläft!

Aber sobald ein Avatar eine Aktion provoziert, wacht das Skript auf!

Es führt dann einige Anweisungen aus (z. B. zeigt es eine Nachricht an),

und wenn es fertig ist, geht das Skript wieder schlafen und wartet auf das nächste

Aktion.

Zwischen zwei Aktionen, also während es schläft, geht das Skript komplett verloren

Speicher, d.h. alle Variablen werden zurückgesetzt!

Es gibt nur eine Ausnahme von dieser Regel, nämlich die deklarierten Variablen

ganz oben im Skript. Letztere sind daher sehr nützlich, weil sie halten

ihren Wert, solange das Skript läuft!

Jedes Mal, wenn eine Aktion auftritt, wird ein „Ereignis“ ausgeführt.

Beispiel :

  // durch eine Nachricht regieren, wenn der Chatter das Objekt berührt

  Ereignis berühren ()

  {

    say ("Willkommen" + avatar_name(touched_avatar()));

  }

Sobald eine Aktion auftritt, wird ein Ereignis ausgeführt. Sie erhält

eine ganze Reihe von Parametern bezüglich der Aktion:

touched_avatar() zum Beispiel gibt einen Schlüssel auf dem Avatar zurück.

Wir können es in der Funktion avatar_name() übergeben, um den Namen des Avatars abzurufen, der berührt hat.

Kapitel 15: Zähler

=======================

Das folgende Skript teilt jedem Avatar mit, wie viele Avatare das Objekt davor berührt haben.

Dazu verwendet es eine am Anfang des Skripts deklarierte Variable.

Beispiel :

  // ein Skript, das Chatter zählt

  int g_counter = 0;

  Ereignis berühren ()

  {

    say ("Willkommen" + avatar_name(touched_avatar()));

    g_counter++;

    say ("Sie sind die " + itos(g_counter) + " Person, die mich berührt, seit mein Skript läuft");

  }

Häufig beginnen Variablen, die ganz oben im Skript deklariert werden, mit g_, um global anzuzeigen.

Es ist nicht

obligatorisch, aber es ist eine Konvention unter Informatikern.

Kapitel 16: Das Say-Verfahren

===============================

Die say()-Prozedur wird verwendet, um einen Text im Raum anzuzeigen, zum Beispiel:

  sag Hallo!");

Mit können Sie mehrere Textteile zusammenkleben

der Operator + (Plus), zum Beispiel:

  sagen ("Hallo" + "Liebe Freunde!");

Nun, in diesem Fall hätten wir auch schreiben können:

  sagen ("Hallo, liebe Freunde!");

Aber hier ist ein interessanterer Fall:

  sagen ("Hallo " + Benutzer-ID + "!");

Hier fügen wir das Hallo und den Namen des Chatters zusammen.

Beachten Sie, dass, wenn Sie schreiben:

    sagen (zählen);

Sie erhalten eine Fehlermeldung, weil say() nur String-Variablen akzeptiert!

Um einen Wert anzuzeigen, müssen Sie ihn zunächst in Text umwandeln

mit der Funktion itos(). Beispiel :

    say ("Sie sind die " + itos(count) + " Person, die mich berührt hat, seit mein Skript läuft");

Kapitel 17: Schreiben in verschiedenen Schriftarten und Farben

============================================= == =====

Um in verschiedenen Stilen zu schreiben, können Sie die Funktionen verwenden:

    Farbe (0xFFFFFF): Farbe ändern

    Schriftart (5): Nummer der Schriftart

    Stil (unterstrichen => wahr, kursiv => wahr, fett => wahr): Ändert den Stil von unterstrichen kursiv oder fett

Beispiel:

  // Willkommensnachricht

  string font(int f) { return chr(1, f); }

  string style (bool unterstrichen, bool kursiv, bool fett) { int s=0; if (unterstrichen) s++; wenn (kursiv) s+=2; wenn (fett) s+=4; Rückgabe chr(2, s); }

  string color(int col) { return chr(4, col & 0xFFFF, col>>16); }

  eventtouch()

  {

    sagen ("groß"

       + Farbe (0x8080FF)

       + "kuss"

       + Schriftart(9)

       + Farbe(0x00FF00)

       + Stil (unterstrichen => wahr, kursiv => wahr, fett => wahr)

       + "von Didi");

  }

Dieses Beispiel zeigt die Willkommensnachricht in Rot!

Aber hey, wenn Sie viel roten Text anzeigen, ist das nicht praktisch.

Da Sie an dem Tag, an dem Sie die Farbe ändern möchten, alle Farben (0x8080FF) in Ihrem Programm ändern müssen.

Was Sie tun können, ist, Ihre eigene Farbänderungsfunktion zu schreiben.

Beispiel:

  // Willkommensnachricht

  string font(int f) { return chr(1, f); }

  string style (bool unterstrichen, bool kursiv, bool fett) { int s=0; if (unterstrichen) s++; wenn (kursiv) s+=2; wenn (fett) s+=4; Rückgabe chr(2, s); }

  string color(int col) { return chr(4, col & 0xFFFF, col>>16); }

  string ftitle()

  {

    Rückgabefarbe (0x8080FF) + Schriftart (8); // rote Farbe + Impact-Schriftart

  }

  eventtouch()

  {

    sag (ftitle() + "Hallo!");

  }

Wenn Sie also die Farben ändern oder es tun möchten,

Sie müssen nur die ftitle-Funktion ändern.

Hier ist ein weiteres Beispiel, das zeigt, dass Sie einen ganzen Text bearbeiten können:

Beispiel:

  // Willkommensnachricht

  string font(int f) { return chr(1, f); }

  string style (bool unterstrichen, bool kursiv, bool fett) { int s=0; if (unterstrichen) s++; wenn (kursiv) s+=2; wenn (fett) s+=4; Rückgabe chr(2, s); }

  string color(int col) { return chr(4, col & 0xFFFF, col>>16); }

  schnurrot ()

  {

    Farbe zurückgeben (0x8080FF);

  }

  Zeichenfolge Auswirkung ()

  {

    Schriftart zurückgeben (8);

  }

  Zeichenfolge Willkommen (Zeichenfolge Benutzer-ID)

  {

    return red() + Impact() + "Willkommen " + Benutzer-ID + "!";

  }

  eventtouch()

  {

    sag (Willkommen (avatar_name(touched_avatar()))));

  }

Beachten Sie im obigen Beispiel, dass wir den Parameter userid übergeben haben

zur Welcome()-Funktion, weil sie es brauchte!

Eine andere Lösung wäre gewesen, statt einer Funktion eine Prozedur zu verwenden.

Der Unterschied zwischen den beiden ist sehr gering: Eine Funktion gibt einen Wert zurück

oder ein Text, eine Prozedur gibt nichts zurück!

Beispiel:

  // Willkommensnachricht

  string font(int f) { return chr(1, f); }

  string style (bool unterstrichen, bool kursiv, bool fett) { int s=0; if (unterstrichen) s++; wenn (kursiv) s+=2; wenn (fett) s+=4; Rückgabe chr(2, s); }

  string color(int col) { return chr(4, col & 0xFFFF, col>>16); }

  schnurrot ()

  {

    Farbe zurückgeben (0x8080FF);

  }

  Zeichenfolge Auswirkung ()

  {

    Schriftart zurückgeben (8);

  }

  void Willkommen (String Benutzer-ID)

  {

    sag (red() + Impact() + "Willkommen " + Benutzer-ID + "!");

  }

  eventtouch()

  {

    Willkommen (avatar_name(touched_avatar()));

  }

Oben sehen Sie, dass es die say()-Prozedur nicht mehr gibt

im Touch-Event, sondern im Welcome-Verfahren.

Kapitel 18: Ziehe eine Zufallszahl

=====================================

Wie zeige ich eine zufällige Willkommensnachricht an?

Mit der rnd()-Funktion!

Beispiel:

  // zufällige Willkommensnachricht

  eventtouch()

  {

    int n;

    n = rnd(1, 3); //

zieht eine Zufallszahl zwischen 1 und 3

    wenn (n == 1)

      sagen ("Hallo, wie geht es dir?");

    sonst wenn (n == 2)

      sagen ("Wow, ich mag dich nicht!");

    anders

      say ("komm später wieder, ich bin nicht hier :p");

  }

Beachten Sie hier, dass die Variable „n“ nicht am Anfang des Skripts deklariert wurde

wie üblich, aber im Verfahren: es verliert daher seinen Wert

zwischen zwei Aktionen, während das Skript schläft, aber das ist in Ordnung

weil wir es nicht behalten wollen.

Kapitel 19: Lesen einer Datei

============================

Das folgende Skript wählt einen zufälligen Begrüßungstext aus einer Datei aus

die Sie im Skriptordner des Objekts abgelegt haben:

Beispiel:

  // zufällige Willkommensnachricht

  eventtouch()

  {

    // Anzahl der Zeilen in der Datei welcome.txt zählen

    int count = count_lines("willkommen.txt");

    // Ziehen Sie eine Zufallszahl zwischen 1 und count

    int n = rnd(1, count);

    // Ausgewählte Zeile aus der Datei extrahieren

    string(128) s = read_line("welcome.txt", n);

    // die Zeile anzeigen

    sagen (s);

  }

Kapitel 20: Speichern von Informationen auf dem Server

===========================================

Sie wissen, dass die oben im Skript deklarierten Variablen ihre behalten

Wert zwischen zwei Aktionen. Aber was passiert, wenn das Skript geändert wird?

Natürlich werden sie gelöscht.

Was benötigt wird, ist eine Möglichkeit, Daten auf eine Weise aufzubewahren

permanent, auf der Festplatte...

Wir verwenden dazu die Funktionen store und fetch, die das Schreiben erlauben

Informationen über den Planet-Server und lesen Sie sie später erneut.

speichern (Schublade, Wert); // speichere den Wert in der Server-Schublade

                          // Beispiel: store ("PLAY-GUESS", "1 35 16 32 89 12");

s = holen (Schublade); // gibt den in der Schublade enthaltenen Wert zurück

                          // Beispiel: fetch("PLAY-GUESS") == "1 35 16 32 89 12"

Wie funktioniert es?

Stellen Sie sich vor, Sie befinden sich in einer großen Bibliothek mit einer Schubladenwand vor sich.

Auf jeder Schublade steht ein Name.

Wenn Sie eine Schublade öffnen, können Sie einen Wert hineinlegen und sie schließen.

Später können Sie die Schublade wieder öffnen und den Wert abrufen, den Sie dort abgelegt haben.

Genau so funktioniert Store-and-Fetch.

Es steht Ihnen natürlich frei, den gewünschten Wert in die Schublade zu legen.

Es kann eine Punktzahl, Punkte oder die Anzahl der Eingaben eines Chatters sein

im Zimmer, das Datum und die Uhrzeit seines letzten Besuchs oder andere Informationen.

Ende

===