เรามาพูดถึงตัวดำเนินการ JavaScript กันดีกว่า

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

ตัวดำเนินการที่ใช้กันทั่วไปใน JavaScript ได้แก่

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

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

: สัญลักษณ์ที่ใช้ในการดำเนินการทางคณิตศาสตร์ ใช้ในการดำเนินการทางคณิตศาสตร์กับตัวแปรหรือค่าสองตัว

console.log(1 + 1); //2
    console.log(1 - 1); //0
    console.log(1*1); //1
    console.log(1/1); //1
    console.log(4 % 2); //0

ตัวเลขทศนิยมจะมีข้อผิดพลาดในการดำเนินการทางคณิตศาสตร์ (หลีกเลี่ยงการมีส่วนร่วมในการคำนวณโดยตรง):

console.log(0.1 + 0.2); //0.30000000000000004

ไม่สามารถระบุได้โดยตรงว่าตัวเลขทศนิยมสองตัวเป็น เท่ากัน.

วาร์นัม = 0.1 + 0.2;
    console.log(num == 0.3); //false

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

ประกอบด้วยตัวเลข

และค่าที่ส่ง

ตัวดำเนินการ สูตรที่ประกอบด้วย , ตัวแปร ฯลฯ เรียกว่านิพจน์

ในที่สุดนิพจน์จะส่งกลับผลลัพธ์มาให้เราซึ่งเรียกว่าค่าที่ส่งคืน

ตัวดำเนินการเพิ่มและลดค่า

หากคุณต้องการเพิ่มหรือลบ 1 ซ้ำๆ ให้กับตัวแปรตัวเลข คุณสามารถใช้ตัวดำเนินการเพิ่ม ( ++ ) และตัวดำเนินการลด ( -- ) เพื่อทำสิ่งนี้ให้สำเร็จ

การเขียนที่ซับซ้อน:

var num = 1;
    หมายเลข = หมายเลข + 1;
    หมายเลข = หมายเลข + 1;
    console.log(num); //3

ตัวดำเนินการเพิ่มคำนำหน้า:

++ ถูกเขียนไว้หน้าตัวแปร

++num การเพิ่มคำนำหน้าจะเพิ่มขึ้น 1 คล้ายกับ num=num+1

var age = 10;
    ++อายุ;
    console.log(age);//11 คล้ายกับสูตรการใช้งาน age = age + 1

: เพิ่มเข้าไปก่อนแล้วจึงคืนค่า

console.log(age);
    วาร์ ก = 10;
    console.log(++a + 10); //(10+1)+10=21

ตัวดำเนินการหลังการเพิ่ม

++ ถูกเขียนหลังตัวแปร

num++ หลังการเพิ่ม ซึ่งหมายถึงการเพิ่ม 1 ให้กับตัวเอง คล้ายกับ num=num+1

อายุ = 10;
    อายุ++;
    console.log(age);//11 คล้ายกับ

สูตรการใช้งาน age = age + 1: คืนค่าเดิมก่อน แล้วเติม

var a = 10;
    console.log(a++ + 10); //10+10=20
    console.log(a); //11

สรุปความแตกต่าง

• ตัวดำเนินการก่อนเพิ่มและหลังเพิ่มสามารถทำให้การเขียนโค้ดง่ายขึ้น ทำให้ค่าของตัวแปร +1 ง่ายกว่าเมื่อก่อน
• เมื่อใช้เพียงอย่างเดียวผลลัพธ์ก็เหมือนเดิม
• เมื่อใช้ร่วมกับโค้ดอื่นๆ ผลการดำเนินการจะแตกต่างออกไป
• คำบุพบท: เพิ่มตนเองก่อน แล้วจึงคำนวณ ( ก่อนตนเองก่อนผู้อื่น )
• Postposition: อันดับแรกให้คำนวณจากมูลค่าเดิม แล้วจึงบวกตัวเอง ( คนแรกก่อน แล้วจึงเพิ่มตัวเอง )
• ในการพัฒนา ส่วนใหญ่จะใช้การเพิ่ม/ลด postfix และโค้ดมีหนึ่งบรรทัด ตัวอย่าง: num++;

