मैं कैसे अस्थायी बिंदु विभाजन का उपयोग कर सकता हूं?

Question

मैं एक बैश स्क्रिप्ट में दो छवि चौड़ाई विभाजित करने का प्रयास कर रहा हूं, लेकिन बैश मुझे 0परिणाम के रूप में देता है :

RESULT=$(($IMG_WIDTH/$IMG2_WIDTH))

मैंने बैश गाइड का अध्ययन किया और मुझे पता है कि मुझे bcइंटरनेट का उपयोग करना चाहिए bc। में echoमैंने अपने अंदर वही चीज डालने की कोशिश कीSCALE यह काम नहीं किया लेकिन।

यहाँ मैं ट्यूटोरियल में पाया उदाहरण है:

echo "scale=2; ${userinput}" | bc 

मैं मुझे एक फ्लोट की तरह देने के लिए बैश कैसे प्राप्त कर सकता हूं 0.5?

Comments

अपनी स्क्रिप्ट में फ़्लोटिंग पॉइंट अंकगणित करने की कोशिश करने वाले हर व्यक्ति के लिए एक टिप्पणी, खुद से पूछें: क्या मुझे फ़्लोटिंग पॉइंट अंकगणित की ज़रूरत है? कभी-कभी आप वास्तव में बिना मिल सकते हैं। उदाहरण के लिए, BashFAQ / 022 के अंतिम भाग को देखें ।

— गनीउरफ_गनीउरफ

अस्थायी बिंदु परिणामों के साथ बैश जैसे पूर्णांक विभाजन सिखाना संभव है।

— सायरस

Answer 1

आप नहीं कर सकते। बैश केवल पूर्णांक करता है; आप इस तरह के रूप में एक उपकरण के लिए प्रतिनिधि होना चाहिएbc ।

Comments

मैं परिणाम को चर में डालने के लिए bc जैसे उपकरण को कैसे सौंप सकता हूं?

— मेद्या घ

तो आपका मतलब है VAR = $ (गूंज "स्केल = 2; $ (($ IMG_WIDTH / $ IMG2_WIDTH))" | bc)?

— मेड्या घ

@ शेविन VAR=$(echo "scale=2; $IMG_WIDTH/$IMG2_WIDTH" | bc)या VAR=$(bc <<<"scale=2;$IMG_WIDTH/$IMG2_WIDTH")बिना $ (()) (डबल कोष्ठक); जिसे कमांड निष्पादित करने से पहले बैश द्वारा विस्तारित किया जाता है

— नाहुएल फौइलुल

सच है, लेकिन awk आमतौर पर सिस्टम में पहले से स्थापित होने की अधिक संभावना है।

— CMCDragonkai

@NahuelFouilleul आपके पास यहाँ सबसे अच्छा उत्तर है। वास्तव में इसका स्वयं का उत्तर होना चाहिए, और उत्तर के रूप में स्वीकार किया जाना चाहिए। यह विशेष पंक्ति अविश्वसनीय रूप से उपयोगी थी: VAR = $ (bc <<< "स्केल = 2; $ IMG_WIDTH / $ IMG2_WIDTH")

— डेविड

Answer 2

तुम यह केर सकते हो:

bc <<< 'scale=2; 100/3'
33.33

अद्यतन 20130926 : आप उपयोग कर सकते हैं:

bc -l <<< '100/3' # saves a few hits

Comments

... और कई अंक जोड़ता है। कम से कम मेरी मशीन पर यह yiels 33.33333333333333333333 जबकि पूर्व में 33.33 देता है।

— एंड्रियास स्पिंडलर

@AndreasSpindler एक पुरानी पोस्ट की तरह, लेकिन अगर कोई जानना चाहता है, तो इसे स्केल कमांड जैसे जैसे लागू करके बदला जा सकता है। bc -l <<< 'scale=2; 100/3'

— मार्टी

यदि आप स्केल = 0 का उपयोग करके बैश में बाद में उपयोग के लिए पूर्णांक प्राप्त करने की उम्मीद कर रहे हैं, तो देखें। V1.06.95 के अनुसार, बीसी, किसी कारण से, स्केल चर को अनदेखा करता है जब इनपुट संख्याओं में दशमलव भाग होता है। हो सकता है कि यह डॉक्स में हो, लेकिन मुझे यह नहीं मिला। कोशिश करें: गूंज $ (bc -l <<< 'स्केल = 0; 1 * 3.3333')

— ग्रेग बेल

@GregBell मैन पेज कहता है Unless specifically mentioned the scale of the result is the maximum scale of the expressions involved.और /ऑपरेटर के लिए एक अतिरिक्त नोट है :The scale of the result is the value of the variable scale.

— भजन

धन्यवाद @psmith दिलचस्प है, के लिए / यह कहता है "परिणाम का पैमाना चर पैमाने का मूल्य है" लेकिन गुणन के लिए ऐसा नहीं है। मेरे बेहतर उदाहरण: bc <<< 'scale=1; 1*3.00001' स्केल वास्तव में किसी कारण से 5 है, bc <<< 'scale=1; 1/3.000001' स्केल 1 है। दिलचस्प बात यह है कि 1 से विभाजित करके यह सीधा होता है: bc <<< 'scale=1; 1*3.00001/1'स्केल 1 है

— ग्रेग बेल

Answer 3

दे घुमा के

जैसा कि दूसरों ने नोट किया है, bashफ़्लोटिंग पॉइंट अंकगणित का समर्थन नहीं करता है, हालांकि आप इसे कुछ निश्चित दशमलव चाल के साथ नकली कर सकते हैं, जैसे दो दशमलव के साथ:

echo $(( 100 * 1 / 3 )) | sed 's/..$/.&/'

आउटपुट:

.33

एक समान लेकिन अधिक संक्षिप्त दृष्टिकोण के लिए निलफ्रेड का उत्तर देखें ।

वैकल्पिक

उल्लिखित bcऔर awkविकल्पों के अलावा निम्नलिखित भी हैं:

clisp

clisp -x '(/ 1.0 3)'

साफ उत्पादन के साथ:

clisp --quiet -x '(/ 1.0 3)'

या स्टड के माध्यम से:

echo '(/ 1.0 3)' | clisp --quiet | tail -n1

डीसी

echo 2k 1 3 /p | dc

प्रतिभाशाली क्ली कैलकुलेटर

echo 1/3.0 | genius

Ghostscript

echo 1 3 div = | gs -dNODISPLAY -dQUIET | sed -n '1s/.*>//p' 

gnuplot

echo 'pr 1/3.' | gnuplot

JQ

echo 1/3 | jq -nf /dev/stdin

या:

jq -n 1/3

क्ष

echo 'print $(( 1/3. ))' | ksh

lua

lua -e 'print(1/3)'

या स्टड के माध्यम से:

echo 'print(1/3)' | lua

मॅक्सिमा

echo '1/3,numer;' | maxima

साफ उत्पादन के साथ:

echo '1/3,numer;' | maxima --quiet | sed -En '2s/[^ ]+ [^ ]+ +//p'

नोड

echo 1/3 | node -p

सप्टक

echo 1/3 | octave

पर्ल

echo print 1/3 | perl

को Python2

echo print 1/3. | python2

python3

echo 'print(1/3)' | python3

आर

echo 1/3 | R --no-save

साफ उत्पादन के साथ:

echo 1/3 | R --vanilla --quiet | sed -n '2s/.* //p'

माणिक

echo print 1/3.0 | ruby

wcalc

echo 1/3 | wcalc

साफ उत्पादन के साथ:

echo 1/3 | wcalc | tr -d ' ' | cut -d= -f2

zsh

echo 'print $(( 1/3. ))' | zsh

इकाइयों

units 1/3

कॉम्पैक्ट आउटपुट के साथ:

units --co 1/3

अन्य स्रोत

स्टीफन चेज़लस ने Unix.SX पर इसी तरह के सवाल का जवाब दिया।

Comments

बहुत बढ़िया जवाब। मुझे पता है कि यह प्रश्न के कुछ साल बाद पोस्ट किया गया था लेकिन स्वीकृत उत्तर होने के योग्य है।

— ब्रायन क्लाइन

यदि आपके पास zsh उपलब्ध है, तो यह Bash के बजाय zsh में अपनी स्क्रिप्ट लिखने पर विचार करने लायक है

— Andrea Corbellini

— Gnuplot के

अच्छी सूची है। विशेष रूप echo 1/3 | node -pसे कम है।

— जॉनी वोंग

Answer 4

मारविन के उत्तर को थोड़ा सुधारना:

RESULT=$(awk "BEGIN {printf \"%.2f\",${IMG_WIDTH}/${IMG2_WIDTH}}")

bc हमेशा स्थापित पैकेज के रूप में नहीं आता है।

Comments

Awk script exitको अपने इनपुट स्ट्रीम से पढ़ने से रोकने के लिए इसकी आवश्यकता है। मैं -vटूथपिक सिंड्रोम को रोकने के लिए awk के झंडे का उपयोग करने का भी सुझाव देता हूं । तो:RESULT=$(awk -v dividend="${IMG_WIDTH}" -v divisor="${IMG2_WIDTH}" 'BEGIN {printf "%.2f", dividend/divisor; exit(0)}')

— किस्सा

ऐसा करने का एक और अजीब तरीका इनपुट स्ट्रीम से तर्क पढ़ना होगा RESULT=$(awk '{printf("result= %.2f\n",$1/$2)}' <<<" $IMG_WIDTH $IMG2_WIDTH ":।

— jmster जू

bcPOSIX का हिस्सा है, यह आमतौर पर पूर्वस्थापित है।

— फ़ूज

यह मेरे लिए विंडोज 7 में git bash का उपयोग करके काम करता है ... धन्यवाद :)

— द बीस्ट

Answer 5

आप -lविकल्प (L अक्षर) द्वारा bc का उपयोग कर सकते हैं

RESULT=$(echo "$IMG_WIDTH/$IMG2_WIDTH" | bc -l)

Comments

अगर मैं -lअपने सिस्टम में शामिल नहीं करता हूं, तो बीसी फ्लोटिंग पॉइंट गणित नहीं करता है।

— Starbeamrainbowlabs

Answer 6

बीसी के विकल्प के रूप में, आप अपनी स्क्रिप्ट के भीतर awk का उपयोग कर सकते हैं।

उदाहरण के लिए:

echo "$IMG_WIDTH $IMG2_WIDTH" | awk '{printf "%.2f \n", $1/$2}'

उपरोक्त में, "% .2f" दशमलव स्थान के बाद दो अंकों के साथ एक फ्लोटिंग पॉइंट नंबर वापस करने के लिए प्रिंटफ फ़ंक्शन को बताता है। मैं चर का उपयोग करने के लिए प्रतिध्वनियों का उपयोग करता था क्योंकि खेत उन पर ठीक से संचालित होते हैं। "$ 1" और "$ 2" पहले और दूसरे फ़ील्ड इनपुट को awk में संदर्भित करते हैं।

और आप कुछ अन्य चर का उपयोग करके परिणाम को स्टोर कर सकते हैं:

RESULT = `echo ...`

Comments

अति उत्कृष्ट! धन्यवाद। यह एम्बेडेड वातावरण के लिए सहायक है जहाँ bc मौजूद नहीं है। आपने मुझे कुछ क्रास संकलन समय बचा लिया।

— उत्साही 16

Answer 7

फ्लोटिंग पॉइंट मैथ सहित कई अतिरिक्त अच्छे फीचर्स के साथ zsh, a (लगभग) बैश सुपरसेट की कोशिश करने का यह सही समय है। यहाँ आपका उदाहरण zsh में क्या होगा:

% IMG_WIDTH=1080
% IMG2_WIDTH=640
% result=$((IMG_WIDTH*1.0/IMG2_WIDTH))
% echo $result
1.6875

यह पोस्ट आपकी मदद कर सकती है: बैश - आकस्मिक उपयोग के लिए zsh पर स्विच करना?

Comments

मैं zsh का बहुत बड़ा प्रशंसक हूं और पिछले 4 वर्षों से इसका उपयोग कर रहा हूं, लेकिन इंटरैक्टिव उपयोग यहां अच्छा है। एक स्क्रिप्ट जिसे zsh की आवश्यकता होती है, आमतौर पर मशीनों के एक विविध सेट में बहुत पोर्टेबल होने वाली नहीं है क्योंकि यह आमतौर पर मानक नहीं है, दुख की बात है (शायद निष्पक्ष होना, शायद ठीक है; ओपी ने यह नहीं कहा कि यह कैसे उपयोग किया जाएगा)।

— ब्रायन क्लाइन

Answer 8

ठीक है, फ्लोट से पहले एक समय था जहां निश्चित दशमलव तर्क का उपयोग किया गया था:

IMG_WIDTH=100
IMG2_WIDTH=3
RESULT=$((${IMG_WIDTH}00/$IMG2_WIDTH))
echo "${RESULT:0:-2}.${RESULT: -2}"
33.33

अंतिम पंक्ति एक बशीम है, यदि बैश का उपयोग नहीं किया जाता है, तो इस कोड को इसके बजाय आज़माएं:

IMG_WIDTH=100
IMG2_WIDTH=3
INTEGER=$(($IMG_WIDTH/$IMG2_WIDTH))
DECIMAL=$(tail -c 3 <<< $((${IMG_WIDTH}00/$IMG2_WIDTH)))
RESULT=$INTEGER.$DECIMAL
echo $RESULT
33.33

कोड के पीछे तर्क है: 2 दशमलव प्राप्त करने के लिए विभाजन से पहले 100 से गुणा करें।

Answer 9

यदि आपको अपनी पसंद का वैरिएंट मिला है तो आप इसे फंक्शन में भी लपेट सकते हैं।

यहाँ मैं कुछ bashism को div फंक्शन में लपेट रहा हूँ:

एक लाइन:

function div { local _d=${3:-2}; local _n=0000000000; _n=${_n:0:$_d}; local _r=$(($1$_n/$2)); _r=${_r:0:-$_d}.${_r: -$_d}; echo $_r;}

या मल्टी लाइन:

function div {
  local _d=${3:-2}
  local _n=0000000000
  _n=${_n:0:$_d}
  local _r=$(($1$_n/$2))
  _r=${_r:0:-$_d}.${_r: -$_d}
  echo $_r
}

अब आपके पास फंक्शन है

div <dividend> <divisor> [<precision=2>]

और इसका उपयोग करें

> div 1 2
.50

> div 273 123 5
2.21951

> x=$(div 22 7)
> echo $x
3.14

अपडेट करें मैंने एक छोटी स्क्रिप्ट जोड़ी है जो आपको बैश के लिए फ्लोटिंग पॉइंट नंबरों के साथ मूल संचालन प्रदान करती है:

उपयोग:

> add 1.2 3.45
4.65
> sub 1000 .007
999.993
> mul 1.1 7.07
7.7770
> div 10 3
3.
> div 10 3.000
3.333

और यहाँ स्क्रिप्ट:

#!/bin/bash
__op() {
        local z=00000000000000000000000000000000
        local a1=${1%.*}
        local x1=${1//./}
        local n1=$((${#x1}-${#a1}))
        local a2=${2%.*}
        local x2=${2//./}
        local n2=$((${#x2}-${#a2}))
        local n=$n1
        if (($n1 < $n2)); then
                local n=$n2
                x1=$x1${z:0:$(($n2-$n1))}
        fi
        if (($n1 > $n2)); then
                x2=$x2${z:0:$(($n1-$n2))}
        fi
        if [ "$3" == "/" ]; then
                x1=$x1${z:0:$n}
        fi
        local r=$(($x1"$3"$x2))
        local l=$((${#r}-$n))
        if [ "$3" == "*" ]; then
                l=$(($l-$n))
        fi
        echo ${r:0:$l}.${r:$l}
}
add() { __op $1 $2 + ;}
sub() { __op $1 $2 - ;}
mul() { __op $1 $2 "*" ;}
div() { __op $1 $2 / ;}

Comments

local _d=${3:-2}सरल है

— KamilCuk

Answer 10

यह वास्तव में फ्लोटिंग पॉइंट नहीं है, लेकिन यदि आप कुछ ऐसा चाहते हैं जो एक बार के एक से अधिक परिणाम सेट करे तो bc ...

source /dev/stdin <<<$(bc <<< '
d='$1'*3.1415926535897932384626433832795*2
print "d=",d,"\n"
a='$1'*'$1'*3.1415926535897932384626433832795
print "a=",a,"\n"
')

echo bc radius:$1 area:$a diameter:$d

एक वृत्त के क्षेत्रफल और व्यास की गणना करता है जिसका त्रिज्या $ 1 में दिया गया है

Answer 11

विच में ऐसे परिदृश्य हैं जिनका आप उपयोग नहीं कर सकते हैं क्योंकि यह बस मौजूद नहीं हो सकता है, जैसे कि व्यस्त बॉक्स या एम्बेडेड सिस्टम के कुछ कट डाउन संस्करण। किसी भी मामले में बाहरी निर्भरता को सीमित करना हमेशा एक अच्छी बात होती है, इसलिए आप हमेशा शून्य (संख्या) से विभाजित होने वाली संख्या में शून्य जोड़ सकते हैं, यह 10 की शक्ति से गुणा करने के समान है (आपको 10 के अनुसार एक शक्ति का चयन करना चाहिए आपके लिए आवश्यक सटीकता), जो डिवीजन आउटपुट को पूर्णांक संख्या बना देगा। एक बार जब आप उस पूर्णांक को एक स्ट्रिंग के रूप में मानते हैं और दशमलव बिंदु (इसे दाएं से बाएं की ओर ले जाते हैं) तो दस की शक्ति के बराबर कई बार आप अंश को गुणा करते हैं। यह केवल पूर्णांक संख्याओं का उपयोग करके फ्लोट परिणाम प्राप्त करने का एक सरल तरीका है।

Comments

यहां तक ​​कि बिजीबॉक्स में भी Awk है। शायद यहाँ एक और अधिक प्रमुख Awk उत्तर होना चाहिए।

— 5

Answer 12

हालांकि आप Bash में फ़्लोटिंग पॉइंट डिवीज़न का उपयोग नहीं कर सकते हैं, आप निश्चित पॉइंट डिवीज़न का उपयोग कर सकते हैं। आपको बस इतना करना है कि अपने पूर्णांक को 10 की शक्ति से गुणा करें और फिर पूर्णांक भाग को विभाजित करें और आंशिक भाग प्राप्त करने के लिए एक मोडुलो ऑपरेशन का उपयोग करें। आवश्यकतानुसार चक्कर लगाना।

#!/bin/bash

n=$1
d=$2

# because of rounding this should be 10^{i+1}
# where i is the number of decimal digits wanted
i=4
P=$((10**(i+1)))
Pn=$(($P / 10))
# here we 'fix' the decimal place, divide and round tward zero
t=$(($n * $P / $d + ($n < 0 ? -5 : 5)))
# then we print the number by dividing off the interger part and
# using the modulo operator (after removing the rounding digit) to get the factional part.
printf "%d.%0${i}d\n" $(($t / $P)) $(((t < 0 ? -t : t) / 10 % $Pn))

Answer 13

मुझे पता है कि यह पुराना है, लेकिन बहुत आकर्षक है। तो, जवाब है: आप नहीं कर सकते हैं ... लेकिन आप कर सकते हैं। चलो यह करके देखें:

$IMG_WIDTH=1024
$IMG2_WIDTH=2048

$RATIO="$(( IMG_WIDTH / $IMG2_WIDTH )).$(( (IMG_WIDTH * 100 / IMG2_WIDTH) % 100 ))

इस तरह कि आप बिंदु के बाद 2 अंक प्राप्त करते हैं, शुद्ध बश में (इसे निचले, हाहा को गोलाई कहते हैं) (अन्य प्रक्रियाओं को लॉन्च करने की कोई आवश्यकता नहीं है)। बेशक, अगर आपको केवल एक अंक की आवश्यकता है, तो आप जिस बिंदु को 10 से गुणा करते हैं और 10 modulo करते हैं।

यह क्या करता है:

• पहले $ ((...)) पूर्णांक विभाजन करता है;
• दूसरा $ ((...)) पूर्णतया विभाजन को 100 गुना बड़ा करता है, अनिवार्य रूप से आपके 2 अंकों को बिंदु के बाईं ओर ले जाता है, फिर (%) आपको modulo करके केवल उन 2 अंकों को प्राप्त करता है।

बोनस ट्रैक : bc संस्करण x 1000 ने मेरे लैपटॉप पर 1,8 सेकंड का समय लिया, जबकि शुद्ध बैश वाले ने 0,016 सेकंड का समय लिया।

Answer 14

बैश में फ्लोटिंग पॉइंट कैलकुलेशन कैसे करें:

कमांड के साथ " यहाँ स्ट्रिंग्स " ( <<<) का उपयोग करने के बजाय bc, जैसे कि एक सबसे ऊपर वाला उदाहरण है, यहाँ मेरा पसंदीदा bcफ़्लोटिंग पॉइंट उदाहरण है, सही सेEXAMPLESbc मैन पेजों अनुभाग से ( man bcमैनुअल पेजों के लिए देखें )।

शुरू करने से पहले, हम जानते हैं कि पीआई के लिए एक समीकरण है pi = 4*atan(1):। a()नीचे के लिए bcगणित समारोह है atan()।

1. यह एक अस्थायी बिंदु गणना के परिणाम को बैश चर में संग्रहीत करने के लिए है - इस मामले में एक चर कहा जाता हैpi । ध्यान दें कि scale=10इस मामले में परिशुद्धता के दशमलव अंकों की संख्या 10 है। इस स्थान के बाद किसी भी दशमलव अंक को काट दिया जाता है ।

   pi=$(echo "scale=10; 4*a(1)" | bc -l)

2. अब, कोड की एक एकल पंक्ति है जो इस चर के मान को प्रिंट करती है, केवल echoकमांड को फॉलो-अप कमांड के रूप में अंत में जोड़ देती है , निम्नानुसार। आदेश के अनुसार 10 दशमलव स्थानों पर छंटनी पर ध्यान दें :

   pi=$(echo "scale=10; 4*a(1)" | bc -l); echo $pi
   3.1415926532

3. अंत में, चलो कुछ गोलाई में फेंक दें। यहां हम printfफ़ंक्शन को 4 दशमलव स्थानों पर गोल करने के लिए उपयोग करेंगे । ध्यान दें कि 3.14159...अब दौर है 3.1416। चूंकि हम चक्कर लगा रहे हैं, हमें अब scale=1010 दशमलव स्थानों को छोटा करने के लिए उपयोग करने की आवश्यकता नहीं है , इसलिए हम केवल उस हिस्से को हटा देंगे। यहाँ अंत समाधान है:

   pi=$(printf %.4f $(echo "4*a(1)" | bc -l)); echo $pi
   3.1416

उपरोक्त तकनीकों का एक और वास्तव में शानदार अनुप्रयोग और डेमो है: रन-टाइम को मापना और प्रिंट करना।

ध्यान दें कि dt_minसे गोल हो जाता है 0.01666666666...करने के लिए 0.017:

start=$SECONDS; sleep 1; end=$SECONDS; dt_sec=$(( end - start )); dt_min=$(printf %.3f $(echo "$dt_sec/60" | bc -l)); echo "dt_sec = $dt_sec; dt_min = $dt_min"
dt_sec = 1; dt_min = 0.017

सम्बंधित:

• /unix/52313/how-to-get-execution-time-of-a-script-effectively/547849#547849
• तीन बाएं कोण कोष्ठक (`<<<`) का अर्थ क्या है?
• /unix/80362/what-does-mean/80368#80368
• /ubuntu/179898/how-to-round-decimals-using-bc-in-bash/574474#574474

Comments

विस्तृत उदाहरण और उपयोग करता है मामलों और दौर का उपयोग कर printf के साथ ठोस जवाब

— downvoteit

Answer 15

कैल्क का प्रयोग करें। यह सबसे आसान उदाहरण मुझे मिला:

कैल्क 1 + 1

 2

कैल्क 1/10

 0.1

Answer 16

स्वीकृत उत्तर के साथ प्रतिशत की गणना करने की कोशिश करने वालों के लिए, लेकिन सटीक हार रहे हैं:

यदि आप इसे चलाते हैं:

echo "scale=2; (100/180) * 180" | bc

आप 99.00केवल प्राप्त करते हैं, जो सटीक खो रहा है।

यदि आप इसे इस तरह से चलाते हैं:

echo "result = (100/180) * 180; scale=2; result / 1" | bc -l

अब आप प्राप्त करें 99.99 ।

क्योंकि आप केवल मुद्रण के क्षण में स्केलिंग कर रहे हैं।

यहां देखें

Answer 17

** बैश / शेल में इंजेक्शन-सुरक्षित फ्लोटिंग पॉइंट गणित **

नोट: इस उत्तर का ध्यान बैश (या अन्य गोले) में गणित प्रदर्शन करने के लिए इंजेक्शन-सुरक्षित समाधान के लिए विचार प्रदान करता है।बेशक, एक ही उपयोग किया जा सकता है, उन्नत स्ट्रिंग प्रसंस्करण आदि करने के लिए मामूली समायोजन के साथ।

अधिकांश समाधान जो प्रस्तुत किए गए थे, बाहरी डेटा (चर, फाइलें, कमांड लाइन, पर्यावरण चर) का उपयोग करके मक्खी पर छोटे स्क्रिप्टलेट का निर्माण करते हैं। बाहरी इनपुट का उपयोग इंजन में दुर्भावनापूर्ण कोड को इंजेक्ट करने के लिए किया जा सकता है, उनमें से कई

नीचे मूल गणित गणना करने के लिए विभिन्न भाषा का उपयोग करने पर एक तुलना है, जहां फ्लोटिंग पॉइंट में परिणाम है। यह A + B * 0.1 (फ्लोटिंग पॉइंट के रूप में) की गणना करता है।

सभी समाधान प्रयास गतिशील स्क्रिप्टलेट बनाने से बचते हैं, जिन्हें बनाए रखना बेहद कठिन होता है, इसके बजाय वे स्थैतिक कार्यक्रम का उपयोग करते हैं, और नामित चर में पैरामीटर पास करते हैं। वे विशेष वर्णों के साथ मापदंडों को सुरक्षित रूप से संभाल लेंगे - कोड इंजेक्शन की संभावना को कम करना। अपवाद 'बीसी' है जो इनपुट / आउटपुट सुविधा प्रदान नहीं करता है

अपवाद 'bc' है, जो कोई इनपुट / आउटपुट प्रदान नहीं करता है, सारा डेटा स्टडिन में प्रोग्राम के माध्यम से आता है, और सभी आउटपुट stdout में जाता है। सभी गणना सैंडबॉक्स में निष्पादित हो रही है, जो साइड इफेक्ट (फ़ाइलों को खोलने, आदि) की अनुमति नहीं देता है। सिद्धांत रूप में, डिजाइन द्वारा सुरक्षित इंजेक्शन!

A=5.2
B=4.3

# Awk: Map variable into awk
# Exit 0 (or just exit) for success, non-zero for error.
#
awk -v A="$A" -v B="$B" 'BEGIN { print A + B * 0.1 ; exit 0}'

# Perl
perl -e '($A,$B) = @ARGV ; print $A + $B * 0.1' "$A" "$B"

# Python 2
python -c 'import sys ; a = float(sys.argv[1]) ; b = float(sys.argv[2]) ; print a+b*0.1' "$A" "$B"

# Python 3
python3 -c 'import sys ; a = float(sys.argv[1]) ; b = float(sys.argv[2]) ; print(a+b*0.1)' "$A" "$B"

# BC
bc <<< "scale=1 ; $A + $B * 0.1"

Comments

मनमानी तर्कों के साथ python3 के लिए: python3 -c 'import sys ; *a, = map(float, sys.argv[1:]) ; print(a[0] + a[1]*0.1 + a[2])' "$A" "$B""4200.0" ==> 4205.63

— वायरिंगहर्नेस

Answer 18

यहाँ awk कमांड है: -F = फ़ील्ड विभाजक == +

echo "2.1+3.1" |  awk -F "+" '{print ($1+$2)}'