変数がBashの数値であるかどうかをテストするにはどうすればよいですか？

スクリプトに渡される引数が数値であるかどうかを確認する方法がわかりません。

私がしたいのは次のようなものです：

test *isnumber* $1 && VAR=$1 || echo "need a number"

何か助けは？

1つのアプローチは、次のように正規表現を使用することです。

re='^[0-9]+$'
if ! [[ $yournumber =~ $re ]] ; then
   echo "error: Not a number" >&2; exit 1
fi

値が整数でない場合は、正規表現を適切に修正することを検討してください。例えば：

^[0-9]+([.][0-9]+)?$

...または、符号付きの数値を処理するには：

^[+-]?[0-9]+([.][0-9]+)?$

バシズムなし（System V shでも機能）、

case $string in
    ''|*[!0-9]*) echo bad ;;
    *) echo good ;;
esac

これにより、空の文字列および数字以外の文字列を拒否し、その他すべてを受け入れます。

負の数または浮動小数点数には、追加の作業が必要です。最初の「悪い」パターンで-/ を除外.し、それらの不適切な使用を含む「悪い」パターンをさらに追加する（?*-*/ *.*.*）

次のソリューションは、正規表現を必要とせず、Bourneなどの基本的なシェルでも使用できます。基本的に、非数値を使用した数値評価演算はエラーとなり、シェルでは暗黙的にfalseと見なされます。

"$var" -eq "$var"

のように：

#!/bin/bash

var=a

if [ -n "$var" ] && [ "$var" -eq "$var" ] 2>/dev/null; then
  echo number
else
  echo not a number
fi

$をテストすることもできますか？より明示的な操作の戻りコード：

[ -n "$var" ] && [ "$var" -eq "$var" ] 2>/dev/null
if [ $? -ne 0 ]; then
   echo $var is not number
fi

標準エラーのリダイレクトは、数値がない場合にbashが出力する「予想される整数式」メッセージを非表示にすることです。

警告（以下のコメントのおかげで）：

