Solid function learning

​

   Catalog

function

Return value （ Or return variable ）

Supported return parameters and types

visibility （Visibility）

State variability （mutability）

Transactions and calls

Special functions

Getter function

Receive ether function

Fallback function

Function modifiers

---

Today I'd like to share with you Solidity Learning functions in

function

Solidity The function in is ：

function function_name(<param_type> <param_name>) <visibility> <state mutability> [returns(<return_type>)]{ ... }

They can be written inside the contract , It can also be a free function （ Written outside the contract ）.

Return value （ Or return variable ）

Function can return any number of values as output . There are two ways to return variables from functions ：

1. Use the return variable name ：

function arithmetic(uint _a, uint _b) public pure        returns (uint o_sum, uint o_product)    {        o_sum = _a + _b;        o_product = _a * _b;    }

2. Directly in return Provide the return value in the statement ：

function arithmetic(uint _a, uint _b) public pure        returns (uint o_sum, uint o_product)    {        return (_a + _b, _a * _b);    }

Use the second method , You can omit the name of the return variable , Instead, specify only its type .

Supported return parameters and types

To call the smart contract function , We need to use ABI Specification to specify the function to be called and code the parameters , These parameters will be included in the data field of the transaction and sent to the Ethereum network for execution .

ABI Encoding is also used for events and return types , More details can be found in .

Be careful ： ( If you're using Solidity edition ：0.7.5 Can be used v2 edition . For lower than 0.7.5 Version of , We need to use the experimental version ：pragma experimental ABIEncoderV2;).

Use Solidity 0.7.5 An example of this version .

// SPDX-License-Identifier: GPL-3.0pragma solidity >0.7.4;pragma abicoder v2;contract Test {    struct S { uint a; uint[] b; T[] c; }    struct T { uint x; uint y; }    function f(S memory, T memory, uint) public pure {}    function g() public pure returns (S memory, T memory, uint) {}}

visibility （Visibility）

There are four kinds of visibility of functions ：

• Private（ private ）： The most restrictive , Function can only be called inside the defined smart contract .
• Internal（ Inside ）： This function can be called inside the defined smart contract , You can also call this function from the inheritance contract. .
• External（ external ）： Can only be called from outside the smart contract . ( If you want to call it from an intelligent contract. , Must be used  this.)
• Public（ Open ）： It can be called from anywhere . ( Most relaxed )

State variability （mutability）

• view： use view The declared function can only read the State , You can't change the status .
• pure： use pure The declared function can neither read nor modify the state .
• payable： use payable The declared function can accept the Ethernet currency sent to the contract , If not specified , This function will automatically reject all ethers sent to it .

contract SimpleStorage {     uint256 private data;          function getData() external view returns(uint256) {         return data;     }     function setData(uint256 _data) external {        data = _data;    }}

Transactions and calls

use view and pure The function defined by the keyword will not change the state of Ethereum blockchain , This means that when you call these functions , You will not send any transactions to the blockchain , Because transactions are defined as status bar transitions from one state to another . It's just , The node you connect executes the function code locally by checking its own blockchain version , And return the result , There is no need to broadcast any transactions to the Ethereum network .

Special functions

In this section , We will see some special functions that can be used .

Getter function

Defined as public The state variable of has getter function , This function is automatically created by the compiler . This function has the same name as the variable , And it has external visibility .

contract C {    uint public data;    function x() public returns (uint) {        data = 3; //   Internal visits         return this.data(); //  External access     }}

Receive ether function

A contract can have at most one receive function . This function cannot have arguments , Cannot return any parameters , And it has to have receive Visibility and payable State variability .

When sent to contract Ether And no function is specified to call (calldata It's empty ) When the . This is a function executed on an ordinary Ethereum transfer ( for example , adopt .send() or .transfer() Transfer accounts ).

The function is declared as follows ：

receive() external payable {   ...}

Fallback function

A contract can have at most one fallback function （ Fallback function ）. This function cannot have arguments , Cannot return any parameters , And it has to have external visibility . If None of the other functions match the given function signature , perhaps No data was provided at all and no receive function , Execute this function when calling the contract .

You can declare a function like this ：

fallback() external [payable]{     ...}

If one is not implemented receive Function or payable Contract transfer of fallback function , The contract will throw an exception , Ethereum will be refunded .

Can be in Remix Try it by yourself , Create one without receive or payable fallback The contract of , And send some ether coins to them . Click on **Transact（ transaction ）** after , You should see a message similar to the following .

​

edit

Function modifiers

When you want to check some conditions before executing a function , You can use decorators . for example , If you want to check whether the sender is the owner of the contract , You can write the following ：

function selectWinner() external {    require(msg.sender == owner, "this function is restricted to the owner);    ...}

Use decorators , We can separate the code , So that we can reuse it with other functions , We just need to declare modifiers , As shown below ：

modifier onlyOwner(){   require(msg.sender == owner, "this function is restricted to the owner);  _; // will be replaced by the code of the function}

Then add the modifier name to the function ：

function selectWinner() external onlyOwner {       ...}

By specifying multiple modifiers in a space separated list , You can apply them to a function , And apply it in the order given .

​