Millised operaatorid on JavaScriptis?

JavaScript'is on mitu operaatoritüüpi, mis täidavad erinevaid funktsioone:

• Omistamisoperaatorid: omistavad väärtuse muutujale.

  • = (lihtne omistamine)
  • +=, -=, *=, /=, %= (liit-omistamine)
  • **= (astendamine)
  • <<=, >>=, >>>= (liigutamise omistamine)
  • &=, |=, ^= (bittide operatsioonide omistamine)
  • &&=, ||=, ??= (loogiline omistamine)

• Võrdlusoperaatorid: võrdlevad kahte väärtust ja tagastavad loogilise väärtuse.

  • == (võrdsus)
  • != (mittevõrdsus)
  • === (rangelt võrdne)
  • !== (rangelt mittevõrdne)
  • > (suurem)
  • < (väiksem)
  • >= (suurem või võrdne)
  • <= (väiksem või võrdne)

• Aritmeetilised operaatorid: teevad matemaatilisi operatsioone.

  • + (liitmine)
  • - (lahutamine)
  • * (korrutamine)
  • / (jagamine)
  • % (jääg)
  • ** (astendamine)
  • ++ (incrementeerimine)
  • -- (dekrementeerimine)

• Bittoperaatorid: teevad operatsioone üksikute bittide tasemel.

  • & (bitti ja)
  • | (bitti või)
  • ^ (bitti välist või)
  • ~ (bitti mitte)
  • << (vasakpoolne nihutamine)
  • >> (parempoolne nihutamine märgiga)
  • >>> (parempoolne nihutamine nullidega)

• Loogilised operaatorid: ühendavad või pööravad loogilisi väärtusi.

  • && (loogiline ja)
  • || (loogiline või)
  • ! (loogiline mitte)

• Stringi operaatorid: töötavad stringidega.

  • + (kontekstsioon)

• Tingimuslik (ternaarne) operaator: lühike if...else.

  // tingimus ? väljendus1 : väljendus2
  let result = (a > b) ? "a on suurem" : "b on suurem või võrdne a-ga";
  

• Komaoperaator: täidab mitu väljendit, tagastades viimase väärtuse.

  let x = 0;
  let y = (x++, 5); // x muutub 1-ks, y 5-ks
  

• Suhtarvud: kontrollivad tüüpi ja omadusi.

  • in (kontrollib, kas omadus on objekti sees)

  // 'propertyName' in object
  console.log('length' in [1, 2, 3]); // true
  

  • instanceof (kontrollib, kas objekt on klassi eksemplar)

  // object instanceof className
  function Car() {}
  let myCar = new Car();
  console.log(myCar instanceof Car); // true
  

• Unaarne pluss ja miinus:

  • + (muudab operandist numbri)

  console.log(+"5"); // 5 (number)
  

  • - (muudab operandist numbri ja pöörab märgi)

  console.log(-"10"); // -10 (number)
  

• Tüüpide operaatorid:

  • typeof (tagastab stringi, mis näitab operand tüüpi)

  // typeof operand
  console.log(typeof 42); // "number"
  console.log(typeof "hello"); // "string"
  

  • delete (kustutab objekti omaduse või massiivi elemendi)

  // delete object.property
  // delete array[index]
  let obj = { a: 1, b: 2 };
  delete obj.a;
  console.log(obj); // { b: 2 }
  

• Rühmitusoperaator ( ): määrab operatsioonide täitmise järjekorra.

  let z = (2 + 3) * 4; // Esmalt täidetakse sulgudes olevad arvutused
  

• Uue objekti loomise operaator: loob objekti eksemplari.

  // new Constructor([arguments])
  let date = new Date();
  

• Super operaator: kutsub välja vanema klassi meetodi.

  class Parent {
    greet() {
      console.log("Hello from Parent");
    }
  }
  class Child extends Parent {
    greet() {
      super.greet(); // vanema meetodi väljakutse
      console.log("Hello from Child");
    }
  }
  

• This operaator: viitab praegusele täitmisele kontekstile.

• Void operaator: täidab väljendi ja tagastab undefined.

  // void väljend
  console.log(void 0); // undefined
  

• Nullish coalescing ja optional chaining operaatorid:

  • ?? (nullish coalescing operaator - tagastab parempoolse operand, kui vasakpoolne on null või undefined)

  // left ?? right
  let val = undefined ?? "default"; // val on "default"
  

  • ?. (optional chaining operaator - turvaline juurdepääs omadustele, kui vahepealne väärtus on null või undefined)

  // object?.property?.method()
  let user = { address: { city: "NYC" } };
  console.log(user.address?.zipCode); // undefined (ilma veata)