การจัดการการแบ่งบรรทัดของ Python แตกต่างจากอัฒภาคอัตโนมัติของ JavaScript อย่างไร

41

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

function test(){
    // This will return 'undefined', because return is a valid statement
    // and  "john" is a valid statement on its own.
    return 
          "john"
}

เนื่องจาก gotchas เหล่านี้มีบทความมากมายที่มีชื่อเช่น 'การแทรกเครื่องหมายอัฒภาคอัตโนมัติคือความชั่วร้าย', 'ใช้เครื่องหมายอัฒภาคใน Javascript เสมอ' เป็นต้น

แต่ใน Python ไม่มีใครใช้เครื่องหมายอัฒภาคเลยและก็มี gotchas เหมือนกันทุกประการ

def test():
    # This will return 'undefined', because return is a valid statement
    # and  "john" is a valid statement on its own.
    return 
    "john"

ทำงานเหมือนกันทุกประการและไม่มีใครกลัวพฤติกรรมของงูหลาม

ฉันคิดว่ากรณีที่จาวาสคริปต์มีพฤติกรรมไม่ดีพอที่คุณควรหลีกเลี่ยงได้อย่างง่ายดาย ส่งคืนค่าในบรรทัดใหม่หรือไม่ ผู้คนทำสิ่งนั้นมากจริงๆหรือ

ความคิดเห็นใด? คุณใช้เครื่องหมายอัฒภาคใน javascript หรือไม่และทำไม

python javascript

— Einar Egilsson
แหล่งที่มา

3

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

— Reid

1

ประเด็นของฉันไม่ใช่ว่าการใช้เครื่องหมายอัฒภาคและไม่ใช้พวกเขาทำงานเหมือนกันจุดคือกรณีขอบใน javascript และหลามเหมือนกัน มีบางกรณีที่คุณต้องรู้ว่าเกิดอะไรขึ้น บทความที่ดีที่สุดที่ฉันได้อ่านในหัวข้อ: inimino.org/~inimino/blog/javascript_semicolons

— Einar Egilsson

4

ฉันใส่เครื่องหมายอัฒภาคใน JavaScript ด้วยเหตุผลเดียวกันกับที่ใช้จุดเป็นประโยค แน่นอนว่าล่ามจะสามารถเข้าใจถ้อยคำของคุณได้หากไม่มีพวกเขา แต่เป็นรูปแบบที่ไม่ดี

— JD Isaacks

3

คุณอาจลองเขียนไพ ธ อนที่ถูกต้องในตัวอย่างของคุณ ตัวบ่งชี้ความคิดเห็นคือ#ไม่ใช่ `// '

— Aaron Dufour

2

"ชัดเจนดีกว่าการบอกเป็นนัยเสมอ"

62

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

ในทางตรงกันข้าม Javascript นั้นได้รับการออกแบบโดยคำนึงถึงรูปแบบ C-like ซึ่งคำสั่งจะถูกยกเลิกด้วยเครื่องหมายอัฒภาคเสมอ เพื่อให้ภาษามีความทนทานต่อข้อผิดพลาดมากขึ้นพยายามที่จะเดาว่าควรใช้เครื่องหมายอัฒภาคพิเศษเพื่อให้รหัสถูกต้องหรือไม่ เนื่องจากนี่เป็น retro-fit บนไวยากรณ์แบบ C จึงไม่สามารถทำงานได้อย่างที่คาดไว้ (บางครั้งล่ามสคริปต์จะเดาผิด) และสามารถสร้างรหัสต่อต้านได้ง่าย \

หรือการโต้เถียงในแง่ของ "ชัดเจนดีกว่าโดยนัย": ใน Python บรรทัดใหม่มีความชัดเจนโดยสมบูรณ์ในขณะที่ใน Javascript จะไม่ชัดเจนดังนั้นคุณจึงเพิ่มเซมิโคลอนเพื่อทำให้ชัดเจน

— tdammers
แหล่งที่มา

3

โอ้และคุณสามารถใส่รหัสในความคิดเห็นโดยใช้ backquotes

— tdammers

1

ตัวอย่างที่ดีของกรณีที่การแทรกเซมิโคลอนอัตโนมัติจะจบลงด้วยการทำสิ่งที่ไม่คาดคิดคือ: pastebin.com/aVeWGdya

— HoLyVieR

5

ในไพ ธ อนกฎค่อนข้างง่าย: คำสั่งสิ้นสุดที่ linebreaks เว้นแต่ว่าจะมีสตริงหลายบรรทัดที่ไม่มีการแบ่งแยก ("" ", '' '), คำสั่ง unclosed ({}), รายการที่ไม่เปิดเผย ([]) หรือแบ็กสแลชทันที ก่อนการแตกไลน์ใน javascript กฏมีความซับซ้อนมากขึ้น

— Aaron Dufour

5

การครอบคลุมข้อผิดพลาด 99% เป็นวิธีที่ดีที่จะทิ้งไว้ แต่สิ่งที่หายากจริงๆ ไม่เป็นไรที่จะทิ้งมันไว้ในไพ ธ อนเพราะมันมีกฎง่าย ๆ ที่ครอบคลุมปัญหาได้ 100%

— Aaron Dufour

1

@Aaron: คุณลืม "วงเล็บในชุด (())" ที่ไม่มีการเปิดเผย (ไม่ใช่อย่างเคร่งครัด "tuple ที่ไม่เป็นเอกภาพ" เนื่องจากวงเล็บไม่ได้ใช้สำหรับสิ่งอันดับ)

— JAB

28

มีความแตกต่างพื้นฐานค่อนข้างมากจากวิธีการทำงานของ Python ฉันคิดว่า การอ้างอิงจากโพสต์ Einar Egilsson ที่เชื่อมโยงกับ: "อัฒภาคไม่ได้บอกเป็นนัยในตอนท้ายของบรรทัดหากโทเค็นแรกของบรรทัดถัดไปสามารถแยกวิเคราะห์เป็นส่วนหนึ่งของคำสั่งเดียวกัน"

ใน Python การแบ่งบรรทัดจะสิ้นสุดคำสั่งเสมอยกเว้นในบางกรณีที่ค่อนข้างชัดเจนเช่นภายในนิพจน์ที่มีวงเล็บ ในทางตรงกันข้าม JavaScript จะพยายามวิเคราะห์คำให้มากที่สุดเท่าที่จะทำได้ก่อนที่จะจบคำสั่งซึ่งอาจนำไปสู่สิ่งต่าง ๆ เช่นนี้:

// Define a function and name it area.
area = function(r) {
    return r * r * 3.14159
}

// Fooled you! We're actually invoking it.
(14)

— เฮนริก
แหล่งที่มา

8

ตอนนี้ที่นี่เป็นเกมที่สนุก แทนที่ 14 กับสิ่งที่ต้องการ(a + 1) ? do_something() : do_something_else();และก็พื้นที่ถูกตั้งค่าให้ค่าตอบแทนของdo_something()หรือdo_something_else()และคุณซ้ายสับสนอย่างมาก

— Reid

20

ฉันมักจะลดไฟล์ JS ของฉันในโหมดการผลิต หมายถึงการลบความคิดเห็นและ linebreaks

หากไม่มีการใช้เครื่องหมายอัฒภาคนั่นจะทำให้ Javascript ของฉันพัง

— Deradon
แหล่งที่มา

8

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

— Einar Egilsson

2

@Einar Egilsson ปิดคอมไพเลอร์ทำเช่นนี้แน่นอน

— จริงจัง

1

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

— Logan Bailey

3

@Logan: นั่นคือสมมติว่ามีหนึ่งบรรทัดใหม่แน่นอน ;-)

— Cameron

1

แน่นอนถ้าเราใช้ Python แทน Javascript เราจะต้องเขียนโค้ด WAY ให้ทำสิ่งเดียวกันดังนั้นความจริงที่ว่า semi-colons ใช้สองสามไบต์น้อยกว่าการเยื้องเป็นจุดที่สงสัย

— BlueRaja - Danny Pflughoeft

5

มันไม่ทำงานตามที่คุณอธิบาย

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

นี่เป็นสิ่งที่ผิด ตัวอย่าง:

return
  1 + 2;

1เป็นสัญลักษณ์ที่ถูกต้องสมบูรณ์ แต่ parser returnจะยังคงแทรกอัฒภาคโดยตรงหลังจาก

อย่างที่คุณเห็นแม้คุณจะไม่สามารถบอกได้อย่างแน่นอนว่าจะมีเครื่องหมายอัฒภาคเกิดขึ้นที่ไหน

ปัญหาของการแทรกอัตโนมัติคือสองเท่า:

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

แน่นอนว่าการใช้เครื่องหมายอัฒภาคหลังจากคำสั่งทุกคำสั่งจะช่วยเฉพาะกับแหล่งที่มาของข้อผิดพลาดแรกเท่านั้น

ไม่ว่าในกรณีใดก็ตามคุณอาจคาดเดาได้แล้วตอนนี้ฉันเชื่อว่าการแทรกเครื่องหมายอัฒภาคโดยอัตโนมัติในไวยากรณ์ C-like เป็นแนวคิดที่ไม่ดี

— Svante
แหล่งที่มา

1

ข้อมูลจำเพาะสคริปต์ ECMA ระบุอย่างชัดเจนว่ากรณีใดจะมีการใส่เครื่องหมายทวิภาคครึ่งหนึ่งดังนั้นบรรทัดของคุณ "คุณไม่สามารถบอกได้อย่างชัดเจนว่าเครื่องหมายอัฒภาคจะเกิดขึ้นที่ไหน" ไม่ถูกต้อง ปัญหาคือมันไม่ได้ใช้งานง่ายในบางกรณีทำให้ยากที่จะสอนคนที่ไม่เข้าใจวิธีการทำงาน

— zzzzBov

1

@zzzzBov: ใช่มีข้อกำหนดที่แน่นอน แต่ไม่มีใครมีทุกกรณีจริงๆในใจขณะที่เข้ารหัส? คุณแน่ใจไหม? โปรแกรมเมอร์นั้นขี้เกียจและอย่างถูกต้อง พวกเขาไม่ต้องการที่จะจำกฎที่ซับซ้อนเมื่อจะง่ายกว่านั้น ดังนั้นพวกเขาจึงพยายามหลีกเลี่ยงที่จะจำมัน

— Svante

ฉันยอมรับว่าการแทรกเซมิโคลอนนั้นไม่จำเป็น ฉันแค่บอกว่ามีความแตกต่างระหว่างการพูดว่า "คุณไม่มีความคิดที่ semi-colons จะไป" และ "ข้อมูลจำเพาะสำหรับการแทรกเครื่องหมายทวิภาค - กึ่งเป็นสับสนที่ไม่ได้ใช้งานง่าย"

— zzzzBov

1

@Svante: แต่ตัวอย่างที่แสดงให้เห็นว่าเราต้องรู้กฎเหล่านี้อยู่ดี คุณใช้เซมิโคลอน แต่ก็ไม่ได้ช่วยให้คุณทำสิ่งที่คุณต้องการ ดังนั้นเมื่อภาษามีคุณสมบัตินี้เรามีตัวเลือก (1) เขียนอัฒภาคทุกที่และรู้กฎเพื่อให้เราเข้าใจสิ่งที่จะเกิดขึ้น (2) ไม่เขียนอัฒภาคทุกที่และเข้าใจกฎเพื่อให้เราเข้าใจว่าจะเกิดอะไรขึ้น ด้วยตัวเลือกนั้นฉันคิดว่าฉันควรข้ามเครื่องหมายอัฒภาค

— Einar Egilsson

4

ฉันขอระบุเหตุผลง่ายๆข้อเดียว:

Javascript มีลักษณะ "kinda java-ish" หรือ "kinda C-ish" แน่นอนว่ามันเป็นภาษาแบบไดนามิกดังนั้นมันจึงดูแตกต่าง ... แต่ต้องเผชิญ - มีวงเล็บปีกกา ภาษาที่มีเครื่องหมายวงเล็บมักมีเครื่องหมายอัฒภาค Enterการตอบสนองธรรมชาติเตะในและทำให้การเดินทางของคุณต่อนิ้วที่สำคัญอัฒภาคก่อนที่จะกด

ในทางกลับกัน Python ก็ดูแตกต่างกันโดยสิ้นเชิง ดังนั้นการเปรียบเทียบเพียงเล็กน้อยหรือไม่มีเลยกับ "ภาษาที่น่าเบื่อมาตรฐาน" นั้นเกิดขึ้นอย่างสังหรณ์ใจและเมื่อมีใครเข้าสู่ "โหมดหลาม" การขาดเซมิโคลอนจะเป็นไปตามธรรมชาติ

— คอส
แหล่งที่มา

2

มีหลายเหตุผลที่ดีที่จะไม่ใช้การแทรกกึ่งโคลอนใน JavaScript

สาเหตุหลักมาจากการแทรกเซมิโคลอนตามที่กำหนดไว้ในมาตรฐาน ECMAScript นั้นไม่สามารถใช้งานได้ในบางกรณี @Svante ชี้ให้เห็นกรณีreturnที่การใช้บรรทัดใหม่จะทำให้เกิดปัญหา

สิ่งที่เขาไม่ได้กล่าวถึงคือมันจะทำให้เกิดปัญหาหากคุณใช้เซมิโคลอนเช่นกันเนื่องจากการแทรกเซมิโคลอนเกิดขึ้นไม่ว่าคุณจะต้องการหรือไม่

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

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

สำหรับผู้แต่งที่ไม่มีทางเลือกว่าจะเลือกใช้เครื่องมืออะไรมันง่ายกว่ามากที่จะยึดรูปแบบที่เหมาะกับกรณีส่วนใหญ่

— zzzzBov
แหล่งที่มา

อาขออภัยเกี่ยวกับย่อหน้าที่สามของคุณผมทำพูดถึงว่าในประโยคที่สองไปสุดท้ายของฉัน :)

— Svante

ใช่ปัญหาการใช้เครื่องมือนั้นถูกต้อง (ถึงแม้ว่าตัวแปลงขนาดเล็กที่ดีควรจัดการสิ่งนี้เช่นคอมไพเลอร์ตัวปิด) แต่ในความคิดของฉันเราจำเป็นต้องรู้กฎเหล่านี้ต่อไปเพื่อหลีกเลี่ยงสิ่งต่าง ๆ เช่น 'คืน' ตัวอย่าง และเมื่อฉันรู้กฎฉันก็อาจใช้คุณสมบัติเช่นกันโดยเฉพาะอย่างยิ่งเนื่องจากทำให้โค้ด (IMO) อ่านได้มากขึ้น

— Einar Egilsson

1

การไม่ใช้เครื่องหมายอัฒภาคเป็นสูตรสำหรับความล้มเหลวเมื่อคุณย่อขนาดไฟล์ JavaScript ของคุณ นั่นคือเหตุผลที่ฉันกลัวมัน

— พระภิกษุตะวันออก
แหล่งที่มา

1

ใน Javascript คุณสามารถเขียนโปรแกรมที่จะถูกต้องทางไวยากรณ์ในกรณีที่ไม่มีการแทรกเครื่องหมายอัฒภาคโดยอัตโนมัติและ ASI จะแปลงโปรแกรมนั้นเป็นโปรแกรมที่ถูกต้องทางไวยากรณ์ที่แตกต่างกัน (ตัวอย่างเช่นการแปลงรหัสที่ส่งกลับค่าเป็นรหัส ไม่มีกรณีที่เหมือนกันใน Python ใน Python บรรทัดใหม่ใด ๆ ที่สามารถจบคำสั่งจะจบคำสั่งยกเว้นว่ามันจะหลบหนีด้วยแบ็กสแลช ในทางเทคนิคแล้วฉันคิดว่ากฎของ Javascript นั้นกำหนดไว้เท่า ๆ กัน แต่ฉันไม่รู้ว่าคุณสามารถสรุปกฎของ Javascript สำหรับการจบงบในประโยคเดียวได้หรือไม่

— Ryan Thompson
แหล่งที่มา

1

ในกรณีส่วนใหญ่ ASI ของ JavaScript จัดการสิ่งต่าง ๆ ตามที่คาดไว้ ตัวอย่างหนึ่งของ ASI อาจไม่เป็นไปตามที่คุณคาดหวัง:

var i = 0

(function() {
   // do something
})()

สิ่งนี้จะถูกตีความเป็นการเรียกฟังก์ชั่น0ด้วยฟังก์ชั่นที่ไม่ระบุชื่อจากนั้นดำเนินการผลลัพธ์ ในกรณีนี้คุณอาจต้องการมอบหมายงานจากนั้นดำเนินการฟังก์ชันที่ไม่ระบุชื่อทันที

สำหรับคนที่ไม่คุ้นเคยกับ ASI อาจสร้างความสับสนได้มากเมื่อคุณประสบปัญหาเช่นนี้ดังนั้นฉันจึงแนะนำให้นักพัฒนาในทีมของฉันใช้เครื่องหมายอัฒภาคเสมอ

(แยกกัน: ฉันไม่ได้ใช้เครื่องหมายอัฒภาคเมื่อทำงานกับโครงการส่วนตัว / ด้านข้างเพราะฉันรู้ว่าไม่มีใครจะต้องรักษารหัส)

— jay_soo
แหล่งที่มา

1

เช่นคุณฉันคิดว่ามันเป็นความหวาดระแวง กฎสำหรับการแทรกเครื่องหมายอัฒภาคถูกกำหนดไว้อย่างดีใน JavaScript เช่นเดียวกับที่อยู่ใน Python และ CoffeeScript ไม่มีใคร litters Python หรือ CoffeeScript ที่มีเครื่องหมายอัฒภาคทำไม JavaScript จึงได้รับการปฏิบัติแตกต่างกันอย่างไร

ฉันคิดว่ามันเป็นปฏิกิริยาที่เกินคาดของสภาพรหัส JavaScript ทั่วไปเมื่อประมาณสิบปีที่แล้ว - JavaScript ถูกมองว่าเป็นภาษาที่อ่อนแออ่อนแอน่าเกลียดและไม่ดี มันเป็นความลำบากใจ คุณไม่สามารถเขียนโค้ดที่ดีใน JavaScript ได้!

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

ทำไม JavaScript ยังคงได้รับการปฏิบัติแตกต่างกัน

มีความเฉื่อย และไม่ควรมองข้ามว่าคนที่ชื่นชมรหัสที่มีโครงสร้างชัดเจนมักชอบภาษาสไตล์ C ผู้ที่ชื่นชอบโค้ดที่มีโครงสร้างโดยนัยมักจะย้ายไปใช้ภาษาที่ไม่ใช่สไตล์ C (เช่น CoffeeScript)

— ปิดคาวบอย
แหล่งที่มา

0

ฉันใช้มันใน Javascript อย่างเคร่งครัดเพื่อความมั่นคง หากบรรทัดส่วนใหญ่มี

Python มีกรณีขอบเช่นคำสั่งหลายคำสั่งในบรรทัดเดียว javascript มีพวกเขาและเนื่องจากคุณจะพบพวกเขาใช้เป็นประจำฉันปฏิบัติตามบรรทัดฐานที่พวกเขาใช้

ฉันไม่พบการใช้งานสำหรับหลาย ๆ คำสั่งในบรรทัดเดียวกันดังนั้นจึงไม่คาดการณ์ว่าจะใช้เครื่องหมายอัฒภาค

— คริส
แหล่งที่มา

ใช่ฉันแก้ไขตัวอย่าง Python แล้ว แต่ประเด็นก็คือ Python ยังมีเครื่องหมายอัฒภาคคุณสามารถใส่พวกเขาหลังทุกคำสั่ง (และต้องถ้าคุณมีมากกว่าหนึ่งในแต่ละบรรทัด) แต่คนไม่ได้ใช้พวกเขา

— Einar Egilsson

0

หากคุณใช้บางอย่างเช่น bundle-fu และผู้จัดการสินทรัพย์สำหรับแอปพลิเคชันเว็บของคุณในทางรถไฟมันจะพังอย่างน่ากลัวหากไม่พบอัฒภาคในตอนท้ายของโทเค็นใน javascript ดังนั้นจึงเป็นการดีที่จะใส่

— subiet
แหล่งที่มา

ทีนี้, ใหญ่สาม, YUI Compressor, ปิดคอมไพเลอร์, และ UglifyJS, ทั้งหมดทำการแทรกอัฒภาค ฉันไม่แปลกใจเลยว่าพอร์ตทับทิมของ JSMin มีปัญหา

— Benjamin Atkin

0

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

var myFunc = function() {
  ...
}

หากคุณไม่ได้เพิ่ม; หลังจากปิดวงเล็บปีกกาโปรแกรมจะล้มเหลวจริง ๆ ใน IE บางรุ่น พร้อมด้วยเหตุผลอื่น ๆ (รวมถึงคำแนะนำของ Crockford ที่จะใช้มันอย่างชัดเจน) ทำให้ฉันใช้มันอย่างชัดเจนในทุกกรณี

— apinstein
แหล่งที่มา