Dart Command-line apps

Die Programmiersprache Dart

Dart ist vielseitig. Die Programmiersprache lässt sich natürlich auch für Command-Line Apps verwenden.

Solche Programme werden von der Kommandozeile gestartet. In einer Windows Umgebung zum Beispiel von der PowerShell. Solche Programme mögen altmodisch wirken, haben aber durchaus noch ihre Berechtigung. 

Ein Programmierer kann so für Problemstellungen eine Lösung erstellen, für die es eventuell kein kommerzielles Angebot gibt. Command-Line Apps kommen ohne moderne Benutzerführung aus, bieten aber andere Möglichkeiten. Eine davon ist beim Start des Programmes Werte zu übergeben, die Einfluss auf den Ablauf der Software haben.

Vorbereitung

In diesem Post verwenden wir Visual Studio Code. Es ist kostenfrei und leistungsfähig. Der einfachste Weg ein Dart Command-Line App zu starten, ist ein Grundgerüst bereits vom Editor anlegen zu lassen. :

In unserem Fall empfiehlt sich console-simple. Sie müssen für das neue Projekt dann noch einen File Namen vergeben und einen Ordner auswählen. In diesen wird das Grundgerüst eines einfachen Projekts generiert.

Ihre Seitenleiste in Visual Studio Code sollte so aussehen wie links im Bild. Natürlich mit zum Teil anderen File-und Ordner Namen.
Der Editor hat für uns eine Reihe von Ordnern und Files angelegt. Wirklich wichtig im Moment ist das File im bin Ordner. Es enthält jetzt noch den automatisch generierten Code des Editors, wird aber dann gleich durch unseren Code ersetzt.

Das zweite File von Interesse ist pubspec.yaml.

Dazu muss man wissen, das moderne Programmiersprachen oft von externen Bibliotheken oder Dateien abhängig sind. Es ist logisch, das in Ihren Code nur das eingebunden wird, was Sie für Ihr Programm auch brauchen. In unserem Fall aber müssen wir den Code ergänzen.

Für unseren Code benötigen wir das args Package.  Durch einen einfachen Mausklick auf das pubspec.yaml File öffnet sich dieses im Editor und wir können den Code dementsprechend ergänzen. Mit args: ^2.0.0 weis die Entwicklungsumgebung nun, das der Code den wir erstellen, dieses Packet braucht um zu funktionieren. 

Nach dem Sie die geänderte Datei gespeichert haben, wird der Editor automatisch die benötigen Dateien herunterladen.

Wir löschen im Hauptfile, hier dart_test1.dart, allen Code und beginnen wie folgt:

// @dart=2.9
import 'dart:io';
// ignore: import_of_legacy_library_into_null_safe
import 'package:args/args.dart';

Als erstes importieren wir zwei Bibliotheken. dart:io und args.dart. Wie Sie gesehen haben mussten wir für args.dart Vorbereitungen treffen. dependencies, also Abhängigkeiten, heisst die entsprechende Stelle im pubspec.yaml File. Wieso nicht für dart:io ?

dart:io ist ein Kernbestandteil von Dart. Diese wird nach Bedarf mit eingebunden. Änderungen an dieser Library erfolgen, wenn überhaupt, mit einem generellen Update  für Dart. Der Begriff package kann auch eine Library betreffen, oder sie kann eine exe enthalten. Der Unterschied ist das eine package im Dart Ecosystem verteilt und heruntergeladen werden kann. Wichtiger Unterschied ist auch, das ein Update bei einer package unabhängig von Dart selbst erfolgen kann. Zurück zum Thema. Wir haben jetzt zwei Librarys mit eingebunden. Der nächste Schritt:

ArgResults argResultate;

Oben benutzen wir jetzt zum ersten mal args.dart package. Die Variable argResultate ist vom Typ ArgResults. Unserer Command-Line-App werden wir beim Start ein Argument mitgeben. argResultate ist der Speicherplatz dafür.

