ผู้ปฏิบัติงานอาวุโส

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

ระดับอาวุโสของผู้ปฏิบัติงาน เรียงจากต่ำสุดไปสูงสุดจะเป็นดังนี้:

การมอบหมายงาน =+=-=*=/=%==>>>=&=^=|=

เลือกตามเงื่อนไข? -

ตรรกะหรือ ||

ตรรกะและ&&

ระดับบิตหรือ |

พิเศษเฉพาะ Bitwise^

ระดับบิต และ&&

อสมการ!=

ความเท่าเทียมกัน/ความไม่เท่าเทียมกัน == !=

การเปรียบเทียบ =

กะบิต >>>

การบวก/การลบ + -

คูณ/หาร * / %

การปฏิเสธ/การเสริม/เอกนารีลบ/การเพิ่มขึ้น/การลดลง! -

โทรผ่านพารามิเตอร์ () .

คำสำคัญที่สงวนไว้ใน JavaScript

JavaScript มีคำสำคัญที่สงวนไว้จำนวนหนึ่ง คำเหล่านี้มีสามประเภท: คำสงวน JavaScript คำสงวนสำหรับอนาคต และคำที่ควรหลีกเลี่ยง คำหลักจาวาสคริปต์

ทำลายความเท็จในความว่างเปล่านี้

ดำเนินการต่อเพื่อความจริงใหม่ในขณะที่

ลบฟังก์ชันประเภท null ของด้วย

อย่างอื่นถ้า return var

คำหลัก JavaScript สำหรับการใช้งานในอนาคต

ส่งออกดีบักเกอร์เคสสุดยอด

จับสวิตช์ขยายค่าเริ่มต้น

ชั้นเรียนก็โยนในที่สุด

ลองนำเข้า const enum

คำที่ควรหลีกเลี่ยงการใช้คือคำที่มีชื่อของอ็อบเจ็กต์หรือฟังก์ชัน JavaScript ภายในอยู่แล้ว ซึ่งรวมถึงคำเช่น String หรือ parseInt

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

var text = new String("นี่คือวัตถุสตริง");

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

สคริปต์ การสร้างสถานการณ์

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

เนื่องจากปัจจุบัน JavaScript เป็นภาษาสคริปต์เพียงภาษาเดียวที่ได้รับการสนับสนุนจากเว็บเบราว์เซอร์หลักๆ ทั้งหมด (Internet Explorer, Firefox, Netscape, Safari, Opera, Camino ฯลฯ) จึงมีการใช้กันอย่างแพร่หลาย

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

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

สำหรับโปรแกรมแก้ไขข้อความ Windows มีโปรแกรมแก้ไข NotePad แม้ว่าการแก้ไข JavaScript, HTML และ CSS จะเพียงพอแล้ว แต่โปรแกรมแก้ไขที่มีประสิทธิภาพมากกว่า เช่น EditPlus หรือโปรแกรมอื่นอาจสะดวกกว่า

ตอนนี้เราสามารถสร้างสคริปต์ JavaScript ได้แล้ว!

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

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

ด้านล่างนี้เป็นตัวอย่างของสองวิธีในการรวมโค้ด JavaScript:

ฟังก์ชั่นสคริปต์

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

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

มุมมองทั่วไปของคำจำกัดความของฟังก์ชันแสดงไว้ด้านล่าง:

ชื่อฟังก์ชัน([พารามิเตอร์ 1] [,พารามิเตอร์ 2] [...,พารามิเตอร์ N])

เส้นลำตัวของฟังก์ชัน

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

การใช้คีย์เวิร์ด return ฟังก์ชันสามารถส่งคืนค่าได้

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

ผู้ดำเนินการสามารถแปลงประเภทของตัวถูกดำเนินการได้โดยอัตโนมัติตามต้องการ ตัวอย่างเช่น ตัวดำเนินการคูณ * คาดหวังตัวเลข ดังนั้นนิพจน์ "2" * "3" จึงถือว่าถูกต้อง เนื่องจากล่ามจะทำการแปลงสตริงเป็นตัวเลขโดยนัย

ลำดับความสำคัญของตัวดำเนินการ

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

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

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

X - y - z (x - y) - z

ตัวดำเนินการมอบหมายมีการเชื่อมโยงจากขวาไปซ้าย ดังนั้นสองนิพจน์ต่อไปนี้จึงเทียบเท่ากัน:

