Solidity ist eine objektorientierte Hochsprache für die Entwicklung von dApps (dezentralen Anwendungen) in der Ethereum-Blockchain.
Eine Blockchain ist ein Peer-to-Peer-Netzwerk von Computern, die als Knoten bezeichnet werden und alle Daten und den Code im Netzwerk gemeinsam nutzen.
Wenn Sie also ein mit der Blockchain verbundenes Gerät sind, sind Sie ein Knoten im Netzwerk und sprechen mit allen anderen Computerknoten im Netzwerk (wir werden in späteren Lernprogrammen erläutern, wie Sie den Ethereum-Knoten auf Ihrem lokalen Computer einrichten)..
Sie haben jetzt eine Kopie aller Daten und des Codes in der Blockchain. Es werden keine zentralen Server mehr benötigt.
Contents
Was ist Ethereum??
Im einfachsten Fall ist Ethereum eine offene Softwareplattform, die auf Blockchain-Technologie basiert und es Entwicklern ermöglicht, dezentrale Anwendungen zu erstellen und bereitzustellen.
Während die Bitcoin-Blockchain verwendet wird, um den Besitz digitaler Währungen (Bitcoins) zu verfolgen, konzentriert sich die Ethereum-Blockchain auf die Ausführung des Codes dezentraler Anwendungen.
In der Ethereum-Blockchain arbeiten Bergleute nicht an Bitcoin, sondern an Ether, einer Art Krypto-Token, der das Netzwerk antreibt. Neben einer handelbaren Kryptowährung wird Ether auch von Anwendungsentwicklern verwendet, um Transaktionsgebühren und -dienste im Ethereum-Netzwerk zu bezahlen.
Es gibt eine zweite Art von Token, mit der Bergarbeitergebühren für die Aufnahme von Transaktionen in ihren Block gezahlt werden. Sie wird als Gas bezeichnet. Bei jeder intelligenten Vertragsabwicklung muss eine bestimmte Menge Gas mitgeschickt werden, um Bergleute zum Einsetzen zu verleiten die Blockchain.
Beginnend mit den Grundlagen
Der Code von Solidity ist in Verträgen enthalten.
Mit der Ethereum-Blockchain können wir Code mit der Ethereum Virtual Machine (EVM) in der Blockchain mit einem sogenannten Smart-Vertrag ausführen.
In intelligenten Verträgen lebt die gesamte Geschäftslogik unserer Anwendung – alle Variablen und Funktionen gehören zu einem Vertrag, und dies ist der Ausgangspunkt all Ihrer Projekte.
Intelligente Kontakte werden in einer Programmiersprache namens Solidity geschrieben, die wie eine Mischung aus Javascript und C aussieht.
Remix IDE
Remix ist ein Online-Tool, mit dem Sie Solidity-Smart-Verträge schreiben, diese dann bereitstellen und ausführen können.
Geh einfach zu https://remix.ethereum.org von Ihrem Browser und wir können mit dem Codieren beginnen.
Wie Sie sehen können, können Sie zwischen Solidity und Vyper wählen. Beide sind Sprachen zum Schreiben intelligenter Verträge, Vyper ist pythonartig und Solidity ist javascriptartig.
Beide können mit dem EVM-Bytecode kompiliert werden, ähnlich wie Javascript und Typescript. Wir wählen Solidity.
Auf der linken Seite befindet sich der Datei-Explorer. Standardmäßig gibt es zwei .sol-Dateien, nur um die grundlegende Syntax zu demonstrieren (ballot.sol ist ein intelligenter Vertrag, ballot_test.sol ist ein Skript zum Testen dieses intelligenten Vertrags)..
Sie müssen nur auf diese Plus-Schaltfläche klicken, und wir können mit der Codierung unseres ersten intelligenten Vertrags beginnen.
Der gesamte Solidity-Quellcode sollte mit einem „Versionspragma“ beginnen – einer Deklaration der Version des Solidity-Compilers, die dieser Code verwenden sollte. Dies soll verhindern, dass Probleme mit zukünftigen Compilerversionen möglicherweise zu Änderungen führen, die Ihren Code beschädigen würden.
Es sieht aus wie das:
Pragma-Solidität ^ 0,4,25;
(für die Solidity-Version über 0.4.25)
oder
Pragma Solidität >= 0,5,0 < 0,6,0;
(für die Solidity-Version zwischen 0.5.0 und 0.6.0)
Anschließend erstellen Sie Ihren Vertrag, indem Sie ein reserviertes Wort eingeben Vertrag und den Namen Ihrer .sol-Datei (Es ist wichtig, dass der Vertragsname mit dem Namen der Datei übereinstimmt. Wir werden später erläutern, warum). In unserem Fall,
Vertrag MyFirstContract {
}}
Kompilieren wir es. Sie müssen nur zu dieser Registerkarte zum Kompilieren links navigieren und auf die große Schaltfläche zum Kompilieren klicken. Wenn etwas mit dem Code nicht stimmt, werden hier Fehler und Warnungen angezeigt (seien Sie mit Solidity einverstanden, es ist immer noch eine „junge Sprache“)..
Mit unserem aktuellen Vertrag ist alles in Ordnung, weil wir wirklich nichts getan haben.
Jetzt werde ich absichtlich Fehler erzeugen, nur um Ihnen etwas zu zeigen. Sie können den Compiler manuell aus diesem Dropdown-Menü auswählen.
Wählen wir zum Beispiel die Version 0.4.26. Kompilieren Sie es jetzt erneut. Jetzt wird der Fehler “Compiler noch nicht geladen” angezeigt.
Dies liegt daran, dass wir mit Pragma angegeben haben, dass mit Compilerversionen über 0.5.0 gearbeitet werden soll. Ändern Sie einfach die Compiler-Version erneut, und der Fehler wird behoben.
Okay, lass uns jetzt codieren!
Wir werden mit einfachem “Hallo Welt” -Code beginnen und Funktionen abrufen und festlegen, um uns mit der Syntax vertraut zu machen.
Ein Vertrag im Sinne von Solidity ist eine Sammlung von Code (seine Funktionen) und Daten (sein Status), die sich an einer bestimmten Adresse in der Ethereum-Blockchain befinden.
Definieren wir zunächst die Statusvariable “Nachricht”, deren Typ “Zeichenfolge” ist.
Unsere get-Funktion gibt den Wert unserer variablen Nachricht zurück, und die set-Funktion weist unserer variablen Nachricht einen neuen Wert zu.
So geben Sie Funktionen ein?
Erstens reserviertes Wort Funktion dann der Name einer bestimmten Funktion und Parameter und danach .
Funktion myFunction () gibt (bool) {zurück
return true;
}}
Funktionen können sein Öffentlichkeit oder Privat. Wenn eine Funktion öffentlich ist, kann sie außerhalb des Vertrags aufgerufen werden. Wenn eine Funktion privat ist, hat sie einen begrenzten Umfang und kann nur aus ihrem aktuellen Vertrag (z. B. aus einer anderen Funktion) aufgerufen werden..
Hier ist die Liste aller Funktionssichtbarkeitsspezifizierer:
- Öffentlichkeit: extern und intern sichtbar (erstellt eine Getter-Funktion für Speicher- / Statusvariablen)
- Privat: nur im aktuellen Vertrag sichtbar
- extern: nur extern sichtbar (nur für Funktionen) – d. h. kann nur als Nachricht aufgerufen werden (über this.func)
- intern: nur intern sichtbar
Funktionen können sein rein, Aussicht, oder zahlbar. Wenn eine Funktion keine Daten in die Blockchain schreibt, wird die Anzeige dringend empfohlen, da Ansichtsfunktionen kein Gas kosten.
Hier ist die Liste aller Funktionsmodifikatoren (es gibt auch Modifikatoren für Statusvariablen, Ereignisse und Ereignisargumente, auf die später noch eingegangen wird):
- rein: Verbietet keine Änderung oder keinen Zugriff auf den Status.
- Aussicht: Verbietet keine Änderung des Status.
- zahlbar: Ermöglicht es ihnen, Ether zusammen mit einem Anruf zu empfangen.
Wenn Function einen Wert zurückgibt, müssen Sie diesen mit reserviertem Wort angeben kehrt zurück und dann in regulären Klammern, um anzugeben, welcher Typ die Funktion zurückgibt. In unserem Fall handelt es sich um eine Zeichenfolge (da wir unsere variable Nachricht als Zeichenfolge zurückgeben).
Wenn die Funktion keinen Wert zurückgibt, ist dies nicht erforderlich kehrt zurück Erklärung.
Für den Zugriff auf eine Statusvariable benötigen Sie kein Präfix Dies. wie es in anderen Sprachen üblich ist.
Aus diesem Grund ist es üblich, Funktionsargumente mit Unterstrichsyntax zu schreiben (_Botschaft). Diese Konvention stammt aus Javascript, wo private Methoden und Variablen mit _ beginnen.
Um klar zu sein, Ihr Code funktioniert einwandfrei und ohne Unterstriche, ist aber mit ihnen sauberer.
Sie werden ein reserviertes Wort bemerken Erinnerung in unserem Code. Wenn Sie unseren Code ohne Speicher schreiben und Pragma auf eine Version unter 0,5 setzen. * Funktioniert dies einwandfrei, aber wenn Sie Ihren Compiler auf über 0,5 ändern. * EVM generiert einen Kompilierungsfehler.
Warum passiert das?
Nun, die virtuelle Maschine von Ethereum verfügt über drei Bereiche, in denen Gegenstände gespeichert werden können.
- Das erste ist Lager, Hier befinden sich alle Vertragsstatusvariablen. Jeder Vertrag hat seinen eigenen Speicher und ist zwischen Funktionsaufrufen dauerhaft und recht teuer in der Verwendung.
- Der zweite ist Erinnerung, Dies wird verwendet, um temporäre Werte zu speichern. Es wird zwischen (externen) Funktionsaufrufen gelöscht und ist billiger zu verwenden.
- Der dritte ist der Stapel, Hier werden kleine lokale Variablen gespeichert. Die Verwendung ist fast kostenlos, kann jedoch nur eine begrenzte Anzahl von Werten enthalten.
Für fast alle Typen können Sie nicht angeben, wo sie gespeichert werden sollen, da sie bei jeder Verwendung kopiert werden.
Wenn Sie jedoch mit Arrays oder Strukturen arbeiten und ab den neuesten Versionen auch mit Zeichenfolgen, werden Sie vom Compiler gezwungen, den Speicherbereich anzugeben.
Unser Code sieht jetzt so aus:
Pragma-Solidität ^ 0,5,0;
Vertrag MyFirstContract {
Zeichenfolge Nachricht;
Funktion get () public view gibt zurück (String-Speicher) {
Rückmeldung;
}}
Funktionssatz (String Memory _message) public {
message = _message;
}}
}}
Beachten Sie, dass einige Solidity-Entwickler diese Sichtbarkeitsspezifizierer in separate Zeilen aufteilen, um den Code sauberer zu gestalten. Unsere get-Funktion kann also folgendermaßen geschrieben werden:
Funktion get ()
Öffentlichkeit
Aussicht
gibt zurück (Zeichenfolge)
{
Rückmeldung;
}}
Es liegt ganz bei Ihnen, wie Sie Ihre Funktionen schreiben.
Lassen Sie uns jetzt unseren Vertrag zusammenstellen und testen.
Um es zu kompilieren, wiederholen Sie einfach die Schritte von unten (Kompiliere .sol Taste oder cmd / Strg + S. von der Tastatur und es wird es automatisch neu kompilieren)
Um zu sehen, wie es tatsächlich funktioniert (wenn beim Kompilieren keine Fehler auftreten), müssen Sie Ihren Vertrag bereitstellen.
Navigieren Sie dazu von links zur Registerkarte Bereitstellung. Wählen Sie für die Umgebung JavaScriptVM aus und klicken Sie auf die Schaltfläche Bereitstellen.
Nach der Bereitstellung können wir nun Methoden aus unserem Vertrag anzeigen. Konzentrieren wir uns jetzt nur auf diesen Teil des Bildschirms.
Sie können sehen, dass es zwei Schaltflächen gibt (get & set) für unsere beiden öffentlichen Funktionen. Wenn einer von denen privat wäre, würden wir ihn hier nicht sehen.
Wenn wir auf die Schaltfläche “Get” klicken, führt EVM unsere Funktion “get” aus.
Mal sehen, wie es geklappt hat.
Wir haben eine leere Zeichenfolge. Nicht großartig, nicht schrecklich. Aber wieso? Nun, weil wir unsere Nachrichtenvariable nicht an erster Stelle initialisiert haben.
Nur eine kurze Pause. Ich möchte, dass Sie das Remix-Terminal vorstellen. Es befindet sich im Code-Editor. Hier können Sie alle Ihre Transaktionen verfolgen, um festzustellen, ob sie erfolgreich ausgeführt wurden oder nicht, um sie zu debuggen, um Details (Transaktions-Hash usw.) anzuzeigen und vieles mehr.
Derzeit haben wir zwei erfolgreiche Transaktionen. Eine ist die Vertragsbereitstellung und kostet uns Äther (aber keine Sorge, wir sind jetzt im Editor, alles ist virtuell) und die zweite ist Call of our Aussicht Funktion.
Ok, lass uns jetzt zurück gehen. Was passiert, wenn wir jetzt die Set-Funktion aufrufen??
Wir müssen ein Argument _message (zum Beispiel „Hello World“) übergeben und die Transact-Taste drücken, um die Funktion auszuführen. Sie können den Erfolg einer Transaktion im Terminal verfolgen.
Rufen wir nun die Funktion get erneut auf. Jetzt gibt es unsere Nachricht zurück.
Nehmen wir einige Verbesserungen an unserem Code vor. Wir haben unsere variable Nachricht nicht initialisiert. Lass uns das machen.
Vertrag MyFirstContract {
Zeichenfolge message = "Hallo Welt!";;
Funktion get () public view gibt zurück (String-Speicher) {
Rückmeldung;
}}
Funktionssatz (String Memory _message) public {
message = _message;
}}
}}
Beachten Sie, dass die Nachricht jetzt “Hallo Welt!” Lautet. Wenn wir zum ersten Mal die Funktion get aufrufen, wird keine leere Zeichenfolge zurückgegeben.
Um dies zu testen, müssen wir unseren Vertrag kompilieren (cmd / ctrl + S)..
Dann, um es erneut bereitzustellen. Wir müssen eine neue Vertragsinstanz erstellen (aufgrund der von uns vorgenommenen Änderungen) und diese in der Blockchain veröffentlichen.
Löschen Sie einfach die vorherige Version aus dem Editor (natürlich nicht aus unserer virtuellen Blockchain) und klicken Sie erneut auf die Schaltfläche Bereitstellen. Rufen wir jetzt unsere get-Funktion auf.
Nett! Rufen wir jetzt die Set-Funktion auf.
Und wieder kommen.
Cool.
Machen wir jetzt unsere Botschaft a Konstante.
Unser Code jetzt:
Pragma-Solidität ^ 0,5,0;
Vertrag MyFirstContract {
Zeichenfolge Konstante Nachricht = "Hallo Welt!";;
Funktion get () public view gibt zurück (String-Speicher) {
Rückmeldung;
}}
Funktionssatz (String Memory _message) public {
message = _message;
}}
}}
Wenn wir versuchen, es zu kompilieren, erhalten wir Fehler in unserer Set-Funktion. Das liegt daran, dass man einen Wert einer Konstante nicht ändern kann.
Wir werden diese Konstante jetzt einfach loswerden.
Das Initialisieren solcher Variablen ist kein Fehler, aber es ist viel besser, wenn wir dies im Konstruktor tun. Sie können den Konstruktor in Solidity schreiben mit:
Konstruktor () public {
// etwas tun…
}}
Der Konstruktor ist nur eine weitere Funktion, die während der Bereitstellung eines intelligenten Vertrags aufgerufen wird. Unser Code sieht ein bisschen anders aus, funktioniert aber gleich.
Pragma-Solidität ^ 0,5,0;
Vertrag MyFirstContract {
Zeichenfolge Nachricht;
Konstruktor () public {
message = "Hallo Welt!";;
}}
Funktion get () public view gibt zurück (String-Speicher) {
Rückmeldung;
}}
Funktionssatz (String Memory _message) public {
message = _message;
}}
}}
Sie können es erneut kompilieren und testen, wenn Sie möchten.
Schließlich kann man die Sichtbarkeit von Zustandsvariablen ändern. Wenn Sie Ihre Zustandsvariablen machen Öffentlichkeit das heißt, man kann ihre Werte von außerhalb des Vertrages beanspruchen.
Solidity macht für jede öffentliche Zustandsvariable eine Methode mit demselben Namen, die als reguläre Funktion aufgerufen werden kann (ein bisschen wie eine Getter-Funktion)..
Dies bedeutet, dass wir unsere get-Funktion loswerden können, deklarieren Sie einfach die variable Nachricht als Öffentlichkeit, und unser Code wird genauso funktionieren, er wird viel sauberer sein und es wird uns weniger kosten, ihn eines Tages im Hauptnetzwerk bereitzustellen.
Je größer der Code ist, desto mehr Gas wird für die Ausführung benötigt und die Kosten für den Betrieb unserer dApp steigen.
Wenn wir intelligente Verträge entwickeln, müssen wir:
- effizient – Der Gasverbrauch muss niedrig sein
- präzise – Sobald Sie einen Smart Contract bereitgestellt haben, kann dieser nicht mehr geändert werden und ist rund um die Uhr für jede einzelne Codezeile öffentlich (stellen Sie sich einen Hacker vor, der einen Fehler findet und Ihre dApp ausnutzen kann)
Unser endgültiger Code für heute sieht folgendermaßen aus:
Pragma-Solidität ^ 0,5,0;
Vertrag MyFirstContract {
Zeichenfolge öffentliche Nachricht;
Konstruktor () public {
message = "Hallo Welt!";;
}}
Funktionssatz (String Memory _message) public {
message = _message;
}}
}}
Lassen Sie es uns bereitstellen und testen.
Sie können diese Meldungstaste sehen. Es wird erstellt, weil unsere Statusvariablennachricht öffentlich ist.
Wenn wir das nennen, sollte es uns einen Wert zurückgeben, der durch den Konstruktor initialisiert wird (das ist “Hallo Welt!”)..
Nett. Testen wir jetzt die Set-Funktion.
Wie man Solidität lernt?
Solidity selbst ist eine ziemlich einfache Sprache, aber um ein guter Solidity-Entwickler zu sein, muss man verstehen, wie alles auf Ethereum funktioniert.
- Solidity ist eine Programmiersprache auf hoher Ebene mit einer Syntax ähnlich ECMAScript (Javascript)..
- Es wird zu EVM-Bytecode kompiliert, was nur das EVM verstehen kann.
- Der Compiler heißt Solc.
Nehmen wir diesen einfachen Vertrag als Beispiel:
Pragma-Solidität ^ 0,5,0;
Vertragsbeispiel {
uint a = 10 + 5;
}}
So einfach ist das. Jetzt kompilieren wir es. Wenn wir im Terminal zu den Vertragsdetails gehen, sehen wir viele Informationen.
In diesem Fall lautet der kompilierte Code:
0x6080604052600f600055348015601457600080fd5b5060358060226000396000f3fe6080604052600080fdfea165627a7a72305820bf75c57b7d8745a79baee513ead21a9eb8b075896f8e4c
Diese langen Werte sind hexadezimale Darstellungen des endgültigen Vertrags, auch als Bytecode bezeichnet. EVM versteht nur Bytecode.
Aber wenn etwas schief geht, stecken wir mit einem Fehler fest, zum Beispiel kann man den Bytecode nicht debuggen.
Opcodes
Die Sprache über dem Bytecode ist der Opcode. Opcode ist eine einfache Programmiersprache. Solidität und Opcode sind zum Beispiel wie C und Assemblersprache.
Wenn wir also eine fehlgeschlagene Transaktion debuggen müssen, debuggen wir den Opcode.
Eine Sache, die Sie über Solidity und Debugging wissen sollten – es ist sehr schwierig. Aber nicht unmöglich, also lasst uns darauf eingehen.
Dies ist der Opcode unseres Beispielvertrags:
0 PUSH1 60
02 PUSH1 40
04 MSTORE
05 PUSH1 0f
07 PUSH1 00
09 SSTORE
10 CALLVALUE
11 DUP1
12 ISZERO
13 PUSH1 14
15 JUMPI
16 PUSH1 00
18 DUP1
19 REVERT
20 JUMPDEST
21 POP
22 PUSH1 35
24 DUP1
25 PUSH1 22
27 PUSH1 00
29 CODECOPY
30 PUSH1 00
32 RÜCKGABE
33 UNGÜLTIG
34 PUSH1 80
36 PUSH1 40
38 MSTORE
39 PUSH1 00
41 DUP1
42 REVERT
43 UNGÜLTIG
44 LOG1
45 PUSH6 627a7a723058
52 SHA3
53 UNGÜLTIG
54 PUSH22 c57b7d8745a79baee513ead21a9eb8b075896f8e4c59
77 UNGÜLTIG
78 DUP10
79 UND
80 JUMPI
81 UNGÜLTIG
82 BALANCE
83 PUSH29 750029
Opcodes sind die von Menschen lesbaren Anweisungen des Programms auf niedriger Ebene. Alle Opcodes haben ihre hexadezimalen Gegenstücke, z MSTORE ist 0x52.
Das EVM ist Stack Machine. Es basiert auf der LIFO-Struktur (Last In First Out). Stellen Sie sich zur Vereinfachung vor, Sie stapeln Brotscheiben in einer Mikrowelle. Die letzte Scheibe, die Sie hineinlegen, ist die ERSTE, die Sie herausnehmen.
In der normalen Arithmetik schreiben wir unsere Gleichung folgendermaßen:
10 + 2 * 2
und die Antwort ist 14, weil wir vor der Addition multiplizieren.
In einer Stapelmaschine funktioniert es nach dem LIFO-Prinzip:
2 2 * 10 +
Dies bedeutet, dass zuerst 2 in den Stapel gelegt werden, gefolgt von weiteren 2, gefolgt von einer Multiplikationsaktion. Das Ergebnis sind 4, die oben auf dem Stapel sitzen. Fügen Sie nun eine Zahl 10 über 4 hinzu und addieren Sie schließlich die 2 Zahlen. Der Endwert des Stapels wird 14.
Das Einfügen von Daten in den Stapel wird als PUSH-Befehl bezeichnet, und das Entfernen von Daten aus dem Stapel wird als POP-Befehl bezeichnet. Es ist offensichtlich, dass der häufigste Opcode, den wir in unserem obigen Beispiel sehen, PUSH1 ist, was bedeutet, dass 1 Byte Daten in den Stapel gelegt werden.
Also, diese Anweisung:
PUSH1 0x60
bedeutet, einen 1-Byte-Wert von “0x60” in den Stapel zu legen. Zufälligerweise ist der Hexadezimalwert für PUSH1 ebenfalls “0x60”. Wenn wir das nicht obligatorische “0x” entfernen, können wir diese Logik im Bytecode als “6060” schreiben..
Gehen wir noch ein bisschen weiter.
PUSH1 0x60 PUSH1 0x40 MSTORE
Der MSTORE (0x52) nimmt 2 Eingänge auf und erzeugt keinen Ausgang. Die obigen Opcodes bedeuten:
PUSH1 (0x60): 0x60 in den Stapel legen.
PUSH1 (0x40): 0x40 in den Stapel legen.
MSTORE (0x52): 0x60 Speicherplatz zuweisen und an die Position 0x40 verschieben.
Der resultierende Bytecode lautet:
6060604052
Tatsächlich sehen wir diese magische Zahl „6060604052“ immer am Anfang eines Soliditätsbytecodes, weil es so ist, wie der Smart Contract Bootstrap.
Um die Sache weiter zu verkomplizieren, können 0x40 oder 0x60 nicht als reelle Zahl 40 oder 60 interpretiert werden. Da sie hexadezimal sind, entspricht 40 tatsächlich 64 (16¹ x 4) und 60 entspricht 96 (16¹ x 6) in Dezimalzahl.
Kurz gesagt, was “PUSH1 0x60 PUSH1 0x40 MSTORE” tut, ist, 96 Bytes Speicher zuzuweisen und den Zeiger an den Anfang des 64. Bytes zu bewegen. Wir haben jetzt 64 Bytes für den Arbeitsbereich und 32 Bytes für den temporären Speicher.
Im EVM gibt es 3 Orte zum Speichern von Daten. Erstens im Stapel. Wir haben gerade den PUSH-Opcode verwendet, um dort Daten wie im obigen Beispiel zu speichern.
Zweitens im Speicher (RAM), in dem wir den MSTORE-Opcode verwenden, und zuletzt im Plattenspeicher, in dem wir SSTORE zum Speichern der Daten verwenden. Das zum Speichern von Daten zum Speichern erforderliche Gas ist am teuersten und das Speichern von zu stapelnden Daten am billigsten.
Jetzt ist es an der Zeit, in diesem Tutorial zu unserem Solidity-Code zurückzukehren und noch einmal zusammenzufassen, was wir über reservierte Wörter gelernt haben Erinnerung und wie der Compiler uns zwingt anzugeben, wie wir beispielsweise Zeichenfolgen speichern.
Wir haben nur die Grundlagen des Bytecodes und einige Opcodes behandelt.
Wir müssen keine Opcodes kennen, um mit dem Schreiben eines intelligenten Vertrags zu beginnen!
Andererseits ist die EVM-Fehlerbehandlung immer noch sehr primitiv und es ist praktisch, Opcodes zu betrachten, wenn etwas schief geht.
Fazit
Diese erste Lektion hat etwas mehr Theorie als die eigentliche Codierung, aber für Anfänger ist es sehr wichtig zu wissen, wie die Dinge bei Ethereum funktionieren. In den nächsten Tutorials werden wir etwas interessanteren Code schreiben und lernen, wie wir unser eigenes Token in der Ethereum-Blockchain bereitstellen.
Bis dann &# 128075;
