ทำไมการเปลี่ยนแปลงล่าสุดเพื่อลบ / ไม่ใช้เครื่องหมายอัฒภาคจาก Javascript

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

แม้แต่GitHub ก็กระโดดขึ้นไปบน bandwagon ที่ไม่มีเครื่องหมายอัฒภาคต้องการการละเว้นในโค้ดที่พัฒนาขึ้นภายในใด ๆ และความมุ่งมั่นล่าสุดในโครงการ zepto.js โดยผู้ดูแลมันได้ลบเครื่องหมายอัฒภาคทั้งหมดจาก codebase เหตุผลหลักของเขาคือ:

• มันเป็นเรื่องของการตั้งค่าสำหรับทีมของเขา;
• พิมพ์น้อย

มีเหตุผลที่ดีอื่นที่จะปล่อยพวกเขาออกมา?

ตรงไปตรงมาฉันไม่เห็นเหตุผลที่จะละเว้นพวกเขาและแน่นอนไม่มีเหตุผลที่จะกลับไปที่รหัสเพื่อลบพวกเขา มันยังขัดกับแนวทางปฏิบัติที่แนะนำ ( หลายปี ) ซึ่งฉันไม่ได้ซื้ออาร์กิวเมนต์ "ลัทธิการขนส่งสินค้า" สำหรับ ดังนั้นทำไมเซมิโคลอนที่เกลียดชังล่าสุดทั้งหมด มีปัญหาการขาดแคลนปรากฏหรือไม่ หรือนี่เป็นเพียง Javascript ล่าสุดเท่านั้น

ฉันคิดว่าเหตุผลของฉันคือ lamest: ฉันเขียนโปรแกรมในภาษาที่แตกต่างกันมากเกินไปในเวลาเดียวกัน (Java, Javascript, PHP) - ที่ต้องการ ';' ดังนั้นแทนที่จะฝึกนิ้วและตาของฉันว่า ';' ไม่จำเป็นสำหรับ javascript ฉันแค่เพิ่ม ';'

เหตุผลอื่นคือเอกสาร: โดยเพิ่ม ';' ฉันระบุตัวเองอย่างชัดเจนในที่ที่ฉันคาดหวังว่าข้อความจะสิ้นสุด จากนั้นอีกครั้งฉันก็ใช้ {} ตลอดเวลาเช่นกัน

อาร์กิวเมนต์จำนวนไบต์ทั้งหมดฉันพบว่าน่ารำคาญและไม่มีจุดหมาย:

1) สำหรับไลบรารีทั่วไปเช่น jquery: ใช้ google CDN และไลบรารีอาจอยู่ในแคชเบราว์เซอร์แล้ว

2) ปรับรุ่นไลบรารี่ของคุณเองและตั้งให้เป็นแคชถาวร

3) gzip และย่อให้เล็กสุดถ้าจำเป็นจริงๆ

แต่จริงๆแล้วมีกี่เว็บไซต์ที่เป็นคอขวดความเร็วที่ใหญ่ที่สุดของความเร็วในการดาวน์โหลดจาวาสคริปต์ของพวกเขา? หากคุณทำงานให้กับเว็บไซต์ 100 อันดับแรกเช่น twitter, google, yahoo เป็นต้น พวกเราที่เหลือควรกังวลเกี่ยวกับคุณภาพของรหัสไม่ใช่สงครามทางศาสนาอัฒภาค

มันทำให้วิธีการผูกมัดง่ายขึ้นและกระทำการทำความสะอาดที่แตกต่าง

สมมุติว่าฉัน jQuerying เกี่ยวกับฉัน

$('some fancy selector')
  .addClass()
  .attr();

ถ้าฉันต้องการเพิ่มสิ่งต่าง ๆและทำให้การคอมมิชชันตามบรรทัดของฉันเล็กลงฉันต้องเพิ่มมันไว้เหนือ attr ดังนั้นจึงเป็นความคิดที่ยาวเกินกว่า "เพิ่มในตอนท้าย" และใครอยากคิด =)

$('some fancy selector')
  .addClass()
  // new method calls must go here
  .attr();

แต่เมื่อฉันลดเซมิโคลอนลงไปฉันก็สามารถต่อท้ายและเรียกมันได้หนึ่งวัน

  $('some fancy selector')
    .addClass()
    .attr()
+   .animate()
+   .click()

นอกจากนี้ถ้าฉันตัดสินใจที่จะโผล่ออกมาจากวิธีสุดท้ายฉันไม่ต้องกำหนดเซมิโคลอนอีกครั้งและทำให้การกระทำของฉันเป็นมลทินอีกครั้ง

  $('some fancy selector')
    .addClass()
    .attr()
    .animate()
-   .click()

กับ uggo

  $('some fancy selector')
    .addClass()
    .attr()
+   .animate();
-   .animate()
-   .click();

semi colons ใน JavaScript เป็นตัวเลือก

เหตุผลส่วนตัวของฉันที่ไม่ได้ใช้ semi colons คือ OCD

