JavaScript Salīdzināšanas Operatori, jeb Comparison Operators

šajā apmācībā jūs uzzināsiet, kā izmantot JavaScript salīdzināšanas operatorus, lai salīdzinātu divas vērtības.

Ievads JavaScript salīdzināšanas operators

Lai salīdzinātu divas vērtības, izmantojiet salīdzināšanas operatoru. Šajā tabulā ir parādīti JavaScript salīdzināšanas operatori:

Salīdzināšanas operators atgriež Būlian (Boolean) vērtību, kas norāda, vai salīdzinājums ir patiess(true) vai nē(false). Skatiet šādu piemēru:

let r1 = 20 > 10; // true
let r2 = 20 < 10; // false
let r3 = 10 == 10; // true

Salīdzināšanas operatoram ir divas vērtības. Ja vērtību veidi nav salīdzināmi, salīdzināšanas operators pārvērš tos salīdzināmu tipu vērtībās saskaņā ar īpašiem noteikumiem.

Salīdziniet skaitļus

Ja vērtības ir skaitļi, salīdzināšanas operatori veic skaitlisku salīdzinājumu. 

Piemēram:

let a = 10,
b = 20;

console.log(a >= b); // false
console.log(a == 10); // true

Šis piemērs ir vienkāršs. Mainīgais a ir 10, b ir 20. Izteiksme a >= b atgriež nepatiesu(false) un izteiksme a == 10 atgriež patiesu(true).

Salīdziniet virknes
Ja operandi ir virknes, JavaScript salīdzina rakstzīmju kodus virknē pa vienam skaitliski.

let name1 = 'alice',
name2 = 'bob';

let result = name1 < name2;
console.log(result); // true
console.log(name1 == 'alice'); // true

Tā kā JavaScript salīdzina rakstzīmju kodus virknēs, jūs varat saņemt negaidītu rezultātu, piemēram:

let f1 = 'apple',
f2 = 'Banana';
let result = f2 < f1;
console.log(result); // true

Šajā piemērā f2 ir mazāks par f1, jo burtam B ir rakstzīmes kods 66, bet burtam a ir rakstzīmes kods 97.

Lai to labotu, veiciet tālāk norādītās darbības.

Vispirms pārveidojiet virknes parastā formātā — ar mazajiem vai lielajiem burtiem
Otrkārt, salīdziniet konvertētās vērtības
Piemēram:

let f1 = 'apple',
f2 = 'Banana';

let result = f2.toLowerCase() < f1.toLowerCase();
console.log(result); // false

Ņemiet vērā, ka toLowerCase() ir objekta String metode, kas pārvērš virkni mazajos burtos.

Salīdziniet skaitli ar cita veida vērtību
Ja vērtība ir skaitlis, bet otra nav, salīdzināšanas operators neskaitlisko vērtību pārveidos par skaitli un salīdzinās tos skaitliski. Piemēram:

console.log(10 < '20'); // true

Šajā piemērā salīdzināšanas operators pārvērš virkni “20” par skaitli 20 un salīdzina ar skaitli 10. Šeit ir piemērs:

console.log(10 == '10'); // true

Šajā piemērā salīdzināšanas operators pārvērš virkni “10” par skaitli 10 un salīdzina tos skaitliski.

Salīdziniet objektu ar objektu, kas nav objekts
Ja vērtība ir objekts, šī objekta metode valueOf() tiek izsaukta, lai atgrieztu vērtību salīdzināšanai. Ja objektam nav metodes valueOf(), tā vietā tiek izsaukta metode toString(). Piemēram:

let apple = {
valueOf: function () {
return 10;
},
};

let orange = {
toString: function () {
return '20';
},
};
console.log(apple > 10); // false
console.log(orange == 20); // true

Šajā pirmajā salīdzinājumā ābolu objektam ir metode valueOf(), kas atgriež 10. Tāpēc salīdzināšanas operators salīdzināšanai izmanto skaitli 10.

Otrajā salīdzinājumā JavaScript vispirms izsauc valueOf() metodi. Tomēr apelsīna objektam nav valueOf() metodes. Tātad JavaScript izsauc metodi toString(), lai salīdzinājumam iegūtu atgriezto vērtību 20.

Salīdziniet Būlean vērtību ar citu vērtību
Ja vērtība ir Būlean vērtība, JavaScript pārvērš to par skaitli un salīdzina konvertēto vērtību ar citu vērtību; true tiek pārvērsts par 1 un false tiek pārveidots par 0. Piemēram:

console.log(true > 0); // true
console.log(false < 1); // true
console.log(true > false); // true
console.log(false > true); // false
console.log(true >= true); // true
console.log(true <= true); // true
console.log(false <= false); // true
console.log(false >= false); // true

Papildus iepriekš minētajiem noteikumiem operatoriem vienāds (==) un nevienāds(!=) ir arī šādi noteikumi.

Salīdziniet nulles un undefined
Programmā JavaScript null ir vienāds ar undefined. Tas nozīmē, ka sekojošā izteiksme atgriež patiesu.

console.log(null == undefined); // true

Salīdziniet NaN ar citām vērtībām
Ja kāda no vērtībām ir NaN, tad vienāds operators (==) atgriež false.

console.log(NaN == 1); // false

Nevienāds (!=) operators atgriež patieso vērtību, salīdzinot NaN ar citu vērtību:

console.log(NaN != 1); // true

Stingri vienlīdzīgi (===) un ne stingri vienādi (!==)
Papildus iepriekš minētajiem salīdzināšanas operatoriem JavaScript nodrošina strikti vienādus ( ===) un ne strikti vienādus (!==) operatorus.

Stingri vienlīdzīgi un nevienlīdzīgi operatori uzvedas kā vienlīdzīgi un nevienlīdzīgi operatori, izņemot to, ka pirms salīdzināšanas tie nekonvertē operandu. Skatiet šādu piemēru:

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

Pirmajā salīdzinājumā, tā kā mēs izmantojam vienlīdzības operatoru, JavaScript pārvērš virkni skaitlī un veic salīdzināšanu.

Tomēr otrajā salīdzinājumā mēs izmantojam stingru vienādības operatoru ( ===), JavaScript nepārvērš virkni pirms salīdzināšanas, tāpēc rezultāts ir nepatiess.

Šajā apmācībā jūs uzzinājāt, kā vērtību salīdzināšanai izmantot JavaScript salīdzināšanas operatorus.