Erste Schritte mit dem GetX-Paket in Flutter-Anwendungen

Flutter ist eine der schnellsten Möglichkeiten, wirklich plattformübergreifende native Anwendungen zu erstellen. Es bietet Funktionen, die es dem Entwickler ermöglichen, ein wirklich schönes UI-Erlebnis für seine Benutzer zu erstellen.

In den meisten Fällen sind jedoch viele Boilerplates erforderlich, um Dinge wie die Navigation zu Bildschirmen, die Zustandsverwaltung und das Anzeigen von Warnungen zu erreichen. Diese Boilerplates neigen dazu, die Entwicklungseffizienz von Entwicklern zu verlangsamen, die versuchen, Funktionen zu erstellen und ihre Fristen einzuhalten.

Nehmen Sie zum Beispiel die Boilerplate, die benötigt wird, um zu einem Bildschirm in einer Flutter-Anwendung zu navigieren. Angenommen, Sie möchten zu einem Bildschirm namens AboutScreen navigieren. du musst schreiben:

 Navigator.push( context, MaterialPageRoute(builder: (context) => AboutScreen()), );

Es wäre effizienter und entwicklerfreundlicher, Folgendes zu tun:

 Get.to(AboutScreen());

Wenn Sie in Flutter zur vorherigen Seite zurücknavigieren müssen, müssen Sie Folgendes schreiben:

 Navigator.pop(context);

Sie werden feststellen, dass wir für etwas so Alltägliches wie das Navigieren zwischen Bildschirmen immer von der Kontexteigenschaft abhängig sind. Was wäre, wenn wir stattdessen so etwas tun könnten:

 Get.back();

Die obigen Beispiele sind einige der Möglichkeiten, wie die Anwendungsentwicklung in Flutter verbessert werden kann, um mit weniger Boilerplate intuitiver und effizienter zu sein. Wenn Sie Einfachheit bevorzugen und beim Aufbau von Funktionen und Ideen effizient sind, wird Sie das Get-Paket in Flutter interessieren.

Was ist GetX

Get oder GetX ist ein schnelles, stabiles, extra leichtes Framework zum Erstellen von Flutter-Anwendungen.

GetX wird sofort einsatzbereit mit leistungsstarker Zustandsverwaltung, intelligenter Abhängigkeitsinjektion und Routenverwaltung auf einfache und praktische Weise geliefert.

GetX zielt darauf ab, Boilerplates zu minimieren und gleichzeitig eine einfache und intuitive Syntax bereitzustellen, die Entwickler beim Erstellen ihrer Anwendungen verwenden können. Der Kern von GetX sind diese 3 Prinzipien:

• Leistung
  GetX konzentriert sich auf die Leistung Ihrer Anwendung, indem es seine Funktionen implementiert, um so wenig Ressourcen wie möglich zu verbrauchen.
• Produktivität
  GetX möchte, dass Entwickler seine Funktionen nutzen, um so schnell wie möglich produktiv zu sein. Dies geschieht durch den Einsatz von leicht zu merkender Syntax und Praktiken. Beispielsweise sollte sich der Entwickler im Allgemeinen darum kümmern, Controller aus dem Speicher zu entfernen, aber GetX bietet standardmäßig eine intelligente Verwaltung, die Controller in Ihrer Anwendung überwacht und sie entfernt, wenn sie nicht standardmäßig verwendet werden.
• Organisation
  GetX ermöglicht die Entkopplung von Ansicht, Präsentationslogik, Geschäftslogik, Abhängigkeitsinjektion und Navigation in Ihrer Flutter-Anwendung. Sie benötigen keinen Kontext, um zwischen Routen zu navigieren, sodass Sie für die Navigation nicht auf den Widget-Baum angewiesen sind. Sie benötigen keinen Kontext, um über ein inheritedWidget auf Ihre Controller/Blocs zuzugreifen, sodass Sie Ihre Präsentationslogik und Geschäftslogik vollständig von Ihrer Ansichtsebene entkoppeln können. Sie müssen Ihre Controllers/Models/Blocs-Klassen nicht über Multiprovider in Ihren Widget-Baum einfügen, da GetX seine eigene Abhängigkeitsinjektionsfunktion verwendet und das DI vollständig von seiner Ansicht entkoppelt.

