ซีเรียลไลซ์ตัวแปรเชลล์ใน bash หรือ zsh

มีวิธีใดในการทำให้เชลล์เชลล์เป็นอนุกรม? สมมติว่าฉันมีตัวแปร$VARและฉันต้องการที่จะสามารถบันทึกลงในไฟล์หรืออะไรก็ตามแล้วอ่านมันอีกครั้งในภายหลังเพื่อรับค่าเดียวกันกลับมา?

มีวิธีพกพาในการทำเช่นนี้? (ฉันไม่คิดอย่างนั้น)

มีวิธีทำใน bash หรือ zsh หรือไม่

คำเตือน:ด้วยวิธีการใด ๆ เหล่านี้คุณต้องระวังว่าคุณกำลังไว้วางใจในความถูกต้องของไฟล์ข้อมูลเพื่อความปลอดภัยเนื่องจากพวกเขาจะถูกเรียกใช้งานเป็นรหัสเชลล์ในสคริปต์ของคุณ การรักษาความปลอดภัยเป็นสิ่งสำคัญยิ่งสำหรับความปลอดภัยของสคริปต์ของคุณ!

การใช้งานอินไลน์อย่างง่ายสำหรับการทำให้เป็นอนุกรมอย่างน้อยหนึ่งตัวแปร

ใช่ทั้ง bash และ zsh คุณสามารถทำให้เนื้อหาของตัวแปรเป็นแบบที่ง่ายต่อการดึงข้อมูลโดยใช้typesetbuiltin และ-pอาร์กิวเมนต์ รูปแบบผลลัพธ์เป็นเช่นนั้นคุณสามารถsourceส่งออกเพื่อรับสิ่งของของคุณกลับมา

 # You have variable(s) $FOO and $BAR already with your stuff
 typeset -p FOO BAR > ./serialized_data.sh

คุณสามารถนำข้อมูลของคุณกลับมาเช่นนี้ไม่ว่าจะในภายหลังในสคริปต์ของคุณหรือในสคริปต์อื่นทั้งหมด:

# Load up the serialized data back into the current shell
source serialized_data.sh

สิ่งนี้จะใช้ได้กับ bash, zsh และ ksh รวมถึงการส่งผ่านข้อมูลระหว่างเชลล์ที่แตกต่างกัน Bash จะแปลสิ่งนี้เป็นdeclareฟังก์ชั่นbuiltin ในขณะที่ zsh จะดำเนินการนี้ด้วยtypesetแต่เนื่องจาก bash มีนามแฝงสำหรับสิ่งนี้ที่จะทำงานในแบบที่เราใช้typesetที่นี่เพื่อความเข้ากันได้ของ ksh

การใช้งานทั่วไปที่ซับซ้อนยิ่งขึ้น

การใช้งานด้านบนนั้นง่ายมาก แต่ถ้าคุณเรียกมันบ่อยครั้งคุณอาจต้องการให้ฟังก์ชั่นยูทิลิตี้เพื่อให้ง่ายขึ้น นอกจากนี้หากคุณเคยลองใส่ฟังก์ชั่นที่กำหนดเองข้างต้นคุณจะพบกับปัญหาเกี่ยวกับการกำหนดขอบเขตตัวแปร รุ่นนี้ควรกำจัดปัญหาเหล่านั้น

หมายเหตุสำหรับสิ่งเหล่านี้เพื่อรักษาความเข้ากันได้ข้าม bash / zsh เราจะทำการแก้ไขทั้งกรณีtypesetและdeclareดังนั้นรหัสควรทำงานในเปลือกอย่างใดอย่างหนึ่งหรือทั้งสอง นี่เป็นการเพิ่มจำนวนมากและความยุ่งเหยิงที่สามารถกำจัดได้หากคุณทำสิ่งนี้กับเปลือกหอยอันใดอันหนึ่งเท่านั้น

