Ugrás a fő tartalomra

Segíts frissíteni ezt az oldalt

🌏

Az oldal új verziója jelenleg csak angolul érhető el. Segíts nekünk a fordításban.

Oldal fordítása
Lásd angolul

Itt nincsenek bugok!🐛

Ez az oldal nincs lefordítva. Egyelőre szándékosan hagytuk meg angol nyelven ezt az oldalt.

Okos szerződés nyelvek

Utolsó módosítás: , Invalid DateTime
Oldal szerkesztése

Az Ethereum egyik nagyszerű szempontja, hogy az okosszerződéseket viszonylag fejlesztőbarát nyelveken lehet programozni. Ha már jártas vagy a Python vagy a JavaScript használatában, akkor találhatsz hasonló szintaxisú nyelvet.

A két legaktívabb és leginkább karbantartott nyelv:

  • Solidity
  • Vyper

A tapasztaltabb fejlesztők kipróbálhatják a Yul nyelvet, mely egy haladó nyelv az Ethereum Virtuális Gépre, vagy a Yul+-t, mely a Yul kiterjesztése.

Előfeltételek

A programozási nyelvek, különösen a JavaScript vagy a Python korábbi ismerete segíthet az okosszerződés nyelvekben mutatkozó különbségek értelmezésében. Azt is javasoljuk, hogy értsd meg az okosszerződést, mint fogalmat, mielőtt túl mélyre ásnál a nyelvi összehasonlításokban. Bevezetés az okosszerződésekbe.

Solidity

  • A C++, Python és a JavaScript gyakorolt rá hatást.
  • Statikusan típusos (a változó típusa ismert a fordítási időben).
  • Támogatja:
    • Öröklődés (kiterjeszthetsz más szerződéseket).
    • Könyvtárak (újrafelhasználható kódot írhatsz, melyet meghívhatsz különböző szerződésekből – mint a statikus függvényeket statikus osztályokban más objektumorientált programozási nyelveken).
    • Komplex felhasználó által definiált típusok.
  • Dokumentáció
  • Solidity Nyelv Portál
  • Solidity egy példa alapján
  • GitHub
  • Solidity Gitter Chatszoba
  • Cheat Sheet
  • Solidity Blog

Példa szerződés

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5 // A "public" kulcsszó a változókat
6 // elérhetővé teszi más szerződések számára
7 address public minter;
8 mapping (address => uint) public balances;
9
10 // Az események lehetővé teszik, hogy a kliensek
11 // általad deklarált szerződés változásokra reagáljanak
12 event Sent(address from, address to, uint amount);
13
14 // A konstruktor csak a szerződés létrehozásakor
15 // fut le
16 constructor() {
17 minter = msg.sender;
18 }
19
20 // Az újonnan létrehozott tokeneket elküldi egy címre
21 // Csak a szerződés létrehozó hívhatja meg
22 function mint(address receiver, uint amount) public {
23 require(msg.sender == minter);
24 require(amount < 1e60);
25 balances[receiver] += amount;
26 }
27
28 // Elküld valamennyi létező tokent
29 // bármely hívótól egy címre
30 function send(address receiver, uint amount) public {
31 require(amount <= balances[msg.sender], "Insufficient balance.");
32 balances[msg.sender] -= amount;
33 balances[receiver] += amount;
34 emit Sent(msg.sender, receiver, amount);
35 }
36}
37
Összes megjelenítése
📋 Másolás

Ez a példa adhat egy benyomást arról, hogyan néz ki a Solidity szerződés szintaxis. A függvények és a változók részletesebb leírásáért, nézd meg a dokumentációt.

Vyper

  • Pythonikus programozási nyelv
  • Erősen típusos
  • Kicsi és érthető fordító kód
  • Szándékosan kevesebb elemmel rendelkezik, mint a Solidity azzal a céllal, hogy a szerződések biztonságosabbak és könnyebben auditálhatóak legyenek. A Vyper nem támogatja a:
    • Módosítókat (modifier)
    • Öröklést
    • Soron belüli assembly-t
    • Függvény overloading-ot
    • Operátor overloading-ot
    • Rekurzív hívást
    • Végtelen hosszú ciklusokat
    • Bináris fix pontokat

További információért, olvasd el a Vyper indoklást.

Példa

1# Nyílt Aukció
2
3# Aukció paraméterek
4# A kedvezményezett pénzt kap a legnagyobb licitálótól
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Az aukció jelenlegi állapota
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Legyen igaz a végén, bármely változást elutasít
14ended: public(bool)
15
16# Számontartja a visszafizetett liciteket, így követni tudjuk a kiutalási mintát
17pendingReturns: public(HashMap[address, uint256])
18
19# Egy egyszerű aukció létrehozása `_bidding_time`
20# másodpercnyi licit idővel a kedvezményezett cím
21# `_beneficiary` nevében.
22@external
23def __init__(_beneficiary: address, _bidding_time: uint256):
24 self.beneficiary = _beneficiary
25 self.auctionStart = block.timestamp
26 self.auctionEnd = self.auctionStart + _bidding_time
27
28# Licitálás az aukción
29# a tranzakcióval küldött értékkel.
30# Az érték csak akkor kerül visszautalásra
31# ha az aukció nincs megnyerve.
32@external
33@payable
34def bid():
35 # Ellenőrzi, hogy a licit idő véget ért-e már.
36 assert block.timestamp < self.auctionEnd
37 # Ellenőrzi, hogy elég magas-e a licit
38 assert msg.value > self.highestBid
39 # Nyomonköveti az előző legmagasabb licit visszatérítését
40 self.pendingReturns[self.highestBidder] += self.highestBid
41 # Nyomonköveti a legmagasabb licitet
42 self.highestBidder = msg.sender
43 self.highestBid = msg.value
44
45# Kiutalja az előzőleg visszatérített licitet. A kiutalási mintát használjuk itt,
46# hogy elkerüljünk egy biztonsági rést. Ha a visszatérítés közvetlenül
47# a bid() része lenne, egy ártalmas licit szerződés blokkolhatná
48# ezeket a visszatérítéseket, így blokkolná a magasabb bejövő liciteket.
49@external
50def withdraw():
51 pending_amount: uint256 = self.pendingReturns[msg.sender]
52 self.pendingReturns[msg.sender] = 0
53 send(msg.sender, pending_amount)
54
55# Vége az aukciónak és elküldi a legmagasabb licitet
56# a kedvezményezettnek.
57@external
58def endAuction():
59 # Jó gyakorlat a szerződéssel interakcióba lépő függvényeket
60 # (vagyis függvény hívásokat, vagy küldést végző függvények)
61 # három fázisra osztani:
62 # 1. feltételek ellenőrzése
63 # 2. akció végrehajtás (potenciálisan megváltoztatja a feltételeket)
64 # 3. interakció más szerződésekkel
65 # Ha ezt a sorrendet felcseréljük, akkor más szerződés visszahívhat
66 # a jelenlegi szerződésbe és módosíthatja az állapotot vagy
67 # többszörösen elvégzett műveletet eredményezhet (ether kifizetés).
68 # Ha a belsőleg meghívott függvény külső szerződéssel történő
69 # interakciót tartalmaz, akkor azokat is külső szerződéssel történő
70 # interakcióként kell kezelni.
71
72 # 1. Feltételek
73 # Ellenőrzi, hogy elértük-e az aukció végét
74 assert block.timestamp >= self.auctionEnd
75 # Ellenőrzi, hogy függvény meg lett-e már hívva
76 assert not self.ended
77
78 # 2. Hatások
79 self.ended = True
80
81 # 3. Interakció
82 send(self.beneficiary, self.highestBid)
83
Összes megjelenítése
📋 Másolás

Ez a példa adhat egy benyomást arról, hogyan néz ki a Vyper szerződés szintaxis. A függvények és a változók részletesebb leírásáért, nézd meg a dokumentációt.

Yul és Yul+

Ha neked még új az Ethereum és nem programoztál okosszerződés nyelveken, akkor azt javasoljuk, hogy kezdj először a Solidity-vel és a Vyper-rel. Csak akkor kezdj bele a Yul-ba vagy a Yul+-ba, ha már ismered az okosszerződés biztonsági praktikákat és az EVM-mel kapcsolatos munka részleteit.

Yul

  • Haladó nyelv Ethereumra.
  • Támogatja az EVM-et és az eWASM-t, ami egy Ethereummal fűszerezett WebAssembly, amit a két platform közös nevezőjének terveztek.
  • Jó cél a magas szintű optimizációs szinteknek, melyek az EVM-ből és az eWASM-ból is tudnak profitálni.

Yul+

  • A Yul egy alacsony szintű, nagy hatékonyságú kiterjesztése.
  • Eredetileg az optimista összegző szerződésre lett kifejlesztve.
  • A Yul+-ra úgy is tekinthetünk, mint a Yul-nak egy kísérleti fejlesztési javaslatára, melyhez új funkciók tartoznak.

Példa szerződés

Az alábbi egyszerű példa egy hatvány függvényt implementál. A solc --strict-assembly --bin input.yul használatával lehet befordítani. Ezt a példát az input.yul fájlnak kell tartalmaznia.

1{
2 function power(base, exponent) -> result
3 {
4 switch exponent
5 case 0 { result := 1 }
6 case 1 { result := base }
7 default
8 {
9 result := power(mul(base, base), div(exponent, 2))
10 if mod(exponent, 2) { result := mul(base, result) }
11 }
12 }
13 let res := power(calldataload(0), calldataload(32))
14 mstore(0, res)
15 return(0, 32)
16}
17
Összes megjelenítése

Ha már sok tapasztalatod van az okosszerződésekkel, akkor a teljes ERC20 implementáció a Yul-ban itt érhető el.

Hogyan válasszunk

Mint minden más programozási nyelvnél, itt is leginkább a megfelelő eszköz kiválasztása a megfelelő munkához, valamint a személyes preferenciák döntenek.

Íme néhány szempont, amelyet érdemes figyelembe venni, ha még nem próbáltad meg egyik nyelvet sem:

Mi a jó a Solidity-ben?

  • Ha kezdő vagy, akkor sok útmutató és tanulási anyag áll rendelkezésedre. További anyagért látogasd meg Tanulás kódolással szekciót.
  • Jó fejlesztői eszközök érhetők el.
  • A Solidity-nek nagy a fejlesztői közössége, ami azt jelenti, hogy nagy valószínűséggel gyorsan választ kapsz majd a kérdéseidre.

Mi a jó a Vyper-ben?

  • Nagyszerű módszer az okosszerződéseket írni kívánó Python fejlesztők számára.
  • A Vyper kevesebb funkcióval rendelkezik, így nagyszerűen lehet az ötleteidből gyorsan prototípust készíteni.
  • A Vyper célja, hogy könnyen auditálható és emberek számára olvasható legyen.

Mi a jó a Yul-ban és a Yul+-ban?

  • Egyszerűsített és funkcionális alacsony szintű nyelv.
  • Közelebb enged a nyers EVM-hez, így könnyebben tudod a szerződéseid gáz felhasználását optimálni.

Nyelv összehasonlítások

Az alapvető szintaxis, szerződés életciklus, interfészek, operátorok, adatszerkezetek, függvények, control flow és további szempontok alapján történő összehasonlításért olvasd el a cheatsheet by Auditless cikket

További olvasnivaló

Hasznosnak találtad a cikket?