Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/shaikahmadnawaz/solidity

A Beginner's Guide to Solidity
https://github.com/shaikahmadnawaz/solidity

arrays enums ethereum functions mappings remix-ide smart-contracts solidity structs web3

Last synced: 15 days ago
JSON representation

A Beginner's Guide to Solidity

Awesome Lists containing this project

README 

        
# Solidifying Your Understanding: A Beginner's Guide to Solidity



## Introduction



Welcome to the world of Solidity and smart contract development on the Ethereum blockchain! Whether you're new to programming or have prior experience, this guide will serve as your comprehensive introduction to the basics of Solidity and how to create smart contracts. We will start with the fundamental concepts and build upon them to give you a solid understanding of the language.



## What is Solidity and Why Use it?



Solidity is a contract-oriented, high-level programming language used for writing smart contracts on the Ethereum blockchain. It was developed to enable developers to create decentralized applications (dApps) and automate processes on the Ethereum network.



Smart contracts are self-executing agreements with the terms of the agreement between buyer and seller being directly written into lines of code. They provide a secure, transparent, and tamper-proof way of executing transactions on the blockchain.



## Remix IDE



Remix is a web-based Integrated Development Environment (IDE) for Solidity that allows you to write, test, and deploy smart contracts. It is easy to use and provides a simple interface for writing and testing Solidity code.



Here's a brief overview of how to use Remix:



1. Open your web browser and go to [**https://remix.ethereum.org/**](https://remix.ethereum.org/)

2. In the left-side panel, select the Solidity compiler version you want to use.

3. Write or paste your Solidity code in the center panel.

4. On the right-side panel, you can select the environment (JavaScript VM or web3 provider) in which you want to deploy and test your contract.

5. Click the "Create" button to deploy the contract to the selected environment.

6. You can interact with your deployed contract by calling its functions and viewing its data in the right-side panel.

7. You can also run tests on your contract by writing test cases in the Solidity file and clicking the "Run" button.



That's it! You can now start writing and testing your Solidity code using Remix.



## Data Types in Solidity



Solidity supports several data types that can be used to store and manipulate values in smart contracts.



Here are some of the most commonly used data types in Solidity with examples:



1. `bool`: Represents a boolean value, either `true` or `false`.



   Example: `bool isTrue = true;`



2. `int`: Represents a signed integer value.



   Example: `int age = 25;`



3. `uint`: Represents an unsigned integer value.



   Example: `uint balance = 100;`



4. `address`: Represents an Ethereum address.



   Example: `address owner = 0x123456789abcdef0123456789abcdef0123456789;`



5. `string`: Represents a string of Unicode characters.



   Example: `string name = "Nawaz";`



6. `bytes`: Represents a dynamic-length byte array.



   Example: `bytes32 hash = 0x123456789abcdef0123456789abcdef0123456789;`



7. `enum`: Represents a named set of values.



   Example:



   ```solidity

   enum Color {Red, Green, Blue}

   Color myColor = Color.Red;

   ```



8. `mapping`: Represents an unordered collection of key-value pairs.



   Example:



   ```solidity

   mapping(address => uint) balances;

   balances[owner] = 100;

   ```



9. `array`: Represents an ordered collection of values of a specified type.



   Example:



   ```solidity

   uint[] numbers;

   numbers.push(1);

   numbers.push(2);

   ```



These are the most commonly used data types in Solidity, but there are many more types and features available for you to use. It's important to choose the right data type for your use case to ensure the efficiency and security of your smart contract.



## Variables in Solidity



Variables in Solidity are used to store values in your smart contract.



In Solidity, there are 3 types of variables: state, local, and global variables.



1. **State Variables:** State variables are declared at the contract level and are stored on the blockchain, making them available to all functions in the contract.



   ```solidity

   // SPDX-License-Identifier: GPL-3.0

   pragma solidity >=0.4.16 <0.9.0;



   contract HelloWorld {

     uint public balance;



     function setBalance(uint newBalance) public {

       balance = newBalance;

     }

   }

   ```



   In this example, `balance` is a state variable declared as `public`, meaning it can be accessed from outside the contract. The `setBalance` function allows a caller to set the value of `balance`. Since `balance` is a state variable and is available to all functions in the contract.



2. **Local Variables:** Local variables are declared within a function and are stored in memory. They are automatically cleared when the function returns and are only accessible within the function. Local variables are also referred to as "temporary" or "stack" variables.



   ```solidity

   // SPDX-License-Identifier: GPL-3.0

   pragma solidity >=0.4.16 <0.9.0;



   contract HelloWorld {

     function calculateSum(uint a, uint b) public returns (uint) {

       uint sum;

       sum = a + b;

       return sum;

     }

   }

   ```



   In this example, `sum` is a local variable declared within the `calculateSum` function. It is used to store the result of adding `a` and `b` and is returned as the function's output. Since `sum` is a local variable, it is stored in memory and will be cleared when the function returns.



3. **Global Variables:** Global variables are variables declared in a global context, outside of any contract or function. These variables are shared by all contracts in the same source code file and are accessible from anywhere in the code. Global variables are rare in Solidity and are generally not recommended for use in smart contracts.



   ```solidity

   // SPDX-License-Identifier: GPL-3.0

   pragma solidity >=0.4.16 <0.9.0;



   uint globalCount;



   contract HelloWorld {

     function incrementGlobalCount() public {

       globalCount++;

     }

   }

   ```



   In this example, `globalCount` is a global variable declared outside of any contract or function. This variable is accessible from anywhere in the code and can be shared by multiple contracts in the same source code file. The `incrementGlobalCount` function in the `HelloWorld` contract increments the value of `globalCount` by one.



In general, it is recommended to use state or local variables instead of global variables, unless there is a specific requirement that can only be met by using a global variable.



## Operators and Expressions



**Operators:** Operators are symbols that perform specific operations on variables and values. There are various types of operators in Solidity, including:



- Arithmetic operators: +, -, \*, /, %

- Comparison operators: ==, !=, >, >=, <, <=

- Logical operators: &&, ||, !

- Bitwise operators: &, |, ^, ~, <<, >>​

- Assignment operator: =



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a = 2;

  uint b = 3;

  uint c;



  function performOperations() public returns (uint) {

    c = a + b;

    c = c * 2;

    return c;

  }

}

```



In this example, the `performOperations` function uses arithmetic and assignment operators to perform operations on variables `a`, `b`, and `c`. The function returns the value of `c` after performing the operations, which is equal to `(a + b) * 2 = (2 + 3) * 2 = 10`.



**Expressions:** Expressions are combinations of variables, values, and operators that evaluate to a single value. Expressions are used in various parts of Solidity code, including conditional statements, loops, and function return values.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a = 2;

  uint b = 3;



  function checkGreater() public returns (bool) {

    return a > b;

  }

}

```



In this example, the `checkGreater` function returns a Boolean value that is the result of a comparison expression `a > b`. The expression evaluates to `false` since `a` (2) is not greater than `b` (3).



## Conditional Statements



Conditional statements are used to execute a block of code only if a specified condition is true. The two main types of conditional statements in Solidity are `if` statements and `switch` statements.



Here's an example of an `if` statement in Solidity:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint value;



  function setValue(uint _value) public {

    value = _value;

    if (value > 100) {

      // code to execute if value is greater than 100

    }

  }

}

```



In this example, the `if` statement checks if the `value` is greater than 100. If the condition is true, the code inside the `if` statement will be executed.



Here's an example of a `switch` statement in Solidity:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint value;



  function setValue(uint _value) public {

    value = _value;

    switch (value) {

      case 10:

        // code to execute if value is equal to 10

        break;

      case 20:

        // code to execute if value is equal to 20

        break;

      default:

        // code to execute if value does not match any case

    }

  }

}

```



In this example, the `switch` statement checks the value of `value` and executes the code inside the matching case. If no case matches, the code inside the `default` case will be executed.



## Loops



Loops are used to repeat a block of code a specified number of times. The two main types of loops in Solidity are `for` loops and `while` loops.



Here's an example of a `for` loop in Solidity:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint value;



  function setValue(uint _value) public {

    for (uint i = 0; i < _value; i++) {

      value++;

    }

  }

}

```



In this example, the `for` loop repeats the code inside the loop `_value` times. The loop starts with `i = 0`, continues as long as `i < _value`, and increments `i` by 1 each time.



Here's an example of a `while` loop in Solidity:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint value;



  function setValue(uint _value) public {

    while (value < _value) {

      value++;

    }

  }

}

```