• 小数点付きの数値は有効な「数値」として識別され
• の[[ ]]代わりに使用[ ]と、常に評価されますtrue
• ほとんどの非Bashシェルは、この式を常に次のように評価します true
• Bashの動作は文書化されていないため、警告なしに変更される可能性があります
• 値の後にスペースが含まれている場合（例： "1 a"）は次のようなエラーを生成します bash: [[: 1 a: syntax error in expression (error token is "a")
• 値がvar-nameと同じ場合（例：i = "i"）、次のようなエラーが発生します。 bash: [[: i: expression recursion level exceeded (error token is "i")

これは、数値が非負の整数であり、両方ともシェルに依存せず（つまり、バシズムなし）、シェルの組み込みのみを使用するかどうかをテストします。

誤り。

この最初の回答（下記）では、最初の回答が変数の最初でない限り、文字を含む整数を使用できます。

[ -z "${num##[0-9]*}" ] && echo "is a number" || echo "is not a number";

正しい。

以下のようjillesがでコメントや提案彼の答えこれは、シェル・パターンを使用して、それを行うための正しい方法です。

[ ! -z "${num##*[!0-9]*}" ] && echo "is a number" || echo "is not a number";

誰もbashの拡張パターンマッチングを提案していません：

[[ $1 == ?(-)+([0-9]) ]] && echo "$1 is an integer"

シェルで数値形式を直接解析するソリューションに驚いています。シェルはこれにはあまり適していません。ファイルとプロセスを制御するためのDSLです。少し下に、十分な数のパーサーがあります。次に例を示します。

isdecimal() {
  # filter octal/hex/ord()
  num=$(printf '%s' "$1" | sed "s/^0*\([1-9]\)/\1/; s/'/^/")

  test "$num" && printf '%f' "$num" >/dev/null 2>&1
}

'％f'を必要な特定の形式に変更します。

私は答えを見ていました... FLOAT数（ドット付き）について誰も考えていないことに気づきました！

grepの使用も素晴らしいです。
-Eは拡張正規表現を
意味します-qは静かな（エコーしない）ことを意味します
-qEは両方の組み合わせです。

コマンドラインで直接テストするには：

$ echo "32" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is: 32

$ echo "3a2" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is empty (false)

$ echo ".5" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer .5

$ echo "3.2" | grep -E ^\-?[0-9]?\.?[0-9]+$  
# answer is 3.2

bashスクリプトでの使用：

check=`echo "$1" | grep -E ^\-?[0-9]*\.?[0-9]+$`

if [ "$check" != '' ]; then    
  # it IS numeric
  echo "Yeap!"
else
  # it is NOT numeric.
  echo "nooop"
fi

JUST整数に一致させるには、次のようにします。

# change check line to:
check=`echo "$1" | grep -E ^\-?[0-9]+$`

@maryまでの単なるフォローアップ。しかし、十分な担当者がいないため、この投稿へのコメントとしてこれを投稿できませんでした。とにかく、これが私が使ったものです：

isnum() { awk -v a="$1" 'BEGIN {print (a == a + 0)}'; }

この関数は、引数が数値の場合は「1」を返し、それ以外の場合は「0」を返します。これは、浮動小数点数だけでなく整数でも機能します。使い方は次のようなものです：

n=-2.05e+07
res=`isnum "$n"`
if [ "$res" == "1" ]; then
     echo "$n is a number"
else
     echo "$n is not a number"
fi

test -z "${i//[0-9]}" && echo digits || echo no no no

${i//[0-9]}の値の数字を$i空の文字列に置き換えますman -P 'less +/parameter\/' bash。を参照してください。-z結果の文字列の長さがゼロかどうかをチェックします。

$iが空の場合もケースを除外したい場合は、次の構文のいずれかを使用できます。

test -n "$i" && test -z "${i//[0-9]}" && echo digits || echo not a number
[[ -n "$i" && -z "${i//[0-9]}" ]] && echo digits || echo not a number

私の問題では、ユーザーが誤ってテキストを入力しないようにする必要があるだけだったので、シンプルで読みやすいものにしようとしました

isNumber() {
    (( $1 )) 2>/dev/null
}

manページによると、これはほとんど私が望むことをします

式の値がゼロ以外の場合、戻り状況は0です。

「数字の可能性がある」文字列の厄介なエラーメッセージを防ぐために、エラー出力を無視します

$ (( 2s ))
bash: ((: 2s: value too great for base (error token is "2s")

古い質問ですが、私は自分の解決策に取り組みたかっただけです。これは奇妙なシェルトリックを必要としないか、永遠に存在しなかった何かに依存します。

if [ -n "$(printf '%s\n' "$var" | sed 's/[0-9]//g')" ]; then
    echo 'is not numeric'
else
    echo 'is numeric'
fi

基本的に、それは入力からすべての数字を削除するだけであり、ゼロ以外の長さの文字列が残っている場合、それは数値ではありませんでした。

まだコメントできないので、独自の回答を追加します。これは、bashパターンマッチングを使用したglenn jackmanの回答の拡張です。

私の本来の必要性は、数値を識別し、整数と浮動小数点数を区別することでした。以下に差し引かれる関数定義：

function isInteger() {
    [[ ${1} == ?(-)+([0-9]) ]]
}

function isFloat() {
    [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]
}

ユニットテスト（shUnit2を使用）を使用して、パターンが意図したとおりに機能することを検証しました。

oneTimeSetUp() {
    int_values="0 123 -0 -123"
    float_values="0.0 0. .0 -0.0 -0. -.0 \
        123.456 123. .456 -123.456 -123. -.456
        123.456E08 123.E08 .456E08 -123.456E08 -123.E08 -.456E08 \
        123.456E+08 123.E+08 .456E+08 -123.456E+08 -123.E+08 -.456E+08 \
        123.456E-08 123.E-08 .456E-08 -123.456E-08 -123.E-08 -.456E-08"
}

testIsIntegerIsFloat() {
    local value
    for value in ${int_values}
    do
        assertTrue "${value} should be tested as integer" "isInteger ${value}"
        assertFalse "${value} should not be tested as float" "isFloat ${value}"
    done

    for value in ${float_values}
    do
        assertTrue "${value} should be tested as float" "isFloat ${value}"
        assertFalse "${value} should not be tested as integer" "isInteger ${value}"
    done

}

注：isFloatパターンは、小数点（@(.,)）およびE記号（@(Ee)）に対してより寛容になるように変更できます。単体テストでは、整数または浮動小数点の値のみをテストし、無効な入力はテストしません。

私はこれを試します：

printf "%g" "$var" &> /dev/null
if [[ $? == 0 ]] ; then
    echo "$var is a number."
else
    echo "$var is not a number."
fi

注：これはnanおよびinfを数値として認識します。

明確な答えは、@ charles Dufyや他の人々によってすでに与えられています。純粋なbashソリューションは以下を使用します：

string="-12,345"
if [[ "$string" =~ ^-?[0-9]+[.,]?[0-9]*$ ]]
then
    echo $string is a number
else
    echo $string is not a number
fi

実数の場合、基数ポイントの前に数値があることは必須ではありません。

浮動小数点数と科学表記法のより完全なサポートを提供するには（C / Fortranの多くのプログラムまたはそうでなければfloatをこのようにエクスポートします）、この行への便利な追加は次のようになります：

string="1.2345E-67"
if [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*[eE]?-?[0-9]+$ ]]
then
    echo $string is a number
else
    echo $string is not a number
fi

したがって、特定のタイプを探している場合は、数値のタイプを区別する方法につながります。

string="-12,345"
if [[ "$string" =~ ^-?[0-9]+$ ]]
then
    echo $string is an integer
elif [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*$ ]]
then
    echo $string is a float
elif [[ "$string" =~ ^-?[0-9]*[.,]?[0-9]*[eE]-?[0-9]+$ ]]
then
    echo $string is a scientific number
else
    echo $string is not a number
fi

注：10進表記および科学表記の構文要件をリストできます。1つは、コンマを基点として使用できること、および「。」を使用できることです。次に、そのような基数ポイントは1つだけでなければならないと断言します。[Ee] floatには2つの+/-記号を含めることができます。Auluの作業からさらにいくつかのルールを学び、 '' '-' '-E-1' '0-0'などの不良ストリングに対してテストしました。以下は、我慢しているように見える私のregex / substring / exprツールです：

parse_num() {
 local r=`expr "$1" : '.*\([.,]\)' 2>/dev/null | tr -d '\n'` 
 nat='^[+-]?[0-9]+[.,]?$' \
 dot="${1%[.,]*}${r}${1##*[.,]}" \
 float='^[\+\-]?([.,0-9]+[Ee]?[-+]?|)[0-9]+$'
 [[ "$1" == $dot ]] && [[ "$1" =~ $float ]] || [[ "$1" =~ $nat ]]
} # usage: parse_num -123.456

[[ $1 =~ ^-?[0-9]+$ ]] && echo "number"

-負の数を含めることを忘れないでください！

これはgrep、問題の変数が拡張正規表現と一致するかどうかを確認するために使用することで実現できます。

テスト整数1120：

yournumber=1120
if echo "$yournumber" | grep -qE '^[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

出力： Valid number.

非整数をテストする1120a：

yournumber=1120a
if echo "$yournumber" | grep -qE '^[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

出力： Error: not a number.

説明

• grep、-Eスイッチは、私たちは拡張正規表現を使用することができます'^[0-9]+$'。この正規表現は、変数には変数の最初から最後まで[]0〜9の数字のみが含まれ、少なくとも1つの文字が含まれている必要があることを意味します。0-9^$+
• grep、-q静かなスイッチは、それが何かを見つけたかどうかを任意の出力がオフになります。
• ifの終了ステータスをチェックしますgrep。終了ステータス0は成功を意味し、それ以上のものはエラーを意味します。grepコマンドはの終了ステータスを持っている0、それが一致するものを見つけた場合と1そうでないとき。

したがって、すべてをまとめて、ifテストではecho、変数$yournumberと|パイプをgrep使用して、-qスイッチを使用して-E拡張された正規表現'^[0-9]+$'式に暗黙的に一致させます。終了ステータスはgrepなります0場合はgrep、正常マッチを発見し、1それがなかった場合。成功した場合、私たちは、一致しますecho "Valid number."。それが一致しなかった場合は、私たちecho "Error: not a number."。

フロートまたはダブルスの場合

私達はちょうどから正規表現を変更することができます'^[0-9]+$'への'^[0-9]*\.?[0-9]+$'山車やダブルスのために。

テストフロート1120.01：

yournumber=1120.01
if echo "$yournumber" | grep -qE '^[0-9]*\.?[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

出力： Valid number.

テストフロート11.20.01：

yournumber=11.20.01
if echo "$yournumber" | grep -qE '^[0-9]*\.?[0-9]+$'; then
    echo "Valid number."
else
    echo "Error: not a number."
fi

出力： Error: not a number.

ネガティブ

負の整数を許可するには、正規表現をから'^[0-9]+$'に変更するだけ'^\-?[0-9]+$'です。

負の浮動小数点数または倍精度浮動小数点数を許可するには、正規表現をから'^[0-9]*\.?[0-9]+$'に変更するだけ'^\-?[0-9]*\.?[0-9]+$'です。

http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_04_03.html

bashの文字クラスを使用することもできます。

if [[ $VAR = *[[:digit:]]* ]]; then
 echo "$VAR is numeric"
else
 echo "$VAR is not numeric"
fi

数値には、スペース、小数点、浮動小数点の「e」または「E」が含まれます。

ただし、Cスタイルの16進数、つまり「0xffff」または「0XFFFF」を指定すると、[[：digit：]]はtrueを返します。ここでちょっとした罠ですが、bashを使用すると、「0xAZ00」のようなことを行っても、それを数字として数えることができます（これは、16以外のベースに0x表記を使用できるようにするGCCコンパイラの奇妙な癖からではありませんか??? ）

16進数を受け入れたくない場合を除いて、入力が完全に信頼できない場合、数値かどうかをテストする前に、「0x」または「0X」をテストすることをお勧めします。それは以下によって達成されます：

if [[ ${VARIABLE:1:2} = "0x" ]] || [[ ${VARIABLE:1:2} = "0X" ]]; then echo "$VAR is not numeric"; fi

最も簡単な方法は、数字以外の文字が含まれているかどうかを確認することです。すべての数字を何も置換せず、長さをチェックします。長さがあれば数字ではありません。

if [[ ! -n ${input//[0-9]/} ]]; then
    echo "Input Is A Number"
fi

私は最近これを改ざんしなければならなかったので、ユニットテストでのkarttuのアプローチが最も好きです。私はコードを修正し、他のいくつかの解決策も追加しました。自分で試して結果を確認してください。

#!/bin/bash

    # N={0,1,2,3,...} by syntaxerror
function isNaturalNumber()
{
 [[ ${1} =~ ^[0-9]+$ ]]
}
    # Z={...,-2,-1,0,1,2,...} by karttu
function isInteger() 
{
 [[ ${1} == ?(-)+([0-9]) ]]
}
    # Q={...,-½,-¼,0.0,¼,½,...} by karttu
function isFloat() 
{
 [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]
}
    # R={...,-1,-½,-¼,0.E+n,¼,½,1,...}
function isNumber()
{
 isNaturalNumber $1 || isInteger $1 || isFloat $1
}

bools=("TRUE" "FALSE")
int_values="0 123 -0 -123"
float_values="0.0 0. .0 -0.0 -0. -.0 \
    123.456 123. .456 -123.456 -123. -.456 \
    123.456E08 123.E08 .456E08 -123.456E08 -123.E08 -.456E08 \
    123.456E+08 123.E+08 .456E+08 -123.456E+08 -123.E+08 -.456E+08 \
    123.456E-08 123.E-08 .456E-08 -123.456E-08 -123.E-08 -.456E-08"
false_values="blah meh mooh blah5 67mooh a123bc"

for value in ${int_values} ${float_values} ${false_values}
do
    printf "  %5s=%-30s" $(isNaturalNumber $value) ${bools[$?]} $(printf "isNaturalNumber(%s)" $value)
    printf "%5s=%-24s" $(isInteger $value) ${bools[$?]} $(printf "isInteger(%s)" $value)
    printf "%5s=%-24s" $(isFloat $value) ${bools[$?]} $(printf "isFloat(%s)" $value)
    printf "%5s=%-24s\n" $(isNumber $value) ${bools[$?]} $(printf "isNumber(%s)" $value)
done

そのため、isNumber（）にはダッシュ、コンマ、指数表記が含まれているため、整数と浮動小数点数ではTRUEを返し、一方でisFloat（）は整数値でFALSEを返し、isInteger（）は同様に浮動小数点数ではFALSEを返します。ワンライナーとしてあなたの便宜のために：

isNaturalNumber() { [[ ${1} =~ ^[0-9]+$ ]]; }
isInteger() { [[ ${1} == ?(-)+([0-9]) ]]; }
isFloat() { [[ ${1} == ?(-)@(+([0-9]).*([0-9])|*([0-9]).+([0-9]))?(E?(-|+)+([0-9])) ]]; }
isNumber() { isNaturalNumber $1 || isInteger $1 || isFloat $1; }

私はexprを使用します。数値以外の値にゼロを追加しようとすると、ゼロ以外の値が返されます。

if expr -- "$number" + 0 > /dev/null 2>&1
then
    echo "$number is a number"
else
    echo "$number isn't a number"
fi

非整数が必要な場合はbcを使用することが可能かもしれませんが、私bcはまったく同じ動作をするとは思いません。非数値にゼロを追加すると、ゼロが取得され、ゼロの値も返されます。たぶん、あなたは組み合わせることができますbcとexpr。bcにゼロを追加するために使用します$number。答えがの場合は0、それがゼロでないexprことを確認してください$number。

アルベルト・ザッカニの答えが好きです。

if [ "$var" -eq "$var" ] 2>/dev/null; then

重要な前提条件：-生成されるサブシェルがない-REパーサーが呼び出されない-ほとんどのシェルアプリケーションは実数を使用しません

しかし、$var複雑な場合（例：連想配列アクセス）、数値が負でない整数（ほとんどのユースケース）になる場合、これはおそらくより効率的ですか？

if [ "$var" -ge 0 ] 2> /dev/null; then ..

形式文字列 "％f"または "％i"を指定した場合、printfがチェックを実行します。チェックを再発明するよりも簡単で、構文は単純で短く、printfは至る所にあります。したがって、私の意見ではそれはまともな選択です。次のアイデアを使用して、さまざまなものをチェックすることもできます。数値をチェックするだけでなく、

declare  -r CHECK_FLOAT="%f"  
declare  -r CHECK_INTEGER="%i"  

 ## <arg 1> Number - Number to check  
 ## <arg 2> String - Number type to check  
 ## <arg 3> String - Error message  
function check_number() { 
  local NUMBER="${1}" 
  local NUMBER_TYPE="${2}" 
  local ERROR_MESG="${3}"
  local -i PASS=1 
  local -i FAIL=0   
  case "${NUMBER_TYPE}" in 
    "${CHECK_FLOAT}") 
        if ((! $(printf "${CHECK_FLOAT}" "${NUMBER}" &>/dev/random;echo $?))); then 
           echo "${PASS}"
        else 
           echo "${ERROR_MESG}" 1>&2
           echo "${FAIL}"
        fi 
        ;;                 
    "${CHECK_INTEGER}") 
        if ((! $(printf "${CHECK_INTEGER}" "${NUMBER}" &>/dev/random;echo $?))); then 
           echo "${PASS}"
        else 
           echo "${ERROR_MESG}" 1>&2
           echo "${FAIL}"
        fi 
        ;;                 
                     *) 
        echo "Invalid number type format: ${NUMBER_TYPE} to check_number()." 1>&2
        echo "${FAIL}"
        ;;                 
   esac
} 

>$ var=45

>$ (($(check_number $var "${CHECK_INTEGER}" "Error: Found $var - An integer is required."))) && { echo "$var+5" | bc; }

バッシュ 正規表現 vsバッシュ パラメータ拡張

チャールズ・ダフィーの答えの仕事が、唯一の使用バッシュ正規表現、これが遅いことがわかっているので、別の方法を使用して、バッシュパラメータ展開：

正の整数のみ：

is_num() { [ "$1" ] && [ -z "${1//[0-9]}" ] ;}

整数の場合：

is_num() { 
    local chk=${1#[+-]};
    [ "$chk" ] && [ -z "${chk//[0-9]}" ]
}

次に、フローティングの場合：

is_num() { 
    local chk=${1#[+-]};
    chk=${chk/.}
    [ "$chk" ] && [ -z "${chk//[0-9]}" ]
}

最初のリクエストに一致させるには：

set -- "foo bar"
is_num "$1" && VAR=$1 || echo "need a number"
need a number

set -- "+3.141592"
is_num "$1" && VAR=$1 || echo "need a number"

echo $VAR
+3.141592

ここで少し比較します。

Charles Duffyの回答に基づく同じチェックがあります：

cdIs_num() { 
    local re='^[+-]?[0-9]+([.][0-9]+)?$';
    [[ $1 =~ $re ]]
}

いくつかのテスト：

if is_num foo;then echo It\'s a number ;else echo Not a number;fi
Not a number
if cdIs_num foo;then echo It\'s a number ;else echo Not a number;fi
Not a number
if is_num 25;then echo It\'s a number ;else echo Not a number;fi
It's a number
if cdIs_num 25;then echo It\'s a number ;else echo Not a number;fi
It's a number
if is_num 3+4;then echo It\'s a number ;else echo Not a number;fi
Not a number
if cdIs_num 3+4;then echo It\'s a number ;else echo Not a number;fi
Not a number
if is_num 3.1415;then echo It\'s a number ;else echo Not a number;fi
It's a number
if cdIs_num 3.1415;then echo It\'s a number ;else echo Not a number;fi
It's a number

OK、それは大丈夫です。これすべてにかかる時間はどれくらいですか（私のラズベリーpiで）：

time for i in {1..1000};do is_num +3.14159265;done
real    0m2.476s
user    0m1.235s
sys     0m0.000s

次に、正規表現で：

time for i in {1..1000};do cdIs_num +3.14159265;done
real    0m4.363s
user    0m2.168s
sys     0m0.000s

負の数をキャッチするには：

if [[ $1 == ?(-)+([0-9.]) ]]
    then
    echo number
else
    echo not a number
fi

「let」も次のように使用できます。

[ ~]$ var=1
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s a number
[ ~]$ var=01
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s a number
[ ~]$ var=toto
[ ~]$ let $var && echo "It's a number" || echo "It's not a number"
It\'s not a number
[ ~]$ 

しかし、私はこのスレッドのいくつかの回答のように、「=〜」Bash 3+演算子を使用することを好みます。

printf '%b' "-123\nABC" | tr '[:space:]' '_' | grep -q '^-\?[[:digit:]]\+$' && echo "Integer." || echo "NOT integer."

-\?負の整数を受け入れない場合は、grep一致パターンを削除します。

ドットで区切られた部分全体と小数部分をテストする正規表現を使用して、同じことをここで行いましたか？

re="^[0-9]*[.]{0,1}[0-9]*$"

if [[ $1 =~ $re ]] 
then
   echo "is numeric"
else
  echo "Naahh, not numeric"
fi

以下を使用します（整数の場合）：

## ##### constants
##
## __TRUE - true (0)
## __FALSE - false (1)
##
typeset -r __TRUE=0
typeset -r __FALSE=1

## --------------------------------------
## isNumber
## check if a value is an integer 
## usage: isNumber testValue 
## returns: ${__TRUE} - testValue is a number else not
##
function isNumber {
  typeset TESTVAR="$(echo "$1" | sed 's/[0-9]*//g' )"
  [ "${TESTVAR}"x = ""x ] && return ${__TRUE} || return ${__FALSE}
}

isNumber $1 
if [ $? -eq ${__TRUE} ] ; then
  print "is a number"
fi

ウルトラソーブレードのレシピを試してみました。私にとっては最も実用的であり、機能させることができなかったためです。最後に、私は別の方法を考案しましたが、他のパラメータ置換に基づいて、今回は正規表現の置換を行いました。

[[ "${var//*([[:digit:]])}" ]]; && echo "$var is not numeric" || echo "$var is numeric"

$ var内のすべての：digit：クラス文字を削除し、空の文字列が残っているかどうかをチェックします。つまり、元の文字列は数字のみだったということです。

これについて私が好きなのは、その小さな設置面積と柔軟性です。この形式では、区切られていない、基数10の整数に対してのみ機能しますが、パターンマッチングを使用して他のニーズに合わせることができます。

Quick＆Dirty：最もエレガントな方法ではないことはわかっていますが、通常はゼロを追加して結果をテストします。そのようです：

function isInteger {
  [ $(($1+0)) != 0 ] && echo "$1 is a number" || echo "$1 is not a number"
 }

x=1;      isInteger $x
x="1";    isInteger $x
x="joe";  isInteger $x
x=0x16 ;  isInteger $x
x=-32674; isInteger $x   

$（（$ 1 + 0））は、$ 1が整数でない場合、0または爆弾を返します。例えば：

function zipIt  { # quick zip - unless the 1st parameter is a number
  ERROR="not a valid number. " 
  if [ $(($1+0)) != 0 ] ; then  # isInteger($1) 
      echo " backing up files changed in the last $1 days."
      OUT="zipIt-$1-day.tgz" 
      find . -mtime -$1 -type f -print0 | xargs -0 tar cvzf $OUT 
      return 1
  fi
    showError $ERROR
}

注：スクリプト全体を爆弾にする浮動小数点数または混合型をチェックすることは考えていなかったと思います...私の場合、それ以上進めたくありませんでした。私は、mrucciのソリューションとDuffyの正規表現で遊んでみます-それらはbashフレームワーク内で最も堅牢に見えます...