-
ตามที่คุณสามารถจินตนาการได้ มีหลายวิธีในการเรียกใช้ฟังก์ชันที่ไม่ระบุชื่อทันที โดยสรุป มีสามวิธีทั่วไป (มีวิธีอื่น โปรดแจ้งให้เราทราบ):
วิธีที่หนึ่ง
(การทำงาน() {
-
-
วิธีที่ 2
ฟังก์ชั่นเป็นโมฆะ () {
-
-
วิธีที่สาม
~ฟังก์ชั่น() {
-
-
คุณอาจเคยเห็นวิธีที่ 1 และวิธีที่ 2 แล้ว ที่นี่เราจะอธิบายวิธีที่ 3 เป็นหลัก ก่อนที่จะอธิบายวิธีที่สาม ตอนนี้เราจะตรวจสอบคำจำกัดความของตัวดำเนินการ "~" (การปฏิเสธบิต) ใน EMCAScript (หน้า 72 ของฉบับที่ 5) ซึ่งเป็นคำแปลง่ายๆ:
แปลงค่าเก่าเป็นจำนวนเต็ม 32 บิตโดยการรวมคำสั่งกับตัวดำเนินการ ดำเนินการคำสั่งหลังตัวดำเนินการและแปลงบรรทัดผลลัพธ์เป็นจำนวนเต็ม 32 บิตและส่งคืน
ตามที่เข้าใจได้จากข้างต้น อันที่จริงแล้ว ตัวดำเนินการระดับบิตสามารถส่งคืนค่าของนิพจน์ต่อไปนี้ได้ทันที ในความเป็นจริง ตัวดำเนินการระดับบิตอื่นๆ สามารถบรรลุวัตถุประสงค์นี้ได้ ตัวอย่างเช่น:
!การทำงาน() {
-
-
ฯลฯ สามารถบรรลุเป้าหมายของเราได้ ดังนั้นจึงไม่มีเหตุผลอื่นในการใช้ "~" เพียงว่าโค้ด "ดูดี" :^)
ประสิทธิภาพไม่ใช่ประสิทธิภาพของการดำเนินการฟังก์ชันที่ไม่ระบุชื่อมากนักในสามวิธี แต่จะเป็นการดีกว่าถ้าวิเคราะห์ประสิทธิภาพการดำเนินการของผู้ปฏิบัติงานแต่ละรายโดยตรง ลองมาเปรียบเทียบและดูคำจำกัดความของ "()" และ "โมฆะ" ในข้อกำหนด EMCA
ผู้ดำเนินการกลุ่ม (ฉบับที่ 5 หน้า 66)
ส่งกลับผลลัพธ์การดำเนินการของนิพจน์
เป็นโมฆะ (หน้า 70 ฉบับที่ 5)
การรวมคำสั่งกับตัวดำเนินการจะส่งคืนไม่ได้กำหนด
เนื่องจากตัวดำเนินการกลุ่มจำเป็นต้องดำเนินการคำสั่งและส่งกลับค่าที่ส่งคืนโดยบล็อกคำสั่ง เมื่อเปรียบเทียบกับ void จะมีการดำเนินการหลายอย่างเพื่อรับบล็อกคำสั่ง (แม้ว่าจะไม่ได้ใช้ประสิทธิภาพมากนัก) ดังนั้นในกรณีนี้ ประสิทธิภาพ ของ void ดีกว่าตัวดำเนินการกลุ่ม
เมื่อเปรียบเทียบทั้งสองวิธีแล้ว การเปรียบเทียบประสิทธิภาพของวิธีที่สามจะต่ำกว่าสองวิธีแรกอย่างเห็นได้ชัด โดยสรุป จากมุมมองทางไวยากรณ์ ในบรรดาวิธีฟังก์ชันที่ไม่ระบุชื่อสามวิธีข้างต้น วิธีที่สองดีกว่าวิธีที่หนึ่ง และวิธีที่สามมีประสิทธิภาพน้อยที่สุด
สรุปและคิดถึงข้อดีระหว่างทั้งสาม
วิธีที่ 1 เป็นวิธีที่ใช้กันทั่วไปและปลอดภัย ดังนั้นจึงไม่มีใครตำหนิคุณที่ใช้วิธีนี้ อย่างไรก็ตาม นักเรียนที่ใช้วิธีที่ 1 มักจะทำให้ "ปัญหา" ของการลืมจับคู่วงเล็บเหลี่ยม (โดยเฉพาะเมื่อบล็อกคำสั่งยาวมาก ฉัน มักจะเข้าใจผิด)
การใช้ตัวดำเนินการระดับบิตเพื่อเรียกใช้ฟังก์ชันที่ไม่ระบุตัวตนนั้นทันสมัยมากและถูกใช้เพื่อให้ดูดี IDE จำนวนมาก (เช่น IDEA) และเครื่องมือเน้นไวยากรณ์ไม่รองรับการเขียนแบบที่สาม
void นั้นมีประสิทธิภาพมากที่สุด แต่ก็มักจะรู้สึกป่องมากเมื่อเทียบกับการใช้งานอีกสองแบบ (เพิ่มอักขระอีกสองสามตัว?)
ดังนั้น
เมื่อพิจารณาถึงจำนวนโค้ดและประสิทธิภาพแล้ว มันถูกต้องที่จะใช้วิธีที่หนึ่งในกรณีที่จำเป็นต้องบันทึกโค้ดเพิ่มเติม และใช้วิธีที่ 3 เพื่อให้ความสำคัญกับประสิทธิภาพ จากนั้นผมอยากจะอธิบายการใช้วิธีที่ 2 ที่นี่ ความจริงแล้วความแตกต่างในประสิทธิภาพระหว่างทั้งสามวิธีนั้นน้อยมาก ดังนั้นจึงแทบจะป้องกันไม่ได้ที่จะใช้วิธีการนั้นโดยพิจารณาจากประสิทธิภาพเพียงอย่างเดียว
แผนเฉพาะที่จะนำมาใช้จะต้องได้รับการพิจารณาตามสถานการณ์จริง เช่น ผมมักจะใช้วิธีที่ 3 เพราะ 1. สะดวก (เพิ่มแค่ 1 ตัวอักษร) 2. วงเล็บที่ตรงกันเมื่อฟังก์ชันยาวจะทำให้เวียนหัว 3. ใช้ก็เก๋ แต่วิธีที่ 3 มักทำให้ผมต้องดู Code สมาชิกในทีม มีปัญหา
หากคุณมีโค้ดพื้นฐานตามเฟรมเวิร์ก เช่น ไลบรารีคลาสบางคลาส การใช้วิธีที่ 1 เป็นวิธีที่ปลอดภัยและง่ายที่สุดสำหรับทุกคนที่จะเข้าใจ ดังนั้นจึงเป็นทางเลือกที่ปลอดภัยที่สุด
[ข้อความต้นฉบับ: http://www.gracecode.com/archives/3004/ ดีมาก ใครๆ ก็เรียนรู้จากมันได้