ปัญหาหลักของการใช้ฟังก์ชั่นนี้ (หรือรวมถึงรหัสในฟังก์ชั่นอื่น ๆ ) คือtypesetฟังก์ชั่นสร้างรหัสที่เมื่อแหล่งที่มากลับเข้าไปในสคริปต์จากภายในฟังก์ชั่นเริ่มต้นในการสร้างตัวแปรท้องถิ่นมากกว่าตัวแปรทั่วโลก

สามารถแก้ไขได้ด้วยหนึ่งในหลาย ๆ แฮ็ก ความพยายามเริ่มต้นของฉันในการแก้ไขปัญหานี้คือการแยกวิเคราะห์ผลลัพธ์ของกระบวนการซีเรียลไลซ์sedเพื่อเพิ่มการ-gตั้งค่าสถานะเพื่อให้รหัสที่สร้างขึ้นกำหนดตัวแปรทั่วโลกเมื่อแหล่งที่มากลับมา

serialize() {
    typeset -p "$1" | sed -E '0,/^(typeset|declare)/{s/ / -g /}' > "./serialized_$1.sh"
}
deserialize() {
    source "./serialized_$1.sh"
}

โปรดทราบว่าsedนิพจน์ที่ขี้ขลาดนั้นจะตรงกับเหตุการณ์แรกของ 'เรียงพิมพ์' หรือ 'ประกาศ' เท่านั้นและเพิ่ม-gเป็นอาร์กิวเมนต์แรก มีความจำเป็นต้องจับคู่เหตุการณ์แรกเท่านั้นเนื่องจากStéphane Chazelasชี้ให้เห็นอย่างถูกต้องในความคิดเห็นมิฉะนั้นจะจับคู่กรณีที่สตริงที่ต่อเนื่องนั้นมีบรรทัดใหม่ตามตัวอักษรตามด้วยคำที่ประกาศหรือเรียงพิมพ์

นอกเหนือจากการแก้ไข pasing faux pasเบื้องต้นของฉันแล้วStéphaneยังแนะนำวิธีที่ง่ายกว่าในการแฮ็คสิ่งนี้ไม่เพียง แต่ทำตามขั้นตอนด้านปัญหาของการวิเคราะห์สตริง แต่อาจเป็นตะขอที่มีประโยชน์ในการเพิ่มฟังก์ชันการทำงานเพิ่มเติมโดยใช้ฟังก์ชัน wrapper ดำเนินการเมื่อมีการจัดหาข้อมูลกลับมาสิ่งนี้ถือว่าคุณไม่ได้เล่นเกมอื่น ๆ ที่มีคำสั่งประกาศหรือเรียงพิมพ์ แต่เทคนิคนี้จะง่ายต่อการใช้งานในสถานการณ์ที่คุณรวมฟังก์ชั่นนี้เป็นส่วนหนึ่งของฟังก์ชันอื่นของคุณเองหรือ คุณไม่ได้อยู่ในการควบคุมข้อมูลที่กำลังเขียนและมีการ-gเพิ่มค่าสถานะหรือไม่ สิ่งที่คล้ายกันสามารถทำได้ด้วยนามแฝงดูคำตอบของ Gillesสำหรับการดำเนินการ

เพื่อให้ผลลัพธ์มีประโยชน์มากขึ้นเราสามารถทำซ้ำหลาย ๆ ตัวแปรที่ส่งผ่านไปยังฟังก์ชันของเราโดยสมมติว่าแต่ละคำในอาเรย์อาร์กิวเมนต์เป็นชื่อตัวแปร ผลลัพธ์จะเป็นดังนี้:

serialize() {
    for var in $@; do
        typeset -p "$var" > "./serialized_$var.sh"
    done
}

deserialize() {
    declare() { builtin declare -g "$@"; }
    typeset() { builtin typeset -g "$@"; }
    for var in $@; do
        source "./serialized_$var.sh"
    done
    unset -f declare typeset
}