In this example, the `while` loop repeats the code inside the loop as long as `value < _value`. The loop will continue to execute until `value` is equal to or greater than `_value`.



## Functions



Functions are blocks of code that perform a specific task. Functions in Solidity can take input parameters, perform operations, and return output values. Functions can be called from within the same contract or from other contracts.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a = 2;

  uint b = 3;



  function addNumbers(uint c, uint d) public returns (uint) {

    return c + d;

  }

}

```



In this example, the `addNumbers` function takes two input parameters `c` and `d` and returns their sum. The function can be called from within the contract or from other contracts to perform the addition operation.



## View and Pure



In Solidity, `view` and `pure` are two keywords used to define the state-read and state-write access of functions.



**view:** Functions marked as `view` can only read the state, but cannot modify it. They do not modify the state, and therefore do not require any gas to be executed.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a = 2;

  uint b = 3;



  function getSum() view public returns (uint) {

    return a + b;

  }

}

```



In this example, the `getSum` function is marked as a `view` function. It only reads the values of `a` and `b` and returns their sum. Since it does not modify the state, it can be safely executed without consuming any gas.



**pure:** Functions marked as `pure` can only read the state and input parameters, but cannot modify the state or access contract storage. They do not modify the state and do not interact with contract storage, and therefore do not require any gas to be executed.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a = 2;

  uint b = 3;



  function getProduct(uint c) pure public returns (uint) {

    return c * (a + b);

  }

}

```



In this example, the `getProduct` function is marked as a `pure` function. It only reads the input parameter `c` and the values of `a` and `b`. It returns the product of `c` and the sum of `a` and `b`. Since it does not modify the state or access contract storage, it can be safely executed without consuming any gas.



Using `view` and `pure` functions can help optimize the gas consumption and performance of your contract, and can also increase the transparency and trust of your code by allowing users to verify its behavior without affecting the state.



## Access Modifiers



In Solidity, access modifiers are used to control the visibility and accessibility of functions and state variables. Solidity supports 4 access modifiers: `public`, `private`, `internal`, and `external`.



- `public`: A `public` function or state variable is visible and accessible from outside the contract and can be called or read by anyone.

- `private`: A `private` function or state variable is only visible and accessible within the contract and cannot be called or read from outside the contract.

- `internal`: An `internal` function or state variable is visible and accessible within the contract and its derived contracts but not from outside the contract.

- `external`: An `external` function is a function that can be called from outside the contract but cannot be called from within the contract.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint public counter = 0;

  uint private secretCounter = 0;



  function incrementCounter() public {

    counter++;

    secretCounter++;

  }



  function getCounter() public view returns (uint) {

    return counter;

  }



  function incrementSecretCounter() private {

    secretCounter++;

  }

}

```



In this example, a state variable `counter` is declared as `public` and another state variable `secretCounter` is declared as `private`. The `incrementCounter` function increments both the `counter` and `secretCounter`. The `getCounter` function returns the value of `counter` and is declared as `public` so it can be called from outside the contract. The `incrementSecretCounter` function increments the `secretCounter` and is declared as `private` so it can only be called from within the contract.



## Constructor



A constructor in Solidity is a special type of function that is automatically executed when a smart contract is deployed to the blockchain. It is used to initialize the state of a contract, set default values for variables, and perform any other setup tasks that are required before the contract can be used.



A constructor is defined using the `constructor` keyword, and is called only once when the contract is deployed.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a;



  constructor(uint _a) public {

    a = _a;

  }



  function getA() public view returns (uint) {

    return a;

  }

}

```



In this example, the `constructor` function takes an input parameter `_a` and sets the value of the `a` state variable to this value. The constructor is called only once when the contract is deployed, and the value of `a` is set at this time. The `getA` function is used to retrieve the value of `a` and return it to the caller.



## Storage and Memory



In Solidity, `storage` and `memory` are two locations used to store data in a smart contract. They are used to keep track of the state of the contract and to pass data between functions.



**storage:** The `storage` location is a persistent data storage that is part of the contract's state. Values stored in `storage` persist between function calls and are stored on the blockchain, making them available to all users of the contract.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a;



  function setA(uint _a) public {

    a = _a;

  }



  function getA() public view returns (uint) {

    return a;

  }

}

```



In this example, the `a` variable is stored in `storage`. The `setA` function takes an input parameter `_a` and sets the value of `a` to this value. The value of `a` is stored in `storage` and persists between function calls, allowing it to be retrieved later using the `getA` function.



**memory:** The `memory` location is a temporary data storage that is used to store data that is only needed within the scope of a single function. Values stored in `memory` are lost when the function returns and are not stored on the blockchain.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  uint a;



  function setA(uint _a) public {

    uint b = _a * 2;

    a = b;

  }



  function getA() public view returns (uint) {

    return a;

  }

}

```



In this example, the `b` variable is stored in `memory`. The `setA` function takes an input parameter `_a` and calculates a new value `b` as the double of `_a`. The value of `b` is stored in `memory` and used to set the value of `a`. The value of `b` is not stored on the blockchain and is lost when the function returns.



## Arrays



In Solidity, arrays are used to store multiple values of a specified data type. There are two types of arrays: `static arrays` and `dynamic arrays`.



1. **Static Arrays:** Static arrays have a fixed size, meaning the number of elements in the array is set when the array is declared and cannot be changed during the life of the contract.



   Example:



   ```solidity

   // SPDX-License-Identifier: GPL-3.0

   pragma solidity >=0.4.16 <0.9.0;



   contract HelloWorld {

     uint[3] array;



     function setArray(uint _a, uint _b, uint _c) public {

       array[0] = _a;

       array[1] = _b;

       array[2] = _c;

     }



     function getArray(uint index) public view returns (uint) {

       return array[index];

     }

   }

   ```



   In this example, a static array `array` with 3 elements is declared. The `setArray` function takes 3 input parameters `_a`, `_b`, and `_c` and sets the values of `array[0]`, `array[1]`, and `array[2]` to these values, respectively. The `getArray` function takes an input parameter `index` and returns the value of `array[index]`.



2. **Dynamic arrays:** Dynamic arrays have a variable size, meaning the number of elements in the array can be changed during the life of the contract. Dynamic arrays are declared using the `[]` operator.



   Example:



   ```solidity

   // SPDX-License-Identifier: GPL-3.0

   pragma solidity >=0.4.16 <0.9.0;



   contract HelloWorld {

     uint[] array;



     function addElement(uint element) public {

       array.push(element);

     }



     function getArrayLength() public view returns (uint) {

       return array.length;

     }



     function getArrayElement(uint index) public view returns (uint) {

       return array[index];

     }

   }

   ```



   In this example, a dynamic array `array` is declared. The `addElement` function takes an input parameter `element` and adds this value to the end of the array using the `push` method. The `getArrayLength` function returns the length of the array using the `length` property. The `getArrayElement` function takes an input parameter `index` and returns the value of `array[index]`.



## Mappings



In Solidity, mappings are used to store key-value pairs. The keys and values can be of any data type. Mappings are declared using the `mapping` keyword.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  mapping(address => uint) balances;



  function addBalance(address _address, uint _balance) public {

    balances[_address] = _balance;

  }



  function getBalance(address _address) public view returns (uint) {

    return balances[_address];

  }

}

```



In this example, a mapping `balances` is declared with `address` as the key and `uint` as the value. The `addBalance` function takes two input parameters `_address` and `_balance` and sets the value of `balances[_address]` to `_balance`. The `getBalance` function takes an input parameter `_address` and returns the value of `balances[_address]`.



## Structs



In Solidity, structs are used to define custom data types. Structs can contain multiple data types, including other structs. Structs are declared using the `struct` keyword.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  struct Person {

    string name;

    uint age;

    address address;

  }



  mapping(address => Person) people;



  function addPerson(address _address, string memory _name, uint _age) public {

    people[_address].name = _name;

    people[_address].age = _age;

  }



  function getPerson(address _address) public view returns (string memory, uint) {

    return (people[_address].name, people[_address].age);

  }

}

