Detailed explanation of the method of implementing fuzzy search for big data before and after JavaScript

function init() {
  // Open IndexedDB database  const openDB = ("myDatabase", 1);
  // It is called only when the new database and database version number changes   = function (event) {
    const db = ;
    // Create object storage space    const objectStore = ("myObjectStore", {
      keyPath: "code",
    });
    // Add index    // ("code", "code");
    ("pCode", "pCode", { unique: false });
    ("name", "name", { unique: false });
  };

   = async function (event) {
    const db = ;
    const dataArray = data;
    // Get transaction object    const transaction = (["myObjectStore"], "readwrite");
    // Get object storage space    const objectStore = ("myObjectStore");

    // Add objects to object storage    (function (data) {
      const addRequest = (data);

       = function () {
        ("Data has been successfully added to object storage");
      };

       = function (error) {
        ("An error occurred while adding data", error);
      };
    });
  };
}

function search() {
   = [];
  // Open the database  const openRequest = ("myDatabase", 1);
  // Open the database successfully callback   = function (event) {
    // Database object    const db = ;
    // Open read-only transaction and get object storage readwrite read-write read-only read-only    const transaction = (["myObjectStore"], "readonly");
    // Get a reference to myObjectStore object storage space    const objectStore = ("myObjectStore");
    // Get name index    const index = ("name");
    // Open cursor    const request = (); // All data    // const request = (searchKey); // Accurate matching    // const request = (
    //   (searchKey, searchKey + "\uffff", false, false)
    // ); // Post blur    const startTime = new Date().getTime();
     = function (event) {
      const cursor = ;
      if (cursor) {
        const name = ;
        // Determine whether the name contains search keywords. If it is blurred afterwards, just take the name directly.        if ((name)) {
          ();
        }
        ();
      } else {
        const endTime = new Date().getTime();
        (`Time-consuming search：${endTime - startTime}`);
        (result);
      }
    };

     = function () {
      ("An error occurred while performing search");
    };
  };
  // The callback failed to open the database   = function () {
    ("An error occurred while opening the database");
  };
}

class TrieNode {
  constructor() {
     = new Map(); // Children used to store the current node     = false; // Indicates whether the current node is the end of a word     = []; // Used to store the value associated with the current node  }
}

class Trie {
  constructor() {
     = new TrieNode();
  }
  // If the current character does not exist in the child node of the current node, create a new child node.  // and add it to the child node map.  Then, update the current node to a new child node and continue to traverse the next character.  // After traversing all characters, set the isEndOfWord property of the current node to true, indicating that the node is the end of a word.  // At the same time, add the value associated with the word to the values ​​array of the current node.  insert(word, value) {
    let node = ;
    for (let i = 0; i < ; i++) {
      const char = word[i];

      if (!(char)) {
        (char, new TrieNode());
      }
      node = (char);
    }
     = true;
    (value);
  }

  // Recursively collects the associated values ​​of all words in a subtree rooted by a given node.  If the current node is the end of a word  // Add all associated values ​​of the node to the result set.  Then, for each child node of the current node,  // Recursively call collectValues ​​method.  collectValues(node, results) {
    if () {
      for (const value of ) {
        (value);
      }
    }
    for (const childNode of ()) {
      (childNode, results);
    }
  }

  // Fuzzy searches for words that match the given keyword and returns all associated values ​​that match.  This method first creates an empty  // Set object results, used to store results.  Then, call the collectSuffixValues ​​method,  // Recursively search for words matching the keyword from the root node and add the matching associated value to the results.  // Finally, convert results to array and return.  fuzzySearch(keyword) {
    const results = new Set();
    (, keyword, results);
    return (results);
  }

  // Recursively search for words matching the given keyword suffix and add the matching associated value to the result set.  // If the length of the keyword is 0, it means that the end of the keyword has been matched. At this time, the collectValues ​​method is called.  // Add all associated values ​​from the current node and its subtrees to the result set.  // Otherwise, take the first character char of the keyword and get the child node of the current node.  // If childNode exists, collectSuffixValues ​​method is called recursively.  // Pass the remainder of the keyword and childNode as parameters.  // Then, recursively call the collectSuffixValues ​​method for each child node of the current node.  // Pass keywords and result sets as parameters  collectSuffixValues(node, keyword, results) {
    if ( === 0) {
      (node, results);
    } else {
      const char = keyword[0];
      const childNode = (char);
      if (childNode) {
        (childNode, (1), results);
      }
    }
    for (const childNode of ()) {
      (childNode, keyword, results);
    }
  }
}

async function search() {
  // Example usage  const trie = new Trie();
  const dataArray = await getJSON();
  ((item) => {
    (, item);
  });
  const startTime = new Date().getTime();
  const results = ("Headquarters");
  const endTime = new Date().getTime();
  (`Time-consuming search：${endTime - startTime}`);
  (trie, "results", results);
}
search();

function search() {
  const startTime = new Date().getTime();
  const fuseOptions = {
    // isCaseSensitive: false, // Indicates whether the comparison should be case sensitive.    // includeScore: true, // Whether the score should be included in the result set.  A score of 0 means an exact match, and a score of 1 means an entire mismatch.    // shouldSort: true, // Whether to sort the result list by score.    // includeMatches: true, // Whether the match should be included in the result set.  When true, each record in the result set will contain an index of the matching characters.  Therefore, these can be used for highlighting purposes.    // findAllMatches: true, // When true, the match function will continue to the end of the search pattern, even if a perfect match has been found in the string.    // minMatchCharLength: 1, // Return only matches with length exceeding this value.  (For example, if you want to ignore a single character match in the result, set it to 2).    // location: 0, // Determines the approximate location of the pattern expected to be found in the text.    // threshold: 0.6, // When will the matching algorithm be given up?  Threshold 0.0 requires a perfect match (letter and position), and threshold 1.0 can match anything    // distance: 100, // Determines the proximity of the match to the fuzzy position (specified by location).  The exact letter match of the characters away from the blurred position will be scored as a complete mismatch.  A distanceof0 requires matching the exact specified location.  The distance 1000 requires a perfect match within 800 characters found using of.  locationthreshold0.8    // ignoreLocation: true, // true, search will ignore location and distance, so the location where the pattern appears in the string does not matter.    // ignoreFieldNorm: true, //true, the calculation of the correlation score (for sorting) will ignore the field length norm.    // fieldNormWeight: 1, // Determine the degree of influence of the field length norm on the score.  The value 0 is equivalent to ignoring the field length norm.  A value of 0.5 will greatly reduce the impact of the field length norm, while a value of 2.0 will greatly increase the impact of the field length norm.    keys: ["name"],
  };
  const fuse = new Fuse(data, fuseOptions);
  const searchPattern = "Human Resources Department, Meat Headquarters";
  result = (searchPattern);
  const endTime = new Date().getTime();
  (`Time-consuming search：${endTime - startTime}`);
  (result);
}

let array = [{id:1,name:"Headquarters"},{id:2,name:"total"},{id:3,name:"department"}]

let result = {"total":{ids:[1,2]},"department":{ids:[1,3]}}