Օբյեկտների և նախատիպերի ուսումնասիրություն JavaScript-ում օբյեկտի վրա հիմնված ծրագրավորման մեջ

Ներածություն

JavaScript-ը ծրագրավորման լեզու է, որն աջակցում է օբյեկտի վրա հիմնված ծրագրավորմանը (OOP) օբյեկտների և նախատիպերի օգտագործման միջոցով: Այս հոդվածում մենք կխորանանք JavaScript-ի օբյեկտների և նախատիպերի աշխարհում՝ կենտրոնանալով օբյեկտի վրա հիմնված ծրագրավորման վրա: Մենք կուսումնասիրենք JavaScript-ում դասերի ստեղծումը, կհասկանանք ստացողների և սահմանողների հայեցակարգը, կքննարկենք ժառանգությունը դասերի հետ և առանց դասերի, ինչպես նաև կուսումնասիրենք օրինակներ և ստատիկ մեթոդներ: Այս հոդվածի վերջում դուք լավ կհասկանաք այս հասկացությունները և կիմանաք, թե ինչպես դրանք արդյունավետ կիրառել ձեր JavaScript կոդում:

Օբյեկտներ JavaScript-ում

JavaScript-ում օբյեկտները տվյալների կառուցվածքներ են, որոնք կարող են պահպանել հատկություններ և մեթոդներ: Հատկությունները բանալի-արժեք զույգեր են, մինչդեռ մեթոդները՝ օբյեկտի հետ կապված ֆունկցիաներ։ Տեսնենք JavaScript-ում օբյեկտներ ստեղծելու պարզ օրինակ.

const person = {
  name: 'John',
  age: 30,
  greeting() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
};

console.log(person.name); // Output: John
console.log(person.age); // Output: 30
person.greeting(); // Output: Hello, my name is John and I am 30 years old.

Այս օրինակում մենք ունենք person օբյեկտ՝ երկու հատկությամբ՝ name և age, և greeting() մեթոդ, որը տպում է անհատականացված ողջույն: Մենք կարող ենք մուտք գործել օբյեկտի հատկություններ՝ օգտագործելով կետային նշումը և մեթոդը կանչել՝ օգտագործելով ֆունկցիայի կանչման շարահյուսությունը:

Դասեր JavaScript-ով

Չնայած JavaScript-ը չուներ հայրենական դասի աջակցություն մինչև ECMAScript 2015 (ES6), մենք կարող ենք դասեր մոդելավորել՝ օգտագործելով կոնստրուկտորի ֆունկցիաները և նախատիպերը: Տեսնենք JavaScript-ում դաս ստեղծելու օրինակ.

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.greeting = function() {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
};

const person = new Person('John', 30);

console.log(person.name); // Output: John
console.log(person.age); // Output: 30
person.greeting(); // Output: Hello, my name is John and I am 30 years old.

Այս օրինակում մենք օգտագործում ենք Person կոնստրուկտոր ֆունկցիա՝ name և age հատկություններով օբյեկտներ ստեղծելու համար: Այնուհետև մենք ավելացնում ենք greeting մեթոդը կոնստրուկտոր ֆունկցիայի նախատիպին: new հիմնաբառը օգտագործվում է Person դասի օրինակ ստեղծելու համար: Այսպիսով, մենք կարող ենք ստեղծել դասի նման կառուցվածքով օբյեկտներ:

Ժամանակակից JavaScript-ում, սակայն, մենք կարող ենք օգտագործել դասի շարահյուսությունը, որը ներկայացված է ECMAScript 2015-ում (ES6)՝ ավելի հարմար դասեր ստեղծելու համար: Եկեք վերագրենք նախորդ օրինակը՝ օգտագործելով դասի շարահյուսությունը.

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greeting() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person = new Person('John', 30);

console.log(person.name); // Output: John
console.log(person.age); // Output: 30
person.greeting(); // Output: Hello, my name is John and I am 30 years old.

Այս թարմացված օրինակում մենք սահմանում ենք դաս, որը կոչվում է Person՝ օգտագործելով class հիմնաբառը: constructor մեթոդն օգտագործվում է name և age հատկությունները սկզբնավորելու համար, երբ ստեղծվում է դասի նոր օրինակ: greeting մեթոդը սահմանվում է անմիջապես դասի մարմնի ներսում:

Օգտագործելով դասի շարահյուսությունը, մենք կարող ենք կազմակերպել մեր կոդը ավելի կառուցվածքային և ինտուիտիվ ձևով: Դասը գործում է որպես ընդհանուր հատկություններով և մեթոդներով օբյեկտներ ստեղծելու նախագիծ: constructor մեթոդը ավտոմատ կերպով կանչվում է, երբ դասից նոր օբյեկտ է ստեղծվում, ինչը թույլ է տալիս մեզ սկզբնական արժեքներ սահմանել նրա հատկությունների համար:

