JavaScript'i andmestruktuurid: Map'ide, Set'ide ja kohandatud implementatsioonide valdamine globaalsetele arendajatele

Tarkvaraarenduse dünaamilises maailmas on andmestruktuuride valdamine esmatähtis. Need moodustavad tõhusate algoritmide ja hästi organiseeritud koodi aluse, mõjutades otseselt rakenduse jõudlust ja skaleeritavust. Globaalsete arendajate jaoks on nende kontseptsioonide mõistmine ülioluline, et ehitada robustseid rakendusi, mis teenindavad mitmekesist kasutajaskonda ja tulevad toime erinevate andmekoormustega. See põhjalik juhend süveneb JavaScripti võimsatesse sisseehitatud andmestruktuuridesse, Map'idesse ja Set'idesse, ning seejärel uurib kaalukaid põhjuseid ja meetodeid oma kohandatud andmestruktuuride loomiseks.

Navigeerime läbi praktiliste näidete, reaalsete kasutusjuhtude ja rakendatavate teadmiste, tagades, et igasuguse taustaga arendajad saavad neid tööriistu täielikult ära kasutada. Olenemata sellest, kas töötate idufirmas Berliinis, suures ettevõttes Tokyos või vabakutselise projektiga kliendile São Paulos, on siin käsitletud põhimõtted universaalselt rakendatavad.

Andmestruktuuride tähtsus JavaScriptis

Enne konkreetsetesse JavaScripti implementatsioonidesse sukeldumist käsitleme lühidalt, miks andmestruktuurid on nii fundamentaalse tähtsusega. Andmestruktuurid on spetsialiseeritud vormingud andmete organiseerimiseks, töötlemiseks, hankimiseks ja salvestamiseks. Andmestruktuuri valik mõjutab oluliselt operatsioonide, nagu lisamine, kustutamine, otsimine ja sortimine, tõhusust.

JavaScriptis, mis on tuntud oma paindlikkuse ja laialdase kasutuse poolest nii esiotsa, taustaprogrammi (Node.js) kui ka mobiiliarenduses, on tõhus andmetöötlus kriitilise tähtsusega. Halvasti valitud andmestruktuurid võivad põhjustada:

• Jõudluse kitsaskohad: Aeglased laadimisajad, mittereageerivad kasutajaliidesed ja ebatõhus serveripoolne töötlemine.
• Suurenenud mälukasutus: Süsteemi ressursside tarbetu kasutamine, mis toob kaasa suuremad tegevuskulud ja potentsiaalsed kokkujooksmised.
• Koodi keerukus: Raskused koodi hooldamisel ja silumisel keerulise andmehalduse loogika tõttu.

Kuigi JavaScript pakub võimsaid abstraktsioone, annab see arendajatele ka tööriistad kõrgelt optimeeritud lahenduste loomiseks. Selle sisseehitatud struktuuride ja kohandatud struktuuride mustrite mõistmine on võti vilunud globaalseks arendajaks saamisel.

JavaScripti sisseehitatud jõujaamad: Map'id ja Set'id

Pikka aega toetusid JavaScripti arendajad andmekogude haldamisel peamiselt tavalistele JavaScripti objektidele (sarnased sõnastike või räsikaartidega) ja massiividele. Kuigi need on mitmekülgsed, olid neil oma piirangud. Map'ide ja Set'ide kasutuselevõtt ECMAScript 2015-s (ES6) täiustas oluliselt JavaScripti andmehaldusvõimalusi, pakkudes spetsialiseeritumaid ja sageli ka jõudlusvõimelisemaid lahendusi.

1. JavaScripti Map'id

Map on võti-väärtus paaride kogum, kus võtmed võivad olla mis tahes andmetüüpi, sealhulgas objektid, funktsioonid ja primitiivid. See on oluline erinevus traditsioonilistest JavaScripti objektidest, kus võtmed konverteeritakse kaudselt stringideks või sümboliteks.

Map'ide peamised omadused:

