Enums

In Solidity, enums (short for enumerations) are used to create custom data types with a fixed set of values. Enums are a key concept in programming that allow you to create custom data types with a limited set of options, making it easier to manage and organize data in your contracts and decentralized applications. In this article, we’ll take a closer look at enums in Solidity, including how to define and use them, and how to access and modify their values.

Defining Enums

In Solidity, enums are defined using the “enum” keyword followed by the enum name and a set of curly braces containing the values that the enum will contain. The values in an enum can be of any data type, and multiple enums can be defined in a single contract.

For example, the following code defines an enum called “Colors” that contains four values: “Red”, “Green”, “Blue”, and “Yellow”:

enum Colors { Red, Green, Blue, Yellow }

This enum can be used to store one of four possible color values.

Creating Enum Instances

To create an instance of an enum in Solidity, use the enum name followed by a period and one of the values in the enum. For example:

Colors c = Colors.Red;

This code creates a new instance of the “Colors” enum called “c” and sets its value to “Red”.

Accessing and Modifying Enum Values

To access the value of an enum instance, use the instance name. For example:

string color = c;

This code retrieves the value of the “c” enum instance and stores it in the “color” variable.

To modify the value of an enum instance, use the instance name followed by an assignment operator and one of the values in the enum. For example:

c = Colors.Green;

This code sets the value of the “c” enum instance to “Green”.

Comparing Enum Values

In Solidity, it is possible to compare the values of enum instances using comparison operators such as “==” (equal to) and “!=” (not equal to). For example:

if (c == Colors.Red) {
  console.log("The color is red.");
}

This code checks if the value of the “c” enum instance is equal to “Red” and, if so, prints a message to the console.

Using Enums as Function Parameters

In Solidity, enums can be passed as function parameters in the same way as other data types. For example:

function setColor(Colors color) public {
  c = color;
}

This function takes an enum instance of the “Colors” type as a parameter and sets it as the value of the “c” enum instance.

Using Enums as Mapping Keys

In Solidity, it is also possible to use enums as keys in mappings. Mappings are data structures that store key-value pairs, and they are useful for storing and accessing data efficiently.

For example, the following code defines a mapping that uses the “Colors” enum as the key and the “string” data type as the value:

mapping (Colors => string) colorNames;

This mapping can be used to store the names of colors as strings, using the values in the “Colors” enum as the keys.

To access or modify a value in a mapping, use the mapping name followed by the key in square brackets. For example:

colorNames[Colors.Red] = "Red";

This code sets the value of the “Red” key in the “colorNames” mapping to “Red”.

Conclusion

In conclusion, enums in Solidity are a useful tool for creating custom data types with fixed values. Enums can be used to store and manipulate data with a limited set of options, and they can be passed as function parameters and used as mapping keys. Enums are a key concept in programming and are a useful way to manage and organize data in Solidity contracts and decentralized applications.

Exercises

To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.