Julia Language
सशर्त,

वाक्य - विन्यास

• अगर कंडोम; तन; समाप्त
• अगर कंडोम; तन; अन्य; तन; समाप्त
• अगर कंडोम; तन; अन्योक्ति कंडस; तन; अन्य; समाप्त
• अगर कंडोम; तन; अन्योक्ति कंडस; तन; समाप्त
• कंडोम? iftrue: iffalse
• cond && iftrue
• कंडोम || iffalse
• ifelse (cond, iftrue, iffalse)

टिप्पणियों

अगर ... और अभिव्यक्ति

जूलिया में सबसे आम सशर्त है if ... else अभिव्यक्ति। उदाहरण के लिए, नीचे हम आधार मामले को संभालने के लिए एक सशर्त का उपयोग करके, सबसे बड़े सामान्य भाजक की गणना के लिए यूक्लिडियन एल्गोरिथ्म को लागू करते हैं:

mygcd(a, b) = if a == 0
    abs(b)
else
    mygcd(b % a, a)
end

if ... जूलिया में else रूप वास्तव में एक अभिव्यक्ति है, और इसका एक मूल्य है; मूल्य उस स्थिति में पूंछ की स्थिति में अभिव्यक्ति (यानी, अंतिम अभिव्यक्ति) है जो लिया जाता है। निम्नलिखित नमूना इनपुट पर विचार करें:

julia> mygcd(0, -10)
10

यहां, a 0 और b -10 । स्थिति a == 0 true , इसलिए पहली शाखा ली जाती है। लौटाया गया मान abs(b) जो 10 ।

julia> mygcd(2, 3)
1

यहाँ, a 2 और b 3 । स्थिति a == 0 गलत है, इसलिए दूसरी शाखा ली गई है, और हम mygcd(b % a, a) गणना mygcd(b % a, a) , जो mygcd(3 % 2, 2) । % ऑपरेटर शेष जब देता है 3 से विभाजित है 2 इस मामले में, 1 । इस प्रकार हम mygcd(1, 2) गणना mygcd(1, 2) , और इस बार a 1 और b 2 । एक बार फिर, a == 0 गलत है, इसलिए दूसरी शाखा ली गई है, और हम mygcd(b % a, a) , जो कि mygcd(0, 1) गणना mygcd(b % a, a) । इस बार, अंतिम पर a == 0 और इतना abs(b) वापस आ गया है, जो परिणाम 1 देता है।

अगर ... और बयान

name = readline()
if startswith(name, "A")
    println("Your name begins with A.")
else
    println("Your name does not begin with A.")
end

किसी भी अभिव्यक्ति, जैसे if ... else अभिव्यक्ति, को बयान की स्थिति में रखा जा सकता है। यह इसके मूल्य की अनदेखी करता है लेकिन फिर भी इसके दुष्प्रभावों के लिए अभिव्यक्ति को निष्पादित करता है।

अगर बयान

किसी अन्य अभिव्यक्ति की तरह, एक की वापसी मान if ... else अभिव्यक्ति पर ध्यान नहीं दिया जा सकता है (और इसलिए खारिज कर दिया)। यह आम तौर पर केवल तब उपयोगी होता है जब अभिव्यक्ति के शरीर पर दुष्प्रभाव होते हैं, जैसे किसी फ़ाइल पर लिखना, परिवर्तनशील चर, या स्क्रीन पर मुद्रण करना।

इसके अलावा, if की एक else शाखा ... else अभिव्यक्ति वैकल्पिक है। उदाहरण के लिए, हम आउटपुट के लिए निम्न कोड को स्क्रीन पर तभी लिख सकते हैं जब कोई विशेष शर्त पूरी हो।

second = Dates.second(now())
if iseven(second)
    println("The current second, $second, is even.")
end

ऊपर के उदाहरण में, हम वर्तमान दूसरे को प्राप्त करने के लिए समय और दिनांक कार्यों का उपयोग करते हैं; उदाहरण के लिए, यदि यह वर्तमान में 10:55:27 है, तो चर second 27 होगा। यदि यह संख्या सम है, तो स्क्रीन पर एक लाइन प्रिंट की जाएगी। अन्यथा, कुछ भी नहीं किया जाएगा।

टर्नरी सशर्त संचालक

pushunique!(A, x) = x in A ? A : push!(A, x)

टर्नरी सशर्त ऑपरेटर कम चिंताजनक है if ... else अभिव्यक्ति हो।

वाक्य रचना विशेष रूप से है:

[condition] ? [execute if true] : [execute if false]

इस उदाहरण में, हम x को संग्रह A जोड़ते हैं यदि x पहले से ही A में नहीं है। अन्यथा, हम सिर्फ A अपरिवर्तित छोड़ देते हैं।

टर्नरी ऑपरेटर संदर्भ:

• जूलिया प्रलेखन
• विकिबुक्स

शॉर्ट-सर्किट ऑपरेटर: && और ||

ब्रांचिंग के लिए

शॉर्ट-सर्कुलेटिंग सशर्त ऑपरेटर && और || निम्नलिखित निर्माणों के लिए हल्के प्रतिस्थापन के रूप में इस्तेमाल किया जा सकता है:

• x && y , x ? y : x बराबर है x ? y : x
• x || y , x ? x : y बराबर है x ? x : y