Դասի ներսում սահմանված մեթոդները ավելացվում են դասի նախատիպին, ինչպես նախորդ օրինակում մենք մեթոդներ ենք ավելացրել նախատիպին՝ օգտագործելով կոնստրուկտորի ֆունկցիաները և նախատիպերը: Սա նշանակում է, որ դասի բոլոր օրինակները կիսում են նույն մեթոդի իրականացումը` նվազեցնելով հիշողության սպառումը:

Գեթթեր և կարգավորիչներ

Ստացողները և կարգավորիչները հատուկ մեթոդներ են, որոնք թույլ են տալիս վերահսկել օբյեկտի հատկությունների հասանելիությունը և արժեքների վերագրումը: Դրանք օգտակար են տվյալների ամբողջականությունն ապահովելու և վավերացումներ կատարելու համար: Տեսնենք JavaScript-ում ստացողների և կարգավորիչների օգտագործման օրինակ.

function Person(name) {
  this._name = name;

  Object.defineProperty(this, 'name', {
    get() {
      return this._name.toUpperCase();
    },
    set(newName) {
      if (typeof newName === 'string' && newName.length > 0) {
        this._name = newName;
      } else {
        console.log('The name must be a non-empty string.');
      }
    }
  });
}

const person = new Person('John');

console.log(person.name); // Output: JOHN

person.name = 'Maria';
console.log(person.name); // Output: MARIA

person.name = '';
// Output: The name must be a non-empty string.
console.log(person.name); // Output: MARIA (value was not changed)

Այս օրինակում մենք օգտագործում ենք Object.defineProperty մեթոդը՝ name հատկության համար մուտքի կարգավորումները սահմանելու համար: Ստացողը վերադարձնում է հատկության արժեքը մեծատառերով, մինչդեռ սահմանիչը թույլ է տալիս նոր անուն վերագրել՝ կիրառելով վավերացում՝ համոզվելու համար, որ այն դատարկ չէ:

Ժառանգություն դասերի հետ և առանց դասերի

Ժառանգությունը OOP-ում կարևոր հասկացություն է, որը թույլ է տալիս դասին ժառանգել հատկություններ և մեթոդներ մեկ այլ դասից: JavaScript-ում ժառանգությանը կարելի է հասնել նախատիպերի միջոցով: Տեսնենք JavaScript-ում դասերով և առանց դասերի ժառանգության օրինակ.

// Inheritance with classes
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Rex');
dog.speak(); // Output: Rex barks.

// Inheritance without classes
function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  console.log(`${this.name} makes a sound.`);
};

function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
  console.log(`${this.name} barks.`);
};

const dog = new Dog('Rex');
dog.speak(); // Output: Rex barks.

Այս օրինակում մենք ստեղծում ենք Animal դաս և ածանցյալ դաս Dog: Դասերի հետ ժառանգության դեպքում մենք օգտագործում ենք extends հիմնաբառը՝ նշելու, որ Dog դասը ժառանգում է Animal դասից: Առանց դասերի ժառանգության մեջ մենք օգտագործում ենք կոնստրուկտոր ֆունկցիան և նախատիպը՝ ֆունկցիաների միջև ժառանգությունը հաստատելու համար։

Օրինակ և ստատիկ մեթոդներ

JavaScript-ում դասի մեթոդները կարող են դասակարգվել որպես օրինակային մեթոդներ և ստատիկ մեթոդներ: Օրինակների մեթոդները կապված են դասի օրինակների հետ, մինչդեռ ստատիկ մեթոդները կապված են հենց դասի հետ: Տեսնենք օրինակների և ստատիկ մեթոդների օգտագործման օրինակ.

class Calculator {
  constructor() {
    this.result = 0;
  }

  add(value) {
    this.result += value;
  }

  static subtract(value1, value2) {
    return value1 - value2;
  }
}

const calc = new Calculator();
calc.add(5);
console.log(calc.result); // Output: 5

const subtraction = Calculator.subtract(10, 3);
console.log(subtraction); // Output: 7

Այս օրինակում Calculator դասը ունի օրինակի մեթոդ add, որը թարմացնում է հաշվիչի ներքին արդյունքը: Բացի այդ, մենք ունենք subtract ստատիկ մեթոդ, որն իրականացնում է ուղղակի հանում առանց դասի օրինակ ստեղծելու անհրաժեշտության:

Եզրակացություն

Այս հոդվածում մենք ուսումնասիրեցինք JavaScript-ում օբյեկտների և նախատիպերի հիմունքները՝ կենտրոնանալով օբյեկտի վրա հիմնված ծրագրավորման վրա: Մենք տեսանք, թե ինչպես կարելի է ստեղծել դասեր՝ օգտագործելով կոնստրուկտորի ֆունկցիաները և նախատիպերը, հասկացանք ստացողների և կարգավորիչների հայեցակարգը՝ սեփականության արժեքների հասանելիությունն ու վերագրումը վերահսկելու համար, քննարկեցինք ժառանգությունը դասերով և առանց դասերի, և ուսումնասիրեցինք օրինակներ և ստատիկ մեթոդներ: