Téigh ar aghaidh chuig an bpríomhábhar
Change page

Teangacha conartha cliste

Is gné iontach de Ethereum é gur féidir conarthaí cliste a ríomhchlárú le teangacha atá sách éasca do na forbróirí. Má tá taithí agat ar Python nó ar aon teanga "curly bracket"(opens in a new tab), is féidir leat teacht ar theanga le comhréir aithnidiúil.

Is iad seo an dá theanga is gníomhaí agus is mó cothabhála:

  • Solidity
  • Vyper

Soláthraíonn Remix IDE timpeallacht chuimsitheach forbartha chun conarthaí a chruthú agus a thástáil i Solidity agus Vyper araon. Bain triail as an IDE Remix sa bhrabhsálaí(opens in a new tab) chun an códú a thosú.

Seans gur mhaith le forbróirí a bhfuil níos mó taithí acu Yul a úsáid freisin, teanga idirmheánach don Ethereum Virtual Machine, nó Yul+, síneadh ar Yul.

Má tá tú fiosrach agus fonn ort cabhrú le tástáil a dhéanamh ar theangacha nua atá fós á bhforbairt go mór, is féidir leat triail a bhaint as Fe, teanga chonarthach cliste atá ag teacht chun cinn agus atá fós ina thús.

Réamhriachtanais

Is féidir le heolas atá agat cheana ar theangacha ríomhchlárúcháin, go háirithe ar JavaScript nó Python, cabhrú leat tuiscint a fháil ar dhifríochtaí i dteangacha conartha cliste. Molaimid duit freisin tuiscint a fháil ar choincheap na gconarthaí cliste roimh thochailt go ró-dhomhain isteach sna comparáidí teanga. Réamhrá ar chonarthaí cliste.

Solidity

  • Teanga ardleibhéil atá dírithe ar oibiachtaí chun conarthaí cliste a chur i bhfeidhm.
  • Teanga "curly-bracket" atá go mór faoi thionchar C++.
  • Scríofa go statach (tá an cineál athróige ar eolas ag am tiomsaithe).
  • Tacaíochtaí:
    • Oidhreacht (is féidir leat síneadh a chur le conarthaí eile).
    • Leabharlanna (is féidir leat cód ath-inúsáidte a chruthú ar féidir leat glaoch air ó chonarthaí éagsúla - cosúil le feidhmeanna statacha i rang statach i dteangacha ríomhchláraithe eile atá dírithe ar oibiachtaí).
    • Cineálacha casta atá sainithe ag an úsáideoir.

Naisc thábhachtacha

Conradh samplach

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // The keyword "public" makes variables
6    // accessible from other contracts
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // Events allow clients to react to specific
11    // contract changes you declare
12    event Sent(address from, address to, uint amount);
13
14    // Constructor code is only run when the contract
15    // is created
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // Sends an amount of newly created coins to an address
21    // Can only be called by the contract creator
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // Sends an amount of existing coins
29    // from any caller to an address
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}
Taispeáin gach rud
 Cóip

Ba chóir go dtabharfadh an sampla seo tuiscint duit ar chomhréir an chonartha Solidity. Tá tuairisc níos mionsonraithe a fháil ar na feidhmeanna agus na hathróga, sna doiciméid(opens in a new tab).

Vyper

  • Teanga ríomhchlárúcháin Pythonic
  • Clóscríobh láidir
  • Cód tiomsaitheora beag agus intuigthe
  • Giniúint éifeachtach beartchóid
  • Tá níos lú gnéithe aige d’aon ghnó ná Solidity agus é d'aidhm aige conarthaí a dhéanamh níos sláine agus níos éasca le hiniúchadh. Ní thacaíonn Vyper le:
    • Mionathraitheoirí
    • Oidhreacht
    • Tionól inlíne
    • Ró-ualú feidhme
    • Ró-ualú oibritheora
    • Glaonna athfhillteacha
    • Lúba fad gan teorainn
    • Pointí seasta dénártha

Le haghaidh tuilleadh faisnéise, léigh réasúnaíocht Vyper(opens in a new tab).

Naisc thábhachtacha

Sampla

1# Open Auction
2
3# Auction params
4# Beneficiary receives money from the highest bidder
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# Current state of auction
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# Set to true at the end, disallows any change
14ended: public(bool)
15
16# Keep track of refunded bids so we can follow the withdraw pattern
17pendingReturns: public(HashMap[address, uint256])
18
19# Create a simple auction with `_bidding_time`
20# seconds bidding time on behalf of the
21# beneficiary address `_beneficiary`.
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# Bid on the auction with the value sent
29# together with this transaction.
30# The value will only be refunded if the
31# auction is not won.
32@external
33@payable
34def bid():
35    # Check if bidding period is over.
36    assert block.timestamp < self.auctionEnd
37    # Check if bid is high enough
38    assert msg.value > self.highestBid
39    # Track the refund for the previous high bidder
40    self.pendingReturns[self.highestBidder] += self.highestBid
41    # Track new high bid
42    self.highestBidder = msg.sender
43    self.highestBid = msg.value
44
45# Withdraw a previously refunded bid. The withdraw pattern is
46# used here to avoid a security issue. If refunds were directly
47# sent as part of bid(), a malicious bidding contract could block
48# those refunds and thus block new higher bids from coming in.
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# End the auction and send the highest bid
56# to the beneficiary.
57@external
58def endAuction():
59    # It is a good guideline to structure functions that interact
60    # with other contracts (i.e. they call functions or send ether)
61    # into three phases:
62    # 1. checking conditions
63    # 2. performing actions (potentially changing conditions)
64    # 3. interacting with other contracts
65    # If these phases are mixed up, the other contract could call
66    # back into the current contract and modify the state or cause
67    # effects (ether payout) to be performed multiple times.
68    # If functions called internally include interaction with external
69    # contracts, they also have to be considered interaction with
70    # external contracts.
71
72    # 1. Conditions
73    # Check if auction endtime has been reached
74    assert block.timestamp >= self.auctionEnd
75    # Check if this function has already been called
76    assert not self.ended
77
78    # 2. Effects
79    self.ended = True
80
81    # 3. Interaction
82    send(self.beneficiary, self.highestBid)
Taispeáin gach rud
 Cóip