W = x = y = z w = (x = (y = z))

คอลัมน์ O ระบุจำนวนตัวถูกดำเนินการ

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

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

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

ตัวดำเนินการ ประเภทตัวดำเนินการ A O ประเภทค่า

(…)	การจัดกลุ่ม	ไม่มา	1	ใด ๆ →ใด ๆ
… . … … […] ใหม่...()	ตัวดำเนินการเข้าถึง ตัวดำเนินการเข้าถึง ใหม่ (พร้อมรายการข้อโต้แย้ง)	จากซ้ายไปขวา จากซ้ายไปขวา ไม่มา	2 2 1	lval, lval →ใด ๆ lval, สตริงหรือหมายเลข → ใด ๆ ตัวสร้าง -> วัตถุ
… () ใหม่...	การเรียกใช้ฟังก์ชัน ใหม่ (ไม่มีข้อโต้แย้ง)	จากซ้ายไปขวา จากขวาไปซ้าย	1 1	ฟังก์ชั่น → ใด ๆ ตัวสร้าง -> วัตถุ
… ++ … --	การเพิ่มขึ้นภายหลัง การลดลงภายหลัง	ไม่มา ไม่มา	1 1	ระดับ → หมายเลข ระดับ → หมายเลข
! … ~ … + … - … ++ … -- … ลบ... ประเภท... เป็นโมฆะ...	ตรรกะไม่ใช่ (ผกผัน) Bitwise ไม่ใช่ (ผกผัน) ยูนินารี พลัส อูนารีลบ เพิ่มคำนำหน้า คำนำหน้าลดลง การกำจัด กำหนดชนิดข้อมูล ส่งกลับค่าที่ไม่ได้กำหนด	จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย	1 1 1 1 1 1 1 1 1	ใดๆ → บูลีน ทั้งหมด → ทั้งหมด หมายเลข → หมายเลข หมายเลข → หมายเลข ระดับ → หมายเลข ระดับ → หมายเลข lval → บูลีน ใด ๆ → สตริง ใด ๆ → ไม่ได้กำหนด
… ** … … * … … / … … % …	การยกกำลัง การคูณ แผนก การหารด้วยเศษ	จากขวาไปซ้าย จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา	2 2 2 2	หมายเลข หมายเลข → หมายเลข หมายเลข หมายเลข → หมายเลข หมายเลข หมายเลข → หมายเลข หมายเลข หมายเลข → หมายเลข
… + … … - … … + …	ส่วนที่เพิ่มเข้าไป การลบ การต่อข้อมูล	จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา	2 2 2	หมายเลข หมายเลข → หมายเลข หมายเลข หมายเลข → หมายเลข สตริง, สตริง → สตริง
… > … … >>> …	เลื่อนบิตไปทางซ้าย เลื่อนบิตไปทางขวาขณะรักษาเครื่องหมาย เลื่อนบิตไปทางขวาโดยไม่มีช่องว่างภายในเป็นศูนย์	จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา	2 2 2	ทั้งหมดทั้งหมด→ทั้งหมด ทั้งหมดทั้งหมด→ทั้งหมด ทั้งหมดทั้งหมด→ทั้งหมด
… < … … … … >= … ... ใน ... ... ตัวอย่าง ...	น้อยกว่า น้อยกว่าหรือเท่ากับ มากกว่า มากกว่าหรือเท่ากับ การตรวจสอบการมีอยู่ของทรัพย์สิน การตรวจสอบว่าเป็นของประเภทนี้	จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา	2 2 2 2 2 2	หมายเลข หมายเลข → บูลีน หมายเลข หมายเลข → บูลีน หมายเลข หมายเลข → บูลีน หมายเลข หมายเลข → บูลีน สตริง วัตถุ → บูลีน วัตถุ ตัวสร้าง → บูลีน
… == … … != … … === … … !== …	เท่ากับ ไม่เท่ากัน เท่าเทียมกันอย่างเคร่งครัด ไม่เท่ากันเด็ดขาด	จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา จากซ้ายไปขวา	2 2 2 2	ใดๆ, ใดๆ → บูลีน ใดๆ, ใดๆ → บูลีน ใดๆ, ใดๆ → บูลีน ใดๆ, ใดๆ → บูลีน
… & …	ระดับบิตและ	จากซ้ายไปขวา	2	ทั้งหมดทั้งหมด→ทั้งหมด
… ^ …	Bitwise พิเศษหรือ	จากซ้ายไปขวา	2	ทั้งหมดทั้งหมด→ทั้งหมด
… | …	การดำเนินการมอบหมาย การดำเนินการมอบหมาย การดำเนินการมอบหมาย	จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย จากขวาไปซ้าย	2 2 2 2 2 2 2 2 2 2 2 2 2	lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ lval, ใด ๆ → ใด ๆ
ผลผลิต... ผลผลิต* ...	ผลผลิต ผลผลิต*	จากขวาไปซ้าย จากขวาไปซ้าย	1 1
... …	ส่วนขยาย	ไม่มา	1
… , …	จุลภาค	จากซ้ายไปขวา	2	ใด ๆ ใด ๆ → ใด ๆ

