Jquery หากมีตัวอย่างอื่น คำสั่งแบบมีเงื่อนไขใน Javascript - โครงสร้าง IF-ELSE - เงื่อนไขใน Javascript - พื้นฐาน แท็กรายการสัญลักษณ์แสดงหัวข้อย่อย

คำสั่งแบบมีเงื่อนไข

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

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

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

คำสั่ง if (นิพจน์)

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

ถ้า (ชื่อผู้ใช้ == null) // หากตัวแปรชื่อผู้ใช้เป็น null หรือชื่อผู้ใช้ที่ไม่ได้กำหนด = "Alex"; //กำหนดมัน

โปรดทราบว่าวงเล็บรอบนิพจน์แบบมีเงื่อนไขเป็นส่วนที่จำเป็นของไวยากรณ์คำสั่ง if

รูปแบบที่สองของคำสั่ง if จะแนะนำส่วนคำสั่ง else ที่ถูกดำเนินการเมื่อนิพจน์ประเมินว่าเป็นเท็จ ไวยากรณ์ของมันคือ:

ถ้า (นิพจน์) คำสั่ง 1 คำสั่งอื่น 2

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

ถ้า (n == 1) console.log("ได้รับข้อความใหม่ 1 ข้อความ"); else console.log("ได้รับข้อความใหม่" + n + ");

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

ถ้า (n == 1) ( // ดำเนินการบล็อก 1 ) else if (n == 2) ( // ดำเนินการบล็อก 2 ) else if (n == 3) ( // ดำเนินการบล็อก 3 ) else ( // ถ้าไม่ทั้งสอง คำสั่ง else ก่อนหน้านี้ไม่ได้ถูกดำเนินการ ให้ดำเนินการบล็อก 4)

ไม่มีอะไรพิเศษเกี่ยวกับงานชิ้นนี้ มันเป็นเพียงลำดับของคำสั่ง if โดยที่แต่ละคำสั่ง if เป็นส่วนหนึ่งของคำสั่ง else ของคำสั่งก่อนหน้า

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

คำสั่ง switch ได้รับการออกแบบมาโดยเฉพาะสำหรับสถานการณ์ดังกล่าว คีย์เวิร์ด switch ตามด้วยนิพจน์ในวงเล็บและบล็อกของโค้ดในวงเล็บปีกกา:

สวิตช์ (นิพจน์) ( คำแนะนำ )

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

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

การดำเนินการของคำสั่ง switch นั้นยากที่จะอธิบายด้วยคำพูด คำอธิบายนั้นดูชัดเจนยิ่งขึ้นด้วยตัวอย่าง คำสั่ง switch ต่อไปนี้เทียบเท่ากับคำสั่ง if/else ซ้ำที่แสดงในตัวอย่างก่อนหน้านี้:

Switch(n) ( กรณีที่ 1: // ดำเนินการถ้า n === 1 // ดำเนินการบล็อก 1 ตัวแบ่ง; // หยุดที่นี่กรณีที่ 2: // ดำเนินการหาก n === 2 // ดำเนินการบล็อก 2 ตัวแบ่ง; / / หยุด ที่นี่กรณีที่ 3: // ดำเนินการถ้า n === 3 // ดำเนินการแบ่งบล็อก 3; // หยุดที่นี่ ค่าเริ่มต้น: // หากทุกอย่างล้มเหลว... // ดำเนินการแบ่งบล็อก 4;

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

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

ด้านล่างนี้เป็นตัวอย่างการใช้งานจริงของการใช้คำสั่ง switch โดยจะแปลงค่าเป็นสตริงในลักษณะที่ขึ้นอยู่กับประเภทของค่า:

ฟังก์ชั่นแปลง(x) ( switch(typeof x) ( // แปลงตัวเลขเป็นเลขฐานสิบหก กรณี "number": return x.toString(16); // คืนสตริงที่ยกมา case "string": return """ + x + """; // ประเภทอื่น ๆ จะถูกแปลงด้วยวิธีปกติ ค่าเริ่มต้น: return x.toString(); ) ) console.log(convert(1067)); // ผลลัพธ์ "42b"

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

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

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

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

มาเริ่มเรียนรู้เกี่ยวกับคำสั่งแบบมีเงื่อนไขใน JavaScript กันดีกว่า เราจะมาดูโครงสร้าง If-Else กัน เมื่อแปลเป็นภาษารัสเซีย เงื่อนไขนี้อ่านว่า If-Then

แต่ก่อนที่เราจะเริ่มพูดถึงเงื่อนไขใน JavaScript เรามาดูกันว่าเงื่อนไขเหล่านี้เกิดขึ้นได้อย่างไรและที่ไหนในชีวิตจริง

เช่นถ้าตอนเย็นเราจะไปสวนสาธารณะ

ถ้ารถคันนี้ราคาต่ำกว่า $1,000 ฉันจะซื้อมัน ฯลฯ

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

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

เรามาลองใช้ตัวอย่างง่ายๆ ของการใช้คำสั่งแบบมีเงื่อนไข หรือใช้โครงสร้าง If-Else ใน JavaScript แทน

อันดับแรก มาดูกันว่าคำสั่ง If ทำงานอย่างไรใน JavaScript

ในการดำเนินการนี้ เราจะยกตัวอย่างก่อนแล้วจึงวิเคราะห์ด้านล่างนี้

var weather = "ชัดเจน" ; /* สร้างตัวแปร pogoda และกำหนดค่าเป็น “clear” */

if(pogoda == "clear" ) /* สร้างเงื่อนไข: ถ้า pogoda เท่ากับ "clear" - TRUE*/

( /* ที่... */

เอกสาร.write();

ฉันและครอบครัวไปสวนสาธารณะในตอนเย็น

คุณควรใส่ใจอะไรในตัวอย่างข้างต้น

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

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

หากเงื่อนไขเป็นเท็จ ดังตัวอย่างด้านล่าง เงื่อนไขที่อยู่ในเครื่องหมายปีกกา () จะไม่ถูกดำเนินการ

var weather = "มีเมฆมาก" ;

if(pogoda == "clear" ) /* ตอนนี้เงื่อนไขเป็น FALSE: pogoda ไม่เท่ากับ "clear" */

document .write ("ฉันและครอบครัวจะไปสวนสาธารณะตอนเย็น" );

นี่คือวิธีที่ตัวดำเนินการตามเงื่อนไข หากทำงาน: หากเงื่อนไขเป็น True การดำเนินการจะถูกดำเนินการ หากเป็น False การดำเนินการจะไม่ถูกดำเนินการ มันง่ายมาก

ตอนนี้เรามาพูดถึงวิธีการทำงานของโครงสร้าง If-Else ใน JavaScript อย่างอื่นแปลว่า "อย่างอื่น"

ลองกลับมาสู่ชีวิตจริงอีกครั้ง ในกรณีส่วนใหญ่ หากตรงตามเงื่อนไขใดๆ เราจะดำเนินการอย่างใดอย่างหนึ่ง หากไม่เป็นไปตามนั้น - "มิฉะนั้น" เราก็ทำอย่างอื่น

เรามาทำงานกับตัวอย่างที่ให้ไว้ก่อนหน้านี้ต่อไป

ถ้าชัดเจนตอนเย็นเราจะไปสวนสาธารณะไม่อย่างนั้น (ถ้ามีเมฆมาก)เราจะอยู่บ้านและดูทีวี

หรือถ้ารถคันนี้ราคาต่ำกว่า 1,000 เหรียญสหรัฐ ผมก็จะซื้อเป็นอย่างอื่น (ถ้าจะแพงกว่านี้.) ฉันจะไปเที่ยวด้วยเงินจำนวนนี้

JavaScript ยังมีความสามารถนี้ในการจัดหาทางเลือกอื่น ( ทำอย่างอื่น)หากไม่ตรงตามเงื่อนไข ใน JavaScript เราสามารถสร้างเงื่อนไขที่คล้ายกันได้โดยใช้โครงสร้าง If-Else ลองมาตัวอย่าง.

var weather = "มีเมฆมาก" ; /* กำหนดตัวแปร “pogoda” เป็นค่า “cloudy” */

if(pogoda == "clear") /* สร้างเงื่อนไข: ถ้า pogoda เท่ากับ "clear" - นี่เป็น TRUE */

document .write ("ฉันและครอบครัวจะไปสวนสาธารณะตอนเย็น" );

else /* มิฉะนั้น - ถ้า pogoda ไม่เท่ากับ "clear" - นี่คือ FALSE */

{
เอกสาร.write("

" + "เราอยู่บ้าน - ดูทีวี" );
}

เราอยู่บ้านดูทีวี

ลองดูตัวอย่างที่ให้มา

ดังนั้น หากเงื่อนไขเป็น True การดำเนินการตามคำสั่ง If ซึ่งอยู่ในวงเล็บปีกกา () จะถูกดำเนินการ

หากเงื่อนไขเป็นเท็จ ให้ดำเนินการดังต่อไปนี้ โอเปอเรเตอร์อื่นซึ่งอยู่ในวงเล็บปีกกา () ด้วย

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

หากต้องการรวมเนื้อหาที่ครอบคลุม “ข้อความสั่งแบบมีเงื่อนไขใน Javascript - โครงสร้าง IF-ELSE” ลองดูอีกตัวอย่างหนึ่ง

เฉพาะตอนนี้เท่านั้นที่เราใช้เงื่อนไข If-Else เมื่อทำงานกับตัวเลข

จำนวนนับ = 10 ;

if(count = 3 ) /* สร้างเงื่อนไข: ถ้าจำนวนองค์ประกอบของอาร์เรย์เพื่อนมากกว่าหรือเท่ากับ 3 ดังนั้น....*/

document .write("นี่คืออาร์เรย์ขนาดใหญ่ที่มีองค์ประกอบอย่างน้อย 3 องค์ประกอบ");

else /* อย่างอื่น... */

{
document .write ("นี่คืออาร์เรย์ขนาดเล็กที่มีองค์ประกอบน้อยกว่า 3 องค์ประกอบ" );

Reg.ru: โดเมนและโฮสติ้ง

นายทะเบียนและผู้ให้บริการโฮสติ้งที่ใหญ่ที่สุดในรัสเซีย

มีชื่อโดเมนมากกว่า 2 ล้านชื่อที่ให้บริการ

โปรโมชั่น เมลโดเมน โซลูชั่นทางธุรกิจ

ลูกค้ามากกว่า 700,000 รายทั่วโลกได้ตัดสินใจเลือกแล้ว

กรอบ Bootstrap: รูปแบบที่ปรับเปลี่ยนได้รวดเร็ว

หลักสูตรวิดีโอทีละขั้นตอนเกี่ยวกับพื้นฐานของเค้าโครงแบบปรับได้ในกรอบงาน Bootstrap

เรียนรู้การเรียงพิมพ์อย่างง่ายดาย รวดเร็ว และมีประสิทธิภาพโดยใช้เครื่องมือที่ทรงพลังและใช้งานได้จริง

เค้าโครงการสั่งซื้อและรับเงิน

*เลื่อนเมาส์ไปเหนือเพื่อหยุดการเลื่อนชั่วคราว

กลับไปข้างหน้า

บ่อยครั้งเมื่อ โดยใช้จาวาสคริปต์มีความจำเป็นต้องปฏิบัติตาม การกระทำที่แตกต่างกันเมื่อตรงตามเงื่อนไขที่แตกต่างกัน

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

ไวยากรณ์ทั่วไปของโครงสร้าง if-else มีดังนี้:

ถ้า (เงื่อนไข) (การกระทำ) อื่น ๆ (การกระทำ2);

เป็นตัวอย่าง ให้พิจารณาโค้ดต่อไปนี้:

ถ้า (browser=="MSIE") ( alert("คุณกำลังใช้ IE") ) else ( alert("คุณไม่ได้ใช้ IE") );

โปรดทราบว่าจะใช้อักษรตัวพิมพ์เล็กทั้งหมด หากคุณเขียน "IF" จะเกิดข้อผิดพลาด

โปรดทราบว่าการเปรียบเทียบใช้เครื่องหมายเท่ากับสองเท่า (==)

ถ้าเราเขียน เบราว์เซอร์ = "MSIE"จากนั้นเราจะกำหนดค่าง่ายๆ เอ็มซี่ชื่อตัวแปร เบราว์เซอร์.

เมื่อเราเขียน เบราว์เซอร์ = = "MSIE"จากนั้น JavaScript "เข้าใจ" ว่าเราต้องการทำการเปรียบเทียบและไม่กำหนดค่า

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

ถ้า (เงื่อนไข) (การกระทำ1) อื่น ๆ (ถ้า (เงื่อนไขอื่น ๆ) (การกระทำ2) อื่น ๆ (การกระทำ3); );

ตัวอย่างเช่น:

If (browser=="MSIE") ( alert("คุณกำลังใช้ IE") ) else ( if (browser=="Netscape") ( alert("คุณกำลังใช้ Firefox") ) else ( alert("คุณกำลังใช้ เบราว์เซอร์ที่ไม่รู้จัก: )")); -

ตัวดำเนินการเชิงตรรกะ AND, OR และ NOT

เพื่อการใช้งานที่ยืดหยุ่นมากยิ่งขึ้น ถ้า-อย่างอื่นคุณสามารถใช้สิ่งที่เรียกว่าตัวดำเนินการเชิงตรรกะได้

และเขียนเป็น && และใช้เมื่อต้องมีการทดสอบความจริงมากกว่าหนึ่งเงื่อนไข

เช่น ถ้ามีไข่อยู่ในตู้เย็นและมีเบคอนอยู่ในตู้เย็น เราก็จะกินไข่และเบคอนได้

ไวยากรณ์มีดังนี้:

ถ้า (เงื่อนไข1 && เงื่อนไข2) ( การกระทำ ) ถ้า (ชั่วโมง==12 && นาที==0) ( การแจ้งเตือน("เที่ยง!") );

หรือเขียนเป็น ||

และใช้เมื่อเราต้องการตรวจสอบความจริงของเงื่อนไขอย่างน้อยหนึ่งในสองเงื่อนไขขึ้นไป (คุณสามารถรับ || ได้โดยการกดปุ่ม Shift และปุ่ม \ ค้างไว้)

ไวยากรณ์มีดังนี้:

เช่น ถ้ามีนมอยู่ในตู้เย็น หรือมีน้ำอยู่ในตู้เย็น เราก็มีของให้ดื่ม

If (condition1 || Condition2) ( action ) if (hour==11 || hour==10) ( alert("ยังไม่เที่ยง!") );

Not เขียนว่า !

และใช้ในการปฏิเสธ

ตัวอย่างเช่น หากไม่มีไข่หรือเบคอนในตู้เย็น เราก็ไม่สามารถรับประทานไข่หรือเบคอนได้

ไวยากรณ์คือ:

If (!(condition)) ( action ) if (!(hour==11)) ( alert("It's not 11 o'clock") );

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

สีพื้นหลัง

หน้าเมื่อคุณคลิกที่ปุ่มเฉพาะ ในกรณีนี้ คุณต้อง "บอก" เบราว์เซอร์ว่าไม่ควรเรียกใช้สคริปต์นี้เพียงเพราะถึงคราวแล้ว

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

ในกรณีนี้ โค้ด JavaScript จะไม่ถูกดำเนินการจนกว่าเราจะ "ถาม" ให้ดำเนินการในลักษณะพิเศษ

ดูตัวอย่างสคริปต์ที่เขียนเป็นฟังก์ชันนี้:

ฟังก์ชั่น myfunction() ( alert("ยินดีต้อนรับ!"); ) คลิกปุ่มเพื่อดูว่าสคริปต์นี้ทำอะไร:ถ้าเป็นแนว

alert("ยินดีต้อนรับ!");

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

onClick="myfunction()"

สำหรับปุ่ม

ในบทเรียนต่อๆ ไป เราจะดูเหตุการณ์ประเภทอื่นๆ ที่ทริกเกอร์ฟังก์ชันต่างๆ

ไวยากรณ์ทั่วไปสำหรับฟังก์ชันมีดังนี้:

ชื่อฟังก์ชันของฟังก์ชัน(ตัวแปร1, ตัวแปร2,..., ตัวแปรN) ( ​​// นี่คือเนื้อความของฟังก์ชัน, การดำเนินการที่ฟังก์ชันทำ)

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

คุณชอบเนื้อหาและต้องการขอบคุณฉันหรือไม่?
เพียงแบ่งปันกับเพื่อนและเพื่อนร่วมงานของคุณ!

ดูเพิ่มเติมที่:

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

คำแนะนำการควบคุมสามารถซ้อนกันได้และยังสามารถใช้ภายในคำแนะนำการควบคุมอื่นๆ ได้อีกด้วย

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

คำสั่ง if มี 2 รูปแบบ ไวยากรณ์ของแบบฟอร์มแรก:

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

หาก (จริง) แจ้งเตือน ("เสร็จสิ้น!"); if (false) alert("จะไม่ดำเนินการ!");

ไวยากรณ์ if อนุญาตให้คุณดำเนินการได้เพียงคำสั่งเดียว แต่ถ้าคุณต้องการดำเนินการมากกว่าหนึ่งคำสั่ง คุณต้องใช้คำสั่งผสม:

ถ้า (จริง) ( ​​var str = "Hello!"; alert(str); )

ไวยากรณ์ของรูปแบบที่สอง:

ถ้า (นิพจน์) คำสั่ง; คำสั่งอื่น;

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

หาก (เท็จ) แจ้งเตือน ("ล้มเหลว"); การแจ้งเตือนอื่น ("กำลังทำงาน");

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

วาร์นัม = 2; if (num == 1) ( alert("num value: " + num); ) else if (num == 2) ( alert("num value: " + num); ) else ( alert("ฉันไม่ได้ รู้เลขนี้!"); )

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

วาร์นัม = 2; if (num == 1) ( alert("num value: " + num); ) else ( if (num == 2) ( alert("num value: " + num); ) else ( alert("ฉันทำไม่ได้' ไม่รู้ตัวเลขนี้!"); ) )

JavaScript มีโครงสร้างแบบมีเงื่อนไขที่ส่งผลต่อการทำงานของโปรแกรม ถ้า (ในภาษาอังกฤษถ้า) มีบางสิ่งอยู่ มีบางอย่างเป็นจริง ให้ทำสิ่งหนึ่ง มิฉะนั้น (ในภาษาอังกฤษอื่น) - ทำอย่างอื่น

มาดูกันว่าคำสั่ง if ทำงานอย่างไร ง่ายและไม่ต้องการคำอธิบายมากนัก

If (เงื่อนไข) (โค้ดที่จะดำเนินการหากเงื่อนไขเป็นจริง)

ง่ายมาก: หากเงื่อนไขเป็นจริง โค้ดในบล็อก (...) จะถูกดำเนินการ

หลักวาร์ = 4; if (หลัก == 4) ( document.write("ค่าของหลักตัวแปรคือ 4"); )

คุณสามารถสร้างโค้ดแปลก ๆ ได้เล็กน้อย:

หลักวาร์ = 4; ถ้า (จริง) ( ​​document.write("เงื่อนไขเป็นจริง"); )

คำสั่ง else สามารถใช้ร่วมกับคำสั่ง if ได้ แปลเป็น "อย่างอื่น" และระบุรหัสสำรอง

หลักวาร์ = 4; ถ้า (ตัวเลข

สังเกตการสะกดแบบต่างๆ ของเครื่องหมายปีกกา ในตัวอย่างนี้สำหรับคำสั่ง if และ else ไม่จำเป็นต้องเขียนแบบนี้เลย ทั้งสองไวยากรณ์ถูกต้อง

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

หลักวาร์ = 4; ถ้า (ตัวเลข

JavaScript ไม่มีคำสั่ง elseif (ในคำเดียว) เช่นเดียวกับ PHP

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

หลักวาร์ = 4; ถ้า (ตัวเลข

คำสั่ง if (เงื่อนไข) ประเมินและแปลงเงื่อนไข (นิพจน์) ในวงเล็บให้เป็นประเภทบูลีน (จริงหรือเท็จ)

ขอย้ำอีกครั้งว่ามีการโกหกใน JavaScript

• หมายเลข 0 (ศูนย์)
• สตริงว่าง ""
• ค่าบูลีนเป็นเท็จ :)
• ค่าเป็นโมฆะ
• ไม่ได้กำหนดมูลค่า
• ค่าคือ NaN (ไม่ใช่ตัวเลข)

ทุกสิ่งทุกอย่างเป็นจริง

ข้อผิดพลาดที่เป็นไปได้สองสามข้อ:

ถ้า ("เท็จ") document.write("นี่เป็นความจริง
"); if (false) document.write("สิ่งนี้เป็นจริง

");

ที่นี่คุณจะต้องแยกแยะสตริง “false” (อยู่ในเครื่องหมายคำพูด) จากค่าบูลีน false

ถ้า (" ") document.write("นี่เป็นเรื่องจริง
"); else document.write("นี่เป็นเท็จ
");

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

• โครงสร้างสวิตช์ JavaScript
• เครื่องหมายคำถามของผู้ปฏิบัติงาน