change the way of speaking things to be less "it's magic!" and more serious in state management

Nipodemos
Commit 570595a8889bb18a225c85c5fb8c97afaaa09f63 570595a8 1 parent c5eeaba3
Showing 1 changed file with 373 additions and 346 deletions
docs/state_management.md
--- a/docs/state_management.md
View file @570595a
+++ b/docs/state_management.md
View file @570595a
-
 # State Management
 There are currently several state managers for Flutter. However, most of them involve using ChangeNotifier to update widgets and this is a bad and very bad approach to performance of medium or large applications. You can check in the official Flutter documentation that [ChangeNotifier should be used with 1 or a maximum of 2 listeners](https://api.flutter.dev/flutter/foundation/ChangeNotifier-class.html), making it practically unusable for any application medium or large.
@@ -11,532 +10,560 @@ Other state managers are good, but have their nuances:
 Get isn't better or worse than any other state manager, but that you should analyze these points as well as the points below to choose between using Get in pure form (Vanilla), or using it in conjunction with another state manager. Definitely, Get is not the enemy of any other state manager, because Get is a microframework, not just a state manager, and can be used either alone or in conjunction with them.
-## Simple State Manager
+## Reactive State Manager
-Get has a state manager that is extremely light and easy, which does not use ChangeNotifier, will meet the need especially for those new to Flutter, and will not cause problems for large applications.
+Reactive programming can alienate many people because it is said to be complicated. GetX turns reactive programming into something quite simple:
-### Advantages
+- You won't need to create StreamControllers.
+- You won't need to create a StreamBuilder for each variable
+- You will not need to create a class for each state.
+- You will not need to create a get for an initial value.
-1. Update only the required widgets.
+Reactive programming with Get is as easy as using setState.
-2. Does not use changeNotifier, it is the state manager that uses less memory (close to 0mb).
+Let's imagine that you have a name variable and want that every time you change it, all widgets that use it are automatically changed.
-3. Forget StatefulWidget! With Get you will never need it. With the other state managers, you will probably have to use a StatefulWidget to get the instance of your Provider, BLoC, MobX Controller, etc. But have you ever stopped to think that your appBar, your scaffold, and most of the widgets that are in your class are stateless? So why save the state of an entire class, if you can only save the state of the Widget that is stateful? Get solves that, too. Create a Stateless class, make everything stateless. If you need to update a single component, wrap it with GetBuilder, and its state will be maintained.
+This is your count variable:
-4. Organize your project for real! Controllers must not be in your UI, place your TextEditController, or any controller you use within your Controller class.
+```dart
+var name = 'Jonatas Borges';
+```
-5. Do you need to trigger an event to update a widget as soon as it is rendered? GetBuilder has the property "initState", just like StatefulWidget, and you can call events from your controller, directly from it, no more events being placed in your initState.
+To make it observable, you just need to add ".obs" to the end of it:
-6. Do you need to trigger an action like closing streams, timers and etc? GetBuilder also has the dispose property, where you can call events as soon as that widget is destroyed.
+```dart
+var name = 'Jonatas Borges'.obs;
+```
-7. Use streams only if necessary. You can use your StreamControllers inside your controller normally, and use StreamBuilder also normally, but remember, a stream reasonably consumes memory, reactive programming is beautiful, but you shouldn't abuse it. 30 streams open simultaneously can be worse than changeNotifier (and changeNotifier is very bad).
+That's all. It's *that* simple.
-8. Update widgets without spending ram for that. Get stores only the GetBuilder creator ID, and updates that GetBuilder when necessary. The memory consumption of the get ID storage in memory is very low even for thousands of GetBuilders. When you create a new GetBuilder, you are actually sharing the state of GetBuilder that has a creator ID. A new state is not created for each GetBuilder, which saves A LOT OF ram for large applications. Basically your application will be entirely Stateless, and the few Widgets that will be Stateful (within GetBuilder) will have a single state, and therefore updating one will update them all. The state is just one.
+What did we do under the hood? We created a stream of Strings, assigned the initial value "Jonatas Borges", we warn all widgets that use "Jonatas Borges" that they now belong to this variable, and when it is changed, they will be changed too. This is the magic of Get, that only dart allows us to do this.
-9. Get is omniscient and in most cases it knows exactly the time to take a controller out of memory. You should not worry about when to dispose of a controller, Get knows the best time to do this.
+Okay, but as we know, a widget can only be changed if it is inside a function, because static classes do not have the power to "auto-change". You will need to create a StreamBuilder, subscribe to listen to this variable, and create a "cascade" of StreamBuilder if you want to change several variables in the same scope, right?
+No, you don't need a StreamBuilder, but you are right about static classes.
-### Usage
+Well, in the view we usually have a lot of boilerplate when we want to change a specific widget. With Get you can also forget about this Boilerplate. StreamBuilder? initialValue? builder?
+No, you just need to play this variable inside an Obx widget.
 ```dart
-// Create controller class and extends GetxController
-class Controller extends GetxController {
-  int counter = 0;
-  void increment() {
-    counter++;
-    update(); // use update() to update counter variable on UI when increment be called
-  }
-}
-// On your Stateless/Stateful class, use GetBuilder to update Text when increment be called
-GetBuilder<Controller>(
-  init: Controller(), // INIT IT ONLY THE FIRST TIME
-  builder: (_) => Text(
-    '${_.counter}',
-  ),
-)
-//Initialize your controller only the first time. The second time you are using ReBuilder for the same controller, do not use it again. Your controller will be automatically removed from memory as soon as the widget that marked it as 'init' is deployed. You don't have to worry about that, Get will do it automatically, just make sure you don't start the same controller twice.
+Obx (() => Text (controller.name));
 ```
-**Done!**
+What do you need to memorize? "Obx(() =>" You are just passing that widget through an arrow-function into an Obx. Obx is smart, and will only be changed if the value of name is changed. If name is "John" and you change it to "John", it will not have any changes on the screen, and Obx will simply ignore this change, and will not rebuild the widget, to save resources. Isn't that amazing?
-- You have already learned how to manage states with Get.
+What if I have 5 observable variables within an Obx? It will update when any of them are changed. And if I have 30 variables in a class, when I update one, will it update all variables that are in that class? No, just the specific widget that uses that variable.
-- Note: You may want a larger organization, and not use the init property. For that, you can create a class and extends Bindings class, and within it mention the controllers that will be created within that route. Controllers will not be created at that time, on the contrary, this is just a statement, so that the first time you use a Controller, Get will know where to look. Get will remain lazyLoad, and will continue to dispose Controllers when they are no longer needed. See the pub.dev example to see how it works.
+GetX only updates the screen when the variable changes on the screen, if the screen remains the same, it will not reconstruct anything.
-If you navigate many routes and need data that was in your previously used controller, you just need to use GetBuilder Again (with no init):
+### Advantages
-```dart
-class OtherClass extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      body: Center(
-        child: GetBuilder<Controller>(
-          builder: (s) => Text('${s.counter}'),
-        ),
-      ),
-    );
-  }
+GetX is focused for when you need granular control over what is being updated. Is for situations where you want only the widget when a certain variable has been changed to be rebuilt.
-```
+If you do not need unique IDs, because all your variables will be changed when you perform an action, use GetBuilder, because it is a simple state updater in blocks, made in a few lines of code. It was done in a simple way, to have the least computational logic involved, just to fulfill a single purpose and spend the minimum resources possible for that purpose.
-If you need to use your controller in many other places, and outside of GetBuilder, just create a get in your controller and have it easily. (or use `Get.find<Controller>()`)
+If you want a powerful state manager, you can go without fear to GetX. It does not work with variables, but flows, everything in it is streams under the hood. You can use rxDart in conjunction with it, because everything is stream, you can hear the event of each "variable", because everything in it is stream, it is literally BLoC, easier than MobX, and without code generator or decorations .
-```dart
-class Controller extends GetxController {
+Without decorations, you can turn anything into Observable with just a ".obs".
-  /// You do not need that. I recommend using it just for ease of syntax.
-  /// with static method: Controller.to.counter();
-  /// with no static method: Get.find<Controller>().counter();
-  /// There is no difference in performance, nor any side effect of using either syntax. Only one does not need the type, and the other the IDE will autocomplete it.
-  static Controller get to => Get.find(); // add this line
+Maximum performance: In addition to having a smart algorithm for minimal reconstruction, Get uses comparators to make sure the state has changed. If you experience any errors in your application, and send a duplicate change of state, Get will ensure that your application does not collapse.
-  int counter = 0;
-  void increment() {
-    counter++;
-    update();
-  }
-}
-```
+The state only changes if the values change. That's the main difference between Get, and using Computed from MobX for example. When joining two observables, when one is changed, the hearing of that observable will change. With Get, if you join two variables (which is unnecessary computed for that), GetX (similar to Observer) will only change if it implies a real change of state.
-And then you can access your controller directly, that way:
+### Usage
+
+You have 3 ways to turn a variable into an observable.
+The first is using Rx{Type}.
 ```dart
-FloatingActionButton(
-  onPressed: () {
-    Controller.to.increment(),
-  } // This is incredibly simple!
-  child: Text("${Controller.to.counter}"),
-),
+var count = RxString();
 ```
-When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
+The second is to use Rx and type it with `Rx<Type>`
-### How it handles controllers
+```dart
+var count = Rx<String>();
+```
-Let's say we have this:
+The third, more practical and easier approach, is just to add an .obs to your variable.
-`Class a => Class B (has controller X) => Class C (has controller X)`
+```dart
+var count = 0.obs;
-In class A the controller is not yet in memory, because you have not used it yet (Get is lazyLoad). In class B you used the controller, and it entered memory. In class C you used the same controller as in class B, Get will share the state of controller B with controller C, and the same controller is still in memory. If you close screen C and screen B, Get will automatically take controller X out of memory and free up resources, because Class a is not using the controller. If you navigate to B again, controller X will enter memory again, if instead of going to class C, you return to class A again, Get will take the controller out of memory in the same way. If class C didn't use the controller, and you took class B out of memory, no class would be using controller X and likewise it would be disposed of. The only exception that can mess with Get, is if you remove B from the route unexpectedly, and try to use the controller in C. In this case, the creator ID of the controller that was in B was deleted, and Get was programmed to remove it from memory every controller that has no creator ID. If you intend to do this, add the "autoRemove: false" flag to class B's GetBuilder and use adoptID = true; in class C's GetBuilder.
+// or Rxint count = 0.obs;
+// or Rx<int> count = 0.obs;
+```
-### You won't need StatefulWidgets anymore
+As we know, Dart is now heading towards null safety. Since that it is a good idea, from now on, you should start to use your variables always with an initial value. Transforming a variable into an observable with an initial value with Get is the simplest and most practical approach. You will literally add a ".obs" to the end of your variable, and that’s it, you’ve made it observable, and its value will be the initial value.
-Using StatefulWidgets means storing the state of entire screens unnecessarily, even because if you need to minimally rebuild a widget, you will embed it in a Consumer/Observer/BlocProvider/GetBuilder/GetX/Obx, which will be another StatefulWidget.
-The StatefulWidget class is a class larger than StatelessWidget, which will allocate more RAM, and this may not make a significant difference between one or two classes, but it will most certainly do when you have 100 of them!
-Unless you need to use a mixin, like TickerProviderStateMixin, it will be totally unnecessary to use a StatefulWidget with Get.
+You can add variables, and if you want to type your widget to get your controller inside, you just need to use GetX widget instead of Obx
-You can call all methods of a StatefulWidget directly from a GetBuilder.
-If you need to call initState() or dispose() method for example, you can call them directly;
+### Example
 ```dart
-GetBuilder<Controller>(
-  initState: (_) => Controller.to.fetchApi(),
-  dispose: (_) => Controller.to.closeStreams(),
-  builder: (s) => Text('${s.username}'),
-),
+final count1 = 0.obs;
+final count2 = 0.obs;
+int get sum => count1.value + count2.value;
 ```
-A much better approach than this is to use the onInit() and onClose() method directly from your controller.
-
 ```dart
-@override
-void onInit() {
-  fetchApi();
-  super.onInit();
-}
+GetX<Controller>(
+  builder: (value) {
+    print("count 1 rebuild");
+    return Text('${value.count1.value}');
+  },
+),
+GetX<Controller>(
+  builder: (_) {
+    print("count 2 rebuild");
+    return Text('${_.count2.value}');
+  },
+),
+GetX<Controller>(
+  builder: (_) {
+    print("count 3 rebuild");
+    return Text('${_.sum}');
+  },
+),
 ```
-- NOTE: If you want to start a method at the moment the controller is called for the first time, you DON'T NEED to use constructors for this, in fact, using a performance-oriented package like Get, this borders on bad practice, because it deviates from the logic in which the controllers are created or allocated (if you create an instance of this controller, the constructor will be called immediately, you will be populating a controller before it is even used, you are allocating memory without it being in use, this definitely hurts the principles of this library). The onInit() methods; and onClose(); were created for this, they will be called when the Controller is created, or used for the first time, depending on whether you are using Get.lazyPut or not. If you want, for example, to make a call to your API to populate data, you can forget about the old-fashioned method of initState/dispose, just start your call to the api in onInit, and if you need to execute any command like closing streams, use the onClose() for that.
+If we increment the number of count 1, only count 1 and count 3 are reconstructed, because count 1 now has a value of 1, and 1 + 0 = 1, changing the sum value.
-### Why it exists
+If we change count 2, only count2 and 3 are reconstructed, because the value of 2 has changed, and the result of the sum is now 2.
-The purpose of this package is precisely to give you a complete solution for navigation of routes, management of dependencies and states, using the least possible dependencies, with a high degree of decoupling. Get engages all high and low level Flutter APIs within itself, to ensure that you work with the least possible coupling. We centralize everything in a single package, to ensure that you don't have any kind of coupling in your project. That way, you can put only widgets in your view, and leave the part of your team that works with the business logic free, to work with the business logic without depending on any element of the View. This provides a much cleaner working environment, so that part of your team works only with widgets, without worrying about sending data to your controller, and part of your team works only with the business logic in its breadth, without depending on no element of the view.
+If we add the number 1 to count 1, which already contains 1, no widget is reconstructed. If we add a value of 1 for count 1 and a value of 2 for count 2, only 2 and 3 will be reconstructed, simply because GetX not only changes what is necessary, it avoids duplicating events.
-So to simplify this:
-You don't need to call methods in initState and send them by parameter to your controller, nor use your controller constructor for that, you have the onInit() method that is called at the right time for you to start your services.
-You do not need to call the device, you have the onClose() method that will be called at the exact moment when your controller is no longer needed and will be removed from memory. That way, leave views for widgets only, refrain from any kind of business logic from it.
+- NOTE: By default, the first event will allow rebuild even if it is the same. We created this behavior due to dualistic variables, such as Boolean.
+Imagine you did this:
-Do not call a dispose method inside GetxController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
+```dart
+var isLogged = false.obs;
+```
+
+and then you check if a user is logged in to trigger an event in "ever".
 ```dart
-class Controller extends GetxController {
-  StreamController<User> user = StreamController<User>();
-  StreamController<String> name = StreamController<String>();
+onInit(){
+  ever(isLogged, fireRoute);
+  isLogged.value = await Preferences.hasToken();
+}
-  /// close stream = onClose method, not dispose.
-  @override
-  void onClose() {
-    user.close();
-    name.close();
-    super.onClose();
+fireRoute(logged) {
+  if (logged) {
+   Get.off(Home());
+  } else {
+   Get.off(Login());
   }
 }
 ```
-Controller life cycle:
-
-- onInit() where it is created.
-- onClose() where it is closed to make any changes in preparation for the delete method
-- deleted: you do not have access to this API because it is literally removing the controller from memory. It is literally deleted, without leaving any trace.
+if hasToken was false, there would be no change to isLogged, so ever would never be called. To avoid this type of behavior, the first change to an observable will always trigger an event, even if it is the same.
+You can remove this behavior if you want, using:
+`isLogged.firstRebuild = false;`
-### Other ways of using it
+### Conditions to rebuild
-You can use Controller instance directly on GetBuilder value:
+In addition, Get provides refined state control. You can condition an event (such as adding an object to a list), on a certain condition.
 ```dart
-GetBuilder<Controller>(
-  init: Controller(),
-  builder: (value) => Text(
-    '${value.counter}', //here
-  ),
-),
+// First parameter: condition, must return true of false
+// Second parameter: the new value to aplly if the condition is true
+list.addIf(item < limit, item);
 ```
-You may also need an instance of your controller outside of your GetBuilder, and you can use these approaches to achieve this:
+Without decorations, without a code generator, without complications :smile:
+
+Do you know Flutter's counter app? Your Controller class might look like this:
 ```dart
-class Controller extends GetxController {
-  static Controller get to => Get.find();
-[...]
+class CountCtl extends GetxController {
+  final count = 0.obs;
 }
-// on you view:
-GetBuilder<Controller>(  
-  init: Controller(), // use it only first time on each controller
-  builder: (_) => Text(
-    '${Controller.to.counter}', //here
-  )
-),
 ```
-or
+With a simple:
 ```dart
-class Controller extends GetxController {
- // static Controller get to => Get.find(); // with no static get
-[...]
-}
-// on stateful/stateless class
-GetBuilder<Controller>(  
-  init: Controller(), // use it only first time on each controller
-  builder: (_) => Text(
-    '${Get.find<Controller>().counter}', //here
-  ),
-),
+ctl.count.value++
 ```
-- You can use "non-canonical" approaches to do this. If you are using some other dependency manager, like get_it, modular, etc., and just want to deliver the controller instance, you can do this:
+You could update the counter variable in your UI, regardless of where it is stored.
-```dart
-Controller controller = Controller();
-[...]
-GetBuilder<Controller>(
-  init: controller, //here
-  builder: (_) => Text(
-    '${controller.counter}', // here
-  ),
-),
+### Where .obs can be used
-```
+You can transform anything on obs:
-### Unique IDs
+```dart
+class RxUser {
+  final name = "Camila".obs;
+  final age = 18.obs;
+}
-If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:
+class User {
+  User({String name, int age});
+  final rx = RxUser();
-```dart
-GetBuilder<Controller>(
-  id: 'text'
-  init: Controller(), // use it only first time on each controller
-  builder: (_) => Text(
-    '${Get.find<Controller>().counter}', //here
-  ),
-),
-```
+  String get name => rx.name.value;
+  set name(String value) => rx.name.value = value;
-And update it this form:
+  int get age => rx.age.value;
+  set age(int value) => rx.age.value = value;
+}
+```
 ```dart
-update(['text']);
+
+void main() {
+  final user = User();
+  print(user.name);
+  user.age = 23;
+  user.rx.age.listen((int age) => print(age));
+  user.age = 24;
+  user.age = 25;
+}
+___________
+out:
+Camila
+23
+24
+25
+
 ```
-You can also impose conditions for the update:
+### Note about Lists
+
+Lists are completely observable as are the objects within it. That way, if you add a value to a list, it will automatically rebuild the widgets that use it.
+
+You also don't need to use ".value" with lists, the amazing dart api allowed us to remove that, unfortunate primitive types like String and int cannot be extended, making the use of .value mandatory, but that won't be a problem if you work with gets and setters for these.
 ```dart
-update(['text'], counter < 10);
+final String title = 'User Info:'.obs
+final list = List<User>().obs;
 ```
-GetX does this automatically and only reconstructs the widget that uses the exact variable that was changed, if you change a variable to the same as the previous one and that does not imply a change of state , GetX will not rebuild the widget to save memory and CPU cycles (3 is being displayed on the screen, and you change the variable to 3 again. In most state managers, this will cause a new rebuild, but with GetX the widget will only is rebuilt again, if in fact his state has changed).
+```dart
+Text(title.value), // String need to have .value in front of it
+ListView.builder (
+  itemCount: list.lenght // lists don't need it
+)
+```
-## Reactive State Manager
+You don't have to work with sets if you don't want to. you can use the "assign 'and" assignAll "api.
+The "assign" api will clear your list, and add a single object that you want to start there.
+The "assignAll" api will clear the existing list and add any iterable objects that you inject into it.
-Reactive programming can alienate many people because it is said to be complicated. Getx turns reactive programming into something so simple, that it can be used and learned by those who started at that very moment in Flutter. No, you will not need to create StreamControllers. You also won't need to create a StreamBuilder for each variable. You will not need to create a class for each state. You will not need to create a get for an initial value. Reactive programming with Get is as easy as using setState (or even easier!).
+### Why i have to use .value
-Let's imagine that you have a name variable and want that every time you change it, all widgets that use it are automatically changed.
+We could remove the obligation to use 'value' to String and int with a simple decoration and code generator, but the purpose of this lib is precisely not to need any external dependency. It is to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, light and performance way without needing any external package.
-This is your count variable:
+You can literally add 3 letters to your pubspec (get) and a colon and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance.
-```dart
-var name = 'Jonatas Borges';
-```
+The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand.
-To make it observable, you just need to add ".obs" to the end of it:
+If you are bothered by value, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
-```dart
-var name = 'Jonatas Borges'.obs;
-```
+If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
-This borders on absurdity when it comes to practicality. What did we do under the hood? We created a stream of Strings, assigned the initial value "Jonatas Borges", we warn all widgets that use "Jonatas Borges" that they now belong to this variable, and when it is changed, they will be changed too. This is the magic of Get, that only dart allows us to do this.
+Obviously, if someone wants to contribute to the project and create a code generator, or something similar, I will link in this readme as an alternative, my need is not the need for all devs, but for now I say, there are good solutions that already do that, like MobX.
-Okay, but as we know, a widget can only be changed if it is inside a function, because static classes do not have the power to "auto-change". You will need to create a StreamBuilder, subscribe to listen to this variable, and create a "cascade" of StreamBuilder if you want to change several variables in the same scope, right?
-No, you don't need a StreamBuilder, but you are right about static classes.
+### Obx()
-Well, in the view we usually have a lot of boilerplate when we want to change a specific widget. With Get you can also forget about this Boilerplate. StreamBuilder? initialValue? builder?
-No, you just need to play this variable inside an Obx widget.
+Typing in Get using Bindings is unnecessary. you can use the Obx widget instead of GetX which only receives the anonymous function that creates a widget.
+Obviously, if you don't use a type, you will need to have an instance of your controller to use the variables, or use `Get.find<Controller>()` .value or Controller.to.value to retrieve the value.
+
+### Workers
+
+Workers will assist you, triggering specific callbacks when an event occurs.
 ```dart
-Obx (() => Text (controller.name));
+/// Called every time the variable $_ is changed
+ever(count1, (_) => print("$_ has been changed"));
+
+/// Called only first time the variable $_ is changed
+once(count1, (_) => print("$_ was changed once"));
+
+/// Anti DDos - Called every time the user stops typing for 1 second, for example.
+debounce(count1, (_) => print("debouce$_"), time: Duration(seconds: 1));
+
+/// Ignore all changes within 1 second.
+interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));
 ```
-What do you need to memorize? "Obx(() =>" You are just passing that widget through an arrow-function into an Obx. Obx is smart, and will only be changed if the value of name is changed. If name is "John" and you change it to "John", it will not have any changes on the screen, and Obx will simply ignore this change, and will not rebuild the widget, to save resources. Isn't that amazing?
+- ever
+'ever' is called every time its variable is changed. That's it.
-What if I have 5 observable variables within an Obx? It will update when any of them are changed. And if I have 30 variables in a class, when I update one, will it update all variables that are in that class? No, just the specific widget that uses that variable. And if I machine-gun my observable variable 1 billion times with the same value, will I have freeze on the screen for unnecessary reconstructions? No, GetX only updates the screen when the variable changes on the screen, if the screen remains the same, it will not reconstruct anything.
+- ever
+'once' is called only the first time the variable has been changed.
-### Advantages
+- debounce
+'debounce' is very useful in search functions, where you only want the API to be called when the user finishes typing. If the user types "Jonny", you will have 5 searches in the APIs, by the letter J, o, n, n, and y. With Get this does not happen, because you will have a "debounce" Worker that will only be triggered at the end of typing.
-GetBuilder is aimed precisely at multiple state control. Imagine that you added 30 products to a cart, you click delete one, at the same time that the list is updated, the price is updated and the badge in the shopping cart is updated to a smaller number. This type of approach makes GetBuilder killer, because it groups states and changes them all at once without any "computational logic" for that. GetBuilder was created with this type of situation in mind, since for ephemeral change of state, you can use setState and you would not need a state manager for this. However, there are situations where you want only the widget where a certain variable has been changed to be rebuilt, and this is what GetX does with a mastery never seen before.
+- interval
+'interval' is different from the debouce. debouce if the user makes 1000 changes to a variable within 1 second, he will send only the last one after the stipulated timer (the default is 800 milliseconds). Interval will instead ignore all user actions for the stipulated period. If you send events for 1 minute, 1000 per second, debounce will only send you the last one, when the user stops strafing events. interval will deliver events every second, and if set to 3 seconds, it will deliver 20 events that minute. This is recommended to avoid abuse, in functions where the user can quickly click on something and get some advantage (imagine that the user can earn coins by clicking on something, if he clicked 300 times in the same minute, he would have 300 coins, using interval, you you can set a time frame for 3 seconds, and even then clicking 300 or a thousand times, the maximum he would get in 1 minute would be 20 coins, clicking 300 or 1 million times). The debounce is suitable for anti-DDos, for functions like search where each change to onChange would cause a query to your api. Debounce will wait for the user to stop typing the name, to make the request. If it were used in the coin scenario mentioned above, the user would only win 1 coin, because it is only executed, when the user "pauses" for the established time.
-That way, if you want an individual controller, you can assign IDs for that, or use GetX. This is up to you, remembering that the more "individual" widgets you have, the more the performance of GetX will stand out, while the performance of GetBuilder should be superior, when there is multiple change of state.
+## Mixing the two state managers
-You can use both in any situation, but if you want to tune their application to the maximum possible performance, I would say that: if your variables are changed at different times, use GetX, because there is no competition for it when the subject is to rebuild only what is necessary, if you do not need unique IDs, because all your variables will be changed when you perform an action, use GetBuilder, because it is a simple state updater in blocks, made in a few lines of code, to make just what he promises to do: update state in blocks. There is no way to compare RAM, CPU, or anything else from a giant state manager to a simple StatefulWidget (like GetBuilder) that is updated when you call update(). It was done in a simple way, to have the least computational logic involved, just to fulfill a single purpose and spend the minimum resources possible for that purpose.
-If you want a powerful state manager, you can go without fear to GetX. It does not work with variables, but flows, everything in it is streams under the hood. You can use rxDart in conjunction with it, because everything is stream, you can hear the event of each "variable", because everything in it is stream, it is literally BLoC, easier than MobX, and without code generator or decorations .
+Some people opened a feature request, as they wanted to use only one type of reactive variable, and the other mechanics, and needed to insert an Obx into a GetBuilder for this. Thinking about it MixinBuilder was created. It allows both reactive changes by changing ".obs" variables, and mechanical updates via update(). However, of the 4 widgets he is the one that consumes the most resources, since in addition to having a Subscription to receive change events from his children, he subscribes to the update method of his controller.
-If you want power, Get gives you the most advanced state manager you could ever have.
-GetX was built 100% based on Streams, and give you all the firepower that BLoC gave you, with an easier facility than using MobX.
-Without decorations, you can turn anything into Observable with just a ".obs".
+Extending GetxController is important, as they have life cycles, and can "start" and "end" events in their onInit() and onClose() methods. You can use any class for this, but I strongly recommend you use the GetxController class to place your variables, whether they are observable or not.
-Maximum performance: In addition to having a smart algorithm for minimal reconstruction, Get uses comparators to make sure the state has changed. If you experience any errors in your application, and send a duplicate change of state, Get will ensure that your application does not collapse.
-The state only changes if the values change. That's the main difference between Get, and using Computed from MobX. When joining two observables, when one is changed, the hearing of that observable will change. With Get, if you join two variables (which is unnecessary computed for that), GetX (similar to Observer) will only change if it implies a real change of state.
+## Simple State Manager
-### Usage
+Get has a state manager that is extremely light and easy, which does not use ChangeNotifier, will meet the need especially for those new to Flutter, and will not cause problems for large applications.
-You have 3 ways to turn a variable into an observable.
-The first is using Rx{Type}.
+GetBuilder is aimed precisely at multiple state control. Imagine that you added 30 products to a cart, you click delete one, at the same time that the list is updated, the price is updated and the badge in the shopping cart is updated to a smaller number. This type of approach makes GetBuilder killer, because it groups states and changes them all at once without any "computational logic" for that. GetBuilder was created with this type of situation in mind, since for ephemeral change of state, you can use setState and you would not need a state manager for this.
-```dart
-var count = RxString();
-```
+That way, if you want an individual controller, you can assign IDs for that, or use GetX. This is up to you, remembering that the more "individual" widgets you have, the more the performance of GetX will stand out, while the performance of GetBuilder should be superior, when there is multiple change of state.
-The second is to use Rx and type it with `Rx<Type>`
+### Advantages
-```dart
-var count = Rx<String>();
-```
+1. Update only the required widgets.
-The third, more practical, easy, and incredible approach, is just to add an .obs to your variable.
+2. Does not use changeNotifier, it is the state manager that uses less memory (close to 0mb).
-```dart
-var count = 0.obs;
+3. Forget StatefulWidget! With Get you will never need it. With the other state managers, you will probably have to use a StatefulWidget to get the instance of your Provider, BLoC, MobX Controller, etc. But have you ever stopped to think that your appBar, your scaffold, and most of the widgets that are in your class are stateless? So why save the state of an entire class, if you can only save the state of the Widget that is stateful? Get solves that, too. Create a Stateless class, make everything stateless. If you need to update a single component, wrap it with GetBuilder, and its state will be maintained.
-// or Rxint count = 0.obs;
-// or Rx<int> count = 0.obs;
-```
+4. Organize your project for real! Controllers must not be in your UI, place your TextEditController, or any controller you use within your Controller class.
- As we know, Dart is now heading towards null safety. With that it is a good idea, from now on, you start to use your variables always with an initial value. Transforming a variable into an observable with an initial value with Get is the simplest and most practical approach that currently exists in Flutter. You will literally add a ".obs" to the end of your variable, and that’s it, you’ve made it observable, and its value will be the initial value, this is fantastic!
+5. Do you need to trigger an event to update a widget as soon as it is rendered? GetBuilder has the property "initState", just like StatefulWidget, and you can call events from your controller, directly from it, no more events being placed in your initState.
-You can add variables, and if you want to type your widget to get your controller inside, you just need to use GetX widget instead of Obx
+6. Do you need to trigger an action like closing streams, timers and etc? GetBuilder also has the dispose property, where you can call events as soon as that widget is destroyed.
-```dart
-final count1 = 0.obs;
-final count2 = 0.obs;
-int get sum => count1.value + count2.value;
-```
+7. Use streams only if necessary. You can use your StreamControllers inside your controller normally, and use StreamBuilder also normally, but remember, a stream reasonably consumes memory, reactive programming is beautiful, but you shouldn't abuse it. 30 streams open simultaneously can be worse than changeNotifier (and changeNotifier is very bad).
+
+8. Update widgets without spending ram for that. Get stores only the GetBuilder creator ID, and updates that GetBuilder when necessary. The memory consumption of the get ID storage in memory is very low even for thousands of GetBuilders. When you create a new GetBuilder, you are actually sharing the state of GetBuilder that has a creator ID. A new state is not created for each GetBuilder, which saves A LOT OF ram for large applications. Basically your application will be entirely Stateless, and the few Widgets that will be Stateful (within GetBuilder) will have a single state, and therefore updating one will update them all. The state is just one.
+
+9. Get is omniscient and in most cases it knows exactly the time to take a controller out of memory. You should not worry about when to dispose of a controller, Get knows the best time to do this.
+
+### Usage
 ```dart
-GetX<Controller>(
-  builder: (value) {
-    print("count 1 rebuild");
-    return Text('${value.count1.value}');
-  },
-),
-GetX<Controller>(
-  builder: (_) {
-    print("count 2 rebuild");
-    return Text('${_.count2.value}');
-  },
-),
-GetX<Controller>(
-  builder: (_) {
-    print("count 3 rebuild");
-    return Text('${_.sum}');
-  },
-),
+// Create controller class and extends GetxController
+class Controller extends GetxController {
+  int counter = 0;
+  void increment() {
+    counter++;
+    update(); // use update() to update counter variable on UI when increment be called
+  }
+}
+// On your Stateless/Stateful class, use GetBuilder to update Text when increment be called
+GetBuilder<Controller>(
+  init: Controller(), // INIT IT ONLY THE FIRST TIME
+  builder: (_) => Text(
+    '${_.counter}',
+  ),
+)
+//Initialize your controller only the first time. The second time you are using ReBuilder for the same controller, do not use it again. Your controller will be automatically removed from memory as soon as the widget that marked it as 'init' is deployed. You don't have to worry about that, Get will do it automatically, just make sure you don't start the same controller twice.
 ```
-If we increment the number of count 1, only count 1 and count 3 are reconstructed, because count 1 now has a value of 1, and 1 + 0 = 1, changing the sum value.
+**Done!**
-If we change count 2, only count2 and 3 are reconstructed, because the value of 2 has changed, and the result of the sum is now 2.
+- You have already learned how to manage states with Get.
-If we add the number 1 to count 1, which already contains 1, no widget is reconstructed. If we add a value of 1 for count 1 and a value of 2 for count 2, only 2 and 3 will be reconstructed, simply because GetX not only changes what is necessary, it avoids duplicating events.
+- Note: You may want a larger organization, and not use the init property. For that, you can create a class and extends Bindings class, and within it mention the controllers that will be created within that route. Controllers will not be created at that time, on the contrary, this is just a statement, so that the first time you use a Controller, Get will know where to look. Get will remain lazyLoad, and will continue to dispose Controllers when they are no longer needed. See the pub.dev example to see how it works.
-- NOTE: By default, the first event will allow rebuild even if it is the same. We created this behavior due to dualistic variables, such as Boolean.
-Imagine you did this:
+If you navigate many routes and need data that was in your previously used controller, you just need to use GetBuilder Again (with no init):
 ```dart
-var isLogged = false.obs;
+class OtherClass extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(
+        child: GetBuilder<Controller>(
+          builder: (s) => Text('${s.counter}'),
+        ),
+      ),
+    );
+  }
+
 ```
-and then you check if a user is logged in to trigger an event in "ever".
+If you need to use your controller in many other places, and outside of GetBuilder, just create a get in your controller and have it easily. (or use `Get.find<Controller>()`)
 ```dart
-onInit(){
-  ever(isLogged, fireRoute);
-  isLogged.value = await Preferences.hasToken();
-}
+class Controller extends GetxController {
-fireRoute(logged) {
-  if (logged) {
-   Get.off(Home());
-  } else {
-   Get.off(Login());
+  /// You do not need that. I recommend using it just for ease of syntax.
+  /// with static method: Controller.to.counter();
+  /// with no static method: Get.find<Controller>().counter();
+  /// There is no difference in performance, nor any side effect of using either syntax. Only one does not need the type, and the other the IDE will autocomplete it.
+  static Controller get to => Get.find(); // add this line
+
+  int counter = 0;
+  void increment() {
+    counter++;
+    update();
   }
 }
 ```
-if hasToken was false, there would be no change to isLogged, so ever would never be called. To avoid this type of behavior, the first change to an observable will always trigger an event, even if it is the same.
-You can remove this behavior if you want, using:
-`isLogged.firstRebuild = false;`
-
-In addition, Get provides refined state control. You can condition an event (such as adding an object to a list), on a certain condition.
+And then you can access your controller directly, that way:
 ```dart
-list.addIf(item<limit, item);
+FloatingActionButton(
+  onPressed: () {
+    Controller.to.increment(),
+  } // This is incredibly simple!
+  child: Text("${Controller.to.counter}"),
+),
 ```
-Without decorations, without a code generator, without complications, GetX will change the way you manage your states in Flutter, and that is not a promise, it is a certainty!
+When you press FloatingActionButton, all widgets that are listening to the 'counter' variable will be updated automatically.
-Do you know Flutter's counter app? Your Controller class might look like this:
+### How it handles controllers
-```dart
-class CountCtl extends GetxController {
-  final count = 0.obs;
-}
-```
+Let's say we have this:
-With a simple:
+`Class a => Class B (has controller X) => Class C (has controller X)`
-```dart
-ctl.count.value++
-```
+In class A the controller is not yet in memory, because you have not used it yet (Get is lazyLoad). In class B you used the controller, and it entered memory. In class C you used the same controller as in class B, Get will share the state of controller B with controller C, and the same controller is still in memory. If you close screen C and screen B, Get will automatically take controller X out of memory and free up resources, because Class a is not using the controller. If you navigate to B again, controller X will enter memory again, if instead of going to class C, you return to class A again, Get will take the controller out of memory in the same way. If class C didn't use the controller, and you took class B out of memory, no class would be using controller X and likewise it would be disposed of. The only exception that can mess with Get, is if you remove B from the route unexpectedly, and try to use the controller in C. In this case, the creator ID of the controller that was in B was deleted, and Get was programmed to remove it from memory every controller that has no creator ID. If you intend to do this, add the "autoRemove: false" flag to class B's GetBuilder and use adoptID = true; in class C's GetBuilder.
-You could update the counter variable in your UI, regardless of where it is stored.
+### You won't need StatefulWidgets anymore
-### Where .obs can be used
+Using StatefulWidgets means storing the state of entire screens unnecessarily, even because if you need to minimally rebuild a widget, you will embed it in a Consumer/Observer/BlocProvider/GetBuilder/GetX/Obx, which will be another StatefulWidget.
+The StatefulWidget class is a class larger than StatelessWidget, which will allocate more RAM, and this may not make a significant difference between one or two classes, but it will most certainly do when you have 100 of them!
+Unless you need to use a mixin, like TickerProviderStateMixin, it will be totally unnecessary to use a StatefulWidget with Get.
-You can transform anything on obs:
+You can call all methods of a StatefulWidget directly from a GetBuilder.
+If you need to call initState() or dispose() method for example, you can call them directly;
 ```dart
-class RxUser {
-  final name = "Camila".obs;
-  final age = 18.obs;
-}
-
-class User {
-  User({String name, int age});
-  final rx = RxUser();
+GetBuilder<Controller>(
+  initState: (_) => Controller.to.fetchApi(),
+  dispose: (_) => Controller.to.closeStreams(),
+  builder: (s) => Text('${s.username}'),
+),
+```
-  String get name => rx.name.value;
-  set name(String value) => rx.name.value = value;
+A much better approach than this is to use the onInit() and onClose() method directly from your controller.
-  int get age => rx.age.value;
-  set age(int value) => rx.age.value = value;
+```dart
+@override
+void onInit() {
+  fetchApi();
+  super.onInit();
 }
 ```
-```dart
+- NOTE: If you want to start a method at the moment the controller is called for the first time, you DON'T NEED to use constructors for this, in fact, using a performance-oriented package like Get, this borders on bad practice, because it deviates from the logic in which the controllers are created or allocated (if you create an instance of this controller, the constructor will be called immediately, you will be populating a controller before it is even used, you are allocating memory without it being in use, this definitely hurts the principles of this library). The onInit() methods; and onClose(); were created for this, they will be called when the Controller is created, or used for the first time, depending on whether you are using Get.lazyPut or not. If you want, for example, to make a call to your API to populate data, you can forget about the old-fashioned method of initState/dispose, just start your call to the api in onInit, and if you need to execute any command like closing streams, use the onClose() for that.
-void main() {
-  final user = User();
-  print(user.name);
-  user.age = 23;
-  user.rx.age.listen((int age) => print(age));
-  user.age = 24;
-  user.age = 25;
-}
-___________
-out:
-Camila
-23
-24
-25
+### Why it exists
-```
+The purpose of this package is precisely to give you a complete solution for navigation of routes, management of dependencies and states, using the least possible dependencies, with a high degree of decoupling. Get engages all high and low level Flutter APIs within itself, to ensure that you work with the least possible coupling. We centralize everything in a single package, to ensure that you don't have any kind of coupling in your project. That way, you can put only widgets in your view, and leave the part of your team that works with the business logic free, to work with the business logic without depending on any element of the View. This provides a much cleaner working environment, so that part of your team works only with widgets, without worrying about sending data to your controller, and part of your team works only with the business logic in its breadth, without depending on no element of the view.
-### Note about Lists
+So to simplify this:
+You don't need to call methods in initState and send them by parameter to your controller, nor use your controller constructor for that, you have the onInit() method that is called at the right time for you to start your services.
+You do not need to call the device, you have the onClose() method that will be called at the exact moment when your controller is no longer needed and will be removed from memory. That way, leave views for widgets only, refrain from any kind of business logic from it.
-Working with Lists using Get is the best and most enjoyable thing in the world. They are completely observable as are the objects within it. That way, if you add a value to a list, it will automatically rebuild the widgets that use it.
-You also don't need to use ".value" with lists, the amazing dart api allowed us to remove that, unfortunate primitive types like String and int cannot be extended, making the use of .value mandatory, but that won't be a problem if you work with gets and setters for these.
+Do not call a dispose method inside GetxController, it will not do anything, remember that the controller is not a Widget, you should not "dispose" it, and it will be automatically and intelligently removed from memory by Get. If you used any stream on it and want to close it, just insert it into the close method. Example:
 ```dart
-final list = List<User>().obs;
-```
+class Controller extends GetxController {
+  StreamController<User> user = StreamController<User>();
+  StreamController<String> name = StreamController<String>();
-```dart
-ListView.builder (
-  itemCount: list.lenght
-)
+  /// close stream = onClose method, not dispose.
+  @override
+  void onClose() {
+    user.close();
+    name.close();
+    super.onClose();
+  }
+}
 ```
-You don't have to work with sets if you don't want to. you can use the "assign 'and" assignAll "api.
-The "assign" api will clear your list, and add a single object that you want to start there.
-The "assignAll" api will clear the existing list and add any iterable objects that you inject into it.
-
-### Why i have to use .value
+Controller life cycle:
-We could remove the obligation to use 'value' to String and int with a simple decoration and code generator, but the purpose of this lib is precisely not to need any external dependency. It is to offer an environment ready for programming, involving the essentials (management of routes, dependencies and states), in a simple, light and performance way without needing any external package. You can literally add 3 letters to your pubspec (get) and start programming. All solutions included by default, from route management to state management, aim at ease, productivity and performance. The total weight of this library is less than that of a single state manager, even though it is a complete solution, and that is what you must understand. If you are bothered by value, and like a code generator, MobX is a great alternative, and you can use it in conjunction with Get. For those who want to add a single dependency in pubspec and start programming without worrying about the version of a package being incompatible with another, or if the error of a state update is coming from the state manager or dependency, or still, do not want to worrying about the availability of controllers, whether literally "just programming", get is just perfect.
+- onInit() where it is created.
+- onClose() where it is closed to make any changes in preparation for the delete method
+- deleted: you do not have access to this API because it is literally removing the controller from memory. It is literally deleted, without leaving any trace.
-If you have no problem with the MobX code generator, or have no problem with the BLoC boilerplate, you can simply use Get for routes, and forget that it has state manager. Get SEM and RSM were born out of necessity, my company had a project with more than 90 controllers, and the code generator simply took more than 30 minutes to complete its tasks after a Flutter Clean on a reasonably good machine, if your project it has 5, 10, 15 controllers, any state manager will supply you well. If you have an absurdly large project, and code generator is a problem for you, you have been awarded this solution.
+### Other ways of using it
-Obviously, if someone wants to contribute to the project and create a code generator, or something similar, I will link in this readme as an alternative, my need is not the need for all devs, but for now I say, there are good solutions that already do that, like MobX.
+You can use Controller instance directly on GetBuilder value:
-### Obx()
+```dart
+GetBuilder<Controller>(
+  init: Controller(),
+  builder: (value) => Text(
+    '${value.counter}', //here
+  ),
+),
+```
-Typing in Get using Bindings is unnecessary. you can use the Obx widget instead of GetX which only receives the anonymous function that creates a widget.
-Obviously, if you don't use a type, you will need to have an instance of your controller to use the variables, or use `Get.find<Controller>()` .value or Controller.to.value to retrieve the value.
+You may also need an instance of your controller outside of your GetBuilder, and you can use these approaches to achieve this:
-### Workers
+```dart
+class Controller extends GetxController {
+  static Controller get to => Get.find();
+[...]
+}
+// on you view:
+GetBuilder<Controller>(  
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Controller.to.counter}', //here
+  )
+),
+```
-Workers will assist you, triggering specific callbacks when an event occurs.
+or
 ```dart
-/// Called every time the variable $_ is changed
-ever(count1, (_) => print("$_ has been changed"));
+class Controller extends GetxController {
+ // static Controller get to => Get.find(); // with no static get
+[...]
+}
+// on stateful/stateless class
+GetBuilder<Controller>(  
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Get.find<Controller>().counter}', //here
+  ),
+),
+```
-/// Called only first time the variable $_ is changed
-once(count1, (_) => print("$_ was changed once"));
+- You can use "non-canonical" approaches to do this. If you are using some other dependency manager, like get_it, modular, etc., and just want to deliver the controller instance, you can do this:
-/// Anti DDos - Called every time the user stops typing for 1 second, for example.
-debounce(count1, (_) => print("debouce$_"), time: Duration(seconds: 1));
+```dart
+Controller controller = Controller();
+[...]
+GetBuilder<Controller>(
+  init: controller, //here
+  builder: (_) => Text(
+    '${controller.counter}', // here
+  ),
+),
-/// Ignore all changes within 1 second.
-interval(count1, (_) => print("interval $_"), time: Duration(seconds: 1));
 ```
-- ever
-'ever' is called every time its variable is changed. That's it.
+### Unique IDs
-- ever
-'once' is called only the first time the variable has been changed.
+If you want to refine a widget's update control with GetBuilder, you can assign them unique IDs:
-- debounce
-'debounce' is very useful in search functions, where you only want the API to be called when the user finishes typing. If the user types "Jonny", you will have 5 searches in the APIs, by the letter J, o, n, n, and y. With Get this does not happen, because you will have a "debounce" Worker that will only be triggered at the end of typing.
+```dart
+GetBuilder<Controller>(
+  id: 'text'
+  init: Controller(), // use it only first time on each controller
+  builder: (_) => Text(
+    '${Get.find<Controller>().counter}', //here
+  ),
+),
+```
-- interval
-'interval' is different from the debouce. debouce if the user makes 1000 changes to a variable within 1 second, he will send only the last one after the stipulated timer (the default is 800 milliseconds). Interval will instead ignore all user actions for the stipulated period. If you send events for 1 minute, 1000 per second, debounce will only send you the last one, when the user stops strafing events. interval will deliver events every second, and if set to 3 seconds, it will deliver 20 events that minute. This is recommended to avoid abuse, in functions where the user can quickly click on something and get some advantage (imagine that the user can earn coins by clicking on something, if he clicked 300 times in the same minute, he would have 300 coins, using interval, you you can set a time frame for 3 seconds, and even then clicking 300 or a thousand times, the maximum he would get in 1 minute would be 20 coins, clicking 300 or 1 million times). The debounce is suitable for anti-DDos, for functions like search where each change to onChange would cause a query to your api. Debounce will wait for the user to stop typing the name, to make the request. If it were used in the coin scenario mentioned above, the user would only win 1 coin, because it is only executed, when the user "pauses" for the established time.
+And update it this form:
-## Mixing the two state managers
+```dart
+update(['text']);
+```
-Some people opened a feature request, as they wanted to use only one type of reactive variable, and the other mechanics, and needed to insert an Obx into a GetBuilder for this. Thinking about it MixinBuilder was created. It allows both reactive changes by changing ".obs" variables, and mechanical updates via update(). However, of the 4 widgets he is the one that consumes the most resources, since in addition to having a Subscription to receive change events from his children, he subscribes to the update method of his controller.
+You can also impose conditions for the update:
-Extending GetxController is important, as they have life cycles, and can "start" and "end" events in their onInit() and onClose() methods. You can use any class for this, but I strongly recommend you use the GetxController class to place your variables, whether they are observable or not.
+```dart
+update(['text'], counter < 10);
+```
+
+GetX does this automatically and only reconstructs the widget that uses the exact variable that was changed, if you change a variable to the same as the previous one and that does not imply a change of state , GetX will not rebuild the widget to save memory and CPU cycles (3 is being displayed on the screen, and you change the variable to 3 again. In most state managers, this will cause a new rebuild, but with GetX the widget will only is rebuilt again, if in fact his state has changed).
 ## GetBuilder vs GetX vs Obx vs MixinBuilder