ตัว ดำเนินการ NOT ระดับบิตหรือตัวดำเนินการส่วนเติมเต็มระดับบิตเป็นการดำเนิน การทางตรรกะ แบบเอกภาค ที่ทำการ ปฏิเสธทางตรรกะในแต่ละบิต เพื่อสร้างส่วนเติมเต็มหนึ่ง (ones' complement)ของค่าไบนารีที่กำหนด บิตที่เป็น 0 จะกลายเป็น 1 และบิตที่เป็น 1 จะกลายเป็น 0 ตัวอย่างเช่น:

ไม่ใช่0 111 (เลขฐานสิบ 7) = 1,000 (เลขฐานสิบ 8)

ไม่ใช่ 10101011 (เลขฐานสิบ 171) = 01010100 (เลขฐานสิบ 84)

ผลลัพธ์จะเท่ากับ ค่า สองส่วนเติมเต็มลบหนึ่ง ถ้าใช้เลขคณิตแบบสองส่วนเติมเต็มแล้วจะได้NOT x = -x − 1.

สำหรับจำนวนเต็มที่ ไม่ติดลบ ค่าผกผันบิตของจำนวนนั้นคือ "ภาพสะท้อน" ของจำนวนนั้นที่จุดกึ่งกลางของช่วงของจำนวนเต็มที่ไม่ติดลบ ตัวอย่างเช่น สำหรับจำนวนเต็มที่ไม่ติดลบ 8 บิตNOT x = 255 - xซึ่งสามารถมองเห็นได้บนกราฟเป็นเส้นตรงที่ลากลง ซึ่ง "พลิก" ช่วงที่เพิ่มขึ้นจาก 0 ถึง 255 ไปเป็นช่วงที่ลดลงจาก 255 ถึง 0 ตัวอย่างการใช้งานที่ง่ายแต่ชัดเจนคือการกลับภาพขาวดำโดยที่แต่ละพิกเซลถูกจัดเก็บเป็นจำนวนเต็มที่ไม่ติดลบ

การ ดำเนินการ AND ระดับบิตเป็นการดำเนินการทางตรรกะแบบไบนารีที่รับเอาการแสดงค่าไบนารีสองค่าที่มีความยาวเท่ากัน และทำการ ดำเนินการ AND ระดับบิตกับแต่ละคู่ของบิตที่สอดคล้องกัน ดังนั้น หากบิตทั้งสองในตำแหน่งที่เปรียบเทียบเป็น 1 บิตในการแสดงค่าไบนารีที่ได้จะเป็น 1 (1  × 1  = 1) มิเช่นนั้น ผลลัพธ์จะเป็น 0 (1  × 0  = 0 และ 0  × 0  = 0) ตัวอย่างเช่น:

 010 1 (เลขฐานสิบ 5) และ 001 1 (เลขฐานสิบ 3) = 000 1 (เลขฐานสิบ 1)

การดำเนินการนี้อาจใช้เพื่อตรวจสอบว่าบิตใดบิตหนึ่งถูกตั้งค่า (1) หรือถูกล้าง (0) หรือไม่ ตัวอย่างเช่น เมื่อกำหนดรูปแบบบิต 0011 (เลขฐานสิบ 3) เพื่อตรวจสอบว่าบิตที่สองถูกตั้งค่าหรือไม่ เราจะใช้การดำเนินการ AND แบบบิตกับรูปแบบบิตที่มีค่า 1 เฉพาะในบิตที่สองเท่านั้น:

 00 1 1 (เลขฐานสิบ 3) และ 00 1 0 (เลขฐานสิบ 2) = 00 1 0 (เลขฐานสิบ 2)

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

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

ตัวอย่างเช่น 0110 (เลขฐานสิบ 6) สามารถพิจารณาได้ว่าเป็นชุดของแฟล็กสี่ตัวที่เรียงลำดับจากขวาไปซ้าย โดยแฟล็กแรกและแฟล็กที่สี่เป็นค่าว่าง (0) และแฟล็กที่สองและแฟล็กที่สามเป็นค่าที่ตั้งไว้ (1) แฟล็กที่สามสามารถล้างค่าได้โดยใช้การดำเนินการ AND แบบบิตกับรูปแบบที่มีค่าศูนย์เฉพาะในบิตที่สามเท่านั้น:

 0 1 10 (เลขฐานสิบ 6) และ 1 0 11 (เลขฐานสิบ 11) = 0 0 10 (เลขฐานสิบ 2)

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

 011 0 (เลขฐานสิบ 6) และ 000 1 (เลขฐานสิบ 1) = 000 0 (เลขฐานสิบ 0)

เนื่องจาก 6 และ 1 รวมกันได้ศูนย์ ดังนั้น 6 จึงหารด้วย 2 ลงตัว และจึงเป็นจำนวนคู่

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

 0 101 (เลขฐานสิบ 5) หรือ 0 011 (เลขฐานสิบ 3) = 0 111 (เลขฐานสิบ 7)

สามารถใช้การดำเนินการ OR แบบบิตเพื่อตั้งค่าบิตที่เลือกในรีจิสเตอร์ที่อธิบายไว้ข้างต้นให้เป็น 1 ได้ ตัวอย่างเช่น บิตที่สี่ของ 0010 (เลขฐานสิบ 2) สามารถตั้งค่าได้โดยการดำเนินการ OR แบบบิตกับรูปแบบที่มีการตั้งค่าเฉพาะบิตที่สี่เท่านั้น:

0 0 1 0 (เลขฐานสิบ 2) หรือ1 0 0 0 (เลขฐานสิบ 8) = 1 0 1 0 (เลขฐานสิบ 10)

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

 0 10 1 (เลขฐานสิบ 5) XOR 0 01 1 (เลขฐานสิบ 3) = 0 11 0 (เลขฐานสิบ 6)

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

0 0 1 0 (เลขฐานสิบ 2) XOR 1 0 1 0 (เลขฐานสิบ 10) = 1 0 0 0 (เลขฐานสิบ 8)

เทคนิคนี้อาจใช้เพื่อจัดการรูปแบบบิตที่แสดงถึงชุดสถานะบูลีน

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

หาก เรามองว่าเซตของสตริงบิตที่มีความยาวคงที่n (เช่นคำของเครื่อง ) เป็น ปริภูมิเวกเตอร์nมิติ${\displaystyle {\bf {F}}_{2}^{n}}$ข้ามสนาม${\displaystyle {\bf {F}}_{2}}$ดังนั้น การบวกเวกเตอร์จึงสอดคล้องกับการดำเนินการ XOR ระดับบิต

สมมติว่า⁠${\displaystyle x\geq y}$สำหรับจำนวน เต็มที่ไม่เป็นลบ การดำเนินการแบบบิตไวส์สามารถเขียนได้ดังนี้:

${\displaystyle {\begin{aligned}\operatorname {NOT} (x)&=\sum _{n=0}^{\lfloor \log _{2}x\rfloor }2^{n}\left(\left(\left\lfloor {\frac {x}{2^{n}}}\right\rfloor {\bmod {2}}+1\right){\bmod {2}}\right)\\&=\left(2^{\lfloor \log _{2}x\rfloor +1}-1\right)-x\\[10pt]x\operatorname {AND} y&=\sum _{n=0}^{\lfloor \log _{2}x\rfloor }2^{n}\left(\left\lfloor {\frac {x}{2^{n}}}\right\rfloor {\bmod {2}}\right)\left(\left\lfloor {\frac {y}{2^{n}}}\right\rfloor {\bmod {2}}\right)\\[10pt]x\operatorname {OR} y&=\sum _{n=0}^{\lfloor \log _{2}x\rfloor }2^{n}{\Bigg (}\left\lfloor {\frac {x}{2^{n}}}\right\rfloor {\bmod {2}}+\left\lfloor {\frac {y}{2^{n}}}\right\rfloor {\bmod {2}}\\&\qquad \qquad -\left(\left\lfloor {\frac {x}{2^{n}}}\right\rfloor {\bmod {2}}\right)\left(\left\lfloor {\frac {y}{2^{n}}}\right\rfloor {\bmod {2}}\right){\Bigg )}\\[10pt]x\operatorname {XOR} y&=\sum _{n=0}^{\lfloor \log _{2}x\rfloor }2^{n}\left(\left(\left\lfloor {\frac {x}{2^{n}}}\right\rfloor +\left\lfloor {\frac {y}{2^{n}}}\right\rfloor \right){\bmod {2}}\right)\end{aligned}}}$

มีฟังก์ชันความจริง ที่เป็นไปได้ 16 แบบ สำหรับตัวแปรไบนารี สองตัว ซึ่งกำหนดตารางความจริง เรียกว่า ตารางค้นหา LUT2 หรือเรียกอีกอย่างว่าฟังก์ชันบูลีนลำดับ k =2 (อินพุต 2 ตัว) ผู้ผลิตบางรายใช้คำว่าconnective ^{[ 2 ]}สำหรับคำสั่งที่มีฟิลด์ 4 บิตที่ระบุตัวเชื่อมต่อไบนารีเฉพาะ ผู้ผลิตบางรายใช้คำว่าการดำเนินการบูลีน^{[ 3 ]}สำหรับรหัสคำสั่งที่แตกต่างกัน 16 แบบ

ต่อไปนี้คือการดำเนินการเทียบเท่าระดับบิตของบิตสองบิต P และ Q:

ค่าเทียบเท่าของเลขฐานสามคือฟังก์ชันบูลีน LUT3 อันดับ k=3 (อินพุตสามตัว) ซึ่งส่งผลให้ได้ตารางการดำเนินการ 256 รายการ และในทางคอมพิวเตอร์เรียกว่าคำสั่งตรรกะเลขฐานสามแบบบิต (Bitwise ternary logic instruction )

ถ้าความกว้างของรีจิสเตอร์ (โดยทั่วไปคือ 32 หรือแม้แต่ 64) มากกว่าจำนวนบิต (โดยปกติคือ 8) ของหน่วยที่เล็กที่สุดที่สามารถระบุตำแหน่งได้ ซึ่งมักเรียกว่าไบต์ การดำเนินการเลื่อนบิตจะเหนี่ยวนำให้เกิดรูปแบบการระบุตำแหน่งจากไบต์ไปเป็นบิต โดยที่ทิศทาง "ซ้าย" และ "ขวา" มาจากการเขียนตัวเลขมาตรฐานในระบบเลขฐานค่าประจำหลักกล่าวคือ การเลื่อนบิตไปทางซ้ายจะเพิ่มค่า และการเลื่อนบิตไปทางขวาจะลดค่าของตัวเลข ― ถ้าอ่านตัวเลขทางซ้ายก่อน จะทำให้เกิด การจัดเรียง แบบบิ๊กเอนเดียนโดยไม่คำนึงถึงผลกระทบที่ขอบเขตทั้งสองด้านของรีจิสเตอร์ การดำเนินการเลื่อนบิตทางคณิตศาสตร์และตรรกะจะทำงานเหมือนกัน และการเลื่อน บิต 8 ตำแหน่งจะเคลื่อนย้ายรูปแบบบิตไป 1  ตำแหน่งไบต์ในลักษณะต่อไปนี้:

การเรียงลำดับแบบ Little-endian :	การเลื่อนไปทางซ้าย 8 ตำแหน่ง จะเพิ่มที่อยู่ไบต์ขึ้น 1 ตำแหน่ง
	การเลื่อนบิตไปทางขวา 8 ตำแหน่ง จะทำให้แอดเดรสไบต์ลดลง 1 ตำแหน่ง
การเรียงลำดับ แบบบิ๊กเอนเดียน :	การเลื่อนไปทางซ้าย 8 ตำแหน่ง จะทำให้แอดเดรสไบต์ลดลง 1 ตำแหน่ง
	การเลื่อนบิตไปทางขวา 8 ตำแหน่ง จะเพิ่มที่อยู่ไบต์ขึ้น 1 ตำแหน่ง

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

ตัวอย่างนี้ใช้รีจิสเตอร์ 8 บิต ซึ่งถูกตีความว่าเป็นค่าสองคอมพลีเมนต์:

 00010111 (เลขฐานสิบ +23) เลื่อนซ้าย = 0010111 0 (เลขฐานสิบ +46)

 10010111 (เลขฐานสิบ −105) เลื่อนขวา = 1 1001011 (เลขฐานสิบ −53)

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

 00010111 (เลขฐานสิบ +23) เลื่อนซ้ายไปสอง = 010111 00 (เลขฐานสิบ +92)

การเลื่อนเลขคณิตไปทางซ้ายn ครั้งเทียบเท่ากับการคูณด้วย 2n ⁽โดยที่ค่าไม่เกินขีดจำกัด ) ในขณะที่การเลื่อนเลขคณิตไปทางขวาn ครั้ง ของ ค่า เลขฐานสองแบบส่วนเติมเต็มสองเทียบเท่ากับการปัดเศษลงของหารด้วย²ⁿหากเลขฐานสองนั้นถูกมองว่าเป็นแบบส่วนเติมเต็มหนึ่งการเลื่อนไปทางขวาแบบเดียวกันนี้จะส่งผลให้หารด้วย 2n ^และปัดเศษเข้าหาศูนย์

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

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

การ เลื่อนบิตอีกรูปแบบหนึ่งคือ การเลื่อน แบบวงกลมหรือ การ หมุนบิต

หมุน

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

หมุนผ่านขณะถือ

การหมุนผ่านตัวทด (Rotate through carry)เป็นรูปแบบหนึ่งของการดำเนินการหมุน โดยบิตที่ถูกเลื่อนเข้ามา (ที่ปลายด้านใดด้านหนึ่ง) จะเป็นค่าเดิมของแฟล็กตัวทด และบิตที่ถูกเลื่อนออกไป (ที่ปลายอีกด้านหนึ่ง) จะกลายเป็นค่าใหม่ของแฟล็กตัวทด

คำ สั่ง rotate through carryเพียงครั้งเดียวสามารถจำลองการเลื่อนบิตแบบตรรกะหรือแบบเลขคณิตได้หนึ่งตำแหน่ง โดยการตั้งค่าแฟล็ก carry ไว้ล่วงหน้า ตัวอย่างเช่น ถ้าแฟล็ก carry มีค่าเป็น 0 จะx RIGHT-ROTATE-THROUGH-CARRY-BY-ONEเป็นการเลื่อนบิตไปทางขวาแบบตรรกะ และถ้าแฟล็ก carry มีค่าเป็นสำเนาของบิตเครื่องหมาย จะx RIGHT-ROTATE-THROUGH-CARRY-BY-ONEเป็นการเลื่อนบิตไปทางขวาแบบเลขคณิต ด้วยเหตุนี้ ไมโครคอนโทรลเลอร์บางตัว เช่นPIC รุ่นราคาประหยัด จึง มีเพียง คำสั่ง rotateและrotate through carry เท่านั้น และไม่มีคำสั่งการเลื่อนบิตแบบเลขคณิตหรือแบบตรรกะเพิ่มเติม

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

• x & y = y & x
• x & (y & z) = (x & y) & z
• x & 0xFFFF = x^{[ 16 ]}
• x & 0 = 0

• x & x = x

• x | y = y | x
• x | (y | z) = (x | y) | z
• x | 0 = x
• x | 0xFFFF = 0xFFFF
• x | x = x

• ~(~x) = x

• x ^ y = y ^ x
• x ^ (y ^ z) = (x ^ y) ^ z
• x ^ 0 = x
• x ^ y ^ y = x
• x ^ x = 0
• x ^ 0xFFFF = ~x

นอกจากนี้ XOR ยังสามารถประกอบขึ้นจากโอเปอเรชันพื้นฐาน 3 อย่าง (AND, OR, NOT) ได้อีกด้วย

• a ^ b = (a | b) & (~a | ~b)
• a ^ b = (a & ~b) | (~a & b)

• x | (x & y) = x
• x & (x | y) = x
• ~(x | y) = ~x & ~y
• ~(x & y) = ~x | ~y
• x | (y & z) = (x | y) & (x | z)
• x & (y | z) = (x & y) | (x & z)
• x & (y ^ z) = (x & y) ^ (x & z)
• x + y = (x ^ y) + ((x & y) << 1)
• x - y = ~(~x + y)

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

• มีสิ่งที่ตรงกันข้าม
  • ไม่
  • เอ็กซ์ออร์
  • หมุนไปทางซ้าย
  • หมุนไปทางขวา
• ไม่มีสิ่งที่ตรงกันข้าม
  • และ
  • หรือ
  • เลื่อนไปทางซ้าย
  • เลื่อนไปทางขวา

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

• ( )
• ~ -^{[ 17 ]}
• * / %
• + -^{[ 18 ]}
• << >>
• &
• ^
• |