Bagaimana saya bisa mem-parsing file YAML dari skrip shell Linux?

Saya ingin menyediakan file konfigurasi terstruktur yang semudah mungkin untuk diedit oleh pengguna non-teknis (sayangnya itu harus berupa file) dan jadi saya ingin menggunakan YAML. Saya tidak dapat menemukan cara untuk menguraikan ini dari skrip shell Unix.

Kasing penggunaan saya mungkin atau mungkin tidak persis sama dengan apa yang ditanyakan oleh posting asli ini, tetapi pasti mirip.

Saya perlu menarik beberapa YAML sebagai variabel bash. YAML tidak akan pernah lebih dari satu level.

YAML terlihat seperti ini:

KEY:                value
ANOTHER_KEY:        another_value
OH_MY_SO_MANY_KEYS: yet_another_value
LAST_KEY:           last_value

Output like-a dis:

KEY="value"
ANOTHER_KEY="another_value"
OH_MY_SO_MANY_KEYS="yet_another_value"
LAST_KEY="last_value"

Saya mencapai output dengan baris ini:

sed -e 's/:[^:\/\/]/="/g;s/$/"/g;s/ *=/=/g' file.yaml > file.sh

• s/:[^:\/\/]/="/gmenemukan :dan menggantinya dengan =", sementara mengabaikan ://(untuk URL)
• s/$/"/gditambahkan "ke akhir setiap baris
• s/ *=/=/g menghapus semua spasi sebelumnya =

Berikut ini adalah pengurai bash-only yang memanfaatkan sed dan awk untuk mengurai file yaml sederhana:

function parse_yaml {
   local prefix=$2
   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -ne "s|^\($s\):|\1|" \
        -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
        -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p"  $1 |
   awk -F$fs '{
      indent = length($1)/2;
      vname[indent] = $2;
      for (i in vname) {if (i > indent) {delete vname[i]}}
      if (length($3) > 0) {
         vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
         printf("%s%s%s=\"%s\"\n", "'$prefix'",vn, $2, $3);
      }
   }'
}

Ini memahami file seperti:

## global definitions
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## output
output:
   file: "yes"

Yang mana, ketika diuraikan menggunakan:

parse_yaml sample.yml

akan menampilkan:

global_debug="yes"
global_verbose="no"
global_debugging_detailed="no"
global_debugging_header="debugging started"
output_file="yes"

ia juga memahami file yaml, dihasilkan oleh ruby ​​yang mungkin menyertakan simbol ruby, seperti:

---
:global:
  :debug: 'yes'
  :verbose: 'no'
  :debugging:
    :detailed: 'no'
    :header: debugging started
  :output: 'yes'

dan akan menampilkan yang sama seperti pada contoh sebelumnya.

penggunaan khas dalam skrip adalah:

eval $(parse_yaml sample.yml)

parse_yaml menerima argumen awalan sehingga pengaturan yang diimpor semua memiliki awalan umum (yang akan mengurangi risiko tabrakan namespace).

parse_yaml sample.yml "CONF_"

hasil:

CONF_global_debug="yes"
CONF_global_verbose="no"
CONF_global_debugging_detailed="no"
CONF_global_debugging_header="debugging started"
CONF_output_file="yes"

Perhatikan bahwa pengaturan sebelumnya dalam file dapat dirujuk dengan pengaturan selanjutnya:

## global definitions
global:
  debug: yes
  verbose: no
  debugging:
    detailed: no
    header: "debugging started"

## output
output:
   debug: $global_debug

Penggunaan bagus lainnya adalah mem-parsing file default terlebih dahulu dan kemudian pengaturan pengguna, yang berfungsi karena pengaturan yang terakhir menimpa yang pertama:

eval $(parse_yaml defaults.yml)
eval $(parse_yaml project.yml)

Saya telah menulis shyamldengan python untuk kebutuhan permintaan YAML dari baris perintah shell.

Gambaran:

$ pip install shyaml      ## installation

