ตัวดำเนินการพื้นฐาน คณิตศาสตร์

เรารู้จักเจ้าหน้าที่จากโรงเรียนมากมาย พวกมันคือสิ่งต่างๆ เช่น การบวก + การคูณ * การลบ - และอื่นๆ

ในบทนี้ เราจะเริ่มต้นด้วยตัวดำเนินการอย่างง่าย จากนั้นมุ่งเน้นไปที่ลักษณะเฉพาะของ JavaScript ซึ่งไม่ครอบคลุมอยู่ในเลขคณิตของโรงเรียน

เงื่อนไข: “unary”, “binary”, “operand”

ก่อนที่เราจะไปต่อ เรามาทำความเข้าใจคำศัพท์ทั่วไปกันก่อน

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

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

   ให้ x = 1;
  
  x = -x;
  การแจ้งเตือน ( x ); // -1 ใช้การปฏิเสธแบบเอกนารี

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

   ให้ x = 1, y = 3;
  การแจ้งเตือน (y - x); // 2 ไบนารีลบลบค่า

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

คณิตศาสตร์

รองรับการดำเนินการทางคณิตศาสตร์ต่อไปนี้:

• นอกจากนี้ + ,

• การลบ - ,

• การคูณ * ,

• แผนก / ,

• % ที่เหลือ

• การยกกำลัง ** .

สี่คำแรกนั้นตรงไปตรงมา ในขณะที่ % และ ** ต้องการคำสองสามคำเกี่ยวกับสิ่งเหล่านั้น

% ที่เหลือ

ตัวดำเนินการส่วนที่เหลือ % แม้ว่าจะมีลักษณะที่ปรากฏ แต่ก็ไม่เกี่ยวข้องกับเปอร์เซ็นต์

ผลลัพธ์ของ a % b คือส่วนที่เหลือของการหารจำนวนเต็มของ a ด้วย b

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

 การแจ้งเตือน( 5 % 2 ); // 1 เศษของ 5 หารด้วย 2
การแจ้งเตือน( 8 % 3 ); // 2 เศษของ 8 หารด้วย 3
การแจ้งเตือน( 8 % 4 ); // 0 เศษของ 8 หารด้วย 4

การยกกำลัง **

ตัวดำเนินการยกกำลัง a ** b ยกกำลัง a ของ b

ในคณิตศาสตร์โรงเรียน เราเขียนมันเป็น ^b

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

 การแจ้งเตือน (2 ** 2 ); // 2² = 4
การแจ้งเตือน( 2 ** 3 ); // 2³ = 8
การแจ้งเตือน( 2 ** 4 ); // 2⁴ = 16

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

ตัวอย่างเช่น รากที่สองคือการยกกำลังด้วย ½:

 การแจ้งเตือน( 4 ** (1/2) ); // 2 (กำลังของ 1/2 เท่ากับสแควร์รูท)
การแจ้งเตือน( 8 ** (1/3) ); // 2 (กำลังของ 1/3 เท่ากับลูกบาศก์รูท)

การต่อสตริงด้วยไบนารี +

พบกับฟีเจอร์ของตัวดำเนินการ JavaScript ที่เหนือกว่าเลขคณิตของโรงเรียนกัน

โดยปกติแล้ว ตัวดำเนินการบวก + ตัวเลขผลรวม

แต่ถ้าใช้ไบนารี + กับสตริง มันจะรวม (ต่อกัน) เข้าด้วยกัน:

 ให้ s = "ของฉัน" + "สตริง";
การแจ้งเตือน; // มายสตริง

โปรดทราบว่าหากตัวถูกดำเนินการใดๆ เป็นสตริง อีกตัวหนึ่งจะถูกแปลงเป็นสตริงด้วย

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

 การแจ้งเตือน( '1' + 2 ); // "12"
การแจ้งเตือน( 2 + '1' ); // "21"

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

นี่เป็นตัวอย่างที่ซับซ้อนมากขึ้น:

 การแจ้งเตือน(2 + 2 + '1' ); // "41" ไม่ใช่ "221"

ที่นี่ผู้ปฏิบัติงานทำงานทีละคน ตัวแรก + รวมตัวเลขสองตัว ดังนั้นมันจึงส่งคืน 4 จากนั้น + ถัดไปจะเพิ่มสตริง 1 ลงไป ดังนั้นจึงเหมือนกับ 4 + '1' = '41'

 การแจ้งเตือน ('1' + 2 + 2); // "122" ไม่ใช่ "14"

ในที่นี้ ตัวถูกดำเนินการตัวแรกคือสตริง คอมไพลเลอร์จะถือว่าตัวถูกดำเนินการอีกสองตัวเป็นสตริงเช่นกัน 2 ถูกต่อเข้ากับ '1' ดังนั้นจึงเหมือนกับ '1' + 2 = "12" และ "12" + 2 = "122"

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

นี่คือการสาธิตการลบและการหาร:

 การแจ้งเตือน( 6 - '2' ); // 4 แปลง '2' เป็นตัวเลข
การแจ้งเตือน( '6' / '2' ); // 3 แปลงตัวถูกดำเนินการทั้งสองเป็นตัวเลข

การแปลงตัวเลข เอกนารี +

เครื่องหมายบวก + มีอยู่สองรูปแบบ: รูปแบบไบนารี่ที่เราใช้ด้านบน และรูปแบบเอกนารี

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

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

 // ไม่มีผลกับตัวเลข
ให้ x = 1;
การแจ้งเตือน( +x ); // 1

ให้ y = -2;
การแจ้งเตือน( +y ); // -2

// แปลงค่าที่ไม่ใช่ตัวเลข
การแจ้งเตือน( +จริง ); // 1
การแจ้งเตือน( +"" );   // 0

จริงๆ แล้วมันก็ทำสิ่งเดียวกันกับ Number(...) แต่สั้นกว่า

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

ไบนารีบวกจะเพิ่มเป็นสตริง:

 ให้แอปเปิ้ล = "2";
ให้ส้ม = "3";

การแจ้งเตือน ( แอปเปิ้ล + ส้ม ); // "23" ไบนารีบวกเชื่อมสตริงเข้าด้วยกัน

หากเราต้องการถือเป็นตัวเลข เราต้องแปลงแล้วรวมเข้าด้วยกัน:

 ให้แอปเปิ้ล = "2";
ให้ส้ม = "3";

// ค่าทั้งสองถูกแปลงเป็นตัวเลขก่อนเลขฐานสองบวก
alert( +แอปเปิ้ล + +ส้ม ); // 5

// ตัวแปรที่ยาวกว่า
// alert( หมายเลข(แอปเปิ้ล) + หมายเลข(ส้ม) ); // 5

จากมุมมองของนักคณิตศาสตร์ ข้อดีมากมายอาจดูแปลก แต่จากมุมมองของโปรแกรมเมอร์ ไม่มีอะไรพิเศษ: ใช้ unary pluses ก่อน แปลงสตริงเป็นตัวเลข จากนั้นไบนารีบวกจะรวมเข้าด้วยกัน

เหตุใด unary pluses จึงถูกนำไปใช้กับค่าก่อนค่าไบนารี่ ดังที่เราจะได้เห็น นั่นเป็นเพราะ ลำดับความสำคัญที่สูงกว่า

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

หากนิพจน์มีโอเปอเรเตอร์มากกว่าหนึ่งตัว ลำดับการดำเนินการจะถูกกำหนดโดย ลำดับความสำคัญ หรืออีกนัยหนึ่งคือ ลำดับลำดับความสำคัญเริ่มต้นของตัวดำเนินการ

จากโรงเรียน เราทุกคนรู้ดีว่าควรคำนวณการคูณในนิพจน์ 1 + 2 * 2 ก่อนการบวก นั่นคือสิ่งที่สำคัญกว่า กล่าวกันว่าการคูณมี ลำดับความสำคัญสูงกว่า การบวก

วงเล็บจะแทนที่ลำดับความสำคัญใดๆ ดังนั้นหากเราไม่พอใจกับลำดับเริ่มต้น เราก็สามารถใช้วงเล็บในการเปลี่ยนแปลงได้ เช่น เขียน (1 + 2) * 2

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

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

ดังที่เราเห็นแล้วว่า “unary plus” มีลำดับความสำคัญเป็น 14 ซึ่งสูงกว่า 11 ของ “addition” (binary plus) นั่นเป็นเหตุผลว่าทำไมในนิพจน์ "+apples + +oranges" เครื่องหมายบวกแบบเอกภาคจึงทำงานก่อนการบวก

งานที่มอบหมาย

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

นั่นเป็นเหตุผลว่าทำไมเมื่อเรากำหนดตัวแปร เช่น x = 2 * 2 + 1 การคำนวณจะเสร็จสิ้นก่อน จากนั้นจึงประเมิน = โดยจัดเก็บผลลัพธ์ไว้ใน x

 ให้ x = 2 * 2 + 1;

การแจ้งเตือน ( x ); // 5

การกำหนด = ส่งกลับค่า

ข้อเท็จจริงของการ = เป็นผู้ดำเนินการ ไม่ใช่โครงสร้างภาษา "มหัศจรรย์" มีความหมายที่น่าสนใจ

โอเปอเรเตอร์ทั้งหมดใน JavaScript ส่งกลับค่า นั่นชัดเจนสำหรับ + ​​และ - แต่ก็เป็นจริงสำหรับ = ด้วย

การเรียก x = value เขียน value ลงใน x แล้วส่งคืน

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

 ให้ = 1;
ให้ข = 2;

ให้ c = 3 - (a = b + 1);

การแจ้งเตือน (ก); // 3
การแจ้งเตือน (ค); // 0

ในตัวอย่างข้างต้น ผลลัพธ์ของนิพจน์ (a = b + 1) คือค่าที่กำหนดให้กับ a (นั่นคือ 3 ) แล้วนำไปใช้ในการประเมินต่อไป

รหัสตลกใช่มั้ย? เราควรเข้าใจวิธีการทำงาน เพราะบางครั้งเราเห็นมันในไลบรารี JavaScript

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

การมอบหมายการผูกมัด

คุณสมบัติที่น่าสนใจอีกประการหนึ่งคือความสามารถในการมอบหมายงานต่อเนื่อง:

 ให้ a, b, c;

ก = ข = ค = 2 + 2;

การแจ้งเตือน (ก); // 4
การแจ้งเตือน (ข); // 4
การแจ้งเตือน (ค); // 4

การมอบหมายงานแบบลูกโซ่ประเมินจากขวาไปซ้าย ขั้นแรก นิพจน์ขวาสุด 2 + 2 จะถูกประเมิน จากนั้นกำหนดให้กับตัวแปรทางด้านซ้าย: c , b และ a ท้ายที่สุดแล้ว ตัวแปรทั้งหมดจะใช้ค่าเดียวกันร่วมกัน

อีกครั้ง เพื่อให้ง่ายต่อการอ่าน ควรแบ่งโค้ดดังกล่าวออกเป็นสองสามบรรทัด:

 ค = 2 + 2;
ข = ค;
ก = ค;

อ่านง่ายกว่า โดยเฉพาะเมื่อสแกนโค้ดด้วยสายตาอย่างรวดเร็ว

ปรับเปลี่ยนในสถานที่

เรามักจะต้องใช้โอเปอเรเตอร์กับตัวแปรและเก็บผลลัพธ์ใหม่ไว้ในตัวแปรเดียวกันนั้น

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

 ให้ n = 2;
n = n + 5;
n = n * 2;

สัญกรณ์นี้สามารถย่อให้สั้นลงได้โดยใช้ตัวดำเนินการ += และ *= :

 ให้ n = 2;
n += 5; // ตอนนี้ n = 7 (เหมือนกับ n = n + 5)
n *= 2; // ตอนนี้ n = 14 (เหมือนกับ n = n * 2)

การแจ้งเตือน (n); // 14

ตัวดำเนินการ “แก้ไขและกำหนด” แบบสั้นมีอยู่สำหรับตัวดำเนินการทางคณิตศาสตร์และระดับบิตทั้งหมด: /= , -= ฯลฯ

ตัวดำเนินการดังกล่าวมีลำดับความสำคัญเหมือนกับการกำหนดปกติ ดังนั้นตัวดำเนินการดังกล่าวจึงทำงานตามการคำนวณอื่นๆ ส่วนใหญ่:

 ให้ n = 2;

n *= 3 + 5; // ประเมินส่วนขวาก่อน เช่นเดียวกับ n *= 8

การแจ้งเตือน (n); // 16

เพิ่ม/ลด

การเพิ่มหรือลดจำนวนทีละหนึ่งเป็นการดำเนินการทางตัวเลขที่พบบ่อยที่สุด

ดังนั้นจึงมีโอเปอเรเตอร์พิเศษสำหรับมัน:

• การเพิ่มขึ้น ++ เพิ่มตัวแปร 1:

   ให้เคาน์เตอร์ = 2;
  เคาน์เตอร์++;        // ทำงานเหมือนกับ counter = counter + 1 แต่สั้นกว่า
  การแจ้งเตือน (ตัวนับ); // 3

• การลดลง -- ลดตัวแปรลง 1:

   ให้เคาน์เตอร์ = 2;
  เคาน์เตอร์--;        // ทำงานเหมือนกับ counter = counter - 1 แต่สั้นกว่า
  การแจ้งเตือน (ตัวนับ); // 1

สำคัญ:

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

ตัวดำเนินการ ++ และ -- สามารถวางไว้ก่อนหรือหลังตัวแปรได้

• เมื่อโอเปอเรเตอร์ไล่ตามตัวแปร มันจะอยู่ใน "รูปแบบ postfix": counter++

• “แบบฟอร์มคำนำหน้า” คือเมื่อตัวดำเนินการไปก่อนตัวแปร: ++counter

ข้อความทั้งสองนี้ทำสิ่งเดียวกัน: เพิ่ม counter ด้วย 1

มีความแตกต่างหรือไม่? ใช่ แต่เราจะมองเห็นได้ก็ต่อเมื่อเราใช้ค่าที่ส่งคืนเป็น ++/--

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

หากต้องการดูความแตกต่าง ต่อไปนี้เป็นตัวอย่าง:

 ให้เคาน์เตอร์ = 1;
ปล่อยให้ a = ++ เคาน์เตอร์; -

การแจ้งเตือน (ก); // 2

ในบรรทัด (*) คำนำหน้า แบบฟอร์ม ++counter การเพิ่ม counter และส่งกลับค่าใหม่ 2 ดังนั้น alert จึงแสดง 2

ตอนนี้ ลองใช้แบบฟอร์ม postfix:

 ให้เคาน์เตอร์ = 1;
ให้ = เคาน์เตอร์ ++; // (*) เปลี่ยน ++ตัวนับต่อตัวนับ++

การแจ้งเตือน (ก); // 1

ในบรรทัด (*) ตัวนับแบบฟอร์ม postfix counter++ จะเพิ่ม counter ด้วย แต่ส่งคืนค่า เก่า (ก่อนที่จะเพิ่มขึ้น) ดังนั้น alert จะแสดง 1

สรุป:

• หากไม่ได้ใช้ผลลัพธ์ของการเพิ่มขึ้น/ลดลง จะไม่มีความแตกต่างในการใช้รูปแบบใด:

   ให้เคาน์เตอร์ = 0;
  เคาน์เตอร์++;
  ++เคาน์เตอร์;
  การแจ้งเตือน (ตัวนับ); // 2 บรรทัดด้านบนก็ทำเช่นเดียวกัน

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

   ให้เคาน์เตอร์ = 0;
  การแจ้งเตือน ( ++ ตัวนับ ); // 1

• หากเราต้องการเพิ่มค่าแต่ใช้ค่าก่อนหน้า เราจำเป็นต้องมีแบบฟอร์ม postfix:

   ให้เคาน์เตอร์ = 0;
  การแจ้งเตือน (ตัวนับ ++ ); // 0

เพิ่ม/ลดระหว่างตัวดำเนินการอื่นๆ

ตัวดำเนินการ ++/-- สามารถใช้ภายในนิพจน์ได้เช่นกัน ลำดับความสำคัญสูงกว่าการดำเนินการทางคณิตศาสตร์อื่นๆ ส่วนใหญ่

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

 ให้เคาน์เตอร์ = 1;
การแจ้งเตือน( 2 * ++ตัวนับ ); // 4

เปรียบเทียบกับ:

 ให้เคาน์เตอร์ = 1;
การแจ้งเตือน( 2 * ตัวนับ ++ ); // 2 เนื่องจาก counter++ ส่งกลับค่า "เก่า"

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

ในขณะที่อ่านโค้ด การสแกนตาแบบ "แนวตั้ง" ที่รวดเร็วอาจพลาดบางอย่างเช่น counter++ ได้อย่างง่ายดาย และจะไม่ชัดเจนว่าตัวแปรเพิ่มขึ้น

เราแนะนำสไตล์ "หนึ่งบรรทัด - หนึ่งการกระทำ":

 ให้เคาน์เตอร์ = 1;
การแจ้งเตือน( 2 * ตัวนับ );
เคาน์เตอร์++;

ตัวดำเนินการ Bitwise

ตัวดำเนินการ Bitwise ถือว่าอาร์กิวเมนต์เป็นตัวเลขจำนวนเต็ม 32 บิต และทำงานในระดับของการแทนค่าไบนารี่

โอเปอเรเตอร์เหล่านี้ไม่เฉพาะเจาะจงกับ JavaScript ได้รับการสนับสนุนในภาษาการเขียนโปรแกรมส่วนใหญ่

รายชื่อผู้ดำเนินการ:

• และ ( & )

• หรือ ( | )

• แฮคเกอร์ ( ^ )

• ไม่ ( ~ )

• เลื่อนซ้าย ( << )

• กะขวา ( >> )

• การเปลี่ยนเกียร์ขวาเป็นศูนย์ ( >>> )

โอเปอเรเตอร์เหล่านี้ไม่ค่อยได้ใช้ เมื่อเราต้องการเล่นกับตัวเลขในระดับต่ำสุด (ระดับบิต) เราจะไม่ต้องการโอเปอเรเตอร์เหล่านี้ในเร็วๆ นี้ เนื่องจากการพัฒนาเว็บไม่ค่อยได้ใช้โอเปอเรเตอร์เหล่านี้ แต่ในบางพื้นที่พิเศษ เช่น การเข้ารหัส จะมีประโยชน์ คุณสามารถอ่านบท Bitwise Operators บน MDN ได้เมื่อมีความจำเป็น

จุลภาค

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

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

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

 ให้ = (1 + 2, 3 + 4);

การแจ้งเตือน (ก); // 7 (ผลลัพธ์ของ 3 + 4)

ที่นี่ นิพจน์แรก 1 + 2 จะถูกประเมิน และผลลัพธ์จะถูกโยนทิ้งไป จากนั้น 3 + 4 จะถูกประเมินและส่งคืนตามผลลัพธ์

เครื่องหมายจุลภาคมีลำดับความสำคัญต่ำมาก

โปรดทราบว่าตัวดำเนินการเครื่องหมายจุลภาคมีลำดับความสำคัญต่ำมาก ต่ำกว่า = ดังนั้นวงเล็บจึงมีความสำคัญในตัวอย่างด้านบน

หากไม่มีพวกมัน: a = 1 + 2, 3 + 4 ประเมิน + ก่อน แล้วรวมตัวเลขเข้ากับ a = 3, 7 จากนั้นตัวดำเนินการมอบหมาย = กำหนด a = 3 และส่วนที่เหลือจะถูกละเว้น มันเหมือนกับ (a = 1 + 2), 3 + 4 .

เหตุใดเราจึงต้องมีโอเปอเรเตอร์ที่ทิ้งทุกอย่างยกเว้นนิพจน์สุดท้าย

บางครั้งผู้คนใช้มันในโครงสร้างที่ซับซ้อนมากขึ้นเพื่อรวมการกระทำหลายอย่างไว้ในบรรทัดเดียว

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

 // สามการดำเนินการในหนึ่งบรรทัด
สำหรับ (a = 1, b = 3, c = a * b; a < 10; a++) {
 -
-

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

งาน

แบบฟอร์มคำนำหน้าและคำนำหน้า

ความสำคัญ: 5

ค่าสุดท้ายของตัวแปรทั้งหมด a , b , c และ d หลังจากโค้ดด้านล่างคืออะไร

 ให้ a = 1, b = 1;

ให้ c = ++a; -
ให้ d = b++; -

สารละลาย

คำตอบคือ:

• a = 2

• b = 2

• c = 2

• d = 1

 ให้ a = 1, b = 1;

การแจ้งเตือน ( ++ก ); // 2 แบบฟอร์มคำนำหน้าส่งคืนค่าใหม่
การแจ้งเตือน (b++); // 1 แบบฟอร์ม postfix ส่งคืนค่าเก่า

การแจ้งเตือน (ก); // 2 เพิ่มขึ้นหนึ่งครั้ง
การแจ้งเตือน (ข); // 2 เพิ่มขึ้นหนึ่งครั้ง

ผลการมอบหมายงาน

ความสำคัญ: 3

ค่าของ a และ x หลังโค้ดด้านล่างเป็นเท่าใด

 ให้ = 2;

ให้ x = 1 + (a *= 2);

สารละลาย

คำตอบคือ:

• a = 4 (คูณด้วย 2)

• x = 5 (คำนวณเป็น 1 + 4)

ประเภทการแปลง

ความสำคัญ: 5

ผลลัพธ์ของนิพจน์เหล่านี้คืออะไร?

 "" + 1 + 0
"" - 1 + 0
จริง + เท็จ
6 / "3"
"2" * "3"
4 + 5 + "พิกเซล"
"$" + 4 + 5
"4" - 2
"4px" - 2
" -9 " + 5
" -9 " - 5
โมฆะ + 1
ไม่ได้กำหนด +1
" t n" - 2

คิดให้ดี จดบันทึก แล้วเปรียบเทียบกับคำตอบ

สารละลาย

 "" + 1 + 0 = "10" // (1)
"" - 1 + 0 = -1 // (2)
จริง + เท็จ = 1
6 / "3" = 2
"2" * "3" = 6
4 + 5 + "พิกเซล" = "9px"
"$" + 4 + 5 = "$45"
"4" - 2 = 2
"4px" - 2 = น่าน
" -9 " + 5 = " -9 5" // (3)
" -9 " - 5 = -14 // (4)
โมฆะ + 1 = 1 // (5)
ไม่ได้กำหนด + 1 = น่าน // (6)
" t n" - 2 = -2 // (7)

1. การบวกด้วยสตริง "" + 1 จะแปลง 1 เป็นสตริง: "" + 1 = "1" จากนั้นเรามี "1" + 0 จะใช้กฎเดียวกัน

2. การลบ - (เช่นเดียวกับการดำเนินการทางคณิตศาสตร์ส่วนใหญ่) ใช้ได้กับตัวเลขเท่านั้น โดยจะแปลงสตริงว่าง "" เป็น 0

3. การบวกด้วยสตริงจะผนวกเลข 5 เข้ากับสตริง

4. การลบจะแปลงเป็นตัวเลขเสมอ ดังนั้นจึงทำให้ " -9 " เป็นตัวเลข -9 (ไม่ต้องสนใจช่องว่างรอบๆ)

5. null กลายเป็น 0 หลังจากการแปลงตัวเลข

6. undefined จะกลายเป็น NaN หลังจากการแปลงตัวเลข

7. อักขระช่องว่างจะถูกตัดออกจากจุดเริ่มต้นและจุดสิ้นสุดของสตริงเมื่อแปลงสตริงเป็นตัวเลข ที่นี่สตริงทั้งหมดประกอบด้วยอักขระเว้นวรรค เช่น t , n และช่องว่าง "ปกติ" ระหว่างอักขระเหล่านั้น ดังนั้น ในทำนองเดียวกันกับสตริงว่าง มันจะกลายเป็น 0

แก้ไขการบวก

ความสำคัญ: 5

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

มันทำงานไม่ถูกต้อง ผลลัพธ์ในตัวอย่างด้านล่างคือ 12 (สำหรับค่าพร้อมท์เริ่มต้น)

ทำไม แก้ไขมัน ผลลัพธ์ควรเป็น 3

 ให้ a = prompt("หมายเลขแรก?", 1);
ให้ b = prompt("หมายเลขที่สอง?", 2);

การแจ้งเตือน (ก + ข); // 12

สารละลาย

เหตุผลก็คือพรอมต์ส่งคืนอินพุตของผู้ใช้เป็นสตริง

ดังนั้นตัวแปรจึงมีค่า "1" และ "2" ตามลำดับ

 ให้ = "1"; // prompt("หมายเลขแรก?", 1);
ให้ข = "2"; // prompt("หมายเลขที่สอง?", 2);

การแจ้งเตือน (ก + ข); // 12

สิ่งที่เราควรทำคือแปลงสตริงเป็นตัวเลขก่อน + ตัวอย่างเช่น การใช้ Number() หรือนำหน้าด้วย +

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

 ให้ a = +prompt("หมายเลขแรก?", 1);
ให้ b = +prompt("หมายเลขที่สอง?", 2);

การแจ้งเตือน (ก + ข); // 3

หรือใน alert :

 ให้ a = prompt("หมายเลขแรก?", 1);
ให้ b = prompt("หมายเลขที่สอง?", 2);

การแจ้งเตือน (+a + +b); // 3

ใช้ทั้ง unary และ binary + ในโค้ดล่าสุด ดูตลกใช่มั้ย?