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

บทช่วยสอนนี้มีหลายวิธีในการกำหนดและเรียกใช้ฟังก์ชัน และใช้พารามิเตอร์ฟังก์ชันใน JavaScript

นิยามฟังก์ชัน

ฟังก์ชั่นถูกกำหนดหรือประกาศโดยใช้คำสำคัญฟังก์ชั่น ไวยากรณ์ของฟังก์ชันใน JavaScript มีลักษณะดังนี้:

ชื่อฟังก์ชันOfFunction() (
// รหัสที่จะดำเนินการ
}

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

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

// เรียกใช้ฟังก์ชันทักทายโดยมี "8host" เป็นอาร์กิวเมนต์
ทักทาย("8host");

ค่า 8host ถูกส่งไปยังฟังก์ชันผ่านพารามิเตอร์ชื่อ ตอนนี้พารามิเตอร์ชื่อจะแสดงค่านี้ในฟังก์ชันนี้ รหัสสำหรับไฟล์ waitUser.js มีลักษณะดังนี้:

// เริ่มต้นฟังก์ชันการทักทายแบบกำหนดเอง
ฟังก์ชั่น ทักทาย(ชื่อ) (
console.log(`สวัสดี $(ชื่อ)!`);
}
// เรียกใช้ฟังก์ชันทักทายโดยมี "8host" เป็นอาร์กิวเมนต์
ทักทาย("8host");

เมื่อคุณรันโปรแกรมนี้ คุณจะได้ผลลัพธ์ดังต่อไปนี้:

ตอนนี้คุณรู้วิธีใช้ฟังก์ชันซ้ำแล้ว

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

ส่งกลับค่า

คุณสามารถใช้พารามิเตอร์มากกว่าหนึ่งตัวในฟังก์ชันได้ คุณสามารถส่งค่าหลายค่าไปยังฟังก์ชันและส่งกลับค่าได้ ตัวอย่างเช่น สร้างไฟล์ sum.js และประกาศฟังก์ชันในไฟล์ที่จะค้นหาผลรวมของสองค่า นั่นคือ x และ y

// เริ่มต้นฟังก์ชันเพิ่ม
เพิ่มฟังก์ชัน(x, y) (
กลับ x + y;
}

เพิ่ม(9, 7);

รหัสนี้กำหนดฟังก์ชันด้วยพารามิเตอร์ x และ y ฟังก์ชั่นจะได้รับค่า 9 และ 7 รันโปรแกรม:

โปรแกรมจะเพิ่มค่าผลลัพธ์ 9 และ 7 และส่งคืนผลลัพธ์ 16

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

นิพจน์ฟังก์ชัน

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

ใช้ฟังก์ชันก่อนหน้าเพื่อนำค่าผลลัพธ์ไปใช้กับตัวแปรผลรวม

// กำหนดฟังก์ชันเพิ่มให้กับผลรวมคงที่
const sum = เพิ่มฟังก์ชัน(x, y) (
กลับ x + y;
}
// เรียกใช้ฟังก์ชันเพื่อค้นหาผลรวม
ผลรวม(20, 5);
25

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

// กำหนดฟังก์ชันให้รวมค่าคงที่
ผลรวม const = ฟังก์ชัน(x, y) (
กลับ x + y;
}
// เรียกใช้ฟังก์ชันเพื่อค้นหาผลรวม
ผลรวม(100, 3);
103

ตอนนี้ฟังก์ชันไม่มีชื่ออีกต่อไป แต่กลายเป็นแบบไม่ระบุชื่อ

นิพจน์ฟังก์ชันที่มีชื่อสามารถใช้สำหรับการดีบักได้

ฟังก์ชั่นลูกศร

จนถึงขณะนี้ ฟังก์ชันต่างๆ ได้รับการกำหนดโดยใช้คีย์เวิร์ดของฟังก์ชัน อย่างไรก็ตาม มีวิธีที่ใหม่กว่าและรัดกุมมากขึ้นในการกำหนดฟังก์ชัน - ฟังก์ชันลูกศร ECMAScript 6 ฟังก์ชันลูกศรแสดงด้วยเครื่องหมายเท่ากับ ตามด้วยเครื่องหมายมากกว่า: =>