File YAML contoh (dengan fitur kompleks):

$ cat <<EOF > test.yaml
name: "MyName !!"
subvalue:
    how-much: 1.1
    things:
        - first
        - second
        - third
    other-things: [a, b, c]
    maintainer: "Valentin Lab"
    description: |
        Multiline description:
        Line 1
        Line 2
EOF

Permintaan dasar:

$ cat test.yaml | shyaml get-value subvalue.maintainer
Valentin Lab

Permintaan perulangan yang lebih kompleks pada nilai-nilai kompleks:

$ cat test.yaml | shyaml values-0 | \
  while read -r -d $'\0' value; do
      echo "RECEIVED: '$value'"
  done
RECEIVED: '1.1'
RECEIVED: '- first
- second
- third'
RECEIVED: '2'
RECEIVED: 'Valentin Lab'
RECEIVED: 'Multiline description:
Line 1
Line 2'

Beberapa poin kunci:

• semua tipe YAML dan keanehan sintaks ditangani dengan benar, seperti multiline, string yang dikutip, urutan inline ...
• \0 output empuk tersedia untuk manipulasi entri multiline padat.
• notasi sederhana bertitik untuk memilih sub-nilai (yaitu: subvalue.maintaineradalah kunci yang valid).
• akses menurut indeks disediakan untuk urutan (yaitu: subvalue.things.-1adalah elemen terakhir dari subvalue.thingsurutan.)
• akses ke semua elemen urutan / struct dalam satu jalan untuk digunakan dalam loop bash.
• Anda dapat menampilkan seluruh bagian dari file YAML sebagai ... YAML, yang berbaur dengan baik untuk manipulasi lebih lanjut dengan shyaml.

Lebih banyak sampel dan dokumentasi tersedia di halaman shyaml github atau halaman shyaml PyPI .

yq adalah prosesor YAML baris perintah yang ringan dan portabel

Tujuan dari proyek ini adalah untuk menjadi jq atau sed file yaml.

( https://github.com/mikefarah/yq#readme )

Sebagai contoh (dicuri langsung dari dokumentasi ), diberikan file sample.yaml dari:

---
bob:
  item1:
    cats: bananas
  item2:
    cats: apples

kemudian

yq r sample.yaml bob.*.cats

akan menampilkan

- bananas
- apples

Dimungkinkan untuk mengirimkan skrip kecil ke beberapa penerjemah, seperti Python. Cara mudah untuk melakukannya menggunakan Ruby dan pustaka YAML-nya adalah sebagai berikut:

$ RUBY_SCRIPT="data = YAML::load(STDIN.read); puts data['a']; puts data['b']"
$ echo -e '---\na: 1234\nb: 4321' | ruby -ryaml -e "$RUBY_SCRIPT"
1234
4321

, di mana datahash (atau array) dengan nilai-nilai dari yaml.

Sebagai bonus, itu akan mengurai masalah depan Jekyll baik-baik saja.

ruby -ryaml -e "puts YAML::load(open(ARGV.first).read)['tags']" example.md

Mengingat bahwa Python3 dan PyYAML adalah dependensi yang cukup mudah untuk dipenuhi saat ini, berikut ini dapat membantu:

yaml() {
    python3 -c "import yaml;print(yaml.safe_load(open('$1'))$2)"
}

VALUE=$(yaml ~/my_yaml_file.yaml "['a_key']")

di sini versi lanjutan dari jawaban Stefan Farestam:

function parse_yaml {
   local prefix=$2
   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -ne "s|,$s\]$s\$|]|" \
        -e ":1;s|^\($s\)\($w\)$s:$s\[$s\(.*\)$s,$s\(.*\)$s\]|\1\2: [\3]\n\1  - \4|;t1" \
        -e "s|^\($s\)\($w\)$s:$s\[$s\(.*\)$s\]|\1\2:\n\1  - \3|;p" $1 | \
   sed -ne "s|,$s}$s\$|}|" \
        -e ":1;s|^\($s\)-$s{$s\(.*\)$s,$s\($w\)$s:$s\(.*\)$s}|\1- {\2}\n\1  \3: \4|;t1" \
        -e    "s|^\($s\)-$s{$s\(.*\)$s}|\1-\n\1  \2|;p" | \
   sed -ne "s|^\($s\):|\1|" \
        -e "s|^\($s\)-$s[\"']\(.*\)[\"']$s\$|\1$fs$fs\2|p" \
        -e "s|^\($s\)-$s\(.*\)$s\$|\1$fs$fs\2|p" \
        -e "s|^\($s\)\($w\)$s:$s[\"']\(.*\)[\"']$s\$|\1$fs\2$fs\3|p" \
        -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" | \
   awk -F$fs '{
      indent = length($1)/2;
      vname[indent] = $2;
      for (i in vname) {if (i > indent) {delete vname[i]; idx[i]=0}}
      if(length($2)== 0){  vname[indent]= ++idx[indent] };
      if (length($3) > 0) {
         vn=""; for (i=0; i<indent; i++) { vn=(vn)(vname[i])("_")}
         printf("%s%s%s=\"%s\"\n", "'$prefix'",vn, vname[indent], $3);
      }
   }'
}

