Operator logis Boolean - AND, OR, NOT, XOR

  • Artikel

Operator Boolean logis melakukan operasi logis dengan operand bool . Operator termasuk negasi logis unary (!), logis biner AND (&), OR (|), dan eksklusif OR (^), dan logis bersyarat biner AND (&&) dan OR (||).

Untuk operan tipe numerik integral , &, |, dan ^ operator melakukan operasi logika bitwise. Untuk informasi lebih lanjut, lihat Operator bitwise dan shift.

Operator negasi logis!

Operator awalan unary ! menghitung negasi logis dari operand-nya. Artinya, itu menghasilkan true, jika operan mengevaluasi ke false, dan false, jika operan mengevaluasi ke true:

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

Operator postfix ! unary adalah operator null-forgiving.

Operator LOGIS AND &

Operator & menghitung logika AND dari operandnya. Hasil dari x & y adalah true jika kedua x dan y mengevaluasi ke true. Jika tidak, hasilnya adalah false.

Operator & selalu mengevaluasi kedua operan. Ketika operand sebelah kiri mengevaluasi ke false, hasil operasi terlepas false dari nilai operand sebelah kanan. Namun, bahkan saat itu, operan sebelah kanan dievaluasi.

Dalam contoh berikut, operand sisi kanan operator & adalah panggilan metode, yang dilakukan terlepas dari nilai operand sebelah kiri:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Operator AND logis bersyarat&& juga menghitung logis AND dari operannya, tetapi tidak mengevaluasi operand tangan kanan jika operand sebelah kiri mengevaluasi ke false.

Untuk operand dari jenis numerik integral, & operator menghitung logis bitwise DAN operannya. Operator & unary adalah alamat operator.

Operator OR eksklusif logis

Operator ^ menghitung OR eksklusif logis, juga dikenal sebagai XOR logis, dari operand-nya. Hasil dari x ^ y adalah true jika x mengevaluasi kepada true dan y mengevaluasi ke false, atau x mengevaluasi kepada false dan y mengevaluasi kepada true. Jika tidak, hasilnya adalah false. Artinya, untuk operand bool, operator ^ menghitung hasil yang sama dengan operator pertidaksamaan!=.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Untuk operan dari jenis numerik integral, ^ operator menghitung eksklusif logis bitwise ATAU operannya.

Operator OR logis |

Operator | menghitung OR logis dari operand-nya. Hasil dari x | y adalah true jika salah satu x atau y bernilai true. Jika tidak, hasilnya adalah false.

Operator | selalu mengevaluasi kedua operan. Ketika operand sebelah kiri mengevaluasi ke true, hasil operasi terlepas true dari nilai operand sebelah kanan. Namun, bahkan saat itu, operan sebelah kanan dievaluasi.

Dalam contoh berikut, operand sisi kanan operator | adalah panggilan metode, yang dilakukan terlepas dari nilai operand sebelah kiri:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Operator AND logis bersyarat|| juga menghitung logis AND dari operannya, tetapi tidak mengevaluasi operand tangan kanan jika operand sebelah kiri mengevaluasi ke true.

Untuk operand dari jenis numerik integral, | operator menghitung logis bitwise DAN operand-nya.

Operator DAN logis kondisional &

Operator &&AND logis bersyarat, juga dikenal sebagai operator AND logis "short-circuiting", menghitung logis AND dari operandnya. Hasil dari x && y adalah true jika kedua x dan y mengevaluasi ke true. Jika tidak, hasilnya adalah false. Jika x dievaluasi ke false, y tidak dievaluasi.

Dalam contoh berikut, operand && kanan operator adalah panggilan metode, yang dilakukan terlepas dari nilai operand sebelah kirifalse:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Operator AND& logis juga menghitung logis AND dari operandnya, tetapi selalu mengevaluasi kedua operand.

Logika bersyarat OR operator ||

Operator OR logis bersyarat ||, juga dikenal sebagai operator OR logis "hubungan arus pendek", menghitung OR logis dari operan-operannya. Hasil dari x || y adalah true jika salah satu x atau y bernilai true. Jika tidak, hasilnya adalah false. Jika x dievaluasi ke true, y tidak dievaluasi.

Dalam contoh berikut, operand || kanan operator adalah panggilan metode, yang dilakukan terlepas dari nilai operand sebelah kiritrue:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Operator AND| logis juga menghitung logis AND dari operandnya, tetapi selalu mengevaluasi kedua operand.

Operator logika Boolean Nullable

Untuk bool? operand, & operator (logical AND) dan | (logical OR) mendukung logika tiga nilai sebagai berikut:

  • Operator & hanya menghasilkan true jika kedua operandnya dievaluasi ke true. Jika salah satu x atau y mengevaluasi ke false, x & y menghasilkan false (bahkan jika operand lain mengevaluasi ke null). Jika tidak, hasil dari x & y adalah null.

  • Operator | hanya menghasilkan false jika kedua operandnya dievaluasi ke false. Jika salah satu x atau y mengevaluasi ke true, x | y menghasilkan true (bahkan jika operand lain mengevaluasi ke null). Jika tidak, hasil dari x | y adalah null.

Tabel berikut menyajikan semantik tersebut:

x y x&y x\y
benar benar benar benar
benar salah salah benar
benar null null benar
salah benar salah benar
salah salah salah salah
salah nihil salah null
null benar nihil benar
nihil salah salah null
null null null null

Perilaku operator tersebut berbeda dari perilaku operator biasa dengan tipe nilai nullable. Biasanya, operator yang didefinisikan untuk operan dari jenis nilai juga dapat digunakan dengan operan dari jenis nilai nullable yang sesuai. Operator semacam itu menghasilkan null jika salah satu operandnya mengevaluasi ke null. Namun, operator & dan | bisa menghasilkan non-null bahkan jika salah satu operand mengevaluasi ke null. Untuk informasi selengkapnya tentang perilaku operator dengan jenis nilai yang bisa diubah ke null, lihat bagian Operator yang diangkat dari artikel Jenis nilai yang bisa diubah ke null.

Anda juga bisa menggunakan ! operator dan ^ dengan bool? operand, seperti yang ditunjukkan contoh berikut:

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Operator logis kondisional && dan || tidak mendukung bool? operand.

Penetapan campuran

Untuk op operator biner, ekspresi penetapan campuran dari formulir

x op= y

setara dengan:

x = x op y

kecuali x hanya dievaluasi sekali.

Operator &, |, dan ^ mendukung penetapan campuran, seperti yang ditunjukkan oleh contoh berikut:

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Catatan

Operator && logis kondisional dan || tidak mendukung penetapan mabung.

Prioritas operator

Daftar berikut ini mengurutkan operator aritmetika mulai dari prioritas tertinggi hingga terendah:

  • Operator logika negasi: !
  • Operator AND logis &
  • Operator OR eksklusif logis ^
  • Operator OR logis |
  • Operator AND logis kondisional &&
  • Operator AND logis kondisional ||

Gunakan tanda kurung (), untuk mengubah urutan evaluasi yang diberlakukan oleh prioritas operator:

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Untuk daftar lengkap operator C# yang diurutkan berdasarkan tingkat prioritas, lihat bagian Prioritas operator dari artikel operator C#.

Kelebihan beban operator

Tipe yang ditentukan pengguna dapat membebani operator !, &, |, dan operator ^. JIka operator biner kelebihan beban, operator penetapan campuran yang sesuai juga secara implisit kelebihan beban. Jenis yang ditentukan pengguna tidak dapat secara eksplisit membebani operator penetapan majemuk.

Jenis yang ditentukan pengguna tidak dapat membebani operator && logis kondisional dan ||. Namun, jika jenis yang ditentukan pengguna membebani operator benar dan salah dan & operator atau | dengan cara tertentu, && operasi atau ||, masing-masing, bisa dievaluasi untuk operand jenis tersebut. Untuk informasi selengkapnya, lihat bagian Operator logis kondisional yang ditentukan pengguna dari bagian spesifikasi bahasa C#.

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihat bagian berikut dari spesifikasi bahasa C#:

Lihat juga