ฉันมีโปรแกรมเล็ก ๆ สองโปรแกรมนี้:

C

#include <stdio.h>
int main()
{
    if (5) {
        printf("true\n");
    }
    else {
        printf("false\n");
    }

    return 0;
}

ชวา

class type_system {
   public static void main(String args[]) {
       if (5) {
           System.out.println("true");
       }
       else {
           System.out.println("false");
       }
   }
}

ซึ่งรายงานข้อผิดพลาด:

type_system.java:4: error: incompatible types: int cannot be converted to boolean
       if (5) {
           ^
1 error

ความเข้าใจของฉัน

จนถึงตอนนี้ฉันเข้าใจตัวอย่างนี้เป็นการสาธิตระบบชนิดต่าง ๆ C มีการพิมพ์ที่อ่อนแอกว่าและอนุญาตให้ทำการแปลงจาก int เป็นบูลีนโดยไม่มีข้อผิดพลาด Java นั้นพิมพ์และล้มเหลวมากกว่าเพราะไม่อนุญาตให้มีการสนทนาโดยนัย

ดังนั้นคำถามของฉัน: ฉันเข้าใจผิดอยู่ที่ไหน

สิ่งที่ฉันไม่ได้มองหา

คำถามของฉันไม่เกี่ยวข้องกับรูปแบบการเข้ารหัสที่ไม่ดี ฉันรู้ว่ามันไม่ดี แต่ฉันสนใจว่าทำไม C อนุญาตและ Java ไม่ได้ ดังนั้นฉันสนใจระบบพิมพ์ภาษาโดยเฉพาะความแข็งแกร่งของมัน

1. C และ Java เป็นภาษาอื่น

ความจริงที่ว่าพวกเขามีพฤติกรรมแตกต่างกันไม่ควรแปลกใจอย่างมาก

2. C ไม่ได้ทำการแปลงใด ๆ จากintเป็นbool

เป็นไปได้อย่างไร C ไม่ได้มีจริงboolชนิดแปลงไปจนถึง 1999 C ที่ถูกสร้างขึ้นในช่วงต้นปี 1970 และifเป็นส่วนหนึ่งของมันก่อนที่มันก็ยิ่ง C, กลับมาเมื่อมันเป็นเพียงแค่ชุดของการปรับเปลี่ยนไปB 1

ifไม่ใช่แค่NOPใน C มาเกือบ 30 ปี มันทำหน้าที่โดยตรงกับค่าตัวเลข การใช้คำฟุ่มเฟือยในมาตรฐาน C ( ลิงก์ PDF ) แม้กว่าทศวรรษหลังจากการแนะนำของbools ถึง C ยังคงระบุพฤติกรรมของif(p 148) และ?:(p 100) โดยใช้คำว่า "ไม่เท่ากับ 0" และ "เท่ากับ 0 "แทนที่จะเป็นคำบูลีน" จริง "หรือ" เท็จ "หรือบางอย่างที่คล้ายกัน

สะดวกสบาย ...

3. ... ตัวเลขเกิดขึ้นเมื่อคำสั่งของโปรเซสเซอร์ทำงาน

JZและJNZเป็นคำแนะนำการประกอบ x86 พื้นฐานของคุณสำหรับการแยกย่อยตามเงื่อนไข ตัวย่อคือ " J ump ถ้าZ ero" และ " J ump ถ้าN ot Z ero" เทียบเท่าสำหรับ PDP-11 ที่ C มาเป็นBEQ( " Bไร่ถ้าEQ UAL ') และBNE(' Bไร่ถ้าไม่มี OT E qual")

คำแนะนำเหล่านี้ตรวจสอบว่าการดำเนินการก่อนหน้านี้ส่งผลให้ศูนย์หรือไม่และกระโดด (หรือไม่) ตาม

4. Java ให้ความสำคัญกับความปลอดภัยมากกว่า C เป็นอย่างมาก²

และด้วยความปลอดภัยในใจพวกเขาตัดสินใจว่าการ จำกัดifให้booleans นั้นคุ้มค่ากับค่าใช้จ่าย (ทั้งการดำเนินการตามข้อ จำกัด และต้นทุนโอกาสที่เกิดขึ้น)

^1. B ไม่มีประเภทแม้แต่เลย ภาษาแอสเซมบลีโดยทั่วไปก็ไม่เช่นกัน กระนั้นภาษา B และภาษาแอสเซมบลีก็สามารถจัดการกับการแตกแขนงได้อย่างดี

^2.ในคำพูดของเดนนิสริตชี่เมื่ออธิบายถึงการปรับเปลี่ยนตามแผนเป็น B ซึ่งกลายเป็น C (เน้นที่เหมือง):

... ดูเหมือนว่ารูปแบบการพิมพ์มีความจำเป็นที่จะต้องรับมือกับตัวละครและการจัดการกับไบต์และเพื่อเตรียมพร้อมสำหรับฮาร์ดแวร์จุดลอยตัวที่จะมาถึง ปัญหาอื่น ๆโดยเฉพาะอย่างยิ่งประเภทความปลอดภัยและการตรวจสอบอินเตอร์เฟสดูเหมือนจะไม่สำคัญเท่าที่ควรในภายหลัง

C 2011 Online Draft

6.8.4.1 if

ข้อ จำกัดคำสั่ง

1 การควบคุมการแสดงออกของifคำสั่งจะต้องมีประเภทสเกลาร์

Semantics

2 ในทั้งสองรูปแบบ substatement แรกจะถูกดำเนินการหากการแสดงออกเปรียบเทียบไม่เท่ากันถึง 0 ในelseรูปแบบ substatement ที่สองจะถูกดำเนินการถ้าการแสดงออกเปรียบเทียบเท่ากับ 0 หากถึงการ substatement แรกผ่านทางฉลาก substatement ที่สองคือ ไม่ดำเนินการ

3 An elseมีความเกี่ยวข้องกับคำศัพท์ที่ใกล้เคียงที่สุดก่อนหน้าหากได้รับอนุญาตจากไวยากรณ์

โปรดทราบว่าข้อนี้ระบุเฉพาะว่าการควบคุมการแสดงออกจะต้องมีประเภทสเกลาร์ ( char/ short/ int/ long/ ฯลฯ .) ไม่ได้เฉพาะประเภทบูลีน สาขาจะถูกดำเนินการถ้าการแสดงออกการควบคุมมีค่าที่ไม่เป็นศูนย์

เปรียบเทียบกับ

ข้อมูลจำเพาะภาษา Java SE 8

14.9 ifคำแถลงคำแถลง

ดังifกล่าวอนุญาตให้ดำเนินการตามเงื่อนไขของข้อความสั่งหรือเลือกเงื่อนไขสองข้อความสั่งดำเนินการอย่างใดอย่างหนึ่ง แต่ไม่ใช่ทั้งสองอย่าง

    ถ้าจากนั้นสถานะ :
        if ( Expression ) Statement

    IfThenElseStatement :
        if ( Expression ) StatementNoShortถ้าอื่นStatement

    IfThenElseStatementNoShortIf :
        if ( Expression ) StatementNoShort if อื่นStatementNoShortIf

การแสดงออกต้องมีประเภทbooleanหรือBooleanหรือรวบรวมข้อผิดพลาดเกิดขึ้นเวลา

Java, OTOH ต้องการการแสดงออกของการควบคุมในifคำสั่งที่มีประเภทบูลีนเป็นพิเศษ

ดังนั้นมันไม่เกี่ยวกับการพิมพ์ที่อ่อนแอและรุนแรง แต่มันเกี่ยวกับความหมายของแต่ละภาษาที่ระบุว่าเป็นนิพจน์ควบคุมที่ถูกต้อง

แก้ไข

สำหรับสาเหตุที่ภาษาแตกต่างกันในเรื่องนี้โดยเฉพาะอย่างยิ่งหลายจุด:

1. C มาจาก B ซึ่งเป็นภาษา "ไม่มีตัวตน" - โดยทั่วไปทุกอย่างเป็นคำ 32-36- บิต (ขึ้นอยู่กับฮาร์ดแวร์) และการดำเนินการทางคณิตศาสตร์ทั้งหมดเป็นการดำเนินการจำนวนเต็ม ระบบชนิดของ C ถูกปิดในเวลาเช่นนี้ ...

2. C ไม่มีประเภทบูลีนที่แตกต่างกันจนกระทั่งภาษาปี 1999 C เพียงตามการประชุม B ของการใช้เป็นศูนย์ที่จะเป็นตัวแทนและที่ไม่ใช่ศูนย์ที่จะเป็นตัวแทน falsetrue

3. Java โพสต์ลงวันที่ C ภายในสองสามทศวรรษที่ดีและได้รับการออกแบบมาโดยเฉพาะเพื่อจัดการข้อบกพร่องบางอย่างของ C และ C ++ ไม่ต้องสงสัยเลยว่าข้อ จำกัด ที่เข้มงวดเกี่ยวกับสิ่งที่อาจเป็นนิพจน์ควบคุมในifข้อความเป็นส่วนหนึ่งของสิ่งนั้น

4. ไม่มีเหตุผลที่จะคาดหวังไม่ได้ใด ๆสองภาษาโปรแกรมที่จะทำสิ่งต่างๆด้วยวิธีเดียวกัน แม้แต่ภาษาที่เกี่ยวข้องอย่างใกล้ชิดกับ C และ C ++ แตกต่างกันไปในบางวิธีที่น่าสนใจเช่นคุณสามารถมีโปรแกรม C ทางกฎหมายที่ไม่ใช่โปรแกรม C ++ ที่ถูกกฎหมายหรือเป็นโปรแกรม C ++ ที่ถูกกฎหมาย แต่มีความหมายต่างกันเป็นต้น

ดูเหมือนว่าคำตอบหลายคำตอบจะถูกกำหนดเป้าหมายไปที่นิพจน์การมอบหมายที่ฝังอยู่ซึ่งอยู่ในนิพจน์เงื่อนไข (แม้ว่าจะเป็นอันตรายที่อาจทราบได้ แต่ก็ไม่ใช่ที่มาของข้อความแสดงข้อผิดพลาดของ Java ในกรณีนี้)

อาจเป็นเพราะ OP ไม่ได้เผยแพร่ข้อความแสดงข้อผิดพลาดที่เกิดขึ้นจริงและ^เครื่องหมายรูปหมวกจะชี้ไปยัง=ผู้ประกอบการที่ได้รับมอบหมายโดยตรง

อย่างไรก็ตามคอมไพเลอร์กำลังชี้ไปที่=เพราะมันเป็นโอเปอเรเตอร์ที่สร้างค่าสุดท้าย (และเป็นประเภทสุดท้าย) ของนิพจน์ที่เงื่อนไขเห็น

มันกำลังบ่นเกี่ยวกับการทดสอบค่าที่ไม่ใช่บูลีนโดยมีข้อผิดพลาดประเภทต่อไปนี้:

ข้อผิดพลาด: ประเภทที่เข้ากันไม่ได้: int ไม่สามารถแปลงเป็นบูลีนได้

การทดสอบจำนวนเต็มในบางครั้งก็สะดวกถือว่าเป็นข้อผิดพลาดที่ผู้ออกแบบ Java เลือกที่จะหลีกเลี่ยง หลังจากที่ทุกJava มีจริงชนิดข้อมูลแบบบูลซึ่ง C ไม่ได้ (มันไม่มีประเภทบูล)

สิ่งนี้ยังใช้กับพอยน์เตอร์ทดสอบของ C สำหรับโมฆะ / ไม่เป็นโมฆะif (p) ...และif (!p) ...ซึ่งจาวาในทำนองเดียวกันไม่อนุญาตให้ต้องการตัวดำเนินการเปรียบเทียบที่ชัดเจนเพื่อขอรับบูลีนที่ต้องการแทน

ประเภทที่เข้ากันไม่ได้: int ไม่สามารถแปลงเป็นบูลีนได้

ฉันสนใจว่าทำไม C ถึงยอมและไม่จาวา ดังนั้นฉันสนใจระบบพิมพ์ภาษาโดยเฉพาะความแข็งแกร่งของมัน

คำถามของคุณมีสองส่วน:

ทำไม Java ไม่แปลงintเป็นboolean?

การทำเช่นนี้จะทำให้ Java มีความตั้งใจชัดเจนที่สุดเท่าที่จะเป็นไปได้ มันคงที่ "อยู่ในใบหน้าของคุณ" ด้วยระบบการพิมพ์ สิ่งที่นำแสดงโดยอัตโนมัติในภาษาอื่นไม่ได้เป็นเช่นนั้นใน Java คุณต้องเขียนint a=(int)0.5เช่นกัน การแปลงfloatเป็นintข้อมูลสูญหาย เหมือนกับการแปลงintเป็นbooleanและจะทำให้เกิดข้อผิดพลาดได้ง่าย นอกจากนี้พวกเขาจะต้องระบุชุดค่าผสมจำนวนมาก แน่นอนสิ่งเหล่านี้ดูเหมือนจะชัดเจน แต่พวกเขาตั้งใจที่จะทำผิดในด้านของความระมัดระวัง

โอ้และเมื่อเปรียบเทียบกับภาษาอื่น ๆ แล้ว Java นั้นมีความแม่นยำอย่างมากในสเปคของมันเนื่องจาก bytecode ไม่ได้เป็นเพียงรายละเอียดการติดตั้งภายในเท่านั้น พวกเขาจะต้องระบุการโต้ตอบใด ๆ และทั้งหมดอย่างแม่นยำ กิจการขนาดใหญ่

ทำไมifไม่ยอมรับประเภทอื่นที่ไม่ใช่boolean?

ifbooleanจะสมบูรณ์ดีจะหมายถึงการอนุญาตให้มีชนิดอื่นที่ไม่ใช่ อาจมีคำจำกัดความที่ระบุว่าสิ่งต่อไปนี้เทียบเท่า:

• true
• int != 0
• String กับ .length>0
• การอ้างอิงวัตถุอื่นใด ๆ ที่ไม่ใช่ - null(ไม่ใช่Booleanค่าที่มีfalse)
• หรือแม้กระทั่ง: ใด ๆ อ้างอิงวัตถุอื่น ๆ ที่เป็นไม่nullและมีวิธีการObject.check_if(การประดิษฐ์คิดค้นโดยฉันเพียงแค่สำหรับโอกาสนี้) trueผลตอบแทน

พวกเขาไม่ได้; ไม่มีความต้องการที่แท้จริงและพวกเขาต้องการให้มีประสิทธิภาพคงที่โปร่งใสง่ายต่อการอ่านและอื่น ๆ เท่าที่จะทำได้ ไม่มีคุณสมบัติโดยนัย นอกจากนี้การใช้งานจะค่อนข้างซับซ้อนฉันแน่ใจว่าต้องทดสอบแต่ละค่าสำหรับกรณีที่เป็นไปได้ทั้งหมดดังนั้นประสิทธิภาพอาจมีปัจจัยเล็ก ๆ น้อย ๆ เช่นกัน (Java เคยเป็นคนพูดเหลวไหลในคอมพิวเตอร์ของวันนั้นจำไว้ว่ามี ไม่มีคอมไพเลอร์ JIT ที่มีการเปิดตัวครั้งแรกอย่างน้อยก็ไม่ได้ใช้กับคอมพิวเตอร์ที่ฉันใช้)

เหตุผลที่ลึก

เหตุผลที่ลึกกว่านั้นอาจเป็นความจริงที่ว่า Java มีชนิดดั้งเดิมของมันดังนั้นระบบชนิดของมันจึงขาดระหว่างวัตถุและดั้งเดิม บางทีถ้าพวกเขาหลีกเลี่ยงสิ่งเหล่านั้นสิ่งต่าง ๆ ก็จะกลับกลายเป็นอีกทางหนึ่ง ด้วยกฎที่ให้ไว้ในส่วนก่อนหน้าพวกเขาจะต้องกำหนดความจริงของดั้งเดิมทุก ๆอย่างชัดเจน (ตั้งแต่ดั้งเดิมไม่แบ่งปันซูเปอร์คลาสและไม่มีกำหนดชัดเจนnullสำหรับดั้งเดิม) นี่จะกลายเป็นฝันร้ายอย่างรวดเร็ว

ภาพ

และในที่สุดอาจเป็นเพียงความชอบของนักออกแบบภาษา แต่ละภาษาดูเหมือนจะหมุนในแบบของตัวเองที่นั่น ...

ตัวอย่างเช่น Ruby ไม่มีประเภทดั้งเดิม ทุกอย่างแท้จริงทุกอย่างเป็นวัตถุ พวกเขามีเวลาง่ายมากที่จะทำให้แน่ใจว่าวัตถุทุกชิ้นมีวิธีการบางอย่าง

ทับทิมมองหาความจริงในวัตถุทุกประเภทที่คุณสามารถโยนได้ ที่น่าสนใจก็ยังไม่มีbooleanประเภท (เพราะไม่มีพื้นฐาน) และมันก็ไม่มีBooleanคลาส ถ้าคุณถามว่าระดับค่าที่trueมี (คล่องแคล่วสามารถใช้ได้กับtrue.class) TrueClassคุณจะได้รับ ชั้นเรียนนั้นมีวิธีการจริงๆนั่นคือตัวดำเนินการ 4 ตัวสำหรับ booleans ( | & ^ ==) ที่นี่ifพิจารณาค่าของมันปลอมถ้าหากเป็นอย่างใดอย่างหนึ่งfalseหรือnil( nullของ Ruby) ทุกสิ่งทุกอย่างเป็นเรื่องจริง ดังนั้น0หรือ""เป็นจริงทั้งคู่

มันคงเป็นเรื่องไม่สำคัญสำหรับพวกเขาที่จะสร้างวิธีการObject#truthy?ที่สามารถนำไปใช้กับชั้นเรียนใด ๆ และคืนความจริงส่วนบุคคล ตัวอย่างเช่นString#truthy?อาจมีการใช้งานเป็นจริงสำหรับสตริงที่ไม่ว่างเปล่าหรืออะไรก็ตาม พวกเขาไม่ได้แม้ว่า Ruby จะเป็นสิ่งที่ตรงกันข้ามของ Java ในแผนกส่วนใหญ่ (การพิมพ์เป็ดแบบไดนามิกด้วยมิกซ์อิน, การเปิดคลาสอีกครั้งและทั้งหมดนั้น)

ซึ่งอาจจะแปลกใจสำหรับโปรแกรมเมอร์ Perl ที่เคย$value <> 0 || length($value)>0 || defined($value)เป็นจริง และอื่น ๆ

ป้อน SQL ด้วยแบบแผนที่ nullอยู่ภายในนิพจน์ใด ๆ ทำให้เป็นเท็จโดยอัตโนมัติไม่ว่าอะไรก็ตาม (null==null) = falseดังนั้น ในทับทิม, (nil==nil) = true. เวลาแห่งความสุข.

นอกเหนือจากคำตอบที่ดีอื่น ๆ ฉันต้องการพูดคุยเกี่ยวกับความสอดคล้องระหว่างภาษา

เมื่อเราคิดถึงคำสั่ง if ที่บริสุทธิ์ทางคณิตศาสตร์เราเข้าใจว่าเงื่อนไขสามารถเป็นจริงหรือเท็จไม่มีค่าอื่น ๆ ภาษาการเขียนโปรแกรมหลักทุกคนเคารพอุดมคติทางคณิตศาสตร์นี้ ถ้าคุณให้ค่าบูลีนจริง / เท็จกับคำสั่ง if แล้วคุณสามารถคาดหวังที่จะเห็นพฤติกรรมที่สอดคล้องและใช้งานง่ายตลอดเวลา

จนถึงตอนนี้ดีมาก นี่คือสิ่งที่ Java ใช้และเฉพาะสิ่งที่ Java ใช้

ภาษาอื่นพยายามนำสิ่งอำนวยความสะดวกสำหรับค่าที่ไม่ใช่บูลีน ตัวอย่างเช่น:

• สมมติว่าnเป็นจำนวนเต็ม ตอนนี้กำหนดif (n)if (n != 0)ให้เป็นชวเลข
• สมมติว่าxเป็นจำนวนจุดลอยตัว ตอนนี้กำหนดif (x)if (x != 0 && !isNaN(x))ให้เป็นชวเลข
• สมมติว่าpเป็นประเภทตัวชี้ ตอนนี้กำหนดif (p)if (p != null)ให้เป็นชวเลข
• สมมติว่าsเป็นชนิดสตริง ตอนนี้กำหนดif (s)if (s != null && s != "")ให้เป็น
• สมมติว่าaเป็นประเภทอาร์เรย์ ตอนนี้กำหนดให้เป็นif (a)if (a != null && a.length > 0)

ความคิดในการให้การทดสอบชวเลขนั้นดูดีบนพื้นผิว ... จนกว่าคุณจะพบความแตกต่างในการออกแบบและความคิดเห็น:

• if (0)ถือว่าเป็นเท็จใน C, Python, JavaScript; แต่ถือว่าเป็นจริงใน Ruby
• if ([]) ถือว่าเป็นเท็จใน Python แต่จริงใน JavaScript

แต่ละภาษามีเหตุผลที่ดีในการใช้สำนวนไม่ทางใดก็ทางหนึ่ง (ตัวอย่างเช่นค่าเท็จเท่านั้นใน Ruby คือfalseและnilด้วยเหตุนี้0เป็นความจริง)

Java ใช้การออกแบบที่ชัดเจนเพื่อบังคับให้คุณจัดหาค่าบูลีนให้กับคำสั่ง if หากคุณแปลรหัสจาก C / Ruby / Python เป็น Java อย่างเร่งรีบคุณจะไม่สามารถปล่อยให้หละหลวมหากการทดสอบไม่เปลี่ยนแปลง คุณต้องเขียนเงื่อนไขอย่างชัดเจนใน Java สละเวลาสักครู่เพื่อหยุดและคิดว่าสามารถช่วยคุณจากความผิดพลาดที่เลอะเทอะ

สเกลาร์ทุกประเภทใน C, ตัวชี้, บูลีน (ตั้งแต่ C99), หมายเลข (floating-point หรือไม่) และการแจงนับ (เนื่องจากการจับคู่โดยตรงกับตัวเลข) มีค่า "ธรรมชาติ" ปลอมดังนั้นจึงดีพอสำหรับการแสดงออกตามเงื่อนไขใด ๆ .

Java มีสิ่งเหล่านั้นด้วย (แม้ว่าตัวชี้ Java จะถูกเรียกว่าการอ้างอิงและถูก จำกัด อย่างหนัก) แต่ก็มีการแนะนำมวยอัตโนมัติใน Java 5.0 ซึ่งทำให้น้ำไม่เป็นที่ยอมรับ นอกจากนี้ผู้เขียนโปรแกรมจาวายังแนะนำคุณค่าที่แท้จริงของการพิมพ์มากขึ้น

ข้อผิดพลาดอย่างหนึ่งที่เกิดขึ้นจากการถกเถียงกันว่าการ จำกัด เงื่อนไขนิพจน์ให้เป็นบูลีนเป็นประเภทของการเขียนการมอบหมายที่การเปรียบเทียบนั้นตั้งใจจะทำซึ่งไม่ได้กล่าวถึงโดยการ จำกัด ประเภทของนิพจน์เงื่อนไขทั้งหมดแต่โดยไม่อนุญาต สำหรับมูลค่าของมัน

คอมไพเลอร์ C หรือ C ++ ที่ทันสมัยใด ๆ จัดการได้อย่างง่ายดายซึ่งให้คำเตือนหรือข้อผิดพลาดสำหรับการสร้างที่น่าสงสัยดังกล่าวหากถูกถาม
สำหรับกรณีที่ตรงตามที่ตั้งใจไว้การเพิ่มวงเล็บช่วย

ในการสรุปการ จำกัด บูลีน (และค่าที่เทียบเท่าใน Java) ดูเหมือนว่าความพยายามที่ล้มเหลวในการสร้างคลาสของความผิดพลาดที่เกิดจากการเลือก=สำหรับการรวบรวมข้อผิดพลาดที่ได้รับมอบหมาย

คำถามของฉันไม่เกี่ยวข้องกับรูปแบบการเข้ารหัสที่ไม่ดี ฉันรู้ว่ามันไม่ดี แต่ฉันกำลัง intersted ในเหตุผลที่ C ไม่อนุญาตและ java ไม่

สองเป้าหมายการออกแบบของ Java คือ:

1. อนุญาตให้ผู้พัฒนามุ่งเน้นไปที่ปัญหาทางธุรกิจ ทำให้สิ่งต่าง ๆ ง่ายขึ้นและมีข้อผิดพลาดน้อยลงเช่นการรวบรวมขยะเพื่อให้นักพัฒนาไม่จำเป็นต้องมุ่งเน้นไปที่หน่วยความจำรั่ว

2. เคลื่อนย้ายได้ระหว่างแพลตฟอร์มเช่นทำงานบนคอมพิวเตอร์ที่มี CPU ใด ๆ

เป็นที่ทราบกันดีว่าการใช้การมอบหมายเป็นนิพจน์ทำให้เกิดข้อบกพร่องมากมายเนื่องจากการพิมพ์ผิดดังนั้นภายใต้เป้าหมาย # 1 ด้านบนจะไม่ได้รับอนุญาตในแบบที่คุณพยายามจะใช้

นอกจากนี้การอนุมานว่าค่าใด ๆ ที่ไม่ใช่ศูนย์ = จริงและค่าศูนย์ใด ๆ = false นั้นไม่จำเป็นต้องพกพา (ใช่เชื่อหรือไม่ระบบบางระบบปฏิบัติต่อ 0 ว่าเป็นจริงและ 1 เป็นเท็จ ) ดังนั้นภายใต้เป้าหมาย # 2 ด้านบน . คุณยังสามารถส่งแน่นอน

เป็นตัวอย่างสิ่งที่ภาษาอื่น ๆ ทำ: Swift ต้องการนิพจน์ของชนิดที่รองรับโปรโตคอล "BooleanType" ซึ่งหมายความว่าจะต้องมีวิธี "boolValue" ประเภท "บูล" สนับสนุนโปรโตคอลนี้อย่างชัดเจนและคุณสามารถสร้างประเภทของคุณเองที่สนับสนุน ประเภทจำนวนเต็มไม่รองรับโปรโตคอลนี้

ในรุ่นที่เป็นตัวเลือกภาษารุ่นเก่ารองรับ "BooleanType" ดังนั้นคุณสามารถเขียน "if x" แทน "if x! = nil" ซึ่งทำโดยใช้ "ตัวเลือกบูล" สับสนมาก บูลเสริมมีค่าเป็นศูนย์, เท็จหรือจริงและ "ถ้า b" จะไม่ถูกดำเนินการถ้า b เป็นศูนย์และดำเนินการถ้า b เป็นจริงหรือเท็จ สิ่งนี้ไม่ได้รับอนุญาตอีกต่อไป

และดูเหมือนจะมีผู้ชายคนหนึ่งที่ไม่ชอบการเปิดโลกทัศน์ของคุณ ...