Was ist der Zweck eines Befehls, der nichts tut, nur ein Kommentarführer ist, sondern tatsächlich eine in sich selbst eingebaute Shell ist?

Es ist langsamer als das Einfügen eines Kommentars in Ihre Skripte um etwa 40% pro Anruf, was wahrscheinlich stark von der Größe des Kommentars abhängt. Die einzigen möglichen Gründe, die ich dafür sehen kann, sind folgende:

# poor man's delay function
for ((x=0;x<100000;++x)) ; do : ; done

# inserting comments into string of commands
command ; command ; : we need a comment in here for some reason ; command

# an alias for `true' (lazy programming)
while : ; do command ; done

Ich denke, was ich wirklich suche, ist, welche historische Anwendung es gehabt haben könnte.

Historisch gesehen , haben Bourne - Shells nicht haben trueund falseals integrierte Befehle. truewurde stattdessen einfach auf :und falseauf so etwas ausgerichtet let 0.

:ist etwas besser als truefür die Portabilität auf alte Muscheln aus Bourne. Betrachten Sie als einfaches Beispiel, dass Sie weder den !Pipeline-Operator noch den ||Listen-Operator haben (wie dies bei einigen alten Bourne-Shells der Fall war). Damit bleibt die elseKlausel der ifAnweisung das einzige Mittel zur Verzweigung basierend auf dem Exit-Status:

if command; then :; else ...; fi

Da ifeine nicht leere thenKlausel erforderlich ist und Kommentare nicht als nicht leer gelten, :dient sie als No-Op.

Heutzutage (das heißt: in einem modernen Kontext) können Sie normalerweise entweder :oder verwenden true. Beide werden von POSIX spezifiziert und einige sind trueleichter zu lesen. Es gibt jedoch einen interessanten Unterschied: Es :handelt sich um ein sogenanntes POSIX- Special , während truees sich um ein reguläres integriertes System handelt .

• In die Shell müssen spezielle Einbauten eingebaut werden. Regelmäßige Einbauten sind nur "normalerweise" eingebaut, aber es ist nicht streng garantiert. Normalerweise sollte es :auf den truemeisten Systemen kein reguläres Programm mit der Funktion in PATH geben.

• Der wahrscheinlich wichtigste Unterschied besteht darin, dass bei speziellen integrierten Funktionen jede von den integrierten Variablen festgelegte Variable - auch in der Umgebung während der einfachen Befehlsauswertung - nach Abschluss des Befehls bestehen bleibt, wie hier mit ksh93 gezeigt:

  $ unset x; ( x=hi :; echo "$x" )
  hi
  $ ( x=hi true; echo "$x" )
  
  $

  Beachten Sie, dass Zsh diese Anforderung ignoriert, ebenso wie GNU Bash, außer wenn es im POSIX-Kompatibilitätsmodus arbeitet. Alle anderen wichtigen "POSIX sh-abgeleiteten" Shells, einschließlich dash, ksh93 und mksh, beachten dies.

• Ein weiterer Unterschied besteht darin, dass reguläre integrierte Funktionen kompatibel sein müssen exec- hier anhand von Bash demonstriert:

  $ ( exec : )
  -bash: exec: :: not found
  $ ( exec true )
  $

• POSIX weist auch ausdrücklich darauf hin, dass dies :möglicherweise schneller ist als true, obwohl dies natürlich ein implementierungsspezifisches Detail ist.

Ich benutze es, um Variablenbefehle einfach zu aktivieren / deaktivieren:

#!/bin/bash
if [[ "$VERBOSE" == "" || "$VERBOSE" == "0" ]]; then
    vecho=":"     # no "verbose echo"
else
    vecho=echo    # enable "verbose echo"
fi

$vecho "Verbose echo is ON"

Somit

$ ./vecho
$ VERBOSE=1 ./vecho
Verbose echo is ON

Dies sorgt für ein sauberes Skript. Dies ist mit '#' nicht möglich.

Ebenfalls,

: >afile

ist eine der einfachsten Möglichkeiten, um sicherzustellen, dass 'afile' existiert, aber eine Länge von 0 hat.

Eine nützliche Anwendung für: ist, wenn Sie nur Parametererweiterungen für ihre Nebenwirkungen verwenden möchten, anstatt das Ergebnis tatsächlich an einen Befehl zu übergeben. In diesem Fall verwenden Sie das PE als Argument für entweder: oder false, je nachdem, ob Sie einen Exit-Status von 0 oder 1 wünschen : "${var:=$1}". Ein Beispiel könnte sein . Da :es ein eingebautes ist, sollte es ziemlich schnell sein.