• Mis tahes tüüpi võti: Erinevalt tavalistest objektidest, kus võtmed on tavaliselt stringid või sümbolid, võivad Map'i võtmed olla mis tahes väärtusega (objektid, primitiivid jne). See võimaldab keerukamaid ja nüansseeritumaid andmesuhteid.
• Järjestatud iteratsioon: Map'i elemente itereeritakse nende lisamise järjekorras. See ennustatavus on paljude rakenduste jaoks hindamatu väärtusega.
• Size omadus: Map'idel on `size` omadus, mis tagastab otse elementide arvu, mis on tõhusam kui nende loendamiseks võtmete või väärtuste üle itereerimine.
• Jõudlus: Võti-väärtus paaride sagedase lisamise ja kustutamise puhul pakuvad Map'id üldiselt paremat jõudlust kui tavalised objektid, eriti suure hulga kirjete puhul.

Levinud Map'i operatsioonid:

Uurime olulisemaid meetodeid Map'idega töötamiseks:

• `new Map([iterable])`: Loob uue Map'i. Map'i initsialiseerimiseks võib anda valikulise itereeritava võti-väärtus paaride kogumi.
• `map.set(key, value)`: Lisab või uuendab elementi määratud võtme ja väärtusega. Tagastab Map'i objekti.
• `map.get(key)`: Tagastab määratud võtmega seotud väärtuse või `undefined`, kui võtit ei leita.
• `map.has(key)`: Tagastab tõeväärtuse, mis näitab, kas Map'is on olemas määratud võtmega element.
• `map.delete(key)`: Eemaldab Map'ist määratud võtmega elemendi. Tagastab `true`, kui element eemaldati edukalt, vastasel juhul `false`.
• `map.clear()`: Eemaldab Map'ist kõik elemendid.
• `map.size`: Tagastab elementide arvu Map'is.

Itereerimine Map'idega:

Map'id on itereeritavad, mis tähendab, et nende sisu läbimiseks saate kasutada konstruktsioone nagu `for...of` tsüklid ja laotussüntaksit (`...`).

• `map.keys()`: Tagastab iteraatori võtmete jaoks.
• `map.values()`: Tagastab iteraatori väärtuste jaoks.
• `map.entries()`: Tagastab iteraatori võti-väärtus paaride jaoks (kujul `[key, value]` massiivid).
• `map.forEach((value, key, map) => {})`: Käivitab antud funktsiooni iga võti-väärtus paari kohta üks kord.

Map'i praktilised kasutusjuhud:

Map'id on uskumatult mitmekülgsed. Siin on mõned näited:

• Vahemälu (caching): Salvestage sageli kasutatavaid andmeid (nt API vastused, arvutatud väärtused) koos vastavate võtmetega.
• Andmete seostamine objektidega: Kasutage objekte endid võtmetena, et seostada nende objektidega metaandmeid või lisaväärtusi.
• Otsingute implementeerimine: ID-de tõhus kaardistamine kasutajaobjektide, tooteandmete või konfiguratsiooniseadetega.
• Sageduse loendamine: Nimekirjas olevate elementide esinemissageduse loendamine, kus element on võti ja selle arv on väärtus.

Näide: API vastuste vahemällu salvestamine (globaalne perspektiiv)

Kujutage ette, et ehitate globaalset e-kaubanduse platvormi. Võite hankida tooteandmeid erinevatest piirkondlikest API-dest. Nende vastuste vahemällu salvestamine võib jõudlust drastiliselt parandada. Map'idega on see lihtne:

            const apiCache = new Map();

async function getProductDetails(productId, region) {
  const cacheKey = `${productId}-${region}`;

  if (apiCache.has(cacheKey)) {
    console.log(`Vahemälutabamus võtmele ${cacheKey}`);
    return apiCache.get(cacheKey);
  }

  console.log(`Vahemälust möödaläinud võtmele ${cacheKey}. Hangin API-st...`);
  // Simuleerime regionaalsest API-st hankimist
  const response = await fetch(`https://api.example.com/${region}/products/${productId}`);
  const productData = await response.json();

  // Salvestame vahemällu edaspidiseks kasutamiseks
  apiCache.set(cacheKey, productData);

  return productData;
}

