๐““๐“ป-๐“›๐“ฒ๐“ท๐“พ๐”๐“ฎ๐“ป ๐“‘๐“ต๐“ธ๐“ฐ

Exploring Enums in Solidity: Simplifying Code with Predefined Values

Aung Aung Myo Myint's photo
Aung Aung Myo Myint
ยท

4 min read

Table of contents

Enums (short for "Enumerations") in Solidity are a powerful feature that improves code readability and ensures a variable has a limited set of predefined options.

This blog will explain what enums are, how to define them, and how to use them in real situations, all while using Solidity to create smarter and easier-to-maintain contracts.

What are Enums?

Enums are user-defined data types in Solidity that let a variable hold only one value from a set of predefined options. Instead of using numbers or strings to show states or choices, enums offer a cleaner, easier-to-read, and easier-to-manage way.

Key Features:

  1. Predefined Values: Enums limit variables to specific values set when they are declared.

  2. Integer Representation: Enum values are stored as integers starting from 0.

  3. Readability: Enums improve code clarity by using meaningful names instead of random integers.

Defining Enums in Solidity

To declare an enum, use the enum keyword followed by the enum name and its values enclosed in curly braces:

enum Button { On, Off }

Here, Button can hold only two values: On (represented as 0) and Off (represented as 1).

Declaring Variables of Enum Type

You can declare a variable of the Button type like this:

Button public status;

By default, status will be set to the first value in the enum (On in this case).

Example: Using Enums in Solidity

Here's a full Solidity example showing how to use enums effectively:

Solidity Code Example

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;

contract EnumExample {
    // Defining the enum
    enum Button { On, Off }

    // Declaring a public variable of the enum type
    Button public status;

    // Function to check the raw status (enum value)
    function checkStatus() public view returns (Button) {
        return status;
    }

    // Function to update the status
    function setStatus(Button _status) public {
        status = _status;
    }

    // Function to get a descriptive status
    function getStatus() public view returns (string memory) {
        if (status == Button.On) {
            return "Button is On";
        } else {
            return "Button is Off";
        }
    }    
}

How It Works:

  1. Defining the Enum:
    The Button enum is defined with two possible states: On and Off. These values are stored as integers internally (On = 0, Off = 1).

  2. Declaring a Variable:
    The status variable is declared as a public variable of type Button. By default, it is set to the first value in the enum, which is On.

  3. Retrieving the Raw Status:
    The checkStatus function returns the raw enum value (0 or 1), which corresponds to the enum's internal representation.

  4. Changing the Status:
    The setStatus function allows users to update the status variable to either On or Off by passing the appropriate enum value.

  5. Getting a Descriptive Status:
    The getStatus function checks the current status and returns a descriptive string ("Button is On" or "Button is Off") based on the enum value.

Why Use Enums?

1. Better Readability:

Enums use clear names like On and Off instead of random numbers like 0 and 1, making the code easier to read.

2. Fewer Mistakes:

Enums limit the values a variable can have, which helps prevent errors from invalid states.

3. Efficient Storage:

Enums use meaningful names but are stored as numbers internally, which keeps storage efficient.

Advanced Usage: Comparing and Returning Enums

Enums can be compared and returned like any other variable type. Here's an enhanced example:

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;

contract AdvancedEnumExample {
    enum Button { On, Off, Open }
    Button public status;

    // Check if the button is On
    function isButtonOn() public view returns (bool) {
        return status == Button.On;
    }

    // Set the button to a specific state
    function toggleButton(Button _status) public {
        status = _status;
    }

    // Return a descriptive status
    function getButtonStatus() public view returns (string memory) {
        if (status == Button.On) {
            return "The button is On";
        } else if (status == Button.Off) {
            return "The button is Off";
        } else {
            return "The button is Open";
        }
    }
}

Best Practices

  1. Use for Finite States:
    Enums are ideal for representing a small set of options, like On/Off, Open/Closed, or similar scenarios.

  2. Avoid Overuse:
    If the set of values becomes too large, enums may lose their simplicity. For larger datasets, consider alternative data structures.

  3. Readable Names:
    Use meaningful names for enum values to ensure clarity and ease of understanding.

Conclusion

Enums in Solidity provide an easy way to handle limited states in your smart contracts. By using readable and limited values instead of integers or strings, enums make your code clearer and reduce mistakes. Whether you're managing a device's state or setting user roles, enums are a useful tool in your Solidity programming toolkit.

Ethereum
ย