:kann auch für Blockkommentare verwendet werden (ähnlich wie / * * / in C-Sprache). Wenn Sie beispielsweise einen Codeblock in Ihrem Skript überspringen möchten, können Sie Folgendes tun:

: << 'SKIP'

your code block here

SKIP

Wenn Sie eine Datei auf null Byte kürzen möchten, was zum Löschen von Protokollen hilfreich ist, versuchen Sie Folgendes:

:> file.log

Es ist ähnlich wie passin Python.

Eine Verwendung wäre, eine Funktion zu stubben, bis sie geschrieben wird:

future_function () { :; }

Zwei weitere Verwendungen, die in anderen Antworten nicht erwähnt werden:

Protokollierung

Nehmen Sie dieses Beispielskript:

set -x
: Logging message here
example_command

In der ersten Zeile set -xdruckt die Shell den Befehl aus, bevor sie ausgeführt wird. Es ist ein ziemlich nützliches Konstrukt. Der Nachteil ist, dass die übliche echo Log messageArt der Anweisung die Nachricht jetzt zweimal druckt. Die Doppelpunktmethode umgeht das. Beachten Sie, dass Sie Sonderzeichen immer noch so entkommen müssen, wie Sie es möchten echo.

Cron Berufsbezeichnungen

Ich habe gesehen, wie es in Cron-Jobs verwendet wird, wie folgt:

45 10 * * * : Backup for database ; /opt/backup.sh

Dies ist ein Cron-Job, der das Skript /opt/backup.shjeden Tag um 10:45 Uhr ausführt. Der Vorteil dieser Technik besteht darin, dass die E-Mail-Betreffs besser aussehen, wenn /opt/backup.sheine Ausgabe gedruckt wird.

Sie können es in Verbindung mit backticks ( ``) verwenden, um einen Befehl auszuführen, ohne seine Ausgabe wie folgt anzuzeigen:

: `some_command`

Natürlich könnte man das auch tun some_command > /dev/null, aber die :-Version ist etwas kürzer.

Davon abgesehen würde ich nicht empfehlen, dies tatsächlich zu tun, da dies die Leute nur verwirren würde. Es kam mir nur als möglicher Anwendungsfall in den Sinn.

Es ist auch nützlich für polyglotte Programme:

#!/usr/bin/env sh
':' //; exec "$(command -v node)" "$0" "$@"
~function(){ ... }

Dies ist nun sowohl ein ausführbarer Shell-Skript und ein JavaScript - Programm: Sinn ./filename.js, sh filename.jsund node filename.jsalle arbeitet.

(Auf jeden Fall ein bisschen seltsam, aber trotzdem effektiv.)

Einige Erklärungen, wie gewünscht:

• Shell-Skripte werden zeilenweise ausgewertet; und der execBefehl, wenn ausgeführt, beendet die Schale und ersetzt es den Prozeß mit dem resultierenden Befehl. Dies bedeutet, dass das Programm für die Shell folgendermaßen aussieht:

  #!/usr/bin/env sh
  ':' //; exec "$(command -v node)" "$0" "$@"

• Solange im Wort keine Parametererweiterung oder kein Aliasing auftritt, kann jedes Wort in einem Shell-Skript in Anführungszeichen gesetzt werden, ohne seine Bedeutung zu ändern. Dies bedeutet, dass dies ':'äquivalent zu ist :(wir haben es hier nur in Anführungszeichen gesetzt, um die unten beschriebene JavaScript-Semantik zu erreichen).

• ... und wie oben beschrieben, ist der erste Befehl in der ersten Zeile ein No-Op (übersetzt : //oder, wenn Sie die Wörter lieber zitieren möchten) ':' '//'. Beachten Sie, dass der Befehl //hier keine besondere Bedeutung hat, wie dies in JavaScript der Fall ist. Es ist nur ein bedeutungsloses Wort, das weggeworfen wird.)

• Schließlich ist der zweite Befehl in der ersten Zeile (nach dem Semikolon) das eigentliche Kernstück des Programms: Es ist der execAufruf, der das aufgerufene Shell-Skript durch einen Node.js-Prozess ersetzt, der aufgerufen wird, um den Rest des Skripts auszuwerten .

• In der Zwischenzeit wird die erste Zeile in JavaScript als Zeichenfolgenliteral ( ':') und dann als Kommentar analysiert , der gelöscht wird. Für JavaScript sieht das Programm also folgendermaßen aus:

  ':'
  ~function(){ ... }

  Da sich das String-Literal in einer eigenen Zeile befindet, handelt es sich um eine No-Op-Anweisung und wird daher aus dem Programm entfernt. Das bedeutet, dass die gesamte Zeile entfernt wird und nur Ihr Programmcode (in diesem Beispiel der function(){ ... }Text) übrig bleibt .

Selbstdokumentierende Funktionen

Sie können :die Dokumentation auch in eine Funktion einbetten.

Angenommen, Sie haben ein Bibliotheksskript mylib.sh, das eine Vielzahl von Funktionen bietet. Sie können entweder die Bibliothek ( . mylib.sh) als Quelle verwenden und die Funktionen direkt danach aufrufen ( lib_function1 arg1 arg2) oder vermeiden, dass Ihr Namespace überfüllt ist, und die Bibliothek mit einem Funktionsargument ( mylib.sh lib_function1 arg1 arg2) aufrufen .

Wäre es nicht schön, wenn Sie auch mylib.sh --helpeine Liste der verfügbaren Funktionen und deren Verwendung eingeben und abrufen könnten, ohne die Funktionsliste im Hilfetext manuell pflegen zu müssen?

#! / bin / bash

# Alle "öffentlichen" Funktionen müssen mit diesem Präfix beginnen
LIB_PREFIX = 'lib_'

# "öffentliche" Bibliotheksfunktionen
lib_function1 () {
    : Diese Funktion macht etwas Kompliziertes mit zwei Argumenten.
    ::
    : Parameter:
    : 'arg1 - erstes Argument ($ 1)'
    : 'arg2 - zweites Argument'
    ::
    : Ergebnis:
    : " es ist kompliziert"

    # Hier beginnt der eigentliche Funktionscode
}}

lib_function2 () {
    : Funktionsdokumentation

    # Funktionscode hier
}}

# Hilfefunktion
--Hilfe() {
    Echo MyLib v0.0.1
    Echo
    echo Verwendung: mylib.sh [Funktionsname [Argumente]]
    Echo
    echo Verfügbare Funktionen:
    deklariere -f | sed -n -e '/ ^' $ LIB_PREFIX '/, / ^} $ / {/ \ (^' $ LIB_PREFIX '\) \ | \ (^ [\ t] *: \) / {
        s / ^ \ ('$ LIB_PREFIX'. * \) () / \ n === \ 1 === /; s / ^ [\ t] *: \? ['\' '"] \? / / ; s / ['\' '"] \ ?; \? $ //; p}}'
}}

# Haupt code
if ["$ {BASH_SOURCE [0]}" = "$ {0}"]; dann
    # Das Skript wurde ausgeführt anstatt bezogen
    # die angeforderte Funktion aufrufen oder Hilfe anzeigen
    if ["$ (Typ -t -" $ 1 "2> / dev / null)" = Funktion]; dann
        "$ @"
    sonst
        --Hilfe
    fi
fi

Einige Kommentare zum Code:

1. Alle "öffentlichen" Funktionen haben das gleiche Präfix. Nur diese sollen vom Benutzer aufgerufen und im Hilfetext aufgeführt werden.
2. Die selbstdokumentierende Funktion basiert auf dem vorherigen Punkt und declare -fzählt alle verfügbaren Funktionen auf. Anschließend werden sie durch sed gefiltert, um nur Funktionen mit dem entsprechenden Präfix anzuzeigen.
3. Es ist eine gute Idee, die Dokumentation in einfache Anführungszeichen zu setzen, um unerwünschte Erweiterungen und das Entfernen von Leerzeichen zu verhindern. Sie müssen auch vorsichtig sein, wenn Sie Apostrophe / Anführungszeichen im Text verwenden.
4. Sie können Code schreiben, um das Bibliothekspräfix zu verinnerlichen, dh der Benutzer muss nur eingeben mylib.sh function1und es wird intern in übersetzt lib_function1. Dies ist eine Übung, die dem Leser überlassen bleibt.
5. Die Hilfefunktion heißt "--help". Dies ist ein praktischer (dh fauler) Ansatz, bei dem der Mechanismus zum Aufrufen der Bibliothek verwendet wird, um die Hilfe selbst anzuzeigen, ohne dass eine zusätzliche Prüfung erforderlich ist $1. Gleichzeitig wird Ihr Namespace unübersichtlich, wenn Sie die Bibliothek als Quelle verwenden. Wenn Ihnen das nicht gefällt, können Sie entweder den Namen in einen ähnlichen Namen ändern lib_helpoder die Argumente --helpim Hauptcode überprüfen und die Hilfefunktion manuell aufrufen.

Ich habe diese Verwendung in einem Skript gesehen und dachte, es sei ein guter Ersatz für das Aufrufen des Basisnamens in einem Skript.

oldIFS=$IFS  
IFS=/  
for basetool in $0 ; do : ; done  
IFS=$oldIFS  

... dies ist ein Ersatz für den Code: basetool=$(basename $0)