Ի՞նչ օպերատորներ կան JavaScript-ում։

JavaScript- ում կան մի քանի օպերատորների տեսակներ, որոնք կատարում են տարբեր գործառույթներ:

• Ավատառ օպերատորներ: Դատում են արժեքը փոփոխականի վրա:

  • = (պարզապես նշանակում)
  • +=, -=, *=, /=, %= (կոմպոզիտային նշանակումներ)
  • **= (նշանակում բարձրացնել աստիճանի)
  • <<=, >>=, >>>= (շարժում)
  • &=, |=, ^= (բիթային գործողություններ)
  • &&=, ||=, ??= (լոգիկական նշանակումներ)

• Համեմատական օպերատորներ: Համեմատում են երկու արժեք և վերադարձնում բուլյան արժեք:

  • == (հավասարություն)
  • != (չհավասարություն)
  • === (խստիվ հավասարություն)
  • !== (խստիվ ոչ հավասար)
  • > (ավելի)
  • < (փոքր)
  • >= (ավելի կամ հավասար)
  • <= (փոքր կամ հավասար)

• Աрифմետիկ օպերատորներ: Կատարում են մաթեմատիկական գործողություններ:

  • + (հավաք)
  • - (բացառում)
  • * (մեծացում)
  • / (բաժանում)
  • % (մնացորդ)
  • ** (դարձնել աստիճան)
  • ++ (ավելացում)
  • -- (գումար)

• Բիթային օպերատորներ: Կատարում են գործողություններ թվի առանձին բիթերի մակարդակով:

  • & (բիթային AND)
  • | (բիթային OR)
  • ^ (բիթային բացառիկ OR)
  • ~ (բիթային NOT)
  • << (ձախ շեղում)
  • >> (աջ շեղում՝ պահպանելով նշանը)
  • >>> (աջ շեղում՝ լրացնելով զրոյներով)

• Լոգիկական օպերատորներ: Միավորում կամ հակադարձում բուլյան արժեքները:

  • && (լոգիկական AND)
  • || (լոգիկական OR)
  • ! (լոգիկական NOT)

• Ստրինգ օպերատորներ: Աշխատում են տողերի հետ:

  • + (կոնկատենացիա)

• Տարբերակային (տեռնարի) օպերատոր: Կարճ ձև if...else:

  // պայման ? արտահայտություն1 : արտահայտություն2
  let result = (a > b) ? "a մեծ է b-ից" : "b մեծ է կամ հավասար a-ին";
  

• Վերադարձի օպերատոր: Կատարում է մի քանի արտահայտություն և վերադարձնում վերջինի արժեքը:

  let x = 0;
  let y = (x++, 5); // x դառնում է 1, y դառնում է 5
  

• Հարաբերական օպերատորներ: Ստուգում են տիպը և հատկությունների առկայությունը:

  • in (ստուգում, արդյոք հատկությունը կա օբյեկտում)

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

  • instanceof (ստուգում, արդյոք օբյեկտը օրինակ է դասի)

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

• Ունարի օպերատորներ + և -:

  • + (փոխում է օպերանդը թիվ)

  console.log(+"5"); // 5 (թիվ)
  

  • - (փոխում է օպերանդը թիվ և փոխում նշանը)

  console.log(-"10"); // -10 (թիվ)
  

• Տիպի օպերատորներ:

  • typeof (վերադարձնում է տող, որը ցույց է տալիս օպերանդի տիպը)

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

  • delete (հեռացնում է հատկությունը օբյեկտից կամ տարրից զանգվածում)

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

• Խմբային օպերատոր ( ): Կարգավորում է գործողությունների հերթականությունը:

  let z = (2 + 3) * 4; // Հետագա հաշվարկները կատարվում են առաջինը
  

• Նոր օպերատոր: Ստեղծում է նոր օբյեկտի օրինակ:

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

• super օպերատոր: Կոչում է ծնողական դասի մեթոդը:

  class Parent {
    greet() {
      console.log("Hello from Parent");
    }
  }
  class Child extends Parent {
    greet() {
      super.greet(); // Կոչում է ծնողի մեթոդը
      console.log("Hello from Child");
    }
  }
  

• this օպերատոր: Կապվում է ընթացիկ կատարման կոնտեքստին:

• void օպերատոր: Կատարում է արտահայտությունը և վերադարձնում undefined:

  // void արտահայտություն
  console.log(void 0); // undefined
  

• nullish coalescing և optional chaining օպերատորներ:

  • ?? (nullish coalescing օպերատոր - վերադարձնում է աջ կողմը, եթե ձախը null կամ undefined է)

  // left ?? right
  let val = undefined ?? "default"; // val կլինի "default"
  

  • ?. (optional chaining օպերատոր - անվտանգ մուտք դեպի հատկություններ, եթե միջնորդական արժեքը null կամ undefined է)

  // object?.property?.method()
  let user = { address: { city: "NYC" } };
  console.log(user.address?.zipCode); // undefined (առանց սխալի)