เมื่อฉันใช้เครื่องหมายทวิภาคกึ่งฉันลืม 2% ของพวกเขาและต้องตรวจสอบ / เพิ่มอย่างต่อเนื่อง

เมื่อฉันไม่ใช้ semi colons ฉันไม่เคยใส่เข้าไปโดยไม่ตั้งใจดังนั้นฉันจึงไม่ต้องตรวจสอบ / ลบออก

ฉันเพิ่งเขียน parser / วิเคราะห์สำหรับจาวาสคริปต์ที่ผมต้องระมัดระวังการใช้ ASI และฉันยังมีสำเนาของฉัน Crockford ของJavaScript: ส่วนดีบนชั้นวางหนังสือของฉันซึ่งสนับสนุนเสมอโดยใช้เครื่องหมายอัฒภาค ความตั้งใจนั้นดี แต่ก็ไม่ได้ช่วยในทางปฏิบัติเสมอไป

เห็นได้ชัดว่าคนที่เขียนเฟรมเวิร์กเช่น jQuery, zepto ฯลฯ เป็นจาวาไวยากรณ์ของจาวาสคริปต์ดังนั้นพวกเขาจึงรู้ถึงความแตกต่างระหว่าง:

return
{
    status: true
};

และ

return {
    status: true
};

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

1. บอกพวกเขาว่า "ทำตามกฎข้อนี้และอย่าถามว่าทำไม" บอกให้พวกเขาใส่เครื่องหมายอัฒภาคเสมอในตอนท้ายของทุกบรรทัด น่าเสียดายที่สิ่งนี้ไม่ได้ช่วยในตัวอย่างด้านบนหรือตัวอย่างอื่น ๆ ที่ ASI เข้ามา และนายหรือนางสาวโปรแกรมเมอร์เริ่มต้นจะสับสนเมื่อรหัสข้างต้นล้มเหลว
2. บอกพวกเขาว่า "ทำตามกฎทั้งสองนี้และอย่าถามว่าทำไม" บอกให้พวกเขาไม่ต้องกังวลกับเครื่องหมายอัฒภาคในตอนท้ายของทุกบรรทัดและเสมอ a) ตามreturnด้วย a {และ b) เมื่อบรรทัดเริ่มด้วย a (, prepend ;มันด้วย

การเลือกตัวเลือกที่ 2 เป็นชุดที่ดีกว่าของกฎ "ลัทธิลัทธิขนส่งสินค้า" ที่จะปฏิบัติตาม (จะส่งผลให้เกิดข้อผิดพลาดที่เกี่ยวข้องกับ ASI น้อยมาก) และแม้ว่าคุณจะมีความเข้าใจอย่างถ่องแท้ในหัวข้อคุณมีตัวอักษรที่ไม่จำเป็น

ไม่มีสิ่งใดที่เกินความเป็นข้อมูลเพียงการออกแบบที่ไม่ดี

- Edward Tufte

เป็นกฎทั่วไปในการออกแบบกราฟิกเพื่อให้องค์ประกอบที่ไม่จำเป็นและการตกแต่งเพื่อลดเสียงรบกวน

องค์ประกอบภาพบนหน้าจอที่น้อยลงหมายถึงว่าสมองของเราทำงานน้อยลงในการแยกวิเคราะห์ข้อมูลที่เป็นประโยชน์จริง

let foo = 1

เมื่อเทียบกับ

let /* variable */ foo = 1; // EOL

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

เหตุผลทางประวัติศาสตร์ในการใช้เครื่องหมายอัฒภาคใน JavaScript คือ:

• รักษาความคล้ายคลึงกันกับ C / Java
• หลีกเลี่ยงปัญหาความเข้ากันได้กับเบราว์เซอร์และเครื่องมือที่เขียนไม่ดี
• ช่วยให้มนุษย์และเครื่องตรวจจับข้อผิดพลาดของรหัส
• การแทรกเซมิโคลอนอัตโนมัติมีโทษประสิทธิภาพ

ปัญหาความเข้ากันได้ค่อนข้างไม่เป็นปัญหาในวันนี้ linters ที่ทันสมัยสามารถตรวจจับข้อผิดพลาดของรหัสได้เช่นกันโดยไม่มีเครื่องหมายอัฒภาค ความคล้ายคลึงกันกับ C / Java / PHP ยังสามารถนำมาพิจารณาได้ (ดูคำตอบที่ยอมรับโดย Pat) แต่เพียงเพราะภาษาอื่น ๆ มีองค์ประกอบทางไวยากรณ์ฟุ่มเฟือยไม่ได้หมายความว่าเราควรเก็บไว้ใน JavaScript โดยเฉพาะอย่างยิ่งเนื่องจากภาษาอื่น ๆ (Coffeescript, Python Ruby, Scala, Lua) ไม่ต้องการมัน

ฉันทำการทดสอบอย่างรวดเร็วเพื่อดูว่ามีโทษปรับประสิทธิภาพใน V8 หรือไม่ นี่คือ Io.js ในการแยกวิเคราะห์ไฟล์ JavaScript 41 MB (Lodash ซ้ำ 100 ครั้ง) ด้วยเครื่องหมายอัฒภาคจากนั้นลบเครื่องหมายอัฒภาค:

$ time node lodashx100.js
node lodashx100.js  2.34s user 1.30s system 99% cpu 3.664 total
$ time node lodashx100s.js
node lodashx100s.js  2.34s user 1.15s system 99% cpu 3.521 total

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

การเลือกแบบแผนการเขียนโปรแกรมก็เหมือนกับการเลือกภาษาย่อยของภาษาเป้าหมาย เราทุกคนทำสิ่งนี้ด้วยเหตุผลปกติ: ความสามารถในการอ่านรหัสการบำรุงรักษาความมั่นคงความสะดวกในการพกพา ฯลฯ - ในขณะที่อาจเสียสละความยืดหยุ่น เหตุผลเหล่านี้เป็นเหตุผลทางธุรกิจที่แท้จริง

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

ในกรณีของฉันฉันต้องเร่งความเร็วใน JavaScript อย่างรวดเร็วดังนั้นการใช้ประโยชน์จากเซตย่อยของภาษาก็เพื่อประโยชน์ของฉัน ดังนั้นฉันเลือกชุดย่อย JSLint ของ JavaScript เปิดแอป Rockstar JSLinter ใน Eclipse เป็นการตั้งค่าที่เข้มงวดที่สุดที่ฉันสามารถทำได้และไม่ได้มองย้อนกลับไป

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

แน่นอนสิ่งที่สำคัญที่สุดเกี่ยวกับการประชุมคือความมั่นคงและคิดว่ามันเป็นส่วนย่อยภาษาช่วยเสริมความจำเป็นนี้ และแม้ว่าสิ่งนี้อาจไม่ได้ช่วยตอบคำถามของ OP แต่ฉันคิดว่ามันอาจช่วยในการกำหนดกรอบการปฏิบัติของมัน

ค่อนข้างคำถามเก่า แต่ฉันประหลาดใจไม่มีใครพูดถึง:

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

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

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

ทำไมวันนี้ถึงได้รับความนิยมมากขึ้น

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

มีเหตุผลที่ดีที่จะเก็บไว้

พวกเขาไม่ได้เป็นตัวเลือกจริง ๆ JS สามารถเพิ่มพวกเขากลับมาด้วยการแทรกอัฒภาคอัตโนมัติเมื่อพวกเขาหายไป แต่นั่นไม่ใช่สิ่งเดียวกัน

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

JSLint ไม่อนุมัติ

JavaScript ไม่ต้องการเซมิโคลอนเพื่อยกเลิกข้อความในรอบกว่าทศวรรษ นั่นเป็นเพราะตัวละครขึ้นบรรทัดใหม่ถือเป็นการยกเลิกงบ มันสมเหตุสมผลมากโดยเฉพาะอย่างยิ่งเนื่องจากไม่มีเหตุผลที่ดี [ที่ฉันรู้] ว่าทำไม JavaScript จึงต้องใช้เซมิโคลอนบ่อยๆ แต่ไม่ใช่ภาษาอื่นที่ตีความเช่น Ruby หรือ Python

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

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

ฟังดูดีกว่าอะไรสำหรับคุณ; การตัดสินใจอย่างชาญฉลาดหรือการตัดสินใจแบบคนตาบอด / ความคิดในการต้อนฝูงสัตว์?

ฉันมีสองทฤษฎี:

A)

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

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

