ჩაშენებული მონაცემთა სტრუქტურები

Object

Object არის JavaScript-ის ფუნდამენტური მონაცემთა სტრუქტურა, რომელიც გამმოიყენება სხვადასხვა key-value წყვილებზე დაფუძნებული კოლექციებისა და კიმპლექსური ერთეულების შესანახად.

ობიექტის ერთ-ერთი ძირითადი მახასიათებელი არის მისი პროტოტიპის მექანიზმი. ობიექტი შეიძლება მოიცავდეს სხვა ობიექტს, როგორც პროტოტიპს.

const person = {
  isHuman: true,
};

const me = Object.create(person);
console.log(me.isHuman); // true

მაგალითში გამოვიყენეთ Object.create მეთოდი, რომელიც ქმნის ახალ ობიექტს me ცვლადში და ამ ობიექტს პროტოტიპად აქვს მითითებული person ობიექტი.

ობიექტს კიდევ ბევრი საინტერესო მეთოდი გააჩნია, როგორიცაა:

• Object.keys - სტატიკური მეთოდი, რომელიც დააბრუნებს გადაცემული ობიექტის გასაღებებს მასივის სახით.
• Object.values - სტატიკური მეთოდი, რომელიც დააბრუნებს გადაცემული ობიექტის მნიშვნელობებს მასივის სახით.
• Object.entries - სტატიკური მეთოდი, რომელიც დააბრუნებს გადაცემული ობიექტის მნიშვნელობებს იტერირებადი მასივის სახით.

const students = {
  studentA: 90,
  studentB: 78,
  studentC: 100,
  studnetD: 51,
};

console.log(Object.keys(students)); // ['studentA', 'studentB', 'studentC', 'studnetD']
console.log(Object.values(students)); // [90, 78, 100, 51]
console.log(Object.entries(students)); // [['studentA', 90], ['studentB', 78], ['studentC', 100], ['studnetD', 51]]

for (const [student, grade] of Object.entries(students)) {
  console.log(`${student}: ${grade}`);
}

Map

Map არის ჩაშენებული მონაცემთა სტრუქტურა JavaScript-ში, რომელიც ობიექტის მსგავსად ინახავს key-value წყვილებს, ოღონდ Map-ის შემთხვევაში შესაძლებელია ნებისმიერი ტიპის გამოყენება გასაღებისთვის, თუნდაც ობიექტების. key (გასაღების მნიშვნელობა) Map-ში შესაძელბელია აღმოჩნდეს მხოლოდ ერთხელ, ის ყოველთვის შეიცავს უნიკალურ გასაღებებს.

set მეთოდი გამოიყენება მნიშვნელობის დასამატებლად Map-ში, ხოლო get მნიშნველობისთვის ამოსაღებად.

const students = new Map();
students.set('studentA', 90);
students.set('studentB', 78);
students.set('studentC', 100);
students.set('studentD', 51);

console.log(students.get('studentC')); // 100

has მეთოდი ამოწმებს, მნიშვნელობა არსებობს თუ არა Map-ში.

console.log(students.has('studentA')); // true
console.log(students.has('studentE')); // false

size თვისება განსაზღვრავს Map-ში არსებული თვისებების რაოდენობას.

console.log(students.size); // 4

delete მეთოდი გამოიყენება Map-დან ერთი მნიშვნელობის წასაშლელად, ხოლო clear ყველა ელემენტის წასაშლელად.

console.log(students.delete('studentA')); // true (გულიხსმობს წარმატებულად წაშლას)
console.log(students.delete('studentE')); // false
students.clear();
console.log(students.size); // 0

forEach მეთოდი მასივის forEach მეთოდის მსგავსია.

const students = new Map();
students.set('studentA', 90); // studentA - 90
students.set('studentB', 78); // studentB - 78
students.set('studentC', 100); // studentC - 100
students.set('studentD', 51); // studentD - 51

students.forEach((key, value) => {
  console.log(`${value} - ${key}`);
});

Map-თან მიმართებაში შესაძებელია ობიექტის მსგავსად მუშაობა, თუმცა ეს მიდგომა არასწორია პრაქტიკაში.

const wrongMap = new Map();
wrongMap['bla'] = 'blaa';
wrongMap['bla2'] = 'blaaa2';

console.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }

მსგავსი მანიპულაციები არ ეყრდნობა Map-ის მეთოდებს და არასასურველ შედეგებს მოგვცემს. თვისება bla არ არის შენახული Map-ში, ამიტომ ზოგი მეთოდი არ დააბრუნებს სწორ მნიშვნელობას:

wrongMap.has('bla'); // false
wrongMap.delete('bla'); // false
console.log(wrongMap); // Map { bla: 'blaa', bla2: 'blaaa2' }

Map არის იტერირებადი სტრუქტურა. მასზე იტერაცია შესაძლებელია შემდეგი სინტაქსით:

const students = new Map();
students.set('studentA', 90);
students.set('studentB', 78);
students.set('studentC', 100);
students.set('studentD', 51);

for (const [key, value] of students) {
  console.log(key, value);
}

Object vs Map

Object და Map ერთმანეთის მსგავსია. ორივე სტრუქტურა იყენებს key-value-ს მიდგომას თვისებების შესანახად. თუმცა, არსებობს მნიშვნელოვანი განსხვავებები, რომლებიც ზოგიერთ შემთხვევაში Map-ს უფრო უპირატესობას ანიჭებს:

Set

Set არის ჩაშენებული მონაცემთა სტრუქტურა, რომელიც ინახავს პრიმიტიულ მნიშვნელობებს ან ობიექტებს. ასევე მასში შენახული მნიშვნელობები არის უნიკალური, ანუ Set-ში არ ინახება იდენტური მნიშვნელობები.

ელემენტების დამატება შესაძლებელია add მეთოდის გამოყენებით.

const set1 = new Set();

set1.add(22);
set1.add(22);
set1.add(7);

for (const item of set1) {
  console.log(item);
  // Expected output: 22
  // Expected output: 7
}

Set-ის ელემენტებზე იტერაცია სრულდება დამატების თანმიმდევრობის მიხედვით (მარცხნიდან მარჯვნივ).

has ამოწმებს ელემენტი არსებობს თუ არა სტრუქტურაში.

const set2 = new Set();
set2.add(27);
console.log(set2.has(27)); // true
console.log(set2.has(10)); // false

Set შემადგენლობა

Set ობიექტი გვთავაზობს რამდენიმე მეთოდს, რომელიც საშუალებას გვაძლევს, შევასრულოთ ოპერაციები მათემატიკურ სიმრავლეებზე:

მეთოდი	დაბრუნებული მნიშვნელობა	მათემატიკური ჩაწერა	ვენის დიაგრამა
A.difference(B)	Set	A \ B
A.intersection(B)	Set	A ∩ B
A.symmetricDifference(B)	Set	(A ∖ B) ∪ (B ∖ A)
A.union(B)	Set	A ∪ B
A.isDisjointFrom(B)	Boolean	A ∩ B = ∅
A.isSubsetOf(B)	Boolean	A ⊆ B
A.isSupersetOf(B)	Boolean	A ⊇ B

ეს მეთოდები პარამეტრად ღებულობენ როგორც Set-ს, ასევე set-like-ის ობიექტებს.

შეჯამება

ამ სტატიაში განვიხილეთ ჩაშენებული მონაცემთა სტრუქტურები. ჩაშენებული სტრუქტურების გარდა ასევე არსებობს სხვა მონაცემთა სტრუქტურები, როგორიცაა: stack, queue, list და სხვა. მსგასვი მონაცემთა სტრუქტურები იგება კერძო მაგალითებიდან გამომდინარე.

გამოყენებული ლიტერატურა

• Object
• Map
• Set