शॉर्ट-सर्किट ऑपरेटरों के लिए एक उपयोग किसी शर्त का परीक्षण करने और उस स्थिति के आधार पर एक निश्चित कार्रवाई करने के लिए एक अधिक संक्षिप्त तरीका है। उदाहरण के लिए, निम्न कोड तर्क को नकारात्मक && लिए && ऑपरेटर का उपयोग करता है यदि तर्क x नकारात्मक है:

function mysqrt(x)
    x < 0 && throw(DomainError("x is negative"))
    x ^ 0.5
end

|| ऑपरेटर का उपयोग त्रुटि जाँच के लिए भी किया जा सकता है, सिवाय इसके कि जब तक कोई शर्त रखता है, तब तक वह त्रुटि को ट्रिगर करता है, बजाय यदि स्थिति रखता है:

function halve(x::Integer)
    iseven(x) || throw(DomainError("cannot halve an odd number"))
    x ÷ 2
end

इसका एक और उपयोगी अनुप्रयोग किसी वस्तु के लिए डिफ़ॉल्ट मूल्य की आपूर्ति करना है, केवल अगर यह पहले से परिभाषित नहीं है:

isdefined(:x) || (x = NEW_VALUE)

यहाँ, यह जाँचता है कि क्या प्रतीक x को परिभाषित किया गया है (अर्थात यदि वस्तु x को दिया गया मान है)। अगर ऐसा है, तो कुछ नहीं होता। लेकिन, यदि नहीं, तो x को NEW_VALUE सौंपा जाएगा। ध्यान दें कि यह उदाहरण केवल बड़े पैमाने पर काम करेगा।

स्थितियों में

ऑपरेटर भी उपयोगी होते हैं क्योंकि उनका उपयोग दो स्थितियों का परीक्षण करने के लिए किया जा सकता है, जिनमें से दूसरे का मूल्यांकन केवल पहली स्थिति के परिणाम के आधार पर किया जाता है। जूलिया प्रलेखन से :

अभिव्यक्ति में a && b , उपसूचक b केवल मूल्यांकन किया जाता है, तो a के लिए मूल्यांकन करता है true

अभिव्यक्ति a || b , सबफ्रेप्रेशन b का मूल्यांकन केवल तभी किया जाता है जब a false मूल्यांकन करता false

इस प्रकार, जबकि a & b दोनों a & b और a && b दोनों true अगर a और b दोनों true , तो उनका व्यवहार a false है।

उदाहरण के लिए, मान लीजिए कि हम जांचना चाहते हैं कि कोई वस्तु पॉजिटिव नंबर है या नहीं, जहाँ यह संभव है कि वह नंबर भी न हो। इन दो प्रयासों के कार्यान्वयन के बीच अंतर पर विचार करें:

CheckPositive1(x) = (typeof(x)<:Number) & (x > 0) ? true : false
CheckPositive2(x) = (typeof(x)<:Number) && (x > 0) ? true : false

CheckPositive1("a")
CheckPositive2("a")

CheckPositive1() एक त्रुटि उत्पन्न करेगा यदि एक गैर-संख्यात्मक प्रकार को एक तर्क के रूप में आपूर्ति की जाती है। ऐसा इसलिए है क्योंकि यह पहले के परिणाम की परवाह किए बिना दोनों अभिव्यक्तियों का मूल्यांकन करता है , और जब कोई गैर-संख्यात्मक प्रकार के लिए इसका मूल्यांकन करने की कोशिश करता है, तो दूसरी अभिव्यक्ति में त्रुटि आएगी।

CheckPositive2() , हालांकि, एक गैर-संख्यात्मक प्रकार की आपूर्ति होने पर false (एक त्रुटि के बजाय) उत्पन्न करेगा, क्योंकि दूसरी अभिव्यक्ति का केवल तभी मूल्यांकन किया जाता है यदि पहला true ।

एक से अधिक शॉर्ट-सर्किट ऑपरेटर को एक साथ मारा जा सकता है। उदाहरण के लिए:

1 > 0 && 2 > 0 && 3 > 5

अगर कई शाखाओं के साथ बयान

d = Dates.dayofweek(now())
if d == 7
    println("It is Sunday!")
elseif d == 6
    println("It is Saturday!")
elseif d == 5
    println("Almost the weekend!")
else
    println("Not the weekend yet...")
end

की कोई भी संख्या elseif शाखाओं एक साथ इस्तेमाल किया जा सकता if बयान है, संभवतः के साथ या एक अंतिम बिना else शाखा। बाद की स्थितियों का मूल्यांकन केवल तभी किया जाएगा जब सभी पूर्व स्थितियां false पाई गई हों।

Ifelse फ़ंक्शन

shift(x) = ifelse(x > 10, x + 1, x - 1)

उपयोग:

julia> shift(10)
9

julia> shift(11)
12

julia> shift(-1)
-2

ifelse फ़ंक्शन दोनों शाखाओं का मूल्यांकन करेगा, यहां तक कि वह भी जो चयनित नहीं है। यह तब उपयोगी हो सकता है जब शाखाओं के दुष्प्रभाव होते हैं जिनका मूल्यांकन किया जाना चाहिए, या क्योंकि यह तेजी से हो सकता है यदि दोनों शाखाएं स्वयं सस्ती हैं।