Bagaimana cara mengambil nilai INI dalam skrip shell?

Saya memiliki file parameter.ini, seperti:

[parameters.ini]
    database_user    = user
    database_version = 20110611142248

Saya ingin membaca dan menggunakan versi database yang ditentukan dalam file parameter.ini dari dalam skrip bash shell sehingga saya dapat memprosesnya.

#!/bin/sh    
# Need to get database version from parameters.ini file to use in script    
php app/console doctrine:migrations:migrate $DATABASE_VERSION

Bagaimana saya melakukan ini?

Bagaimana kalau grep untuk baris itu lalu menggunakan awk

version=$(awk -F "=" '/database_version/ {print $2}' parameters.ini)

Anda dapat menggunakan bash native parser untuk menafsirkan nilai ini, dengan:

$ source <(grep = file.ini)

File contoh:

[section-a]
  var1=value1
  var2=value2
  IPS=( "1.2.3.4" "1.2.3.5" )

Untuk variabel akses, Anda hanya mencetak mereka: echo $var1. Anda juga dapat menggunakan array seperti yang ditunjukkan di atas (echo ${IPS[@]} ).

Jika Anda hanya ingin satu nilai, grep saja:

source <(grep var1 file.ini)

^{Untuk demo, periksa rekaman ini di asciinema .}

Ini sederhana karena Anda tidak memerlukan pustaka eksternal apa pun untuk mengurai data, tetapi ia memiliki beberapa kelemahan. Sebagai contoh:

• Jika Anda memiliki spasi di antara =(nama dan nilai variabel), maka Anda harus memotong spasi terlebih dahulu, misalnya

    $ source <(grep = file.ini | sed 's/ *= */=/g')

  Atau jika Anda tidak peduli dengan ruang (termasuk di tengah), gunakan:

    $ source <(grep = file.ini | tr -d ' ')

• Untuk mendukung ;komentar, gantilah dengan #:

    $ sed "s/;/#/g" foo.ini | source /dev/stdin

• Bagian tidak didukung (mis. Jika Anda pernah [section-name], maka Anda harus memfilternya seperti yang ditunjukkan di atas, misgrep = ), sama untuk kesalahan tak terduga lainnya.

  Jika Anda perlu membaca nilai tertentu di bawah bagian tertentu, penggunaan grep -A, sed, awkatauex ).

  Misalnya

    source <(grep = <(grep -A5 '\[section-b\]' file.ini))

  ^{Catatan: Di mana -A5jumlah baris untuk dibaca di bagian tersebut. Ganti sourcedengan catuntuk debug.}

• Jika Anda mendapatkan kesalahan penguraian, abaikan dengan menambahkan: 2>/dev/null

Lihat juga:

• Bagaimana cara mengurai dan mengonversi file ini menjadi variabel array bash?di serverfault SE
• Apakah ada alat untuk memodifikasi file gaya INI dari skrip shell

Bash tidak menyediakan parser untuk file-file ini. Jelas Anda dapat menggunakan perintah awk atau beberapa panggilan sed, tetapi jika Anda bash-priest dan tidak ingin menggunakan shell lain, maka Anda dapat mencoba kode tidak jelas berikut:

#!/usr/bin/env bash
cfg_parser ()
{
    ini="$(<$1)"                # read the file
    ini="${ini//[/\[}"          # escape [
    ini="${ini//]/\]}"          # escape ]
    IFS=$'\n' && ini=( ${ini} ) # convert to line-array
    ini=( ${ini[*]//;*/} )      # remove comments with ;
    ini=( ${ini[*]/\    =/=} )  # remove tabs before =
    ini=( ${ini[*]/=\   /=} )   # remove tabs after =
    ini=( ${ini[*]/\ =\ /=} )   # remove anything with a space around =
    ini=( ${ini[*]/#\\[/\}$'\n'cfg.section.} ) # set section prefix
    ini=( ${ini[*]/%\\]/ \(} )    # convert text2function (1)
    ini=( ${ini[*]/=/=\( } )    # convert item to array
    ini=( ${ini[*]/%/ \)} )     # close array parenthesis
    ini=( ${ini[*]/%\\ \)/ \\} ) # the multiline trick
    ini=( ${ini[*]/%\( \)/\(\) \{} ) # convert text2function (2)
    ini=( ${ini[*]/%\} \)/\}} ) # remove extra parenthesis
    ini[0]="" # remove first element
    ini[${#ini[*]} + 1]='}'    # add the last brace
    eval "$(echo "${ini[*]}")" # eval the result
}

cfg_writer ()
{
    IFS=' '$'\n'
    fun="$(declare -F)"
    fun="${fun//declare -f/}"
    for f in $fun; do
        [ "${f#cfg.section}" == "${f}" ] && continue
        item="$(declare -f ${f})"
        item="${item##*\{}"
        item="${item%\}}"
        item="${item//=*;/}"
        vars="${item//=*/}"
        eval $f
        echo "[${f#cfg.section.}]"
        for var in $vars; do
            echo $var=\"${!var}\"
        done
    done
}

Pemakaian:

# parse the config file called 'myfile.ini', with the following
# contents::
#   [sec2]
#   var2='something'
cfg.parser 'myfile.ini'

# enable section called 'sec2' (in the file [sec2]) for reading
cfg.section.sec2

# read the content of the variable called 'var2' (in the file
# var2=XXX). If your var2 is an array, then you can use
# ${var[index]}
echo "$var2"

Bash ini-parser dapat ditemukan di situs blog The Old School DevOps .

Sed one-liner, yang memperhitungkan beberapa bagian. File contoh:

[section1]
param1=123
param2=345
param3=678

[section2]
param1=abc
param2=def
param3=ghi

[section3]
param1=000
param2=111
param3=222

Katakanlah Anda menginginkan param2 dari bagian2. Jalankan perintah berikut:

sed -nr "/^\[section2\]/ { :l /^param2[ ]*=/ { s/.*=[ ]*//; p; q;}; n; b l;}" ./file.ini

akan memberimu

def

Cukup sertakan file .ini Anda ke dalam bash body:

File example.ini :

DBNAME=test
DBUSER=scott
DBPASSWORD=tiger

File example.sh

#!/bin/bash
#Including .ini file
. example.ini
#Test
echo "${DBNAME}   ${DBUSER}  ${DBPASSWORD}"

Semua solusi yang saya lihat sejauh ini juga sesuai dengan baris komentar. Yang ini tidak, jika kode komentarnya adalah ;:

awk -F '=' '{if (! ($0 ~ /^;/) && $0 ~ /database_version/) print $2}' file.ini

salah satu solusi yang lebih mungkin

dbver=$(sed -n 's/.*database_version *= *\([^ ]*.*\)/\1/p' < parameters.ini)
echo $dbver

Tampilkan nilai my_key dalam my_file gaya ini :

sed -n -e 's/^\s*my_key\s*=\s*//p' my_file

• -n - jangan mencetak apa pun secara default
• -e - jalankan ekspresinya
• s/PATTERN//p - tampilkan apa pun yang mengikuti pola ini Dalam pola:
• ^ - pola dimulai di awal baris
• \s - karakter spasi
• * - nol atau banyak (karakter spasi)

Contoh:

$ cat my_file
# Example INI file
something   = foo
my_key      = bar
not_my_key  = baz
my_key_2    = bing

$ sed -n -e 's/^\s*my_key\s*=\s*//p' my_file
bar

Begitu:

Temukan pola di mana baris dimulai dengan nol atau banyak karakter spasi, diikuti oleh string my_key , diikuti oleh nol atau banyak karakter spasi, tanda sama dengan, kemudian nol atau banyak karakter spasi putih lagi. Tampilkan sisa konten di baris itu mengikuti pola itu.

sed

Anda dapat menggunakan seduntuk mengurai file konfigurasi ini, terutama jika Anda memiliki nama bagian seperti:

# last modified 1 April 2001 by John Doe
[owner]
name=John Doe
organization=Acme Widgets Inc.

[database]
# use IP address in case network name resolution is not working
server=192.0.2.62
port=143
file=payroll.dat

sehingga Anda dapat menggunakan sedskrip berikut untuk mengurai data di atas:

# Configuration bindings found outside any section are given to
# to the default section.
1 {
  x
  s/^/default/
  x
}

# Lines starting with a #-character are comments.
/#/n

# Sections are unpacked and stored in the hold space.
/\[/ {
  s/\[\(.*\)\]/\1/
  x
  b
}

# Bindings are unpacked and decorated with the section
# they belong to, before being printed.
/=/ {
  s/^[[:space:]]*//
  s/[[:space:]]*=[[:space:]]*/|/
  G
  s/\(.*\)\n\(.*\)/\2|\1/
  p
}

ini akan mengubah data ini menjadi format datar ini:

owner|name|John Doe
owner|organization|Acme Widgets Inc.
database|server|192.0.2.62
database|port|143
database|file|payroll.dat

sehingga akan lebih mudah untuk mengurai menggunakan sed, awkatau readdengan memiliki nama bagian di setiap baris.

^{Kredit & sumber: File konfigurasi untuk skrip shell , Michael Grünewald}

Atau, Anda dapat menggunakan proyek ini chilladx/config-parser:, parser konfigurasi menggunakan sed.

Anda dapat menggunakan crudinialat untuk mendapatkan nilai ini, misalnya:

DATABASE_VERSION=$(crudini --get parameters.ini '' database_version)

Untuk orang-orang (seperti saya) yang ingin membaca file INI dari skrip shell (baca shell, bukan bash) - Saya telah membuat pustaka pembantu kecil yang mencoba melakukan hal itu:

https://github.com/wallyhall/shini (Lisensi MIT, lakukan sesuka Anda. Saya telah menautkan di atas termasuk inline karena kodenya cukup panjang.)

Ini agak lebih "rumit" daripada sedbaris sederhana yang disarankan di atas - tetapi bekerja dengan dasar yang sangat mirip.

Fungsi membaca dalam file baris demi baris - mencari penanda bagian ( [section]) dan kunci / nilai deklarasi ( key=value).

Pada akhirnya Anda mendapatkan panggilan balik ke fungsi Anda sendiri - bagian, kunci, dan nilai.

Mirip dengan jawaban Python lainnya, Anda dapat melakukan ini menggunakan -cbendera untuk menjalankan urutan pernyataan Python yang diberikan pada baris perintah:

$ python3 -c "import configparser; c = configparser.ConfigParser(); c.read('parameters.ini'); print(c['parameters.ini']['database_version'])"
20110611142248

Ini memiliki keuntungan karena hanya membutuhkan pustaka standar Python dan keuntungan tidak menulis file skrip terpisah.

Atau gunakan dokumen di sini agar lebih mudah dibaca, dengan demikian:

#!/bin/bash
python << EOI
import configparser
c = configparser.ConfigParser()
c.read('params.txt')
print c['chassis']['serialNumber']
EOI

serialNumber=$(python << EOI
import configparser
c = configparser.ConfigParser()
c.read('params.txt')
print c['chassis']['serialNumber']
EOI
)

echo $serialNumber

Beberapa jawaban tidak menghargai komentar. Beberapa tidak menghormati bagian. Beberapa hanya mengenali satu sintaks (hanya ":" atau hanya "="). Beberapa jawaban Python gagal di mesin saya karena perbedaan huruf kapital atau gagal mengimpor modul sys. Semuanya agak terlalu singkat bagi saya.

Jadi saya menulis sendiri, dan jika Anda memiliki Python modern, Anda mungkin dapat memanggil ini dari shell Bash Anda. Ini memiliki keuntungan karena mengikuti beberapa konvensi pengkodean Python umum, dan bahkan menyediakan pesan kesalahan yang masuk akal dan bantuan. Untuk menggunakannya, beri nama seperti myconfig.py (JANGAN menyebutnya configparser.py atau mungkin mencoba mengimpor sendiri,) membuatnya dapat dieksekusi, dan menyebutnya seperti

value=$(myconfig.py something.ini sectionname value)

Ini kode saya untuk Python 3.5 di Linux:

#!/usr/bin/env python3
# Last Modified: Thu Aug  3 13:58:50 PDT 2017
"""A program that Bash can call to parse an .ini file"""

import sys
import configparser
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="A program that Bash can call to parse an .ini file")
    parser.add_argument("inifile", help="name of the .ini file")
    parser.add_argument("section", help="name of the section in the .ini file")
    parser.add_argument("itemname", help="name of the desired value")
    args = parser.parse_args()

    config = configparser.ConfigParser()
    config.read(args.inifile)
    print(config.get(args.section, args.itemname))

kesederhanaan yang kompleks

file ini

test.ini

[section1]
name1=value1
name2=value2
[section2]
name1=value_1
  name2  =  value_2

bash script dengan membaca dan mengeksekusi

/ bin / parseini

#!/bin/bash

set +a
while read p; do
  reSec='^\[(.*)\]$'
  #reNV='[ ]*([^ ]*)+[ ]*=(.*)'     #Remove only spaces around name
  reNV='[ ]*([^ ]*)+[ ]*=[ ]*(.*)'  #Remove spaces around name and spaces before value
  if [[ $p =~ $reSec ]]; then
      section=${BASH_REMATCH[1]}
  elif [[ $p =~ $reNV ]]; then
    sNm=${section}_${BASH_REMATCH[1]}
    sVa=${BASH_REMATCH[2]}
    set -a
    eval "$(echo "$sNm"=\""$sVa"\")"
    set +a
  fi
done < $1

kemudian di skrip lain saya mencari hasil dari perintah dan dapat menggunakan variabel apa pun di dalamnya

test.sh

#!/bin/bash

source parseini test.ini

echo $section2_name2

akhirnya dari baris perintah hasilnya adalah demikian

# ./test.sh 
value_2

Ini adalah versi saya, yang mem-parsing bagian dan mengisi array asosiatif global g_iniProperties dengannya. Perhatikan bahwa ini hanya berfungsi dengan bash v4.2 dan yang lebih tinggi.

function parseIniFile() { #accepts the name of the file to parse as argument ($1)
    #declare syntax below (-gA) only works with bash 4.2 and higher
    unset g_iniProperties
    declare -gA g_iniProperties
    currentSection=""
    while read -r line
    do
        if [[ $line = [*  ]] ; then
            if [[ $line = [* ]] ; then 
                currentSection=$(echo $line | sed -e 's/\r//g' | tr -d "[]")  
            fi
        else
            if [[ $line = *=*  ]] ; then
                cleanLine=$(echo $line | sed -e 's/\r//g')
                key=$currentSection.$(echo $cleanLine | awk -F: '{ st = index($0,"=");print  substr($0,0,st-1)}')
                value=$(echo $cleanLine | awk -F: '{ st = index($0,"=");print  substr($0,st+1)}')
                g_iniProperties[$key]=$value
            fi
        fi;
    done < $1
}

Dan berikut ini contoh kode menggunakan fungsi di atas:

parseIniFile "/path/to/myFile.ini"
for key in "${!g_iniProperties[@]}"; do
    echo "Found key/value $key = ${g_iniProperties[$key]}"
done

Script ini akan mendapatkan parameter sebagai berikut:

Artinya jika ini Anda memiliki:

pars_ini.ksh <jalur ke file ini> <nama Sektor di file Ini> <nama dalam nama = nilai untuk kembali>

misalnya. bagaimana menyebutnya:

[ lingkungan Hidup ]

a = x

[DataBase_Sector]

DSN = sesuatu

Kemudian menelepon:

pars_ini.ksh /users/bubu_user/parameters.ini DataBase_Sector DSN

ini akan mengambil "sesuatu" berikut

skrip "pars_ini.ksh":

\#!/bin/ksh

\#INI_FILE=path/to/file.ini

\#INI_SECTION=TheSection

\# BEGIN parse-ini-file.sh

\# SET UP THE MINIMUM VARS FIRST

alias sed=/usr/local/bin/sed

INI_FILE=$1

INI_SECTION=$2

INI_NAME=$3

INI_VALUE=""


eval `sed -e 's/[[:space:]]*\=[[:space:]]*/=/g' \

    -e 's/;.*$//' \

    -e 's/[[:space:]]*$//' \

    -e 's/^[[:space:]]*//' \

    -e "s/^\(.*\)=\([^\"']*\)$/\1=\"\2\"/" \

   < $INI_FILE  \

    | sed -n -e "/^\[$INI_SECTION\]/,/^\s*\[/{/^[^;].*\=.*/p;}"`


TEMP_VALUE=`echo "$"$INI_NAME`

echo `eval echo $TEMP_VALUE`

Saya menulis skrip python yang cepat dan mudah untuk disertakan dalam skrip bash saya.

Misalnya, file ini Anda dipanggil food.ini dan di dalam file Anda dapat memiliki beberapa bagian dan beberapa baris:

[FRUIT]
Oranges = 14
Apples = 6

Salin skrip Python 6 baris kecil ini dan simpan sebagai file configparser.py

#!/usr/bin/python
import configparser
import sys
config = configparser.ConfigParser()
config.read(sys.argv[1])
print config.get(sys.argv[2],sys.argv[3])

Sekarang, di skrip bash Anda, Anda dapat melakukan ini misalnya.

OrangeQty=$(python configparser.py food.ini FRUIT Oranges)

atau

ApplesQty=$(python configparser.py food.ini FRUIT Apples)
echo $ApplesQty

Ini mengandaikan:

1. Anda telah menginstal Python
2. Anda telah menginstal pustaka configparser (ini harus datang dengan instalasi std python)

Semoga membantu : ¬)

Versi saya dari satu baris

#!/bin/bash
#Reader for MS Windows 3.1 Ini-files
#Usage: inireader.sh

# e.g.: inireader.sh win.ini ERRORS DISABLE
# would return value "no" from the section of win.ini
#[ERRORS]
#DISABLE=no
INIFILE=$1
SECTION=$2
ITEM=$3
cat $INIFILE | sed -n /^\[$SECTION\]/,/^\[.*\]/p | grep "^[:space:]*$ITEM[:space:]*=" | sed s/.*=[:space:]*//

Baru saja selesai menulis parser saya sendiri. Saya mencoba menggunakan berbagai parser yang ditemukan di sini, sepertinya tidak ada yang berfungsi dengan ksh93 (AIX) dan bash (Linux).

Ini gaya pemrograman lama - mengurai baris demi baris. Cukup cepat karena menggunakan beberapa perintah eksternal. Sedikit lebih lambat karena semua eval yang diperlukan untuk nama dinamis array.

Ini mendukung 3 sintaks khusus:

• Includefile = ini file -> Muat file ini tambahan. Berguna untuk memisahkan ini menjadi beberapa file, atau menggunakan kembali beberapa bagian konfigurasi
• includeir = directory -> Sama seperti Includefile, tetapi sertakan direktori lengkapnya
• includeection = section -> Salin bagian yang ada ke bagian saat ini.

Saya menggunakan semua sintaks itu untuk memiliki file ini yang cukup kompleks dan dapat digunakan kembali. Berguna untuk menginstal produk saat menginstal OS baru - kami sering melakukannya.

Nilai dapat diakses dengan $ {ini [$ section. $ Item]}. Array HARUS didefinisikan sebelum memanggil ini.

Selamat bersenang-senang. Semoga bermanfaat untuk orang lain!

function Show_Debug {
    [[ $DEBUG = YES ]] && echo "DEBUG $@"
    }

function Fatal {
    echo "$@. Script aborted"
    exit 2
    }
#-------------------------------------------------------------------------------
# This function load an ini file in the array "ini"
# The "ini" array must be defined in the calling program (typeset -A ini)
#
# It could be any array name, the default array name is "ini".
#
# There is heavy usage of "eval" since ksh and bash do not support
# reference variable. The name of the ini is passed as variable, and must
# be "eval" at run-time to work. Very specific syntax was used and must be
# understood before making any modifications.
#
# It complexify greatly the program, but add flexibility.
#-------------------------------------------------------------------------------

function Load_Ini {
    Show_Debug "$0($@)"
    typeset ini_file="$1"
# Name of the array to fill. By default, it's "ini"
    typeset ini_array_name="${2:-ini}"
    typeset section variable value line my_section file subsection value_array include_directory all_index index sections pre_parse
    typeset LF="
"
    if [[ ! -s $ini_file ]]; then
        Fatal "The ini file is empty or absent in $0 [$ini_file]"
    fi

    include_directory=$(dirname $ini_file)
    include_directory=${include_directory:-$(pwd)}

    Show_Debug "include_directory=$include_directory"

    section=""
# Since this code support both bash and ksh93, you cannot use
# the syntax "echo xyz|while read line". bash doesn't work like
# that.
# It forces the use of "<<<", introduced in bash and ksh93.

    Show_Debug "Reading file $ini_file and putting the results in array $ini_array_name"
    pre_parse="$(sed 's/^ *//g;s/#.*//g;s/ *$//g' <$ini_file | egrep -v '^$')"
    while read line; do
        if [[ ${line:0:1} = "[" ]]; then # Is the line starting with "["?
# Replace [section_name] to section_name by removing the first and last character
            section="${line:1}"
            section="${section%\]}"
            eval "sections=\${$ini_array_name[sections_list]}"
            sections="$sections${sections:+ }$section"
            eval "$ini_array_name[sections_list]=\"$sections\""
            Show_Debug "$ini_array_name[sections_list]=\"$sections\""
            eval "$ini_array_name[$section.exist]=YES"
            Show_Debug "$ini_array_name[$section.exist]='YES'"
        else
            variable=${line%%=*}   # content before the =
            value=${line#*=}       # content after the =

            if [[ $variable = includefile ]]; then
# Include a single file
                Load_Ini "$include_directory/$value" "$ini_array_name"
                continue
            elif [[ $variable = includedir ]]; then
# Include a directory
# If the value doesn't start with a /, add the calculated include_directory
                if [[ $value != /* ]]; then
                    value="$include_directory/$value"
                fi
# go thru each file
                for file in $(ls $value/*.ini 2>/dev/null); do
                    if [[ $file != *.ini ]]; then continue; fi
# Load a single file
                    Load_Ini "$file" "$ini_array_name"
                done
                continue
            elif [[ $variable = includesection ]]; then
# Copy an existing section into the current section
                eval "all_index=\"\${!$ini_array_name[@]}\""
# It's not necessarily fast. Need to go thru all the array
                for index in $all_index; do
# Only if it is the requested section
                    if [[ $index = $value.* ]]; then
# Evaluate the subsection [section.subsection] --> subsection
                        subsection=${index#*.}
# Get the current value (source section)
                        eval "value_array=\"\${$ini_array_name[$index]}\""
# Assign the value to the current section
# The $value_array must be resolved on the second pass of the eval, so make sure the
# first pass doesn't resolve it (\$value_array instead of $value_array).
# It must be evaluated on the second pass in case there is special character like $1,
# or ' or " in it (code).
                        eval "$ini_array_name[$section.$subsection]=\"\$value_array\""
                        Show_Debug "$ini_array_name[$section.$subsection]=\"$value_array\""
                    fi
                done
            fi

# Add the value to the array
            eval "current_value=\"\${$ini_array_name[$section.$variable]}\""
# If there's already something for this field, add it with the current
# content separated by a LF (line_feed)
            new_value="$current_value${current_value:+$LF}$value"
# Assign the content
# The $new_value must be resolved on the second pass of the eval, so make sure the
# first pass doesn't resolve it (\$new_value instead of $new_value).
# It must be evaluated on the second pass in case there is special character like $1,
# or ' or " in it (code).
            eval "$ini_array_name[$section.$variable]=\"\$new_value\""
            Show_Debug "$ini_array_name[$section.$variable]=\"$new_value\""
        fi
    done  <<< "$pre_parse"
    Show_Debug "exit $0($@)\n"
    }

Implementasi ini menggunakan awkdan memiliki keuntungan sebagai berikut:

1. Hanya akan mengembalikan entri pertama yang cocok
2. Mengabaikan baris yang dimulai dengan a ;
3. Memangkas spasi kosong di depan dan di belakang, tetapi bukan spasi internal

Versi yang diformat :

awk -F '=' '/^\s*database_version\s*=/ {
            sub(/^ +/, "", $2);
            sub(/ +$/, "", $2);
            print $2;
            exit;
          }' parameters.ini

Satu baris :

awk -F '=' '/^\s*database_version\s*=/ { sub(/^ +/, "", $2); sub(/ +$/, "", $2); print $2; exit; }' parameters.ini

Ketika saya menggunakan kata sandi di base64, saya meletakkan pemisah ":" karena string base64 mungkin memiliki "=". Misalnya (saya gunakan ksh):

> echo "Abc123" | base64
QWJjMTIzCg==

Dalam parameters.inimenempatkan baris pass:QWJjMTIzCg==, dan akhirnya:

> PASS=`awk -F":" '/pass/ {print $2 }' parameters.ini | base64 --decode`
> echo "$PASS"
Abc123

Jika garis memiliki spasi seperti "pass : QWJjMTIzCg== "tambahkan | tr -d ' 'untuk memangkasnya:

> PASS=`awk -F":" '/pass/ {print $2 }' parameters.ini | tr -d ' ' | base64 --decode`
> echo "[$PASS]"
[Abc123]

Ini menggunakan perl sistem dan ekspresi reguler yang bersih:

cat parameters.ini | perl -0777ne 'print "$1" if /\[\s*parameters\.ini\s*\][\s\S]*?\sdatabase_version\s*=\s*(.*)/'

Jawaban dari "Karen Gabrielyan" di antara jawaban lainnya adalah yang terbaik tetapi di beberapa lingkungan kami tidak memiliki awk, seperti busybox biasa, saya mengubah jawaban dengan kode di bawah ini.

trim()
{
    local trimmed="$1"

    # Strip leading space.
    trimmed="${trimmed## }"
    # Strip trailing space.
    trimmed="${trimmed%% }"

    echo "$trimmed"
}


  function parseIniFile() { #accepts the name of the file to parse as argument ($1)
        #declare syntax below (-gA) only works with bash 4.2 and higher
        unset g_iniProperties
        declare -gA g_iniProperties
        currentSection=""
        while read -r line
        do
            if [[ $line = [*  ]] ; then
                if [[ $line = [* ]] ; then 
                    currentSection=$(echo $line | sed -e 's/\r//g' | tr -d "[]")  
                fi
            else
                if [[ $line = *=*  ]] ; then
                    cleanLine=$(echo $line | sed -e 's/\r//g')
                    key=$(trim $currentSection.$(echo $cleanLine | cut -d'=' -f1'))
                    value=$(trim $(echo $cleanLine | cut -d'=' -f2))
                    g_iniProperties[$key]=$value
                fi
            fi;
        done < $1
    }

Jika Python tersedia, berikut ini akan membaca semua bagian, kunci dan nilai dan menyimpannya dalam variabel dengan nama mereka mengikuti format "[section] _ [key]". Python dapat membaca file .ini dengan baik, jadi kami memanfaatkannya.

#!/bin/bash

eval $(python3 << EOP
from configparser import SafeConfigParser

config = SafeConfigParser()
config.read("config.ini"))

for section in config.sections():
    for (key, val) in config.items(section):
        print(section + "_" + key + "=\"" + val + "\"")
EOP
)

echo "Environment_type:  ${Environment_type}"
echo "Environment_name:  ${Environment_name}"

config.ini

[Environment]
  type                = DEV
  name                = D01

Anda dapat menggunakan parser CSV xsv sebagai pengurai data INI.

cargo install xsv

$ cat /etc/*release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=16.04
DISTRIB_CODENAME=xenial

$ xsv select -d "=" - <<< "$( cat /etc/*release )" | xsv search --no-headers --select 1 "DISTRIB_CODENAME" | xsv select 2
xenial

atau dari file.

$ xsv select -d "=" - file.ini | xsv search --no-headers --select 1 "DISTRIB_CODENAME" | xsv select 2

Jika menggunakan bagian, ini akan melakukan pekerjaan:

Contoh keluaran mentah:

$ ./settings
[section]
SETTING_ONE=this is setting one
SETTING_TWO=This is the second setting
ANOTHER_SETTING=This is another setting

Penguraian reguler:

$ ./settings | sed -n -E "/^\[.*\]/{s/\[(.*)\]/\1/;h;n;};/^[a-zA-Z]/{s/#.*//;G;s/([^ ]*) *= *(.*)\n(.*)/\3_\1='\2'/;p;}"
section_SETTING_ONE='this is setting one'
section_SETTING_TWO='This is the second setting'
section_ANOTHER_SETTING='This is another setting'

Sekarang semuanya:

$ eval "$(./settings | sed -n -E "/^\[.*\]/{s/\[(.*)\]/\1/;h;n;};/^[a-zA-Z]/{s/#.*//;G;s/([^ ]*) *= *(.*)\n(.*)/\3_\1='\2'/;p;}")"
$ echo $section_SETTING_TWO
This is the second setting

Saya memiliki satu baris yang bagus (mengasumsikan Anda telah phpdan jqmenginstal):

cat file.ini | php -r "echo json_encode(parse_ini_string(file_get_contents('php://stdin'), true, INI_SCANNER_RAW));" | jq '.section.key'