මා සතුව මෙම නූල විචල්‍යයක ගබඩා කර ඇත:

IN="bla@some.com;john@home.com"

දැන් මා ;සතුව ඇති පරිසීමාවෙන් නූල් බෙදීමට මම කැමැත්තෙමි :

ADDR1="bla@some.com"
ADDR2="john@home.com"

මට අනිවාර්යයෙන්ම ADDR1සහ ADDR2විචල්‍යයන් අවශ්‍ය නොවේ . ඒවා අරාවෙහි මූලද්‍රව්‍ය නම් ඊටත් වඩා හොඳය.

පහත දැක්වෙන පිළිතුරු වලින් යෝජනා කිරීමෙන් පසුව, මම පහත සඳහන් දෑ සමඟ අවසන් කළෙමි.

#!/usr/bin/env bash

IN="bla@some.com;john@home.com"

mails=$(echo $IN | tr ";" "\n")

for addr in $mails
do
    echo "> [$addr]"
done

ප්‍රතිදානය:

> [bla@some.com]
> [john@home.com]

Internal_field_separator (IFS) සැකසීම සම්බන්ධ විසඳුමක් තිබුණි ;. එම පිළිතුරෙන් සිදුවූයේ කුමක්දැයි මට විශ්වාස නැත, ඔබ IFSපෙරනිමියට නැවත සකසන්නේ කෙසේද ?

RE: IFSවිසඳුම, මම මෙය උත්සාහ කළ අතර එය ක්‍රියාත්මක වේ, මම පැරණි දේ තබා IFSඑය නැවත පිහිටුවන්න:

IN="bla@some.com;john@home.com"

OIFS=$IFS
IFS=';'
mails2=$IN
for x in $mails2
do
    echo "> [$x]"
done

IFS=$OIFS

BTW, මම උත්සාහ කරන විට

mails2=($IN)

මට පළමු නූල ලැබුනේ එය ලූපයකින් මුද්‍රණය කරන විට පමණි, $INඑය වටා වරහන් නොමැතිව ක්‍රියා කරයි.

ඔබට අභ්‍යන්තර ක්ෂේත්‍ර බෙදුම්කරු (IFS) විචල්‍යය සැකසිය හැකි අතර පසුව එය අරාවකට විග්‍රහ කිරීමට ඉඩ දෙන්න. මෙය විධානයකින් සිදු වූ විට, පැවරුම IFSසිදුවන්නේ එම තනි විධානයේ පරිසරයට පමණි (වෙත read). ඉන්පසු එය IFSවිචල්‍ය අගය අනුව ආදානය අරාවකට විග්‍රහ කරයි , එවිට අපට නැවත නැවත කළ හැක.

IFS=';' read -ra ADDR <<< "$IN"
for i in "${ADDR[@]}"; do
    # process "$i"
done

එය වෙන් කරන ලද අයිතම පේළියක් විග්‍රහ ;කර එය අරාවකට තල්ලු කරයි. සමස්තයක් ලෙස සැකසීමේ දේවල් $IN, එක් එක් වාරයේ ආදාන පේළියක් වෙන් කරන්නේ ;:

 while IFS=';' read -ra ADDR; do
      for i in "${ADDR[@]}"; do
          # process "$i"
      done
 done <<< "$IN"

සිට ගෙන bash shell පිටපත භේදය අරා :

