เหตุใดฉันจึงควรใช้เครื่องหมายอัฒภาคหลังจากทุกฟังก์ชันใน javascript

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

function weLikeSemiColons(arg) {
   // bunch of code
};

หรือ

function unnecessary(arg) {
  // bunch of code
}

อัฒภาคหลังจากการประกาศฟังก์ชั่นมีไม่จำเป็น

ไวยากรณ์ของ a FunctionDeclarationถูกอธิบายไว้ในข้อกำหนดดังต่อไปนี้:

function Identifier ( FormalParameterListopt ) { FunctionBody }

ไม่จำเป็นต้องใช้เครื่องหมายอัฒภาค แต่อาจสงสัยว่าทำไม

อัฒภาคทำหน้าที่ในการแยกจากกันงบจากแต่ละอื่น ๆ และFunctionDeclarationไม่ได้เป็นคำสั่ง

FunctionDeclarationsได้รับการประเมินก่อนที่รหัสจะเข้าสู่การดำเนินการการยกเป็นคำทั่วไปที่ใช้เพื่ออธิบายพฤติกรรมนี้

คำว่า "การประกาศฟังก์ชั่น" และ "คำสั่งฟังก์ชั่น" มักจะใช้แทนกันอย่างไม่ถูกต้องเพราะไม่มีคำสั่งฟังก์ชั่นที่อธิบายไว้ในข้อมูลจำเพาะ ECMAScript อย่างไรก็ตามมีการใช้งานบางอย่างที่มีคำสั่งฟังก์ชั่นในไวยากรณ์ของพวกเขา ไม่ได้มาตรฐาน

อย่างไรก็ตามควรใช้เครื่องหมายอัฒภาคในตำแหน่งที่คุณใช้FunctionExpressionsเสมอเช่น

var myFn = function () {
  //...
};

(function () {
  //...
})();

หากคุณเว้นเครื่องหมายอัฒภาคหลังจากฟังก์ชันแรกในตัวอย่างข้างต้นคุณจะได้รับผลลัพธ์ที่ไม่พึงประสงค์อย่างสมบูรณ์:

var myFn = function () {
  alert("Surprise!");
} // <-- No semicolon!

(function () {
  //...
})();

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

การบรรยายที่แนะนำ:

• การแสดงออกของฟังก์ชั่นที่ตั้งชื่อ demystified (บทความที่ดี)
• อธิบายถึงฟังก์ชั่นนิรนามที่ไม่ระบุตัวตนของ JavaScript (เพิ่มเติมเกี่ยวFunctionDeclarationกับ vs FunctionExpression)

ฉันใช้พวกเขาหลังจากประกาศฟังก์ชั่นตามตัวแปร:

var f = function() { ... };

แต่ไม่ใช่หลังจากคำจำกัดความสไตล์คลาสสิก:

function f() {
    ...
}

JS Lintเป็นแบบแผนโดยพฤตินัยและมันบอกว่าไม่มีเครื่องหมายอัฒภาคหลังจากฟังก์ชันเนื้อหา ดู"อัฒภาค"ส่วน

อยู่อย่างสม่ำเสมอ! พวกเขาไม่จำเป็น แต่ฉันใช้พวกเขาเป็นการส่วนตัวเพราะเทคนิคการแบ่งย่อยส่วนใหญ่ขึ้นอยู่กับเซมิโคลอน (ตัวอย่างเช่นPacker )

ขึ้นอยู่กับความชอบของคุณ ฉันชอบที่จะวางบรรทัดของโค้ดด้วย semi colons เพราะฉันคุ้นเคยกับ Java, C ++, C # ฯลฯ ดังนั้นฉันจึงใช้มาตรฐานเดียวกันสำหรับการเข้ารหัสใน javascript

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

เบราว์เซอร์จะทำงานด้วยวิธีใดวิธีหนึ่ง แต่บางทีสักวันหนึ่งพวกเขาอาจจะเกิดขึ้นพร้อมกับมาตรฐานที่เข้มงวดซึ่งควบคุมเรื่องนี้

ตัวอย่างของรหัสที่ฉันจะเขียน:

function handleClickEvent(e)
{
     // comment
     var something = true;  // line of code
     if (something)  // code block
     {
        doSomething();  // function call
     }
}

มันเป็นมากกว่าแค่เรื่องของการประชุมหรือความมั่นคง

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

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

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

ต้องการเครื่องหมายอัฒภาค

var x = function(){};
var x = new function(){};
this.x = function(){};

ไม่จำเป็นต้องใช้เครื่องหมายอัฒภาค

function x(){}

SIMPLE:

เป็นวิธีปฏิบัติที่ดีที่จะทิ้งเครื่องหมายอัฒภาคไว้;หลังจากสิ้นสุดฟังก์ชั่นเครื่องมือจัดฟัน พวกเขาได้รับการพิจารณาว่าเป็นแนวปฏิบัติที่ดีที่สุดมานานหลายปี

ข้อดีอย่างหนึ่งของการใช้งานอยู่ตลอดเวลาคือถ้าคุณต้องการลดขนาด JavaScript ของคุณ

ในการลดขนาดจาวาสคริปต์จะช่วยลดขนาดไฟล์ลงได้เล็กน้อย

แต่สำหรับแนวทางปฏิบัติที่ดีที่สุดและคำตอบข้างต้นไม่แนะนำให้ใช้หลังจากแท็กฟังก์ชั่น

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

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

//file one
var one=1;
var two=2;
function tryOne(){}
function trytwo(){}

และ

//file two
var one=1;
var two=2;
function tryOne(){};
function trytwo(){};

เมื่อคุณย่อขนาดทั้งสองคุณจะได้รับสิ่งต่อไปนี้เป็นเอาต์พุต

โปรดทราบว่าความคิดเห็นเป็นเพียงเพื่อความไม่พอใจ

//file one
var one=1;var two=2;function tryOne(){}
function trytwo(){}

และ

//file two
var one=1;var two=2;function tryOne(){};function trytwo(){};