Flutterexperts

Dart’s enums are more than just a collection of constants. If you want your code to look neat, secure, and expressive, Dart Enum can help. Dart provides additional capabilities that can take enums even further, even though the basics of Dart Enum are fairly well-known throughout its development.

In this article, we’ll Explore Advanced Dart Enum. We see how to execute a demo program, like adding properties, methods, and using switch expressions effectively in a project.

If you’re looking for the best Flutter app development company for your mobile application then feel free to contact us at — support@flutterdevs.com.

---

Table Of Contents::

What is Dart Enum?

Adding Dart Enum properties

Methods added to enums

Using enums with switch expressions

Extending enums with mixins

Using enums in data structures

Enum-driven state management

Conclusion

---

---

What is Dart Enum?

A method for defining a limited collection of constants is provided by Dart Enum. They are ideal for situations when you need to represent a set of related choices that are closed.

An easy illustration:

enum UserRole {  
  admin,  
  editor,  
  viewer,  
}  

void main() {  
  UserRole role = UserRole.admin;  

  print(role); 
}

When we run the application, we ought to get the screen’s output like the underneath console output.

UserRole.admin 

Process finished with exit code 0

Adding properties to Dart Enum:

Dart enum is more than just a list of values. You can also bind properties to it.

Adding descriptions:-

Assume that each of the following roles requires you to submit an annotation.

A description is included in the instantiation of every admin, editor, and viewer enum value. Since the description property is fixed, it cannot be changed. The enum’s const constructor ensures that it is a compile-time constant.

enum UserRole {
admin('Administrator with full access'),
editor('Editor with content management access'),
viewer('Viewer with read-only access');
final String description;
const UserRole(this.description);
}
void main() {
print(UserRole.admin.description);
}

When we run the application, we ought to get the screen’s output like the underneath console output.

Administrator with full access

Process finished with exit code 0

Methods added to enums:

Methods can also be included in Dart Enum. It is also useful, for instance, when the enum’s behavior needs to be contained within a box. The canEdit method determines whether a role has edit permission. The current enum value is referred to by this keyword.

enum UserRole {  
  admin,  
  editor,  
  viewer;  

  bool canEdit() => this == UserRole.admin || this == UserRole.editor;  
}  

void main() {  
  print(UserRole.admin.canEdit()); 
  print(UserRole.viewer.canEdit());  
}

When we run the application, we ought to get the screen’s output like the underneath console output.

true
false  

Process finished with exit code 0

Using enums with switch expressions:

As a result, the Dart switch expression cases directly interface with enums and can be implemented in a minimal and type-safe manner. The switch expression guarantees that every enum case is addressed. Dart will generate a compile-time error and your program will be safe if you neglect to handle a case.

enum UserRole {  
  admin,  
  editor,  
  viewer;  

  bool canEdit() => this == UserRole.admin || this == UserRole.editor;  
}  

void main() {  
  UserRole role = UserRole.editor;  

  String message = switch (role) {  
    UserRole.admin => 'Welcome, Admin!',  
    UserRole.editor => 'Hello, Editor!',  
    UserRole.viewer => 'Greetings, Viewer!'  
  };  

  print(message); 
}

When we run the application, we ought to get the screen’s output like the underneath console output.

Hello, Editor!   

Process finished with exit code 0

Extending enums with mixins:

You can add reusable behaviour to enums by extending them with mixins for more complex use cases.Every enum value has access to a logging action thanks to the Loggable mixin. This method maintains the modularity and  keeps your code DRY.

mixin Loggable {  
  void log(String message) {  
    print('LOG: $message');  
  }  
}  

enum UserRole with Loggable {  
  admin,  
  editor,  
  viewer;  
}  

void main() {  
  UserRole.admin.log('Admin has logged in.');  
}

When we run the application, we ought to get the screen’s output like the underneath console output.

LOG: Admin has logged in.

Process finished with exit code 0

Using enums in data structures:

Additionally, enums can serve as keys for more intricate data structures like maps. Each role is mapped to a set of authorisation actions that it is capable of performing. Managing permissions is simple and type-safe with this method.

enum UserRole {  
  admin,  
  editor,  
  viewer;  
}  
void main() {  
  Map<UserRole, List<String>> permissions = {  
    UserRole.admin: ['read', 'write', 'delete'],  
    UserRole.editor: ['read', 'write'],  
    UserRole.viewer: ['read'],  
  };  

  print(permissions[UserRole.editor]); 
} 

When we run the application, we ought to get the screen’s output like the underneath console output.

[read, write] 

Process finished with exit code 0

Enum-driven state management:

Consider creating a shopping application that shows the order status. Using an enum to control the state and its state transitions is also possible. The logic for transitioning between states is defined in the following procedure. There is a descriptive message for each state. The lifecycle of an order is simulated by the while loop.

enum OrderStatus {
  pending('Order received, awaiting confirmation'),
  confirmed('Order confirmed, preparing for shipment'),
  shipped('Order shipped, on its way'),
  delivered('Order delivered, enjoy!');

  final String message;

  const OrderStatus(this.message);

  OrderStatus? next() {
    switch (this) {
      case OrderStatus.pending:
        return OrderStatus.confirmed;
      case OrderStatus.confirmed:
        return OrderStatus.shipped;
      case OrderStatus.shipped:
        return OrderStatus.delivered;
      case OrderStatus.delivered:
        return null;
    }
  }
}

void main() {
  OrderStatus? status = OrderStatus.pending;

  while (status != null) {
    print(status.message);
    status = status.next();
  }
}

Conclusion:

In the article, I have explained the Explore Advanced Dart Enum basic structure in a flutter; you can modify this code according to your choice. This was a small introduction to the Explore Advanced Dart Enum On User Interaction from my side, and it’s working using Flutter.

I hope this blog will provide you with sufficient information on Trying the Explore Advanced Dart Enum in your projects. Dart enums are a flexible tool for writing expressive and maintainable code; they are more than just a list of values.  So please try it.

❤ ❤ Thanks for reading this article ❤❤

If I got something wrong? Let me know in the comments. I would love to improve.

Clap 👏 If this article helps you.

---

Feel free to connect with us:
And read more articles from FlutterDevs.com.

FlutterDevs team of Flutter developers to build high-quality and functionally-rich apps. Hire a Flutter developer for your cross-platform Flutter mobile app project on an hourly or full-time basis as per your requirement! For any flutter-related queries, you can connect with us on Facebook, GitHub, Twitter, and LinkedIn.

We welcome feedback and hope that you share what you’re working on using #FlutterDevs. We truly enjoy seeing how you use Flutter to build beautiful, interactive web experiences.

---