Funktionen von GetX

GetX enthält einige Funktionen, die Sie bei Ihrer täglichen App-Entwicklung in Flutter benötigen. Schauen wir sie uns an:

Staatsverwaltung

Eines der Flaggschiff-Features von GetX ist die intuitive Zustandsverwaltungsfunktion. Die Zustandsverwaltung in GetX kann mit wenig oder ohne Boilerplate erreicht werden.

Routenverwaltung

GetX bietet eine API zum Navigieren innerhalb der Flutter-Anwendung. Diese API ist einfach und benötigt weniger Code.

Abhängigkeitsverwaltung

GetX bietet eine intelligente Möglichkeit, Abhängigkeiten in Ihrer Flutter-Anwendung wie die View-Controller zu verwalten. GetX entfernt jeden Controller, der gerade nicht verwendet wird, aus dem Speicher. Dies war eine Aufgabe, die Sie als Entwickler manuell erledigen müssen, aber GetX erledigt das automatisch für Sie.

Internationalisierung

GetX bietet standardmäßig i18n, mit dem Sie Anwendungen mit Unterstützung für verschiedene Sprachen schreiben können.

Validierung

GetX bietet Validierungsmethoden zur Durchführung der Eingabevalidierung in Ihren Flutter-Anwendungen. Dies ist sehr praktisch, da Sie kein separates Validierungspaket installieren müssen.

Lager

GetX bietet einen schnellen, besonders leichten und synchronen Schlüsselwert im Speicher, der Daten bei jedem Vorgang auf der Festplatte sichert. Es ist vollständig in Dart geschrieben und lässt sich leicht in das Kernpaket von GetX integrieren.

Erste Schritte mit GetX

Nachdem Sie nun gesehen haben, was GetX ist und welche Funktionen und Vorteile es bietet, sehen wir uns an, wie Sie es in Ihrer Anwendung einrichten. Wir werden eine Demo-App erstellen, um die meisten der erwähnten Funktionen in Aktion zu sehen. Lass uns anfangen.

Erstellen Sie eine brandneue Flutter-Anwendung

Wir beginnen mit der Erstellung einer brandneuen Flutter-Anwendung über die Flutter-CLI. Ich gehe davon aus, dass Ihre Maschine bereits für die Anwendungsentwicklung mit Flutter eingerichtet ist. Also laufen wir:

 flutter create getx_demo

Dadurch wird der grundlegende Code generiert, der für eine Flutter-Anwendung benötigt wird. Öffnen Sie als Nächstes das Projekt, das Sie gerade erstellt haben, in einem Editor Ihrer Wahl (für diesen Artikel verwenden wir VS Code). Wir führen dann das Projekt aus, um sicherzustellen, dass es ordnungsgemäß funktioniert (stellen Sie sicher, dass entweder ein Gerät angeschlossen ist oder ein Emulator/Simulator läuft).

Wenn die Anwendung ausgeführt wird, sehen Sie die standardmäßige Zähleranwendung, die Flutter für Sie bereitstellt, wenn Sie eine neue Flutter-Anwendung erstellen. Was wir tun werden, ist, dieselbe Zähleranwendung zu implementieren, aber mit GetX, um den Status der App (die Zählvariable) zu verwalten.

Wir beginnen damit, main.dart zu löschen und nur dieses Code-Snippet zu hinterlassen:

 # main.dart import 'package:flutter/material.dart'; void main() { runApp(MyApp()); } class MyApp extends StatelessWidget { // This widget is the root of your application. @override Widget build(BuildContext context) { return MaterialApp( title: 'Flutter Demo', theme: ThemeData( primarySwatch: Colors.blue, visualDensity: VisualDensity.adaptivePlatformDensity, ), home: MyHomePage(title: 'Flutter Demo Home Page'), ); } }

Inzwischen wäre unsere Anwendung kaputt, da es kein MyHomePage Widget mehr gibt. Lassen Sie uns das beheben. Mit GetX brauchen wir keine Stateful Widgets und auch unsere UI lässt sich klar von unserer Businesslogik trennen. Also werden wir zwei Verzeichnisse innerhalb von lib/ erstellen. Diese Verzeichnisse sind:

Lassen Sie uns ein MyHomePage -Widget in views/ erstellen. Der Name der Datei my_home_page.dart . Nachdem Sie es erstellt haben, fügen Sie das folgende Code-Snippet hinzu:

 import 'package:flutter/material.dart'; class MyHomePage extends StatelessWidget { final String title; MyHomePage({this.title}); @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text(title), ), body: Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Text( 'You have pushed the button this many times:', ), Text( '0', style: Theme.of(context).textTheme.headline4, ), ], ), ), floatingActionButton: FloatingActionButton( onPressed: null, tooltip: 'Increment', child: Icon(Icons.add), ), ); } }

Jetzt haben wir das MyHomePage -Widget, importieren wir es in main.dart . Fügen Sie die import-Anweisung oben in main.dart unter import 'package:flutter/material.dart';

 import './views/my_home_page.dart';

Jetzt sollte Ihre main.dart -Datei so aussehen:

 import 'package:flutter/material.dart'; import './views/my_home_page.dart'; void main() { runApp(MyApp()); } class MyApp extends StatelessWidget { // This widget is the root of your application. @override Widget build(BuildContext context) { return MaterialApp( title: 'Flutter Demo', theme: ThemeData( primarySwatch: Colors.blue, visualDensity: VisualDensity.adaptivePlatformDensity, ), home: MyHomePage(title: 'Flutter Demo Home Page'), ); } }

Wenn Sie Ihre Anwendung jetzt speichern, sollten alle Fehler behoben sein und die App ausgeführt werden. Aber Sie werden feststellen, dass der Zähler nicht aktualisiert wird, wenn Sie erneut auf die Schaltfläche klicken. Wenn Sie sich den Code views/my_home_page.dart , sehen Sie, dass wir nur 0 als Wert des Text-Widgets fest codieren und null an den onPressed Handler der Schaltfläche übergeben. Lassen Sie uns GetX in den Mix einbringen, um die Anwendung wieder funktionsfähig zu machen.

GetX installieren

Gehen Sie zur Installationsseite für GetX auf pub.dev und Sie sehen die Codezeile, die Sie kopieren müssen, um sie in Ihre pubspec.yml -Datei zu kopieren, um GetX zu installieren. Zum Zeitpunkt der Erstellung dieses Artikels ist die aktuelle Version von GetX 3.23.1. Also kopieren wir die Zeile:

 get: ^3.23.1

Und fügen Sie es dann im Abschnitt " dependencies " unserer Datei " pubspec.yml " ein. Wenn Sie die Datei speichern, sollte get automatisch für Sie installiert werden. Oder Sie können manuell in Ihrem Terminal ausführen.

 flutter pub get

Der Abhängigkeitsabschnitt Ihrer pubspec.yml -Datei sollte wie folgt aussehen:

 dependencies: flutter: sdk: flutter get: ^3.23.1

GetxController

Wir haben erwähnt, dass Sie mit GetX die Benutzeroberfläche Ihrer Anwendung von der Logik trennen können. Dazu wird eine GetxController -Klasse bereitgestellt, die Sie erben können, um Controller-Klassen für die Ansichten Ihrer Anwendung zu erstellen. Für unsere aktuelle App haben wir eine Ansicht, also erstellen wir einen Controller für diese Ansicht. Gehen Sie zum Verzeichnis controllers/ und erstellen Sie eine Datei mit dem Namen my_home_page_controller.dart . Dies enthält den Controller für die MyHomePage Ansicht.

Nachdem Sie die Datei erstellt haben, importieren Sie zuerst das GetX-Paket, indem Sie dies oben in der Datei hinzufügen:

 import 'package:get/get.dart';

Dann erstellen Sie darin eine Klasse namens MyHomePageController und erweitern die Klasse GetxController . So sollte die Datei aussehen:

 import 'package:get/get.dart'; class MyHomePageController extends GetxController {}

Lassen Sie uns den Zählstatus zu der von uns erstellten Klasse hinzufügen.

 final count = 0;

In GetX eine Variable beobachtbar zu machen – das bedeutet, dass andere Teile unserer Anwendung, die davon abhängig sind, benachrichtigt werden, wenn sie sich ändert. Dazu müssen wir einfach .obs zur Variableninitialisierung hinzufügen. Für unsere obige count fügen wir .obs zu 0 hinzu. Die obige Deklaration sieht nun also so aus:

 final count = 0.obs;

So sieht unsere Controller-Datei im Moment aus:

 import 'package:get/get.dart'; class MyHomePageController extends GetxController { final count = 0.obs; }

Zum Abschluss des MyHomePageController implementieren wir die increment -Methode. Dies ist der Ausschnitt, um das zu tun:

 increment() => count.value++;

Sie werden feststellen, dass wir .value zur count-Variablen hinzufügen mussten, um sie zu erhöhen. Wir haben dies getan, weil das Hinzufügen von .obs zu einer Variablen sie zu einer beobachtbaren Variablen macht, und um den Wert einer beobachtbaren Variablen zu erhalten, tun Sie dies aus der Eigenschaft value .

Damit sind wir mit dem Controller fertig. Wenn sich nun der Wert von count ändert, wird jeder Teil unserer Anwendung, der ihn verwendet, automatisch aktualisiert.

Wir werden jetzt zu unserer Ansicht gehen und sie über den gerade erstellten Controller informieren. Wir tun dies, indem wir die Controller-Klasse mit der GetX-Abhängigkeitsverwaltungsfunktion instanziieren. Dadurch wird sichergestellt, dass unser Controller nicht mehr im Speicher ist, wenn er nicht mehr benötigt wird.

Importieren Sie in views/my_home_page.dart das Get-Paket und auch den von Ihnen erstellten Controller wie folgt:

 import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart';

Dann werden wir innerhalb der MyHomePage -Klasse den MyHomePageController instanziieren:

 final MyHomePageController controller = Get.put(MyHomePageController());

Jetzt haben wir eine Instanz des MyHomePageController , wir können sowohl die Zustandsvariable als auch die Methode verwenden. Beginnend mit dem Zustand in GetX, um einen Teil Ihrer Benutzeroberfläche zu markieren, der neu erstellt werden soll, wenn sich eine Zustandsvariable ändert, werden Sie diesen Teil mit dem Obx Widget umschließen. GetX bietet dafür andere Möglichkeiten, aber diese Methode ist viel einfacher und sauberer.

Für unsere Zählanwendung möchten wir, dass das Text-Widget mit der aktuellen Zählung aktualisiert wird. Also werden wir das Text-Widget mit dem Obx Widget wie folgt umschließen:

 Obx(() => Text('0',style: Theme.of(context).textTheme.headline4,),)

Als Nächstes ersetzen wir die statische Zeichenfolge 0 wie folgt durch die Zählvariable aus dem MyHomePageController :

 Obx(() => Text('${controller.count.value}', ,style: Theme.of(context).textTheme.headline4,),)

Zuletzt rufen wir die Increment-Methode auf, wenn der floatingActionButton wie folgt gedrückt wird:

 floatingActionButton: FloatingActionButton( onPressed: controller.increment, tooltip: 'Increment', child: Icon(Icons.add), ),

Insgesamt sollte unsere MyHomePage Ansichtsdatei nun so aussehen:

 import 'package:flutter/material.dart'; import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart'; class MyHomePage extends StatelessWidget { final String title; final MyHomePageController controller = Get.put(MyHomePageController()); MyHomePage({this.title}); @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text(title), ), body: Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Text( 'You have pushed the button this many times:', ), Obx( () => Text( '${controller.count.value}', style: Theme.of(context).textTheme.headline4, ), ) ], ), ), floatingActionButton: FloatingActionButton( onPressed: controller.increment, tooltip: 'Increment', child: Icon(Icons.add), ), ); } }

Wenn Sie Ihre Anwendung speichern oder erneut ausführen, sollte die Zähler-App so funktionieren wie bei der ersten Erstellung der Anwendung.

Ich glaube, Sie haben gesehen, wie intuitiv die Zustandsverwaltung mit GetX ist, wir mussten nicht viele Textbausteine ​​schreiben, und diese Einfachheit wird deutlicher, wenn Ihre Anwendung komplexer wird. Sie werden auch feststellen, dass unsere Ansicht keinen Zustand enthält oder beibehält, sodass es sich um ein zustandsloses Widget handeln kann. Das Gehirn der Ansicht wiederum ist jetzt eine Controller-Klasse, die den Zustand für die Ansicht und die Methoden enthält.

Navigation in GetX

Wir haben die Zustandsverwaltung in GetX gesehen. Sehen wir uns nun an, wie GetX die Navigation in Ihrer Anwendung unterstützt. Um die Navigationsfunktion von GetX zu aktivieren, müssen Sie nur eine Änderung in main.dart , nämlich das MaterialApp -Widget in ein GetMaterialApp Widget umwandeln. Dazu importieren wir zunächst Get in the top of main.dart

 import 'package:get/get.dart';

Dann nehmen wir die Änderung an MaterialApp vor, sodass unsere main.dart -Datei jetzt so aussieht:

 import 'package:flutter/material.dart'; import 'package:get/get.dart'; import './views/my_home_page.dart'; void main() { runApp(MyApp()); } class MyApp extends StatelessWidget { // This widget is the root of your application. @override Widget build(BuildContext context) { return GetMaterialApp( title: 'Flutter Demo', theme: ThemeData( primarySwatch: Colors.blue, visualDensity: VisualDensity.adaptivePlatformDensity, ), home: MyHomePage(title: 'Flutter Demo Home Page'), ); } }

Jetzt wurde unsere App so eingerichtet, dass sie die GetX-Navigation unterstützt. Um dies zu testen, erstellen wir eine weitere Ansicht im Verzeichnis views/ . Wir werden dies auf about_page.dart und es wird den folgenden Code enthalten:

 import 'package:flutter/material.dart'; import 'package:get/get.dart'; import '../controllers/my_home_page_controller.dart'; class AboutPage extends StatelessWidget { final MyHomePageController controller = Get.put(MyHomePageController()); @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text('About GetX'), ), body: Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: <Widget>[ Padding( padding: const EdgeInsets.all(16.0), child: Text( 'GetX is an extra-light and powerful solution for Flutter. It combines high performance state management, intelligent dependency injection, and route management in a quick and practical way.', ), ), ], ), ), ); } }

