JavaScript kar┼č─▒la┼čt─▒rmalar─▒nda hangi e┼čittir operat├Âr├╝ (== vs ===) kullan─▒lmal─▒d─▒r?


Al─▒nan cevaba git


JavaScript'i kullanmak i├žin JSLint kullan─▒yorum ve bir ifadenin i├žinde kar┼č─▒la┼čt─▒rma yapmak gibi ┼čeyler yaparken == (iki e┼čittir i┼čareti) === (├╝├ž e┼čittir i┼čareti) ile de─či┼čtirmek i├žin bir├žok ├Âneri getiriyor . idSele_UNVEHtype.value.length == 0 if

De─či┼čtirilmesi i├žin bir performans yarar─▒ var m─▒d─▒r == ile === ?

Herhangi bir performans iyile┼čtirmesi bir├žok kar┼č─▒la┼čt─▒rma operat├Âr├╝ bulundu─čundan memnuniyetle kar┼č─▒lanacakt─▒r.

Herhangi bir t├╝r d├Ân├╝┼č├╝m ger├žekle┼čmezse, performans art─▒┼č─▒ elde edilebilir == mi?


5666









Cevap say─▒s─▒n─▒ say: 30






─░dentity ( === ) operat├Âr├╝, == t├╝r d├Ân├╝┼čt├╝rmesi yap─▒lmad─▒─č─▒ s├╝rece e┼čitlik ( ) operat├Âr├╝ne ayn─▒ ┼čekilde davran─▒r ve t├╝rlerin e┼čit olarak kabul edilmesi gereken ayn─▒ olmas─▒ gerekir.

Referans: Javascript E─čitimi: Kar┼č─▒la┼čt─▒rma Operat├Ârleri

== Operat├Âr e┼čitlik kar┼č─▒la┼čt─▒r─▒r gerekli tip d├Ân├╝┼č├╝mleri yapt─▒ktan sonra . === Operat├Âr olacak de─čil iki de─čer de─čil ayn─▒ t├╝r├╝d├╝r e─čer ├Âyleyse, d├Ân├╝┼č├╝m yapmak === basit├že d├Ânecektir false . Her ikisi de e┼čit derecede h─▒zl─▒.

Douglas Crockford'un m├╝kemmel JavaScript'inden al─▒nt─▒ yapmak i├žin : The Good Parts ,

JavaScript'in iki e┼čitlik operat├Âr├╝ vard─▒r: === ve !== , ve onlar─▒n k├Ât├╝ ikizleri == ve != . ─░yi olanlar bekledi─činiz gibi ├žal─▒┼č─▒r. ─░ki i┼členen ayn─▒ t├╝rde ve ayn─▒ de─čere sahipse, o zaman === ├╝retir true ve !== ├╝retir false . K├Ât├╝ ikizler, operandlar ayn─▒ tip oldu─čunda do─čru olan─▒ yaparlar, ancak farkl─▒ tiplerdeyse de─čerleri zorlamaya ├žal─▒┼č─▒rlar. Yapt─▒klar─▒ kurallar karma┼č─▒k ve unutulmaz. Bunlar ilgin├ž durumlardan baz─▒lar─▒:

 '' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true
 

Ge├ži┼č eksikli─či endi┼če verici. Tavsiyem asla k├Ât├╝ ikizleri kullanmamak. Bunun yerine, her zaman === ve kullan─▒n !== . Az ├Ânce g├Âsterilen kar┼č─▒la┼čt─▒rmalar─▒n t├╝m├╝ operat├Ârle false birlikte === ├╝retilir.


G├╝ncelle┼čtirme:

─░yi bir nokta taraf─▒ndan yeti┼čtirildim @Casebash yorumlarda ve @Phillipe Laybaert en cevab─▒ ili┼čkin ba┼čvuru t├╝rleri. Referans tipleri i├žin == ve === birbirleriyle tutarl─▒ hareket edin (├Âzel bir durum hari├ž).

 var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true
 

├ľzel durum, de─či┼čmezi, ayn─▒ de─či┼čmezle, kendi y├Ântemi toString veya valueOf y├Ântemi nedeniyle de─čerlendiren bir nesneyle kar┼č─▒la┼čt─▒rd─▒─č─▒n─▒zda ortaya ├ž─▒kar . ├ľrne─čin, bir haz─▒r bilgi dizgesinin String kurucu taraf─▒ndan olu┼čturulan bir dizgi nesnesiyle kar┼č─▒la┼čt─▒r─▒lmas─▒n─▒ d├╝┼č├╝n├╝n .

 "abc" == new String("abc")    // true
"abc" === new String("abc")   // false
 

Burada == operat├Âr iki nesnenin de─čerlerini kontrol ediyor ve geri geliyor true , ama === ayn─▒ tip olmad─▒─č─▒n─▒ ve geri d├Ând├╝─č├╝n├╝ g├Âr├╝yor false . Hangisi do─čru? Bu ger├žekten kar┼č─▒la┼čt─▒rmaya ├žal─▒┼čt─▒─č─▒n─▒z ┼čeye ba─čl─▒d─▒r. Tavsiyem soruyu tamamen atlamak ve sadece String string nesneleri olu┼čturmak i├žin yap─▒c─▒y─▒ kullanmamakt─▒r .

Referans
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3


6301







Kullan─▒lmas─▒ == operat├Âr├╝ ( E┼čitlik )

 true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared
 

Kullan─▒lmas─▒ === operat├Âr├╝ ( Kimlik )

 true === 1; //false
"2" === 2;  //false
 

Bunun nedeni, e┼čitlik operat├Âr├╝n├╝n == zorlama t├╝r├╝ yapmas─▒d─▒r ; bu, yorumlay─▒c─▒n─▒n kar┼č─▒la┼čt─▒rmadan ├Ânce de─čerleri d├Ân├╝┼čt├╝rmeye ├žal─▒┼čt─▒─č─▒ anlam─▒na gelir.

├ľte yandan, kimlik operat├Âr├╝ === zorlama t├╝r├╝ yapmaz ve bu nedenle kar┼č─▒la┼čt─▒r─▒rken de─čerleri d├Ân├╝┼čt├╝rmez ve bu nedenle ( Bu JS k─▒yaslama testine g├Âre) bir ad─▒m─▒ atlad─▒─č─▒ndan daha h─▒zl─▒d─▒r .


1102







== Ve aras─▒ndaki e┼čitlik kar┼č─▒la┼čt─▒rmas─▒n─▒n ilgin├ž bir resimsel g├Âsterimi === .

Kaynak: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

=== JavaScript e┼čitlik testi i├žin kullan─▒rken , her ┼čey oldu─ču gibi. Hi├žbir ┼čey de─čerlendirilmeden ├Ânce d├Ân├╝┼čt├╝r├╝lmez.


JS'de === E┼čitlik de─čerlendirmesi


var1 == var2

== JavaScript e┼čitlik testi i├žin kullan─▒ld─▒─č─▒nda baz─▒ korkak d├Ân├╝┼č├╝mler ger├žekle┼čir.


JS'de == E┼čitlik de─čerlendirmesi

Hikayeden ├ž─▒kar─▒lacak ders:

Birlikte === ger├žekle┼čen d├Ân├╝┼č├╝mleri tam olarak anlamad─▒─č─▒n─▒z s├╝rece kullan─▒n == .


678


2014-05-05





Buradaki cevaplarda, e┼čittir ne anlama geldi─či hakk─▒nda bir ┼čey okumad─▒m . Baz─▒ diyecekler === ara├žlar─▒ ve ayn─▒ tipte e┼čit , ama bu ger├žekten do─čru de─čil. Asl─▒nda, her iki i┼členenin de ayn─▒ nesneye ba┼čvurdu─ču veya de─čer t├╝rlerinde ayn─▒ de─čere sahip oldu─ču anlam─▒na gelir .

├ľyleyse a┼ča─č─▒daki kodu alal─▒m:

 var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true
 

Burada da ayn─▒:

 var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true
 

Ya da:

 var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true
 

Bu davran─▒┼č her zaman a├ž─▒k de─čildir. Hikayede, e┼čit olmak ve ayn─▒ tipte olmaktan daha fazlas─▒ var.

Kural:

De─čer t├╝rleri i├žin (say─▒lar): ayn─▒ de─čere
a === b sahipse a ve b ayn─▒t├╝rdeyse true de─čerini d├Ând├╝r├╝r

Referans t├╝rleri i├žin:
a === b d├Âner do─čru ise a ve b tam olarak ayn─▒ nesneye referans

: Dizeleri i├žin
a === b true d├Ând├╝r├╝r a ve b tam ayn─▒ karakterlerle hem dizeleri ve i├žermek


Dizeler: ├Âzel durum ...

Dizeler de─čer t├╝rleri de─čildir, ancak Javascript'te de─čer t├╝rleri gibi davran─▒rlar, bu nedenle dizedeki karakterler ayn─▒ oldu─čunda ve ayn─▒ uzunlukta olduklar─▒nda (├╝├ž├╝nc├╝ kuralda a├ž─▒kland─▒─č─▒ gibi) "e┼čit" olurlar

┼×imdi ilgin├žle┼čiyor:

 var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types
 

Ama buna ne dersin?

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

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

Dizelerin de─čer t├╝rleri gibi davrand─▒─č─▒n─▒ d├╝┼č├╝nd├╝m? Kime sordu─čuna ba─čl─▒ ... Bu durumda a ve b ayn─▒ tip de─čil. a t├╝r├╝nde Object iken b t├╝r string . Yap─▒c─▒y─▒ kullanarak bir dize nesnesi olu┼čturman─▒n ├žo─ču zaman bir dize g├Ârevi g├Âren String t├╝rde bir ┼čey olu┼čturdu─čunu unutmay─▒n . Object


603







Bu dan─▒┼čman─▒ ekleyeyim:

┼×├╝pheniz varsa, spesifikasyonu okuyun !

ECMA-262, JavaScript'in leh├že oldu─ču bir betik dili i├žin ┼čartnamedir. Elbette pratikte, en ├Ânemli taray─▒c─▒lar─▒n, bir ┼čeyin nas─▒l kullan─▒lmas─▒ gerekti─či ile ilgili ezoterik bir tan─▒mdan daha ├žok nas─▒l davrand─▒─č─▒ daha ├Ânemlidir. Ancak neden yeni String'in ("a")! == "a" oldu─čunu anlamak yard─▒mc─▒ olacakt─▒r .

L├╝tfen bu soruyu netle┼čtirmek i├žin ├Âzellikleri nas─▒l okuyaca─č─▒m─▒ a├ž─▒klayay─▒m. Bu ├žok eski konuda kimsenin ├žok garip etki i├žin bir cevab─▒ olmad─▒─č─▒n─▒ g├Âr├╝yorum. Bu nedenle, bir ┼čartnameyi okuyabiliyorsan─▒z, bu size mesle─činizde ├žok yard─▒mc─▒ olacakt─▒r. Bu edinilmi┼č bir beceridir. ├ľyleyse devam edelim.

PDF dosyas─▒n─▒ === i├žin aramak beni ┼čartnamenin 56. sayfas─▒na getiriyor: 11.9.4. S─▒k─▒ E┼čit Operat├Âr (===) ve ┼čartnameye bakt─▒ktan sonra ┼čunlar─▒ buldum:

11.9.6 Kat─▒ E┼čitlik Kar┼č─▒la┼čt─▒rma Algoritmas─▒
X ve y'nin oldu─ču x ve = y = kar┼č─▒la┼čt─▒rmas─▒ do─čru veya yanl─▒┼č ├╝retir . B├Âyle bir kar┼č─▒la┼čt─▒rma a┼ča─č─▒daki gibi yap─▒l─▒r:
  1. Tip (x), Tip (y) den farkl─▒ysa false d├Ând├╝r├╝n .
  2. Tip (x) Tan─▒ms─▒z ise, true de─čerini d├Ând├╝r├╝n .
  3. Type (x) Null ise, true de─čerini d├Ând├╝r├╝n .
  4. T├╝r (x) Say─▒ de─čilse, ad─▒m 11'e gidin.
  5. x, NaN ise false d├Ând├╝r├╝n .
  6. y, NaN ise , false d├Ând├╝r├╝n .
  7. E─čer x, y ile ayn─▒ say─▒ de─čerindeyse, true de─čerini d├Ând├╝r├╝n .
  8. x +0 ve y Ôłĺ0 ise, true de─čerini d├Ând├╝r├╝n .
  9. x, Ôłĺ0 ve y +0 ise, true de─čerini d├Ând├╝r├╝n .
  10. false d├Ând├╝r .
  11. E─čer Tip (x) String, daha sonra geri olan ger├žek x ise ve y tam karakter (ayn─▒ uzunluk ve kar┼č─▒l─▒k gelen pozisyonlarda, ayn─▒ karakterler) ayn─▒ dizi oldu─čunu; Aksi takdirde, false d├Ând├╝r├╝n .
  Tip (x), Boolean ise, geri 12. do─čru x ve y her ikisi de, e─čer do─čru ya da her ikisi false ; Aksi takdirde, false d├Ând├╝r├╝n .
  13. E─čer x ve y ayn─▒ nesneye ba┼čvuruyorsa veya birbirlerine birle┼čtirilen nesnelere at─▒f yap─▒yorsa true de─čerini d├Ând├╝r├╝n (bkz. 13.1.2). Aksi takdirde, false d├Ând├╝r├╝n .