ด้วยวิธีใดวิธีการใช้งานจะเป็นดังนี้:

# Load some test data into variables
FOO=(an array or something)
BAR=$(uptime)

# Save it out to our serialized data files
serialize FOO BAR

# For testing purposes unset the variables to we know if it worked
unset FOO BAR

# Load  the data back in from out data files
deserialize FOO BAR

echo "FOO: $FOO\nBAR: $BAR"

ใช้การเปลี่ยนเส้นทางการทดแทนคำสั่งและการขยายพารามิเตอร์ ต้องใช้เครื่องหมายอัญประกาศคู่เพื่อรักษาช่องว่างและอักขระพิเศษ การติดตามxจะบันทึกบรรทัดใหม่ต่อท้ายซึ่งจะถูกลบออกเป็นอย่างอื่นในการทดแทนคำสั่ง

#!/bin/bash
echo "$var"x > file
unset var
var="$(< file)"
var=${var%x}

ทำให้เป็นอนุกรมทั้งหมด - POSIX

ใน POSIX เชลล์ใด ๆ คุณสามารถซีเรียลexport -pไลซ์ตัวแปรสภาพแวดล้อมทั้งหมดด้วย สิ่งนี้ไม่รวมตัวแปรเชลล์ที่ไม่ได้ถูกเอ็กซ์พอร์ต เอาต์พุตถูกยกมาอย่างเหมาะสมเพื่อให้คุณสามารถอ่านได้ในเชลล์เดียวกันและรับค่าตัวแปรที่เหมือนกันทั้งหมด เอาต์พุตอาจไม่สามารถอ่านได้ในเชลล์อื่นตัวอย่างเช่น ksh ใช้$'…'ไวยากรณ์ที่ไม่ใช่ POSIX

save_environment () {
  export -p >my_environment
}
restore_environment () {
  . ./my_environment
}

ทำให้เป็นอันดับบางส่วนหรือทั้งหมด - ksh, bash, zsh

Ksh (ทั้ง pdksh / mksh และ ATT ksh), bash และ zsh ให้สิ่งอำนวยความสะดวกที่ดีกว่าด้วยtypesetbuiltin typeset -pพิมพ์ตัวแปรที่กำหนดไว้ทั้งหมดและค่าของมัน (zsh ละเว้นค่าของตัวแปรที่ซ่อนไว้ด้วยtypeset -H) เอาต์พุตมีการประกาศที่เหมาะสมเพื่อให้ตัวแปรสภาพแวดล้อมถูกส่งออกเมื่ออ่านกลับ (แต่ถ้าตัวแปรถูกส่งออกไปแล้วเมื่ออ่านกลับจะไม่ถูกยกเลิกการเอ็กซ์พอร์ต) ดังนั้นอาร์เรย์จะถูกอ่านกลับเป็นอาร์เรย์ ฯลฯ ที่นี่เช่นกันเอาต์พุต อ้างถึงอย่างถูกต้อง แต่รับประกันว่าจะสามารถอ่านได้ในเชลล์เดียวกันเท่านั้น คุณสามารถส่งชุดของตัวแปรเพื่อทำให้เป็นอนุกรมในบรรทัดคำสั่ง หากคุณไม่ผ่านตัวแปรใด ๆ แล้วทั้งหมดจะต่อเนื่องกัน

save_some_variables () {
  typeset -p VAR OTHER_VAR >some_vars
}

ใน bash และ zsh การกู้คืนไม่สามารถทำได้จากฟังก์ชันเนื่องจากtypesetคำสั่งภายในฟังก์ชันถูกกำหนดขอบเขตให้กับฟังก์ชันนั้น คุณต้องเรียกใช้. ./some_varsในบริบทที่คุณต้องการใช้ค่าของตัวแปรดูแลว่าตัวแปรที่เป็นโกลบอลเมื่อส่งออกจะถูกประกาศใหม่เป็นโกลบอล หากคุณต้องการอ่านค่าภายในฟังก์ชั่นและส่งออกคุณสามารถประกาศนามแฝงหรือฟังก์ชั่นชั่วคราว ใน zsh:

