bash—eine Bessere Möglichkeit zum speichern von Variablen zwischen den Läufen?

Ich habe ein bash script, das ich jede Stunde mit crontab, und ich brauche zum speichern einer Variablen, so dass ich zugreifen kann, es das nächste mal, wenn ich es ausführen. Das Skript ändert die variable jedes mal, wenn es läuft, so kann ich nicht hartcodieren. Jetzt bin ich dem schreiben in eine txt-Datei und dann Lesen Sie es wieder. Gibt es einen besseren Weg, es zu tun als das? Und die Art, wie lese ich die txt-Datei ist etwas, das ich gefunden hier, ich verstehe es nicht, und es ist ein bisschen klobig. Gibt es nicht einen eingebauten Befehl dafür? Wie auch immer, hier der entsprechende code, mit einigen der Variablen geändert, um es einfacher zu Lesen.

while read x; do
  var=$x
done < var.txt

# Do some stuff, change var to a new value

echo $var > var.txt

Ist die variable nur eine einzige integer-Zahl, also die text-Datei fühlt overkill.

Der kurze text-Datei mit persistenten Daten ist genau der Weg, es zu tun, nichts zu klobig.

InformationsquelleAutor shardbearer | 2012-09-08

  1. 8

    Gibt es keine Notwendigkeit zu verwenden var; x wird im Bereich für die aktuelle shell. Alternativ 

    read var < var.txt
# do stuff with var
echo $var > var.txt

    Empfehle ich eine einfache text-Datei, die zum speichern der variable. Allerdings gibt es die (höchst fragwürdige) Möglichkeit, ein selbst-ändern-Skript. ZUM ZWECKE DER UNTERHALTUNG NUR!

    #!/bin/bash

read val < <( tail -n 1 "$0" )

(( val++ ))
echo "$val"

tmp=$(mktemp /tmp/XXXXXXX)
sed '$s/.*/'$val'/' "$0" > "$tmp"
mv "$tmp" "$0"

exit
0

    Der Schlüssel ist, um die nächsten, letzten Zeile werden die exit-Befehl, so dass nichts nach dem es ausgeführt wird. Die Letzte Zeile ist der Wert der Variablen, die Sie wollen, zu bestehen. Wenn das Skript ausgeführt wird, es reads aus seinen eigenen letzten Zeile. Bevor es beendet wird, verwendet sed zu schreiben, eine Kopie von sich selbst toa temp-Datei, mit der letzten Zeile geändert mit dem aktuellen Wert der persistenten Wert. Dann haben wir überschreiben das aktuelle Skript mit der temp-Datei (vorausgesetzt, wir haben die Erlaubnis, dies zu tun).

    Aber im ernst? Tun Sie das nicht.

    Danke, das ist viel einfacher. Sind text-Dateien, die der beste Weg, dies zu tun?
    Es hängt davon ab. Sie können wählen Sie aus Datei, Datenbank, andere exotische java/ruby/python-Objekt-Persistenz speichert, oder halten Sie Ihre Programm läuft in einer Endlosschleife (mit den entsprechenden sleep-Zeiten embedded) und speichern des Wertes im Speicher, je nachdem, was Ihre Allgemeinen Anforderungen sind. Datei Persistenz ist in der Regel gut genug. Wenn Sie sich in eine mongo-system mit tausenden von Dateien und Verzeichnissen (wie kürzlich bereits hier auf S. O.), dann müssen Sie einige Zeit damit verbringen, die richtige Technik. Viel Glück an alle.
    Downvoter: bitte kommentieren Sie den Grund. Ist es denn der abscheuliche self-modifying-code? 🙂
    Statt einer änderung der letzten Zeile, können Sie einfach fügen Sie die neuen Werte mit echo "$val" >> "$0". Es ist sogar noch furchtbarer (aber macht den code viel einfacher) :) Sie können auch ed zum Bearbeiten der Quell-Datei, statt die schreckliche combo tmp/sed/mv.
    Hahah ich mag diese Antwort

    InformationsquelleAutor chepner

  2. 3

    Ich weiß, das ist eine alte Frage. Aber, ich immer noch entscheiden, zu posten meine Lösung hier in der Hoffnung, dass es vielleicht hilfreich sein, für andere, die hierher kommen auf der Suche nach einem Weg zu serialisieren env vars zwischen den Sitzungen.

    Der einfache Weg ist, schreiben Sie einfach "Variablennamen=var_value" in eine Datei, z.B. "./environ". Und dann "source ./envrion" in den folgenden Sitzungen. Zum Beispiel:

    echo "var1=$var1" > ./environ

    Einer umfassenderen (und elegant?) Weg die noch alle Attribute von Variablen ist die Anwendung der "declare-p":

    declare -p var1 var2 > ./environ
