Supratimas, kodėl nepavyksta palyginti „JavaScript“ su objektais „typeof“ patikrinime

Kodėl „JavaScript“ objektų palyginimas gali būti sudėtingas

„JavaScript“ yra universali ir stipri kalba, tačiau ji turi trūkumų. Viena tipiška spąsta, su kuria susiduria daugelis kūrėjų, yra suprasti, kaip veikia palyginimai, ypač kai kalbama apie objektų tipus. Problema dažnai iškyla lyginant tipas objektų, kurie gali sukelti netikėtų rezultatų.

Jei kada nors bandėte palyginti du objektus „JavaScript“, naudodami tipas, galbūt pastebėjote, kad tam tikri būdai veikia, o kiti ne. Jūsų kodas tam tikromis aplinkybėmis veiks nepriekaištingai, bet kitomis – ne, nors atrodo beveik panašus. Norint sukurti patikimesnį programavimą, labai svarbu suprasti, kodėl egzistuoja šie skirtumai.

Tai, kaip „JavaScript“ vertina išraiškas, dažnai yra šios painiavos šaltinis. Nuoseklus apdorojimas palyginimo operatoriai gali sukelti subtilių problemų. Šiame įraše išanalizuosime, kodėl naudojamas vienas palyginimas tipas veikia ir kodėl panašus nepavyksta, nors iš pradžių atrodo tikslus.

Peržiūrėsime vertinimo tvarką ir paaiškinsime, kodėl kai kurios frazės veikia ne taip, kaip tikėtasi. Darydami išvadą, turėsite daugiau žinių, kaip teisingai palyginti objektus „JavaScript“, išvengiant dažnų klaidų.

„JavaScript“ objektų palyginimo ir išraiškos įvertinimo supratimas

Ankstesni scenarijai išsprendžia dažną „JavaScript“ problemą, kai objektai lyginami su tipas operatorius. Problema kyla dėl to, kaip palyginimai struktūruojami ir vykdomi naudojant „JavaScript“. Pirmojo scenarijaus išraiška typeof(val1) === typeof(val2) === 'objektas' įvertina klaidingai dėl „JavaScript“ reiškinių apdorojimo iš kairės į dešinę. Užuot tikrinę, ar abi reikšmės yra objektai, pirmoji palyginimo dalis tipas(val1) === tipas(val2) įvertina į loginį dydį, kuris vėliau lyginamas su eilute 'objektas', duodantis netikėtą rezultatą.

Pataisytoje versijoje palyginimas perrašomas, kad būtų galima atskirai patikrinti kiekvienos reikšmės tipą naudojant typeof(val1) === 'objektas' && typeof(val2) === 'objektas'. Tai užtikrina, kad abi vertės yra objektai prieš tolesnį palyginimą. Griežto nelygybės operatoriaus naudojimas (!==), kad patikrintumėte, ar reikšmės nėra nulinis užtikrina, kad dirbame su galiojančiais objektais, kaip nulinis techniškai yra „JavaScript“ tipo „objektas“, o tai gali sukelti netikėtą elgesį, jei nėra aiškiai patikrinta.

Pagrindinė funkcija, palyginti objektus (), grąžina true, kai abi reikšmės yra objektai, o ne nulinės, o kitu atveju – false. Dėl šios inkapsuliacijos metodą galima pakartotinai naudoti ir nesudėtinga įtraukti į kelias kodų bazės dalis, kurioms reikia objektų palyginimo. Atskirdami vertinimą į atskiras situacijas, išvengiame netikslių išraiškų įvertinimų pavojų, todėl palyginimas yra patikimesnis.

Antrasis scenarijus tiria, kodėl tokia išraiška typeof(val1) === typeof(val2) === 'objektas' nepavyksta ir leidžia geriau suprasti, kaip operacijų tvarka veikia „JavaScript“ palyginimą. Tai pabrėžia būtinybę visiškai suprasti, kaip apdorojamos išraiškos, ypač lyginant sudėtingus duomenų tipus, pvz., objektus. Galime sukurti labiau nuspėjamą ir prižiūrimą kodą, vadovaudamiesi geriausia palyginimų organizavimo ir atitinkamų operatorių naudojimo praktika.

// Solution 1: Correct way to compare object types in JavaScript
function compareObjects(val1, val2) {
    if (typeof(val1) === 'object' && typeof(val2) === 'object' && val1 !== null && val2 !== null) {
        return true; // Both are objects and not null
    }
    return false; // One or both are not objects
}
// Example usage:
console.log(compareObjects({}, {})); // true
console.log(compareObjects(null, {})); // false
console.log(compareObjects([], {})); // true

// Solution 2: Understanding why typeof(val1) === typeof(val2) === 'object' fails
function incorrectComparison(val1, val2) {
    // typeof(val1) === typeof(val2) === 'object' is evaluated left to right
    // First: (typeof(val1) === typeof(val2)) evaluates to true or false
    // Then: true === 'object' or false === 'object' will always return false
    if (typeof(val1) === typeof(val2) === 'object' && val1 !== null && val2 !== null) {
        return true; // This condition will never be met
    }
    return false;
}
// Correct this by comparing each 'typeof' individually:
function correctComparison(val1, val2) {
    if (typeof(val1) === 'object' && typeof(val2) === 'object' && val1 !== null && val2 !== null) {
        return true;
    }
    return false;
}
// Example usage:
console.log(incorrectComparison({}, {})); // false
console.log(correctComparison({}, {})); // true

„JavaScript“ objektų palyginimo tyrinėjimas ne tik „typeof“

Suprasti skirtumą tarp nuorodų tipai ir vertės tipai yra labai svarbus „JavaScript“ objektų palyginimui. „JavaScript“ objektai yra nuorodų tipai, o tai reiškia, kad du tos pačios struktūros objektai nėra lygiaverčiai, nebent jie nurodo tą patį atminties adresą. Tai svarbu lyginant objektus, nes paprasčiausiai apžiūrint jų struktūrą tipas nėra adekvatus. Pavyzdžiui, {} nėra lygiavertis {} nes jie yra skirtingi atminties dalykai.

Norėdami tiksliai palyginti dviejų objektų turinį, kūrėjai dažnai taiko gilaus palyginimo metodus. „JavaScript“ neturi integruotos gilaus palyginimo funkcijos, todėl tokios bibliotekos kaip Lodašas pateikti tokius metodus _.isEqual išspręsti šią problemą. Kūrėjai taip pat gali sukurti savo rekursinę funkciją, kad nuodugniai palygintų objekto charakteristikas. Ypač svarbu valdyti situacijas, kai objektuose yra įdėtų objektų, nes kiekvienas lygis turi būti patikrintas, ar nėra lygybės.

Lyginant objektus, taip pat labai svarbu atsižvelgti į prototipo paveldėjimą. „JavaScript“ programoje kiekvienas objektas turi prototipą, iš kurio gaunamos savybės ir metodai. Norėdami palyginti du objektus pagal jų savybes (be prototipo savybių), naudokite Object.hasOwnProperty(). Šis metodas užtikrina, kad lyginant būtų naudojami tik tiesioginiai atributai, taip išvengiama netikėtų rezultatų dėl paveldėtų savybių.