Bagaimana untuk menentukan sama ada fasa adalah sama dalam JavaScript

Cara menentukan kesamaan dalam JavaScript: 1. Gunakan operator "==" atau "!=" untuk membandingkan sama ada nilai kedua-dua operan adalah sama 2. Gunakan "===" atau "! ==" operator, membandingkan sama ada nilai dua operan adalah sama dan menyemak sama ada jenisnya adalah sama.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi JavaScript 1.8.5, komputer Dell G3.

JavaScript menentukan kesaksamaan

Dalam JavaScript, anda boleh menggunakan ==, ===, !=, !== pengendali untuk menentukan kesamaan atau ketidaksamaan

等值检测运算符	说明
==（相等）	比较两个操作数的值是否相等
!=（不想等）	比较两个操作数的值是否不相等
===（全等）	比较两个操作数的值是否相等，同时检测它们的类型是否相同
!==（不全等）	比较两个操作数的值是否不相等，同时检测它们的类型是否不相同

Dalam operasi kesamaan, isu-isu berikut perlu diambil perhatian:

• Jika operan Jika ia adalah Nilai Boolean, ia ditukar kepada nilai berangka terlebih dahulu, di mana salah ditukar kepada 0 dan benar ditukar kepada 1.

• Jika satu operan ialah rentetan dan satu lagi operan ialah nombor, cuba tukar rentetan itu kepada nombor dahulu.

• Jika satu operan ialah rentetan dan satu lagi operan ialah objek, cuba tukar objek itu kepada rentetan dahulu.

• Jika satu operan ialah nombor dan satu lagi operan ialah objek, cuba tukar objek itu kepada nombor dahulu.

• Jika kedua-dua operan ialah objek, alamat rujukan akan dibandingkan. Jika alamat rujukan adalah sama, ia adalah sama;

Contoh 1

Berikut ialah perbandingan kesamaan operan khas.

console.log("1" == 1);  //返回true。字符串被转换为数字
console.log(true == 1);  //返回true。true被转换为1
console.log(false == 0);  //返回true。false被转换为0
console.log(null == 0);  //返回false
console.log(undefined == 0);  //返回false
console.log(undefined == null);  //返回true
console.log(NaN == "NaN");  //返回false
console.log(NaN ==1);  //返回false
console.log(NaN == NaN);  //返回false
console.log(NaN != NaN);  //返回true

NaN tidak sama dengan mana-mana nilai, termasuk dirinya sendiri. Nilai null dan undefined adalah sama, tetapi ia adalah jenis data yang berbeza. Dalam perbandingan kesamaan, null dan undefined tidak dibenarkan untuk ditukar kepada jenis nilai lain.

Contoh 2

Nilai dua pembolehubah berikut adalah sama.

var a = "abc" + "d";
var b = "a" + "bcd";
console.log(a == b);  //返回true

Operasi perbandingan kesamaan nilai berangka dan nilai Boolean adalah agak cekap, manakala rentetan perlu dibandingkan aksara mengikut watak, dan kecekapan operasi perbandingan kesamaan adalah agak rendah.

Dalam operasi kongruen, isu berikut perlu diberi perhatian:

• Jika kedua-dua operan adalah nilai mudah, selagi nilainya sama dan jenisnya adalah sama, Sama sahaja.

• Jika satu operan ialah nilai mudah dan satu lagi operan ialah objek komposit, ia tidak kongruen.

• Jika kedua-dua operan ialah objek komposit, bandingkan sama ada alamat rujukan adalah sama.

Contoh 3

Berikut ialah perbandingan kongruen bagi operan khas.

console.log(null === undefined);  //返回false
console.log(0 === "0");  //返回false
console.log(0 === false);  //返回false

Contoh 4

Berikut ialah perbandingan dua objek Memandangkan kedua-duanya merujuk kepada alamat yang sama, benar dikembalikan.

var a = {};
var b = a;
console.log(a === b);  //返回true

Walaupun dua objek berikut mempunyai struktur yang sama, ia mempunyai alamat yang berbeza, jadi ia tidak kongruen.

var a = {};
var b = {};
console.log(a === b);  //返回false

Contoh 5

Untuk objek komposit, alamat rujukan terutamanya dibandingkan, dan nilai objek tidak dibandingkan.

var a = new String("abcd);  //定义字符串“abcd”对象
var b = new String("abcd);  //定义字符串“abcd”对象
console.log(a === b);  //返回false
console.log(a == b);  //返回false

Dalam contoh di atas, nilai kedua-dua objek adalah sama, tetapi alamat rujukan adalah berbeza, jadi mereka tidak mahu menunggu dan tidak sama. Oleh itu, untuk objek komposit, hasil operasi kesamaan == dan kongruen === adalah sama.

Contoh 6

Untuk nilai mudah, selagi ia mempunyai jenis yang sama dan nilai yang sama, ia adalah kongruen, tanpa mengira perubahan proses operasi ungkapan atau pembolehubah alamat rujukan.

var a = "1" + 1;
var b = "11";
console.log(a ===b);  //返回true

Contoh 7

Ungkapan (a>b || a==b) tidak betul-betul sama dengan ungkapan (a>=b).

var a = 1;
var b = 2;
console.log((a > b || a == b) == (a >= b));  //返回true，此时似乎相等

Jika null dan undefined masing-masing ditugaskan kepada pembolehubah a dan b, nilai palsu dikembalikan, menunjukkan bahawa kedua-dua ungkapan itu tidak setara sepenuhnya.

var a = null;
var b = undefined;
console.log((a > b || a == b) == (a >= b));  //返回false，表达式的值并非相等

Oleh kerana null == undefined adalah sama dengan benar, nilai pulangan bagi ungkapan (a > b || a == b) adalah benar, tetapi nilai pulangan bagi ungkapan null > = undefined adalah palsu.

[Cadangan berkaitan: tutorial pembelajaran javascript]

Atas ialah kandungan terperinci Bagaimana untuk menentukan sama ada fasa adalah sama dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!