ฟังก์ชันลูกศรจะไม่ระบุชื่อเสมอและเป็นประเภทของนิพจน์ฟังก์ชัน ลองสร้างฟังก์ชันลูกศรพื้นฐานเพื่อหาผลรวมของตัวเลขสองตัว

// กำหนดฟังก์ชันการคูณ
const คูณ = (x, y) => (
กลับ x * y;
}

คูณ(30, 4);
120

แทนที่จะเขียนฟังก์ชัน คุณสามารถใช้สัญลักษณ์ => ได้

หากฟังก์ชันมีพารามิเตอร์เพียงตัวเดียว สามารถละเว้นวงเล็บได้ ในตัวอย่างต่อไปนี้ ฟังก์ชันกำลังสอง x ดังนั้นจึงต้องการเพียงตัวเลขเดียวเป็นอาร์กิวเมนต์

// กำหนดฟังก์ชันสี่เหลี่ยม
สแควร์ const = x => (
กลับ x * x;
}
// เรียกใช้ฟังก์ชันเพื่อค้นหาผลิตภัณฑ์
สี่เหลี่ยมจัตุรัส(8);
64

บันทึก: หากฟังก์ชันลูกศรไม่มีพารามิเตอร์ คุณจะต้องเพิ่มวงเล็บว่าง ()

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

// กำหนดฟังก์ชันสี่เหลี่ยม
สแควร์ const = x => x * x;
// เรียกใช้ฟังก์ชันเพื่อค้นหาผลิตภัณฑ์
สี่เหลี่ยมจัตุรัส(10);
100

บทสรุป

บทช่วยสอนนี้จะแนะนำให้คุณรู้จักกับการประกาศฟังก์ชัน นิพจน์ฟังก์ชัน และ ฟังก์ชั่นลูกศรส่งคืนค่าและกำหนดค่าฟังก์ชันให้กับตัวแปร

ฟังก์ชันคือกลุ่มของโค้ดที่ส่งคืนค่าหรือดำเนินการ

แท็ก:

ตัวแปรและค่าคงที่ใน JavaScript การประกาศตัวแปรและการกำหนดค่าให้กับตัวแปรเหล่านั้น ตัวแปรโกลบอลและโลคัล การใช้ค่าคงที่

การประกาศตัวแปรใน JavaScript

ชื่อตัวแปรใน JavaScript สามารถประกอบด้วยตัวอักษร ตัวเลข เครื่องหมาย $ และเครื่องหมาย _ และชื่อตัวแปรไม่สามารถขึ้นต้นด้วยตัวเลขได้ โปรดทราบว่า JavaScript คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ และตัวแปร a1 และ A1 เป็นตัวแปรที่แตกต่างกัน ไม่แนะนำให้ใช้ Cyrillic แม้ว่าจะเป็นไปได้ก็ตาม
ตัวแปรใน JavaScript ได้รับการประกาศด้วยคำสำคัญ var:

วาร์ เปเรเมนนายา_1 วาร์ เปเรเมนนายา_2

ไม่แนะนำให้ใช้ตัวแปรใน JavaScript โดยไม่มีการประกาศ สิ่งนี้เป็นไปได้ แต่อาจทำให้เกิดข้อผิดพลาดได้

การกำหนดค่าให้กับตัวแปร

การกำหนดค่าให้กับตัวแปรที่ประกาศใน JavaScript:

Peremennaya_1 = 25 Peremennaya_2 = "ข้อความที่กำหนดอยู่ในเครื่องหมายคำพูดตรง"

คุณสามารถกำหนดค่าให้กับตัวแปรได้ทันทีเมื่อมีการประกาศ:

Var Peremennaya_1 = 25 var Peremennaya_2 = "ข้อความที่กำหนดอยู่ในเครื่องหมายคำพูดตรง"

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

ตัวแปรท้องถิ่นและระดับโลก

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

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

ค่าคงที่ใน JavaScript

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

วาร์ DRUG_CHELOVEKA = "สุนัข"

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

