मैं पर्ल में बूलियन चर का उपयोग कैसे करूं?

Question

मैंने कोशिश की है:

$var = false;
$var = FALSE;
$var = False;

इनमें से कोई काम नहीं करता। मुझे त्रुटि संदेश मिलता है

"सख्त उप" उपयोग में होने के बावजूद "गलत" अनुमति नहीं है।

Comments

आप मेरी पुस्तक लर्निंग पर्ल से शुरू करना चाहते हैं । यह अनुमान लगाने की तुलना में आसान है कि क्या करें जब तक आप इसे सही नहीं पाते (बंदर, टाइपराइटर, और हेमलेट, और वह सब)। :)

— ब्रायन डी फ़ो

Answer 1

Perl में, सशर्त में झूठे का मूल्यांकन करें:

0
'0'
undef
''  # Empty scalar
()  # Empty list
('')

बाकी सब सच है। वहाँ के लिए कोई barewords हैं trueया false।

Comments

@BlueWaldo: आप स्केलर की तुलना के परिणामों की तुलना और असाइन करते समय cmp और <=> का भी उपयोग कर सकते हैं। $ var = $ var1 cmp $ var2; 'cmp' और '<=>' (संख्यात्मक तुलना के लिए उपयोग किया जाता है) -1, 0, या 1 देता है, यदि बाईं तर्क सही तर्क से कम, बराबर या उससे अधिक है। इसका बूलियन नहीं है, लेकिन कभी-कभी आप यह जानना चाहते हैं कि क्या एक तर्क बराबर या उससे कम या एक से अधिक के बराबर है या नहीं के बराबर है।

— user118435

समस्या 1: एक खाली सूची झूठी नहीं है, क्योंकि यह जांचना असंभव है कि कोई सूची सही है या गलत। स्केलर संदर्भ रिटर्न में एक खाली सूची undef।

— इकेगामी

समस्या 2: ('')और ''समान मूल्य हैं। मुझे लगता है कि आप एक तत्व के साथ एक सूची को लागू करना चाहते थे जिसमें एक खाली स्ट्रिंग शामिल है (भले ही parens सूची नहीं बनाते हैं), लेकिन जैसा कि मैंने पहले ही उल्लेख किया है, यह जांचना असंभव है कि क्या कोई सूची झूठी है।

— इकेगामी

समस्या 3: ओवरलोडेड बूलियन ऑपरेटर वाली वस्तुएँ भी झूठी हो सकती हैं।

— इकेगामी

@eternicode, Perl के दो विशिष्ट मूल्य हैं जिनका उपयोग यह तब करता है जब इसे सही और गलत वापस करने की आवश्यकता होती है, इसलिए न केवल इसमें बूलियन्स होते हैं, इसमें सच ( !0aka PL_sv_yes) और असत्य ( !1aka PL_sv_no) होता है। या आप कह रहे हैं कि पर्ल को क्रोक होना चाहिए जब भी इन दो मूल्यों के अलावा कुछ और सच्चाई के लिए परीक्षण किया जाता है? यह पूरी तरह से भयानक होगा। उदा। इससे बचाव होगा$x ||= $default;

— ikegami

Answer 2

सबसे झूठी, संक्षिप्त परिभाषा जो मेरे सामने आई है, वह है:

जो कुछ भी खाली स्ट्रिंग या स्ट्रिंग 0को स्ट्रिंग करता है वह झूठा है। बाकी सब सच है।

इसलिए, निम्न मान गलत हैं:

• खाली तार
• संख्यात्मक मान शून्य
• एक अपरिभाषित मूल्य
• एक अतिभारित बूलियन ऑपरेटर के साथ एक वस्तु जो उपरोक्त में से एक का मूल्यांकन करती है।
• एक जादुई चर जो भ्रूण पर उपरोक्त में से एक का मूल्यांकन करता है।

ध्यान रखें कि एक खाली सूची शाब्दिक स्केलर संदर्भ में एक अपरिभाषित मूल्य का मूल्यांकन करती है, इसलिए यह कुछ गलत का मूल्यांकन करता है।

---

"सच्चे शून्य" पर एक नोट

जबकि संख्याएँ जो 0स्ट्रिंग को गलत बनाती हैं, वे तार जो शून्य पर संख्याबद्ध होते हैं, आवश्यक नहीं हैं। केवल झूठे तार हैं 0और खाली स्ट्रिंग है। कोई भी अन्य स्ट्रिंग, भले ही वह शून्य के बराबर हो, सच है।

निम्नलिखित वे तार हैं जो एक संख्या के रूप में एक बूलियन और शून्य के रूप में सत्य हैं:

• बिना किसी चेतावनी के:
  • "0.0"
  • "0E0"
  • "00"
  • "+0"
  • "-0"
  • " 0"
  • "0\n"
  • ".0"
  • "0."
  • "0 but true"
  • "\t00"
  • "\n0e1"
  • "+0.e-9"
• एक चेतावनी के साथ:
  • कोई भी तार जिसके लिए Scalar::Util::looks_like_numberगलत है। (उदा "abc")

Comments

अगर मैं आपको सही शब्द समझ में आ सच में एक ओर जहां नंबरों 0 stringify सत्य हैं होना चाहिए झूठी या (भ्रम की स्थिति को रोकने के लिए) को गलत पर मूल्यांकन ।

— दिमित्री कोरोलीव

आपकी "संक्षिप्त" परिभाषा आपके लंबे स्पष्टीकरण के साथ असंगत है। पर विचार करें: my $value = do { package XXX; use overload q[""] => sub { "XXX" }, q[bool] => sub { 0 }; bless [] };। अब $value"एक्सएक्सएक्स" पर सख्ती करेंगे लेकिन झूठे को गलत ठहराएंगे।

— tobyink

@tobyink, संक्षिप्त संस्करण पूर्ण नहीं है, केवल सबसे अच्छा मैंने पाया है। यह व्यावहारिक होने के लिए है, सर्वव्यापी नहीं है। ध्यान दें कि आपके द्वारा लौटाए गए मूल्य boolको सख्त बनाता है 0। इसके अलावा, आपको असंगत अधिभार बनाने से हतोत्साहित किया जाता है, और आपके द्वारा लौटाए गए मूल्यों को ऐसे माना जा सकता है। (उदाहरण के लिए एक &&में अनुकूलित किया जा सकता है ||, इसलिए यदि ये असंगत थे, तो आपको एक समस्या होगी।)

— ikegami

मुझे यकीन नहीं है कि 0x00यहां कवर किया गया है।

— ज़ेड

@ कहा, क्या आप कोड 0x00(संख्यात्मक मान शून्य) या स्ट्रिंग 0x00(जिसके looks_like_numberलिए गलत है) द्वारा लौटाए गए मूल्य का मतलब है ? किसी भी तरह से, यह पहले से ही कवर किया गया है।

— इकेगामी

Answer 3

पर्ल में एक देशी बूलियन प्रकार नहीं है, लेकिन आप समान व्यवहार प्राप्त करने के लिए पूर्णांक या स्ट्रिंग्स की तुलना का उपयोग कर सकते हैं। एलन का उदाहरण पूर्णांक की तुलना का उपयोग करने का एक अच्छा तरीका है। यहाँ एक उदाहरण है

my $boolean = 0;
if ( $boolean ) {
    print "$boolean evaluates to true\n";
} else {
    print "$boolean evaluates to false\n";
}

एक चीज जो मैंने अपने कुछ कार्यक्रमों में की है, एक निरंतर का उपयोग करके समान व्यवहार जोड़ा जाता है:

#!/usr/bin/perl

use strict;
use warnings;

use constant false => 0;
use constant true  => 1;

my $val1 = true;
my $val2 = false;

print $val1, " && ", $val2;
if ( $val1 && $val2 ) {
    print " evaluates to true.\n";
} else {
    print " evaluates to false.\n";
}

print $val1, " || ", $val2;
if ( $val1 || $val2 ) {
    print " evaluates to true.\n";
} else {
    print " evaluates to false.\n";
}

"निरंतर का उपयोग करें" में चिह्नित लाइनें एक निरंतर नाम सच को परिभाषित करती हैं जो हमेशा 1 का मूल्यांकन करता है, और एक निरंतर नाम गलत है जो हमेशा 0 से मूल्यांकन करता है। जिस तरह से कॉन्स्टैंट को पर्ल में परिभाषित किया गया है, उस तरह से कोड की निम्नलिखित पंक्तियां भी विफल हो जाती हैं:

true = 0;
true = false;

त्रुटि संदेश कुछ इस तरह कहना चाहिए "स्केलर असाइनमेंट में निरंतर संशोधित नहीं कर सकता।"

मैंने देखा कि एक टिप्पणी में आपने तार की तुलना करने के बारे में पूछा था। आपको यह पता होना चाहिए कि क्योंकि पर्ल स्केलर वैरिएबल में स्ट्रिंग्स और न्यूमेरिक प्रकारों को जोड़ती है, आपके पास स्ट्रिंग्स और संख्याओं की तुलना करने के लिए अलग-अलग सिंटैक्स हैं:

my $var1 = "5.0";
my $var2 = "5";

print "using operator eq\n";
if ( $var1 eq $var2 ) {
    print "$var1 and $var2 are equal!\n";
} else {
    print "$var1 and $var2 are not equal!\n";
}

print "using operator ==\n";
if ( $var1 == $var2 ) {
    print "$var1 and $var2 are equal!\n";
} else {
    print "$var1 and $var2 are not equal!\n";
}

इन ऑपरेटरों के बीच का अंतर पर्ल में भ्रम का एक बहुत ही आम स्रोत है।

Comments

use warnings;इसके बजाय#! perl -w

— ब्रैड गिल्बर्ट

एक गरीब आदमी के रूप में स्थिरांक का उपयोग करना उस तरह से खतरनाक है। ये कोड उदाहरण समतुल्य नहीं हैं: if ($exitstatus) { exit; }बनाम if ($exitstatus == true) { exit; }, जो एक आकस्मिक पर्यवेक्षक के लिए स्पष्ट नहीं हो सकता है। (और हां, अंतिम उदाहरण खराब प्रोग्रामिंग शैली है, लेकिन यह बिंदु के बगल में है)।

— Zano

Answer 4

मैं सलाह देता हूं use boolean;। आपको हालांकि cpan से बूलियन मॉड्यूल को स्थापित करना होगा ।

Comments

पर्ल में, जीवन में, कई सत्य हैं। अनुभवहीन को मूर्खतापूर्ण बातें लिखना पसंद है if ($my_true_value == true)। यह कहते हुए कि एक सच्चा सत्य है, मेरे अनुभव में, दर्द का एक रास्ता है, और अक्षम कोड है।

— tjd 17

पर्ल स्वभाव से दार्शनिक है

— ILMostro_7

Answer 5

मेरा पसंदीदा हमेशा से रहा है

use constant FALSE => 1==0;
use constant TRUE => not FALSE;

जो आंतरिक प्रतिनिधित्व से पूरी तरह से स्वतंत्र है।

Comments

प्रतिभाशाली। आपने एकल प्रोग्रामिंग भाषा को निश्चित रूप से निर्धारित किया है!

— Nostalg.io

Answer 6

मैं एक ट्यूटोरियल के बारे में आया, जिसमें पर्ल में सही और गलत मूल्यों के बारे में अच्छी तरह से व्याख्या की गई है । यह बताता है कि:

अदिश मानों को गलत माना जाता है:

• undef - अपरिभाषित मूल्य
• 0 संख्या 0, भले ही आप इसे 000 या 0.0 के रूप में लिखते हैं
• '' खाली स्ट्रिंग।
• '0' स्ट्रिंग जिसमें एक 0 अंक होता है।

निम्नलिखित सहित सभी अन्य अदिश मान सत्य हैं:

• 1 कोई भी गैर 0 नंबर
• ' ' इसमें एक स्पेस के साथ स्ट्रिंग
• '00' एक स्ट्रिंग में दो या अधिक 0 अक्षर
• "0\n" 0 के बाद एक नई पंक्ति
• 'true'
• 'false' हां, यहां तक ​​कि स्ट्रिंग 'असत्य' भी सही का मूल्यांकन करता है।

एक और अच्छा ट्यूटोरियल है जो पर्ल के बारे में सही और गलत बताता है ।

Answer 7

बूलियन मूल्यों के लिए बॉब द्वारा दी गई सुंदर व्याख्या : सही या गलत? एक त्वरित संदर्भ गाइड

विभिन्न मूल्यों के लिए सत्य परीक्षण

                       Result of the expression when $var is:

Expression          | 1      | '0.0'  | a string | 0     | empty str | undef
--------------------+--------+--------+----------+-------+-----------+-------
if( $var )          | true   | true   | true     | false | false     | false
if( defined $var )  | true   | true   | true     | true  | true      | false
if( $var eq '' )    | false  | false  | false    | false | true      | true
if( $var == 0 )     | false  | true   | true     | true  | true      | true

Comments

खराब उत्तर, लेकिन perlmonks.org में एक मजबूत, सम्मानित स्रोत। टिप्पणी और लिंक के बजाय कुछ वास्तविक सामग्री रखना अच्छा होगा । : - /

— ILMostro_7

Answer 8

निम्न फ़ाइल उपसर्ग का उपयोग करें, यह आपकी पर्ल स्क्रिप्ट को eTRUE और eFALSE में जोड़ेगा, यह वास्तव में वास्तविक (!) सत्य और असत्य होगा (बिल्कुल जावा की तरह)

#!/usr/bin/perl
use strict;
use warnings;

use constant { #real true false, compatible with encode_json decode_json for later (we don't want field:false... will be field:0...)
                eTRUE  =>  bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
                eFALSE =>  bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
             };

वास्तव में, कुछ कारण हैं जिनके कारण आपको इसका उपयोग करना चाहिए।

मेरा कारण यह है कि JSON के साथ काम करते हुए, मुझे कुंजी के मान के रूप में 0 और 1 मिला है, लेकिन यह हैक सुनिश्चित करेगा कि आपकी स्क्रिप्ट के साथ सही मान रखे गए हैं।