Versi ini mendukung -notasi dan notasi singkat untuk kamus dan daftar. Input berikut:

global:
  input:
    - "main.c"
    - "main.h"
  flags: [ "-O3", "-fpic" ]
  sample_input:
    -  { property1: value, property2: "value2" }
    -  { property1: "value3", property2: 'value 4' }

menghasilkan output ini:

global_input_1="main.c"
global_input_2="main.h"
global_flags_1="-O3"
global_flags_2="-fpic"
global_sample_input_1_property1="value"
global_sample_input_1_property2="value2"
global_sample_input_2_property1="value3"
global_sample_input_2_property2="value 4"

karena Anda dapat melihat -item secara otomatis diberi nomor untuk mendapatkan nama variabel yang berbeda untuk setiap item. Di bashsana tidak ada array multidimensi, jadi ini adalah salah satu cara untuk mengatasinya. Beberapa level didukung. Untuk mengatasi masalah dengan membuntuti spasi putih yang disebutkan oleh @briceburg, seseorang harus menyertakan nilai dalam tanda kutip tunggal atau ganda. Namun, masih ada beberapa batasan: Perluasan kamus dan daftar dapat menghasilkan hasil yang salah ketika nilai mengandung koma. Juga, struktur yang lebih kompleks seperti nilai yang mencakup banyak garis (seperti kunci ssh) belum didukung.

Beberapa kata tentang kode: sedPerintah pertama memperluas bentuk kamus singkat { key: value, ...}menjadi reguler dan mengubahnya menjadi gaya yaml yang lebih sederhana. sedPanggilan kedua melakukan hal yang sama untuk notasi singkat daftar dan mengkonversi [ entry, ... ]ke daftar item dengan -notasi. sedPanggilan ketiga adalah yang asli yang menangani kamus normal, sekarang dengan tambahan untuk menangani daftar -dan lekukan. Bagian ini awkmemperkenalkan indeks untuk setiap tingkat lekukan dan meningkatkannya ketika nama variabel kosong (yaitu saat memproses daftar). Nilai saat ini dari penghitung digunakan sebagai ganti vname kosong. Saat naik satu tingkat, penghitungnya akan memusatkan perhatian.

Sunting: Saya telah membuat repositori github untuk ini.

Sulit dikatakan karena itu tergantung pada apa yang Anda ingin parser untuk mengekstrak dari dokumen YAML Anda. Untuk kasus sederhana, Anda mungkin dapat menggunakan grep, cut, awkdll Untuk lebih parsing kompleks Anda akan perlu menggunakan full-blown parsing perpustakaan seperti Python PyYAML atau YAML :: Perl .