นิพจน์ใน JavaScript เป็นการรวมกัน ตัวถูกดำเนินการและ ตัวดำเนินการ.

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

ข้าว. 1. โครงสร้างนิพจน์ใน JavaScript

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

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

ขึ้นอยู่กับจำนวนตัวถูกดำเนินการ ตัวดำเนินการประเภทต่างๆ ต่อไปนี้จะมีความโดดเด่น:
ยูนารี - ตัวถูกดำเนินการหนึ่งตัวมีส่วนร่วมในการดำเนินการ
ไบนารี - การดำเนินการเกี่ยวข้องกับตัวถูกดำเนินการสองตัว
ternary - รวมตัวถูกดำเนินการสามตัว

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

นิพจน์และตัวดำเนินการใน JavaScript 1. ตัวดำเนินการทางคณิตศาสตร์

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

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

ตารางที่ 1. ตัวดำเนินการทางคณิตศาสตร์ ลำดับความสำคัญของคำอธิบายการดำเนินการ/การดำเนินการ

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

วาร์ x = 5, y = 8, z; z = x + y; // ส่งคืน 13 z = x - y; // กลับ -3 z = - y; // กลับ -8 z = x * y; // กลับ 40 z = x / y; // ส่งกลับ 0.625 z = y % x; // กลับ 3 2. ตัวดำเนินการที่ได้รับมอบหมาย

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

วาร์ ก = 5; // กำหนดค่าตัวเลข 5 ให้กับตัวแปร a var b = "hello"; // เก็บสตริงเฮลโลว์ไว้ในตัวแปร b var m = n = z = 10; // กำหนดตัวแปร m, n, z ค่าตัวเลข 10 x += 10; // เทียบเท่ากับ x = x + 10; x -= 10; // เทียบเท่ากับ x = x - 10; x *= 10; // เทียบเท่ากับ x = x * 10; x /= 10; // เทียบเท่ากับ x = x / 10; x %= 10; // เทียบเท่ากับ x = x % 10; 3. ตัวดำเนินการเพิ่มและลด

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

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* จากการคำนวณจะส่งกลับค่า z = 12, x = 6 เช่น ค่าของ x จะเพิ่มขึ้น 1 ก่อนจากนั้นจึงดำเนินการคูณ */ s = y++ * 2; /* จากการคำนวณจะส่งกลับค่า s = 10, y = 6 เช่น ขั้นแรก ดำเนินการคูณ จากนั้นค่าที่เพิ่มขึ้น 1 จะถูกเก็บไว้ในตัวแปร y */ k = --m * 2; // ส่งกลับค่า k = 8, m = 4 l = n-- * 2; // ส่งกลับค่า l = 10, n = 4 4. ตัวดำเนินการเปรียบเทียบ

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

หากไม่สามารถแปลงตัวถูกดำเนินการทั้งสองเป็นตัวเลขหรือสตริงได้สำเร็จ ตัวดำเนินการจะส่งคืนค่า false เสมอ

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

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

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

ตารางที่ 4. ตัวดำเนินการเปรียบเทียบ ลำดับความสำคัญของคำอธิบายการดำเนินการ/การดำเนินการ

== ความเท่าเทียมกัน	ทดสอบสองค่าด้วยค่าเดียวกัน อนุญาตให้แปลงประเภทได้ คืนค่าเป็นจริงหากตัวถูกดำเนินการเหมือนกัน และคืนค่าเป็นเท็จหากต่างกัน	9
!= อสมการ	คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากัน	9
=== ตัวตน	ทดสอบตัวถูกดำเนินการสองตัวสำหรับ "ข้อมูลประจำตัว" โดยใช้คำจำกัดความที่เข้มงวดของการจับคู่ คืนค่าเป็นจริงหากตัวถูกดำเนินการเท่ากันโดยไม่มีการแปลงประเภท	9
!== ไม่มีตัวตน	ดำเนินการยืนยันตัวตน คืนค่าเป็นจริงหากตัวถูกดำเนินการไม่เท่ากันโดยไม่มีการแปลงประเภท	9
> เพิ่มเติม	คืนค่าเป็นจริงหากตัวถูกดำเนินการตัวแรกมากกว่าตัวที่สอง มิฉะนั้นจะส่งคืนค่าเท็จ	10
>= มากกว่าหรือเท่ากับ	คืนค่าเป็นจริงหากตัวถูกดำเนินการตัวแรกไม่น้อยกว่าตัวที่สอง มิฉะนั้นจะส่งคืนค่าเท็จ	10
	คืนค่าเป็นจริงหากตัวถูกดำเนินการตัวแรกน้อยกว่าตัวที่สอง มิฉะนั้นจะส่งกลับค่าเท็จ	10
	คืนค่าเป็นจริงหากตัวถูกดำเนินการตัวแรกไม่มากกว่าตัวที่สอง มิฉะนั้นจะส่งคืนค่าเท็จ	10

5 == "5"; // คืนค่าจริง 5 != -5.0; // คืนค่าจริง 5 === "5"; // กลับเท็จเท็จ === เท็จ; // คืนค่าจริง 1 !== จริง; // คืนค่าจริง 1 != จริง; // จะคืนค่าเท็จเนื่องจากค่าจริงถูกแปลงเป็น 1 3 > -3; // คืนค่าจริง 3 >= "4"; // return false 5. ตัวดำเนินการเชิงตรรกะ

ตัวดำเนินการเชิงตรรกะช่วยให้คุณสามารถรวมเงื่อนไขที่ส่งกลับค่าบูลีนได้ มักใช้ในคำสั่ง if Conditional

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // จะคืนค่าเป็นจริงหาก x อยู่ในช่วงตั้งแต่ 0 ถึง 10 !false; // return true 6. ตัวดำเนินการ Bitwise

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

ตารางที่ 6. ตัวดำเนินการ Bitwise ลำดับความสำคัญของคำอธิบายการดำเนินการ/การดำเนินการ

& ระดับบิต และ	ถ้าทั้งสองบิตเป็น 1 บิตผลลัพธ์จะเป็น 1 มิฉะนั้นผลลัพธ์จะเป็น 0	8
- บิตไวส์หรือ	หากตัวถูกดำเนินการตัวใดตัวหนึ่งมี 1 ที่ตำแหน่ง ผลลัพธ์ก็จะมี 1 อยู่ที่ตำแหน่งนั้นด้วย มิฉะนั้น ผลลัพธ์ที่ตำแหน่งนั้นจะเป็น 0	6
↑ เอกสิทธิ์เฉพาะบุคคล หรือ	หากค่าเดียวเท่านั้นที่มี 1 ที่ตำแหน่งใดๆ ผลลัพธ์ก็จะมี 1 ที่ตำแหน่งนั้น มิฉะนั้น ผลลัพธ์ที่ตำแหน่งนั้นจะเป็น 0	7
~ การปฏิเสธ	การดำเนินการปฏิเสธระดับบิตจะดำเนินการกับการแทนค่าไบนารีของนิพจน์ ตำแหน่งใดๆ ที่มี 1 ในนิพจน์เดิมจะถูกแทนที่ด้วย 0 ตำแหน่งใดๆ ที่มี 0 ในนิพจน์ดั้งเดิมจะกลายเป็น 0 จำนวนบวกเริ่มต้นที่ 0 จำนวนลบเริ่มต้นที่ -1 ดังนั้น ~ n == -(n+1)	14
	ตัวดำเนินการเลื่อนบิตของตัวถูกดำเนินการตัวแรกไปทางซ้ายตามจำนวนตำแหน่งบิตที่กำหนดโดยตัวถูกดำเนินการตัวที่สอง เลขศูนย์ใช้เพื่อเติมตำแหน่งทางด้านขวา ส่งกลับผลลัพธ์ประเภทเดียวกันกับตัวถูกดำเนินการทางซ้าย	11