─░lgin├ž ad─▒m 11'dir. Evet, dizgiler de─čer t├╝rleri olarak kabul edilir. Ancak bu neden yeni String'in ("a")! == "a" oldu─čunu a├ž─▒klam─▒yor . ECMA-262 ile uyumlu olmayan bir taray─▒c─▒m─▒z var m─▒?

├çok h─▒zl─▒ de─čil!

─░┼členenlerin t├╝rlerini kontrol edelim. Bunlar─▒ typeof () i├žine alarak kendiniz deneyin . Yeni String'in ("a") bir nesne oldu─čunu ve ad─▒m 1'in kullan─▒ld─▒─č─▒n─▒ buldum : t├╝rler farkl─▒ysa false d├Ân .

Yeni String'in ("a") neden bir dize d├Ând├╝rmedi─čini merak ediyorsan─▒z , bir spesifikasyonu okumaya ne dersiniz? ─░yi e─členceler!


Aidiakapi bunu a┼ča─č─▒daki yorumda yazd─▒:

┼×artname

11.2.2 Yeni Operat├Âr :

Type (constructor) Object de─čilse, bir TypeError istisnas─▒ at─▒n.

Ba┼čka bir deyi┼čle, String, Object t├╝r├╝nde de─čilse, yeni operat├Ârle birlikte kullan─▒lamaz.

new , String yap─▒c─▒lar i├žin bile, daima bir Object d├Ând├╝r├╝r . Ve ne yaz─▒k ki! Dizgelerin semantikleri (bkz. Ad─▒m 11) kaybedilmi┼čtir.

Ve bu nihayet demek: yeni String ("a")! == "a" .


264







PHP ve JavaScript'te kat─▒ bir e┼čitlik operat├Âr├╝d├╝r. Bu, hem t├╝r├╝ hem de de─čerleri kar┼č─▒la┼čt─▒raca─č─▒ anlam─▒na gelir.


101







Bunu Firefox'ta Firebug ile ┼č├Âyle bir kod kullanarak test ettim :

 console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");
 

ve

 console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");
 

Sonu├žlar─▒m (her biri be┼č kez test edildi ve ortalamas─▒ al─▒nd─▒):

 ==: 115.2
===: 114.4
 

Bu y├╝zden, minik fark─▒n (bu 100000'in ├╝zerinde yinelemedir, hat─▒rlay─▒n) ihmal edilebilir oldu─čunu s├Âyleyebilirim. Performans yapmak i├žin bir neden de─čildir === . G├╝venli─či yaz─▒n (peki, JavaScriptÔÇÖte alaca─č─▒n─▒z kadar g├╝venli) ve kod kalitesi de ├Âyle.


96







JavaScript'te ayn─▒ de─čer ve t├╝rde anlam─▒na gelir.

├ľrne─čin,

 4 == "4" // will return true
 

fakat

 4 === "4" // will return false 
 

94







=== operat├Âr, s─▒k─▒ bir kar┼č─▒la┼čt─▒rma operat├Âr├╝ denir gelmez farkl─▒l─▒k == operat├Âr├╝.

2 de─či┼čken a ve b alal─▒m.

─░├žin "bir == b" olmak ger├žek a ve b ihtiyac─▒na de─čerlendirmek ayn─▒ de─čeri .

"A === b" durumunda, a ve b ayn─▒ de─čerde olmal─▒ ve do─čru olarak de─čerlendirilebilmesi i├žin ayn─▒ tip olmal─▒d─▒r .

A┼ča─č─▒daki ├Ârne─či al

 var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}
 

├ľzet olarak ; == i┼člecini kullanmak, istemedi─činiz durumlarda ger├že─či de─čerlendirebilir; bu y├╝zden === i┼člecini kullanmak daha g├╝venli olur.

% 90 kullan─▒m senaryosunda hangisini kulland─▒─č─▒n─▒z ├Ânemli de─čildir, ancak bir g├╝n beklenmedik davran─▒┼člarda bulundu─čunuzda fark─▒ bilmek faydal─▒ olacakt─▒r.


84







Ayn─▒ taraf─▒n de─čer kadar t├╝r olarak e┼čit olup olmad─▒─č─▒n─▒ kontrol eder .

├ľrnek:

 '1' === 1 // will return "false" because `string` is not a `number`
 

Ortak ├Ârnek:

 0 == ''  // will be "true", but it's very common to want this check to be "false"
 

Ba┼čka bir yayg─▒n ├Ârnek:

 null == undefined // returns "true", but in most cases a distinction is necessary
 

