පහත දැක්වෙන වාක්‍ය ඛණ්ඩය භාවිතා කරමින් මම ෂෙල් පිටපතක බූලියන් විචල්‍යයක් ප්‍රකාශ කිරීමට උත්සාහ කළෙමි:

variable=$false

variable=$true

මේක හරිද? එසේම, මට එම විචල්‍යය යාවත්කාලීන කිරීමට අවශ්‍ය නම් මම එකම සින්ටැක්ස් භාවිතා කරනවාද? අවසාන වශයෙන්, බූලියන් විචල්‍යයන් ප්‍රකාශන ලෙස භාවිතා කිරීම සඳහා පහත සඳහන් වාක්‍ය ඛණ්ඩය නිවැරදි ද?

if [ $variable ]

if [ !$variable ]

සංශෝධිත පිළිතුර (2014 පෙබරවාරි 12)

the_world_is_flat=true
# ...do something interesting...
if [ "$the_world_is_flat" = true ] ; then
    echo 'Be careful not to fall off!'
fi

මුල් පිළිතුර

Caveats: https://stackoverflow.com/a/21210966/89391

the_world_is_flat=true
# ...do something interesting...
if $the_world_is_flat ; then
    echo 'Be careful not to fall off!'
fi

සිට: Bash හි බූලියන් විචල්‍යයන් භාවිතා කිරීම

මුල් පිළිතුර මෙහි ඇතුළත් කිරීමට හේතුව වන්නේ 2014 පෙබරවාරි 12 වන දින සංශෝධනයට පෙර අදහස් මුල් පිළිතුරට පමණක් අදාළ වන අතර සංශෝධිත පිළිතුර සමඟ සම්බන්ධ වූ විට බොහෝ අදහස් වැරදි ය. නිදසුනක් ලෙස, true2010 ජුනි 2 වන දින ඩෙනිස් විලියම්සන්ගේ බාෂ් බිල්ඩින් පිළිබඳ ප්‍රකාශය අදාළ වන්නේ සංශෝධිත නොව මුල් පිළිතුරට පමණි.

ටීඑල්; ඩී.ආර්

bool=true

if [ "$bool" = true ]

මිකුගේ ( මුල් ) පිළිතුර සමඟ ගැටළු

මම කරන්නේ නැහැ විසින් පිළිගත් පිළිතුර නිර්දේශ ¹ . එහි වාක්‍ය ඛණ්ඩය ලස්සනයි, නමුත් එහි යම් අඩුපාඩු තිබේ.

අපට පහත කොන්දේසියක් ඇති බව පවසන්න.

if $var; then
  echo 'Muahahaha!'
fi

පහත දැක්වෙන අවස්ථා ^{2 හි} , මෙම තත්වය සත්‍ය ලෙස තක්සේරු කර කූඩු විධානය ක්‍රියාත්මක කරනු ඇත.

# Variable var not defined beforehand. Case 1
var=''  # Equivalent to var="".      # Case 2
var=                                 # Case 3
unset var                            # Case 4
var='<some valid command>'           # Case 5

සාමාන්‍යයෙන් ඔබට අවශ්‍ය වන්නේ ඔබේ "බූලියන්" විචල්‍යය varමෙම උදාහරණයේ දී පැහැදිලිවම සත්‍ය ලෙස සකසා ඇති විට ඔබේ තත්වය සත්‍ය ලෙස තක්සේරු කිරීමයි . අනෙක් සියලුම සිද්ධීන් භයානක ලෙස නොමඟ යවන සුළුය!

අන්තිම අවස්ථාව (# 5) විශේෂයෙන් නරකයි, මන්ද එය විචල්යයේ අඩංගු විධානය ක්රියාත්මක කරයි (වලංගු විධාන ^{3, 4} සඳහා තත්වය සත්‍ය ලෙස තක්සේරු කරන්නේ එබැවිනි ).

හානිකර උදාහරණයක් මෙන්න:

var='echo this text will be displayed when the condition is evaluated'
if $var; then
  echo 'Muahahaha!'
fi

# Outputs:
# this text will be displayed when the condition is evaluated
# Muahahaha!

ඔබේ විචල්‍යයන් උපුටා දැක්වීම වඩා ආරක්ෂිතයි, උදා if "$var"; then. ඉහත අවස්ථා වලදී, විධානය සොයාගත නොහැකි බවට ඔබට අනතුරු ඇඟවීමක් කළ යුතුය. නමුත් අපට තවමත් වඩා හොඳින් කළ හැකිය (පතුලේ මගේ නිර්දේශ බලන්න).

^{මිකුගේ මුල් පිළිතුර ගැන මයික් හෝල්ට්ගේ පැහැදිලි කිරීමද බලන්න.}

හබාර්ගේ පිළිතුර සමඟ ගැටළු

මෙම ප්රවේශය අනපේක්ෂිත හැසිරීම් ද ඇත.

var=false
if [ $var ]; then
  echo "This won't print, var is false!"
fi

# Outputs:
# This won't print, var is false!

ඉහත කොන්දේසිය අසත්‍යයක් ලෙස තක්සේරු කරනු ඇතැයි ඔබ අපේක්ෂා කරන අතර එමඟින් කිසි විටෙකත් කැදැලි ප්‍රකාශය ක්‍රියාත්මක නොකරයි. පුදුමය!

අගය ( "false") උපුටා දැක්වීම, විචල්‍යය ( "$var") උපුටා දැක්වීම හෝ භාවිතා කිරීම testහෝ [[ඒ වෙනුවට භාවිතා කිරීම හෝ [වෙනසක් නොකරන්න.

මම කුමක් කරන්නේ නිර්දේශ:

ඔබේ "බූලියන්ස්" පරීක්ෂා කිරීමට මම නිර්දේශ කරන ක්‍රම මෙන්න. ඔවුන් බලාපොරොත්තු වූ පරිදි වැඩ කරයි.

bool=true

if [ "$bool" = true ]; then
if [ "$bool" = "true" ]; then

if [[ "$bool" = true ]]; then
if [[ "$bool" = "true" ]]; then
if [[ "$bool" == true ]]; then
if [[ "$bool" == "true" ]]; then

if test "$bool" = true; then
if test "$bool" = "true"; then

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

පාද සටහන්

1. මිකුගේ පිළිතුර එතැන් සිට සංස්කරණය කර ඇති අතර තවදුරටත් (දන්නා) අඩුපාඩු අඩංගු නොවේ.
2. පරිපූර්ණ ලැයිස්තුවක් නොවේ.
3. මෙම සන්දර්භය තුළ වලංගු විධානයක් යනු පවතින විධානයකි. විධානය නිවැරදිව හෝ වැරදි ලෙස භාවිතා කර ඇත්ද යන්න ගැටළුවක් නොවේ. man womanඑබඳු මෑන් පිටුවක් නොතිබුණද, උදා: වලංගු විධානයක් ලෙස සලකනු ලැබේ.
4. අවලංගු (නොපවතින) විධානයන් සඳහා, විධානය හමු නොවූ බවට බාෂ් සරලවම පැමිණිලි කරනු ඇත.
5. ඔබ දිග ගැන සැලකිලිමත් නම්, පළමු නිර්දේශය කෙටිම වේ.

Bash buildin trueගැන සහ වඩාත් නිශ්චිතවම, Bash වරහන් තුළ ප්‍රකාශන පුළුල් කිරීම සහ අර්ථ නිරූපණය කරන්නේ කෙසේද යන්න පිළිබඳව මෙහි යම් වැරදි වැටහීමක් ඇති බව පෙනේ .

දී කේතය miku පිළිතුර එම බෑෂ් builtin සමග කරන්න දෙයක් නැති බවයි true, හෝ /bin/true, හෝ වෙනත් කිසිම රසයක් trueවිධාන. මෙම අවස්ථාවෙහිදී, trueසරල අක්ෂර මාලාවකට වඩා වැඩි දෙයක් trueනොවන අතර, විචල්ය පැවරුමෙන් හෝ කොන්දේසි සහිත ප්‍රකාශනය ඇගයීමෙන් හෝ කිසි විටෙකත් විධානය / බිල්ඩින් වෙත ඇමතුමක් ලබා නොදේ.

පහත කේතය මිකුගේ පිළිතුරේ කේතයට ක්‍රියාකාරීව සමාන වේ:

the_world_is_flat=yeah
if [ "$the_world_is_flat" = yeah ]; then
    echo 'Be careful not to fall off!'
fi

මෙහි ඇති එකම වෙනස නම්, සසඳන විට අක්ෂර හතර 'y', 'e', ​​'a' සහ 'h' වෙනුවට 't', 'r', 'u' සහ 'e' ය. ඒක තමයි. විධානයක් හෝ බිල්ඩින් නම් කිරීමට කිසිදු උත්සාහයක් ගෙන නොමැත yeah, (මිකුගේ උදාහරණයේ) බාෂ් ටෝකනය විග්‍රහ කරන විට කිසිදු ආකාරයක විශේෂ හැසිරවීමක් සිදු නොවේ true. එය නූලක් පමණක් වන අතර එය සම්පූර්ණයෙන්ම අත්තනෝමතික ය.

යාවත්කාලීන කිරීම (2014-02-19): මිකුගේ පිළිතුරෙහි ඇති සබැඳිය අනුගමනය කිරීමෙන් පසුව, දැන් සමහර ව්‍යාකූලතා පැමිණෙන්නේ කොතැනින්දැයි මට පෙනේ. මිකුගේ පිළිතුර තනි වරහන් භාවිතා කරයි, නමුත් ඔහු සම්බන්ධ කරන කේත ස්නිපටය වරහන් භාවිතා නොකරයි. එය යන්තම්:

the_world_is_flat=true
if $the_world_is_flat; then
  echo 'Be careful not to fall off!'
fi

කේත ස්නිපෙට් දෙකම එකම ආකාරයකින් හැසිරෙනු ඇත, නමුත් වරහන් වර්‍ගය යටතේ සිදුවන දේ සම්පූර්ණයෙන්ම වෙනස් කරයි.

සෑම අවස්ථාවකම බාෂ් කරන්නේ කුමක්ද යන්න මෙන්න:

වරහන් නොමැත:

1. විචල්ය පුළුල් $the_world_is_flatවැල කිරීමට "true".
2. "true"විධානයක් ලෙස නූල විග්‍රහ කිරීමට උත්සාහ කිරීම .
3. trueවිධානය සොයාගෙන ක්‍රියාත්මක කරන්න (එක්කෝ බිල්ඩින් හෝ /bin/true, බාෂ් අනුවාදය අනුව).
4. trueවිධානයෙහි පිටවීමේ කේතය (සෑම විටම 0) සමඟ සසඳන්න . බොහෝ කවච වල 0 හි පිටවීමේ කේතය සාර්ථකත්වය පෙන්නුම් කරන අතර වෙනත් ඕනෑම දෙයක් අසාර්ථක බව පෙන්නුම් කරයි.
5. පිටවීමේ කේතය 0 (සාර්ථක) බැවින්, ifප්‍රකාශයේ thenවගන්තිය ක්‍රියාත්මක කරන්න

වරහන්:

1. විචල්ය පුළුල් $the_world_is_flatවැල කිරීමට "true".
2. දැන් සම්පුර්ණයෙන්ම පුළුල් වී ඇති කොන්දේසි සහිත ප්‍රකාශනය විග්‍රහ කරන්න string1 = string2. මෙම =ක්රියාකරු bash ගේ වේ string සංසන්දනය ක්රියාකරු. නිසා...
3. "true"සහ අතර සංසන්දනයක් කරන්න "true".
4. ඔව්, නූල් දෙක එක හා සමානයි, එබැවින් කොන්දේසිගත වටිනාකම සත්‍ය වේ.
5. ifප්‍රකාශයේ thenවගන්තිය ක්‍රියාත්මක කරන්න .

වරහන් රහිත කේතය ක්‍රියා කරයි, මන්ද trueවිධානය මඟින් පිටවීමේ කේතයක් 0 ලබා දෙන අතර එය සාර්ථකත්වය පෙන්නුම් කරයි. වරහන් කේතය ක්‍රියා කරයි, මන්ද යත් එහි අගය දකුණු පස ඇති $the_world_is_flatවචනාර්ථයට සමාන වන බැවිනි .true=

කාරණය ගෙදර ගෙනයාමට, පහත දැක්වෙන කේත කොටස් දෙක සලකා බලන්න:

මෙම කේතය (මූල වරප්‍රසාද සමඟ ක්‍රියාත්මක වන්නේ නම්) ඔබේ පරිගණකය නැවත ආරම්භ කරනු ඇත:

var=reboot
if $var; then
  echo 'Muahahaha! You are going down!'
fi

මෙම කේතය මුද්‍රණය කරන්නේ "හොඳයි උත්සාහ කරන්න" යනුවෙනි. නැවත පණගැන්වීමේ විධානය කැඳවනු නොලැබේ.

var=reboot
if [ $var ]; then
  echo 'Nice try.'
fi

යාවත්කාලීන කිරීම (2014-04-14)= සහ ==: AFAIK අතර ඇති වෙනස පිළිබඳ අදහස් දැක්වීමේ ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා කිසිදු වෙනසක් නොමැත. මෙම ==ක්රියාකරු සඳහා බෑෂ්-විශේෂිත පර්යාය පදයක් වන =අතර, ඈත මම දැකලා තියෙනවා ලෙස, ඔවුන් සියලු සන්දර්භයන් තුළ හරියටම එම වැඩ.

කෙසේ වෙතත්, මම විශේෂයෙන් කතා කරන්නේ එක්කෝ හෝ පරීක්ෂණ වලදී භාවිතා කරන =සහ ==නූල් සංසන්දනය කිරීමේ ක්‍රියාකරුවන් ගැන ය . මම එය යෝජනා නොකරන අතර සෑම තැනකම හුවමාරු කර ගත හැකිය.[ ][[ ]]===

උදාහරණයක් ලෙස, ඔබට පැහැදිලිවම විචල්‍ය පැවරුම් කළ නොහැක ==, වැනි var=="foo"(තාක්‍ෂණිකව ඔබට මෙය කළ හැකිය , නමුත් එහි වටිනාකම varවනුයේ "=foo", බාෂ් ==මෙහි ක්‍රියාකරුවෙකු නොදකින නිසා , එය =(පැවරුම්) ක්‍රියාකරුවෙකු දකින අතර , පසුව වචනයේ පරිසමාප්ත අර්ථයෙන්ම ="foo"එය බවට පත්වේ "=foo").

එසේම, නමුත් =සහ ==එකිනෙකට හුවමාරු වන අතර, ඔබ මතක එම පරීක්ෂණ කටයුතු ආකාරය කරන බව අවධාරණය කළ යුතුය කරන්නේ ඔබ තුළ එය භාවිතා කරන්නේ ද යන්න මත රඳා පවතී [ ]හෝ [[ ]], සහ ද operands උපුටා ඇත නැද්ද යන්න මත. උසස් බාෂ් ස්ක්‍රිප්ටින් මාර්ගෝපදේශය තුළ ඔබට ඒ ගැන වැඩිදුර කියවිය හැකිය : 7.3 වෙනත් සංසන්දනාත්මක ක්‍රියාකරුවන් ( =සහ සාකච්ඡාවට පහළට අනුචලනය කරන්න ==).

අංක ගණිත ප්‍රකාශන භාවිතා කරන්න.

#!/bin/bash

false=0
true=1

((false)) && echo false
((true)) && echo true
((!false)) && echo not false
((!true)) && echo not true

ප්‍රතිදානය:

සත්‍ය
අසත්‍ය නොවේ

දිග කතාවක් කෙටි:

බාෂ් හි බූලියන් නොමැත

සංසන්දනය හා කොන්දේසි අනුව බාෂ් සතුව බූලියන් ප්‍රකාශන ඇත. එයින් කියැවෙන්නේ ඔබට Bash හි ප්‍රකාශ කළ හැකි හා සංසන්දනය කළ හැකි දේ නූල් සහ සංඛ්‍යා ය. ඒක තමයි.

ඔබ කොතැනක trueහෝ falseබාෂ් හි කොතැනක සිටියත් එය නූලක් හෝ විධානයක් / බිල්ඩින් එකක් වන අතර එය එහි පිටවීමේ කේතය සඳහා පමණක් භාවිතා කරයි.

මෙම වාක්‍ය ඛණ්ඩය ...

if true; then ...

අත්‍යවශ්‍යයෙන්ම ...

if COMMAND; then ...

තත්ත්වය සෑම විටම විධානය ප්රතිලාභ පිටවීම් කේතය 0 සත්යයකි trueහා falseබෑෂ් builtins දෙයක් කරන්නේ නැහැ නමුත් මේවාට අනුරූප පිටවීම් කේතය නැවත බව ඇතැම් විට නවීන වැඩසටහන් වේ.

ඉහත කොන්දේසිය සමාන වේ:

COMMAND && ...

වර්ග වරහන් හෝ testවිධානය භාවිතා කරන විට , ඔබ එම ඉදිකිරීමේ පිටවීමේ කේතය මත විශ්වාසය තබයි. බව මතක තබා ගන්න [ ]සහ [[ ]]ද, වෙනත් ඕනෑම පමණක් විධාන / builtins වේ. නිසා ...

if [[ 1 == 1 ]]; then echo yes; fi

අදාල වන්නේ

if COMMAND; then echo yes; fi

සහ COMMANDමෙහි[[ 1 == 1 ]]

මෙම if..then..fiඉදිකිරීමක් පමණක් සින්ටැක්ටික් සීනි වේ. එකම බලපෑමක් සඳහා ඔබට සෑම විටම ද්විත්ව ඇම්පියර්සෑන්ඩ් මගින් වෙන් කරන ලද විධාන ධාවනය කළ හැකිය:

[[ 1 == 1 ]] && echo yes

මෙම පරීක්ෂණ ව්‍යුහයන් භාවිතා කරන විට trueසහ භාවිතා falseකිරීමේදී ඔබ සැබවින්ම ගමන් කරන්නේ නූලට "true"හෝ "false"පරීක්ෂණ විධානයට පමණි. මෙන්න උදාහරණයක්:

එය විශ්වාස කරන්න හෝ නොවන්න නමුත් එම කොන්දේසි සියල්ලම එකම ප්‍රති result ලයක් ලබා දෙයි :

if [[ false ]]; then ...
if [[ "false" ]]; then ...
if [[ true ]]; then ...
if [[ "true" ]]; then ...

ටීඑල්; ඩීආර්; සෑම විටම නූල් හෝ සංඛ්‍යා සමඟ සසඳන්න

අනාගත පාඨකයන්ට මෙම පැහැදිලි කිරීමට, මම වටා මිල කැඳවීම් භාවිතා සෑම විටම නිර්දේශ trueහා false:

DO

if [[ "${var}" == "true" ]]; then ...
if [[ "${var}" == "false" ]]; then ...
if [[ -n "${var:-}" ]]; then echo "var is not empty" ...

කරන්න එපා

if [ ... ]; then ...  # Always use double square brackets in bash!
if [[ "${var}" ]]; then ...  # This is not as clear or searchable as -n
if [[ "${var}" != true ]]; then ...  # Creates impression of Booleans
if [[ "${var}" -eq "true" ]]; then ...  # `-eq` is for numbers and doesn't read as easy as `==`

සමහරවිට

if [[ "${var}" != "true" ]]; then ...  # Creates impression of Booleans. It can be used for strict checking of dangerous operations. This condition is false for anything but the literal string "true".

බොහෝ කලකට පෙර, අප සතුව තිබූ සෑම අවස්ථාවකම sh, බූලියන්ස් හසුරුවනු ලැබුවේ testවැඩසටහනේ සම්මුතියක් මත යැපීමෙන් වන අතර testකිසිදු තර්කයක් නොමැතිව ධාවනය වුවහොත් ව්‍යාජ පිටවීමේ තත්වයක් ලබා දෙයි.

අසත්‍යයක් ලෙස සකසා නැති විචල්‍යයක් සහ ඕනෑම අගයකට සත්‍ය ලෙස සැකසූ විචල්‍යයක් ගැන සිතීමට මෙය කෙනෙකුට ඉඩ දෙයි. අද, testඑය බාෂ් සඳහා සාදන ලද එකක් වන අතර එය පොදුවේ හැඳින්වෙන්නේ එහි එක් අක්ෂර අන්වර්ථයකි [(හෝ ඩොල්මන් සටහන් කර ඇති පරිදි ෂෙල් වෙඩි නොමැති විට එය භාවිතා කළ හැකිය):

FLAG="up or <set>"

if [ "$FLAG" ] ; then
    echo 'Is true'
else
    echo 'Is false'
fi

# Unset FLAG
#    also works
FLAG=

if [ "$FLAG" ] ; then
    echo 'Continues true'
else
    echo 'Turned false'
fi

සම්මුති උපුටා දැක්වීම නිසා, පිටපත් [[රචකයින් අනුකරණය කරන සංයුක්ත විධානය භාවිතා කිරීමට කැමැත්තක් දක්වයි test, නමුත් වඩා හොඳ වාක්‍ය ඛණ්ඩයක් ඇත: අවකාශයන් සහිත විචල්‍යයන් උපුටා දැක්වීමට අවශ්‍ය නොවේ; භාවිතා කළ හැකි &&හා ||අමුතු තැනක්ද සමග තාර්කික ලෙස, සහ පද සංඛ්යාව කිසිදු POSIX සීමාවන් ඇත.

උදාහරණයක් ලෙස, FLAG සකසා තිබේද සහ COUNT 1 ට වඩා වැඩි සංඛ්‍යාවක්ද යන්න තීරණය කිරීම සඳහා:

FLAG="u p"
COUNT=3

if [[ $FLAG  && $COUNT -gt '1' ]] ; then
    echo 'Flag up, count bigger than 1'
else
    echo 'Nope'
fi

අවකාශය, ශුන්‍ය දිග නූල් සහ ශුන්‍ය විචල්‍යයන් අවශ්‍ය වන විටත්, ඔබේ ස්ක්‍රිප්ටයට ෂෙල් වෙඩි කිහිපයක් සමඟ වැඩ කිරීමට අවශ්‍ය වූ විටත් මෙම දේවල් ව්‍යාකූල විය හැකිය .

ෂෙල් ස්ක්‍රිප්ට් එකක බූලියන් විචල්‍යයන් ප්‍රකාශ කර භාවිතා කරන්නේ කෙසේද?

වෙනත් බොහෝ ක්‍රමලේඛන භාෂාවන් මෙන් නොව, බාෂ් එහි විචල්‍යයන් "වර්ගය" අනුව වෙන් නොකරයි. [1]

එබැවින් පිළිතුර ඉතා පැහැදිලිය. Bash හි කිසිදු බූලියන් විචල්‍යයක් නොමැත .

කෙසේවෙතත්:

ප්‍රකාශන ප්‍රකාශයක් භාවිතා කරමින්, අපට අගය පැවරීම විචල්‍යයන්ට සීමා කළ හැකිය. [2]

#!/bin/bash
declare -ir BOOL=(0 1) # Remember BOOL can't be unset till this shell terminates
readonly false=${BOOL[0]}
readonly true=${BOOL[1]}

# Same as declare -ir false=0 true=1
((true)) && echo "True"
((false)) && echo "False"
((!true)) && echo "Not True"
((!false)) && echo "Not false"

මෙම rතුළ විකල්පය declareහා readonlyවිචල්යයන් බව පැහැදිලිව ම සඳහන් කිරීමට භාවිතා කරයි කියවීම පමණයි . අරමුණ පැහැදිලි බව මම විශ්වාස කරමි.

බූලියන් ව්‍යාජ ලෙස සකස් කර අනාගත පා readers කයන්ට උගුලක් තබනවා වෙනුවට සත්‍ය හා අසත්‍යයට වඩා හොඳ වටිනාකමක් භාවිතා නොකරන්නේ මන්ද?

උදාහරණයක් වශයෙන්:

build_state=success
if something-horrible; then
  build_state=failed
fi

if [[ "$build_state" == success ]]; then
  echo go home; you are done
else
  echo your head is on fire; run around in circles
fi

මගේ සොයා ගැනීම් සහ යෝජනාව අනෙක් තනතුරු වලට වඩා ටිකක් වෙනස් ය. "හූප් ජම්පිං" යෝජනා නොකර, ඕනෑම "සාමාන්‍ය" භාෂාවක මෙන් මූලික වශයෙන් මට "බූලියන්" භාවිතා කළ හැකි බව මට පෙනී ගියේය ...

[]නූල් සැසඳීම් අවශ්‍ය හෝ පැහැදිලි නැත ... මම ලිනක්ස් බෙදාහැරීම් කිහිපයක් උත්සාහ කළෙමි. මම Bash, Dash සහ BusyBox පරීක්ෂා කළා. ප්‍රති results ල සෑම විටම එක හා සමාන විය. ඉහළ ඡන්දය දුන් මුල් තනතුරු ගැන කතා කරන්නේ කුමක් දැයි මට විශ්වාස නැත. සමහර විට කාලය වෙනස් වී ඇති අතර එපමණක් තිබේද?

ඔබ විචල්‍යයක් සකසන්නේ නම් true, එය පසුව කොන්දේසියක් තුළ “සහතික කිරීමක්” ලෙස තක්සේරු කරයි. එය සකසන්න false, එය ".ණ" ලෙස ඇගයීමට ලක් කරයි. හරිම සරලයි! එකම අවවාදය නම්, නිර්වචනය නොකළ විචල්‍යයක් සත්‍ය ලෙස තක්සේරු කිරීමයි ! එය ප්‍රතිවිරුද්ධ දේ (බොහෝ භාෂාවලින් මෙන්) කළහොත් හොඳයි, නමුත් එය උපක්‍රමයයි - ඔබේ බූලියන් සත්‍ය හෝ අසත්‍ය ලෙස පැහැදිලිව ආරම්භ කළ යුතුය .

එය මේ ආකාරයෙන් ක්‍රියාත්මක වන්නේ ඇයි? එම පිළිතුර දෙයාකාරයකි. අ) කවචයක සත්‍ය / අසත්‍යය යනු සැබවින්ම "දෝෂයක් නැත" එදිරිව "දෝෂය" (එනම් 0 එදිරිව වෙනත් කිසිවක්) යන්නයි. නමුත් ඒ වෙනුවට - බී) සැබෑ / බොරු වටිනාකම් නැත ප්රකාශ ෂෙල් විධානාවලි දී! දෙවන කරුණ සම්බන්ධයෙන්, ක්‍රියාත්මක කිරීම trueහෝ falseරේඛාවක් මඟින් ඔබ එම අගයට ප්‍රතිලාභ අගය නියම කරයි, එනම් false“දෝෂයක් ඇතිවීම” ප්‍රකාශ කිරීමකි, එහිදී සත්‍ය “නිෂ්කාශනය” වේ. විචල්යයට පැවරුමක් සහිතව එය භාවිතා කිරීම විචල්යයට "ආපසු". ක නිර්වචනය නොකළ වැනි විචල්ය ඇගයීමට trueසමානව 0 නියෝජනය වන නිසා හෝ "නැත දෝෂයක්" කොන්දේසි දී.

පහත දැක්වෙන බෑෂ් රේඛා සහ ප්‍රති results ල බලන්න. ඔබට තහවුරු කිරීමට අවශ්‍ය නම් එය ඔබම පරීක්ෂා කරන්න ...

#!/bin/sh

# Not yet defined...
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=true
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

myBool=false
echo "when set to ${myBool}"
if ${myBool}; then echo "it evaluates to true"; else echo "it evaluates to false"; fi;

අස්වැන්න

when set to
it evaluates to true
when set to true
it evaluates to true
when set to false
it evaluates to false

පොසික්ස් (අතේ ගෙන යා හැකි මෙහෙයුම් පද්ධති අතුරුමුහුණත)

අතේ ගෙන යා හැකි ප්‍රධාන කරුණ මට මෙහි මග හැරී ඇත. මගේ ශීර්ෂකය තුළම POSIX ඇත්තේ එබැවිනි .

අත්යවශ්යයෙන්ම, ඡන්දය දුන් සියලු පිළිතුරු නිවැරදි ය, ඒවා හැරුණු විට ඒවා බාෂ්- විශේෂිත ය .

මූලික වශයෙන්, මම බලාපොරොත්තු වන්නේ අතේ ගෙන යා හැකි ආකාරය පිළිබඳ වැඩි විස්තර එකතු කිරීමට පමණි.

1. [සහ ]වැනි වරහන් [ "$var" = true ]අවශ්‍ය නොවන අතර, ඔබට ඒවා අතහැර testසෘජුවම විධානය භාවිතා කළ හැකිය :

   test "$var" = true && yourCodeIfTrue || yourCodeIfFalse

   වැදගත් සටහන: මම මෙය තවදුරටත් නිර්දේශ නොකරන්නේ එය සෙමින් ක්ෂය වී ඇති අතර බහු ප්‍රකාශයන් ඒකාබද්ධ කිරීම වඩාත් අපහසු වන බැවිනි.

2. එම වචන trueසහ falseකවචයට අදහස් කරන්නේ කුමක්දැයි සිතා බලන්න , එය ඔබම පරීක්ෂා කරන්න:

   echo $(( true ))

   0

   echo $(( false ))

   1

   නමුත් උපුටා දැක්වීම් භාවිතා කිරීම:

   echo $(( "true" ))

   bash: "true": syntax error: operand expected (error token is ""true"")
   sh (dash): sh: 1: arithmetic expression: expecting primary: ""true""

   මෙයම වේ:

   echo $(( "false" ))

   කවචයට එය නූල් හැර වෙනත් අර්ථකථනය කළ නොහැක. උපුටා දැක්වීම් නොමැතිව නිසි වචන පදය භාවිතා කිරීම කොතරම් හොඳද යන්න පිළිබඳ අදහස ඔබට ලැබෙනු ඇතැයි මම බලාපොරොත්තු වෙමි .

   නමුත් පෙර පිළිතුරු වලින් කිසිවෙකු එය කීවේ නැත.

3. මෙමගින් කුමක් වෙයිද? හොඳයි, කරුණු කිහිපයක්.

   • ඔබ බූලියන් වචන වලට පුරුදු විය යුත්තේ සැබවින්ම සංඛ්‍යා ලෙස සලකනු ලැබේ, එනම් true= 0සහ false= 1, ශුන්‍ය නොවන අගයන් සියල්ලම සලකනු ලබන බව මතක තබා ගන්න false.

   • ඒවා සංඛ්‍යා ලෙස සලකන බැවින්, ඔබත් ඔවුන්ට එලෙසම සැලකිය යුතුය, එනම් ඔබ විචල්ය අර්ථ දක්වන්නේ නම්:

     var_bool=true
     echo "$var_bool"

      true

     ඔබට මෙහි ප්‍රතිවිරුද්ධ අගයක් නිර්මාණය කළ හැකිය:

     var_bool=$(( 1 - $var_bool ))  # same as $(( ! $var_bool ))
     echo "$var_bool"

     1

   ඔබට පෙනෙන පරිදි, කවචය trueඔබ පළමු වරට එය භාවිතා කරන විට මුද්‍රණ නූලක් කරයි, නමුත් එතැන් සිට, ඒ සියල්ල පිළිවෙලින් 0නියෝජනය කරන trueහෝ 1නියෝජනය කරන අංක හරහා ක්‍රියා කරයි false.

අවසාන වශයෙන්, ඔබ එම සියලු තොරතුරු සමඟ කළ යුත්තේ කුමක්ද

• පළමුව, එක් හොඳ පුරුද්දක් 0වෙනුවට පැවරීම true; 1වෙනුවට false.

• දෙවන හොඳ පුරුද්ද වනුයේ විචල්‍යය ශුන්‍යයට සමාන නොවේද යන්න පරීක්ෂා කිරීමයි:

  if [ "$var_bool" -eq 0 ]; then
       yourCodeIfTrue
  else
       yourCodeIfFalse
  fi

වාක්‍ය ඛණ්ඩය සම්බන්ධයෙන් ගත් කල, මෙය බූලියන් තර්කනය නිරන්තරයෙන් හා බුද්ධිමත්ව කළමනාකරණය කිරීම සඳහා මම භාවිතා කරන සරල ක්‍රමයකි (උදාහරණයක් ලෙස):

# Tests
var=
var=''
var=""
var=0
var=1
var="abc"
var=abc

if [[ -n "${var}" ]] ; then
    echo 'true'
fi
if [[ -z "${var}" ]] ; then
    echo 'false'
fi

# Results
# var=        # false
# var=''      # false
# var=""      # false
# var=0       # true
# var=1       # true
# var="abc"   # true
# var=abc     # true

විචල්‍යය කිසි විටෙකත් ප්‍රකාශ නොකළහොත් පිළිතුර: # false

ඒ නිසා, (මෙම කාරක රීති ක්රමවේදය භාවිතා කරමින්) සැබෑ කිරීමට විචල්ය ඇති කිරීමට සරල ක්රමයක් වනු ඇත, var=1; අනෙක් අතට , var=''.

යොමුව:

-n = Var string වල දිග ශුන්‍ය නොවේ නම් සත්‍යය.

-z = Var string වල දිග ශුන්‍ය නම් සත්‍යය.

බොහෝ ක්‍රමලේඛන භාෂාවල, බූලියන් වර්ගය පූර්ණ සංඛ්‍යා වල උප ප්‍රභේදයක් ලෙස ක්‍රියාත්මක වේ, එහිදී trueහැසිරෙන්නේ 1හා falseහැසිරෙන්නේ 0:

• සී හි බූලියන්

• පයිතන් හි බූලියන්

• ජාවා හි බූලියන්

ගණිතමය වශයෙන් , බූලියන් වීජ ගණිතය පූර්ණ සංඛ්‍යා ගණිත මොඩියුලයට සමාන වේ. එබැවින් භාෂාවක් ස්වදේශීය බූලියන් වර්ගයක් ලබා නොදෙන්නේ නම්, වඩාත් ස්වාභාවික හා කාර්යක්ෂම විසඳුම වන්නේ පූර්ණ සංඛ්‍යා භාවිතා කිරීමයි. මෙය ඕනෑම භාෂාවක් සමඟ ක්‍රියා කරයි. උදාහරණයක් ලෙස, Bash හි ඔබට කළ හැක්කේ:

# val=1; ((val)) && echo "true" || echo "false"
true
# val=0; ((val)) && echo "true" || echo "false"
false

මෑන් බාෂ් :

((ප්‍රකාශනය))

ARITHMETIC EVALUATION යටතේ පහත විස්තර කර ඇති නීතිරීති අනුව ප්‍රකාශනය ඇගයීමට ලක් කෙරේ. ප්‍රකාශනයේ අගය ශුන්‍ය නොවේ නම්, ප්‍රතිලාභ තත්ත්වය 0; නැතහොත් ආපසු පැමිණීමේ තත්වය 1 වේ. මෙය හරියටම "ප්‍රකාශනයට" ඉඩ දීමට සමාන වේ.

බිල් පාකර් ඡන්දය ප්‍රකාශ කිරීම අඩු කරන්නේ ඔහුගේ අර්ථ දැක්වීම් සාමාන්‍ය කේත සම්මුතියෙන් ආපසු හරවන බැවිනි. සාමාන්‍යයෙන් සත්‍යය 0 ලෙසත් අසත්‍යය නිර්වචනය ලෙසත් අර්ථ දැක්වේ. 9999 සහ -1 මෙන් 1 ව්‍යාජ ලෙස ක්‍රියා කරයි. ශ්‍රිත ප්‍රතිලාභ අගයන් සමඟ සමාන වේ - 0 සාර්ථකත්වය වන අතර ඕනෑම දෙයක් අසාර්ථක වේ. කණගාටුයි, මට තවම ඡන්දය දීමට හෝ ඔහුට කෙලින්ම පිළිතුරු දීමට වීදි විශ්වසනීයත්වයක් නොමැත.

තනි වරහන් වෙනුවට පුරුද්දක් ලෙස ද්විත්ව වරහන් භාවිතා කිරීමට බාෂ් නිර්දේශ කරන අතර මයික් හෝල්ට් ලබා දුන් සබැඳිය ඒවා ක්‍රියා කරන ආකාරයෙහි වෙනස්කම් පැහැදිලි කරයි. 7.3. වෙනත් සංසන්දනාත්මක ක්‍රියාකරුවන්

එක් දෙයක් නම්, -eqසංඛ්‍යාත්මක ක්‍රියාකරු වන බැවින් කේතය තිබීම

#**** NOTE *** This gives error message *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

පූර්ණ ප්‍රකාශනයක් අපේක්ෂා කරමින් දෝෂ ප්‍රකාශයක් නිකුත් කරනු ඇත. පූර්ණ සංඛ්‍යා අගයක් නොවන බැවින් මෙය එක් පරාමිතියකටම අදාළ වේ. එහෙත්, අපි එය වටා ද්විත්ව වරහන් දැමුවහොත්, එය වැරදි ප්‍රකාශයක් නිකුත් නොකරනු ඇත, නමුත් එය වැරදි අගයක් ලබා දෙනු ඇත (හොඳයි, විය හැකි ප්‍රේරණයන්ගෙන් 50% ක් තුළ). එය [[0 -eq true]] = සාර්ථකත්වයට පමණක් නොව [[0 -eq false]] = සාර්ථකත්වයටද තක්සේරු කරනු ඇත, එය වැරදියි (හ්ම්ම් .... එම බිල්ඩින් සංඛ්‍යාත්මක අගයක් වීම ගැන කුමක් කිව හැකිද?).

#**** NOTE *** This gives wrong output *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then

කොන්දේසි සහිත වෙනත් ප්‍රේරණයන් ද ඇත, එමඟින් වැරදි ප්‍රතිදානය ද ලැබෙනු ඇත. මූලික වශයෙන්, විචල්‍යයක් සංඛ්‍යාත්මක අගයකට සකසා එය සත්‍ය / ව්‍යාජ බිල්ඩින් සමඟ සංසන්දනය කරන හෝ විචල්‍යයක් සත්‍ය / ව්‍යාජ බිල්ඩින් සමඟ සංසන්දනය කර සංඛ්‍යාත්මක අගයකට සංසන්දනය කරන ඕනෑම දෙයක් (ඉහත ලැයිස්තුගත කර ඇති දෝෂ තත්ත්වය හැර). සත්‍ය / ව්‍යාජ බිල්ඩින් වෙත විචල්‍යයක් සැකසෙන සහ භාවිතා කරමින් සංසන්දනයක් කරන ඕනෑම දෙයක් -eq. එබැවින් -eqබූලියන් සැසඳීම් වලින් වළකින්න සහ බූලියන් සැසඳීම් සඳහා සංඛ්‍යාත්මක අගයන් භාවිතා කිරීමෙන් වළකින්න. අවලංගු ප්‍රති results ල ලබා දෙන ප්‍රේරණයන්ගේ සාරාංශයක් මෙන්න:

# With variable set as an integer and evaluating to true/false
# *** This will issue error warning and not run: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then

# With variable set as an integer and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=0;
if [ "${The_world_is_flat}" -eq true ]; then
#
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" == true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then


# With variable set as an true/false builtin and evaluating to true/false
# *** These statements will not evaluate properly: *****
The_world_is_flat=true;
if [[ "${The_world_is_flat}" -eq true ]]; then
#
if [ "${The_world_is_flat}" = 0 ]; then
#
if [[ "${The_world_is_flat}" = 0 ]]; then
#
if [ "${The_world_is_flat}" == 0 ]; then
#
if [[ "${The_world_is_flat}" == 0 ]]; then

ඉතින්, දැන් වැඩ කරන දෙයට. ඔබගේ සංසන්දනය සහ ඇගයීම යන දෙකටම සත්‍ය / ව්‍යාජ බිල්ඩින් භාවිතා කරන්න (මයික් හන්ට් සඳහන් කළ පරිදි, ඒවා මිල ගණන් වල කොටු නොකරන්න). ඉන්පසු හෝ තනි හෝ ද්විත්ව සමාන ලකුණක් (= හෝ ==) සහ තනි හෝ ද්විත්ව වරහන් ([] හෝ [[]) භාවිතා කරන්න. පුද්ගලිකව, මම ද්විත්ව සමාන ලකුණට කැමතියි, මන්ද එය වෙනත් ක්‍රමලේඛන භාෂාවල තාර්කික සැසඳීම් මට මතක් කර දෙන අතර, යතුරු ලියනය කිරීමට මා කැමති නිසා ද්විත්ව උපුටා දැක්වීම්. එබැවින් මෙම වැඩ:

# With variable set as an integer and evaluating to true/false
# *** These statements will work properly: *****
#
The_world_is_flat=true/false;
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" = true ]]; then
#
if [ "${The_world_is_flat}" = true ]; then
#
if [[ "${The_world_is_flat}" == true ]]; then

එහිදී ඔබට එය තිබේ.

මෙන්න මට වැඩ කරන සරල උදාහරණයක්:

temp1=true
temp2=false

if [ "$temp1" = true ] || [ "$temp2" = true ]
then
    echo "Do something." 
else
    echo "Do something else."
fi

කෙටිකාලීනව ක්‍රියාත්මක කිරීම මෙන්න if true.

# Function to test if a variable is set to "true"
_if () {
    [ "${1}" == "true" ] && return 0
    [ "${1}" == "True" ] && return 0
    [ "${1}" == "Yes" ] && return 0
    return 1
}

උදාහරණ 1

my_boolean=true

_if ${my_boolean} && {
    echo "True Is True"
} || {
    echo "False Is False"
}

උදාහරණ 2

my_boolean=false
! _if ${my_boolean} && echo "Not True is True"

පවතින පිළිතුරු අවුල් සහගත බව මට පෙනී ගියේය.

පුද්ගලිකව, මට අවශ්‍ය වන්නේ සී මෙන් පෙනෙන හා ක්‍රියා කරන යමක් ලබා ගැනීමට ය.

නිෂ්පාදනයේ මෙම ස්නිපටය දිනකට බොහෝ වාරයක් ක්‍රියා කරයි:

snapshotEvents=true

if ($snapshotEvents)
then
    # Do stuff if true
fi

හැමෝම සතුටින් තියන්න, මම පරීක්ෂා කළා:

snapshotEvents=false

if !($snapshotEvents)
then
    # Do stuff if false
fi

එය ද හොඳින් ක්‍රියාත්මක විය.

මෙම $snapshotEventsවිචල්ය අගය අන්තර්ගතය පරීක්ෂා කර බැලීමයි. ඉතින් ඔබට අවශ්‍යයි $.

ඔබට සැබවින්ම වරහන් අවශ්‍ය නැත, මම ඒවා ප්‍රයෝජනවත් යැයි සිතමි.

• පරීක්ෂා කර ඇත්තේ: ග්නූ බෑෂ්, 4.1.11 (2) අනුවාදය - මුදා හැරීම

• ආරම්භකයින් සඳහා වන මාර්ගෝපදේශය , මැක්ටෙල්ට් ගැරල්ස්, v1.11, 2008

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

the_world_is_flat=true

if ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

විචල්‍යය දැයි පරීක්ෂා කිරීමට false:

if ! ${the_world_is_flat:-false} ; then
    echo "Be careful not to fall off!"
fi

විචල්යයේ අප්රසන්න අන්තර්ගතයක් ඇති වෙනත් අවස්ථා ගැන, මෙය වැඩසටහනකට පෝෂණය වන ඕනෑම බාහිර ආදානයක ගැටළුවකි.

ඕනෑම බාහිර ආදානයක් විශ්වාස කිරීමට පෙර එය වලංගු කළ යුතුය. නමුත් එම වලංගු කිරීම එක් වරක් පමණක් කළ යුතුය, එම ආදානය ලැබුණු විට.

ඩෙනිස් විලියම්සන් යෝජනා කරන ආකාරයට විචල්‍යයේ සෑම භාවිතයක්ම සිදු කිරීමෙන් එය වැඩසටහනේ ක්‍රියාකාරිත්වයට බලපෑම් කළ යුතු නැත .

ඔබට shFlags භාවිතා කළ හැකිය .

එය ඔබට අර්ථ දැක්වීමේ විකල්පය ලබා දෙයි: DEFINE_bool

උදාහරණයක්:

DEFINE_bool(big_menu, true, "Include 'advanced' options in the menu listing");

විධාන රේඛාවෙන් ඔබට අර්ථ දැක්විය හැකිය:

sh script.sh --bigmenu
sh script.sh --nobigmenu # False

මෙය Bash හි "බූලියන්" අගයන් පරීක්ෂා කිරීම සඳහා විවිධ ක්‍රම පිළිබඳ වේගවත් පරීක්ෂණයකි:

#!/bin/bash
rounds=100000

b=true # For true; b=false for false
type -a true
time for i in $(seq $rounds); do command $b; done
time for i in $(seq $rounds); do $b; done
time for i in $(seq $rounds); do [ "$b" == true ]; done
time for i in $(seq $rounds); do test "$b" == true; done
time for i in $(seq $rounds); do [[ $b == true ]]; done

b=x; # Or any non-null string for true; b='' for false
time for i in $(seq $rounds); do [ "$b" ]; done
time for i in $(seq $rounds); do [[ $b ]]; done

b=1 # Or any non-zero integer for true; b=0 for false
time for i in $(seq $rounds); do ((b)); done

එය වැනි දෙයක් මුද්‍රණය කරනු ඇත

true is a shell builtin
true is /bin/true

real    0m0,815s
user    0m0,767s
sys     0m0,029s

real    0m0,562s
user    0m0,509s
sys     0m0,022s

real    0m0,829s
user    0m0,782s
sys     0m0,008s

real    0m0,782s
user    0m0,730s
sys     0m0,015s

real    0m0,402s
user    0m0,391s
sys     0m0,006s

real    0m0,668s
user    0m0,633s
sys     0m0,008s

real    0m0,344s
user    0m0,311s
sys     0m0,016s

real    0m0,367s
user    0m0,347s
sys     0m0,017s

විකල්ප - ශ්‍රිතයක් භාවිතා කරන්න

is_ok(){ :;}
is_ok(){ return 1;}
is_ok && echo "It's OK" || echo "Something's wrong"

ශ්‍රිතය නිර්වචනය කිරීම අඩු අවබෝධයක් ඇත, නමුත් එහි ප්‍රතිලාභ අගය පරීක්ෂා කිරීම ඉතා පහසුය.

බෑෂ් ඇත්තටම වැන්නවුන් සමග මෙම ප්රශ්නය අපහසුවට පත් [, [[, ((, $((, ආදිය

සියල්ලන්ම එකිනෙකාගේ කේත අවකාශයන් මත පාගා දමයි. මම හිතන්නේ මෙය බොහෝ දුරට historical තිහාසික එකක් වන අතර එහිදී බාෂ්ට shඉඳහිට මවා පෑමට සිදු විය .

බොහෝ විට, මට ක්‍රමයක් තෝරාගෙන එය සමඟ බැඳී සිටිය හැකිය. මෙම අවස්ථාවෙහිදී, මම ප්‍රකාශ කිරීමට නැඹුරු වෙමි (වඩාත් සුදුසු පොදු පුස්තකාල ගොනුවක .මගේ සත්‍ය පිටපත්වල ඇතුළත් කළ හැකිය ).

TRUE=1; FALSE=0

මෙසේ පරීක්ෂා කිරීමට මට ((... ))ගණිත ක්‍රියාකරු භාවිතා කළ හැකිය .

testvar=$FALSE

if [[ -d ${does_directory_exist} ]]
then
    testvar=$TRUE;
fi

if (( testvar == TRUE )); then
    # Do stuff because the directory does exist
fi

1. ඔබ විනයගරුක විය යුතුයි. ඔබේ testvarයුතු එක්කෝ කිරීම සිදු කරනු ලබයි $TRUEහෝ $FALSEසෑම විටම.

2. තුළ ((... ))සංසන්දකයන්, ඔබට පෙර කියවීම අවශ්‍ය නොවන $අතර එය වඩාත් කියවිය හැකිය.

3. මට භාවිතා කළ හැකිය ((... ))මන්ද $TRUE=1සහ $FALSE=0, එනම් සංඛ්‍යාත්මක අගයන්.

4. අවාසිය නම් $ඉඳහිට භාවිතා කිරීමට සිදුවීමයි:

   testvar=$TRUE

   එය එතරම් ලස්සන නැත.

එය පරිපූර්ණ විසඳුමක් නොවේ, නමුත් එවැනි පරීක්ෂණයකට මට අවශ්‍ය සෑම අවස්ථාවක්ම එය ආවරණය කරයි.