>> เลื่อนไปทางขวา	ตัวดำเนินการเลื่อนบิตของตัวถูกดำเนินการตัวแรกไปทางขวาตามจำนวนตำแหน่งบิตที่กำหนดโดยตัวถูกดำเนินการตัวที่สอง ตัวเลขที่ถูกเลื่อนออกนอกช่วงจะถูกลบออก บิตที่สำคัญที่สุด (32) จะไม่ถูกเปลี่ยนแปลงเพื่อรักษาเครื่องหมายของผลลัพธ์ หากตัวถูกดำเนินการตัวแรกเป็นค่าบวก บิตที่สำคัญที่สุดของผลลัพธ์จะถูกเติมด้วยศูนย์ หากตัวถูกดำเนินการตัวแรกเป็นค่าลบ บิตที่สำคัญที่สุดของผลลัพธ์จะเต็มไปด้วยตัวถูกดำเนินการ การเลื่อนค่าไปทางขวาหนึ่งตำแหน่งจะเทียบเท่ากับการหารด้วย 2 (ทิ้งเศษที่เหลือ) และการเลื่อนไปทางขวาด้วยสองตำแหน่งจะเทียบเท่ากับการหารด้วย 4 เป็นต้น	11
>>> เลื่อนไปทางขวาแบบ Bitwise โดยไม่มีเครื่องหมาย	ตัวดำเนินการเลื่อนบิตของตัวถูกดำเนินการตัวแรกไปทางขวาตามจำนวนตำแหน่งบิตที่กำหนดโดยตัวถูกดำเนินการตัวที่สอง เลขศูนย์จะถูกเพิ่มทางด้านซ้าย โดยไม่คำนึงถึงเครื่องหมายของตัวถูกดำเนินการตัวแรก ตัวเลขที่ถูกเลื่อนออกนอกช่วงจะถูกลบออก	11

var x = 9, y = 5, z = 2, s = -5 ผลลัพธ์; // 9 เทียบเท่ากับ 1001, 5 เทียบเท่ากับ 0101 ผลลัพธ์ = x & y; // จะส่งกลับผลลัพธ์ 1 (เทียบเท่ากับ 0001) = x | ใช่; // จะส่งกลับผลลัพธ์ 13 (เทียบเท่ากับ 1101) = x ^ y; // ส่งกลับผลลัพธ์ 12 (เทียบเท่ากับ 1100) = ~ y; // จะส่งกลับ -6 (เทียบเท่ากับ 1100) ผลลัพธ์ = x > z; // ส่งกลับ 2 (เทียบเท่ากับ 10) ผลลัพธ์ = s >>> z; // จะส่งกลับ 1073741822 (เทียบเท่ากับ 111111111111111111111111111110) 7. ตัวดำเนินการสตริง

มีโอเปอเรเตอร์หลายตัวที่ทำงานกับสตริงในลักษณะพิเศษ

"1" + "10"; // กลับ "110" "1" + 10; // ส่งกลับ "110" 2 + 5 + "ดินสอสี"; // ส่งคืน "ดินสอสี 7 แท่ง" "ดินสอสี" + 2 + 5; // ส่งคืน "ดินสอสี 25 แท่ง" "1" > "10"; // return false "10" 10 ? x * 2: x / 2; // ส่งคืน x * 2 ถ้า x > 10 มิฉะนั้น x / 2 9. ความคิดเห็นใน JavaScript

ความคิดเห็นบรรทัดเดียว: คุณต้องนำสัญลักษณ์ด้านหน้าข้อความความคิดเห็น //

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

1. วัตถุภาษาในตัว ออบเจ็กต์เหล่านี้ได้รับการออกแบบมาให้ทำงานกับประเภทข้อมูลเฉพาะหรือทำงานทั่วไป (เช่น คณิตศาสตร์ สตริง ออบเจ็กต์วันที่ ฯลฯ) ก่อนที่จะใช้ออบเจ็กต์ที่มาพร้อมเครื่อง มักจำเป็นต้องสร้างอินสแตนซ์ที่สอดคล้องกันของออบเจ็กต์นั้น (นอกเหนือจากคณิตศาสตร์)

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

3. วัตถุที่กำหนดเอง นักพัฒนาสร้างขึ้นเพื่อความต้องการเฉพาะบางประการ การสร้างวัตถุของคุณเองต้องใช้ทักษะและประสบการณ์การพัฒนาบางอย่าง

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