Ba cheart go dtabharfadh an sampla seo tuiscint duit ar chomhréir chonartha Vyper. Le cur síos níos mionsonraithe a fháil ar na feidhmeanna agus na hathróga, féach na doiciméid(opens in a new tab).

Yul agus Yul+

Mura bhfuil taithí agat ar Ethereum agus mura bhfuil aon chódú déanta agat le teangacha conartha cliste go fóill, molaimid duit tosú le Solidity nó Vyper. Ná breathnaigh ar Yul nó Yul+ go dtí go mbíonn tú eolach ar na cleachtais is fearr maidir le slándáil conarthaí cliste agus na sonraí a bhaineann le bheith ag obair leis an EVM.

Yul

  • Teanga idirmheánach le haghaidh Ethereum.
  • Tacaíonn sé le EVM agus Ewasm(opens in a new tab), WebAssembly ar a bhfuil blas Ethereum, agus tá sé deartha le bheith ina comhainmneoir inúsáidte ar an dá ardán.
  • Sprioc mhaith le haghaidh céimeanna optamaithe ardleibhéil ar féidir leo leas a dhéanamh do ardáin EVM agus Ewasm araon.

Yul+

  • Síneadh íseal-leibhéil, ard-éifeachtach ar Yul.
  • Dearadh é ar dtús do chonradh rolladh dóchasach.
  • Is féidir breathnú ar Yul+ mar thogra uasghrádaithe turgnamhach do Yul, ag cur gnéithe nua leis.

Naisc thábhachtacha

Conradh samplach

Cuireann an sampla simplí seo a leanas feidhm chumhachta i ngníomh. Is féidir é a thiomsú le solc --strict-assembly --bin input.yul. Ba chóir an sampla a stóráil sa chomhad input.yul.

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}
Taispeáin gach rud

Má tá taithí mhaith agat cheana féin ar chonarthaí cliste, is féidir feidhmiú iomlán ERC20 in Yul a fháil anseo (opens in a new tab).

Fe

  • Teanga chlóscríofa go statach do Mheaisín Fíorúil Ethereum (EVM).
  • Spreagtha ag Python agus Rust.
  • Tá sé mar aidhm leis a bheith éasca le foghlaim - fiú d'fhorbróirí nach bhfuil taithí acu ar éiceachóras Ethereum.
  • Tá Fe i dtús forbartha fós, eisíodh alfa don teanga i mí Eanáir 2021.

Naisc thábhachtacha

Conradh samplach

Seo a leanas conradh simplí a cuireadh i bhfeidhm in Fe.

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
16
Taispeáin gach rud

Conas rogha a dhéanamh

Ar nós aon teanga ríomhchlárúcháin eile, baineann sé den chuid is mó leis an uirlis cheart a roghnú don phost ceart chomh maith le roghanna pearsanta.

Seo roinnt rudaí le cur san áireamh mura bhfuil triail bainte agat as aon cheann de na teangacha go fóill:

Cad atá iontach faoi Solidity?

  • Más tosaitheoir thú, tá go leor ranganna teagaisc agus uirlisí foghlama ar fáil. Féach tuilleadh faoi sin sa rannán Foghlaim trí Chódú.
  • Tá uirlisí maithe forbróra ar fáil.
  • Tá pobal mór forbróirí ag Solidity, rud a chiallaíonn go bhfaighidh tú freagraí ar do cheisteanna tapa go leor.

Cad atá iontach faoi Vyper?

  • Bealach iontach le haghaidh forbróirí Python atá ag iarraidh conarthaí cliste a scríobh.
  • Tá líon níos lú gnéithe ag Vyper, rud a fhágann go bhfuil sé iontach chun smaointe a fhréamhshamhlú go tapa.
  • Tá sé mar aidhm ag Vyper a bheith éasca le hiniúchadh agus an-inléite don duine.

Cad atá iontach faoi Yul agus Yul+?

  • Teanga ísealleibhéil atá simplí agus feidhmiúil.
  • Ligeann sé duit dul i bhfad níos gaire do EVM amh, a chuideoidh le húsáid gáis do chonarthaí a bharrfheabhsú.

Comparáidí teanga

Chun comparáid a dhéanamh idir an chomhréir bhunúsach, saolré an chonartha, comhéadain, oibreoirí, struchtúir sonraí, feidhmeanna, sreabhadh rialaithe, agus tuilleadh seiceáil an bileog leideanna Auditless(opens in a new tab)

Tuilleadh léitheoireachta

An raibh an t-alt seo cabhrach?