Search code examples
staticdartflutterconstants

What's the best practice to keep all the constants in Flutter?


What's the best programming practice to create a constant class in Flutter to keep all the application constants for easy reference?

I know that there is const keyword in Dart for creating constant fields, but is it okay to use static along with const, or will it create memory issues during runtime?

class Constants {
  static const String SUCCESS_MESSAGE = "You will be contacted by us very soon.";
}

This question is not only based on getting a proper structure but also on knowing how to save resources and memory leakage prevention while creating constants.


Solution

  • EDIT

    Now that the flag --dart-define has been added to the different command lines of Flutter, the following answer no-longer applies.

    Instead just declare constants wherever you want, and potentially refer to other answers.


    While there are no technical issues with static const, architecturally you may want to do it differently.

    Flutter tend to not have any global/static variables and use an InheritedWidget.

    Which means you can write:

    class MyConstants extends InheritedWidget {
      static MyConstants of(BuildContext context) => context. dependOnInheritedWidgetOfExactType<MyConstants>();
    
      const MyConstants({Widget child, Key key}): super(key: key, child: child);
    
      final String successMessage = 'Some message';
    
      @override
      bool updateShouldNotify(MyConstants oldWidget) => false;
    }
    

    Then inserted at the root of your app:

    void main() {
      runApp(
        MyConstants(
          child: MyApp(),
        ),
      );
    }
    

    And used as such:

    @override
    Widget build(BuilContext context) {
      return Text(MyConstants.of(context).successMessage);
    }
    

    This has a bit more code than the static const, but offer many advantages:

    • Works with hot-reload
    • Easily testable and mockable
    • Can be replaced with something more dynamic than constants without rewriting the whole app.

    But at the same time it:

    1. Doesn't consume much more memory (the inherited widget is typically created once)
    2. Is performant (Obtaining an InheritedWidget is O(1))