คุณสามารถเข้าถึงคุณสมบัติหรือวิธีการโดยการระบุชื่อและอินสแตนซ์ของวัตถุ:

object.คุณสมบัติ

วัตถุ.วิธีการ()

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

// ล่ามจะเรียก open() METHOD

// ล่ามจะมองหาคุณสมบัติที่เปิดอยู่

// จะไม่พบมันและจะเกิดข้อผิดพลาด

8. ตัวดำเนินการพิเศษใน JavaScript

?: ให้คุณพูดง่ายๆ ว่า "ถ้า...แล้ว...อย่างอื่น"

ประเมินสองนิพจน์และส่งกลับผลลัพธ์ของนิพจน์ที่สอง

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

ใหม่ ช่วยให้คุณสร้างอินสแตนซ์ของประเภทวัตถุที่ผู้ใช้กำหนดหรือหนึ่งในประเภทวัตถุในตัว

คำหลักนี้คุณสามารถใช้เพื่ออ้างถึงวัตถุปัจจุบัน

typeof ส่งกลับสตริงที่ระบุประเภทของตัวถูกดำเนินการที่ไม่ได้รับการประเมิน

เป็นโมฆะ ตัวดำเนินการ void กำหนดนิพจน์ที่จะถูกประเมินโดยไม่ส่งคืนค่า

9. ลำดับความสำคัญของตัวดำเนินการใน JavaScript

ผู้ปฏิบัติงานอาวุโส

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

ระดับอาวุโสของผู้ปฏิบัติงาน เรียงจากต่ำสุดไปสูงสุดจะเป็นดังนี้:

การมอบหมายงาน =+=-=*=/=%==>>>=&=^=|=

เลือกตามเงื่อนไข? -

ตรรกะหรือ ||

ตรรกะและ &&

ระดับบิตหรือ |

พิเศษเฉพาะ Bitwise^

ระดับบิต และ &

อสมการ!=

ความเท่าเทียมกัน/ความไม่เท่าเทียมกัน == !=

การเปรียบเทียบ =

การเปลี่ยนบิต > >>>

การบวก/การลบ + -

คูณ/หาร * / %

การปฏิเสธ/การเสริม/เอกนารีลบ/การเพิ่มขึ้น/การลดลง! -

โทรผ่านพารามิเตอร์ () .

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

คุณไม่จำเป็นต้องเก่งคณิตศาสตร์เพื่อที่จะเป็นนักพัฒนาที่ดี แต่สิ่งสำคัญคือต้องรู้ว่ามีการดำเนินการประเภทใดใน JavaScript และวิธีใช้งานเพื่อปฏิบัติงานจริง

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

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

ตัวดำเนินการทางคณิตศาสตร์

ตัวดำเนินการทางคณิตศาสตร์คือสัญลักษณ์ที่กำหนดการดำเนินการทางคณิตศาสตร์และส่งกลับผลลัพธ์ ตัวอย่างเช่น ใน 3 + 7 = 10 สัญลักษณ์ + จะกำหนดไวยากรณ์สำหรับการดำเนินการบวก

ตัวดำเนินการ JavaScript จำนวนมากคุ้นเคยกับคุณจากคณิตศาสตร์พื้นฐาน แต่ก็มีตัวดำเนินการเพิ่มเติมอีกหลายตัวเช่นกัน

ตัวดำเนินการทางคณิตศาสตร์ JavaScript ทั้งหมดจะแสดงอยู่ในตารางต่อไปนี้

ผู้ดำเนินการ	ไวยากรณ์	ตัวอย่าง	คำนิยาม
ส่วนที่เพิ่มเข้าไป	+	x+y	ผลรวมของ x และ y
การลบ	—	เอ็กซ์ - ย	ความแตกต่างระหว่าง x และ y
การคูณ	*	x*y	อนุพันธ์ของ x และ y
แผนก	/	เอ็กซ์/ป	ผลหารของ x และ y
โมดูล	%	x % y	ส่วนที่เหลือ x/y
การยกกำลัง	**	เอ็กซ์**ย	x ยกกำลัง y
เพิ่มขึ้น	++	x++	x บวกหนึ่ง
ลดลง	—	เอ็กซ์—	x ลบหนึ่ง

การบวกและการลบ

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

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

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

// กำหนดค่าให้กับ x และ y
ให้ x = 10;
ให้ y = 20;
// เพิ่ม x และ y แล้วกำหนดผลรวมให้กับ z
ให้ z = x + y;
console.log(z);
30