IN="bla@some.com;john@home.com"
arrIN=(${IN//;/ })

පැහැදිලි කිරීම:

මෙම ඉදිකිරීම මඟින් ';'(ආරම්භක //මාධ්‍යය ගෝලීය ප්‍රතිස්ථාපනය) සියලු සිදුවීම් ( තනි අවකාශයක්) INසමඟ ප්‍රතිස්ථාපනය කරයි ' ', පසුව අවකාශය වෙන් කරන ලද නූල් අරාව ලෙස අර්ථ නිරූපණය කරයි (අවට වරහන් මඟින් කරන්නේ එයයි).

එක් එක් ';'අක්ෂර වෙනුවට අක්ෂරයක් ආදේශ කිරීම සඳහා කැරලි වරහන් තුළ භාවිතා වන වාක්‍ය ඛණ්ඩය පරාමිති විස්තාරණය' ' ලෙස හැඳින්වේ .

පොදු ගොචා කිහිපයක් තිබේ:

1. මුල් නූලට අවකාශ තිබේ නම්, ඔබට IFS භාවිතා කිරීමට අවශ්‍ය වනු ඇත :
   • IFS=':'; arrIN=($IN); unset IFS;
2. මුල් නූලට අවකාශයක් තිබේ නම් සහ පරිසීමකය නව රේඛාවක් නම්, ඔබට මෙය සමඟ IFS සැකසිය හැකිය :
   • IFS=$'\n'; arrIN=($IN); unset IFS;

ඒවා වහාම සැකසීමට ඔබට අවශ්‍ය නැතිනම්, මම මෙය කිරීමට කැමතියි:

for i in $(echo $IN | tr ";" "\n")
do
  # process
done

අරාව ආරම්භ කිරීම සඳහා ඔබට මේ ආකාරයේ ලූපයක් භාවිතා කළ හැකිය, නමුත් එය කිරීමට පහසු ක්‍රමයක් තිබේ. කෙසේ වෙතත් මෙය උපකාරී වේ යැයි සිතමි.

අනුකූල පිළිතුර

මෙය සිදු කිරීම සඳහා විවිධ ක්‍රම රාශියක් ඇත bash.

කෙසේ වෙතත්, එය පළමු සටහන වැදගත් bashවන විවිධ විශේෂ ලක්ෂණ (ඊනියා bashisms ) වෙනත් ඕනෑම වැඩ නැහැකවචය.

විශේෂයෙන්, මෙම පෝස්ට් එකේ විසඳුම් සඳහා මෙන්ම නූල් වල ඇති අනෙක් ඒවා සඳහා භාවිතා කරන අරා , සහායක අරා සහ රටා ආදේශනය , බාෂිස්වාදයන් වන අතර බොහෝ අය භාවිතා කරන වෙනත් ෂෙල් වෙඩි යටතේ ක්‍රියා නොකරනු ඇත.

උදාහරණයක් ලෙස: මගේ ඩේබියන් ග්නූ / ලිනක්ස් හි සම්මත කවචයක් ඇතඉර ඉර; තවත් ෂෙල් එකක් භාවිතා කිරීමට කැමති බොහෝ අය මම දනිමිksh; විශේෂ මෙවලමක් ද ඇතකාර්යබහුල පෙට්ටිය ඔහුගේම ෂෙල් පරිවර්තකය සමඟ (අළු).

ඉල්ලූ නූල

ඉහත ප්‍රශ්නයේදී බෙදිය යුතු නූල:

IN="bla@some.com;john@home.com"

මගේ විසඳුම සුදු අවකාශය සහිත නූල් වලට ශක්තිමත් බව සහතික කිරීම සඳහා මම මෙම නූලෙහි නවීකරණය කරන ලද අනුවාදයක් භාවිතා කරමි, එමඟින් වෙනත් විසඳුම් බිඳ දැමිය හැකිය:

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"

දී පරිසීමකය මත පදනම්ව බෙදීම් නූල් bash (අනුවාදය> = 4.2)

දී පිරිසිදු bash , අපි නිර්මාණය කළ හැක අරාව සඳහා තාවකාලික වටිනාකම මූලද්රව්ය සමග භේද IFS (මෙම ආදාන ක්ෂේත්රය වෙන්කර ). bashඅරාව නිර්වචනය කිරීමේදී මූලද්‍රව්‍ය අතර පරිසීමකයක් ලෙස සැලකිය යුත්තේ කුමන චරිත (ය) ද යන්න අයිඑෆ්එස් පවසයි :

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"

# save original IFS value so we can restore it later
oIFS="$IFS"
IFS=";"
declare -a fields=($IN)
IFS="$oIFS"
unset oIFS

නවතම අනුවාද වලදී bash, අයිඑෆ්එස් අර්ථ දැක්වීමක් සහිත විධානයක් උපසර්ග කිරීමෙන් එම විධානය සඳහා පමණක් අයිඑෆ්එස් වෙනස් වන අතර එය වහාම පෙර අගයට යලි සකසයි. මෙයින් අදහස් කරන්නේ අපට ඉහත එක පේළියකින් කළ හැකි බවයි:

IFS=\; read -a fields <<<"$IN"
# after this command, the IFS resets back to its previous value (here, the default):
set | grep ^IFS=
# IFS=$' \t\n'

අර්ධ සළකුණු මත බෙදී ඇති INනමක් අරාවකට ගබඩා කර ඇති බව අපට පෙනේ fields:

set | grep ^fields=\\\|^IN=
# fields=([0]="bla@some.com" [1]="john@home.com" [2]="Full Name <fulnam@other.org>")
# IN='bla@some.com;john@home.com;Full Name <fulnam@other.org>'

(අපට මෙම විචල්‍යයන්ගේ අන්තර්ගතය ද ප්‍රදර්ශනය කළ හැකිය declare -p:)

declare -p IN fields
# declare -- IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
# declare -a fields=([0]="bla@some.com" [1]="john@home.com" [2]="Full Name <fulnam@other.org>")

දෙබලක හෝ බාහිර සම්පත් කැඳවීමක් නොමැති නිසා භේදය සිදු කිරීමට ඉක්මන්ම ක්‍රමය readඑය බව සලකන්න .

අරාව නිර්වචනය කළ පසු, ඔබට එක් එක් ක්ෂේත්‍රය සැකසීමට සරල පුඩුවක් භාවිතා කළ හැකිය (හෝ, ඒ වෙනුවට, ඔබ දැන් අර්ථ දක්වා ඇති අරාවේ සෑම අංගයක්ම):

# `"${fields[@]}"` expands to return every element of `fields` array as a separate argument
for x in "${fields[@]}" ;do
    echo "> [$x]"
    done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

නැතහොත් මා කැමති මාරුවීමේ ප්‍රවේශයක් භාවිතයෙන් සැකසීමෙන් පසු ඔබට එක් එක් ක්ෂේත්‍රය අරාවෙන් ඉවත් කළ හැකිය :

while [ "$fields" ] ;do
    echo "> [$fields]"
    # slice the array 
    fields=("${fields[@]:1}")
    done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

ඔබට අරාවෙහි සරල මුද්‍රණයක් අවශ්‍ය නම්, ඔබට එය ඉක්මවා යාමට අවශ්‍ය නොවේ:

printf "> [%s]\n" "${fields[@]}"
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

යාවත්කාලීන කිරීම: මෑත bash > = 4.4

හි නවතම අනුවාද වලදී bash, ඔබට විධානය සමඟ සෙල්ලම් කළ හැකිය mapfile:

mapfile -td \; fields < <(printf "%s\0" "$IN")

මෙම වාක්‍ය ඛණ්ඩය විශේෂ අක්ෂර, නව රේඛා සහ හිස් ක්ෂේත්‍ර ආරක්ෂා කරයි!

ඔබට හිස් ක්ෂේත්‍ර ඇතුළත් කිරීමට අවශ්‍ය නැතිනම්, ඔබට පහත සඳහන් දෑ කළ හැකිය:

mapfile -td \; fields <<<"$IN"
fields=("${fields[@]%$'\n'}")   # drop '\n' added by '<<<'

සමඟ mapfile, ඔබට අරාව ප්‍රකාශ කිරීම මඟ හැරිය හැකි අතර, වෙන් කරන ලද මූලද්‍රව්‍යයන් මත ව්‍යංගයෙන් “ලූපයක්” ලබා ගත හැකිය.

myPubliMail() {
    printf "Seq: %6d: Sending mail to '%s'..." $1 "$2"
    # mail -s "This is not a spam..." "$2" </path/to/body
    printf "\e[3D, done.\n"
}

mapfile < <(printf "%s\0" "$IN") -td \; -c 1 -C myPubliMail

(සටහන: \0නූල් අවසානයේ හිස් ක්ෂේත්‍ර ගැන ඔබ තැකීමක් නොකරන්නේ නම් හෝ ඒවා නොපවතී නම්, ආකෘතියේ කෙළවරේ වැඩකට නැති ය.)

mapfile < <(echo -n "$IN") -td \; -c 1 -C myPubliMail

# Seq:      0: Sending mail to 'bla@some.com', done.
# Seq:      1: Sending mail to 'john@home.com', done.
# Seq:      2: Sending mail to 'Full Name <fulnam@other.org>', done.

නැතහොත් ඔබට භාවිතා කළ හැකි <<<අතර, ක්‍රියාකාරීත්වය තුළ එය එකතු කරන නව රේඛාව අතහැර දැමීමට යම් සැකසුම් ඇතුළත් වේ:

myPubliMail() {
    local seq=$1 dest="${2%$'\n'}"
    printf "Seq: %6d: Sending mail to '%s'..." $seq "$dest"
    # mail -s "This is not a spam..." "$dest" </path/to/body
    printf "\e[3D, done.\n"
}

mapfile <<<"$IN" -td \; -c 1 -C myPubliMail

# Renders the same output:
# Seq:      0: Sending mail to 'bla@some.com', done.
# Seq:      1: Sending mail to 'john@home.com', done.
# Seq:      2: Sending mail to 'Full Name <fulnam@other.org>', done.

දී පරිසීමකය මත පදනම්ව බෙදීම් නූල් කවචය

ඔබට භාවිතා කළ නොහැකි bashනම්, හෝ ඔබට විවිධ ෂෙල් වෙඩි භාවිතා කළ හැකි යමක් ලිවීමට අවශ්‍ය නම්, ඔබට බොහෝ විට bashisms භාවිතා කළ නොහැක - තවද ඉහත විසඳුම් සඳහා අප භාවිතා කළ අරා මෙයට ඇතුළත් වේ.

කෙසේ වෙතත්, නූලක “මූලද්‍රව්‍ය” ඉක්මවා යාමට අපට අරා භාවිතා කිරීමට අවශ්‍ය නොවේ. රටාවක පළමු හෝ අවසාන සිදුවීමෙන් නූලක උපස්ථර මකා දැමීම සඳහා බොහෝ කවච වල සින්ටැක්ස් භාවිතා වේ . *අක්ෂර ශුන්‍ය හෝ වැඩි ගණනක් නියෝජනය කරන ආදේශක කාඩ්පතක් බව සලකන්න :

(මෙතෙක් පළ කර ඇති කිසිදු විසඳුමක මෙම ප්‍රවේශය නොමැතිකම මා මෙම පිළිතුර ලිවීමට ප්‍රධාන හේතුවයි;)

${var#*SubStr}  # drops substring from start of string up to first occurrence of `SubStr`
${var##*SubStr} # drops substring from start of string up to last occurrence of `SubStr`
${var%SubStr*}  # drops substring from last occurrence of `SubStr` to end of string
${var%%SubStr*} # drops substring from first occurrence of `SubStr` to end of string

Score_Under විසින් පැහැදිලි කළ පරිදි :

#සහ නූල් ආරම්භයේ සහ අවසානයේ පිළිවෙලින් %හැකි කෙටිම ගැලපෙන උපස්ථරය මකා දමන්න , සහ

##හා %%දිගම හැකි ගැලපෙන substring මකන්න.

ඉහත වාක්‍ය ඛණ්ඩය භාවිතා කරමින්, පරිමිතිය දක්වා හෝ පසුව උපස්ථරයන් මකා දැමීමෙන් අපට “මූලද්‍රව්‍ය” උපස්ථරයෙන් උපුටා ගන්නා ප්‍රවේශයක් නිර්මාණය කළ හැකිය.

පහත කේත අවහිරය හොඳින් ක්‍රියාත්මක වේ bash(මැක් ඕඑස් ඇතුළුව bash),ඉර ඉර, ksh, සහ කාර්යබහුල පෙට්ටියගේ අළු:

IN="bla@some.com;john@home.com;Full Name <fulnam@other.org>"
while [ "$IN" ] ;do
    # extract the substring from start of string up to delimiter.
    # this is the first "element" of the string.
    iter=${IN%%;*}
    echo "> [$iter]"
    # if there's only one element left, set `IN` to an empty string.
    # this causes us to exit this `while` loop.
    # else, we delete the first "element" of the string from IN, and move onto the next.
    [ "$IN" = "$iter" ] && \
        IN='' || \
        IN="${IN#*;}"
  done
# > [bla@some.com]
# > [john@home.com]
# > [Full Name <fulnam@other.org>]

විනෝද වන්න!

cutවිධානය සඳහන් කරමින් පිළිතුරු කිහිපයක් මම දැක ඇත්තෙමි , නමුත් ඒවා සියල්ලම මකා දමා ඇත. කිසිවෙකු ඒ ගැන විස්තාරණය නොකිරීම ටිකක් අමුතු දෙයක්, මන්ද එය මේ ආකාරයේ දෙයක් කිරීම සඳහා වඩාත් ප්‍රයෝජනවත් විධානයන්ගෙන් එකක් යැයි මම සිතමි, විශේෂයෙන් වෙන් කරන ලද ලොග් ගොනු විග්‍රහ කිරීම සඳහා.

මෙම විශේෂිත උදාහරණය බාෂ් ස්ක්‍රිප්ට් අරාවකට බෙදීමේදී, trබොහෝ විට වඩා කාර්යක්ෂම, නමුත් cutභාවිතා කළ හැකි අතර, ඔබට නිශ්චිත ක්ෂේත්‍ර මැදින් ඇද ගැනීමට අවශ්‍ය නම් වඩාත් effective ලදායී වේ.

උදාහරණයක්:

$ echo "bla@some.com;john@home.com" | cut -d ";" -f 1
bla@some.com
$ echo "bla@some.com;john@home.com" | cut -d ";" -f 2
john@home.com

ඔබට එය පැහැදිලිවම ලූපයකට දැමිය හැකි අතර, එක් එක් ක්ෂේත්‍රය ස්වාධීනව ඇද ගැනීමට -f පරාමිතිය නැවත කරන්න.

ඔබට මෙවැනි පේළි සහිත වෙන් කළ ලොග් ගොනුවක් ඇති විට මෙය වඩාත් ප්‍රයෝජනවත් වේ:

2015-04-27|12345|some action|an attribute|meta data

cutcatමෙම ගොනුවට හැකි වීම සහ වැඩිදුර සැකසීම සඳහා විශේෂිත ක්ෂේත්‍රයක් තෝරා ගැනීම ඉතා පහසුය .

මෙය මට ප්‍රයෝජනවත් විය:

string="1;2"
echo $string | cut -d';' -f1 # output is 1
echo $string | cut -d';' -f2 # output is 2

මෙම ප්‍රවේශය ගැන:

IN="bla@some.com;john@home.com" 
set -- "$IN" 
IFS=";"; declare -a Array=($*) 
echo "${Array[@]}" 
echo "${Array[0]}" 
echo "${Array[1]}" 

මූලාශ්රය

ඔබේ ගැටලුව විසඳීමට හොඳම හා කාර්යක්ෂම විධානය AWK යැයි මම සිතමි . සෑම ලිනක්ස් බෙදාහැරීමකම පාහේ AWK පෙරනිමියෙන් ඇතුළත් කර ඇත.

echo "bla@some.com;john@home.com" | awk -F';' '{print $1,$2}'

ලබාදේවි

bla@some.com john@home.com

අමුතු මුද්‍රණ ක්ෂේත්‍රය නැවත අර්ථ දැක්වීමෙන් ඔබට සෑම විද්‍යුත් තැපැල් ලිපිනයක්ම ගබඩා කළ හැකිය.

echo "bla@some.com;john@home.com" | sed -e 's/;/\n/g'
bla@some.com
john@home.com

මෙයද ක්‍රියාත්මක වේ:

IN="bla@some.com;john@home.com"
echo ADD1=`echo $IN | cut -d \; -f 1`
echo ADD2=`echo $IN | cut -d \; -f 2`

ප්රවේශම් වන්න, මෙම විසඳුම සෑම විටම නිවැරදි නොවේ. ඔබ "bla@some.com" පමණක් සමත් වුවහොත් එය එය ADD1 සහ ADD2 යන දෙකටම පවරනු ඇත.

ඩැරන්ගේ පිළිතුර වෙනස් ආකාරයකට ගත් විට , මම එය කරන්නේ මෙයයි:

IN="bla@some.com;john@home.com"
read ADDR1 ADDR2 <<<$(IFS=";"; echo $IN)

ඔබේ විචල්‍යයේ නව රේඛා තිබුණත්, වෙඩි නොවදින ක්‍රමයක් වන බාෂ් හි එය ක්‍රියාත්මක වේ:

IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")

බලන්න:

$ in=$'one;two three;*;there is\na newline\nin this field'
$ IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")
$ declare -p array
declare -a array='([0]="one" [1]="two three" [2]="*" [3]="there is
a newline
in this field")'

මෙය ක්‍රියාත්මක කිරීම සඳහා වූ උපක්‍රමය නම් හිස් පරිසීමකය සමඟ (පරිසීමකය) -dවිකල්පය භාවිතා කිරීමයි read, එමඟින් readඑය පෝෂණය කරන සෑම දෙයක්ම කියවීමට බල කෙරෙයි. තවද අපි readවිචල්යයේ අන්තර්ගතය සමඟ පෝෂණය වන අතර in, නව රේඛාවකට ස්තූතිවන්ත නොවෙමු printf. අප විසින් පරිසීමකය දමන බව සලකන්න, printfසම්මත කරන readලද නූලට පසුපස පරිසීමකයක් ඇති බව සහතික කිරීම . එය නොමැතිව, readහිස් පසුපස ඇති විභව ක්ෂේත්‍රයන් කපා දමනු ඇත:

$ in='one;two;three;'    # there's an empty field
$ IFS=';' read -d '' -ra array < <(printf '%s;\0' "$in")
$ declare -p array
declare -a array='([0]="one" [1]="two" [2]="three" [3]="")'

පසුපස හිස් ක්ෂේත්‍රය ආරක්ෂා වේ.

Bash≥4.4 සඳහා යාවත්කාලීන කරන්න

Bash 4.4 සිට, බිල්ඩින් mapfile(අකා readarray) -dපරිසීමකය නියම කිරීමේ විකල්පයට සහය දක්වයි . එබැවින් තවත් කැනොනිකල් ක්‍රමයක් නම්:

mapfile -d ';' -t array < <(printf '%s;' "$in")

ඔබ අරා භාවිතා නොකරන්නේ නම් මෙම එක් ලයිනර් ගැන කුමක් කිව හැකිද:

IFS=';' read ADDR1 ADDR2 <<<$IN

IFS සැකසීමකින් තොරව

ඔබට එක් බඩවැලක් තිබේ නම් ඔබට එය කළ හැකිය:

a="foo:bar"
b=${a%:*}
c=${a##*:}

ඔබට ලැබෙනු ඇත:

b = foo
c = bar

මෙන්න පිරිසිදු 3-ලයිනර්:

in="foo@bar;bizz@buzz;fizz@buzz;buzz@woof"
IFS=';' list=($in)
for item in "${list[@]}"; do echo $item; done

එහිදී IFSdelimit වචන වෙන්කර මත පදනම් ()නිර්මාණය කිරීමට භාවිතා කරයි මාලාවක් . ඉන්පසු [@]සෑම අයිතමයක්ම වෙනම වචනයක් ලෙස ආපසු ලබා දීමට භාවිතා කරයි.

ඊට පසු ඔබට කිසියම් කේතයක් තිබේ නම්, ඔබ ද ප්‍රතිස්ථාපනය කළ යුතුය $IFS, උදා unset IFS.

පහත දැක්වෙන Bash / zsh ශ්‍රිතය දෙවන තර්කය මඟින් ලබා දෙන පරිසීමකය මත එහි පළමු තර්කය බෙදයි:

split() {
    local string="$1"
    local delimiter="$2"
    if [ -n "$string" ]; then
        local part
        while read -d "$delimiter" part; do
            echo $part
        done <<< "$string"
        echo $part
    fi
}

උදාහරණයක් ලෙස, විධානය

$ split 'a;b;c' ';'

අස්වැන්න

a
b
c

නිදසුනක් ලෙස, මෙම ප්‍රතිදානය වෙනත් විධානයන් වෙත යොමු කළ හැකිය. උදාහරණයක්:

$ split 'a;b;c' ';' | cat -n
1   a
2   b
3   c

ලබා දී ඇති අනෙක් විසඳුම් හා සසඳන විට, පහත සඳහන් වාසි ඇත:

• IFSඅතිච්ඡාදනය නොවේ: දේශීය විචල්‍යයන් පවා ගතිකව පරික්ෂා කිරීම හේතුවෙන්, IFSලූපයක් ඉක්මවා යාමෙන් නව අගය ලූපය තුළ සිට සිදුකරන ශ්‍රිත ඇමතුම් වලට කාන්දු වේ.

• අරා භාවිතා නොකෙරේ: අරාව තුළට නූලක් කියවීමට Bash සහ zsh හි readධජය අවශ්‍ය වේ .-a-A

අවශ්‍ය නම්, ශ්‍රිතය පහත පරිදි ස්ක්‍රිප්ටයකට දැමිය හැකිය:

#!/usr/bin/env bash

split() {
    # ...
}

split "$@"

ඔබට බොහෝ අවස්ථාවන්ට අවදි විය හැකිය

echo "bla@some.com;john@home.com"|awk -F';' '{printf "%s\n%s\n", $1, $2}'

ඔබට මෙය භාවිතා කළ හැකිය

echo "bla@some.com;john@home.com"|awk -F';' '{print $1,$2}' OFS="\n"

මේ වගේ සරල හා බුද්ධිමත් ක්‍රමයක් තිබේ:

echo "add:sfff" | xargs -d: -i  echo {}

නමුත් ඔබ gnu xargs භාවිතා කළ යුතුය, BSD xargs cant support -d delim. ඔබ මා වැනි ඇපල් මැක් භාවිතා කරන්නේ නම්. ඔබට gnu xargs ස්ථාපනය කළ හැකිය:

brew install findutils

එවිට

echo "add:sfff" | gxargs -d: -i  echo {}

මෙය කළ හැකි සරලම ක්‍රමය මෙයයි.

spo='one;two;three'
OIFS=$IFS
IFS=';'
spo_array=($spo)
IFS=$OIFS
echo ${spo_array[*]}

මෙහි සිසිල් පිළිතුරු කිහිපයක් ඇත (errator esp.), නමුත් වෙනත් භාෂාවලට බෙදීමට සමාන යමක් සඳහා - එහි මුල් ප්‍රශ්නය මා අදහස් කළේ එයයි - මම මේ පිළිබඳව සමථයකට පත් කළෙමි:

IN="bla@some.com;john@home.com"
declare -a a="(${IN/;/ })";

දැන් ${a[0]}, ${a[1]}ආදිය, ඔබ අපේක්ෂා කළ පරිදි ය. ${#a[*]}පද ගණනක් සඳහා භාවිතා කරන්න . නැතහොත් නැවත කියවීමට:

for i in ${a[*]}; do echo $i; done

වැදගත් සටහනක්:

කනස්සල්ලට පත්වීමට ඉඩක් නොමැති අවස්ථාවන්හිදී මෙය ක්‍රියාත්මක වන අතර එය මගේ ගැටලුව විසඳූ නමුත් ඔබේ ගැටලුව විසඳන්නේ නැත. $IFSඑම අවස්ථාවේ දී විසඳුම (ය) සමඟ යන්න .

IN="bla@some.com;john@home.com"
IFS=';'
read -a IN_arr <<< "${IN}"
for entry in "${IN_arr[@]}"
do
    echo $entry
done

ප්‍රතිදානය

bla@some.com
john@home.com

පද්ධතිය: උබුන්ටු 12.04.1

ඉඩක් නැත්නම්, ඇයි මේ?

IN="bla@some.com;john@home.com"
arr=(`echo $IN | tr ';' ' '`)

echo ${arr[0]}
echo ${arr[1]}

අරාව setපූරණය කිරීම සඳහා සාදන ලද භාවිතා කරන්න $@:

IN="bla@some.com;john@home.com"
IFS=';'; set $IN; IFS=$' \t\n'

එවිට, පක්ෂය ආරම්භ කිරීමට ඉඩ දෙන්න:

echo $#
for a; do echo $a; done
ADDR1=$1 ADDR2=$2

බාෂ් අරා අවශ්‍ය නොවන බෝර්න්-ඊෂ් විකල්ප දෙකක්:

1 වන අවස්ථාව : එය ලස්සන හා සරල ලෙස තබා ගන්න: රෙකෝඩ්-බෙදුම්කරු ලෙස නිව්ලයින් භාවිතා කරන්න ... උදා.

IN="bla@some.com
john@home.com"

while read i; do
  # process "$i" ... eg.
    echo "[email:$i]"
done <<< "$IN"

සටහන: මෙම පළමු අවස්ථාවෙහිදී ලැයිස්තු හැසිරවීමට සහාය වීම සඳහා කිසිදු උප ක්‍රියාවලියක් බල නොකෙරේ.

අදහස: සමහර විට එය අභ්‍යන්තරව එන්එල් භාවිතා කිරීම වටී , අවසාන ප්‍රති result ලය බාහිරව ජනනය කිරීමේදී පමණක් වෙනත් ආර්එස් වෙත පරිවර්තනය කිරීම පමණි .

2 වන අවස්ථාව : ";" වාර්තා බෙදුම්කරුවෙකු ලෙස ... උදා.

NL="
" IRS=";" ORS=";"

conv_IRS() {
  exec tr "$1" "$NL"
}

conv_ORS() {
  exec tr "$NL" "$1"
}

IN="bla@some.com;john@home.com"
IN="$(conv_IRS ";" <<< "$IN")"

while read i; do
  # process "$i" ... eg.
    echo -n "[email:$i]$ORS"
done <<< "$IN"

අවස්ථා දෙකේදීම ලූපය තුළ උප ලැයිස්තුවක් රචනා කළ හැකිය. මතකයේ ලැයිස්තු හැසිරවීමේදී මෙය ප්‍රයෝජනවත් වේ, ඒ වෙනුවට ලිපිගොනු වල ගොනු ගබඩා කරයි. {ps සන්සුන්ව සිට B- ඉදිරියට යන්න)}

දැනටමත් ලබා දී ඇති අපූරු පිළිතුරු හැරුණු විට, එය භාවිතා කිරීම සඳහා ඔබ සලකා බැලිය හැකි දත්ත මුද්‍රණය කිරීම පමණක් නම් awk:

awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"

මෙමඟින් ක්ෂේත්‍ර බෙදුම්කරු සකසා ඇති අතර එමඟින් ක්ෂේත්‍ර ;හරහා forලූපයකින් ලූපයක් තබා ඒ අනුව මුද්‍රණය කළ හැකිය.

පරීක්ෂණය

$ IN="bla@some.com;john@home.com"
$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "$IN"
> [bla@some.com]
> [john@home.com]

වෙනත් ආදානයක් සමඟ:

$ awk -F";" '{for (i=1;i<=NF;i++) printf("> [%s]\n", $i)}' <<< "a;b;c   d;e_;f"
> [a]
> [b]
> [c   d]
> [e_]
> [f]

ඇන්ඩ්‍රොයිඩ් කවචයේ, යෝජිත ක්‍රම බොහොමයක් ක්‍රියා නොකරයි:

$ IFS=':' read -ra ADDR <<<"$PATH"                             
/system/bin/sh: can't create temporary file /sqlite_stmt_journals/mksh.EbNoR10629: No such file or directory

වැඩ කරන්නේ කුමක්ද:

$ for i in ${PATH//:/ }; do echo $i; done
/sbin
/vendor/bin
/system/sbin
/system/bin
/system/xbin

එහිදී //ගෝලීය වෙනුවට බවයි.

IN='bla@some.com;john@home.com;Charlie Brown <cbrown@acme.com;!"#$%&/()[]{}*? are no problem;simple is beautiful :-)'
set -f
oldifs="$IFS"
IFS=';'; arrayIN=($IN)
IFS="$oldifs"
for i in "${arrayIN[@]}"; do
echo "$i"
done
set +f

ප්‍රතිදානය:

bla@some.com
john@home.com
Charlie Brown <cbrown@acme.com
!"#$%&/()[]{}*? are no problem
simple is beautiful :-)

පැහැදිලි කිරීම: වරහන් () භාවිතා කරමින් සරල පැවරුමක් මඟින් අර්ධ සළකුණු වෙන් කළ ලැයිස්තුව අරාව බවට පරිවර්තනය කරයි. ස්ටෑන්ඩර්ඩ් ෆෝ ලූප් සුපුරුදු පරිදි එම අරාවෙහි ඇති තනි අයිතම හසුරුවයි. IN විචල්‍යය සඳහා ලබා දී ඇති ලැයිස්තුව “දෘඩ” ලෙස උපුටා දැක්විය යුතු බව සලකන්න, එනම් තනි කිනිතුල්ලන් සමඟ.

පැවරුමක් විධානයක් ලෙස Bash නොසලකන බැවින් IFS සුරැකිය යුතු අතර ප්‍රතිෂ් ored ාපනය කළ යුතුය. විකල්ප කාර්යයක් නම්, පැවරුම ශ්‍රිතයක් තුළට ඔතා එම ශ්‍රිතය නවීකරණය කරන ලද IFS සමඟ අමතන්න. එවැනි අවස්ථාවකදී IFS හි වෙනම ඉතිරිකිරීම / ප්‍රතිස්ථාපනය අවශ්‍ය නොවේ. එය පෙන්වා දීම ගැන "බයිස්" ට ස්තූතියි.

හරි යාලුවනේ!

මෙන්න මගේ පිළිතුර!

DELIMITER_VAL='='

read -d '' F_ABOUT_DISTRO_R <<"EOF"
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=14.04
DISTRIB_CODENAME=trusty
DISTRIB_DESCRIPTION="Ubuntu 14.04.4 LTS"
NAME="Ubuntu"
VERSION="14.04.4 LTS, Trusty Tahr"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 14.04.4 LTS"
VERSION_ID="14.04"
HOME_URL="http://www.ubuntu.com/"
SUPPORT_URL="http://help.ubuntu.com/"
BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"
EOF

SPLIT_NOW=$(awk -F$DELIMITER_VAL '{for(i=1;i<=NF;i++){printf "%s\n", $i}}' <<<"${F_ABOUT_DISTRO_R}")
while read -r line; do
   SPLIT+=("$line")
done <<< "$SPLIT_NOW"
for i in "${SPLIT[@]}"; do
    echo "$i"
done

මෙම ප්‍රවේශය මට "හොඳම" වන්නේ ඇයි?

හේතු දෙකක් නිසා:

1. පරිසීමාවෙන් ගැලවීමට ඔබට අවශ්‍ය නැත ;
2. හිස් අවකාශයන් සමඟ ඔබට ගැටළුවක් ඇති නොවේ . අරාව තුළ අගය නිසි ලෙස වෙන් කරනු ඇත!

[] ගේ

';' මගින් වෙන් කරන ලද නූලක් බෙදීමට එක් ලයිනර්. අරාවකට:

IN="bla@some.com;john@home.com"
ADDRS=( $(IFS=";" echo "$IN") )
echo ${ADDRS[0]}
echo ${ADDRS[1]}

මෙය IFS උපසිරැසියක පමණක් සකසයි, එබැවින් එහි වටිනාකම සුරැකීම සහ ප්‍රතිෂ් oring ාපනය කිරීම ගැන ඔබට කරදර විය යුතු නැත.

සමහර විට වඩාත්ම අලංකාර විසඳුම නොව, *සහ අවකාශයන් සමඟ ක්‍රියා කරයි :

IN="bla@so me.com;*;john@home.com"
for i in `delims=${IN//[^;]}; seq 1 $((${#delims} + 1))`
do
   echo "> [`echo $IN | cut -d';' -f$i`]"
done

නිමැවුම්

> [bla@so me.com]
> [*]
> [john@home.com]

වෙනත් උදාහරණය (ආරම්භයේ සහ අවසානයේ ඇති පරිසීමක):

IN=";bla@so me.com;*;john@home.com;"
> []
> [bla@so me.com]
> [*]
> [john@home.com]
> []

මූලික වශයෙන් එය උදා ;කිරීම හැර අනෙක් සෑම චරිතයක්ම ඉවත් කරයි delims. ;;;. එවිට එය forසිට පුඩුවක් 1කිරීමට number-of-delimitersවිසින් ගණන් ලෙස ${#delims}. අවසාන පියවර වන්නේ තෙවන $iකොටස ආරක්ෂිතව ලබා ගැනීමයි cut.