```



In this example, a struct `Person` is declared with 3 data types: `string`, `uint`, and `address`. A mapping `people` is declared with `address` as the key and `Person` as the value. The `addPerson` function takes 3 input parameters `_address`, `_name`, and `_age` and sets the values of `people[_address].name` to `_name` and `people[_address].age` to `_age`. The `getPerson` function takes an input parameter `_address` and returns the values of `people[_address].name` and `people[_address].age`.



## Enums



In Solidity, enums are used to define a set of named constants. Enums can be used to model a set of possible states or values for a particular field in a contract. Enums are declared using the `enum` keyword.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  enum ActionType { BUY, SELL, HOLD }



  ActionType public currentAction;



  function setAction(ActionType _action) public {

    currentAction = _action;

  }



  function getAction() public view returns (ActionType) {

    return currentAction;

  }

}

```



In this example, an enum `ActionType` is declared with 3 constants: `BUY`, `SELL`, and `HOLD`. A state variable `currentAction` of type `ActionType` is declared and public. The `setAction` function takes an input parameter `_action` of type `ActionType` and sets the value of `currentAction` to `_action`. The `getAction` function returns the value of `currentAction`.



## Events



In Solidity, events are used to emit logs that can be read from outside the contract. Events are declared using the `event` keyword.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  event NewPerson(string name, uint age);



  function addPerson(string memory _name, uint _age) public {

    emit NewPerson(_name, _age);

  }

}

```



In this example, an event `NewPerson` is declared with 2 parameters: `name` and `age`. The `addPerson` function takes 2 input parameters `_name` and `_age` and emits the event `NewPerson` with these parameters. The event can be read from outside the contract using an Ethereum client like Remix, Geth, or Parity.



## Payable



In Solidity, the `payable` keyword is used to indicate that a function can receive Ether (the cryptocurrency of the Ethereum network). To make a function `payable`, simply add the `payable` keyword before the function definition.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract HelloWorld {

  function deposit() payable public {

    // code to handle deposit

  }

}

```



In this example, the `deposit` function is declared as `payable` which means it can receive Ether. When this function is called, the caller can send Ether along with the function call, and the contract will receive the Ether. It's important to note that not all functions in a contract need to be `payable`. Functions that do not need to receive Ether do not need the `payable` keyword.



## Object-oriented programming (OOP)



Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code that operates on the data. Solidity is a contract-oriented language and does not have full OOP support. However, Solidity does support some OOP concepts such as inheritance, encapsulation, and polymorphism.



- Inheritance: Solidity supports single inheritance, meaning a contract can inherit from a single base contract. The derived contract inherits the functions, state variables, and events of the base contract.



Example:



```solidity

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.4.16 <0.9.0;



contract Base {

  uint public counter = 0;



  function incrementCounter() public {

    counter++;

  }

}



contract Derived is Base {

  function incrementCounterTwice() public {

    incrementCounter();

    incrementCounter();

  }

}

```



In this example, the `Derived` contract inherits from the `Base` contract. The `Derived` contract has access to the `counter` state variable and the `incrementCounter` function defined in the `Base` contract. The `Derived` contract also defines its own `incrementCounterTwice` function.



- Encapsulation: Solidity supports encapsulation through the use of access modifiers. Access modifiers control the visibility and accessibility of state variables and functions. This allows you to hide internal implementation details and restrict access to certain functions and state variables.

- Polymorphism: Polymorphism is not explicitly supported in Solidity, but similar functionality can be achieved through function overloading and function overriding. Function overloading is not supported in Solidity, but function overriding is supported through inheritance. In inheritance, a derived contract can override a function defined in the base contract to provide a different implementation.



Overall, while Solidity is not a fully object-oriented language, it does support some OOP concepts that can be used to write more organized and maintainable code.



## Conclusion



In conclusion, we have covered the basics of Solidity, a contract-oriented programming language used to write decentralized applications on the Ethereum platform. We discussed setting up your development environment, creating a "Hello World" program, data types and variables, operators and expressions, functions and modifiers, events, and more. By learning Solidity, you are taking the first step towards creating your own decentralized applications and contributing to the growth of the Ethereum ecosystem.



To continue your journey with Solidity, I recommend exploring advanced topics such as smart contract testing, security, and optimization. There are many resources available online, including the Solidity documentation, forums, and online courses, to help you deepen your knowledge and skills in this exciting field.



Stay updated on the latest developments in the world of Solidity and Ethereum. Follow me on [LinkedIn](https://www.linkedin.com/in/shaik-ahmad-nawaz-894425239/), and [Twitter](https://twitter.com/shaikahmadnawaz) for the latest tips, resources, and exciting projects in the decentralized space!