// กำหนดค่าให้กับ x และ y
ให้ x = 10;
ให้ y = 20;
// ลบ x จาก y และกำหนดผลต่างให้กับ z
ให้ z = y - x;
console.log(z);
10

// กำหนดค่าให้กับ x และ y
ให้ x = -5.2;
ให้ y = 2.5;
// ลบ y จาก x และกำหนดผลต่างให้กับ z
ให้ z = x - y;
console.log(z);
-7.7

คุณสมบัติที่น่าสนใจอย่างหนึ่งใน JavaScript ที่คุณควรพิจารณาและรู้คือผลลัพธ์ของการเพิ่มตัวเลขและสตริง เรารู้ว่า 1 + 1 ต้องเท่ากับ 2 แต่สมการนี้จะให้ผลลัพธ์ที่ไม่คาดคิด

ให้ x = 1 + "1";
console.log(x);
ประเภทของ x;
11
"สตริง"

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

การบวกและการลบใน JavaScript มักใช้เพื่อเลื่อนแถบนำทาง

ฟังก์ชั่น scrollToId() (
const navHeight = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);

ในกรณีนี้ แผงจะเลื่อนจากรหัสไป 60 พิกเซล

การคูณและการหาร

ตัวดำเนินการการคูณและการหารของ JavaScript ใช้ในการค้นหาอนุพันธ์และผลหารของค่าตัวเลข

เครื่องหมายดอกจันเป็นตัวดำเนินการคูณ

// กำหนดค่าให้กับ x และ y
ให้ x = 20;
ให้ y = 5;
// คูณ x ด้วย y เพื่อให้ได้ผลลัพธ์
ให้ z = x * y;
console.log(z);
100

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

ราคาต่อตัว = 26.5; // ราคาสินค้าก่อนหักภาษี
อัตราภาษีคงที่ = 0.082; // อัตราภาษี 8.2%
// คำนวณผลรวมหลังหักภาษีเป็นทศนิยมสองตำแหน่ง
ให้ TotalPrice = ราคา + (ราคา * อัตราภาษี);
ราคารวม.toFixed(2);
console.log("รวม:", ราคารวม);
รวม: 28.67

Slash เป็นตัวดำเนินการหาร

// กำหนดค่าให้กับ x และ y
ให้ x = 20;
ให้ y = 5;
// แบ่ง y ออกเป็น x เพื่อให้ได้ใบเสนอราคา
ให้ z = x / y;
console.log(z);
4

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

โมดูลัสจำนวน

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

ตัวอย่างเช่น เรารู้ว่า 9 หารด้วย 3 ลงตัวโดยไม่มีเศษ:

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

// เตรียมใช้งานฟังก์ชันเพื่อทดสอบว่าตัวเลขเป็นเลขคู่หรือไม่
const คือคู่ = x => (
// ถ้าเศษที่เหลือหลังจากหารด้วยสองเป็น 0 ให้คืนค่าเป็นจริง
ถ้า (x % 2 === 0) (
กลับเป็นจริง;
}
// ถ้าเป็นเลขคี่ ให้คืนค่าเท็จ
กลับเท็จ;
}
// ทดสอบตัวเลข
เป็นคู่(12);
จริง

ในตัวอย่างนี้ 12 หารด้วย 2 ลงตัว จึงเป็นเลขคู่

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

การยกกำลัง

การยกกำลังเป็นหนึ่งในตัวดำเนินการใหม่ล่าสุดใน JavaScript ไวยากรณ์สำหรับการยกกำลังคือเครื่องหมายดอกจัน 2 อันติดกัน (**)

ตัวอย่างเช่น 10 ยกกำลังห้า (10^5) เขียนได้ดังนี้:

10 ** 5;
100000

การดำเนินการ 10**5 ให้ผลลัพธ์เหมือนกับ 10*10 ซ้ำ 5 ครั้ง

10 * 10 * 10 * 10 * 10;

การดำเนินการนี้สามารถเขียนได้โดยใช้เมธอด Math.pow()

คณิต.พาว(10, 5);
100000

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

การเพิ่มขึ้นและการลดลง

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

โปรดทราบว่าตัวดำเนินการเพิ่มและลดค่าสามารถใช้ได้กับตัวแปรเท่านั้น การพยายามใช้กับจำนวนเฉพาะจะทำให้เกิดข้อผิดพลาด