Saya baru saja menulis parser yang saya sebut Yay! ( Yaml bukan Yamlesque! ) Yang mem-parsing Yamlesque , sebagian kecil dari YAML. Jadi, jika Anda mencari parser YAML yang 100% sesuai untuk Bash maka ini bukan. Namun, untuk mengutip OP, jika Anda ingin file konfigurasi terstruktur yang semudah mungkin untuk pengguna non-teknis untuk mengedit yang seperti YAML, ini mungkin menarik.

Itu diinspirasi oleh jawaban sebelumnya tetapi menulis array asosiatif ( ya, ini membutuhkan Bash 4.x ) bukan variabel dasar. Ia melakukannya dengan cara yang memungkinkan data diurai tanpa pengetahuan sebelumnya tentang kunci sehingga kode yang digerakkan oleh data dapat ditulis.

Selain elemen array kunci / nilai, setiap array memiliki keysarray yang berisi daftar nama kunci, childrenarray yang berisi nama array anak dan parentkunci yang merujuk ke induknya.

Ini adalah contoh dari Yamlesque:

root_key1: this is value one
root_key2: "this is value two"

drink:
  state: liquid
  coffee:
    best_served: hot
    colour: brown
  orange_juice:
    best_served: cold
    colour: orange

food:
  state: solid
  apple_pie:
    best_served: warm

root_key_3: this is value three

Berikut adalah contoh yang menunjukkan cara menggunakannya:

#!/bin/bash
# An example showing how to use Yay

. /usr/lib/yay

# helper to get array value at key
value() { eval echo \${$1[$2]}; }

# print a data collection
print_collection() {
  for k in $(value $1 keys)
  do
    echo "$2$k = $(value $1 $k)"
  done

  for c in $(value $1 children)
  do
    echo -e "$2$c\n$2{"
    print_collection $c "  $2"
    echo "$2}"
  done
}

yay example
print_collection example

yang keluaran:

root_key1 = this is value one
root_key2 = this is value two
root_key_3 = this is value three
example_drink
{
  state = liquid
  example_coffee
  {
    best_served = hot
    colour = brown
  }
  example_orange_juice
  {
    best_served = cold
    colour = orange
  }
}
example_food
{
  state = solid
  example_apple_pie
  {
    best_served = warm
  }
}

Dan di sini adalah pengurai:

yay_parse() {

   # find input file
   for f in "$1" "$1.yay" "$1.yml"
   do
     [[ -f "$f" ]] && input="$f" && break
   done
   [[ -z "$input" ]] && exit 1

   # use given dataset prefix or imply from file name
   [[ -n "$2" ]] && local prefix="$2" || {
     local prefix=$(basename "$input"); prefix=${prefix%.*}
   }

   echo "declare -g -A $prefix;"

   local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
   sed -n -e "s|^\($s\)\($w\)$s:$s\"\(.*\)\"$s\$|\1$fs\2$fs\3|p" \
          -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" "$input" |
   awk -F$fs '{
      indent       = length($1)/2;
      key          = $2;
      value        = $3;

      # No prefix or parent for the top level (indent zero)
      root_prefix  = "'$prefix'_";
      if (indent ==0 ) {
        prefix = "";          parent_key = "'$prefix'";
      } else {
        prefix = root_prefix; parent_key = keys[indent-1];
      }

      keys[indent] = key;

      # remove keys left behind if prior row was indented more than this row
      for (i in keys) {if (i > indent) {delete keys[i]}}

      if (length(value) > 0) {
         # value
         printf("%s%s[%s]=\"%s\";\n", prefix, parent_key , key, value);
         printf("%s%s[keys]+=\" %s\";\n", prefix, parent_key , key);
      } else {
         # collection
         printf("%s%s[children]+=\" %s%s\";\n", prefix, parent_key , root_prefix, key);
         printf("declare -g -A %s%s;\n", root_prefix, key);
         printf("%s%s[parent]=\"%s%s\";\n", root_prefix, key, prefix, parent_key);
      }
   }'
}

# helper to load yay data file
yay() { eval $(yay_parse "$@"); }

