Agar siz veb-ilova yoki himoyalangan sahifa yaratayotgan bo'lsangiz, har doim foydalanishingiz kerak (faqat iloji bo'lsa)

===

chunki u bir xil tarkib yoki yo'qligini tekshiradi!

shuning uchun kimdir kirsa:

var check = 1;
if(check == '1') {
    //someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
}

lekin bilan

var check = 1;
if(check === 1) {
    //some continued with a number (no string) for your script
} else {
    alert('please enter a real number');
}

xaker hech qachon xatolarni topish va ilovangizni yoki foydalanuvchilaringizni buzish uchun tizimga chuqurroq kirmaydi

Mening fikrim shuki, bu

===

skriptlaringizga xavfsizlikni oshiradi

Albatta, siz kiritilgan raqamning haqiqiyligini, satr ekanligini va hokazolarni tekshirishingiz mumkin. Birinchi misol ichidagi boshqa if iboralari bilan, lekin buni hech bo'lmaganda men uchun tushunish va ishlatish osonroq.

Buni yozishimga sabab, bu suhbatda hech qachon “xavfsizroq” yoki “xavfsizlik” so‘zi aytilmagan (agar siz iCloud.com saytiga qarasangiz, u 2019 marta === va 1308 marta == ishlatadi, bu sizning ba'zan === o'rniga == dan foydalaning, chunki u aks holda sizning funktsiyangizni bloklaydi, lekin boshida aytib o'tilganidek, iloji boricha === dan foydalanishingiz kerak)

Sinovni o'tkazish uchun emacs org-mode va node.js dan foydalangan holda mening fikrlash jarayonim.

| use ==     | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          | 



| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

Quyidagi test skriptim: ishga tushirish > tugun xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}

=== ob'ektlar bir xil bo'lsa, g'amxo'rlik qiladi. Shuning uchun, new String("Hello world") === "Hello world" false qaytaradi. Biroq, == ob'ektlarning bir xil ekanligiga ahamiyat bermaydi; u shunchaki bitta argumentni boshqasining turiga aylantiradi: agar konvertatsiya qilishning iloji bo'lmasa, false ni qaytaring. Keyin new String("Hello world") == "Hello world" false o'rniga rostni qaytaradi.

Javascript zaif terilgan tildir, ya'ni C,c++ da bo'lgani kabi hech qanday ma'lumotlar turiga ega emas. int, mantiqiy, float va boshqalar. Shunday qilib, o'zgaruvchi har qanday turdagi qiymatni ushlab turishi mumkin, shuning uchun bu maxsus taqqoslash operatorlari mavjud

Eg

var i = 20;var j = "20";

Agar taqqoslash operatorlarini qo'llasak, bu o'zgaruvchilar natija bo'ladi

i==j //result is true

or

j != i//result is false

Buning uchun bizga o'zgaruvchiningqiymati va ma'lumotlar turini tekshiradigan maxsus taqqoslash operatorlari kerak.

if we do

i===j //result is false

=, = =, = = = orasidagi farq

• = operatori value ni belgilash uchun ishlatiladi.
• = = operatori datatype emas values ni solishtirish uchun ishlatiladi
• = = = operatori values va datatype raqamlarini solishtirish uchun ishlatiladi.

== operatori faqat ma'lumotlar turini emas, balki qiymatlarni solishtiradi.

=== operatori qiymatlarni ma'lumotlar turini solishtirish bilan solishtiradi.

eg :

1 == "1" //true

1 === "1" //false

Bu operator ("===") avtomatik translatsiyani amalga oshiradigan tillarda ishlatiladi, masalan. PHP, Javascript.
"===" operatori avtomatik yozish natijasida yuzaga keladigan kutilmagan taqqoslashlarning oldini olishga yordam beradi.

har doim '==='dan foydalaning va siz minglab xatolardan qochasiz. Hozirgi vaqtda uchlik tenglikdan foydalanish turli uslublar qo'llanmalari tomonidan ko'proq afzalroq, chunki u operandlar turini hisobga olgan holda taqqoslanadi.

Ha, tenglik == va identifikatsiya === operatorlari o'rtasida katta farq bor.
Odatda identifikatsiya operatori tezroq ishlaydi, chunki hech qanday turdagi konvertatsiya qilinmaydi. Ammo qiymatlar bir xil bo'lsa, siz hech qanday farqni ko'rmaysiz.
Mening postimni tekshiring JavaScript tenglik operatori afsonasi, unda ko'plab misollar bilan ma'lumotlarni, jumladan turlarni o'zgartirish va taqqoslash algoritmlarini tushuntiradi.

