#100DaysOfSolidity 📚 Solidity Enum: Modeling Choices and State Tracking 🚀 #14

#100DaysOfSolidity Series 014 “Enum”

Solidity, the popular programming language for Ethereum smart contract development, offers a powerful feature called enums. 🌟 Enums allow developers to model choices and track state in a structured and efficient manner.

#100DaysOfSolidity 📚 Solidity Enum: Modeling Choices and State Tracking 🚀 #14

In this article, we will explore the concept of enums in Solidity and demonstrate how they can be used effectively in smart contract development. Let’s dive in! 🏊‍♂️

🎯 Understanding Enums in Solidity

Enums in Solidity are user-defined types that represent a set of named values. They provide a way to define a limited number of options or states that a variable can take. 🌈 Each option is assigned an implicit ordinal value, starting from zero for the first option and incrementing by one for each subsequent option. Enums are useful when you want to represent a finite set of choices or track the state of an object with a limited number of possible values.

📝 Declaring Enums in Solidity

To declare an enum in Solidity, you use the `enum` keyword followed by the name of the enum and a list of its possible values enclosed in curly braces. Let’s take a look at an example: 🖋️

```solidity
enum Status {
Pending,
Shipped,
Accepted,
Rejected,
Canceled
}
```

In this example, we have defined an enum called `Status` with five possible values: `Pending`, `Shipped`, `Accepted`, `Rejected`, and `Canceled`. 📋 By default, the first value listed in the enum definition (`Pending` in this case) is assigned the ordinal value of zero. Subsequent values are assigned ordinal values in increasing order.

🧩 Using Enums in Solidity Contracts

Enums can be used as data types for variables and function parameters in Solidity contracts. Let’s create a contract called `Enum` to demonstrate how enums can be utilized: 🏗️

contract Enum {
 enum Status {
 Pending,
 Shipped,
 Accepted,
 Rejected,
 Canceled
 }
Status public status;
function get() public view returns (Status) {
 return status;
 }
function set(Status _status) public {
 status = _status;
 }
function cancel() public {
 status = Status.Canceled;
 }
function reset() public {
 delete status;
 }
}

🔍 Analyzing the Enum Contract

Now, let’s analyze and discuss the different parts of the `Enum` contract and how enums are utilized:

1️⃣ Enum Declaration:
The `Status` enum represents the shipping status of an item and has five possible values: `Pending`, `Shipped`, `Accepted`, `Rejected`, and `Canceled`. 📦

2️⃣ Status Variable:
The `status` variable of type `Status` is declared as public, allowing external access. This variable holds the current shipping status of an item. 📮

3️⃣ Getter Function (get):
The `get` function is a public view function that returns the current value of the `status` variable. It allows external entities to read the shipping status without modifying it. 🔍

4️⃣ Setter Function (set):
The `set` function is a public function that takes a `Status` parameter `_status` and updates the value of the `status` variable to the provided value. This function allows external entities to update the shipping status. 📝

5️⃣ Cancel Function:
The `cancel` function sets the `status` variable to the `Canceled` value of the `Status` enum. It demonstrates how to assign a specific enum value to a variable. 🚫

6️⃣ Reset Function:
The `reset` function uses the `delete` keyword to reset the `status` variable to its default value, which is the first element (`Pending`) of the `Status` enum. 🔄

🔄 Importing Enums in Solidity Contracts

Enums can also be declared outside of a contract and imported into other contracts for reuse. Let’s explore how this can be done:

In a file named `EnumDeclaration.sol`, we define the `Status` enum: 📁

```solidity
enum Status {
Pending,
Shipped,
Accepted,
Rejected,
Canceled
}
```

In another contract, we can import and utilize the `Status` enum as follows: 🌐

```solidity
import “./EnumDeclaration.sol”;

contract Enum {
Status public status;
}
```

💡 Conclusion

Enums in Solidity provide a structured and efficient way to model choices and track state in smart contracts. By understanding and utilizing enums effectively, developers can write more readable and maintainable code. 🚀

In this article, we covered the basics of enums in Solidity, including declaration, usage in contracts, importing enums from external files, and analyzed a sample contract that demonstrates the practical use of enums. Enums are an essential tool in the Solidity developer’s toolbox, enabling better code organization and state tracking in smart contract development.

🔗 Additional Resources:

• Official Solidity Documentation
• Remix IDE
• The Solidity Blueprint
• 📚👩‍💻 Solidity Learning Resources
• 📜🔐 Solidity’s SubStack
• 💡💼📝 Smart Contracts Made Simple
• 🆓🆓🆓 FREE books that are essential

🔥 Now that you have a good grasp of enums in Solidity, you can leverage this powerful feature to enhance the functionality and structure of your smart contracts. Happy coding! 👩‍💻👨‍💻