Ada beberapa dokumentasi dalam file sumber tertaut dan di bawah ini adalah penjelasan singkat tentang apa yang kode lakukan.

The yay_parseFungsi pertama menempatkan inputfile atau keluar dengan status keluar dari 1. Berikutnya, menentukan dataset prefix, baik secara eksplisit ditentukan atau berasal dari nama file.

Ini menulis bashperintah yang valid untuk output standar yang, jika dijalankan, menentukan array yang mewakili konten file data input. Yang pertama dari ini mendefinisikan array tingkat atas:

echo "declare -g -A $prefix;"

Perhatikan bahwa deklarasi array adalah asosiatif ( -A) yang merupakan fitur dari Bash versi 4. Deklarasi juga global ( -g) sehingga dapat dieksekusi dalam suatu fungsi tetapi tersedia untuk lingkup global seperti yayhelper:

yay() { eval $(yay_parse "$@"); }

Data input awalnya diproses dengan sed. Ini menghapus garis yang tidak cocok dengan spesifikasi format Yamlesque sebelum membatasi bidang Yamlesque yang valid dengan karakter Pemisah File ASCII dan menghapus tanda kutip ganda di sekitar bidang nilai.

 local s='[[:space:]]*' w='[a-zA-Z0-9_]*' fs=$(echo @|tr @ '\034')
 sed -n -e "s|^\($s\)\($w\)$s:$s\"\(.*\)\"$s\$|\1$fs\2$fs\3|p" \
        -e "s|^\($s\)\($w\)$s:$s\(.*\)$s\$|\1$fs\2$fs\3|p" "$input" |

Kedua ungkapan itu serupa; mereka berbeda hanya karena yang pertama mengambil nilai yang dikutip sedangkan yang kedua memilih yang tidak dikutip.

The Berkas Separator (28 / hex 12 / oktal 034) digunakan karena, sebagai karakter non-printable, itu tidak mungkin dalam data masukan.

Hasilnya disalurkan ke awkmana memproses inputnya satu baris pada satu waktu. Ini menggunakan karakter FS untuk menetapkan setiap bidang ke variabel:

indent       = length($1)/2;
key          = $2;
value        = $3;

Semua baris memiliki indent (mungkin nol) dan kunci tetapi mereka tidak semua memiliki nilai. Ini menghitung tingkat indentasi untuk garis yang membagi panjang bidang pertama, yang berisi spasi putih terkemuka, sebanyak dua. Item tingkat atas tanpa indentasi berada pada level indent nol.

Selanjutnya, ia mengetahui apa yang prefixharus digunakan untuk item saat ini. Inilah yang akan ditambahkan ke nama kunci untuk membuat nama array. Ada untuk root_prefixlarik level atas yang didefinisikan sebagai nama kumpulan data dan garis bawah:

root_prefix  = "'$prefix'_";
if (indent ==0 ) {
  prefix = "";          parent_key = "'$prefix'";
} else {
  prefix = root_prefix; parent_key = keys[indent-1];
}

Ini parent_keyadalah kunci pada level indent di atas level indentasi baris saat ini dan mewakili koleksi yang menjadi bagian dari baris saat ini. Pasangan kunci / nilai koleksi akan disimpan dalam array dengan namanya didefinisikan sebagai gabungan dari prefixdan parent_key.

Untuk tingkat atas (tingkat indentasi nol) awalan kumpulan data digunakan sebagai kunci induk sehingga tidak memiliki awalan (diatur ke ""). Semua array lainnya diawali dengan awalan root.

Selanjutnya, kunci saat ini dimasukkan ke dalam array (awk-internal) yang berisi kunci. Array ini tetap ada sepanjang seluruh sesi awk dan karenanya berisi kunci yang dimasukkan oleh baris sebelumnya. Kunci tersebut dimasukkan ke dalam array menggunakan indentasinya sebagai indeks array.

keys[indent] = key;

