විධානයක් සාර්ථක දැයි පරීක්ෂා කරන්නේ කෙසේද?

විධානයක් ක්‍රියාත්මක කිරීමේදී දෝෂයක් තිබේදැයි පරීක්ෂා කිරීමට ක්‍රමයක් තිබේද?

උදාහරණයක් :

test1=`sed -i "/:@/c connection.url=jdbc:oracle:thin:@$ip:1521:$dataBase" $search`
valid $test1

function valid () {
  if $test -eq 1; then
    echo "OK"
    else echo "ERROR" 
  fi
}

මම දැනටමත් එය කිරීමට උත්සාහ කර ඇති නමුත් එය ක්‍රියාත්මක නොවන බව පෙනේ. මම කොහොමද ඒක කරන්නේ.

ප්‍රතිලාභ අගය ගබඩා කර ඇත $?. 0 සාර්ථකත්වය පෙන්නුම් කරයි, අනෙක් අය දෝෂය දක්වයි.

some_command
if [ $? -eq 0 ]; then
    echo OK
else
    echo FAIL
fi

වෙනත් ඕනෑම පා value මය වටිනාකමක් මෙන්, අනාගත සංසන්දනය සඳහා ඔබට එය විචල්‍යයක ගබඩා කළ හැකිය:

some_command
retval=$?
do_something $retval
if [ $retval -ne 0 ]; then
    echo "Return code was not zero but $retval"
fi

හැකි සංසන්දනාත්මක ක්‍රියාකරුවන් සඳහා, බලන්න man test.

ඔබට දැන ගැනීමට අවශ්‍ය වන්නේ විධානය සාර්ථක වී හෝ අසාර්ථක වී ඇත්ද යන්න පරීක්ෂා කිරීමට කරදර නොවන්න $?, විධානය කෙලින්ම පරීක්ෂා කරන්න. උදා:

if some_command; then
    printf 'some_command succeeded\n'
else
    printf 'some_command failed\n'
fi

ප්‍රතිදානය විචල්‍යයකට පැවරීමෙන් ප්‍රතිලාභ අගය වෙනස් නොවේ (හොඳයි, stdout ඇත්ත වශයෙන්ම පර්යන්තයක් නොවන විට එය වෙනස් ලෙස හැසිරෙන්නේ නැත්නම්).

if output=$(some_command); then
    printf 'some_command succeded, the output was «%s»\n' "$output"
fi

http://mywiki.wooledge.org/BashGuide/TestsAndConditionalsif වඩාත් විස්තරාත්මකව පැහැදිලි කරයි .

command && echo OK || echo Failed

$? පෙර විධානයෙහි පිටවීමේ තත්වය අඩංගු විය යුතු අතර එය කිසිදු දෝෂයක් සඳහා ශුන්‍ය විය යුතුය.

ඉතින්, වැනි දෙයක්;

cd /nonexistant
if [ $? -ne 0 ]
then
    echo failed
else
    echo success!
fi

බොහෝ අවස්ථාවන්හීදී, එකිනෙකා මත යැපීමට අවශ්‍ය දාම විධාන සඳහා && ඉදිකිරීම් භාවිතා කිරීම පහසුය. ඒ නිසා cd /nonexistant && echo success!බව නොවේ && පෙර අණ විරාම නිසා සාර්ථකත්වය දෝංකාර දෙනවා. මේ වන නිගමනයකි || කොහේ cd /nonexistant || echo fail ඇත අසමත් cd අසමත් නිසා දෝංකාර දෙනවා. (ඔබ || පිටවීම වැනි දෙයක් භාවිතා කරන්නේ නම් මෙය ප්‍රයෝජනවත් වේ, එය පෙර විධානය අසමත් වුවහොත් ස්ක්‍රිප්ට් එක අවසන් වේ.)

command && echo $? || echo $?