Wir gehen dann zu MyHomePage und fügen eine Schaltfläche hinzu, die uns, wenn sie gedrückt wird, zur AboutPage navigiert. Wie so. Die Schaltfläche sollte sich unter dem Obx-Widget befinden. Hier ist es:

 FlatButton(onPressed: () {}, child: Text('About GetX'))

Wir müssen auch die AboutPage über der MyHomePage -Datei importieren:

 import './about_page.dart';

Um GetX zu sagen, dass es zur AboutPage navigieren soll, brauchen wir nur eine Codezeile, nämlich:

 Get.to(AboutPage());

Fügen wir das dem onPressed Callback des FlatButton Widgets wie folgt hinzu:

 FlatButton( onPressed: () { Get.to(AboutPage()); }, child: Text('About GetX'))

Wenn Sie Ihre Bewerbung jetzt speichern, können Sie jetzt zur AboutPage navigieren.

Sie können auch die MyHomePage Ansicht durch die AboutPage ersetzen, damit der Benutzer nicht zur vorherigen Seite zurücknavigieren kann, indem er die Zurück-Taste des Geräts drückt. Dies ist nützlich für Bildschirme wie Anmeldebildschirme. Ersetzen Sie dazu den Inhalt des onPressed -Handlers durch den folgenden Code:

 Get.off(AboutPage());