Karena array ini berisi kunci dari baris sebelumnya, kunci apa pun dengan parutan level indentasi dari level indentasi baris saat ini dihapus:

 for (i in keys) {if (i > indent) {delete keys[i]}}

Ini meninggalkan array kunci yang berisi gantungan kunci dari root pada level indent 0 ke baris saat ini. Ini menghapus kunci basi yang tersisa ketika baris sebelumnya indentasi lebih dalam dari garis saat ini.

Bagian terakhir menampilkan bashperintah: baris input tanpa nilai memulai level indent baru ( koleksi dalam bahasa YAML) dan baris input dengan nilai menambahkan kunci ke koleksi saat ini.

Nama koleksi adalah gabungan dari baris saat ini prefixdan parent_key.

Ketika kunci memiliki nilai, kunci dengan nilai itu ditetapkan untuk koleksi saat ini seperti ini:

printf("%s%s[%s]=\"%s\";\n", prefix, parent_key , key, value);
printf("%s%s[keys]+=\" %s\";\n", prefix, parent_key , key);

Pernyataan pertama menghasilkan perintah untuk menetapkan nilai ke elemen array asosiatif yang dinamai setelah kunci dan yang kedua mengeluarkan perintah untuk menambahkan kunci ke keysdaftar dibatasi-ruang koleksi :

<current_collection>[<key>]="<value>";
<current_collection>[keys]+=" <key>";

Ketika kunci tidak memiliki nilai, koleksi baru dimulai seperti ini:

printf("%s%s[children]+=\" %s%s\";\n", prefix, parent_key , root_prefix, key);
printf("declare -g -A %s%s;\n", root_prefix, key);

Pernyataan pertama menghasilkan perintah untuk menambahkan koleksi baru ke childrendaftar terbatas-ruang koleksi saat ini dan yang kedua menampilkan perintah untuk mendeklarasikan array asosiatif baru untuk koleksi baru:

<current_collection>[children]+=" <new_collection>"
declare -g -A <new_collection>;

Semua output dari yay_parsedapat diurai sebagai perintah bash oleh perintah bash evalatau sourcebuilt-in.

perl -ne 'chomp; printf qq/%s="%s"\n/, split(/\s*:\s*/,$_,2)' file.yml > file.sh

Pilihan lain adalah mengonversi YAML ke JSON, kemudian menggunakan jq untuk berinteraksi dengan representasi JSON baik untuk mengekstrak informasi darinya atau mengeditnya.

Saya menulis skrip bash sederhana yang berisi lem ini - lihat proyek Y2J di GitHub

Jika Anda membutuhkan nilai tunggal, Anda bisa menggunakan alat yang mengubah dokumen YAML Anda menjadi JSON dan memberi makan jq, misalnya yq.

Isi dari sampel. Yaml:

---
bob:
  item1:
    cats: bananas
  item2:
    cats: apples
  thing:
    cats: oranges

Contoh:

$ yq -r '.bob["thing"]["cats"]' sample.yaml 
oranges

Saya tahu ini sangat spesifik, tetapi saya pikir jawaban saya dapat bermanfaat bagi pengguna tertentu.
Jika Anda memiliki nodedan npmmenginstal pada mesin Anda, Anda dapat menggunakan js-yaml.
Instal pertama:

npm i -g js-yaml
# or locally
npm i js-yaml

lalu di skrip bash Anda

#!/bin/bash
js-yaml your-yaml-file.yml

Juga jika Anda menggunakan jqAnda dapat melakukan sesuatu seperti itu

#!/bin/bash
json="$(js-yaml your-yaml-file.yml)"
aproperty="$(jq '.apropery' <<< "$json")"
echo "$aproperty"

Karena js-yaml mengkonversi file yaml ke string json literal. Anda kemudian dapat menggunakan string dengan parser json di sistem unix Anda.

Jika Anda memiliki python 2 dan PyYAML, Anda dapat menggunakan parser ini yang saya tulis disebut parse_yaml.py . Beberapa hal yang lebih rapi yang dilakukannya adalah membiarkan Anda memilih awalan (jika Anda memiliki lebih dari satu file dengan variabel yang sama) dan untuk mengambil nilai tunggal dari file yaml.

Sebagai contoh jika Anda memiliki file yaml ini:

staging.yaml:

db:
    type: sqllite
    host: 127.0.0.1
    user: dev
    password: password123

prod.yaml:

db:
    type: postgres
    host: 10.0.50.100
    user: postgres
    password: password123

Anda dapat memuat keduanya tanpa konflik.

$ eval $(python parse_yaml.py prod.yaml --prefix prod --cap)
$ eval $(python parse_yaml.py staging.yaml --prefix stg --cap)
$ echo $PROD_DB_HOST
10.0.50.100
$ echo $STG_DB_HOST
127.0.0.1

Dan bahkan cherry memilih nilai yang Anda inginkan.

$ prod_user=$(python parse_yaml.py prod.yaml --get db_user)
$ prod_port=$(python parse_yaml.py prod.yaml --get db_port --default 5432)
$ echo prod_user
postgres
$ echo prod_port
5432

Anda bisa menggunakan setara dengan yq yang ditulis dalam golang:

./go-yg -yamlFile /home/user/dev/ansible-firefox/defaults/main.yml -key
firefox_version

pengembalian:

62.0.3

Anda juga dapat mempertimbangkan menggunakan Grunt (Pelari Tugas JavaScript). Dapat dengan mudah diintegrasikan dengan shell. Ini mendukung pembacaan YAML ( grunt.file.readYAML) dan JSON (grunt.file.readJSON file ).

Ini dapat dicapai dengan membuat tugas di Gruntfile.js(atau Gruntfile.coffee), misalnya:

module.exports = function (grunt) {

    grunt.registerTask('foo', ['load_yml']);

    grunt.registerTask('load_yml', function () {
        var data = grunt.file.readYAML('foo.yml');
        Object.keys(data).forEach(function (g) {
          // ... switch (g) { case 'my_key':
        });
    });

};

kemudian dari shell cukup jalankan grunt foo(periksa grunt --helptugas yang tersedia).

Lebih jauh lagi, Anda dapat mengimplementasikan exec:footugas ( grunt-exec) dengan variabel input yang lulus dari tugas Anda ( foo: { cmd: 'echo bar <%= foo %>' }) untuk mencetak output dalam format apa pun yang Anda inginkan, kemudian menyalurkannya ke perintah lain.

Ada juga alat yang mirip dengan Grunt, itu disebut gulp dengan tambahan plugin gulp-yaml .

Instal melalui: npm install --save-dev gulp-yaml

Penggunaan sampel:

var yaml = require('gulp-yaml');

gulp.src('./src/*.yml')
  .pipe(yaml())
  .pipe(gulp.dest('./dist/'))

gulp.src('./src/*.yml')
  .pipe(yaml({ space: 2 }))
  .pipe(gulp.dest('./dist/'))

gulp.src('./src/*.yml')
  .pipe(yaml({ safe: true }))
  .pipe(gulp.dest('./dist/'))

Untuk lebih banyak opsi untuk berurusan dengan format YAML , periksa situs YAML untuk proyek, perpustakaan, dan sumber daya lain yang tersedia yang dapat membantu Anda untuk mem-parsing format itu.

Alat lainnya:

• Jshon

  mem-parsing, membaca dan membuat JSON

Saya tahu jawaban saya spesifik, tetapi jika seseorang sudah menginstal PHP dan Symfony , akan sangat berguna untuk menggunakan parser YAML milik Symfony.

Misalnya:

php -r "require '$SYMFONY_ROOT_PATH/vendor/autoload.php'; \
    var_dump(\Symfony\Component\Yaml\Yaml::parse(file_get_contents('$YAML_FILE_PATH')));"

Di sini saya hanya digunakan var_dumpuntuk menampilkan parsing array tetapi tentu saja Anda dapat melakukan lebih banyak lagi ... :)