restore_and_make_all_global () {
  alias typeset='typeset -g'
  . ./some_vars
  unalias typeset
}

ใน bash (ซึ่งใช้declareแทนtypeset):

restore_and_make_all_global () {
  alias declare='declare -g'
  shopt -s expand_aliases
  . ./some_vars
  unalias declare
}

ใน ksh, typesetประกาศตัวแปรท้องถิ่นในฟังก์ชั่นที่กำหนดไว้กับและตัวแปรระดับโลกในฟังก์ชั่นที่กำหนดไว้กับfunction function_name { … }function_name () { … }

ทำให้เป็นอันดับบางส่วน - POSIX

หากคุณต้องการการควบคุมมากขึ้นคุณสามารถส่งออกเนื้อหาของตัวแปรด้วยตนเอง หากต้องการพิมพ์เนื้อหาของตัวแปรลงในไฟล์ให้ใช้printfบิวอิน ( echoมีบางกรณีพิเศษเช่นecho -nบนเชลล์บางตัวและเพิ่มบรรทัดใหม่):

printf %s "$VAR" >VAR.content

คุณสามารถอ่านย้อนหลังนี้$(cat VAR.content)ได้ยกเว้นว่าการทดแทนคำสั่งจะตัดการขึ้นบรรทัดใหม่ต่อท้าย เพื่อหลีกเลี่ยงรอยย่นนี้ให้จัดการเอาต์พุตไม่ให้จบด้วยการขึ้นบรรทัดใหม่เลยทีเดียว

VAR=$(cat VAR.content && echo a)
if [ $? -ne 0 ]; then echo 1>&2 "Error reading back VAR"; exit 2; fi
VAR=${VAR%?}

'\''หากคุณต้องการพิมพ์หลายตัวแปรคุณสามารถพูดกับพวกเขาด้วยคำพูดเดียวและแทนที่ทั้งหมดฝังตัวราคาเดียวกับ การอ้างอิงรูปแบบนี้สามารถอ่านกลับเข้าไปในเชลล์สไตล์ Bourne / POSIX ตัวอย่างต่อไปนี้ใช้งานได้ในเชลล์ POSIX ใด ๆ มันใช้งานได้กับตัวแปรสตริงเท่านั้น (และตัวแปรตัวเลขในเชลล์ที่มีพวกเขาแม้ว่าพวกเขาจะถูกอ่านกลับเป็นสตริง) แต่ก็ไม่ได้พยายามจัดการกับตัวแปรอาร์เรย์ในเชลล์ที่มีพวกเขา

serialize_variables () {
  for __serialize_variables_x do
    eval "printf $__serialize_variables_x=\\'%s\\'\\\\n \"\$${__serialize_variables_x}\"" |
    sed -e "s/'/'\\\\''/g" -e '1 s/=.../=/' -e '$ s/...$//'
  done
}

นี่เป็นอีกวิธีหนึ่งที่ไม่แยกกระบวนการย่อย แต่หนักกว่าในการจัดการสตริง

serialize_variables () {
  for __serialize_variables_var do
    eval "__serialize_variables_tail=\${$__serialize_variables_var}"
    while __serialize_variables_quoted="$__serialize_variables_quoted${__serialize_variables_tail%%\'*}"
          [ "${__serialize_variables_tail%%\'*}" != "$__serialize_variables_tail" ]; do
      __serialize_variables_tail="${__serialize_variables_tail#*\'}"
      __serialize_variables_quoted="${__serialize_variables_quoted}'\\''"
    done
    printf "$__serialize_variables_var='%s'\n" "$__serialize_variables_quoted"
  done
}

