Aşağıdaki gibi bir şey oldukça basit bir komut dosyası var:

#!/bin/bash

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

echo $MOREF

Bu komut dosyasını komut satırından çalıştırıp argümanları ilettiğimde, herhangi bir çıktı almıyorum. Ancak, $MOREFdeğişkenin içerdiği komutları çalıştırdığımda çıktı alabiliyorum.

Bir komut dosyasında çalıştırılması gereken bir komutun sonuçlarını nasıl alabilir, bir değişkene kaydedebilir ve ardından bu değişkeni ekranda çıktılayabilirsiniz?

Geri vuruşlara ek olarak `command`, komut değiştirme , $(command)veya "$(command)"okumayı daha kolay bulduğum ve iç içe geçmeye izin veren veya ile yapılabilir .

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

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

Quoting ( ") çok satırlı değişken değerlerini korumak için önemlidir ; kelime ayırma yapılmadığından ödevin sağ tarafında isteğe bağlıdır , bu yüzden OUTPUT=$(ls -1)iyi çalışır.

Doğru yol

$(sudo run command)

Bir kesme işareti kullanacaksanız, ihtiyacınız `değil '. Bu karaktere "backticks" (veya "mezar aksanı") denir.

Bunun gibi:

#!/bin/bash

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

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

echo "$MOREF"

Komutlardan değişkenleri ayarlamak için kullandığım bazı Bash hileleri

2. Edit 2018-02-12: Farklı bir yol eklendi, bunun altında uzun süren görevler için arama yapın !

2018-01-25 Düzenleme: bir örnek işlev ekledi (disk kullanımı ile ilgili değişkenleri doldurmak için)

İlk basit, eski ve uyumlu yol

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

Çoğunlukla uyumlu, ikinci yol

Yuvalama ağırlaşabileceğinden, bunun için parantez uygulandı

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

İç içe örnek:

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

Birden fazla değişken okuma ( Bashizmlerle )

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

Ben sadece kullanılan bir değer istiyorsanız :

array=($(df -k /))

bir dizi değişkeni görebilirsiniz :

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

Sonra:

echo ${array[9]}
529020

Ama bunu tercih ederim:

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

Birincisi read foosadece başlık satırını atlayacak , ancak sadece bir komutta 7 farklı değişken dolduracaksınız:

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"

Ya da:

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

... ilişkilendirilebilir dizilerle de çalışacaktır :read foo disk[total] disk[used] ...

Bazı değişkenleri doldurmak için örnek işlev:

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

Not: declaresadece okunabilirlik için satır gerekli değildir.

hakkında sudo cmd | grep ... | cut ...

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

(Lütfen faydasız kaçının cat! Yani bu sadece bir çatal daha az:

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

Tüm borular ( |) çatalları ifade eder. Başka bir işlemin çalıştırılması gereken yerlerde, diske erişme, kitaplık çağrıları vb.

Yani sedörnek için kullanmak , alt süreci sadece bir çatalla sınırlar :

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

Ve Bashizm'lerle :

Ancak, çoğunlukla küçük dosyalarda yapılan birçok eylem için Bash işi kendisi yapabilir:

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

veya

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

Değişken bölme hakkında daha fazla bilgi ...

Bash'deki bir sınırlayıcıdaki bir dizeyi nasıl bölebilirim?

Alternatif: arka planda uzun süre çalışan görevleri kullanarak çatalları azaltmak

2. Düzenleme 2018-02-12:

Gibi birden fazla çatal önlemek için

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

veya

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

Bu işe yarar, ancak birçok çatal çalıştırmak ağır ve yavaştır.

Ve komutları satır satır gibi birçok işlem gibi dateve bcyapabilir !!

Görmek:

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

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

Bu nedenle , her istek için yeni bir çatal başlatmak zorunda kalmadan birçok iş yapmak için uzun süren bir arka plan işlemi kullanabiliriz .

Bunu düzgün yapmak için sadece bazı dosya tanımlayıcılarına ve fifoslara ihtiyacımız var :

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

(Tabii ki, FD 5ve 6kullanılmamış olmalı!) ... Oradan, bu işlemi şu şekilde kullanabilirsiniz:

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

Bir işleve newConnector

Sen benim bulundu edebilir newConnectorüzerindeki fonksiyonunu GitHub.Com veya üzerinde kendi sitesinde (.: Orada sitemde Fonksiyonu iki dosyalardır ve demo kullanımı için kaynaklı ya da sadece demo için çalıştırılabilir bir dosya halinde paketlenmiştir GitHub'dan Not.)

Örneklem:

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

İşlev myBc, arka plan görevini basit sözdizimi ile ve tarih için kullanmanıza izin verir:

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

Oradan, arka plan işlemlerinden birini bitirmek istiyorsanız, sadece fd'sini kapatmanız gerekir :

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

bu gerekli değildir, çünkü ana işlem bittiğinde tüm fd kapanır.

Size zaten belirttikleri gibi, 'backticks' kullanmalısınız.

Önerilen alternatif $(command)de işe yarıyor ve ayrıca okunması daha kolay, ancak sadece Bash veya KornShell (ve bunlardan türetilen kabuklar) için geçerli olduğunu unutmayın, bu nedenle komut dosyalarınızın çeşitli Unix sistemlerinde gerçekten taşınabilir olması gerekiyorsa, eski backticks gösterimi.

Bunu yapmanın üç yolunu biliyorum:

1. İşlevler bu tür görevler için uygundur: **

   func (){
       ls -l
   }

   Bunu söyleyerek çağır func.

2. Ayrıca başka bir uygun çözüm de değerlendirilebilir:

   var="ls -l"
   eval $var

3. Üçüncüsü değişkenleri doğrudan kullanıyor:

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

Üçüncü çözümün çıktısını iyi bir şekilde alabilirsiniz:

echo "$var"

Ve aynı zamanda kötü bir şekilde:

echo $var

Sadece farklı olmak için:

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

Değişken ayarlarken = işaretinden önce ve / veya sonra NO Spaces olduğundan emin olun . Kelimenin tam anlamıyla, her türlü çözümü denemek için bir saat harcadı! Bu hoş değil.

Doğru:

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

"Şeyler: bulunamadı" veya benzeri bir hata ile başarısız olur

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

Bunu çok satırlı / çoklu komut (lar) ile yapmak istiyorsanız, bunu yapabilirsiniz:

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

Veya:

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

Misal:

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

Çıktı:

first
second
third

Yorumlu metin kullanarak , uzun tek satır kodunuzu çok satırlı bir bölüme ayırarak işleri kolayca basitleştirebilirsiniz. Başka bir örnek:

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

Bunlardan birini kullanmanız gerekir

$(command-here)

veya

`command-here`

Misal

#!/bin/bash

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

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

echo "$MOREF"

Bu başka bir yoldur ve oluşturduğunuz her karmaşık kodu doğru şekilde vurgulayamayan bazı metin editörleriyle kullanmak iyidir:

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

Geri vuruşları (aksan mezarları olarak da bilinir) veya olarak kullanabilirsiniz $().

Sevmek:

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

Her ikisi de aynı etkiye sahiptir. Ancak OUTPUT = $ (x + 2) daha okunabilir ve en yenisi.

Yürütmeye çalıştığınız komut başarısız olursa, çıktıyı hata akışına yazar ve sonra konsola yazdırılır.

Bundan kaçınmak için hata akışını yeniden yönlendirmelisiniz:

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

Bazıları bunu faydalı bulabilir. Hile $(())çift ​​parantez kullanan değişken ikamedeki tamsayı değerleri :

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

İşte iki yol daha:

Bash'te alanın çok önemli olduğunu lütfen unutmayın. Yani, komutunuzun çalışmasını istiyorsanız, daha fazla boşluk girmeden olduğu gibi kullanın.

1. Devrettikleri aşağıdaki harshiliçin Ldaha sonra ve onu yazdırır

   L=$"harshil"
   echo "$L"

2. Aşağıdaki komutun çıktısını L2'ye atar tr. trbaşka bir değişken olan L1 üzerinde çalıştırılmaktadır.

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