Node.js-Tutorial zur Entwicklung von Kommandozeilenprogrammen

Wie einfach eine Programmiersprache zu verwenden ist, hängt weitgehend von ihrer Fähigkeit ab, Kommandozeilenprogramme zu entwickeln.

Da Node.js heute zu den beliebtesten Entwicklungswerkzeugen gehört, ist es eine Fähigkeit, die Webentwickler beherrschen sollten, zu wissen, wie man Node.js zur Entwicklung von Kommandozeilenprogrammen verwendet.

Node.js 命令行程序开发教程

Kürzlich veröffentlichte der Npm-Blog eine Reihe vonArtikeln, die meiner Meinung nach sehr gut geschrieben sind. Unten folgt ein Tutorial, das ich auf ihrer Grundlage erweitert habe; es sollte die derzeit beste verfügbare Lösung sein.

1. Ausführbare Skripte

Beginnen wir mit dem einfachsten Fall.

Schreiben Sie zunächst ein ausführbares Skript namens hello mit JavaScript.

#!/usr/bin/env node
console.log('hello world');

Ändern Sie dann die Berechtigungen von hello.

$ chmod 755 hello

Jetzt kann hello ausgeführt werden.

$ ./hello
hello world

Wenn Sie das Pfadpräfix vor hello entfernen möchten, können Sie den Pfad von hello zur Umgebungsvariable PATH hinzufügen. Ein besserer Ansatz ist jedoch, eine package.json im aktuellen Verzeichnis mit dem folgenden Inhalt zu erstellen.

{
  "name": "hello",
  "bin": {
    "hello": "hello"
  }
}

Führen Sie dann den Befehl npm link aus.

$ npm link

Wenn du hello jetzt erneut ausführst, musst du den Pfad nicht mehr eingeben.

$ hello
hello world

2. Grundlegende Syntax für Kommandozeilenargumente

Kommandozeilenargumente können über die Systemvariable process.argv abgerufen werden.

#!/usr/bin/env node
console.log('hello ', process.argv[2]);

Beim Ausführen fügst du die Argumente einfach direkt nach der Skriptdatei hinzu.

$ ./hello tom
hello tom

3. Prozesse erstellen

Skripte können über das child_process-Modul Kindprozesse erstellen, um Unix-Systembefehle auszuführen.

#!/usr/bin/env node
var name = process.argv[2];
var exec = require('child_process').exec;

var child = exec('echo hello ' + name, function(err, stdout, stderr) {
  if (err) throw err;
  console.log(stdout);
});

Die Verwendung ist wie folgt.

$ ./hello tom
hello tom

4. Das shelljs-Modul

shelljsDieses Modul kapselt child_process neu, wodurch das Aufrufen von Systembefehlen bequemer wird. Es muss vor der Verwendung installiert werden.

npm install --save shelljs

Dann schreibe das Skript neu.

#!/usr/bin/env node
var name = process.argv[2];
var shell = require("shelljs");

shell.exec("echo hello " + name);

Der obige Code verwendet den lokalen Modus von shelljs, der Shell-Befehle über die exec-Methode ausführt. Es gibt auch einen globalen Modus, mit dem Shell-Befehle direkt im Skript geschrieben werden können.

require('shelljs/global');

if (!which('git')) {
  echo('Sorry, this script requires git');
  exit(1);
}

mkdir('-p', 'out/Release');
cp('-R', 'stuff/*', 'out/Release');

cd('lib');
ls('*.js').forEach(function(file) {
  sed('-i', 'BUILD_VERSION', 'v0.1.2', file);
  sed('-i', /.*REMOVE_THIS_LINE.*/n/, '', file);
  sed('-i', /.*REPLACE_LINE_WITH_MACRO.*/n/, cat('macro.js'), file);
});
cd('..');

if (exec('git commit -am "Auto-commit"').code !== 0) {
  echo('Error: Git commit failed');
  exit(1);
}

5. Das yargs-Modul

shelljs löst nur, wie man Shell-Befehle aufruft, während das yargs-Modul sich damit befasst, wie man Kommandozeilenargumente verarbeitet. Es muss außerdem installiert werden.

$ npm install --save yargs

Das yargs-Modul bietet ein argv-Objekt zum Lesen von Kommandozeilenargumenten. Bitte sehen Sie das umgeschriebene hello.

#!/usr/bin/env node
var argv = require('yargs').argv;

console.log('hello ', argv.name);

Bei der Verwendung funktioniert jede der folgenden beiden Verwendungsweisen.

$ hello --name=tom
hello tom

$ hello --name tom
hello tom

Wenn Sie argv.name in argv.n ändern, können Sie die einbuchstabige Kurzform des Parameters verwenden.

$ hello -n tom
hello tom

Sie können die alias-Methode verwenden, um anzugeben, dass name ein Alias für n ist.

#!/usr/bin/env node
var argv = require('yargs')
  .alias('n', 'name')
  .argv;

console.log('hello ', argv.n);

Auf diese Weise können sowohl kurze als auch lange Parameter verwendet werden.

$ hello -n tom
hello tom
$ hello --name tom
hello tom

Das argv-Objekt hat eine Unterstrich-Eigenschaft (_), die Argumente abruft, die nicht mit einem Bindestrich beginnen.

#!/usr/bin/env node
var argv = require('yargs').argv;

console.log('hello ', argv.n);
console.log(argv._);

Die Verwendung ist wie folgt.

$ hello A -n tom B C
hello  tom
[ 'A', 'B', 'C' ]

6. Konfigurieren von Kommandozeilenargumenten

Das yargs-Modul bietet auch 3 Methoden zum Konfigurieren von Kommandozeilenargumenten.

demand: ob es erforderlich ist
default: Standardwert
describe: Hinweis

#!/usr/bin/env node
var argv = require('yargs')
  .demand(['n'])
  .default({n: 'tom'})
  .describe({n: 'your name'})
  .argv;

console.log('hello ', argv.n);

Der obige Code gibt an, dass der Parameter n nicht weggelassen werden kann, den Standardwert tom hat und eine Zeile mit Beschreibung bereitstellt.

Die Methode options ermöglicht es, all diese Konfigurationen in ein einziges Objekt zu schreiben.

#!/usr/bin/env node
var argv = require('yargs')
  .option('n', {
    alias : 'name',
    demand: true,
    default: 'tom',
    describe: 'your name',
    type: 'string'
  })
  .argv;

console.log('hello ', argv.n);

Manchmal benötigen bestimmte Parameter keinen Wert und fungieren nur als Schalter. In diesem Fall können Sie die Methode boolean verwenden, um anzugeben, dass diese Parameter boolesche Werte zurückgeben.

#!/usr/bin/env node
var argv = require('yargs')
  .boolean(['n'])
  .argv;

console.log('hello ', argv.n);

Im obigen Code gibt der Parameter n immer einen booleschen Wert zurück. Die Verwendung ist wie folgt.

$ hello
hello  false
$ hello -n
hello  true
$ hello -n tom
hello  true

Die Methode boolean kann auch als Eigenschaft im options-Objekt geschrieben werden.

#!/usr/bin/env node
var argv = require('yargs')
  .option('n', {
    boolean: true
  })
  .argv;

console.log('hello ', argv.n);

7. Hilfeinformationen

Das Modul yargs bietet die folgenden Methoden, um Hilfeinformationen zu generieren.

usage: Verwendungsformat
example: stellt Beispiele bereit
help: zeigt Hilfeinformationen an
epilog: erscheint am Ende der Hilfeinformationen

#!/usr/bin/env node
var argv = require('yargs')
  .option('f', {
    alias : 'name',
    demand: true,
    default: 'tom',
    describe: 'your name',
    type: 'string'
  })
  .usage('Usage: hello [options]')
  .example('hello -n tom', 'say hello to Tom')
  .help('h')
  .alias('h', 'help')
  .epilog('copyright 2015')
  .argv;

console.log('hello ', argv.n);

Das Ausführungsergebnis ist wie folgt.

$ hello -h

Usage: hello [options]

Options:
  -f, --name  your name [string] [required] [default: "tom"]
  -h, --help  Show help [boolean]

Examples:
  hello -n tom  say hello to Tom

copyright 2015

8. Unterbefehle

Das yargs-Modul ermöglicht außerdem das Festlegen von Unterbefehlen im Git-Stil über die command-Methode.

#!/usr/bin/env node
var argv = require('yargs')
  .command("morning", "good morning", function (yargs) {
    console.log("Good Morning");
  })
  .command("evening", "good evening", function (yargs) {
    console.log("Good Evening");
  })
  .argv;

console.log('hello ', argv.n);

Die Verwendung ist wie folgt.

$ hello morning -n tom
Good Morning
hello tom

Sie können diese Funktion mit dem shellojs-Modul kombinieren.

#!/usr/bin/env node
require('shelljs/global');
var argv = require('yargs')
  .command("morning", "good morning", function (yargs) {
    echo("Good Morning");
  })
  .command("evening", "good evening", function (yargs) {
    echo("Good Evening");
  })
  .argv;

console.log('hello ', argv.n);

Jeder Unterbefehl hat oft seine eigenen Argumente, daher müssen Sie sie separat in der Callback-Funktion angeben. In der Callback-Funktion müssen Sie zunächst die reset-Methode verwenden, um das yargs-Objekt zurückzusetzen.

#!/usr/bin/env node
require('shelljs/global');
var argv = require('yargs')
  .command("morning", "good morning", function (yargs) {  
    echo("Good Morning");
    var argv = yargs.reset()
      .option("m", {
        alias: "message",
        description: "provide any sentence"
      })
      .help("h")
      .alias("h", "help")
      .argv;

    echo(argv.m);
  })
  .argv;

Die Verwendung ist wie folgt.

$ hello morning -m "Are you hungry?"
Good Morning
Are you hungry?

9. Sonstiges

(1) Rückgabewert

Nach Unix-Tradition gibt ein Programm bei Erfolg 0 zurück, andernfalls gibt es 1 zurück.

if (err) {
  process.exit(1);
} else {
  process.exit(0);
}

(2) Umleitung

Unix ermöglicht Programmen, Daten mithilfe von Pipes umzuleiten.

$ ps aux | grep 'node'

Skripte können umgeleitete Daten erhalten, indem sie auf das data-Event auf der Standardeingabe warten.

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(data) {
  process.stdout.write(data);
});

So wird es verwendet:

$ echo 'foo' | ./hello
hello foo

(3) Systemsignale

Das Betriebssystem kann Signale an laufende Prozesse senden, und das process-Objekt kann Signal-Events überwachen.

process.on('SIGINT', function () {
  console.log('Got a SIGINT');
  process.exit(0);
});

Die Methode zum Senden von Signalen lautet wie folgt.

$ kill -s SIGINT [process_id]

Originalartikel: http://www.ruanyifeng.com/blog/2015/05/command-line-with-node.html