โปรดทราบว่าในเชลล์ที่อนุญาตให้ใช้ตัวแปรแบบอ่านอย่างเดียวคุณจะได้รับข้อผิดพลาดหากคุณพยายามอ่านตัวแปรที่เป็นแบบอ่านอย่างเดียว

ขอบคุณมากที่ @ stéphane-chazelas ซึ่งชี้ให้เห็นปัญหาทั้งหมดที่เกิดขึ้นกับความพยายามครั้งก่อนของฉันตอนนี้ดูเหมือนจะทำงานเพื่อจัดลำดับอาร์เรย์ให้ stdout หรือเป็นตัวแปร

เทคนิคนี้ไม่ได้แยกวิเคราะห์อินพุต (ต่างจากdeclare -a/ declare -p) และปลอดภัยต่อการแทรกตัวเมตาอักขระในข้อความที่ต่อเนื่อง

หมายเหตุ: การขึ้นบรรทัดใหม่จะไม่ถูก Escape เนื่องจากreadลบ\<newlines>คู่อักขระดังนั้น-d ...ต้องส่งผ่านไปยังการอ่านแทนจากนั้นการขึ้นบรรทัดใหม่ที่ไม่ใช้ค่า Escape จะถูกสงวนไว้

ทั้งหมดนี้ได้รับการจัดการในunserialiseฟังก์ชั่น

มีการใช้อักขระเวทมนตร์สองตัวตัวคั่นฟิลด์และตัวแยกเรคคอร์ด (เพื่อให้สามารถใช้หลายอาร์เรย์ในการสตรีมเดียวกันได้)

ตัวละครเหล่านี้สามารถกำหนดเป็นFSและRSแต่ไม่สามารถกำหนดเป็นตัวละครเพราะการขึ้นบรรทัดใหม่หนีจะถูกลบออกโดยnewlineread

อักขระ escape ต้องเป็น\แบ็กสแลชเนื่องจากเป็นสิ่งที่ใช้readเพื่อหลีกเลี่ยงอักขระที่ถูกจดจำเป็นIFSอักขระ

serialiseจะทำให้เป็นอันดับ"$@"เพื่อ stdout serialise_toจะเป็นแบบอนุกรมไปยัง varable ชื่อใน$1

serialise() {
  set -- "${@//\\/\\\\}" # \
  set -- "${@//${FS:-;}/\\${FS:-;}}" # ; - our field separator
  set -- "${@//${RS:-:}/\\${RS:-:}}" # ; - our record separator
  local IFS="${FS:-;}"
  printf ${SERIALIZE_TARGET:+-v"$SERIALIZE_TARGET"} "%s" "$*${RS:-:}"
}
serialise_to() {
  SERIALIZE_TARGET="$1" serialise "${@:2}"
}
unserialise() {
  local IFS="${FS:-;}"
  if test -n "$2"
  then read -d "${RS:-:}" -a "$1" <<<"${*:2}"
  else read -d "${RS:-:}" -a "$1"
  fi
}

และ unserialise กับ:

unserialise data # read from stdin

หรือ

unserialise data "$serialised_data" # from args

เช่น

$ serialise "Now is the time" "For all good men" "To drink \$drink" "At the \`party\`" $'Party\tParty\tParty'
Now is the time;For all good men;To drink $drink;At the `party`;Party   Party   Party:

(ไม่ขึ้นบรรทัดใหม่ตามท้าย)

อ่านมันกลับมา:

$ serialise_to s "Now is the time" "For all good men" "To drink \$drink" "At the \`party\`" $'Party\tParty\tParty'
$ unserialise array "$s"
$ echo "${array[@]/#/$'\n'}"

Now is the time 
For all good men 
To drink $drink 
At the `party` 
Party   Party   Party

หรือ

unserialise array # read from stdin

Bash readเคารพตัวละคร escape \(เว้นแต่คุณจะผ่านแฟล็ก -r) เพื่อลบความหมายพิเศษของตัวละครเช่นสำหรับการแยกฟิลด์อินพุตหรือการคั่นบรรทัด