ใน JavaScript ค่าคงที่สามารถเขียนใหม่เป็นตัวแปรได้ แต่ถ้าคุณทำเช่นนี้ ความหมายของค่าคงที่จะหายไป

ในบทความนี้คุณจะได้เรียนรู้วิธีการพิจารณา ค่าคงที่ใน JavaScript โดยใช้คีย์เวิร์ด const.

อีเอส6จัดเตรียมวิธีใหม่ในการประกาศค่าคงที่โดยใช้คำหลัก ค่าคงที่- คำสำคัญ ค่าคงที่สร้างการอ้างอิงถึงค่าแบบอ่านอย่างเดียว

ค่า VARIABLE_NAME = ค่า;

ตามข้อตกลง ตัวระบุคงที่ของ JavaScript เป็นตัวพิมพ์ใหญ่.

คำสำคัญ ค่าคงที่ดูเหมือนกุญแจ คำว่าปล่อยให้โดยจะสร้างตัวแปรที่มีขอบเขตบล็อกแต่ค่าจะถูกประกาศด้วย const ไม่สามารถเปลี่ยนแปลงได้.

ตัวแปรที่ประกาศด้วยคำสำคัญ อนุญาตเป็น เปลี่ยนแปลงได้- ซึ่งหมายความว่าคุณสามารถเปลี่ยนค่าได้ตลอดเวลา ดังที่แสดงในตัวอย่างต่อไปนี้

ให้วี = 10;
โวลต์ = 20;
วี = วี + 5;
console.log(วี); // 35

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

ภาษีคงที่ = 0.1;
ภาษี = 0.2 ; //ประเภทข้อผิดพลาด

นอกจากนี้ ตัวแปรที่ถูกประกาศโดยใช้คำสำคัญ คอนสตรัค,จะต้องเริ่มต้นด้วยค่าทันที ตัวอย่างต่อไปนี้เรียก ข้อผิดพลาดทางไวยากรณ์(ข้อผิดพลาดทางไวยากรณ์) เนื่องจากไม่มีตัวเริ่มต้นในการประกาศตัวแปรคงที่

คอนสต์สีแดง; // SyntaxError

ดังที่ได้กล่าวไปแล้ว เช่นเดียวกับการประกาศตัวแปรด้วยคีย์เวิร์ด อนุญาตตัวแปรที่ประกาศด้วยคีย์เวิร์ด คอนสตรัค,มีขอบเขตบล็อก

เพียงเท่านี้ในบทความหน้าเราจะพูดถึงการใช้คำหลัก ค่าคงที่ด้วยตัวอักษรวัตถุใน จาวาสคริปต์.

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

ตัวแปรได้รับชื่อเนื่องจากค่าสามารถเปลี่ยนแปลงได้ระหว่างการทำงานของโปรแกรม

ค่าคงที่

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

ก่อนจึงจะสามารถใช้ค่าคงที่ได้ จะต้องประกาศค่าคงที่เสียก่อน ค่าคงที่ถูกประกาศโดยใช้คีย์เวิร์ด const ตามด้วยชื่อของค่าคงที่ เพื่อแยกแยะค่าคงที่จากตัวแปรในโค้ดโปรแกรม มีการตกลงที่จะตั้งชื่อค่าคงที่ที่เขียนด้วยตัวพิมพ์ใหญ่:

ค่าคอนต์สูงสุด = 10;

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

เหตุใดจึงจำเป็นต้องมีตัวแปรและค่าคงที่?

ตัวแปรและค่าคงที่ช่วยคุณได้ รหัสโปรแกรมชัดเจนยิ่งขึ้น ลองดูตัวอย่างเล็กๆ น้อยๆ:

ราคารวม = 2.42 + 4.33; // ราคารวม

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

ราคารวม = ราคาขนม + ราคาน้ำมัน;

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

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

ขอบเขตของค่าคงที่

กฎเดียวกันนี้ใช้กับค่าคงที่เช่นเดียวกับตัวแปรที่ประกาศด้วยคีย์เวิร์ด let:

ค่าคอนต์สูงสุด = 5; // ค่าคงที่โกลบอล ( const MAX = 10; // บล็อกค่าคงที่ console.log(MAX); // 10 ) console.log(MAX); // 5 foo(); // 15 console.log(สูงสุด); // 5 ฟังก์ชั่น foo() ( const MAX = 15; // ค่าคงที่เฉพาะที่ console.log(MAX); )

ค่าคงที่และประเภทอ้างอิง

เมื่อกำหนดค่าคงที่ให้กับประเภทการอ้างอิง การอ้างอิงไปยังค่านั้นจะไม่เปลี่ยนรูป และตัวค่าเองจะยังคงเปลี่ยนแปลงได้:

Const obj = (a: 5); วัตถุ a = 10; console.log(obj.a); // 10

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

ตัวอย่างการประกาศค่าคงที่โดยใช้ตัวแปร:

var DAYSINWEEK = 7;

var DAYSINWEEK = 7 ;

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

จาวาสคริปต์ เริ่มต้นอย่างรวดเร็ว

const วันในสัปดาห์ = 7;

const วันในสัปดาห์ = 7 ;

และตอนนี้ DAYSINWEEK สามารถเข้าถึงได้ในรูปแบบตัวแปร แต่คุณจะไม่สามารถเปลี่ยนค่าของมันได้:

console.log(วันสัปดาห์); > 7 วันทำการ = 8; > ข้อผิดพลาด

คอนโซล บันทึก (วันในสัปดาห์); วันในสัปดาห์ = 8 ; > ข้อผิดพลาด

เมื่อมีการประกาศค่าคงที่แล้ว (ค่าคงที่ต้องเริ่มต้นด้วยคีย์เวิร์ด const ตามด้วยชื่อค่าคงที่ที่เป็นไปตามกฎการตั้งชื่อตัวแปร) ชื่อนั้นจะถูกสงวนไว้: คุณไม่สามารถตั้งชื่อตัวแปรได้อีกต่อไป DAYSINWEEK และมีค่าคงที่ที่มีชื่อเดียวกันนั้น หรือในทางกลับกัน

คำหลัก const มี การสนับสนุนที่ดีในเบราว์เซอร์สมัยใหม่: IE11 และ Spartan, Firefox 31+, Opera 12+, Safari 5.1.7+, iOS 7 และสูงกว่า พร้อมด้วย Chrome 36+ อย่างไรก็ตาม มีคำเตือนที่สำคัญบางประการ:

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

จาวาสคริปต์ เริ่มต้นอย่างรวดเร็ว

เรียนรู้พื้นฐานของ JavaScript พร้อมตัวอย่างวิธีสร้างเว็บแอปพลิเคชันแบบลงมือปฏิบัติจริง

ค่าคงที่ไม่ได้ถูกสร้างขึ้น พื้นที่ใหม่การมองเห็นใน Webkit เหล่านั้น. ค่าคงที่สามารถมองเห็นได้นอกขอบเขตปัจจุบัน

Firefox 35 และต่ำกว่าช่วยให้คุณเปลี่ยนค่าของ const ได้ทันที สิ่งนี้ได้รับการแก้ไขแล้วใน Firefox 36+

ควรสังเกตว่าปัญหากับ Webkit จะเกิดขึ้นเฉพาะในกรณีที่ไม่ได้ใช้โหมดเข้มงวด (ซึ่งจะกล่าวถึงในบทความต่อๆ ไป)

ตอนนี้เป็นไปได้ไหมที่จะใช้คีย์เวิร์ด const ในโครงการจริง?

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

ตัวเลือกที่ 1: ใช้ transpiler (“transpiler”)

ตามชื่อที่แนะนำ Transpilers จะแปลงโค้ดของคุณ ณ เวลาคอมไพล์เป็นภาษาอื่น: ในกรณีนี้ จากเวอร์ชันของข้อกำหนด ES6 (ซึ่งแนะนำคีย์เวิร์ด const) เป็น ES5 ซึ่งจะทำให้คุณสามารถเขียนโค้ดได้มากขึ้น เวอร์ชั่นใหม่ภาษา แต่โครงการจริงจะใช้เวอร์ชันที่เข้ากันได้กับเบราว์เซอร์ที่หลากหลาย เอ็ดดี้ ออสมานี ประพันธ์