// Näide kasutamisest erinevates regioonides:
getProductDetails('XYZ789', 'us-east-1'); // Hangib ja salvestab vahemällu
getProductDetails('XYZ789', 'eu-west-2'); // Hangib ja salvestab eraldi vahemällu
getProductDetails('XYZ789', 'us-east-1'); // Vahemälutabamus!

            

              
                Copy
              
            
          

2. JavaScripti Set'id

Set on unikaalsete väärtuste kogum. See võimaldab salvestada eristuvaid elemente, käsitledes duplikaate automaatselt. Nagu Map'ide puhul, võivad ka Set'i elemendid olla mis tahes andmetüüpi.

Set'ide peamised omadused:

• Unikaalsed väärtused: Set'i kõige iseloomulikum omadus on see, et see salvestab ainult unikaalseid väärtusi. Kui proovite lisada väärtust, mis on juba olemas, siis seda ignoreeritakse.
• Järjestatud iteratsioon: Set'i elemente itereeritakse nende lisamise järjekorras.
• Size omadus: Sarnaselt Map'idele on Set'idel `size` omadus elementide arvu saamiseks.
• Jõudlus: Elemendi olemasolu kontrollimine (`has`) ning elementide lisamine/kustutamine on Set'ides üldiselt väga tõhusad operatsioonid, sageli keskmise ajakeerukusega O(1).

Levinud Set'i operatsioonid:

• `new Set([iterable])`: Loob uue Set'i. Set'i initsialiseerimiseks elementidega võib anda valikulise itereeritava kogumi.
• `set.add(value)`: Lisab Set'i uue elemendi. Tagastab Set'i objekti.
• `set.has(value)`: Tagastab tõeväärtuse, mis näitab, kas Set'is on olemas määratud väärtusega element.
• `set.delete(value)`: Eemaldab Set'ist määratud väärtusega elemendi. Tagastab `true`, kui element eemaldati edukalt, vastasel juhul `false`.
• `set.clear()`: Eemaldab Set'ist kõik elemendid.
• `set.size`: Tagastab elementide arvu Set'is.

Itereerimine Set'idega:

Set'id on samuti itereeritavad:

• `set.keys()`: Tagastab iteraatori väärtuste jaoks (kuna Set'is on võtmed ja väärtused samad).
• `set.values()`: Tagastab iteraatori väärtuste jaoks.
• `set.entries()`: Tagastab iteraatori väärtuste jaoks, kujul `[value, value]`.
• `set.forEach((value, key, set) => {})`: Käivitab antud funktsiooni iga elemendi kohta üks kord.

Set'i praktilised kasutusjuhud:

• Duplikaatide eemaldamine: Kiire ja tõhus viis massiivist unikaalsete elementide nimekirja saamiseks.
• Liikmelisuse testimine: Väga kiiresti kontrollimine, kas element on kogumis olemas.
• Unikaalsete sündmuste jälgimine: Tagamine, et konkreetne sündmus logitakse või töödeldakse ainult üks kord.
• Hulgaoperatsioonid: Kogumitega ühendi-, ühisosa- ja vaheoperatsioonide teostamine.

Näide: unikaalsete kasutajate leidmine globaalsest sündmuste logist

Kujutage ette globaalset veebirakendust, mis jälgib kasutajate tegevust. Teil võivad olla logid erinevatest serveritest või teenustest, mis võivad sisaldada sama kasutaja tegevuse kohta duplikaatkirjeid. Set on ideaalne kõigi osalenud unikaalsete kasutajate leidmiseks:

            const userActivityLogs = [
  { userId: 'user123', action: 'login', timestamp: '2023-10-27T10:00:00Z', region: 'Asia' },
  { userId: 'user456', action: 'view', timestamp: '2023-10-27T10:05:00Z', region: 'Europe' },
  { userId: 'user123', action: 'click', timestamp: '2023-10-27T10:06:00Z', region: 'Asia' },
  { userId: 'user789', action: 'login', timestamp: '2023-10-27T10:08:00Z', region: 'North America' },
  { userId: 'user456', action: 'logout', timestamp: '2023-10-27T10:10:00Z', region: 'Europe' },
  { userId: 'user123', action: 'view', timestamp: '2023-10-27T10:12:00Z', region: 'Asia' } // Duplikaat user123 tegevus
];

const uniqueUserIds = new Set();

userActivityLogs.forEach(log => {
  uniqueUserIds.add(log.userId);
});

console.log('Unikaalsed kasutaja ID-d:', Array.from(uniqueUserIds)); // Kasutades Array.from, et konverteerida Set tagasi massiiviks kuvamiseks
// Väljund: Unikaalsed kasutaja ID-d: [ 'user123', 'user456', 'user789' ]

// Teine näide: duplikaatide eemaldamine toote ID-de nimekirjast
const productIds = ['A101', 'B202', 'A101', 'C303', 'B202', 'D404'];
const uniqueProductIds = new Set(productIds);
console.log('Unikaalsed toote ID-d:', [...uniqueProductIds]); // Kasutades laotussüntaksit
// Väljund: Unikaalsed toote ID-d: [ 'A101', 'B202', 'C303', 'D404' ]

            

              
                Copy
              
            
          

Kui sisseehitatud struktuuridest ei piisa: kohandatud andmestruktuurid

Kuigi Map'id ja Set'id on võimsad, on need üldotstarbelised tööriistad. Teatud stsenaariumides, eriti keerukate algoritmide, väga spetsiifiliste andmenõuete või jõudluskriitiliste rakenduste puhul, peate võib-olla implementeerima oma kohandatud andmestruktuure. Siin muutub oluliseks algoritmide ja arvutusliku keerukuse sügavam mõistmine.

Miks luua kohandatud andmestruktuure?

• Jõudluse optimeerimine: Struktuuri kohandamine konkreetse probleemi jaoks võib anda olulist jõudluse kasvu võrreldes üldiste lahendustega. Näiteks võib spetsialiseeritud puustruktuur olla teatud otsingupäringute jaoks kiirem kui Map.
• Mälutõhusus: Kohandatud struktuure saab kujundada nii, et need kasutaksid mälu täpsemalt, vältides üldotstarbeliste struktuuridega seotud lisakulusid.
• Spetsiifiline funktsionaalsus: Unikaalsete käitumisviiside või piirangute implementeerimine, mida sisseehitatud struktuurid ei toeta (nt prioriteedijärjekord konkreetsete järjestusreeglitega, suunatud servadega graaf).
• Hariduslikud eesmärgid: Fundamentaalsete andmestruktuuride (nagu magasinid, järjekorrad, ahelloendid, puud) toimimise mõistmine neid nullist implementeerides.
• Algoritmide implementeerimine: Paljud arenenud algoritmid on tihedalt seotud spetsiifiliste andmestruktuuridega (nt Dijkstra algoritm kasutab sageli miinimum-prioriteediga järjekorda).

Levinud kohandatud andmestruktuurid JavaScriptis implementeerimiseks:

1. Ahelloendid

Ahelloend on lineaarne andmestruktuur, kus elemente ei salvestata külgnevates mälukohtades. Selle asemel sisaldab iga element (sõlm) andmeid ja viidet (või linki) järgmisele sõlmele järjestuses.

• Tüübid: Ühesuunalised ahelloendid, Kahesuunalised ahelloendid, Ringahelloendid.
• Kasutusjuhud: Magasini ja järjekorra implementeerimine, dünaamilise mälu haldamine, tagasivõtmise/uuestitegemise funktsionaalsus.
• Keerukus: Lisamine/kustutamine alguses/lõpus võib olla O(1), kuid otsimine on O(n).

Implementatsiooni visand: Ühesuunaline ahelloend

Kasutame lihtsat klassipõhist lähenemist, mis on JavaScriptis levinud.

            class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.size = 0;
  }

  // Sõlme lisamine lõppu
  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
    this.size++;
  }

  // Sõlme eemaldamine väärtuse järgi
  remove(data) {
    if (!this.head) return false;

    if (this.head.data === data) {
      this.head = this.head.next;
      this.size--;
      return true;
    }

    let current = this.head;
    while (current.next) {
      if (current.next.data === data) {
        current.next = current.next.next;
        this.size--;
        return true;
      }
      current = current.next;
    }
    return false;
  }

  // Sõlme leidmine väärtuse järgi
  find(data) {
    let current = this.head;
    while (current) {
      if (current.data === data) {
        return current;
      }
      current = current.next;
    }
    return null;
  }

  // Nimekirja printimine
  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

// Kasutus:
const myList = new LinkedList();
myList.add('Apple');
myList.add('Banana');
myList.add('Cherry');
myList.print(); // Apple -> Banana -> Cherry -> null
myList.remove('Banana');
myList.print(); // Apple -> Cherry -> null
console.log(myList.find('Apple')); // Node { data: 'Apple', next: Node { data: 'Cherry', next: null } }
console.log('Suurus:', myList.size); // Suurus: 2

            

              
                Copy
              
            
          

2. Magasinid (Stacks)

Magasin on lineaarne andmestruktuur, mis järgib põhimõtet "viimasena sisse, esimesena välja" (LIFO). Mõelge taldrikute virnale: lisate uue taldriku virna otsa ja eemaldate taldriku virna otsast.

• Operatsioonid: `push` (lisamine tippu), `pop` (eemaldamine tipust), `peek` (tipuelemendi vaatamine), `isEmpty`.
• Kasutusjuhud: Funktsioonide väljakutsete magasinid, avaldiste hindamine, tagasivõtmisalgoritmid (backtracking).
• Keerukus: Kõik peamised operatsioonid on tavaliselt O(1).

Implementatsiooni visand: Magasin massiivi abil

JavaScripti massiiviga saab hõlpsasti magasini jäljendada.

            class Stack {
  constructor() {
    this.items = [];
  }

  // Elemendi lisamine tippu
  push(element) {
    this.items.push(element);
  }

  // Tipuelemendi eemaldamine ja tagastamine
  pop() {
    if (this.isEmpty()) {
      return "Underflow"; // Või vea viskamine
    }
    return this.items.pop();
  }

  // Tipuelemendi vaatamine ilma eemaldamata
  peek() {
    if (this.isEmpty()) {
      return "Magasinis pole elemente";
    }
    return this.items[this.items.length - 1];
  }

  // Magasini tühjuse kontrollimine
  isEmpty() {
    return this.items.length === 0;
  }

  // Suuruse saamine
  size() {
    return this.items.length;
  }

  // Magasini printimine (tipust alla)
  print() {
    let str = "";
    for (let i = this.items.length - 1; i >= 0; i--) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Kasutus:
const myStack = new Stack();
myStack.push(10);
myStack.push(20);
myStack.push(30);
myStack.print(); // 30 20 10
console.log('Tipp:', myStack.peek()); // Tipp: 30
console.log('Pop:', myStack.pop());   // Pop: 30
myStack.print(); // 20 10
console.log('On tühi:', myStack.isEmpty()); // On tühi: false

            

              
                Copy
              
            
          

3. Järjekorrad (Queues)

Järjekord on lineaarne andmestruktuur, mis järgib põhimõtet "esimesena sisse, esimesena välja" (FIFO). Kujutage ette piletikassas ootavate inimeste järjekorda: esimene inimene järjekorras on esimene, keda teenindatakse.

• Operatsioonid: `enqueue` (lisamine lõppu), `dequeue` (eemaldamine algusest), `front` (alguselemendi vaatamine), `isEmpty`.
• Kasutusjuhud: Ülesannete ajastamine, päringute haldamine (nt prindijärjekorrad, veebiserveri päringute järjekorrad), laiutiotsing (BFS) graafides.
• Keerukus: Tavalise massiivi puhul võib `dequeue` olla O(n) ümberindekseerimise tõttu. Optimeeritum implementatsioon (nt ahelloendi või kahe magasini abil) saavutab O(1).

Implementatsiooni visand: Järjekord massiivi abil (jõudluse kaalutlusega)

Kuigi `shift()` massiivil on O(n), on see kõige otsekohesem viis põhinäite jaoks. Tootmiskeskkonnas kaaluge ahelloendi või täiustatud massiivipõhise järjekorra kasutamist.

            class Queue {
  constructor() {
    this.items = [];
  }

  // Elemendi lisamine lõppu
  enqueue(element) {
    this.items.push(element);
  }

  // Alguselemendi eemaldamine ja tagastamine
  dequeue() {
    if (this.isEmpty()) {
      return "Underflow";
    }
    return this.items.shift(); // O(n) operatsioon tavalistes massiivides
  }

  // Alguselemendi vaatamine ilma eemaldamata
  front() {
    if (this.isEmpty()) {
      return "Järjekorras pole elemente";
    }
    return this.items[0];
  }

  // Järjekorra tühjuse kontrollimine
  isEmpty() {
    return this.items.length === 0;
  }

  // Suuruse saamine
  size() {
    return this.items.length;
  }

  // Järjekorra printimine (algusest lõppu)
  print() {
    let str = "";
    for (let i = 0; i < this.items.length; i++) {
      str += this.items[i] + " ";
    }
    console.log(str.trim());
  }
}

// Kasutus:
const myQueue = new Queue();
myQueue.enqueue('A');
myQueue.enqueue('B');
myQueue.enqueue('C');
myQueue.print(); // A B C
console.log('Esimene:', myQueue.front()); // Esimene: A
console.log('Dequeue:', myQueue.dequeue()); // Dequeue: A
myQueue.print(); // B C
console.log('On tühi:', myQueue.isEmpty()); // On tühi: false

            

              
                Copy
              
            
          

4. Puud (Binaarsed otsingupuud - BST)

Puud on hierarhilised andmestruktuurid. Binaarne otsingupuu (BST) on puu tüüp, kus igal sõlmel on maksimaalselt kaks last, mida nimetatakse vasakuks ja paremaks lapseks. Iga antud sõlme puhul on kõik väärtused selle vasakus alampuus väiksemad kui sõlme väärtus ja kõik väärtused selle paremas alampuus on suuremad.

• Operatsioonid: Lisamine, kustutamine, otsimine, läbimine (in-order, pre-order, post-order).
• Kasutusjuhud: Tõhus otsimine ja sortimine (tasakaalustatud puude puhul sageli parem kui O(n)), sümbolitabelite implementeerimine, andmebaaside indekseerimine.
• Keerukus: Tasakaalustatud BST puhul on otsimine, lisamine ja kustutamine O(log n). Viltuse puu puhul võivad need halveneda kuni O(n).

Implementatsiooni visand: Binaarne otsingupuu

See implementatsioon keskendub põhilisele lisamisele ja otsimisele.

            class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  // Väärtuse lisamine BST-sse
  insert(value) {
    const newNode = new TreeNode(value);
    if (!this.root) {
      this.root = newNode;
      return this;
    }

    let current = this.root;
    while (true) {
      if (value === current.value) return undefined; // Või käsitle duplikaate vastavalt vajadusele

      if (value < current.value) {
        if (!current.left) {
          current.left = newNode;
          return this;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = newNode;
          return this;
        }
        current = current.right;
      }
    }
  }

  // Väärtuse otsimine BST-st
  search(value) {
    if (!this.root) return null;
    let current = this.root;
    while (current) {
      if (value === current.value) return current;
      if (value < current.value) {
        current = current.left;
      } else {
        current = current.right;
      }
    }
    return null; // Ei leitud
  }

  // In-order läbimine (tagastab sorteeritud nimekirja)
  inOrderTraversal(node = this.root, result = []) {
    if (node) {
      this.inOrderTraversal(node.left, result);
      result.push(node.value);
      this.inOrderTraversal(node.right, result);
    }
    return result;
  }
}

// Kasutus:
const bst = new BinarySearchTree();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(2);
bst.insert(7);
bst.insert(12);
bst.insert(18);

console.log('In-order läbimine:', bst.inOrderTraversal()); // [ 2, 5, 7, 10, 12, 15, 18 ]
console.log('Otsime 7:', bst.search(7)); // TreeNode { value: 7, left: null, right: null }
console.log('Otsime 100:', bst.search(100)); // null

            

              
                Copy
              
            
          

5. Graafid

Graafid on mitmekülgne andmestruktuur, mis esindab objektide (tipud või sõlmed) hulka, kus iga tipupaar võib olla ühendatud seosega (serv). Neid kasutatakse võrgustike modelleerimiseks.

• Tüübid: Suunatud vs. suunamata, Kaalutud vs. kaalumata.
• Esitusviisid: Külgnevusloend (kõige levinum JS-is), Külgnevusmaatriks.
• Operatsioonid: Tippude/servade lisamine/eemaldamine, läbimine (DFS, BFS), lühima tee leidmine.
• Kasutusjuhud: Sotsiaalvõrgustikud, kaardistamis-/navigatsioonisüsteemid, soovitussüsteemid, võrgutopoloogia.
• Keerukus: Sõltub suuresti esitusviisist ja operatsioonist.

Implementatsiooni visand: Graaf külgnevusloendiga

Külgnevusloend kasutab Map'i (või tavalist objekti), kus võtmed on tipud ja väärtused on nende külgnevate tippude massiivid.

            class Graph {
  constructor() {
    this.adjacencyList = new Map(); // Kasutame Map'i paremaks võtmete haldamiseks
  }

  // Tipu lisamine
  addVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      this.adjacencyList.set(vertex, []);
    }
  }

  // Serva lisamine (suunamata graafi jaoks)
  addEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      throw new Error("Üks või mõlemad tipud puuduvad.");
    }
    this.adjacencyList.get(vertex1).push(vertex2);
    this.adjacencyList.get(vertex2).push(vertex1); // Suunamata graafi jaoks
  }

  // Serva eemaldamine
  removeEdge(vertex1, vertex2) {
    if (!this.adjacencyList.has(vertex1) || !this.adjacencyList.has(vertex2)) {
      return false;
    }
    this.adjacencyList.set(vertex1, this.adjacencyList.get(vertex1).filter(v => v !== vertex2));
    this.adjacencyList.set(vertex2, this.adjacencyList.get(vertex2).filter(v => v !== vertex1));
    return true;
  }

  // Tipu ja kõigi selle servade eemaldamine
  removeVertex(vertex) {
    if (!this.adjacencyList.has(vertex)) {
      return false;
    }
    while (this.adjacencyList.get(vertex).length) {
      const adjacentVertex = this.adjacencyList.get(vertex).pop();
      this.removeEdge(vertex, adjacentVertex);
    }
    this.adjacencyList.delete(vertex);
    return true;
  }

  // Baastase sügavutiotsing (DFS) läbimine
  dfs(startVertex, visited = new Set(), result = []) {
    if (!this.adjacencyList.has(startVertex)) return null;

    visited.add(startVertex);
    result.push(startVertex);

    this.adjacencyList.get(startVertex).forEach(neighbor => {
      if (!visited.has(neighbor)) {
        this.dfs(neighbor, visited, result);
      }
    });
    return result;
  }
}

// Kasutus (nt globaalsete linnade vaheliste lennumarsruutide esitamine):
const flightNetwork = new Graph();
flightNetwork.addVertex('New York');
flightNetwork.addVertex('London');
flightNetwork.addVertex('Tokyo');
flightNetwork.addVertex('Sydney');
flightNetwork.addVertex('Rio de Janeiro');

flightNetwork.addEdge('New York', 'London');
flightNetwork.addEdge('New York', 'Tokyo');
flightNetwork.addEdge('London', 'Tokyo');
flightNetwork.addEdge('London', 'Rio de Janeiro');
flightNetwork.addEdge('Tokyo', 'Sydney');

console.log('Lennuvõrgustiku DFS New Yorgist:', flightNetwork.dfs('New York'));
// Näidisväljund: [ 'New York', 'London', 'Tokyo', 'Sydney', 'Rio de Janeiro' ] (järjekord võib Set'i iteratsioonist sõltuvalt varieeruda)

// flightNetwork.removeEdge('New York', 'London');
// flightNetwork.removeVertex('Tokyo');

            

              
                Copy
              
            
          

Õige lähenemise valimine

Otsustades, kas kasutada sisseehitatud Map'i/Set'i või implementeerida kohandatud struktuur, kaaluge järgmist:

• Probleemi keerukus: Lihtsate kogumite ja otsingute jaoks on Map'id ja Set'id tavaliselt piisavad ja sageli jõudlusvõimelisemad tänu natiivsetele optimeerimistele.
• Jõudlusvajadused: Kui teie rakendus nõuab teatud operatsioonide jaoks äärmist jõudlust (nt konstantse ajaga lisamine ja kustutamine, logaritmiline otsing), võib olla vajalik kohandatud struktuur.
• Õppimiskõver: Kohandatud struktuuride implementeerimine nõuab head arusaama algoritmidest ja andmestruktuuride põhimõtetest. Enamiku tavaliste ülesannete jaoks on sisseehitatud funktsioonide kasutamine produktiivsem.
• Hooldatavus: Hästi dokumenteeritud ja testitud kohandatud struktuurid võivad olla hooldatavad, kuid keerulised struktuurid võivad lisada märkimisväärset hoolduskoormust.

Globaalse arenduse kaalutlused

Globaalsel areenil töötavate arendajatena on mitu andmestruktuuridega seotud tegurit, mida tasub tähele panna:

• Skaleeritavus: Kuidas käitub teie valitud andmestruktuur andmemahu eksponentsiaalsel kasvamisel? See on ülioluline rakenduste jaoks, mis teenindavad miljoneid kasutajaid üle maailma. Sisseehitatud struktuurid nagu Map'id ja Set'id on üldiselt hästi optimeeritud skaleeritavuse jaoks, kuid kohandatud struktuurid tuleb sellega arvestades kujundada.
• Rahvusvahelistamine (i18n) ja lokaliseerimine (l10n): Andmed võivad pärineda erinevast keelelisest ja kultuurilisest taustast. Mõelge, kuidas teie andmestruktuurid käsitlevad erinevaid märgistikke, sortimisreegleid ja andmevorminguid. Näiteks kasutajanimede salvestamisel võib Map'ide kasutamine objektidega võtmetena olla robustsem kui lihtsate string-võtmete kasutamine.
• Ajavööndid ja kuupäeva/kellaaja käsitlemine: Aja-tundlike andmete salvestamine ja pärimine erinevates ajavööndites nõuab hoolikat kaalumist. Kuigi see pole rangelt andmestruktuuri probleem, sõltub kuupäevaobjektide tõhus hankimine ja manipuleerimine sageli sellest, kuidas neid salvestatakse (nt Map'ides, mis on indekseeritud ajatemplite või UTC väärtuste järgi).
• Jõudlus erinevates piirkondades: Võrgu latentsus ja serverite asukohad võivad mõjutada tajutavat jõudlust. Tõhus andmete hankimine ja töötlemine serveris (kasutades sobivaid struktuure) ja kliendi poolel võib neid probleeme leevendada.
• Meeskonnatöö: Mitmekesistes, hajutatud meeskondades töötades on selge dokumentatsioon ja ühine arusaam kasutatavatest andmestruktuuridest elutähtsad. Standardsete struktuuride nagu Map'id ja Set'id implementeerimine soodustab lihtsamat sisseelamist ja koostööd.

Kokkuvõte

JavaScripti Map'id ja Set'id pakuvad võimsaid, tõhusaid ja elegantseid lahendusi paljudele levinud andmehaldusülesannetele. Need pakuvad paremaid võimalusi kui vanemad meetodid ja on iga kaasaegse JavaScripti arendaja jaoks olulised tööriistad.

Siiski ulatub andmestruktuuride maailm kaugemale nendest sisseehitatud tüüpidest. Keeruliste probleemide, jõudluse kitsaskohtade või spetsialiseeritud nõuete korral on kohandatud andmestruktuuride, nagu ahelloendid, magasinid, järjekorrad, puud ja graafid, implementeerimine rahuldust pakkuv ja sageli vajalik ettevõtmine. See süvendab teie arusaama arvutuslikust tõhususest ja probleemide lahendamisest.

Globaalsete arendajatena annab nende tööriistade omaksvõtmine ja nende mõju mõistmine skaleeritavusele, jõudlusele ja rahvusvahelistamisele teile võimekuse ehitada keerukaid, robustseid ja suure jõudlusega rakendusi, mis suudavad maailmaareenil edu saavutada. Jätkake avastamist, implementeerimist ja optimeerimist!