Declaration and initialisation

State variables are an important tool used in many programming languages, including Solidity.

In programming, they are like labelled boxes which hold different types of information, such as numbers or words. You use them to store data that your application can use and manipulate. When you create a variable, you give it a name and a type, and then you can assign a value to it. Within the application, you can change the value of the variable as and when needed. Variables help make applications more flexible and easier to reuse.

In Solidity, there are three types of variables available:

State variables
Local variables
Special variables

Decorative: Several open cardboard boxes, visually representing variables.

State variables

State variables can be identified by the following characteristics:

they permanently hold values in contract storage.

they can be accessed and modified by any function within a smart contract and their values are retained in storage for as long as the contract is active.

state variables can be of any data type, such as integers, Booleans, and arrays.

they are often used to keep track of the current state of a smart contract, such as the balance of an account or the total supply of a token. This information can be accessed and used by anyone on the Ethereum blockchain.

Example:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.4.0 <0.9.0;
 
contract SimpleStorage {
    uint storedData; // State variable
    // ...
}

Local variables

Local variables allow you to create and manage data that is only needed within a specific function. Below are their key characteristics:

Local variables are variables that are defined within a function and are only accessible within that function.

Local variables are useful for temporary storage of data and for intermediate calculations within a function.

Example:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
contract SomeSmartContract {
   function getResult() public pure returns(uint){
      uint a = 1; // local variable
      uint b = 2; // local variable
      return a + b;
   }
}

Special variables

Special variables are essential for writing smart contracts as they can provide information about the sender of a message, or the amount of cryptocurrency sent. The following are the main characteristics of special variables:

They always exist in the global namespace and are mainly used to provide information about the blockchain.

They are usually for general use.

These are examples of the most common special variables used to write smart contracts:

sender - This variable returns the address of the account that sent the current message (i.e., the address of the account that called the current function).

value - This variable returns the amount of Ether sent with the current message.

now - This variable returns the current block timestamp (in seconds since the Unix epoch).

gas - When a function in a smart contract is called and it involves sending or depositing Ether, a certain amount of gas is needed to execute the function successfully. This gas acts as a payment to incentivise validators to participate in securing the network. The msg.gas variable returns the remaining amount of gas available for the function call.

Naming conventions

Naming conventions are important in all programming languages. They help ensure your code is readable and help you keep track of different elements within your code.

In Solidity, naming conventions follow a few simple guidelines:

use camelCase for variable names, with the first letter of the first word in lowercase and the first letter of subsequent words in uppercase. For example: myVariableName.

avoid using single letter variable names, except for loop indexes.

use more meaningful and descriptive variable names. For example, instead of x, use price or balanceOf.

start variable names with is, has, can, etc. if they are Boolean variables.

Decorative: Reflect banner

Think of a situation where you would use a state variable in a Solidity smart contract. Can you explain why it would be useful in that context?

When you’re ready, select Next to continue.

Solidity basics: variables