Bitta === dan foydalanish uchun eslatilmagan sabab - siz coffee-script ga/dan oʻzaro kompilyatsiya bilan birga boʻlganingizda. CoffeeScript haqida kichik kitobdan...

JavaScript-dagi zaif tenglikni taqqoslash ba'zi chalkash xatti-harakatlarga ega va ko'pincha chalkash xatolarning manbai hisoblanadi.

Buning o'rniga uchta teng belgidan iborat qat'iy tenglik operatoridan foydalanish kerak: ===. Bu oddiy tenglik operatori kabi ishlaydi, lekin hech qanday majburlashsiz. Har doim qat'iy tenglik operatoridan foydalanish va kerak bo'lganda turlarni aniq konvertatsiya qilish tavsiya etiladi.

Agar siz muntazam ravishda coffee-script ga va undan o'tayotgan bo'lsangiz, shunchaki === dan foydalaning. Aslida, coffee-script kompilyatori sizni majburlaydi...

CoffeeScript buni barcha zaif taqqoslashlarni qat'iy taqqoslashlar bilan almashtirish orqali hal qiladi, boshqacha qilib aytganda, barcha == taqqoslashlarini === ga aylantiradi. CoffeeScript-da zaif tenglikni taqqoslash mumkin emas va agar kerak bo'lsa, ularni solishtirishdan oldin turlarni aniq o'zgartirishingiz kerak.

Qattiq tenglik ko'p jihatdan yaxshiroqdir

Javascript bo'shashmasdan yozilgan til ekanligi, u bilan ishlayotganingizda doimo sizning fikringiz oldida bo'lishi kerak. Ma'lumotlar strukturasi bir xil bo'lsa, qat'iy tenglikdan foydalanmaslik uchun hech qanday sabab yo'q, muntazam tenglik bilan siz ko'pincha avtomatik ravishda sodir bo'ladigan qiymatlarni bilvosita o'zgartirasiz, bu sizning kodingizga keng qamrovli ta'sir ko'rsatishi mumkin. Ushbu konvertatsiya bilan bog'liq muammolarga duch kelish juda oson, chunki ular avtomatik ravishda sodir bo'ladi.

Qattiq tenglik bilan avtomatik yashirin konvertatsiya bo'lmaydi, chunki qiymatlar allaqachon to'g'ri ma'lumotlar tuzilishiga ega bo'lishi kerak.

Javascript xuddi PHP kabi erkin terilgan,

var x = "20";
var y =20;

if (x===y) // false

Bu sizga har doim noto'g'ri ma'lumot beradi, chunki o'zgaruvchilarning qiymatlari bir xil bo'lsa ham, ma'lumotlar turlari bir xil emas.

Biri string, ikkinchisi int

If(x==y)//true

Biroq, bu faqat ma'lumotlar turlaridan qat'i nazar, tarkibning bir xilligini tekshiradi ...

Men qiymatlarni teng deb aytmoqchi emasman, chunki string qiymati mantiqiy ravishda int qiymatiga teng bo'lishi mumkin emas

Birinchidan, Javascript satriga oid ba'zi terminologiya tengdir: Double equals rasman mavhum tenglikni taqqoslash operatori sifatida tanilgan, uch barobar esa qat'iy tenglikni taqqoslash operatori deb ataladi. Ularning orasidagi farqni quyidagicha umumlashtirish mumkin: Abstrakt tenglik taqqoslashdan oldin ma'lumotlar turlarini majburlash orqali hal qilishga harakat qiladi. Turlar boshqacha bo'lsa, qat'iy tenglik false qaytaradi. Quyidagi misolni ko'rib chiqing:

console.log(3 == "3"); // true
console.log(3 === "3"); // false.
console.log(3 == "3"); // true
console.log(3 === "3"); // false.

Ikkita teng belgidan foydalanish haqiqatni qaytaradi, chunki taqqoslashdan oldin “3” qatori 3 raqamiga aylantiriladi. Uchta teng belgi turlarning har xil ekanligini ko'radi va yolg'onni qaytaradi. Mana boshqasi:

console.log(true == '1'); // true
console.log(true === '1'); // false
console.log(true == '1'); // true
console.log(true === '1'); // false

Shunga qaramay, mavhum tenglikni taqqoslash turdagi konvertatsiyani amalga oshiradi. Bu holda mantiqiy to'g'ri va "1" qatori 1 raqamiga aylantiriladi va natija haqiqatdir. Qattiq tenglik yolg'onni qaytaradi.

Agar siz == va === ni farqlash yo'lida ekanligingizni tushunsangiz. Biroq, ushbu operatorlarning xatti-harakatlari intuitiv bo'lmagan ba'zi stsenariylar mavjud. Keling, yana bir nechta misollarni ko'rib chiqaylik:

console.log(undefined == null); // true
console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.
console.log(undefined == null); // true     
console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.

console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.log(true === 'true'); // false
console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.log(true === 'true'); // false

Quyidagi misol qiziqarli, chunki u satr literallari satr ob'ektlaridan farq qiladi.

console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false
console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false

== ni === bilan almashtirishni taklif qilishining sababi shundaki, === operatori == ga qaraganda ishonchliroq. Bizning kontekstimizda ishonchli vositalar === turini tekshirish uchun ham qo'llaniladi. Eng yaxshi dasturlash amaliyotlarini hisobga olgan holda, biz har doim kamroq ishonchli xususiyatdan ko'ra ishonchli xususiyatni tanlashimiz kerak. Ko'pincha operatorga to'liq tenglik haqida o'ylaganimizda, biz sukut bo'yicha tur bir xil bo'lishi kerak deb hisoblaymiz. === xuddi shunday ta'minlaganidek, biz bunga borishimiz kerak.

“JavaScript solishtirishda == yoki === dan foydalanishim kerakmi” dilemmasi quyidagi savolga teng yoki oʻxshash: “Ovqatlanish uchun“ qoshiq” yoki “vilka” dan foydalanishim kerakmi?

Bu savolga yagona mantiqiy javob shu

1. Taqqoslash uchun boʻsh tur uchun Dinamik tur solishtirishdan foydalaning, masalan:==.
2. Taqqoslash uchun kuchli tur uchun Statik tur solishtirishdan foydalaning, masalan:===.

Buning sababi, ular bir xil emas. Ular bir xil maqsadga ega emas va bir xil maqsadda foydalanish uchun mo'ljallanmagan.

Albatta, "vilkalar" ham, "qoshiqlar" ham "ovqatlanish" uchun mo'ljallangan, ammo siz ularni nima iste'mol qilganingizga qarab ishlatishni tanlaysiz.

Ma'nosi: siz "qoshiq" dan foydalanishga qaror qilasiz, ya'ni: "sho'rva" ichish uchun == va / yoki "vilkalar", ya'ni: === terish uchun.

"Ovqatlanish" uchun "vilka" yoki "qoshiq" dan foydalanish yaxshiroqmi degan savol - dinamik [==] va dinamik [==] tenglamasidan foydalanish yaxshiroqmi degan savolga tengdir. JSda. Ikkala savol ham bir xil darajada noto'g'ri va ko'rib chiqilayotgan mavzuni juda tor yoki sayoz tushunishni aks ettiradi.

Agar JavaScript-da bir nechta narsani solishtirmoqchi boʻlsangiz, === dan foydalaning, bu qat'iy tenglik deb ataladi, demak, agar faqat tur va qiymat bir xil boʻlsa bu rost boʻladi. Agar siz == dan foydalansangiz, siz asosan turga ahamiyat bermaysiz va ko'p hollarda bo'sh tenglikni taqqoslash bilan bog'liq muammolarga duch kelishingiz mumkin.

=== yordamida qat'iy tenglik

Qattiq tenglik tenglik uchun ikkita qiymatni taqqoslaydi. Hech bir qiymat solishtirishdan oldin bilvosita boshqa qiymatga aylantirilmaydi. Agar qiymatlar turli xil bo'lsa, qiymatlar teng emas deb hisoblanadi. Aks holda, agar qiymatlar bir xil turdagi bo'lsa va raqamlar bo'lmasa, ular bir xil qiymatga ega bo'lsa, ular teng hisoblanadi. Va nihoyat, agar ikkala qiymat ham raqamlar bo'lsa, ikkalasi ham NaN bo'lmasa va bir xil qiymatga ega bo'lsa yoki biri +0 va biri -0 bo'lsa, ular teng hisoblanadi.

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false

Bo'sh tenglik == yordamida

Bo'sh tenglik ikkala qiymatni umumiy turga aylantirgandan so'ng, tenglik uchun ikkita qiymatni taqqoslaydi. Konvertatsiyadan so'ng (bir yoki ikkala tomon ham konversiyadan o'tishi mumkin), yakuniy tenglikni taqqoslash xuddi === bajargandek amalga oshiriladi. Bo'sh tenglik simmetrikdir: A == B har doim A va B ning har qanday qiymatlari uchun B == A ga bir xil semantikaga ega (qo'llaniladigan konvertatsiya qilish tartibidan tashqari).

var num = 0;
var obj = new String('0');
var str = '0';

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// both false, except in rare cases
console.log(obj == null);
console.log(obj == undefined);

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Buni javoblardan birida ko'rgan. Bu holatda a va b bir xil tur emas, agar typeof(a) ni tekshirsangiz, siz 'obyekt'ni olasiz, typeof(b) esa 'string'.