ประโยคการอ่านหลัก JavaScript

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

นิพจน์คำนวณค่า แต่คำสั่งทำให้เกิดอะไรขึ้น

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

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

1. คำสั่งตามเงื่อนไข: ล่าม JavaScript สามารถกำหนดได้ว่าจะดำเนินการหรือข้ามคำสั่งเหล่านี้เช่น IF และสลับคำสั่ง

2. คำสั่งวนลูป: คำสั่งที่สามารถดำเนินการซ้ำ ๆ ได้เช่นในขณะที่และสำหรับคำสั่ง

3. คำสั่งกระโดด: คุณสามารถปล่อยให้ล่ามกระโดดไปยังส่วนอื่น ๆ ของโปรแกรมเพื่อดำเนินการดำเนินการต่อไปเช่นการหยุดพักการส่งคืนและการโยนงบ

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

1. คำสั่งการแสดงออก

คำสั่งการมอบหมายเป็นคำสั่งการแสดงออกที่ค่อนข้างสำคัญ ฟังก์ชั่นของพวกเขาคือการเปลี่ยนค่าของตัวแปรเช่นเดียวกับการดำเนินการคำสั่งการกำหนด: ตัวอย่างเช่น

การคัดลอกรหัสมีดังนี้:

ทักทาย = "สวัสดี" + ชื่อ;

i *= 3;

ตัวดำเนินการที่เพิ่มขึ้น (++) และตัวดำเนินการลดลง (-) เกี่ยวข้องกับคำสั่งการกำหนด ฟังก์ชั่นของพวกเขาคือการเปลี่ยนค่าของตัวแปรเช่นเดียวกับการดำเนินการคำสั่งการกำหนด

การคัดลอกรหัสมีดังนี้:

เคาน์เตอร์ ++;

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

การคัดลอกรหัสมีดังนี้:

ลบวัว;

การเรียกใช้ฟังก์ชันเป็นอีกประเภทสำคัญของคำสั่งนิพจน์

การคัดลอกรหัสมีดังนี้:

การแจ้งเตือน (ทักทาย);

window.close ();

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

Math.cos (x);

เพื่อให้ได้ค่าโคไซน์คุณต้องกำหนดให้กับตัวแปรเพื่อให้สามารถใช้ค่านี้ในอนาคต:

var cx = math.cos (x);

อีกครั้งรหัสแต่ละบรรทัดจะลงท้ายด้วยเครื่องหมายอัฒภาค

2. คำสั่งผสมและงบว่างเปล่า

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

การคัดลอกรหัสมีดังนี้:

-

x = math.pi;

cx = math.cos (x);

console.log ("cos (π) =" + cx);

-

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

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

ประการที่สาม JavaScript ไม่มีขอบเขตระดับบล็อกและตัวแปรที่ประกาศในบล็อกคำสั่งไม่ได้เป็นของเอกชนโดยบล็อกคำสั่ง (อ้างถึงส่วนแรกของบทที่ 3, 10)

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

ใน JavaScript เมื่อคุณต้องการให้ใช้คำสั่งหลายคำเป็นคำสั่งหนึ่งคำสั่งให้ใช้คำสั่งที่สอดคล้องกันแทน คำสั่งที่ว่างเปล่า (คำสั่งว่างเปล่า) ตรงข้ามกันมันอนุญาตให้มีคำสั่ง 0 คำสั่งที่ว่างเปล่ามีลักษณะเช่นนี้:

;//อัฒภาค

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

การคัดลอกรหัสมีดังนี้:

// เริ่มต้นอาร์เรย์ก

สำหรับ (i = 0; i <a.length; a [i ++] = 0);

ในลูปนี้การดำเนินการทั้งหมดจะเสร็จสมบูรณ์ในนิพจน์ A [i ++] = 0 และไม่จำเป็นต้องใช้ร่างกายลูปที่นี่ อย่างไรก็ตาม JavaScript ต้องการให้ร่างกายลูปมีคำสั่งอย่างน้อยหนึ่งคำสั่งดังนั้นมีเพียงเซมิโคลอนแยกต่างหากเท่านั้นที่ใช้ที่นี่เพื่อแสดงคำสั่งที่ว่างเปล่า

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

