JavaScript-ში სლაკური ფუნქციებისა და ჩვეულებრივი ფუნქციების შორის რა განსხვავებაა?

1. სინტაქსი:
   • ჩვეულებრივი ფუნქცია: function myFunction() { ... }
   • სროლა ფუნქცია: () => { ... } ან param => { ... }
2. this კონტექსტი:
   • ჩვეულებრივი ფუნქცია: this განსაზღვრავს გამოძახების კონტექსტი.
   • სროლა ფუნქცია: this ლექსიკურად მემკვიდრეობით გადაეცემა გარშემო სივრციდან (არ აქვს საკუთარი this).
3. კონსტრუქტორები:
   • ჩვეულებრივი ფუნქცია: შეიძლება გამოყენებულ იქნას როგორც კონსტრუქტორი (new myFunction()).
   • სროლა ფუნქცია: არ შეიძლება გამოყენებულ იქნას როგორც კონსტრუქტორი.
4. arguments ობიექტი:
   • ჩვეულებრივი ფუნქცია: აქვს საკუთარი arguments ობიექტი, რომელიც შეიცავს გადაცემულ არგუმენტებს.
   • სროლა ფუნქცია: არ აქვს საკუთარი arguments ობიექტი, არგუმენტებზე წვდომა ხდება რესტ პარამეტრებით (...args).
5. დასახელებული ფუნქციები:
   • ჩვეულებრივი ფუნქცია: შეიძლება იყოს დასახელებული (function myFunction() { ... }).
   • სროლა ფუნქცია: საწყისად ანონიმია, მიენიჭება ცვლადს დასახელებისთვის (const myFunction = () => { ... }).
6. მიუკერძოებელი დაბრუნება:
   • ჩვეულებრივი ფუნქცია: საჭიროებს გამოხატულ return-ს მნიშვნელობის დაბრუნებისთვის (გარდა მარტივი შემთხვევებისა, როგორიცაა IIFE).
   • სროლა ფუნქცია: ერთსტრიქონიანი სხეულის შემთხვევაში შეიძლება არავერბალურად დააბრუნოს გამოთვლის შედეგი return-ის გარეშე.

შედარების სია:

მახასიათებელი	ჩვეულებრივი ფუნქცია	სროლა ფუნქცია
სინტაქსი	function name() { ... }	() => { ... }
this კონტექსტი	დინამიური (გამოძახების კონტექსტი)	ლექსიკურად (მშობელი სივრციდან)
კონსტრუქტორი	დიახ	არა
arguments ობიექტი	დიახ	არა (რესტ პარამეტრებით)
დასახელება	შეიძლება იყოს დასახელებული	ანონიმური (მიწოდებულია)
არავერბალური დაბრუნება	არა (საჭიროა 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); // მემკვიდრეობით იღებს this- ს მშობელი სივრციდან
  // console.log(arguments); // შეცდომა, arguments მიუწვდომელია
};

const outerObj = {
  outerMethod: function() {
    const innerArrowFunction = () => {
      console.log(this); // მემკვიდრეობით იღებს this- ს outerMethod-დან (რომელიც არის outerObj)
    };
    innerArrowFunction();
  }
};

arrowFunction(); // this იქნება window (ბრაუზერში) ან {} (Node.js)
outerObj.outerMethod(); // innerArrowFunction-ის შიგნით this იქნება outerObj

// არავერბალური დაბრუნება სროლა ფუნქციაში
const sum = (a, b) => a + b;
console.log(sum(2, 3)); // 5 (არავერბალურად დაბრუნება a + b)

// ჩვეულებრივი ფუნქცია გამოხატული დაბრუნებით
function multiply(a, b) {
  return a * b;
}
console.log(multiply(2, 3)); // 6

// სროლა ფუნქცია ვერ იქნება კონსტრუქტორი
// new arrowFunction(); // შეცდომა: TypeError: arrowFunction_1 is not a constructor