function init() {
  // 打開 IndexedDB 數據庫
  const openDB = window.indexedDB.open("myDatabase", 1);
  // 新建數據庫和數據庫版本號發(fā)生變化時才被調用
  openDB.onupgradeneeded = function (event) {
    const db = event.target.result;
    // 創(chuàng)建對象存儲空間
    const objectStore = db.createObjectStore("myObjectStore", {
      keyPath: "code",
    });
    // 添加索引
    // objectStore.createIndex("code", "code");
    objectStore.createIndex("pCode", "pCode", { unique: false });
    objectStore.createIndex("name", "name", { unique: false });
  };

  openDB.onsuccess = async function (event) {
    const db = event.target.result;
    const dataArray = data;
    // 獲取事務對象
    const transaction = db.transaction(["myObjectStore"], "readwrite");
    // 獲取對象存儲空間
    const objectStore = transaction.objectStore("myObjectStore");

    // 向對象存儲添加對象
    dataArray.forEach(function (data) {
      const addRequest = objectStore.add(data);

      addRequest.onsuccess = function () {
        console.log("數據已成功添加到對象存儲");
      };

      addRequest.onerror = function (error) {
        console.error("添加數據時發(fā)生錯誤", error);
      };
    });
  };
}

function search() {
  window.result = [];
  // 打開數據庫
  const openRequest = window.indexedDB.open("myDatabase", 1);
  // 打開數據庫成功回調
  openRequest.onsuccess = function (event) {
    // 數據庫對象
    const db = event.target.result;
    // 打開只讀事務并獲取對象存儲 readwrite 讀寫  readonly 只讀
    const transaction = db.transaction(["myObjectStore"], "readonly");
    // 獲取myObjectStore對象存儲空間的引用
    const objectStore = transaction.objectStore("myObjectStore");
    // 獲取 name 索引
    const index = objectStore.index("name");
    // 打開游標
    const request = index.openCursor(); // 全部數據
    // const request = index.openCursor(searchKey); // 精準匹配
    // const request = index.openCursor(
    //   IDBKeyRange.bound(searchKey, searchKey + "\uffff", false, false)
    // ); // 后模糊
    const startTime = new Date().getTime();
    request.onsuccess = function (event) {
      const cursor = event.target.result;
      if (cursor) {
        const name = cursor.value.name;
        // 判斷 name 是否包含搜索關鍵字 如果是后模糊的話 直接拿name就行
        if (regex.test(name)) {
          result.push(cursor.value);
        }
        cursor.continue();
      } else {
        const endTime = new Date().getTime();
        console.log(`搜索耗時：${endTime - startTime}`);
        console.log(result);
      }
    };

    request.onerror = function () {
      console.error("執(zhí)行搜索時發(fā)生錯誤");
    };
  };
  // 打開數據庫失敗回調
  openRequest.onerror = function () {
    console.error("打開數據庫時發(fā)生錯誤");
  };
}

class TrieNode {
  constructor() {
    this.children = new Map(); // 用于存儲當前節(jié)點的子節(jié)點
    this.isEndOfWord = false; // 表示當前節(jié)點是否是一個單詞的結尾
    this.values = []; // 用于存儲與當前節(jié)點關聯的值
  }
}

class Trie {
  constructor() {
    this.root = new TrieNode();
  }
  // 如果當前字符不存在于當前節(jié)點的子節(jié)點中，則創(chuàng)建一個新的子節(jié)點，
  // 并將其添加到子節(jié)點Map中。然后，將當前節(jié)點更新為新的子節(jié)點，繼續(xù)遍歷下一個字符。
  // 當遍歷完所有字符后，將當前節(jié)點的isEndOfWord屬性設置為true，表示該節(jié)點是一個單詞的結尾。
  // 同時，將與該單詞關聯的值添加到當前節(jié)點的values數組中。
  insert(word, value) {
    let node = this.root;
    for (let i = 0; i < word.length; i++) {
      const char = word[i];

      if (!node.children.has(char)) {
        node.children.set(char, new TrieNode());
      }
      node = node.children.get(char);
    }
    node.isEndOfWord = true;
    node.values.push(value);
  }

  // 遞歸地收集以給定節(jié)點為根的子樹中所有單詞的關聯值。如果當前節(jié)點是一個單詞的結尾
  // 則將該節(jié)點的所有關聯值添加到結果集合中。然后，對當前節(jié)點的每個子節(jié)點
  // 遞歸調用collectValues方法。
  collectValues(node, results) {
    if (node.isEndOfWord) {
      for (const value of node.values) {
        results.add(value);
      }
    }
    for (const childNode of node.children.values()) {
      this.collectValues(childNode, results);
    }
  }

  // 模糊搜索與給定關鍵字匹配的單詞，并返回匹配到的所有關聯值。該方法首先創(chuàng)建一個空的
  // Set對象results，用于存儲結果。然后，調用collectSuffixValues方法，
  // 從根節(jié)點開始遞歸地搜索與關鍵字匹配的單詞，并將匹配到的關聯值添加到results中。
  // 最后，將results轉換為數組并返回。
  fuzzySearch(keyword) {
    const results = new Set();
    this.collectSuffixValues(this.root, keyword, results);
    return Array.from(results);
  }

  // 遞歸地搜索與給定關鍵字后綴匹配的單詞，并將匹配到的關聯值添加到結果集合中。
  // 如果關鍵字的長度為0，表示已經匹配到了關鍵字的末尾，此時調用collectValues方法，
  // 將當前節(jié)點及其子樹中的所有關聯值添加到結果集合中。
  // 否則，取關鍵字的第一個字符char，并獲取當前節(jié)點的子節(jié)點childNode。
  // 如果childNode存在，則遞歸調用collectSuffixValues方法，
  // 將關鍵字的剩余部分和childNode作為參數傳遞。
  // 然后，對當前節(jié)點的每個子節(jié)點，遞歸調用collectSuffixValues方法，
  // 將關鍵字和結果集合作為參數傳遞
  collectSuffixValues(node, keyword, results) {
    if (keyword.length === 0) {
      this.collectValues(node, results);
    } else {
      const char = keyword[0];
      const childNode = node.children.get(char);
      if (childNode) {
        this.collectSuffixValues(childNode, keyword.slice(1), results);
      }
    }
    for (const childNode of node.children.values()) {
      this.collectSuffixValues(childNode, keyword, results);
    }
  }
}

async function search() {
  // 示例用法
  const trie = new Trie();
  const dataArray = await getJSON();
  dataArray.forEach((item) => {
    trie.insert(item.name, item);
  });
  const startTime = new Date().getTime();
  const results = trie.fuzzySearch("總部");
  const endTime = new Date().getTime();
  console.log(`搜索耗時：${endTime - startTime}`);
  console.log(trie, "results", results);
}
search();

function search() {
  const startTime = new Date().getTime();
  const fuseOptions = {
    // isCaseSensitive: false, // 指示比較是否應區(qū)分大小寫。
    // includeScore: true, // 分數是否應包含在結果集中。分數0表示完全匹配，分數1表示完全不匹配。
    // shouldSort: true, // 是否按分數對結果列表進行排序。
    // includeMatches: true, // 匹配是否應包含在結果集中。當 時true，結果集中的每條記錄都將包含匹配字符的索引。因此，這些可以用于突出顯示的目的。
    // findAllMatches: true, // 當為 true 時，匹配函數將繼續(xù)到搜索模式的末尾，即使已在字符串中找到完美匹配。
    // minMatchCharLength: 1, // 僅返回長度超過該值的匹配項。（例如，如果您想忽略結果中的單個字符匹配，請將其設置為2）。
    // location: 0, // 確定預期在文本中找到的模式的大概位置。
    // threshold: 0.6, // 匹配算法在什么時候放棄。閾值0.0需要完美匹配（字母和位置），閾值1.0可以匹配任何內容
    // distance: 100, // 確定匹配與模糊位置的接近程度（由 指定location）。distance遠離模糊位置的字符的精確字母匹配將被評分為完全不匹配。A distanceof0要求匹配精確指定location。距離1000需要在使用of找到的800字符內有完美匹配。locationthreshold0.8
    // ignoreLocation: true, // true，搜索將忽略location和distance，因此模式出現在字符串中的位置并不重要。
    // ignoreFieldNorm: true, //true，相關性得分（用于排序）的計算將忽略字段長度范數。
    // fieldNormWeight: 1, // 確定字段長度范數對評分的影響程度。值0相當于忽略字段長度范數。值0.5將大大降低字段長度范數的影響，而值2.0將大大增加字段長度范數的影響。
    keys: ["name"],
  };
  const fuse = new Fuse(data, fuseOptions);
  const searchPattern = "肉食總部人力資源部";
  result = fuse.search(searchPattern);
  const endTime = new Date().getTime();
  console.log(`搜索耗時：${endTime - startTime}`);
  console.log(result);
}

let array = [{id:1,name:"總部"},{id:2,name:"總"},{id:3,name:"部"}]

let result = {"總":{ids:[1,2]},"部":{ids:[1,3]}}