Làm cách nào để kiểm tra nếu một biến là một số trong Bash?

Tôi chỉ không thể hiểu làm thế nào để đảm bảo một đối số được truyền cho tập lệnh của tôi có phải là số hay không.

Tất cả những gì tôi muốn làm là một cái gì đó như thế này:

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

Có ai giúp đỡ không?

Một cách tiếp cận là sử dụng một biểu thức chính quy, như vậy:

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

Nếu giá trị không nhất thiết là số nguyên, hãy xem xét sửa đổi biểu thức chính xác; ví dụ:

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

... hoặc, để xử lý các số có dấu:

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

Không có bashism (hoạt động ngay cả trong System V sh),

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

Điều này từ chối các chuỗi rỗng và các chuỗi chứa các chữ số không, chấp nhận mọi thứ khác.

Số âm hoặc dấu phẩy động cần một số công việc bổ sung. Một ý tưởng là loại trừ -/ .trong mẫu "xấu" đầu tiên và thêm các mẫu "xấu" khác chứa các cách sử dụng không phù hợp của chúng ( ?*-*/ *.*.*)

Giải pháp sau đây cũng có thể được sử dụng trong các shell cơ bản như Bourne mà không cần biểu thức chính quy. Về cơ bản, bất kỳ hoạt động đánh giá giá trị số nào sử dụng số không sẽ dẫn đến một lỗi sẽ được coi là sai trong shell:

"$var" -eq "$var"

như trong:

#!/bin/bash

var=a

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

Bạn cũng có thể kiểm tra $? mã trả về của hoạt động rõ ràng hơn:

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

Chuyển hướng lỗi tiêu chuẩn là có để ẩn thông báo "biểu thức số nguyên dự kiến" mà bash in ra trong trường hợp chúng ta không có số.

CAVEATS (nhờ các ý kiến ​​dưới đây):

• Các số có dấu thập phân không được được xác định là "số" hợp lệ
• Sử dụng [[ ]]thay vì [ ]sẽ luôn luôn đánh giátrue
• Hầu hết các shell không Bash sẽ luôn đánh giá biểu thức này là true
• Hành vi trong Bash không có giấy tờ và do đó có thể thay đổi mà không cần cảnh báo
• Nếu giá trị bao gồm khoảng trắng sau số (ví dụ: "1 a") sẽ tạo ra lỗi, như bash: [[: 1 a: syntax error in expression (error token is "a")
• Nếu giá trị giống với tên var (ví dụ i = "i"), sẽ tạo ra lỗi, như bash: [[: i: expression recursion level exceeded (error token is "i")

Điều này kiểm tra nếu một số là một số nguyên không âm và cả hai đều độc lập với vỏ (tức là không có bashism) và chỉ sử dụng các phần tử dựng sẵn:

SAI.

Vì câu trả lời đầu tiên này (bên dưới) cho phép các số nguyên có ký tự trong đó miễn là câu đầu tiên không phải là đầu tiên trong biến.

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

CHÍNH XÁC .

Như jilles đã nhận xét và đề xuất trong câu trả lời của mình, đây là cách chính xác để làm điều đó bằng cách sử dụng các mẫu vỏ.

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

Không ai đề xuất kết hợp mẫu mở rộng của bash :

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

Tôi ngạc nhiên về các giải pháp phân tích trực tiếp các định dạng số trong shell. shell không phù hợp với điều này, là DSL để kiểm soát các tệp và quy trình. Có rất nhiều trình phân tích cú pháp số thấp hơn một chút, ví dụ:

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
}

Thay đổi '% f' thành bất kỳ định dạng cụ thể nào bạn yêu cầu.

Tôi đã xem xét các câu trả lời và ... nhận ra rằng không ai nghĩ về số FLOAT (có dấu chấm)!

Sử dụng grep cũng rất tuyệt.
-E có nghĩa là regex mở rộng
-q có nghĩa là yên tĩnh (không lặp lại)
-qE là sự kết hợp của cả hai.

Để kiểm tra trực tiếp trong dòng lệnh:

$ 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

Sử dụng trong tập lệnh 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

Để khớp với số nguyên JUST, hãy sử dụng số nguyên này:

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

Chỉ cần theo dõi đến @mary. Nhưng vì tôi không có đủ đại diện nên không thể đăng bài này dưới dạng bình luận cho bài đăng đó. Dù sao, đây là những gì tôi đã sử dụng:

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

Hàm sẽ trả về "1" nếu đối số là số, nếu không sẽ trả về "0". Điều này làm việc cho số nguyên cũng như phao. Cách sử dụng là một cái gì đó như:

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]}thay thế bất kỳ chữ số nào trong giá trị của $ibằng một chuỗi rỗng, xem man -P 'less +/parameter\/' bash.-zkiểm tra xem chuỗi kết quả có độ dài bằng không.

nếu bạn cũng muốn loại trừ trường hợp khi $itrống, bạn có thể sử dụng một trong các công trình sau:

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

Đối với vấn đề của tôi, tôi chỉ cần đảm bảo rằng người dùng không vô tình nhập một số văn bản do đó tôi đã cố gắng giữ cho nó đơn giản và dễ đọc

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

Theo trang người đàn ông này khá nhiều làm những gì tôi muốn

Nếu giá trị của biểu thức là khác không, trạng thái trả về là 0

Để ngăn thông báo lỗi khó chịu cho chuỗi "có thể là số" Tôi bỏ qua đầu ra lỗi

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

Câu hỏi cũ, nhưng tôi chỉ muốn giải quyết vấn đề của tôi. Cái này không yêu cầu bất kỳ thủ thuật vỏ lạ nào, hoặc dựa vào thứ gì đó đã tồn tại mãi mãi.

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

Về cơ bản, nó chỉ loại bỏ tất cả các chữ số khỏi đầu vào và nếu bạn để lại một chuỗi có độ dài khác không thì đó không phải là một số.

Chưa thể bình luận vì vậy tôi sẽ thêm câu trả lời của riêng mình, đây là phần mở rộng cho câu trả lời của glenn jackman bằng cách sử dụng khớp mẫu bash.

Nhu cầu ban đầu của tôi là xác định số và phân biệt số nguyên và số float. Các định nghĩa hàm được khấu trừ vào:

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

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

Tôi đã sử dụng thử nghiệm đơn vị (với shUnit2) để xác thực các mẫu của tôi hoạt động như dự định:

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

}

Lưu ý: Mẫu isFloat có thể được sửa đổi để trở nên khoan dung hơn về dấu thập phân ( @(.,)) và ký hiệu E ( @(Ee)). Đơn vị của tôi kiểm tra chỉ kiểm tra các giá trị là số nguyên hoặc số float, nhưng không có bất kỳ đầu vào không hợp lệ nào.

Tôi sẽ thử điều này:

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

Lưu ý: điều này nhận ra nan và inf là số.

Một câu trả lời rõ ràng đã được đưa ra bởi @charles Dufy và những người khác. Một giải pháp bash tinh khiết sẽ được sử dụng như sau:

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

Mặc dù đối với các số thực, không bắt buộc phải có một số trước điểm cơ số .

Để cung cấp hỗ trợ kỹ lưỡng hơn về số nổi và ký hiệu khoa học (nhiều chương trình trong C / Fortran nếu không sẽ xuất theo cách này), một bổ sung hữu ích cho dòng này sẽ là như sau:

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

Do đó, dẫn đến một cách để phân biệt các loại số, nếu bạn đang tìm kiếm bất kỳ loại cụ thể nào:

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

Lưu ý: Chúng tôi có thể liệt kê các yêu cầu cú pháp cho ký hiệu thập phân và khoa học, một là cho phép dấu phẩy dưới dạng điểm cơ số, cũng như ".". Sau đó chúng tôi sẽ khẳng định rằng chỉ có một điểm cơ số như vậy. Có thể có hai dấu +/- trong một float [Ee]. Tôi đã học được thêm một vài quy tắc từ công việc của Aulu và đã thử nghiệm các chuỗi xấu như '' '-' '-E-1' '0-0'. Dưới đây là các công cụ regex / chuỗi con / expr của tôi dường như đang giữ:

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"

Đừng quên -bao gồm các số âm!

Điều này có thể đạt được bằng cách sử dụng grep để xem liệu biến trong câu hỏi có khớp với biểu thức chính quy mở rộng không.

Kiểm tra số nguyên 1120:

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

Đầu ra: Valid number.

Kiểm tra không nguyên 1120a:

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

Đầu ra: Error: not a number.

Giải trình

• Các grep, các -Ecông tắc cho phép chúng ta sử dụng biểu thức chính quy mở rộng '^[0-9]+$'. Biểu thức chính quy này có nghĩa là biến chỉ nên []chứa các số từ 0-90 đến 9 từ ^đầu đến $cuối biến và nên có ít nhất+ một ký tự.
• Các grep, các -qcông tắc yên tĩnh tắt bất kỳ đầu ra hay không mà nó tìm thấy bất cứ điều gì.
• ifkiểm tra trạng thái thoát của grep. Trạng thái thoát 0có nghĩa là thành công và bất cứ điều gì lớn hơn có nghĩa là một lỗi. Các greplệnh có một trạng thái thoát của 0nếu nó tìm thấy một trận đấu và 1khi nó không;

Vì vậy, kết hợp tất cả lại với nhau, trong ifthử nghiệm, chúng tôi echobiến $yournumbervà đưa |nó vào grepcông -qtắc với âm thầm phù hợp với -Ebiểu thức biểu thức chính quy mở rộng '^[0-9]+$'. Trạng thái thoát của grepsẽ là 0nếu greptìm thấy thành công một trận đấu và 1nếu nó không. Nếu thành công để phù hợp, chúng tôi echo "Valid number.". Nếu nó không phù hợp, chúng tôi echo "Error: not a number.".

Đối với phao hoặc đôi

Chúng ta chỉ có thể thay đổi biểu thức thông thường từ '^[0-9]+$'sang '^[0-9]*\.?[0-9]+$'cho phao hoặc đôi.

Kiểm tra phao 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

Đầu ra: Valid number.

Kiểm tra phao 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

Đầu ra: Error: not a number.

Đối với tiêu cực

Để cho phép số nguyên âm, chỉ cần thay đổi biểu thức chính quy từ '^[0-9]+$'thành '^\-?[0-9]+$'.

Để cho phép nổi hoặc tăng gấp đôi âm, chỉ cần thay đổi biểu thức thông thường từ '^[0-9]*\.?[0-9]+$'sang '^\-?[0-9]*\.?[0-9]+$'.

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

Bạn cũng có thể sử dụng các lớp nhân vật của bash.

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

Số sẽ bao gồm không gian, dấu thập phân và "e" hoặc "E" cho dấu phẩy động.

Nhưng, nếu bạn chỉ định số hex kiểu C, tức là "0xffff" hoặc "0XFFFF", [[: chữ số:]] trả về đúng. Một chút bẫy ở đây, bash cho phép bạn thực hiện một cái gì đó như "0xAZ00" và vẫn tính nó là một chữ số (đây không phải là từ một trình biên dịch kỳ lạ của trình biên dịch GCC cho phép bạn sử dụng ký hiệu 0x cho các cơ sở khác ngoài 16 ??? )

Bạn có thể muốn kiểm tra "0x" hoặc "0X" trước khi kiểm tra nếu đó là số nếu đầu vào của bạn hoàn toàn không tin cậy, trừ khi bạn muốn chấp nhận số hex. Điều đó sẽ được thực hiện bằng cách:

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

Cách đơn giản nhất là kiểm tra xem nó có chứa các ký tự không có chữ số không. Bạn thay thế tất cả các ký tự chữ số không có gì và kiểm tra độ dài. Nếu có chiều dài thì đó không phải là một con số.

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

Vì tôi đã phải can thiệp vào điều này gần đây và giống như appoach của karttu với bài kiểm tra đơn vị nhiều nhất. Tôi đã sửa đổi mã và thêm một số giải pháp khác, hãy tự mình thử để xem kết quả:

#!/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

Vì vậy, isNumber () bao gồm dấu gạch ngang, dấu phẩy và ký hiệu số mũ và do đó trả về TRUE trên số nguyên & số float, mặt khác isFloat () trả về FALSE trên các giá trị nguyên và isInteger () cũng trả về FALSE trên số float. Để thuận tiện cho bạn, tất cả như một lớp lót:

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; }

Tôi sử dụng expr . Nó trả về giá trị khác không nếu bạn cố gắng thêm số 0 vào giá trị không phải là số:

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

Có thể sử dụng bc nếu bạn cần số nguyên, nhưng tôi không tin bccó hành vi tương tự. Thêm số 0 vào số không sẽ giúp bạn có số 0 và nó cũng trả về giá trị bằng 0. Có lẽ bạn có thể kết hợp bcvà expr. Sử dụng bcđể thêm số không vào $number. Nếu câu trả lời là 0, sau đó thử exprxác minh đó $numberkhông phải là số không.

Tôi thích câu trả lời của Alberto Zaccagni.

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

Điều kiện tiên quyết quan trọng: - không có các lớp con sinh ra - không có trình phân tích cú pháp RE được gọi - hầu hết các ứng dụng shell không sử dụng số thực

Nhưng nếu $varphức tạp (ví dụ: truy cập mảng kết hợp) và nếu số đó sẽ là số nguyên không âm (hầu hết các trường hợp sử dụng), thì điều này có lẽ hiệu quả hơn?

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

Tôi sử dụng printf như các câu trả lời khác được đề cập, nếu bạn cung cấp chuỗi định dạng "% f" hoặc "% i" printf sẽ thực hiện việc kiểm tra cho bạn. Dễ dàng hơn so với phát minh lại các kiểm tra, cú pháp đơn giản và ngắn gọn và printf có mặt khắp nơi. Vì vậy, theo tôi, đó là một lựa chọn hợp lý - bạn cũng có thể sử dụng ý tưởng sau đây để kiểm tra một loạt các thứ, nó không chỉ hữu ích cho việc kiểm tra số.

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; }

bash biểu hiện thông thường vsbash mở rộng tham số

Như câu trả lời của Charles Duffy công việc, nhưng chỉ sử dụngbashbiểu thức thông thường và tôi biết điều này là chậm, tôi muốn chỉ ra một cách khác, chỉ sử dụngbashmở rộng tham số :

Chỉ dành cho số nguyên dương:

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

Đối với số nguyên:

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

Sau đó cho nổi:

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

Để phù hợp với yêu cầu ban đầu:

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

Bây giờ một chút so sánh:

Có một kiểm tra tương tự dựa trên câu trả lời của Charles Duffy :

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

Một số xét nghiệm:

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

Được rồi, ổn thôi. Bây giờ sẽ mất bao nhiêu thời gian (Trên mâm xôi pi của tôi):

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

Sau đó với các biểu thức chính quy:

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

Để bắt số âm:

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

Bạn có thể sử dụng "let" quá như thế này:

[ ~]$ 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
[ ~]$ 

Nhưng tôi thích sử dụng toán tử "3 ~" Bash 3+ như một số câu trả lời trong chuỗi này.

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

Xóa -\?mẫu phù hợp trong grep nếu bạn không chấp nhận số nguyên âm.

Đã làm điều tương tự ở đây với một biểu thức chính quy kiểm tra toàn bộ phần và phần thập phân, được phân tách bằng dấu chấm.

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

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

Tôi sử dụng như sau (cho số nguyên):

## ##### 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

Tôi đã thử công thức của ultrasawblade vì nó có vẻ thực tế nhất đối với tôi và không thể làm cho nó hoạt động được. Cuối cùng, tôi đã nghĩ ra một cách khác, dựa trên những cách khác để thay thế tham số, lần này với sự thay thế regex:

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

Nó loại bỏ mọi ký tự: chữ số: lớp trong $ var và kiểm tra xem chúng ta có còn một chuỗi trống không, có nghĩa là bản gốc chỉ là số.

Những gì tôi thích về điều này là dấu chân nhỏ và tính linh hoạt của nó. Trong hình thức này, nó chỉ hoạt động cho các số nguyên cơ bản 10 không phân cách, mặc dù chắc chắn bạn có thể sử dụng khớp mẫu để phù hợp với nó cho các nhu cầu khác.

Nhanh & bẩn: Tôi biết đó không phải là cách thanh lịch nhất, nhưng tôi thường chỉ thêm số 0 vào đó và kiểm tra kết quả. như vậy

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)) sẽ trả về 0 hoặc bom nếu $ 1 KHÔNG phải là số nguyên. ví dụ:

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
}

LƯU Ý: Tôi đoán rằng tôi chưa bao giờ nghĩ sẽ kiểm tra các phao hoặc các loại hỗn hợp sẽ làm cho toàn bộ bom script ... trong trường hợp của tôi, tôi không muốn nó đi xa hơn nữa. Tôi sẽ chơi xung quanh với giải pháp của mrucci và regex của Duffy - họ có vẻ mạnh mẽ nhất trong khuôn khổ bash ...