Dadurch wird die Ansicht MyHomePage und durch AboutPage .

Jetzt, da wir zur AboutPage navigieren können, denke ich, dass es nicht so schlimm sein wird, zu MyHomePage zu können, um dies zu tun, werden wir eine Schaltfläche in AboutPage nach dem Padding-Widget hinzufügen und in seinem onPressed werden wir einen Anruf tätigen zu Get.back() um zurück zur MyHomePage zu navigieren:

 FlatButton( onPressed: () { Get.back(); }, child: Text('Go Home') )

Imbissbude

Um in Flutter konventionell eine Snackbar anzuzeigen, müssen Sie etwa Folgendes schreiben:

 final snackBar = SnackBar(content: Text('Yay! A SnackBar!')); // Find the Scaffold in the widget tree and use it to show a SnackBar. Scaffold.of(context).showSnackBar(snackBar);

Sie können beobachten, dass wir immer noch von der context abhängig sind. Mal sehen, wie wir dies in GetX erreichen können. Gehen Sie in die MyHomePage Ansicht und fügen Sie ein weiteres FlatButton Widget unter der zuletzt hinzugefügten Schaltfläche hinzu. Hier ist das Snippet für den Button:

 FlatButton( onPressed: () { // TODO: Implement Snackbar }, child: Text('Show Snackbar'))

Zeigen wir die Nachricht „Yay! Fantastische GetX-Snackbar'. Fügen Sie innerhalb der onPressed-Handler-Funktion die folgende Codezeile hinzu:

 Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar');

Führen Sie Ihre Anwendung aus und wenn Sie auf die Schaltfläche „Snackbar anzeigen“ klicken, sehen Sie eine Snackbar über Ihrer Anwendung!

Sehen Sie, wie wir die Anzahl der Zeilen reduziert haben, die zum Anzeigen einer Snackbar in einer Flutter-Anwendung erforderlich sind? Lassen Sie uns die Snackbar noch weiter anpassen. Lassen Sie es unten in der App erscheinen. Ändern Sie den Code wie folgt:

 Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar',snackPosition:SnackPosition.BOTTOM, );

Speichern Sie Ihre Anwendung und führen Sie sie aus. Die Snackbar wird nun unten in der Anwendung angezeigt. Wie wäre es, wenn wir die Hintergrundfarbe der Snackbar ändern, da sie im Moment transparent ist? Wir ändern es in eine amberAccent -Farbe aus der Colors -Klasse in Flutter. Aktualisieren Sie den Code wie folgt:

 Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar',snackPosition:SnackPosition.BOTTOM, backgroundColor: Colors.amberAccent );

Insgesamt sollte der Button-Code so aussehen:

 FlatButton( onPressed: () { Get.snackbar('GetX Snackbar', 'Yay! Awesome GetX Snackbar', snackPosition: SnackPosition.BOTTOM, backgroundColor: Colors.amberAccent); }, child: Text('Show Snackbar'))

Dialog

GetX bietet eine einfache Methode zum Erstellen von AlertDialog in Flutter. Sehen wir es uns in Aktion an. Erstellen Sie eine weitere Schaltfläche unter der vorherigen:

 FlatButton( onPressed: () { // TODO: Show alert dialog }, child: Text('Show AlertDialog'))

Rufen wir GetX auf, um einen Alarmdialog anzuzeigen:

 Get.defaultDialog();

Dadurch wird ein standardmäßiger Warndialog angezeigt, der durch Antippen außerhalb des Dialogs geschlossen werden kann. Sie können sehen, wie wir in einer Codezeile einen funktionierenden Warndialog haben. Lassen Sie es uns ein wenig anpassen. Ändern wir den Titel und die Nachricht:

 Get.defaultDialog( title: 'GetX Alert', middleText: 'Simple GetX alert');

Speichern und starten Sie Ihre App und Sie werden die Änderungen sehen, wenn Sie auf die Schaltfläche „AlertDialog anzeigen“ klicken. Wir können Schaltflächen zum Bestätigen und Abbrechen wie folgt hinzufügen:

 Get.defaultDialog( title: 'GetX Alert', middleText: 'Simple GetX alert', textConfirm: 'Okay', confirmTextColor: Colors.amberAccent, textCancel: 'Cancel');

Es gibt viele Möglichkeiten, den GetX-Dialog anzupassen, und die API ist recht intuitiv und einfach.

Fazit

GetX wurde entwickelt, um die Produktivität von Flutter-Entwicklern beim Erstellen von Funktionen zu verbessern. Anstatt nach Boilerplates suchen zu müssen, die für Dinge wie Zustandsverwaltung, Navigationsverwaltung und mehr benötigt werden, bietet GetX eine einfache intuitive API, um diese Aktivitäten ohne Leistungseinbußen durchzuführen. In diesem Artikel erhalten Sie eine Einführung in GetX und erfahren, wie Sie damit beginnen, es in Ihren Flutter-Anwendungen zu verwenden.

• Die Demo finden Sie hier →