void main(List<String> arguments) {
  // eine Liste von Argumenten in String Form
  //
  exitCode = 0; // globaler Exit Code für die Dart VM

  final uebersetzer =
      ArgParser() // ein neuer Parser (Uebersetzer) wird erstellt
        ..addOption('name', abbr: 'n');
  argResultate = uebersetzer.parse(arguments);
  if (argResultate.wasParsed('name')) {
    print('=> ${argResultate['name']}');
  }
}

Oben sehen wir jetzt den Hauptbestandteil des Codes. Aber schauen wir es uns im Detail an:

Eine Command-Line-App ist von Natur aus, darauf ausgelegt beim Start Argumente zu übernehmen. Das ist keine Pflicht, aber eine Möglichkeit.

main(List<String> arguments){...} : In der main Funktion ist festgelegt, das diese Argumente als Liste von Zeichenketten daher kommen müssen.

exitCode = 0; : exitCode ist eine Top Level Eigenschaft der dart:io Library. Wir können sie setzen und verschiedenes damit anzeigen: 0 für Erfolg, 1 für Warnung, 2 für Fehler. In unserem Code hat dies nun keine weitere Bedeutung, In größeren Programmen, die sich auch mit Fehlern auseinander setzen müssen, sieht das anders aus.

final uebersetzer = ArgParser() : ArgParser() generiert das Parser Objekt. Dieses Uebersetzer Objekt wird dann noch um die Möglichkeit einer Option ergänzt mit:

..addOption('name', abbr:'n'); : Die zwei Punkte vor add.. zeigen an das es sich um eine Kaskaden Operation von Dart handelt. Eine Kurzschreibweise. Auf das Resultat von ArgParser() wird ..addOption(...) angewandt.'name" ist die Bezeichnung unseres Arguments. Da könnte auch 'kartoffel' oder 'spinat' stehen.

abbr:'n' : Damit legen wir eine Kurzschreibweise fest, die aus einem Buchstaben besteht, n.

argResultate = uebersetzer.parse(arguments); : Unser Parser übersetzt nun die Argumente die mit der Variable arguments in der main Funktion übernommen wurden. Dabei vergleicht er diese mit denen, die wir gesetzt haben. Im Code oben 'name' und 'n' .

if (argResultate.wasParsed('name')) {...} : Nun könnte man ja unsere Command-Line App mit einem falschen Argument starten. Dieser if(...) Ausdruck würde sich dann zu falsch, false, auflösen. Der restliche Code, der das übergebene Argument ausdruckt, würde nicht ausgeführt.

Wie testen wir jetzt dieses Programm ? Wir wechseln im Terminal ins Verzeichnis unseres Dart Files. Das sollte auch bei Ihnen das bin Verzeichnis sein. 

mit dem Befehl: dart dart_test1.dart --name="IhrName" starten wir das Programm. Natürlich müssen Sie, falls Sie das Beispiel nachvollziehen dart_test1.dart durch Ihre File Bezeichnung ersetzen.

Man beachte --name. Wir haben ja auch eine Kurzschreibweise festgelegt die wir wie folgt starten: dart dart_test.1 -n"IhrName" . Bei der Kurzschreibweise brauchen wir einen anführenden Bindestrich, bei der langen Version zwei. Unten noch einmal der komplette Code. Bis bald !

// @dart=2.9
import 'dart:io';
// ignore: import_of_legacy_library_into_null_safe
import 'package:args/args.dart';

ArgResults argResultate;

void main(List<String> arguments) {
  // eine Liste von Argumenten in String Form
  //
  exitCode = 0; // globaler Exit Code für die Dart VM

  final uebersetzer =
      ArgParser() // ein neuer Parser (Uebersetzer) wird erstellt
        ..addOption('name', abbr: 'n');
  argResultate = uebersetzer.parse(arguments);
  if (argResultate.wasParsed('name')) {
    print('=> ${argResultate['name']}');
  }
} // der Code verwendet Dart 2.9 um Konflikte mit der null safety und Bibliotheken zu vermeiden