Ich habe ein ziemlich einfaches Skript, das ungefähr so ​​aussieht:

#!/bin/bash

VAR1="$1"
MOREF='sudo run command against $VAR1 | grep name | cut -c7-'

echo $MOREF

Wenn ich dieses Skript über die Befehlszeile ausführe und ihm die Argumente übergebe, erhalte ich keine Ausgabe. Wenn ich jedoch die in der $MOREFVariablen enthaltenen Befehle ausführe , kann ich eine Ausgabe erhalten.

Wie kann man die Ergebnisse eines Befehls, der in einem Skript ausgeführt werden muss, in einer Variablen speichern und diese Variable dann auf dem Bildschirm ausgeben?

Zusätzlich zu Backticks `command`kann die Befehlssubstitution mit $(command)oder erfolgen "$(command)", was meiner Meinung nach leichter zu lesen ist und das Verschachteln ermöglicht.

OUTPUT=$(ls -1)
echo "${OUTPUT}"

MULTILINE=$(ls \
   -1)
echo "${MULTILINE}"

Quoting ( ") ist wichtig, um mehrzeilige Variablenwerte beizubehalten . Es ist auf der rechten Seite einer Zuweisung optional, da keine Wortaufteilung durchgeführt wird und daher OUTPUT=$(ls -1)gut funktioniert.

Der richtige Weg ist

$(sudo run command)

Wenn Sie ein Apostroph verwenden möchten, brauchen Sie es `nicht '. Dieses Zeichen wird "Backticks" (oder "schwerwiegender Akzent") genannt.

So was:

#!/bin/bash

VAR1="$1"
VAR2="$2"

MOREF=`sudo run command against "$VAR1" | grep name | cut -c7-`

echo "$MOREF"

Einige Bash- Tricks, mit denen ich Variablen aus Befehlen setze

2nd Edit 2018-02-12: Eine andere Möglichkeit hinzugefügt, suchen Sie unten nach langfristigen Aufgaben !

2018-01-25 Bearbeiten: Eine Beispielfunktion wurde hinzugefügt (zum Auffüllen von Variablen zur Festplattennutzung).

Erster einfacher, alter und kompatibler Weg

myPi=`echo '4*a(1)' | bc -l`
echo $myPi 
3.14159265358979323844

Meistens kompatibel, zweiter Weg

Da die Verschachtelung schwer werden könnte, wurde hierfür eine Klammer implementiert

myPi=$(bc -l <<<'4*a(1)')

Verschachtelte Probe:

SysStarted=$(date -d "$(ps ho lstart 1)" +%s)
echo $SysStarted 
1480656334

Lesen von mehr als einer Variablen (mit Bashisms )

df -k /
Filesystem     1K-blocks   Used Available Use% Mounted on
/dev/dm-0         999320 529020    401488  57% /

Wenn ich nur einen verwendeten Wert möchte :

array=($(df -k /))

Sie konnten eine Array- Variable sehen:

declare -p array
declare -a array='([0]="Filesystem" [1]="1K-blocks" [2]="Used" [3]="Available" [
4]="Use%" [5]="Mounted" [6]="on" [7]="/dev/dm-0" [8]="999320" [9]="529020" [10]=
"401488" [11]="57%" [12]="/")'

Dann:

echo ${array[9]}
529020

Aber ich bevorzuge das:

{ read foo ; read filesystem size using avail prct mountpoint ; } < <(df -k /)
echo $using
529020

Die erste überspringtread foo nur die Kopfzeile, aber in nur einem Befehl werden 7 verschiedene Variablen ausgefüllt:

declare -p avail filesystem foo mountpoint prct size using
declare -- avail="401488"
declare -- filesystem="/dev/dm-0"
declare -- foo="Filesystem     1K-blocks   Used Available Use% Mounted on"
declare -- mountpoint="/"
declare -- prct="57%"
declare -- size="999320"
declare -- using="529020"

Oder auch:

{ read foo ; read filesystem dsk[{6,2,9}] prct mountpoint ; } < <(df -k /)
declare -p mountpoint dsk
declare -- mountpoint="/"
declare -a dsk=([2]="529020" [6]="999320" [9]="401488")

... funktioniert auch mit assoziativen Arrays :read foo disk[total] disk[used] ...

Beispielfunktion zum Auffüllen einiger Variablen:

#!/bin/bash

declare free=0 total=0 used=0

getDiskStat() {
    local foo
    {
        read foo
        read foo total used free foo
    } < <(
        df -k ${1:-/}
    )
}

getDiskStat $1
echo $total $used $free

Hinweis: declareZeile ist nicht erforderlich, nur zur besseren Lesbarkeit.

Über sudo cmd | grep ... | cut ...

shell=$(cat /etc/passwd | grep $USER | cut -d : -f 7)
echo $shell
/bin/bash

(Bitte vermeiden Sie nutzlos cat! Das ist also nur eine Gabel weniger:

shell=$(grep $USER </etc/passwd | cut -d : -f 7)

Alle Rohre ( |) implizieren Gabeln. Wo ein anderer Prozess ausgeführt werden muss, Zugriff auf Festplatte, Bibliotheksaufrufe usw.

Wenn Sie also sedfür sample verwenden, wird der Unterprozess auf nur eine Gabel beschränkt :

shell=$(sed </etc/passwd "s/^$USER:.*://p;d")
echo $shell

Und mit Bashisms :

Aber für viele Aktionen, hauptsächlich für kleine Dateien, könnte Bash die Arbeit selbst erledigen:

while IFS=: read -a line ; do
    [ "$line" = "$USER" ] && shell=${line[6]}
  done </etc/passwd
echo $shell
/bin/bash

oder

while IFS=: read loginname encpass uid gid fullname home shell;do
    [ "$loginname" = "$USER" ] && break
  done </etc/passwd
echo $shell $loginname ...

Weiter über die variable Aufteilung ...

Schauen Sie sich meine Antwort auf Wie teile ich eine Zeichenfolge auf einem Trennzeichen in Bash?

Alternative: Reduzieren von Gabeln durch Verwendung von Hintergrundaufgaben mit langer Laufzeit

2. Änderung 2018-02-12:

Um mehrere Gabeln wie zu verhindern

myPi=$(bc -l <<<'4*a(1)'
myRay=12
myCirc=$(bc -l <<<" 2 * $myPi * $myRay ")

oder

myStarted=$(date -d "$(ps ho lstart 1)" +%s)
mySessStart=$(date -d "$(ps ho lstart $$)" +%s)

Dies funktioniert gut, aber viele Gabeln laufen zu lassen ist schwer und langsam.

Und Befehle mögen dateund bckönnten viele Operationen machen, Zeile für Zeile !!

Sehen:

bc -l <<<$'3*4\n5*6'
12
30

date -f - +%s < <(ps ho lstart 1 $$)
1516030449
1517853288

Wir könnten also einen lang laufenden Hintergrundprozess verwenden, um viele Jobs zu erledigen, ohne für jede Anforderung einen neuen Fork initiieren zu müssen.

Wir brauchen nur einige Dateideskriptoren und Fifos, um dies richtig zu machen:

mkfifo /tmp/myFifoForBc
exec 5> >(bc -l >/tmp/myFifoForBc)
exec 6</tmp/myFifoForBc
rm /tmp/myFifoForBc

(Natürlich, FD 5und 6müssen nicht verwendet werden!) ... Von dort aus können Sie diesen Prozess verwenden, indem Sie:

echo "3*4" >&5
read -u 6 foo
echo $foo
12

echo >&5 "pi=4*a(1)"
echo >&5 "2*pi*12"
read -u 6 foo
echo $foo
75.39822368615503772256

In eine Funktion newConnector

Sie finden meine newConnectorFunktion möglicherweise auf GitHub.Com oder auf meiner eigenen Site (Hinweis auf GitHub: Auf meiner Site befinden sich zwei Dateien. Funktion und Demo sind in einer Datei zusammengefasst, die zur Verwendung bezogen oder nur für die Demo ausgeführt werden kann.)

Stichprobe:

. shell_connector.sh

tty
/dev/pts/20

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30745 pts/20   R+     0:00  \_ ps --tty pts/20 fw

newConnector /usr/bin/bc "-l" '3*4' 12

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30944 pts/20   S      0:00  \_ /usr/bin/bc -l
  30952 pts/20   R+     0:00  \_ ps --tty pts/20 fw

declare -p PI
bash: declare: PI: not found

myBc '4*a(1)' PI
declare -p PI
declare -- PI="3.14159265358979323844"

Mit dieser Funktion myBckönnen Sie die Hintergrundaufgabe mit einfacher Syntax und für Datum verwenden:

newConnector /bin/date '-f - +%s' @0 0
myDate '2000-01-01'
  946681200
myDate "$(ps ho lstart 1)" boottime
myDate now now ; read utm idl </proc/uptime
myBc "$now-$boottime" uptime
printf "%s\n" ${utm%%.*} $uptime
  42134906
  42134906

ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
  29019 pts/20   Ss     0:00 bash
  30944 pts/20   S      0:00  \_ /usr/bin/bc -l
  32615 pts/20   S      0:00  \_ /bin/date -f - +%s
   3162 pts/20   R+     0:00  \_ ps --tty pts/20 fw

Wenn Sie von dort aus einen der Hintergrundprozesse beenden möchten, müssen Sie nur die fd schließen :

eval "exec $DATEOUT>&-"
eval "exec $DATEIN>&-"
ps --tty pts/20 fw
    PID TTY      STAT   TIME COMMAND
   4936 pts/20   Ss     0:00 bash
   5256 pts/20   S      0:00  \_ /usr/bin/bc -l
   6358 pts/20   R+     0:00  \_ ps --tty pts/20 fw

was nicht benötigt wird, da alle fd schließen, wenn der Hauptprozess abgeschlossen ist.

Wie sie Ihnen bereits angedeutet haben, sollten Sie "Backticks" verwenden.

Die vorgeschlagene Alternative $(command)funktioniert ebenfalls und ist auch leichter zu lesen. Beachten Sie jedoch, dass sie nur mit Bash oder KornShell (und von diesen abgeleiteten Shells) gültig ist. Wenn Ihre Skripte also auf verschiedenen Unix-Systemen wirklich portabel sein müssen, sollten Sie dies vorziehen die alte Backticks-Notation.

Ich kenne drei Möglichkeiten:

1. Funktionen sind für solche Aufgaben geeignet: **

   func (){
       ls -l
   }

   Rufen Sie es auf, indem Sie sagen func.

2. Auch eine andere geeignete Lösung könnte eval sein:

   var="ls -l"
   eval $var

3. Der dritte verwendet Variablen direkt:

   var=$(ls -l)
   
       OR
   
   var=`ls -l`

Sie können die Ausgabe der dritten Lösung auf gute Weise erhalten:

echo "$var"

Und auch auf böse Weise:

echo $var

Nur um anders zu sein:

MOREF=$(sudo run command against $VAR1 | grep name | cut -c7-)

Stellen Sie beim Festlegen einer Variablen sicher, dass Sie vor und / oder nach dem = -Zeichen KEINE Leerzeichen haben . Ich habe buchstäblich eine Stunde damit verbracht, dies herauszufinden und alle Arten von Lösungen auszuprobieren! Das ist nicht cool.

Richtig:

WTFF=`echo "stuff"`
echo "Example: $WTFF"

Wird mit dem Fehler "stuff: not found" oder ähnlichem fehlschlagen

WTFF= `echo "stuff"`
echo "Example: $WTFF"

Wenn Sie dies mit mehrzeiligen / mehreren Befehlen tun möchten, können Sie dies tun:

output=$( bash <<EOF
# Multiline/multiple command/s
EOF
)

Oder:

output=$(
# Multiline/multiple command/s
)

Beispiel:

#!/bin/bash
output="$( bash <<EOF
echo first
echo second
echo third
EOF
)"
echo "$output"

Ausgabe:

first
second
third

Mit heredoc können Sie die Dinge ganz einfach vereinfachen, indem Sie Ihren langen einzeiligen Code in einen mehrzeiligen Code zerlegen. Ein anderes Beispiel:

output="$( ssh -p $port $user@$domain <<EOF
# Breakdown your long ssh command into multiline here.
EOF
)"

Sie müssen entweder verwenden

$(command-here)

oder

`command-here`

Beispiel

#!/bin/bash

VAR1="$1"
VAR2="$2"

MOREF="$(sudo run command against "$VAR1" | grep name | cut -c7-)"

echo "$MOREF"

Dies ist eine andere Möglichkeit und eignet sich gut für einige Texteditoren, die nicht in der Lage sind, jeden von Ihnen erstellten komplexen Code korrekt hervorzuheben:

read -r -d '' str < <(cat somefile.txt)
echo "${#str}"
echo "$str"

Sie können Backticks (auch als Akzentgräber bezeichnet) oder verwenden $().

Mögen:

OUTPUT=$(x+2);
OUTPUT=`x+2`;

Beide haben den gleichen Effekt. Aber OUTPUT = $ (x + 2) ist besser lesbar und das neueste.

Wenn der Befehl, den Sie ausführen möchten, fehlschlägt, wird die Ausgabe in den Fehlerstrom geschrieben und dann auf der Konsole ausgedruckt.

Um dies zu vermeiden, müssen Sie den Fehlerstrom umleiten:

result=$(ls -l something_that_does_not_exist 2>&1)

Einige mögen dies nützlich finden. Ganzzahlige Werte bei der Variablensubstitution, bei der der Trick in $(())doppelten Klammern steht:

N=3
M=3
COUNT=$N-1
ARR[0]=3
ARR[1]=2
ARR[2]=4
ARR[3]=1

while (( COUNT < ${#ARR[@]} ))
do
  ARR[$COUNT]=$((ARR[COUNT]*M))
  (( COUNT=$COUNT+$N ))
done

Hier sind zwei weitere Möglichkeiten:

Bitte denken Sie daran, dass Platz in Bash sehr wichtig ist. Wenn Sie also möchten, dass Ihr Befehl ausgeführt wird, verwenden Sie ihn unverändert, ohne weitere Leerzeichen einzufügen.

1. Die folgenden Abtretungsempfänger harshilzu Lund druckt sie dann

   L=$"harshil"
   echo "$L"

2. Im Folgenden wird die Ausgabe des Befehls trL2 zugewiesen. trwird an einer anderen Variablen, L1, betrieben.

   L2=$(echo "$L1" | tr [:upper:] [:lower:])