# NOTE: no '$' before var1, var2

    Später, nach der "source ./envrion" you can get var1, var2 mit allen Attributen wiederhergestellt, zusätzlich zu seinem Wert. Dies bedeutet, es kann mit arrays, integers etc.

    Einen Nachteil für die "declare-p-xx", obwohl: wenn Sie wickeln Sie die "source ./environ" in eine Funktion, dann werden alle Variablen bezogen sind sichtbar innerhalb der Funktion, nur weil Sie "erklären" standardmäßig deklariert Variablen als lokal. Um dies zu umgehen, können Sie entweder "Quelle" aus, der eine Funktion (oder im "main" - Funktion) oder ändern Sie die ./environ hinzufügen "-g" nach erklären (was macht die entsprechende Globale variable). Zum Beispiel:

    sed -i 's/^declare\( -g\)*/declare -g/' ./environ
# "\( -g\)?" ensure no duplication of "-g"
    Dies ist ein einfacher Ansatz, und ich verwende es selbst. Es erfordert Pflege, wenn nicht Vertrauenswürdige Benutzer können in die Datei schreiben (z.B. wenn es in /tmp und zunächst nicht erstellt), denn es enthält die vollständigen Funktionen von der Beschaffung shell. Take care!
    Sie haben Recht, und ich danke Ihnen.

    InformationsquelleAutor Lungang Fang

  3. 1

    1 - vereinfachen Sie Ihr Skript, wie Sie haben nur eine variable 

    var=`cat var.txt`
# Do some stuff, change var to a new value   
echo $var > var.txt

    2 - speichern Sie Ihre Variablen in der Umgebung:

    export var

# Do some stuff, change var to a new value

    Aber Sie benötigen, um prompt es . script.ksh (Punkt am Anfang). Aber es sollte nicht 'exit' - und ich bin nicht sicher, ob dies funktionieren würde, in der cron...

    InformationsquelleAutor Majid Laissi

  4. 0

    Speichern mehrere Variablen zwischen den Läufen, eine Lösung, die ich als speichern unter das format my_var=my_value in einer getrennten Datei.

    Dann habe ich auch zwei Funktionen zum setzen und abrufen von Variablen

    1. In der Datei speichern der Variablen und Ihre Werte:

    Nennen wir diese Datei Kontext.dat

    # Here I store the variables and their values
my_var_x=1
my_var_y=boo
my_var_z=0
    1. In das eigentliche Skript:

    Nennen wir die Datei multiple_run.sh

    context=./context.dat

function update_variables(){
    # update the variable context
    source $context
}

function set_variable(){
    # store variable
    variable=$1 #variable to be set
    value=$2    # value to give to the value
    # modify the file storing the value
    sed -i 's/'${variable}'.*/'${variable}'='${value}'/' $context
}

##################
# Test code
echo var_x
update_variables
echo var_x
# do something
set_variable var_x 2
echo $var_x

    Dies ist ein Ansatz unter anderen. Mit einer solchen Methode müssen Sie zum erstellen der Datei vor dem speichern, und erstellen Sie jede Zeile für jede variable. Neben der Kontext.dat ist a priori zugänglich von jedem anderen script.

    InformationsquelleAutor Uncle Ben Ben

  5. -1

    Landete ich auf folgende Weise. Würde lieber die Variablen in einer Datei, aber das bläht den code etwas. Wie dies funktioniert Lesen Sie, was arbeiten Sie? Sie können speichern, mehrere Variablen in einer separaten Datei, sagen variables.txt und dann haben Sie Ihre wichtigste Programm sagen main.sh. Es wäre vielleicht besser zu schreiben, separate Skripte für das laden und speichern von Variablen, obwohl.

    Für varibles.txt:

    A=0
B=0
C=0

    Für main.sh:

    #!/bin/bash

#reload variables
A=`cat ./variables.txt|grep "A="|cut -d"=" -f2`
B=`cat ./variables.txt|grep "B="|cut -d"=" -f2`
C=`cat ./variables.txt|grep "C="|cut -d"=" -f2`

#print variables
printf "$A\n"
printf "$B\n"
printf "$C\n"

#update variables
A=$((($A+1)))
B=$((($B+2)))
C=$((($C+3)))

#save variables to file
#for A
 #remove entry for A
 cat ./variables.txt|grep -v "A=">>./tmp.txt
 #save entry for A
 printf "A=$A\n">>./tmp.txt
 #move tmp.txt to variables.txt
mv ./tmp.txt ./variables.txt

#for B
 #remove entry for B
 cat ./variables.txt|grep -v "B=">>./tmp.txt
 #save entry for B
 printf "B=$B\n">>./tmp.txt
 #move tmp.txt to variables.txt
 mv ./tmp.txt ./variables.txt

#for C
 #remove entry for C
 cat ./variables.txt|grep -v "C=">>./tmp.txt
 #save entry for C
 printf "C=$C\n">>./tmp.txt
 #move tmp.txt to variables.txt
 mv ./tmp.txt ./variables.txt
    Nichts für ungut, aber das ist schrecklich. Du solltest besser source die Datei variables.txt statt analysieren Sie es selbst. Außerdem Nutzlos Verwendet der Katze gesichtet!

    InformationsquelleAutor ockert

Schreibe einen Kommentar