Solidity Functions. A Beginner’s Guide

Introduction 

Solidity is a contract-oriented programming language used for creating smart contracts on the Ethereum blockchain. Functions are an essential part of Solidity, allowing developers to execute specific tasks within their contracts. In this article, we will cover everything you need to know about Solidity functions, including how to declare and call them, function modifiers, visibility modifiers, mathematical operations, and more.

How to Declare Solidity Functions?

To declare a function in Solidity, you need to specify the function’s name, visibility, return type (if any), and input parameters (if any). Here is an example of Solidity code syntax declaring a function:

function add(uint x, uint y) public returns (uint) { 

   uint result = x + y; 

   return result;

}

The above code declares a function named “add” that takes two unsigned integer parameters (x and y) and returns their sum as an unsigned integer. The function’s visibility is set to public, which means it can be called by anyone.

In some scenarios, the Solidity compiler may throw a warning when you declare a function. For example, if you declare a function with the same name and input parameters as another function within the same contract, the compiler will throw a warning.

There are other ways to declare a function in Solidity, such as using the “view” or “pure” modifiers. Here are some examples of Solidity code syntax for these types of functions:

function getBalance() public view returns (uint) {

    return balance;

}

function multiply(uint x, uint y) public pure returns (uint) {  

  return x * y;

}

Developers use the “view” modifier for functions that do not modify the contract’s state. On the other hand, the “pure” modifier comes into play for functions that neither read from nor modify the state of the contract.

How to Call a Solidity Function?

To call a function in Solidity, you need to specify the function’s name and input parameters (if any). Here is an example of Solidity code syntax calling a function:

uint result = add(2, 3);

The above code calls the “add” function we declared earlier with the input parameters 2 and 3. The function returns their sum, which is stored in the “result” variable.

What Is a Returns Statement in Solidity Functions?

A returns statement is used to return a value from a Solidity function. Here is an example of Solidity code syntax showing a returns statement:

function divide(uint x, uint y) public pure returns (uint) {

    require(y != 0);   

return x / y;

}

The above code declares a function named “divide” that takes two unsigned integer parameters (x and y) and returns their division as an unsigned integer. We have also added a “require” statement to check if the divisor (y) is not zero.

What are the Function Modifiers in Solidity?

Function modifiers are used to modify the behavior of a function in Solidity. They can be used to add additional functionality, restrict access, or validate input parameters. Here is an example of Solidity code syntax showing function modifiers:

modifier onlyOwner() {

    require(msg.sender == owner);   

_;}

function withdraw(uint amount) public onlyOwner {   

    require(amount <= balance);   

balance -= amount;   

msg.sender.transfer(amount);

}

The above code declares a modifier named “onlyOwner” that restricts access to the “withdraw” function to the contract owner only. The modifier checks if the caller of the function is the owner before executing the function’s code.

What are the Function Visibility Modifiers in Solidity?

Function visibility modifiers are used to control the visibility of a function in Solidity. There are four types of visibility modifiers: public, private, internal, and external.

Public Modifiers

Public functions can be called by anyone and are part of the contract’s interface. Here is an example of Solidity code syntax showing public modifiers:

function deposit() public payable {

    balance += msg.value;

}

The above code declares a function named “deposit” that can be called by anyone and accepts Ether as a payment.

Private Modifiers

Developers create private functions that are not part of the contract’s interface and these functions are callable only from within the contract.
Here is an example of Solidity code syntax showing private modifiers:

function _transfer(address recipient, uint amount) private {

    require(amount <= balance);

    balance -= amount;

    recipient.transfer(amount);

}

The above code declares a private function named “_transfer” that is exclusively callable from within the contract itself.. The function transfers Ether to the specified recipient.

Internal Modifiers

Developers can only invoke internal functions from within the contract and its derived contracts. Here is an example of Solidity code syntax showing internal modifiers:

function _add(uint x, uint y) internal returns (uint) {

    uint result = x + y;

    return result;

}

The code above declares an internal function named “_add” that is callable exclusively from within the contract itself and any derived contracts. The function returns the sum of two input parameters.

External Modifiers

Developers can call the external functions only from outside the contract and these are not part of the contract’s interface. Here is an example of Solidity code syntax showing external modifiers:

function withdraw(uint amount) external onlyOwner {

    require(amount <= balance);

    balance -= amount;

    msg.sender.transfer(amount);

}

The code above declares a function named “withdraw” as external, restricting its accessibility to calls originating from outside the contract. The function transfers Ether to the caller if they are the contract owner.

Order of Function Visibility Modifiers in Solidity

In this order, the modifiers are arranged based on their visibility levels, with “public” being the most visible and “private” being the least visible. Additionally, only the “public” modifier can be part of the contract’s interface, allowing external entities to interact with the function.

What Are the View Functions in Solidity

Developers use view functions to retrieve data from the contract without making any modifications to its state. Here is an example of Solidity code syntax showing view functions:

function getBalance() public view returns (uint) {

    return balance;

}

