Ի՞նչն է տարբերությունը սլաքային ֆունկցիաների և սովորական ֆունկցիաների միջև JavaScript-ում։

1. Սինտաքսիս:
   • Ընդհանուր ֆունկցիա: function myFunction() { ... }
   • Ուղղահայաց ֆունկցիա: () => { ... } կամ param => { ... }
2. this կոնտեքստը:
   • Ընդհանուր ֆունկցիա: this-ը որոշվում է կանչի կոնտեքստով:
   • Ուղղահայաց ֆունկցիա: this-ը լեքսիկորեն ժառանգվում է շրջակա միջավայրից (չի ունի սեփական this)։
3. Կառուցողներ:
   • Ընդհանուր ֆունկցիա: Կարող է օգտագործվել որպես կառուցող (new myFunction())։
   • Ուղղահայաց ֆունկցիա: Չի կարող օգտագործվել որպես կառուցող։
4. arguments օբյեկտ:
   • Ընդհանուր ֆունկցիա: Ունի սեփական arguments օբյեկտը։
   • Ուղղահայաց ֆունկցիա: Չի ունի սեփական arguments-ը, հասանելի է rest-պարամետրերով (...args)։
5. Անվանում ունեցող ֆունկցիաներ:
   • Ընդհանուր ֆունկցիա: Կարող է լինել անվանված (function myFunction() { ... })։
   • Ուղղահայաց ֆունկցիա: Դեռևս անանուն է, նշանակվում է փոփոխականի միջոցով (const myFunction = () => { ... })։
6. Անհայտ վերադարձ (implicit return):
   • Ընդհանուր ֆունկցիա: Պահանջում է բացահայտ return-ը։
   • Ուղղահայաց ֆունկցիա: Մի տողից բովանդակության դեպքում կարող է անանուն վերադարձնել արտահայտության արդյունքը։

Համեմատական աղյուսակ՝

Գծանիշ	Ընդհանուր ֆունկցիա	Ուղղահայաց ֆունկցիա
Սինտաքսիս	function name() { ... }	() => { ... }
this կոնտեքստը	Դինամիկ (կանչի կոնտեքստով)	Լեքսիկ (միջավայրից)
Կառուցող	Այո	Ոչ
arguments օբյեկտը	Այո	Ոչ (rest-պարամետրեր)
Անվանում ունեցողը	Կարող է լինել անվանված	Անանուն (նշանակվում է)
Անհայտ վերադարձ	Ոչ (հաճախ պահանջում է return)	Այո (մեկ տողային բովանդակության համար)

// Օրինակներ ընդհանուր ֆունկցիաների
function standardFunction() {
  console.log(this); // Կախված է կանչի կոնտեքստից
  console.log(arguments); // `arguments` օբյեկտը հասանելի է
}

const obj = {
  method: standardFunction
};

standardFunction(); // this կլինի window կամ undefined
obj.method(); // this կլինի obj
new standardFunction(); // this կլինի նոր օբյեկտ

// Ուղղահայաց ֆունկցիաների օրինակներ
const arrowFunction = () => {
  console.log(this); // Լեքսիկորեն ժառանգում է շրջակա միջավայրից
  // console.log(arguments); // Գործողություն, սխալ, arguments հասանելի չէ
};

const outerObj = {
  outerMethod: function() {
    const innerArrowFunction = () => {
      console.log(this); // ժառանգում է outerMethod-ից (outerObj)
    };
    innerArrowFunction();
  }
};

arrowFunction(); // this կլինի window կամ {} (Node.js)
outerObj.outerMethod(); // this ներսում innerArrowFunction- ում կլինի outerObj

// Անհայտ վերադարձ ուղիղ ֆունկցիայում
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5

// Ընդհանուր ֆունկցիա՝ բացահայտ վերադարձով
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// Ուղղահայաց ֆունկցիա չի կարող լինել կոնստրուկտոր
// new arrowFunction(); // Սխալ: TypeError