අප විසින් පරීක්ෂා කිරීමට අවශ්‍ය විධානය මඟින් ආපසු එන තත්වය සමඟ if...then...fiසහ &&/ ||ආකාරයේ ප්‍රවේශයන් ගනුදෙනු කරන බව සැලකිල්ලට ගත යුතුය (සාර්ථකත්වයේ 0); කෙසේ වෙතත්, විධානය අසමත් වුවහොත් හෝ ආදානය සමඟ කටයුතු කිරීමට නොහැකි නම් සමහර විධානයන් ශුන්‍ය නොවන පිටවීමේ තත්වයක් ලබා නොදේ. මෙයින් අදහස් කරන්නේ සුපුරුදු ifසහ &&/ ||ප්‍රවේශයන් එම විශේෂිත විධානයන් සඳහා ක්‍රියා නොකරන බවයි.

නිදසුනක් ලෙස, ලිනක්ස් ග්නූ fileහි දැනට පවතින ගොනුවක් තර්කයක් ලෙස ලැබුනේ නම් සහ 0 සමඟ පිටවෙයි find.

$ find . -name "not_existing_file"                                          
$ echo $?
0
$ file ./not_existing_file                                                  
./not_existing_file: cannot open `./not_existing_file' (No such file or directory)
$ echo $?
0

එවැනි අවස්ථාවන්හිදී, අපට තත්වය හැසිරවිය හැකි එක් ක්‍රමයක් වන්නේ කියවීම stderr/ stdinපණිවිඩ කියවීම , උදා: fileවිධානය මඟින් ආපසු පැමිණීම හෝ විධානයෙහි ප්‍රතිදානය විග්‍රහ කිරීම find. එම අරමුණු සඳහා caseප්‍රකාශය භාවිතා කළ හැකිය.

$ file ./doesntexist  | while IFS= read -r output; do                                                                                                                  
> case "$output" in 
> *"No such file or directory"*) printf "%s\n" "This will show up if failed";;
> *) printf "%s\n" "This will show up if succeeded" ;;
> esac
> done
This will show up if failed

$ find . -name "doesn'texist" | if ! read IFS= out; then echo "File not found"; fi                                                                                     
File not found

(මෙය unix.stackexchange.com හි අදාළ ප්‍රශ්නය පිළිබඳ මගේම පිළිතුරේ නැවත සටහනකි )

වෙනත් බොහෝ පිළිතුරු වල සඳහන් කර ඇති පරිදි, $?කැමැත්ත පිළිබඳ සරල පරීක්ෂණයක් මේ ආකාරයෙන් කරනු ඇත

if [ $? -eq 0 ]; then something; fi

විධානය අසමත් දැයි පරීක්ෂා කිරීමට ඔබට අවශ්‍ය නම් , ඔබට bashපහත දැක්වෙන පරිදි කෙටි අනුවාදයක් භාවිතා කළ හැකිය (නමුත් සමහර විට අතිරික්තය):

if (($?)); then something; fi

මෙය ක්‍රියාත්මක වන්නේ (( ))ගණිත ප්‍රකාරය භාවිතා කිරීමෙනි , එබැවින් විධානය ආපසු ලැබුනේ නම් success, එනම් $? = 0පරීක්ෂණය ((0))කුමන පරීක්ෂණ සඳහාද යන්න තක්සේරු කරයි , එසේ නොමැතිනම් falseඑය නැවත පැමිණේ true.

සාර්ථකත්වය පරීක්ෂා කිරීම සඳහා , ඔබට මෙය භාවිතා කළ හැකිය:

if ! (($?)); then something; fi

නමුත් එය දැනටමත් පළමු උදාහරණයට වඩා කෙටි නොවේ.

ඔබගේ විධාන සනාථ කිරීමේ දෝෂ සඳහා :

execute [INVOKING-FUNCTION] [COMMAND]

execute () {
    error=$($2 2>&1 >/dev/null)

    if [ $? -ne 0 ]; then
        echo "$1: $error"
        exit 1
    fi
}

කෙට්ටු නිෂ්පාදනයේ ආනුභාවයෙන් :

• සැලසුමෙන් දෝෂ කළ නොහැකි කරන්න
• කුඩාම පියවර තබන්න
• අයිතම එකින් එක අවසන් කරන්න
• එය ඕනෑම කෙනෙකුට පැහැදිලි කරන්න