The above code declares a view function named “getBalance” that returns the current balance of the contract.

What Are the Pure Functions in Solidity

Developers use pure functions to perform calculations without reading from or modifying the state of the contract. Here is an example of Solidity code syntax showing pure functions:

function multiply(uint x, uint y) public pure returns (uint) {

    return x * y;

}

The above code declares a pure function named “multiply” that takes two unsigned integer parameters (x and y) and returns their product as an unsigned integer.

If any of the following statements are present in a function marked as pure, they will attempt to modify the state of the contract, which contradicts the purity of the function, and the Solidity compiler will issue a warning:

1. Modifying state variables: If the function attempts to change the values of state variables within the contract.
2. Emitting events: If the function emits events that notify external entities about specific contract actions or changes.
3. Creating other contracts: If the function tries to create new contracts within its execution.
4. Using self-destruct: If the function utilizes the self-destruct operation to remove the contract from the blockchain.
5. Sending Ether via calls: If the function tries to send cryptocurrency (Ether) to other contracts or addresses using calls or transfers.
6. Calling non-pure or non-view functions: If the function invokes other functions that are not marked as pure or view, indicating they might modify the contract state.
7. Using inline assembly with specific opcodes: If the function incorporates inline assembly code containing certain low-level operations or opcodes that can modify the contract state directly.
8. Using low-level calls: If the function employs low-level calls, such as call, delegatecall, or callcode, which can interact with other contracts and potentially modify the state.

It’s crucial to adhere to the restrictions imposed on pure functions to ensure their purity and prevent unintended modifications to the contract’s state.

What Is a Fallback Function in Solidity?

When a contract receives Ether without any data or function call, it executes a fallback function. Here is an example of Solidity code syntax showing a fallback function:

function() external payable {

    balance += msg.value;

}

The above code declares a fallback function that adds the received Ether to the contract’s balance.

What Is Function Overloading in Solidity?

Function overloading is the ability to declare multiple functions with the same name but different input parameters. Here is an example of Solidity code syntax showing function overloading:

function add(uint x, uint y) public returns (uint) {

    uint result = x + y;

    return result;}

function add(uint x, uint y, uint z) public returns (uint) {

    uint result = x + y + z;

    return result;}

The above code declares two functions named “add” with different input parameters. The first function takes two unsigned integer parameters (x and y), while the second function takes three unsigned integer parameters (x, y, and z).

What are the Mathematical Operations in Solidity

Solidity supports various mathematical operations, including addition, subtraction, multiplication, division, modulus, and exponential. Here are some examples of Solidity code syntax defining these operations:

Addition Operation (x + y) in Solidity Functions

function add(uint x, uint y) public pure returns (uint) {

    uint result = x + y;

    return result;

}

The above code declares a function named “add” that takes two unsigned integer parameters (x and y) and returns their sum as an unsigned integer.

Subtraction Operation (x – y) in Solidity Functions

function subtract(uint x, uint y) public pure returns (uint) {

    uint result = x - y;

    return result;

}

The above code declares a function named “subtract” that takes two unsigned integer parameters (x and y) and returns their difference as an unsigned integer.

Multiplication Operation (x * y) in Solidity Functions

function multiply(uint x, uint y) public pure returns (uint) {

    uint result = x * y;

    return result;

}

The above code declares a function named “multiply” that takes two unsigned integer parameters (x and y) and returns their product as an unsigned integer.

Division Operation (x / y) in Solidity Functions

function divide(uint x, uint y) public pure returns (uint) {

    require(y != 0);

    uint result = x / y;

    return result;

}

The above code declares a function named “divide” that takes two unsigned integer parameters (x and y) and returns their division as an unsigned integer. We have also added a “require” statement to check if the divisor (y) is not zero.

Modulus Operation (x % y) in Solidity Functions

function modulus(uint x, uint y) public pure returns (uint) {

    require(y != 0);

    uint result = x % y;

    return result;

}

The above code declares a function named “modulus” that takes two unsigned integer parameters (x and y) and returns their modulus as an unsigned integer. We have also added a “require” statement to check if the divisor (y) is not zero.

Exponential Operation (x ** y)

function power(uint x, uint y) public pure returns (uint) {

    uint result = x ** y;

    return result;

}

The above code declares a function named “power” that takes two unsigned integer parameters (x and y) and returns their exponential as an unsigned integer.

Conclusion

Solidity functions are an essential part of smart contract development on the Ethereum blockchain. In this article, we have covered everything you need to know about Solidity functions, including how to declare and call them, function modifiers, visibility modifiers, mathematical operations, and more.

To learn more about Solidity and smart contract development, check out the official Solidity documentation and the Ethereum Developer Portal.

Related Tutorials

What Is a Solidity Smart Contract? A Beginner’s Guide

Solidity Tutorial. A Comprehensive Guide

Solidity Data Types. A Beginner’s Guide

Solidity Variables. A Beginner’s Guide

References

Solidity documentation

Solidity tutorial