หากคุณต้องการทำให้เป็นอันดับอาร์เรย์แทนที่จะเป็นรายการอาร์กิวเมนต์เพียงแค่ผ่านอาร์เรย์ของคุณเป็นรายการอาร์กิวเมนต์:

serialise_array "${my_array[@]}"

คุณสามารถใช้unserialiseในการวนซ้ำเช่นเดียวกับที่คุณทำreadเพราะมันเป็นเพียงการอ่านแบบห่อ แต่จำไว้ว่ากระแสไม่ได้ขึ้นบรรทัดใหม่:

while unserialise array
do ...
done

คุณสามารถใช้base64:

$ VAR="1/ 
,x"
$ echo "$VAR" | base64 > f
$ VAR=$(cat f | base64 -d)
$ echo "${VAR}X"
1/ 
,xX

printf 'VAR=$(cat <<\'$$VAR$$'\n%s\n'$$VAR$$'\n)' "$VAR" >./VAR.file

อีกวิธีในการดำเนินการคือเพื่อให้แน่ใจว่าคุณจัดการกับข้อความอ้างอิงทั้งหมด'เช่นนี้:

sed '"s/'"'/&"&"&/g;H;1h;$!d;g;'"s/.*/VAR='&'/" <<$$VAR$$ >./VAR.file
$VAR
$$VAR$$

หรือด้วยexport:

env - "VAR=$VAR" sh -c 'export -p' >./VAR.file 

ตัวเลือกแรกและตัวที่สองทำงานในเปลือก POSIX ใด ๆ โดยสมมติว่าค่าของตัวแปรไม่มีสตริง:

"\n${CURRENT_SHELLS_PID}VAR${CURRENT_SHELLS_PID}\n" 

ตัวเลือกที่สามควรจะทำงานใด ๆ POSIX เปลือก แต่อาจพยายามที่จะกำหนดตัวแปรอื่น ๆ เช่นหรือ_ PWDความจริงก็คือว่าตัวแปรเพียงอย่างเดียวที่มันอาจพยายามกำหนดนั้นถูกตั้งค่าและดูแลโดยเชลล์เอง - และแม้ว่าคุณจะนำเข้าexportมูลค่าของสิ่งใดสิ่งหนึ่ง - เช่น$PWDเชลล์จะรีเซ็ตพวกเขาเป็น ค่าที่ถูกต้องทันทีต่อไป - ลองทำPWD=any_valueและดูเอง

และเนื่องจาก - อย่างน้อยด้วย GNU's bash- debug output จะปลอดภัยโดยอัตโนมัติสำหรับ re-input ไปยัง shell สิ่งนี้ทำงานได้โดยไม่คำนึงถึงจำนวนของ'hard-quote ใน"$VAR":

 PS4= VAR=$VAR sh -cx 'VAR=$VAR' 2>./VAR.file

$VAR สามารถตั้งค่าในภายหลังเป็นค่าที่บันทึกในสคริปต์ใด ๆ ที่พา ธ ต่อไปนี้ใช้ได้กับ:

. ./VAR.file

เกือบเหมือนกัน แต่แตกต่างกันเล็กน้อย:

จากสคริปต์ของคุณ:

#!/usr/bin/ksh 

save_var()
{

    (for ITEM in $*
    do
        LVALUE='${'${ITEM}'}'
        eval RVALUE="$LVALUE"
        echo "$ITEM=\"$RVALUE\""  
    done) >> $cfg_file
}

restore_vars()
{
    . $cfg_file
}

cfg_file=config_file
MY_VAR1="Test value 1"
MY_VAR2="Test 
value 2"

save_var MY_VAR1 MY_VAR2
MY_VAR1=""
MY_VAR2=""

restore_vars 

echo "$MY_VAR1"
echo "$MY_VAR2"

เวลานี้ผ่านการทดสอบแล้ว