Operatorlar — arifmetik, taqqoslash, mantiqiy, bitwise
Muammodan boshlaylik
console.log(0 == false); // true
console.log("" == false); // true
console.log(0 == ""); // true
// Demak: 0 == false, "" == false, 0 == "" — hammasi true
// Lekin bu mantiqan to'g'ri emas!
Bu JavaScript ning == operatori — "loose equality". Ko'pchilik shu sababli xatoga tushadi. Operatorlarni to'g'ri tushunmasdan, kutilmagan natijalar chiqadi.
Arifmetik operatorlar
Matematik amallar uchun:
10 + 3 // 13 — qo'shish
10 - 3 // 7 — ayirish
10 * 3 // 30 — ko'paytirish
10 / 3 // 3.3333... — bo'lish
10 % 3 // 1 — qoldiq (modulo)
10 ** 3 // 1000 — daraja (ES2016)
Modulo — qachon kerak?
% — bo'linmaning qoldig'ini beradi. Amalda juda ko'p ishlatiladi:
// Juft/toq tekshirish
n % 2 === 0 // juft
n % 2 !== 0 // toq
// Sikl ichida har N-elementda biror narsa qilish
if (i % 5 === 0) console.log("5 ga karrali");
// Vaqt hisoblash
const minutes = totalSeconds % 60;
const hours = Math.floor(totalSeconds / 3600);
Increment va Decrement
let x = 5;
x++; // x = 6 — keyin qaytaradi (postfix)
++x; // x = 7 — avval qaytaradi (prefix)
x--; // x = 6
--x; // x = 5
Farqi muhim bo'lgan holat:
let a = 5;
console.log(a++); // 5 — avval qaytaradi, keyin oshiradi
console.log(a); // 6
let b = 5;
console.log(++b); // 6 — avval oshiradi, keyin qaytaradi
String bilan +
+ operatori string bilan uchrashsa — qo'shish emas, birlashtirish qiladi:
"5" + 3 // "53" — string + number = string
5 + 3 + "1" // "81" — chapdan o'ngga: 5+3=8, keyin 8+"1"="81"
"1" + 5 + 3 // "153" — "1"+5="15", keyin "15"+3="153"
Nima uchun shunday? JavaScript chapdan o'ngga hisoblaydi. Birinchi operand string bo'lsa — keyingilarini ham string ga aylantiradi.
Taqqoslash operatorlari
== vs === — eng muhim farq
== — loose equality (bo'sh tenglik). Turlarni avtomatik o'zgartiradi, keyin taqqoslaydi.
=== — strict equality (qat'iy tenglik). Tur ham, qiymat ham bir xil bo'lishi kerak.
5 == "5" // true — "5" raqamga aylantirildi
5 === "5" // false — tur boshqa: number vs string
0 == false // true — false → 0 ga aylantirildi
0 === false // false — tur boshqa: number vs boolean
null == undefined // true — maxsus qoida
null === undefined // false — tur boshqa
Qoida: har doim === ishlatiladi. == faqat null tekshirishda qulay:
// null yoki undefined tekshirish — ikkalasini bir vaqtda
if (value == null) { ... } // value === null || value === undefined
Boshqa taqqoslash operatorlari
5 > 3 // true
5 < 3 // false
5 >= 5 // true
5 <= 4 // false
5 != 3 // true — loose: tur o'zgartiriladi
5 !== 3 // true — strict: tur ham tekshiriladi
String taqqoslash — leksikografik (alifbo tartibida):
"b" > "a" // true
"banana" > "apple" // true — birinchi harf b > a
"10" > "9" // false! — string taqqoslash: "1" < "9"
10 > 9 // true — raqam taqqoslash
Mantiqiy operatorlar
&& — VA (AND)
Ikkalasi true bo'lsa — true. Birinchi falsy qiymatni qaytaradi, aks holda oxirgisini.
true && true // true
true && false // false
// Qiymat qaytarish
"Ali" && "Vali" // "Vali" — ikkalasi truthy, oxirgisi qaytadi
0 && "Vali" // 0 — birinchi falsy, shu qaytadi
Amalda — shartli bajarish:
isLoggedIn && showDashboard(); // isLoggedIn true bo'lsa chaqiriladi
user && user.name && console.log(user.name); // xavfsiz zanjir
|| — YOKI (OR)
Biri true bo'lsa — true. Birinchi truthy qiymatni qaytaradi, aks holda oxirgisini.
"Ali" || "Vali" // "Ali" — birinchi truthy
0 || "Vali" // "Vali" — 0 falsy, keyingisi qaytadi
Amalda — default qiymat:
const name = inputName || "Mehmon"; // inputName bo'sh bo'lsa "Mehmon"
const port = process.env.PORT || 3000;
! — EMAS (NOT)
!true // false
!false // true
!0 // true
!"Ali" // false
!! — qiymatni boolean ga aylantirish:
!!"Ali" // true
!!0 // false
!!null // false
?? — Nullish Coalescing (ES2020)
|| ga o'xshash, lekin faqat null va undefined uchun ishlaydi. 0, "", false ni "bo'sh" deb hisoblamaydi.
0 || 100 // 100 — 0 falsy, shuning uchun 100
0 ?? 100 // 0 — 0 null/undefined emas, shuning uchun 0
null ?? "default" // "default"
undefined ?? "default" // "default"
"" ?? "default" // "" — "" null/undefined emas
Nima uchun ?? kerak? Foydalanuvchi 0 yoki "" kiritishi mumkin bo'lgan hollarda || noto'g'ri ishlaydi:
function setVolume(vol) {
const volume = vol || 50; // ❌ vol=0 bo'lsa ham 50 bo'ladi
const volume = vol ?? 50; // ✅ faqat null/undefined bo'lsa 50
}
Tayinlash operatorlari
x = 5; // oddiy tayinlash
x += 3; // x = x + 3
x -= 3; // x = x - 3
x *= 2; // x = x * 2
x /= 2; // x = x / 2
x %= 3; // x = x % 3
x **= 2; // x = x ** 2
x &&= y; // x truthy bo'lsa y tayinlanadi
x ||= y; // x falsy bo'lsa y tayinlanadi
x ??= y; // x null/undefined bo'lsa y tayinlanadi
Bitwise operatorlar
Raqamlarni ikkilik (binary) ko'rinishda boshqaradi. Kundalik kodda kam ishlatiladi.
5 & 3 // 1 — AND: 101 & 011 = 001
5 | 3 // 7 — OR: 101 | 011 = 111
5 ^ 3 // 6 — XOR: 101 ^ 011 = 110
~5 // -6 — NOT
5 << 1 // 10 — chapga siljitish (2 ga ko'paytirish)
5 >> 1 // 2 — o'ngga siljitish (2 ga bo'lish)
Tez-tez uchraydigan xatolar
== ishlatish:
if (user.role == 1) { ... } // ❌ "1" == 1 ham true bo'ladi
if (user.role === 1) { ... } // ✅
|| bilan 0 yoki "" ni yo'qotish:
const volume = vol || 50; // ❌ vol=0 bo'lsa ham 50 bo'ladi
const volume = vol ?? 50; // ✅ faqat null/undefined bo'lsa 50
String raqamlarni taqqoslash:
const a = "10";
const b = "9";
a > b // false — string taqqoslash: "1" < "9"
Number(a) > Number(b) // true — raqam taqqoslash
Xulosa
Arifmetik: +, -, *, /, %, **. + string bilan uchrashsa birlashtiradi.
Taqqoslash: har doim === va !==. == faqat null/undefined tekshirishda.
Mantiqiy: && birinchi falsyni, || birinchi truthyni qaytaradi. ?? faqat null/undefined uchun — 0 va "" ni o'tkazib yuboradi.
Keyingi dars
5-dars: Type Coercion — avtomatik tur o'zgartirish va uning xavflari