$(sudo run command)

Jeśli chcesz użyć apostrofu, potrzebujesz `, a nie '. Postać ta nazywana jest " backticks "(lub"grave accent"):

#!/bin/bash

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

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

echo "$MOREF"

Niektóre Bash sztuczki używam do ustawiania zmiennych z poleceń

Przepraszam, jest odpowiedź loong, ale bashjest powłoką , gdzie głównym celem jest uruchamianie innych poleceń unix i reagowanie na resut code i/lub wyjście, (polecenia są często piped filtr, itd... ).

Przechowywanie wyników poleceń w zmiennych jest czymś podstawowym i fundamentalnym.

Dlatego w zależności na

• compatibility (posix )
• rodzaj wyjścia (filtr (y))
• liczba zmiennych do Ustawienia (Podziel lub zinterpretuj)
• Czas wykonania (monitoring)
• zalewkowanie błędów
[[80]} powtarzalność żądania (patrz długo działający proces w tle, dalej) W 2007 roku firma została założona przez firmę Microsoft, która od 2007 roku zajmuje się dystrybucją i dystrybucją oprogramowania.]}
• czy coś mnie ominęło?

Pierwszy prosty, stary i zgodny sposób

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

W większości kompatybilny, drugi sposób

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

Zagnieżdżona próbka:

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

Bash funkcje

Odczyt więcej niż jednej zmiennej (z )

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

If I just want a used value:

array=($(df -k /))

Możesz zobaczyć tablicę zmienną:

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]="/")'

Potem:

echo ${array[9]}
529020

Ale często używam to:

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

Pierwsza read foo po prostu pominie linię nagłówka, ale w tylko jednej poleceniu, będziesz wypełniać 7 różnych zmiennych:

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"

Lub

{ read -a head;varnames=(${head[@]//[K1% -]});varnames=(${head[@]//[K1% -]});
  read ${varnames[@],,} ; } < <(LANG=C df -k /)

Potem:

declare -p varnames ${varnames[@],,} 
declare -a varnames=([0]="Filesystem" [1]="blocks" [2]="Used" [3]="Available" [4]="Use" [5]="Mounted" [6]="on")
declare -- filesystem="/dev/dm-0"
declare -- blocks="999320"
declare -- used="529020"
declare -- available="401488"
declare -- use="57%"
declare -- mounted="/"
declare -- on=""

Lub nawet:

{ 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")

(Uwaga Used i Blocks jest tam zamienione: read ... dsk[6] dsk[2] dsk[9] ...)

... będzie współpracować z tablicami asocjacyjnymi również: read foo disk[total] disk[used] ...

Dedykowany fd using unnamed fifo :

Istnieje elegancki sposób:

users=()
while IFS=: read -u $list user pass uid gid name home bin ;do
    ((uid>=500)) &&
        printf -v users[uid] "%11d %7d %-20s %s\n" $uid $gid $user $home
done {list}</etc/passwd

Using this way (... read -u $list; ... {list}<inputfile) leave STDIN bezpłatne do innych celów, takich jak interakcja z użytkownikiem.

Then

echo -n "${users[@]}"
       1000    1000 user         /home/user
...
      65534   65534 nobody       /nonexistent

I

echo ${!users[@]}
1000 ... 65534

echo -n "${users[1000]}"
      1000    1000 user       /home/user

{
    read -u $list -a head          # read header in array `head`
    varnames=(${head[@]//[K1% -]}) # drop illegal chars for variable names
    while read -u $list ${varnames[@],,} ;do
        ((pct=available*100/(available+used),pct<10)) &&
            printf "WARN: FS: %-20s on %-14s %3d <10 (Total: %11u, Use: %7s)\n" \
                "${filesystem#*/mapper/}" "$mounted" $pct $blocks "$use"
     done
 } {list}< <(LANG=C df -k)

I oczywiście z dokumentów inline :

while IFS=\; read -u $list -a myvar ;do
    echo ${myvar[2]}
done {list}<<"eof"
foo;bar;baz
alice;bob;charlie
$cherry;$strawberry;$memberberries
eof

Przykładowa funkcja do wypełniania niektórych zmiennych:

#!/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

Nota: declare linia nie jest wymagana, tylko dla czytelności.

O sudo cmd | grep ... | cut ...

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

(proszę unikać bezużytecznych cat! Więc to jest tylko jeden widelec mniej:

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

Wszystkie rury (|) oznaczają widelce. Gdzie musi być uruchomiony inny proces, dostęp do dysku, wywołania bibliotek i tak dalej.

Więc użycie sed dla próbki ograniczy podproces tylko do jednego forka :

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

I z :

Ale dla wielu akcji, głównie na małych plikach, Bash może wykonać zadanie :

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

Lub

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

Idąc dalej o podział zmiennych ...

Alternatywa: redukcja widełek za pomocą długich zadań

W celu uniknięcia wielu widelców, takich jak

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

Lub

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

To działa dobrze, ale uruchamianie wielu widelców jest ciężkie i powolne.

I polecenia takie jak date i bc mogą wykonywać wiele operacji, linia po linii!!

Zobacz:

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

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

Więc możemy użyć długiego procesu w tle, aby wykonać wiele zadań, bez konieczności inicjowania nowegofork dla każdego żądania.

Pod bash znajduje się wbudowana funkcja: coproc:

coproc bc -l
echo 4*3 >&${COPROC[1]}
read -u $COPROC answer
echo $answer
12

echo >&${COPROC[1]} 'pi=4*a(1)'
ray=42.0
printf >&${COPROC[1]} '2*pi*%s\n' $ray
read -u $COPROC answer
echo $answer
263.89378290154263202896

printf >&${COPROC[1]} 'pi*%s^2\n' $ray
read -u $COPROC answer
echo $answer
5541.76944093239527260816

Ponieważ bc jest gotowy, działa w tle i I / O są również gotowe, nie ma opóźnienia, nic do załadowania, otwarcia, zamknięcia, przed lub po operacja. Tylko sama operacja! To staje się o wiele szybsze niż konieczność fork do bc dla każdej operacji!

Efekt graniczny: podczas gdy bc pozostaną uruchomione, będą one przechowywać wszystkie rejestry, więc niektóre zmienne lub funkcje mogą być zdefiniowane w kroku inicjalizacji , jako pierwszy zapis do ${COPROC[1]}, tuż po uruchomieniu zadania (poprzez coproc).

Do funkcji newConnector

Możesz znaleźć moją newConnector funkcję na GitHub.Com lub na mojej własnej stronie (Uwaga na Githubie: na mojej stronie znajdują się dwa pliki. Funkcja i demo są dołączone do jednego pliku uniq, które mogą być pozyskiwane do użytku lub po prostu uruchomić demo.)

Próbka:

source 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"

Funkcja myBc pozwala używać zadania w tle z prostą składnią, a dla date:

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

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

Co nie jest potrzebne, ponieważ wszystkie fd zamykają się po zakończeniu głównego procesu.

Jak już ci wskazali, powinieneś użyć "backticks".

Zaproponowana alternatywa $(command) działa również i jest łatwiejsza do odczytania, ale zauważ, że jest ważna tylko z Bashem lub Kornshellem (i powłokami pochodzącymi z tych), więc jeśli Twoje Skrypty muszą być naprawdę przenośne na różnych systemach uniksowych, powinieneś preferować starą notację backticks.

Znam trzy sposoby:

1. Funkcje są odpowiednie do takich zadań: * *

   func (){
       ls -l
   }
   

   Wywołaj to mówiąc func.

2. Również innym odpowiednim rozwiązaniem może być eval:

   var="ls -l"
   eval $var
   

3. Trzeci używa zmiennych bezpośrednio:

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

Możesz uzyskać wyjście trzeciego rozwiązania w dobry sposób:

echo "$var"

A także w paskudny sposób:

echo $var

Żeby było inaczej:

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

Podczas ustawiania zmiennej upewnij się, że masz Brak spacji przed i / lub po znaku =. Dosłownie spędziłem godzinę próbując to rozgryźć, próbując różnych rozwiązań! To jest nie fajne.

poprawne:

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

nie działa z błędem "stuff: not found" lub podobnym

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

Jeśli chcesz to zrobić za pomocą multiline / multiple command / s, możesz to zrobić:

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

Lub:

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

Przykład:

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

Wyjście:

first
second
third

Używając heredoc , możesz łatwo uprościć wszystko, dzieląc swój długi, jednolinijkowy kod na wielolinijkowy. Inny przykład:

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

Musisz użyć

$(command-here)

Lub

`command-here`

Przykład

#!/bin/bash

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

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

echo "$MOREF"

Jest to inny sposób i dobrze jest używać z niektórymi edytorami tekstu, które nie są w stanie poprawnie wyróżnić każdego złożonego kodu, który tworzysz:

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

Możesz użyć backticks (znany również jako ACCENT graves) lub $().

Jak:

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

Oba mają ten sam efekt. Ale OUTPUT = $(x+2) jest bardziej czytelny i najnowszy.

Jeśli polecenie, które próbujesz wykonać, nie powiedzie się, zapisze wyjście do strumienia błędów, a następnie zostanie wydrukowane na konsoli.

Aby tego uniknąć, musisz przekierować strumień błędów:

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

Niektórzy mogą uznać to za przydatne. Wartości całkowite w podstawieniu zmiennej, gdzie trik używa {[1] } podwójnych nawiasów:

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

Są jeszcze dwa sposoby:

Należy pamiętać, że przestrzeń jest bardzo ważna w Bash. Tak więc, jeśli chcesz, aby Twoje polecenie zostało uruchomione, użyj as is bez wprowadzania dodatkowych spacji.

1. Następujące przyporządkowuje harshil do L, a następnie wypisuje

   L=$"harshil"
   echo "$L"
   

2. Poniższe polecenie przypisuje wyjście polecenia tr do L2. tr jest operowana na innej zmiennej, L1.

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