78







Neden == bu kadar ├Âng├Âr├╝lemez?

Bo┼č bir dizgiyi "" s─▒f─▒r ile kar┼č─▒la┼čt─▒rd─▒─č─▒n─▒zda ne elde edersiniz 0 ?

true

Evet, == bo┼č bir dizeye g├Âre do─čru ve s─▒f─▒r say─▒s─▒ ayn─▒ anda.

Ve orada bitmiyor, i┼čte bir tane daha:

 '0' == false // true
 

Dizilerde i┼čler ger├žekten gariple┼čiyor.

 [1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true
 

Sonra dizeleriyle garip

 [1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!
 

Daha da k├Ât├╝s├╝:

Ne zaman e┼čittir e┼čit de─čil?

 let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!
 

Tekrar s├Âyleyeyim:

 (A == B) && (B == C) // true
(A == C) // **FALSE**
 

Ve bu sadece ilkellerle ald─▒─č─▒n ├ž─▒lg─▒n ┼čeyler.

== Nesnelerle kulland─▒─č─▒n─▒zda tamamen yeni bir delilik .

Bu noktada muhtemelen merak ediyorsun ...

Bu neden oluyor?

├ç├╝nk├╝ === iki de─čerin ayn─▒ olup olmad─▒─č─▒n─▒ kontrol eden "├╝├žl├╝ e┼čittir" ( ) 'den farkl─▒ .

== bir s├╝r├╝ ba┼čka ┼čey yapar .

─░┼člevler i├žin ├Âzel i┼čleme, bo┼člar i├žin ├Âzel i┼čleme, tan─▒ms─▒z, dizeler, siz adland─▒r─▒n.

Olduk├ža ka├ž─▒k oluyor.

Asl─▒nda, bunu yapan bir fonksiyon yazmaya ├žal─▒┼čt─▒ysan─▒z == , bunun gibi bir ┼čey olurdu:

 function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}
 

Peki bu ne anlama geliyor?

Bu == karma┼č─▒k demektir .

├ç├╝nk├╝ karma┼č─▒k bir ┼čey kulland─▒─č─▒n─▒zda ne olaca─č─▒n─▒ bilmek zor.

Bu demek oluyor ki b├Âceklerle bitebilirsin.

├ľyleyse hikayenin ahlak─▒ ...

Hayat─▒n─▒z─▒ daha az karma┼č─▒k hale getirin.

Yerine === kullan─▒n == .

Son.


75







S─▒k─▒ e┼čitlik i├žin Javascript ├žal─▒┼čt─▒rma ak─▒┼č ┼čemas─▒ / Kar┼č─▒la┼čt─▒rma '==='


Javascript kat─▒ e┼čitlik

S─▒k─▒ olmayan e┼čitlik / kar┼č─▒la┼čt─▒rma i├žin Javascript uygulama ak─▒┼č ┼čemas─▒


Javascript e┼čitsizli─či


68







JavaScript === vs == .

 0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type
 

54


2013-07-03





Zorlama t├╝r├╝ zorlama olmadan e┼čitlik anlam─▒na gelir zorlama, JavaScript'in di─čer veri t├╝rlerini otomatik olarak dizge veri t├╝rlerine d├Ân├╝┼čt├╝rmedi─či anlam─▒na gelir.

 0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 
 

53







Tipik bir komut dosyas─▒nda performans fark─▒ olmaz. Daha ├Ânemlisi, bin "===" 'in bin a─č─▒rl─▒─č─▒ndan 1 KB daha a─č─▒r olmas─▒ ger├že─či olabilir "==" :) JavaScript profil belirleyicileri durumunuzda performans fark─▒ olup olmad─▒─č─▒n─▒ s├Âyleyebilir.

Ama ┼čahsen JSLint'in ├Ânerdi─či ┼čeyi yapard─▒m. Bu ├Âneri, performans sorunlar─▒ nedeniyle de─čil, t├╝r zorlama ara├žlar─▒n─▒n ('\t\r\n' == 0) do─čru olmas─▒ nedeniyle vard─▒r .


48







E┼čit kar┼č─▒la┼čt─▒rma operat├Âr├╝ == kafa kar─▒┼čt─▒r─▒c─▒d─▒r ve bundan ka├ž─▒n─▒lmal─▒d─▒r.

E─čer varsa ZORUNDA onunla ya┼čamak, sonra a┼ča─č─▒daki 3 ┼čeyleri hat─▒rlamak:

  1. Ge├ži┼čli de─čildir: (a == b) ve (b == c) yol a├žmaz (a == c)
  2. Olumsuzlu─čunu kar┼č─▒l─▒kl─▒ olarak m├╝nhas─▒rla┼čt─▒r─▒r: (a == b) ve (a! = B) her zaman a ve b ile birlikte Boole de─čerlerinin kar┼č─▒s─▒nda bulunur.
  3. ┼×├╝phe durumunda, a┼ča─č─▒daki do─čruluk tablosunu y├╝rekten ├Â─črenin:

JAVASCR─░PTE E┼×─░T OPERAT├ľR GER├çE─×─░ TABLOSU

  • Tablodaki her sat─▒r 3 kar┼č─▒l─▒kl─▒ "e┼čit" de─čer grubudur, yani aralar─▒ndaki 2 de─čer e┼čittir == i┼čareti * ile ayn─▒d─▒r.

** STRANGE: ilk s├╝tundaki iki de─čerin bu anlamda e┼čit olmad─▒─č─▒n─▒ unutmay─▒n. **

 ''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.
 

44







Kullan─▒m─▒n─▒zdaki iki i┼člem aras─▒nda herhangi bir performans fark─▒n─▒n olmas─▒ muhtemel de─čildir. Her iki parametre de ayn─▒ tip oldu─čundan, yap─▒lmas─▒ gereken bir t├╝r d├Ân├╝┼č├╝m├╝ yoktur. Her iki i┼člem de bir de─čer kar┼č─▒la┼čt─▒rmas─▒ ve ard─▒ndan bir kar┼č─▒la┼čt─▒rma kar┼č─▒la┼čt─▒rmas─▒ yapacakt─▒r.


38


2008-12-11





Evet! Farkeder.

=== JavaScript operat├Âr kontrolleri tip hem de de─čer olarak == operat├Âr, sadece kontrol de─čeri (gerekirse tip d├Ân├╝┼č├╝m yapar) .


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin

Kolayca test edebilirsiniz. Bir HTML dosyas─▒na a┼ča─č─▒daki kodu yap─▒┼čt─▒r─▒n ve taray─▒c─▒da a├ž─▒n

 <script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>
 

Uyar─▒da ' yanl─▒┼č ' olacaks─▒n─▒z . ┼×imdi onPageLoad() , alert(x == 5); size g├Âre y├Ântemi de─či┼čtirerek ger├žek olacak .


37







=== Operat├Âr e┼čitlik i├žin de─či┼čkenlerin yan─▒ s─▒ra de─čerleri de kontrol eder.

== operat├Âr sadece e┼čitlik i├žin de─či┼čkenlerin de─čerini kontrol eder.


34







Bu s─▒k─▒ bir kontrol testi.

├ľzellikle 0 ile yanl─▒┼č ve bo┼č aras─▒nda kontrol ediyorsan─▒z, iyi bir ┼čeydir.

├ľrne─čin, e─čer varsa:

 $a = 0;
 

Sonra:

 $a==0; 
$a==NULL;
$a==false;
 

T├╝m iadeler do─črudur ve bunu istemeyebilirsiniz. Diyelim ki bir dizinin 0nc─▒ indeksini d├Ând├╝rebilecek bir fonksiyonunuz var ya da hata durumunda yanl─▒┼č. "==" false ile i┼čaretlerseniz, kafa kar─▒┼čt─▒r─▒c─▒ bir sonu├ž alabilirsiniz.

Yani yukar─▒daki ile ayn─▒ ┼čey, ancak s─▒k─▒ bir test ile:

 $a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
 

32







JSLint bazen i┼čleri de─či┼čtirmek i├žin ger├žek├ži olmayan sebepler verir. T├╝rleri zaten ayn─▒ === gibi tam olarak ayn─▒ performansa sahiptir == .

Yaln─▒zca t├╝rler ayn─▒ olmad─▒─č─▒nda daha h─▒zl─▒d─▒r, bu durumda t├╝rleri d├Ân├╝┼čt├╝rmeyi denemez, ancak do─črudan bir yanl─▒┼č d├Ând├╝r├╝r.

Yani, IMHO, JSLint belki yeni kod yazmak i├žin kullan─▒l─▒r, ancak gereksiz a┼č─▒r─▒ optimizasyon her ne pahas─▒na olursa olsun ka├ž─▒n─▒lmal─▒d─▒r.

Anlam─▒, de─či┼čtirmek i├žin hi├žbir neden yoktur == i├žin === b├Âyle bir kontrol alt─▒nda if (a == 'test') bir tek String olabilir bir ger├že─či biliyorum zaman.

Geli┼čtiricilerin ve hakemlerin zaman─▒n─▒ bo┼ča harcayan ve hi├žbir ┼čey elde etmeyen bir ├žok kodu de─či┼čtirmek.


31







basit├že

== ile operands aras─▒nda kar┼č─▒la┼čt─▒rma anlam─▒na gelir type conversion

&

=== olmadan operandlar aras─▒ kar┼č─▒la┼čt─▒rma anlam─▒na gelir type conversion

JavaScript'de t├╝r d├Ân├╝┼čt├╝rme, javaScript'in di─čer t├╝m veri t├╝rlerini otomatik olarak dize veri t├╝rlerine d├Ân├╝┼čt├╝rmesi anlam─▒na gelir.

├ľrne─čin:

 123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 
 

30


2015-03-20





Basit bir ├Ârnek

 2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.
 

26







Genel bir kural olarak, genellikle kullanmak istiyorsunuz === yerine == (ve !== yerine != ).

Sebepler yukar─▒daki cevaplarda a├ž─▒klanm─▒┼čt─▒r ve ayr─▒ca Douglas Crockford da olduk├ža a├ž─▒kt─▒r ( JavaScript: The Good Parts ).

Bununla birlikte, tek bir istisna vard─▒r : == null 'bo┼č veya tan─▒ms─▒z' olup olmad─▒─č─▒n─▒ kontrol etmenin etkili bir yolu:

 if( value == null ){
    // value is either null or undefined
}
 

├ľrne─čin, jQuery 1.9.1 bu kal─▒b─▒ 43 kez kullan─▒r ve JSHint s├Âzdizimi denetleyicisi eqnull bu nedenden dolay─▒ bile rahatlat─▒c─▒ bir se├ženek sunar.

G├Ânderen jQuery stil k─▒lavuzu :

== lehine kat─▒ e┼čitlik kontrol├╝ (===) kullan─▒lmal─▒d─▒r. Bunun tek istisnas─▒ tan─▒ms─▒z ve bo┼č de─čerlerin bo┼č de─čerlerle denetlenmesidir.

 // Check for both undefined and null values, for some important reason. 
undefOrNull == null;
 

24







Bahsedilen ilk 2 cevap == e┼čitlik ve === kimlik anlam─▒na gelir. Ne yaz─▒k ki, bu ifade yanl─▒┼čt─▒r.

Her iki == i┼členeni nesne ise, ayn─▒ nesneler olup olmad─▒klar─▒n─▒ g├Ârmek i├žin kar┼č─▒la┼čt─▒r─▒l─▒rlar. Her iki i┼členen de ayn─▒ nesneyi g├Âsterirse, e┼čit i┼čle├ž true de─čerini d├Ând├╝r├╝r. Aksi takdirde, ikisi e┼čit de─čildir.

 var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  
 

Yukar─▒daki kodda, hem == hem === yanl─▒┼č olsun ├ž├╝nk├╝ a ve b ayn─▒ nesneler de─čildir.

Bunun anlam─▒ ┼čudur: == her iki i┼čleci de nesne ise, == === ile ayn─▒ ┼čekilde hareket eder, bu da kimlik anlam─▒na gelir. Bu iki operat├Âr├╝n temel fark─▒ t├╝r d├Ân├╝┼č├╝m├╝yle ilgilidir. == e┼čitli─či kontrol etmeden ├Ânce d├Ân├╝┼č├╝m├╝ var, ancak === yapm─▒yor.


24







Sorun ┼ču ki, kolayca ba┼č─▒n─▒z derde girebilir, ├ž├╝nk├╝ JavaScript ├žok fazla gizli d├Ân├╝┼č├╝m i├žeriyor ...

 var x = 0;
var isTrue = x == null;
var isFalse = x === null;
 

Hangi k─▒sa s├╝rede bir sorun haline gelir. ├ľrt├╝k d├Ân├╝┼č├╝m├╝n neden "k├Ât├╝l├╝k" oldu─čuna dair en iyi ├Ârnek, bu koddan MFC / C ++ ' da al─▒nabilir .

 CString x;
delete x;
 

A├ž─▒k├žas─▒ ├žal─▒┼čma zaman─▒ s─▒ras─▒nda ├žok tan─▒ms─▒z ┼čeyler yapar ...

Google, C ++ ve STLÔÇÖdeki ├Ârt├╝k d├Ân├╝┼čt├╝rmelere dayanarak baz─▒ arg├╝manlar─▒ ele ge├žirmek i├žin ...


22







Kaynaktan ├žekirdek JavaScript referans

=== true ─░┼členenler t├╝r d├Ân├╝┼čt├╝rmesi olmadan kesinlikle e┼čitse (yukar─▒ya bak─▒n) d├Ând├╝r├╝r .


22







E┼čitlik kar┼č─▒la┼čt─▒rmas─▒:

┼×ebeke ==

Her iki i┼členen e┼čit oldu─čunda, true de─čerini d├Ând├╝r├╝r. ─░┼členenler kar┼č─▒la┼čt─▒r─▒lmadan ├Ânce ayn─▒ t├╝re d├Ân├╝┼čt├╝r├╝l├╝r.

 >>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
 

E┼čitlik ve tip kar┼č─▒la┼čt─▒rmas─▒:

┼×ebeke ===

Her iki i┼členen de e┼čit ve ayn─▒ t├╝rde oldu─čunda do─čru d├Ând├╝r├╝r. Bu yolu kar┼č─▒la┼čt─▒r─▒rsan─▒z genellikle daha iyi ve daha g├╝venli, ├ž├╝nk├╝ sahne arkas─▒ tipinde bir d├Ân├╝┼č├╝m yok.

 >>> 1 === '1'
false
>>> 1 === 1
true
 

21







* Operat├Ârler === vs == *

 1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
 

19


2014-03-19





Burada ger├žekle┼čen d├Ân├╝┼č├╝mleri ve aras─▒ndaki farklar─▒ g├Âsteren kullan─▒┼čl─▒ bir kar┼č─▒la┼čt─▒rma tablosu == ve === .

Sonu├ž belirtildi─či gibi:

"─░ki e┼čittir i├žin ger├žekle┼čen d├Ân├╝┼č├╝mleri tam olarak anlamad─▒─č─▒n─▒z s├╝rece ├╝├ž e┼čit kullan─▒n."

http://dorey.github.io/JavaScript-Equality-Table/


19



─░lgili yay─▒nlar


JavaScript ba─člant─▒lar─▒, ÔÇť#ÔÇŁ veya ÔÇťjavascript: void (0)ÔÇŁ i├žin hangi ÔÇťhrefÔÇŁ de─čerini kullanmal─▒y─▒m?

Hangi @NotNull Java ek a├ž─▒klamas─▒n─▒ kullanmal─▒y─▒m?

Java 8'in ─░ste─če Ba─čl─▒ Nedenleri ba─č─▒ms─▒z de─či┼čkenlerde kullan─▒lmamal─▒d─▒r?

Android SDK olu┼čturma ara├žlar─▒, platform ara├žlar─▒ ve ara├žlar─▒ nelerdir? Ve hangi versiyon kullan─▒lmal─▒?

U├žucu anahtar kelime C# dilinde ne zaman kullan─▒lmal─▒d─▒r?

Toplu i┼č dosyalar─▒nda hangi yorum stilini kullanmal─▒y─▒m?

Hangi MySQL yap─▒land─▒rma dosyas─▒n─▒n kullan─▒ld─▒─č─▒n─▒ belirleme

Angular 2 ile hangi tip klas├Âr yap─▒lar─▒ kullan─▒lmal─▒d─▒r?

Java'da hangi e┼čzamanl─▒ S─▒ra uygulamas─▒n─▒ kullanmal─▒y─▒m?

Neden HTTP ├Ânbelle─činde hem ├Ânbellekte hem de ma─čazada kullan─▒lmamal─▒?

Etiketle ilgili di─čer sorular [javascript]


Android 8: Cleartext HTTP trafi─čine izin verilmiyor

Nesnelerin listesini kar─▒┼čt─▒rma

Java'da foreach d├Âng├╝s├╝nde remove ├ža─čr─▒l─▒yor [duplicate]

Node.js'deki __dirname ve ./ aras─▒ndaki fark nedir?

PostgreSQL'e g├╝ncelleme + kat─▒l─▒m nas─▒l yap─▒l─▒r?

JavaScript'te ├Ânde gelen s─▒f─▒rlara sahip say─▒lar─▒ nas─▒l ├ž─▒kt─▒rabilirim [duplicate]

Tek bir tabloda birden fazla birincil anahtar alabilir miyim?

Timeit mod├╝l├╝ nas─▒l kullan─▒l─▒r

CSS ile, ta┼čan ├žok sat─▒rl─▒ blok i├žin ÔÇťÔÇŽÔÇŁ kullan─▒n.

Java bit e┼člemini bayt dizisine d├Ân├╝┼čt├╝rme