การคัดลอกรหัสมีดังนี้:

if ((a == 0) || (b == 0)); // รหัสบรรทัดนี้ไม่ได้ทำอะไร ...

o = null; // รหัสบรรทัดนี้จะถูกเรียกใช้งานเสมอ

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

การคัดลอกรหัสมีดังนี้:

สำหรับ (i = 0; i <a.length; a [i ++] = 0) /*ว่าง* /;

3. คำแถลงการณ์

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

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

i.var

คำสั่ง VAR ใช้เพื่อประกาศตัวแปรอย่างน้อยหนึ่งตัว ไวยากรณ์ของมันมีดังนี้:

var name_1 [= value_1] [, ... , name_n [= value_n]]

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

การคัดลอกรหัสมีดังนี้:

var i; // ตัวแปรง่ายๆ

var j = 0; // ตัวแปรที่มีค่าเริ่มต้น

var p, q; // สองตัวแปร

var greet = "hello" + ชื่อ; // นิพจน์การเริ่มต้นที่ซับซ้อนมากขึ้น

var x = 2.34, y = math.cos (0.75), r, theta; // ตัวแปรมากมาย

var x = 2, y = x * x; // ตัวแปรที่สองใช้ตัวแปรแรก

var x = 2

f = function (x) {return x * x}, // แต่ละตัวแปรมีหนึ่งแถวพิเศษ

y = f (x)

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

หากตัวแปรในคำสั่ง VAR ไม่ได้ระบุนิพจน์การเริ่มต้นค่าของตัวแปรนี้จะไม่ได้กำหนดไว้ในขั้นต้น ดังนั้นค่าของตัวแปรก่อนที่คำสั่งประกาศจะไม่ได้กำหนด

ควรสังเกตว่าคำสั่ง VAR ยังสามารถใช้เป็นส่วนประกอบของการวนรอบหรือสำหรับ/ในลูป (เช่นเดียวกับการประกาศตัวแปรที่ประกาศก่อนลูปตัวแปรที่ประกาศที่นี่จะเป็น "ขั้นสูง") ตัวอย่างเช่น:

การคัดลอกรหัสมีดังนี้:

สำหรับ (var i = 0; i <10; i ++) console.log (i);

สำหรับ (var i = 0, j = 10; i <10; i ++, j--) console.log (i * j);

สำหรับ (var i ใน o) console.log (i);

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

ii.function

ฟังก์ชั่นคำหลักใช้เพื่อประกาศฟังก์ชั่น เราได้เรียนรู้การแสดงออกของฟังก์ชั่น (4.3) คำจำกัดความของฟังก์ชั่นสามารถเขียนลงในรูปแบบของคำสั่ง ตัวอย่างเช่น: คำจำกัดความสองคำเขียนในรหัสตัวอย่างต่อไปนี้:

การคัดลอกรหัสมีดังนี้:

var f = ฟังก์ชั่น f (x) {return x + 1;} // กำหนดนิพจน์ให้กับตัวแปร

ฟังก์ชัน f (x) {return x + 1;} // ประโยคที่มีชื่อตัวแปร

ไวยากรณ์ของการประกาศฟังก์ชันมีดังนี้:

การคัดลอกรหัสมีดังนี้:

ฟังก์ชั่น funcname ([arg1 [, arg2 [... , argn]]]) {

งบ

-

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

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

การคัดลอกรหัสมีดังนี้:

ฟังก์ชั่น hyteus (x, y) {

return math.sqrt (x * x + y * y);

-

Hyteus (1, 2) //=>2.23606797749979

ฟังก์ชั่นใบหน้า (n) {// ฟังก์ชันเรียกซ้ำ

ถ้า (n <= 1) กลับ 1;

ส่งคืน n * ใบหน้า (n - 1);

-

ใบหน้า (11) // => 39916800

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

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

4. งบเงื่อนไข

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

คำสั่ง I.IF

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

การคัดลอกรหัสมีดังนี้:

ถ้า (นิพจน์)

คำแถลง

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

การคัดลอกรหัสมีดังนี้:

ถ้า (ชื่อผู้ใช้ == null) // ถ้าชื่อผู้ใช้เป็นโมฆะหรือไม่ได้กำหนด

ชื่อผู้ใช้ = "Jack Wong"; // กำหนดไว้

ควรสังเกตว่ามีความจำเป็นต้องใส่วงเล็บสวนของการแสดงออกหากคำสั่ง

JavaScript Syntax กำหนดว่าหากคำหลักและการแสดงออกด้วยวงเล็บสวนจะต้องตามด้วยคำสั่ง อย่างไรก็ตามคำสั่งหลายรายการสามารถรวมกันเป็นหนึ่งเดียวโดยใช้บล็อกคำสั่ง ดังนั้นรูปแบบของคำสั่ง IF จึงเป็นแบบนี้:

การคัดลอกรหัสมีดังนี้:

ถ้า (! ที่อยู่) {

ที่อยู่ = "";

message = "โปรดส่งที่อยู่ทางไปรษณีย์"

-

รูปแบบที่สองของคำสั่ง IF แนะนำประโยคอื่นและดำเนินการตรรกะอื่นเมื่อค่าของนิพจน์เป็นเท็จ

การคัดลอกรหัสมีดังนี้:

ถ้า (นิพจน์)

คำสั่ง 1

อื่น

คำแถลง 2

ตัวอย่างเช่นรหัสต่อไปนี้

การคัดลอกรหัสมีดังนี้:

ถ้า (n == 1)

console.log ("1 ข้อความใหม่");

อื่น

console.log ("คุณมี" + n + "ข้อความใหม่");

เมื่อใช้คำสั่ง IF/ELSE ในการใช้คำสั่ง IF ที่ซ้อนกันคุณต้องระมัดระวังเพื่อให้แน่ใจว่าคำสั่งอื่นตรงกับคำสั่งที่ถูกต้องหาก พิจารณารหัสต่อไปนี้:

การคัดลอกรหัสมีดังนี้:

i = j = 1;

k = 2;

ถ้า (i == j)

ถ้า (j == k)

console.log ("ฉันเท่ากับ k");

อื่น

console.log ("ฉันเท่ากัน J"); //ข้อผิดพลาด! -

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

การคัดลอกรหัสมีดังนี้:

ถ้า (i == j) {

ถ้า (j == k)

console.log ("ฉันเท่ากับ k");

อื่น

console.log ("ฉันเท่ากัน J");

-

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

การคัดลอกรหัสมีดังนี้:

ถ้า (i == j) {

ถ้า (j == k) {

console.log ("ฉันเท่ากับ k");

} else {// crape braces ทำให้ผลลัพธ์ของรหัสชัดเจนขึ้น

console.log ("ฉันเท่ากัน J");

-

-

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

ii.else ถ้า

คำสั่ง IF/ELSE เลือกหนึ่งในสองสาขาโดยการตัดสินผลการคำนวณของนิพจน์ ฉันควรทำอย่างไรเมื่อมีหลายสาขาในรหัส? ทางออกหนึ่งคือการใช้คำสั่งอื่น ๆ อย่างอื่นถ้าไม่ใช่คำสั่ง JavaScript จริงมันเป็นเพียงวิธีการเขียนคำสั่งหลายรายการ if/else ด้วยกัน

การคัดลอกรหัสมีดังนี้:

ถ้า (n == 1) {

// ดำเนินการบล็อกรหัส 1

} อื่นถ้า (n == 2) {

// ดำเนินการบล็อกรหัส 2

} อื่นถ้า (n == 3) {

// ดำเนินการบล็อกรหัส 3

} อื่น {

// เงื่อนไขก่อนหน้าเป็นเท็จจากนั้นบล็อกรหัส 4 จะถูกดำเนินการ

-

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

III.Switch

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

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

การคัดลอกรหัสมีดังนี้:

สวิตช์ (นิพจน์) {

งบ

-

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

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

คำสั่งสวิตช์นั้นง่ายมากที่จะสับสนและการแนะนำพร้อมตัวอย่างจะชัดเจนขึ้น คำสั่งสวิตช์ต่อไปนี้เทียบเท่ากับคำสั่ง IF/ELSE ในขณะนี้

การคัดลอกรหัสมีดังนี้:

สวิตช์ (n) {

กรณีที่ 1: // ถ้า n === 1 เริ่มจากที่นี่

// ดำเนินการบล็อกรหัส 1

หยุดพัก;

กรณีที่ 2:

// ดำเนินการบล็อกรหัส 2

หยุดพัก;

กรณีที่ 3:

// ดำเนินการบล็อกรหัส 3

หยุดพัก;

ค่าเริ่มต้น:

// ดำเนินการบล็อกรหัส 4

หยุดพัก;

-

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

คำสั่งต่อไปนี้ใกล้เคียงกับการต่อสู้จริงและจะแปลงค่าเป็นสตริงตามประเภทของค่า

การคัดลอกรหัสมีดังนี้:

ฟังก์ชั่นแปลง (x) {

สวิตช์ (typeof x) {

กรณี 'หมายเลข': // แปลงหมายเลขเป็น hexadecimal

กลับ X.ToString (16);

กรณี 'สตริง':

return '"' + x + '"'; // ส่งคืนสองสตริงด้วยคำพูดสองเท่า

ค่าเริ่มต้น: // ใช้วิธีการทั่วไปเพื่อแปลงประเภทอื่น ๆ

return String (x);

-

-

console.log (แปลง (100255114)) // => 5f9c58a

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

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

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

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

5. วนรอบ

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

ฉันในขณะที่

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

การคัดลอกรหัสมีดังนี้:

ในขณะที่ (นิพจน์)

คำแถลง

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

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

การคัดลอกรหัสมีดังนี้:

count var = 0;

ในขณะที่ (นับ <10) {

console.log (นับ);

นับ ++;

-

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

ii.do/ ในขณะ

DO/ในขณะที่ลูปคล้ายกับลูปในขณะที่มันตรวจพบการแสดงออกของลูปที่หางของลูปมากกว่าที่ด้านบนซึ่งหมายความว่าร่างกายลูปถูกดำเนินการอย่างน้อยหนึ่งครั้ง ไวยากรณ์ของ DO/ในขณะที่ลูปมีดังนี้:

การคัดลอกรหัสมีดังนี้:

ทำ

คำแถลง

ในขณะที่ (แสดงออก);

ทำ/ในขณะที่ลูปไม่ได้ใช้กันทั่วไปเหมือนลูป นี่เป็นเพราะมันไม่ธรรมดาในทางปฏิบัติที่ต้องการดำเนินการลูปอย่างน้อยหนึ่งครั้ง นี่คือตัวอย่างของการทำ/ในขณะลูป

การคัดลอกรหัสมีดังนี้:

ฟังก์ชั่น printarray (a) {

var len = a.length,

i = 0;

ถ้า (len == 0)

console.log ("อาร์เรย์ว่าง");

อื่น

ทำ {

console.log (a [i]);

} ในขณะที่ (++ i <len);

-

PrintArray ([1,5,2,6])

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

iii.for

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

การคัดลอกรหัสมีดังนี้:

สำหรับ (เริ่มต้น; ทดสอบ; เพิ่มขึ้น)

คำแถลง

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

วิธีที่ง่ายที่สุดในการอธิบายวิธีการทำงานของลูปคือการแสดงรายการเทียบเท่าในขณะที่ลูป

การคัดลอกรหัสมีดังนี้:

เริ่มต้น

ในขณะที่ (ทดสอบ) {

คำแถลง

เพิ่มขึ้น;

-

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

ข้างต้นในขณะที่ลูปสามารถเขียนได้โดยใช้ A for loop

การคัดลอกรหัสมีดังนี้:

สำหรับ (var count = 0; count <10; count ++)

console.log (นับ)

แน่นอนว่าลูปบางตัวมีความซับซ้อนมากขึ้นและตัวแปรหลายตัวจะวนซ้ำในเวลาในลูป ใน JavaScript กรณีนี้จะต้องใช้กับตัวดำเนินการเครื่องหมายจุลภาคซึ่งรวมการแสดงออกการเริ่มต้นและการแสดงออกของ autoincrement ลงในนิพจน์เดียวเพื่อใช้ใน A for loop

การคัดลอกรหัสมีดังนี้:

var i, j;

สำหรับ (i = 0, j = 10; i <10; i ++, j--)

console.log (i * j);

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

การคัดลอกรหัสมีดังนี้:

ฟังก์ชันหาง (o) {// ส่งคืนวัตถุโหนดสุดท้ายของรายการที่เชื่อมโยง

สำหรับ (; o.next; o = o.next) /*ว่าง* /// ดำเนินการ traversal โดยขึ้นอยู่กับว่า o.next เป็นค่าที่แท้จริง

กลับมา;

-

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

iiii.for/in

คำสั่ง FOR/In ใช้คำหลักสำหรับคำหลัก แต่เป็นประเภทของลูปที่แตกต่างจากแบบปกติสำหรับลูป ไวยากรณ์ของ for/in loop มีดังนี้

การคัดลอกรหัสมีดังนี้:

สำหรับ (ตัวแปรในวัตถุ)

คำแถลง

ตัวแปรมักจะเป็นชื่อตัวแปรหรือนิพจน์ที่สามารถสร้าง lvalues ​​หรือตัวแปรที่ประกาศผ่านคำสั่ง VAR อย่างไรก็ตามมันเป็นค่าที่ใช้กับด้านซ้ายของนิพจน์การกำหนด วัตถุคือนิพจน์และผลลัพธ์ของนิพจน์นี้เป็นวัตถุ ในทำนองเดียวกันคำสั่งเป็นคำสั่งหรือบล็อกของคำสั่งที่สร้างเนื้อหาของลูป

การใช้ A for loop ในการวนซ้ำผ่านองค์ประกอบอาร์เรย์นั้นง่ายมาก

การคัดลอกรหัสมีดังนี้:

var a = [1, 3, 5, "44"];

สำหรับ (var i = 0; i <a.length; i ++) // ฉันแสดงถึงดัชนีขององค์ประกอบอาร์เรย์

console.log (a [i]) // องค์ประกอบเอาต์พุตของแต่ละอาร์เรย์

For/In Loop ใช้เพื่อการสำรวจคุณสมบัติสมาชิกวัตถุอย่างสะดวกสบาย

การคัดลอกรหัสมีดังนี้:

สำหรับ (var p ใน o) // กำหนดชื่อของแอตทริบิวต์ให้กับตัวแปร p

console.log (o [p]); // ส่งออกค่าของแต่ละแอตทริบิวต์

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

ควรสังเกตว่าตราบใดที่ For/In Loop ค่าของ Varibale สามารถถือได้ว่าเป็น lvalue ของการแสดงออกที่ได้รับมอบหมายและอาจเป็นการแสดงออกใด ๆ นิพจน์นี้คำนวณทุกลูปซึ่งหมายความว่าค่าที่คำนวณอาจแตกต่างกันในแต่ละครั้งที่ลูป ตัวอย่างเช่นคุณสามารถใช้รหัสต่อไปนี้เพื่อคัดลอกคุณสมบัติวัตถุทั้งหมดลงในอาร์เรย์:

การคัดลอกรหัสมีดังนี้:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

สำหรับ (a [i ++] ใน o) /*ว่าง* /;

document.write (a) // => x, y, z

อาร์เรย์ JavaScript เป็นเพียงวัตถุพิเศษดังนั้น FOR/In Loop สามารถระบุดัชนีข้อมูลเช่นการแจกแจงคุณสมบัติของวัตถุ ตัวอย่างเช่นการเพิ่มรหัสนี้หลังจากรหัสด้านบนสามารถระบุดัชนีข้อมูล 0, 1, 2:

การคัดลอกรหัสมีดังนี้:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

สำหรับ (a [i ++] ใน o) /*ว่าง* /;

document.write (a) // => x, y, z คัดลอกคุณสมบัติวัตถุลงในอาร์เรย์

สำหรับ (ฉันอยู่ใน A)

document.write (i) // => enum data index 0 1 2

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

วัตถุสามารถสืบทอดคุณสมบัติของวัตถุอื่น ๆ และบรรทัดสืบทอดคุณสมบัติที่กำหนดเอง (6.2.ii) สามารถแจกแจงโดยใช้สำหรับ/in

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

ลำดับของการแจงนับแอตทริบิวต์

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

1. วัตถุที่สืบทอดคุณลักษณะที่ระบุได้

2. วัตถุมีคุณสมบัติของดัชนีอาร์เรย์จำนวนเต็ม

3. ใช้ลบเพื่อลบคุณสมบัติที่มีอยู่ของวัตถุ

4. ใช้ object.defineProperty () หรือวิธีการที่คล้ายกันเพื่อเปลี่ยนคุณสมบัติของวัตถุ

6. กระโดด

ใน JavaScript ประเภทของคำสั่งเป็นคำสั่ง JUMP จากความเข้าใจในคำสั่งมันสามารถทำให้การดำเนินการ JavaScript กระโดดจากตำแหน่งหนึ่งไปยังตำแหน่งเดียว

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

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

ถัดไปอธิบายคำสั่งกระโดดแต่ละครั้ง

ฉัน. คำสั่งแท็ก

คำสั่งสามารถระบุได้และฉลากประกอบด้วยตัวระบุและลำไส้ใหญ่ก่อนที่คำสั่ง:

ตัวระบุ: คำสั่ง

โดยการกำหนดแท็กสำหรับคำสั่งคุณสามารถอ้างถึงคำสั่งนี้ด้วยชื่อแท็กที่ใดก็ได้ในโปรแกรม คุณสามารถกำหนดป้ายกำกับสำหรับหลายข้อความแม้ว่าจะมีประโยชน์มากกว่าเมื่อกำหนดป้ายกำกับสำหรับบล็อกคำสั่งเช่นคำสั่งลูปหรือคำสั่งการตัดสินตามเงื่อนไข โดยการกำหนดชื่อแท็กสำหรับลูปคุณสามารถใช้ Break และดำเนินการต่อภายในวงวนเพื่อออกจากวงหรือท้าทายโดยตรงไปยังจุดเริ่มต้นของลูปถัดไป break and continue are the only statements in JavaScript that can use statement tags (this chapter will be discussed next). The following example, where the while loop defines a tag, and the continue statement uses this tag:

การคัดลอกรหัสมีดังนี้:

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

-

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

单独使用break语句的作用是立即退出最内存的循环或switch语句。它的语法如下：

หยุดพัก;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到了需要查找的数组元素，则使用break语句退出循环：

การคัดลอกรหัสมีดังนี้:

for (var i = 0; i < a.length; i++) {

if (a[i] == target) break;

-

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

break labelname;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

การคัดลอกรหัสมีดังนี้:

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

for (var y = 0; y < row.length; y++) {

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

-

-

success = true;

-

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

ดำเนินการต่อ;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1.在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2.在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3.在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4.在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

การคัดลอกรหัสมีดังนี้:

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

-

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

The return statement can only appear in the function body. If not, it will report a syntax error. When the return statement is executed, the function terminates the execution and returns the value of the expression to the calling program. ตัวอย่างเช่น:

การคัดลอกรหัสมีดังนี้:

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

The return statement can be used alone without having expression, so the function will also want to call the program to return undefined. ตัวอย่างเช่น:

การคัดลอกรหัสมีดังนี้:

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

การคัดลอกรหัสมีดังนี้:

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

return f;

-

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

การคัดลอกรหัสมีดังนี้:

พยายาม{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

-

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

-

ในที่สุด{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

-

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

การคัดลอกรหัสมีดังนี้:

พยายาม {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

-

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

การคัดลอกรหัสมีดังนี้:

พยายาม {

print("Outer try running..");

พยายาม {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} ในที่สุด {

print("Nested finally is running...");

-

} catch (e) {

print("Outer catch caught " + e);

} ในที่สุด {

print("Outer finally running");

-

// Windows Script Host 作出该修改从而得出WScript.Echo(s)

function print(s) {

document.write(s);

-

输出：

การคัดลอกรหัสมีดังนี้:

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

คำแถลง

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

การคัดลอกรหัสมีดังนี้:

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

-

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

การคัดลอกรหัสมีดังนี้:

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

การคัดลอกรหัสมีดังนี้:

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

การคัดลอกรหัสมีดังนี้:

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

-

f();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

iii.“use strict”

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

การคัดลอกรหัสมีดังนี้:

var hasStrictMode = (function() {

"use strict";

return this === undefined

-

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：