แบบฝึกหัด:

var e = 10;
    var f = e++ + ++e; //1.e++=10 e=11 2.++e=12 f=10+12
    console.log(f); //22

ตัวดำเนินการเปรียบเทียบ

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

console.log( 2 <= 5); //true
    console.log('Yue Zeyi' = 'บล็อกส่วนตัว'); //false
    console.log(17 == '17'); // ประเภทข้อมูลการแปลงเริ่มต้นที่แท้จริง ประเภทสตริงจะถูกแปลงเป็นประเภทตัวเลข console.log (17 = '17'); // ประเภทข้อมูลเท็จแตกต่างกัน ค่าและประเภทข้อมูล จำเป็นต้องมี การใช้

ตัวดำเนินการเชิงตรรกะ

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

logic AND

Symbol: && เป็นจริงเมื่อทั้งสองด้านของ และ

true true ตราบใดที่ด้านหนึ่งเป็น false ผลลัพธ์จะ false

false
    console.log(3 < 5 && 3 < 7); //

ตรรกะที่แท้จริงหรือ

สัญลักษณ์: || เทียบเท่ากับถ้า

ทั้งสองด้านของหรือเป็น false ผลลัพธ์จะเป็น false ใดที่ด้านหนึ่งเป็น true ผลลัพธ์จะเป็น true

console.log(3 > 5 && 3 > 2); //false
    console.log(3 < 5 && 3 < 7); //

!

การปฏิเสธเชิงตรรกะ

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

console.log(!true); //false
    console.log(!false); //

การดำเนินการลัดวงจรจริง (การหยุดชะงักเชิงตรรกะ)

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

ตรรกะ AND:

• ไวยากรณ์ :表达式1 && 表达式2
• หากนิพจน์แรกประเมินว่าเป็นจริง จะส่งกลับนิพจน์ 2
• หากนิพจน์แรกประเมินเป็นเท็จ จะส่งกลับนิพจน์ 1

console.log(123 && 456); //ส่งคืน 456 ตัวเลขทั้งหมด ยกเว้น 0 เป็นจริง
    console.log (123 && 456 && 789); // ส่งคืน 789, ดันกลับในลำดับ console.log (0 && 456); // 0

ตรรกะหรือ:

• ไวยากรณ์ :表达式1 || 表达式2
• หากผลลัพธ์ของนิพจน์ 1 คือ ถ้าเป็นจริง นิพจน์ 1 จะถูกส่งกลับ
• ถ้านิพจน์ 1 เป็นเท็จ นิพจน์ 2 จะถูกส่ง

กลับ
    console.log(123 || 456 || 123 + 456); //123
    console.log(0 || 456 || 123 + 456); //456

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

วาร์นัม = 0;
    console.log(123 || num++); // การหยุดชะงักทางลอจิกทำให้ num ++ ไม่ถูกดำเนินการ console.log (num); // 0

ของตัวดำเนินการกำหนด

: ตัวดำเนินการที่ใช้ในการกำหนดข้อมูลให้กับตัวแปร Assignment

var num = 5;
    หมายเลข += 10;
    console.log(หมายเลข); //5+10=15
    หมายเลข *= 3;
    console.log(num); //15*3=45

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

• ที่ไม่มีลำดับความสำคัญในตัวดำเนินการเอกภาคนั้นสูงมาก
• ตรรกะ AND มีลำดับความสำคัญสูงกว่าตรรกะ OR

console.log(4 >= 6 || 'I' != 'you' && !(12 * 2 == 144) && true); //true
    - 
    ตัวดำเนินการเชิงตรรกะถูกแบ่งออกเป็นสี่ส่วน 1.4 >= 6 เพื่อให้ได้รับค่าเท็จ
    2.'ฉัน' != 'คุณ' จะต้องเป็นจริง
    3.!(12 * 2 == 144) เป็นจริง
    4.จริง
    จากนั้นตัดสินตามตรรกะ AND: 2 และ 3 เป็นจริง 3 และ 4 เป็นจริง 
    จากนั้นตัดสินตามตรรกะหรือ: จริง
     -