B)

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

(NB ฉันไม่เห็นด้วยกับความคิดของการละเว้นบางสิ่งบางอย่างที่ทำให้เข้าใจผิดคำสั่ง)

ฉันไม่ปล่อยให้พวกเขาออก แต่ฉันเปลี่ยนกฎเมื่อจะแทรกพวกเขา

กฎที่คนส่วนใหญ่ใช้คือ

• ก่อนสิ้นสุดแต่ละบรรทัด
• ยกเว้นบรรทัดที่ลงท้ายด้วย}คำสั่งที่มาจากฟังก์ชัน
• แต่เพียงคำสั่งฟังก์ชั่นไม่ได้กำหนดให้กับตัวอักษรฟังก์ชั่น

กฎของฉันคือ: ที่จุดเริ่มต้นของทุกบรรทัดเดียวเริ่มต้นด้วยวงเล็บปีกกาเปิด / วงเล็บ

การขุดของฉันนั้นง่ายกว่าดังนั้นง่ายต่อการติดตามและไม่เกิดข้อผิดพลาด ด้วยจำนวนเซมิโคลอนที่ต่ำทำให้ง่ายต่อการค้นหาข้อบกพร่องที่เกิดจากการปล่อยทิ้งไว้

อีกเหตุผลคือreturn\nvalueข้อผิดพลาดที่น่าอับอายมาจากการไม่รู้เกี่ยวกับ ASI กฎของฉันบังคับให้คุณรู้เกี่ยวกับ ASI ดังนั้นคนที่ใช้กฎของฉันมีโอกาสน้อยที่จะตกหลุมพรางของข้อผิดพลาดนั้น

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