რა შემოწმებს instanceof ოპერატორი JavaScript-ში?

JavaScript-ში instanceof ოპერატორი შემოწმებს, არის თუ არა ობიექტი კონკრეტული კლასი ან კონსტრუქტორის ინსტანცია.

მუშაობის პრინციპი:

1. instanceof ოპერატორი შემოწმებს, არის თუ არა კონსტრუქტორის prototype ობიექტი ობიექტის პროტოტიპულ ჯაჭვში.
2. თუ prototype კონსტრუქტორის ჯაჭვშია, შედეგი იქნება true.
3. თუ არა, შედეგი იქნება false.

მაგალითები:

// კლასი შექმნა
class Animal {
  // კონსტრუქტორი
  constructor(name) {
    this.name = name;
  }
}

// კლასი ინსტანციის შექმნა
let dog = new Animal("Buddy");

// შემოწმება, არის თუ არა dog `Animal`-ის ინსტანცია
console.log(dog instanceof Animal); // true

// შემოწმება, არის თუ არა dog `Object`-ის ინსტანცია (ჯაჭვში)
console.log(dog instanceof Object); // true

// შემოწმება, არის თუ არა dog `Array`-ის ინსტანცია (არ არის)
console.log(dog instanceof Array); // false

// ინტეგრირებული ტიპების შემოწმება
let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.log(arr instanceof Object); // true

let num = 123;
console.log(num instanceof Number); // false (პრიმიტიული მნიშვნელობებისთვის)
// შექმნილი ახალი ობიექტით
let numObj = new Number(123);
console.log(numObj instanceof Number); // true

ს special თვისებები:

• instanceof მუშაობს პროტოტიპულ ჯაჭვზე, ამიტომ შედეგი შეიძლება იყოს true მშობელ კონსტრუქტორებისთვისაც.
• პრიმიტიული ტიპებისთვის (string, number, boolean, null, undefined, symbol, bigint), instanceof ჩვეულებრივ აბრუნებს false, თუ ისინი არ შექმნილია შესაბამისი ობიექტის მეშვეობით (new String(), new Number() და ა.შ.).
• შეიძლება იყოს არასიზუსტე JavaScript-ის სხვადასხვა კონტექსტში მუშაობისას (მაგ., სხვადასხვა ბრაუზერის ფანჯრებში ან iframe-ებში), რადგან თითოეულ კონტექსტს აქვს თავისი კონსტრუქტორები.

ტიპის შემოწმების სხვა მეთოდები:

• typeof: აბრუნებს სტრინგს, რომელიც მიუთითებს ძირითადი მონაცემთა ტიპზე (string, number, boolean, object, function, undefined, symbol, bigint). არ არის შესაფერისი კონკრეტული კლასის შემოწმებისთვის.
• Object.prototype.toString.call(): აბრუნებს უფრო ზუსტ სტრინგს ობიექტის ტიპზე ("[object Array]", "[object Date]" და ა.შ.).

საერთო ჯამში, instanceof სასარგებლოა იმის შემოწმებისთვის, მიეკუთვნება თუ არა ობიექტი კონკრეტულ კლასს ან მის მემკვიდრეობას.