7++
Uncaught ReferenceError: นิพจน์ด้านซ้ายไม่ถูกต้องในการดำเนินการ postfix

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

ส่วนเพิ่มคำนำหน้าจะเขียนเป็น ++x

//ตั้งค่าตัวแปร
ให้ x = 7;

ให้คำนำหน้า = ++x;
console.log(คำนำหน้า);
8

ค่าของ x เพิ่มขึ้น 1 ส่วนที่เพิ่มขึ้นของ postfix จะเขียนเป็น y++

//ตั้งค่าตัวแปร
ให้ y = 7;
// ใช้การดำเนินการเพิ่มคำนำหน้า
ให้ postfix = y++;
console.log (โพสต์ฟิกซ์);
7

การดำเนินการ postfix ไม่ได้เพิ่มค่า ค่านี้จะไม่ถูกเพิ่มขึ้นจนกว่านิพจน์จะได้รับการประเมิน เมื่อต้องการทำเช่นนี้ คุณต้องดำเนินการสองครั้ง:

ให้ y = 7;
ย++;
ย++;
console.log(y);
8

ส่วนใหญ่แล้วโอเปอเรเตอร์เหล่านี้จะอยู่ในลูป ใน for loop นี้ คำสั่ง for จะถูกดำเนินการ 10 ครั้ง โดยเริ่มจาก 0

// วิ่งวนซ้ำสิบครั้ง
สำหรับ (ให้ i = 0; i< 10; i++) {
console.log(ผม);
}
0
1
2
3
4
5
6
7
8
9

ในตัวอย่างนี้ การวนซ้ำจะถูกวนซ้ำโดยใช้ตัวดำเนินการส่วนเพิ่ม

พูดง่ายๆ ก็คือ x++ ​​ย่อมาจาก x = x + 1 และ x ย่อมาจาก x = x – 1

ผู้ดำเนินการที่ได้รับมอบหมาย

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

// กำหนด 27 ให้กับตัวแปรอายุ
ให้อายุ = 27;

นอกเหนือจากตัวดำเนินการกำหนดมาตรฐานแล้ว JavaScript ยังมีตัวดำเนินการกำหนดแบบผสม ซึ่งรวมตัวดำเนินการทางคณิตศาสตร์เข้ากับตัวดำเนินการ =

ตัวอย่างเช่น ตัวดำเนินการเพิ่มจะเริ่มต้นจากค่าเดิมและเพิ่มค่าใหม่ลงไป

// กำหนด 27 ให้กับตัวแปรอายุ
ให้อายุ = 27;
อายุ += 3;
console.log(อายุ);
30

โดยพื้นฐานแล้ว อายุ += 3 จะเท่ากับ อายุ = อายุ + 3

ตัวดำเนินการทางคณิตศาสตร์ทั้งหมดสามารถรวมกับตัวดำเนินการกำหนดได้ ด้านล่างนี้เป็นตารางอ้างอิงของตัวดำเนินการมอบหมายงานใน JavaScript

ตัวดำเนินการกำหนดแบบผสมมักใช้ในลูป เช่น การเพิ่มขึ้นและการลดลง

ลำดับความสำคัญของตัวดำเนินการ

ตัวดำเนินการจะถูกดำเนินการตามลำดับความสำคัญ เช่นเดียวกับในคณิตศาสตร์ทั่วไป

เช่น การคูณมีลำดับความสำคัญสูงกว่าการบวก

// ขั้นแรกคูณ 3 ด้วย 5 แล้วบวก 10
10 + 3 * 5;
25

หากคุณต้องการดำเนินการบวกก่อน ให้ใส่ไว้ในวงเล็บ - การดำเนินการดังกล่าวจะมีลำดับความสำคัญสูงสุดเสมอ

// ขั้นแรกให้บวก 10 และ 3 แล้วคูณด้วย 5
(10 + 3) * 5;
65

ด้านล่างนี้คุณจะพบตารางลำดับความสำคัญของตัวดำเนินการทางคณิตศาสตร์ใน JavaScript สำหรับการเพิ่มขึ้นและการลดลง postfix จะมีลำดับความสำคัญสูงกว่าคำนำหน้า

การเพิ่มขึ้น/การลด การคูณ/การหาร และการบวก/การลบ มีลำดับความสำคัญเท่ากัน

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

แท็ก: