SOURCE

// 1. 数组缓存执行
const doubleDupicate=(arr)=>{
    return arr.filter(item=>item%2===0)
    .map((item,index)=>{
        return item*2
    });
}
// console.log(doubleDupicate([1,2,3,3,4,5,6,8,8]))

// 2. 字符串去重
const removeDupicate=(str)=>{
    const map = new Map();
    let result = "";
    for(const char of str) {
        if(!map.has(char)) {
            map.set(char,true);
            result+=char;
        }
    }
    return result;
}
// console.log(removeDupicate("AAbbaaaccddd"))

// 3. debounce 防抖
const debounce=(fn,delay)=>{
    let timer = null;
    return function(...args) {
    if(timer) clearTimeout(timer);
    timer = setTimeout(()=>{
        fn.apply(this,args)
    },delay)
    }
}
const debounced=debounce(()=>{console.log("111")},1000)

// 4. throttle 节流 (with leading/trailing)
const throttle=(fn,limit)=>{
    let last = 0;
    return function(...args) {
        let now = Date.now();
        if(now-last>=limit) {
            fn.apply(this,args);
            last = now;
        }
    }

}

const throttled = throttle(() => console.log("Scroll!"), 1000);

// 5. 查找最长无重复字符串 (Sliding Window)
const maxNoDupicateStr=(str)=>{
    let left = 0;
    let set = new Set();
    let max = 0;
    for(let right=0;right<str.length;right++) {
        while(set.has(str[right])) {
            set.delete(str[left])
            left++;
        }
        set.add(str[right])
        max = Math.max(max,right-left+1);
    }
    return max;
}
// console.log(maxNoDupicateStr("abacaedef"))

// 6. 最大子数组和 (Kadane)
const maxCount=(nums)=>{
    let left = 0;
    let max = nums[0];
    let tempMax = nums[0];
    for(let right=0;right<nums.length;right++) {
        tempMax = Math.max(nums[right],tempMax+nums[right]);
        max = Math.max(tempMax,max);
    }
    return max;
}
// console.log(maxCount([-2,1,-3,4,-1,2,1,-5,4]))

const promiseAll=(promises)=>{
    return new Promise((resolve,reject)=>{
        const result = [];
        let count = 0;
        if(promises.length===0) {
            resolve([]);
            return;
        }
        for(let p of promises) {
            Promise.resolve(p)
            .then(value=>{
                result.push(value);
                count++;
                if(count===promises.length) {
                    resolve(result)
                }
            })
            .catch(err=>{
                reject(err)
            })
        }       
    })
}

const promiseRace=(promises)=>{
    return new Promise((resolve,reject)=>{
        if(promises.length===0) {
            resolve([]);
            return;
        }
        promises.forEach((p,index)=>{
            Promise.resolve(p)
            .then(value=>resolve(value))
            .catch(err=>reject(err))
        })
    })
}

const promiseAny=(promises)=>{
    return new Promise((resolve,reject)=>{
        if(promises.length===0) {
            resolve([]);
            return;
        }
        const errResult = []
        let count = 0;
        promises.forEach((p,index)=>{
            Promise.resolve(p)
            .then(value=>resolve(value))
            .catch(err=>{
                errResult.push(err)
                count++;
                if(count===promises.length) {
                // reject(new AggregateError(errResult, "All promises were rejected"));
                    reject(errResult)
                }
            })
        })
    })
}

const p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);
const p3 = Promise.resolve(3);

const p4 = Promise.reject(4);
const p5 = Promise.reject(5);
const p6 = Promise.reject(6);

// promiseAll([p1, p2, p3])
//   .then(res => console.log(res)) // [1, 2, 3]
//   .catch(err => console.error(err));

// promiseRace([p1, p2, p3])
//   .then(res => console.log(res)) // [1, 2, 3]
//   .catch(err => console.error(err));

// promiseAny([p4, p5, p6])
//   .then(res => console.log(res)) // [1, 2, 3]
//   .catch(err => console.error(err));

const delegate=(parent,selector,type,handler)=>{
    parent.addEventListener(type,(event)=>{
        let target = event.target;
        while(target&&target!==parent) {
            if(target.matches(selector)){
                handler.call(target,event);
                break;
            }
            target = target.parentElement;
        }
    })
}

const ul = document.getElementById("list");

delegate(ul, "li", "click", function (e) {
  console.log("You clicked:", this.textContent);
});

// 字符串中的第一个唯一字符
const findFirst=(s)=>{
    const set = new Set();
    for(const char of s) {
        if(!set.has(char)) set.add(char);
        else set.delete(char);
    }
    for(let i=0;i<s.length;i++) {
        if(set.has(s[i])) return i;
    }
    return -1;
}
// console.log(findFirst("lovelevetcode"))

// 翻转字符串中的单词顺序
const reverseStr=(str)=>{
    let s = str.trim();
    let ans = "";
    for(let right=s.length-1;right>=0;right--) {
        while(right>=0&&s[right]===" ") right--;
        let left = right-1;
        while(left>=0&&s[left]!==" ") left--;
        ans+=s.slice(left+1,right+1)+" ";
        right = left;
    }
    return ans.trim();
}
// console.log(reverseStr("  the sky  is  blue  "))

// 数组扁平化
const flatten=(arr)=>{
    if(arr.length===0) return [];
    let result = [];
    for(const item of arr) {
        if(!Array.isArray(item)) result.push(item);
        else result.push(...flatten(item))
    } 
    return result;
}
// console.log(flatten([1, [2, [3, 4], 5], 6]));

// 字符频率排序输出
const frequency=(s)=>{
    const map = new Map();
    let result = ""
    for(const char of s) {
        map.set(char,(map.get(char)||0)+1)
    }
    const arr = Array.from(map).sort((a,b)=>b[1]-a[1])
    for(let i in arr) {
        result+= arr[i][0].repeat(arr[i][1])
    }
    return result;
}
// console.log(frequency("Aabbdddcc"))

// 两个数组的交集（去重）
const intersection=(nums1,nums2)=>{
    const set1 = new Set(nums1);
    const set2 = new Set();
    for(const item of nums2) {
        if(set1.has(item)) set2.add(item)
    }
    return Array.from(set2)
}
// console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4] or [4, 9]

// 深拷贝函数 deepClone
const deepClone=(obj,cache=new Map())=>{
    if(obj===null||typeof obj!=="object") return obj;
    if(cache.has(obj)) return cache.get(obj);
    let clone = Array.isArray(obj)?[]:{};
    cache.set(obj,clone);
    for(const key in obj) {
        clone[key] = deepClone(obj[key],cache)
    }
    return clone;
}

const obj = {
  name: 'Alice',
  info: {
    age: 25,
    favorites: ['music', 'chess'],
  },
};

// 创建循环引用
obj.self = obj;

const copy = deepClone(obj);
// console.log(copy.name);                    // Alice
// console.log(copy.info.favorites[0]);      // music
// console.log(copy.self === copy);          // true ✅ 不死循环
// console.log(copy === obj);                // false ✅ 是不同对象

// LRU 缓存实现（基于 Map）
class LRUCache {
    constructor(size) {
        this.size = size;
        this.cache = new Map();
    }
    put(key,value) {
        if(this.cache.size<this.size) this.cache.set(key,value);
        else {
            this.cache.delete(this.cache.keys().next().value);
            this.cache.set(key,value)
        }
    }
    get(key) {
        if(!this.cache.has(key)) return -1;
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key,value)
        return value;
    }
}
// const cache = new LRUCache(2);
// cache.put(1, 1);
// cache.put(2, 2);
// console.log(cache.get(1)); // 1
// cache.put(3, 3);           // 移除 key=2
// console.log(cache.get(2)); // -1
// cache.put(4, 4);           // 移除 key=1
// console.log(cache.get(1)); // -1
// console.log(cache.get(3)); // 3
// console.log(cache.get(4)); // 4

// 用 Map 统计频率，找出最大值
const findMostFrequence=(s)=>{
    const map = new Map();
    let max = 0;
    if(s==="") return "";
    for(const char of s) {
        map.set(char,(map.get(char)||0)+1)
        max = Math.max(max,map.get(char))
    }
    for(const [key,value] of map) {
        if(map.get(key)===max) return key;
    }
}
// console.log(findMostFrequence("daabbbdccdccd"))

// 判断两个字符串是否是 anagram异构词
const anagram=(s1,s2)=>{
    if(s1.length!=s2.length) return false;
    const map1 = new Map();
    const map2 = new Map();
    for(const char of s1) {
        map1.set(char,(map1.get(char)||0)+1);
    }
    for(const char of s2) {
        if(!map1.has(char)) return false;
        map1.set(char,map1.get(char)-1);
        if(map1.get(char)===0) map1.delete(char);
    }
    if(map1.size===0) return true;
    return false;
}
const str1 = "listen";
const str2 = "sitlen";
const str3 = "listes"
// console.log(anagram(str1,str2));

// 实现数组随机打乱 (shuffle)
const shuffle=(arr)=>{
    for(let i=arr.length-1;i>0;i--) {
        const j = Math.floor(Math.random()*(i+1));
        [arr[i],arr[j]] = [arr[j],arr[i]]
    }
    return arr;
}
// console.log(shuffle(['A','B','C','D']))
// console.log(shuffle(['A','B','C','D']))
// console.log(shuffle(['A','B','C','D']))

const deepUniqueArray=(arr)=>{
    const result = [];
    const set = new Set();
    for(const item of arr) {
        let key;
        if(item!==null&&typeof item==="object") {
            key = JSON.stringify(item)
        } else key = item
        if(!set.has(key)) {
            set.add(key)
            result.push(item);
        }
    }
    return result;
}

// console.log(deepUniqueArray([1, 2, 2, 3]))              // [1, 2, 3]
// console.log(deepUniqueArray(["a", "a", "b"]))           // ["a", "b"]
// console.log(deepUniqueArray([{x:1}, {x:1}, {x:2}]) )    // [{x:1}, {x:2}]
// console.log(deepUniqueArray([[1,2], [1,2], [2,1]]))     // [[1,2], [2,1]]

const shallowEqual=(obj1,obj2)=>{
    if(obj1===obj2) return true;
    if(typeof obj1!=="object"
    ||typeof obj2!=="object"
    ||obj1===null||obj2===null
    ) return false;
    const key1 = Object.keys(obj1);
    const key2 = Object.keys(obj2);
    if(key1.length!==key2.length) return false;
    for(const key of key1) {
        if(!obj2.hasOwnProperty(key)
        ||obj2[key]!==obj1[key]
        ) return false;
    }
    return true;
}

const a = { name: "Alice", age: 20};
const b = { name: "Alice", age: 20};
const c = { name: "Alice" };

// console.log(shallowEqual(a, b)); // true
// console.log(shallowEqual(a, c)); // false
// console.log(shallowEqual(a, a)); // true

const flattenObject=(obj,prefix="",result={})=>{
    
    for(const item in obj) {
        const key = prefix?`${prefix}.${item}`:item;
        if(typeof obj[item]==="object"&&obj[item]!==null) {
            flattenObject(obj[item],key,result)
        }
        else result[key] = obj[item]
    }

    return result;
}
// function flattenObject(obj, prefix = '', result = {}) {
//   for (let key in obj) {
//     if (!obj.hasOwnProperty(key)) continue;

//     const fullKey = prefix ? `${prefix}.${key}` : key;
//     const value = obj[key];

//     if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
//       flattenObject(value, fullKey, result); // 递归
//     } else {
//       result[fullKey] = value; // 扁平化赋值
//     }
//   }

//   return result;
// }


console.log(flattenObject({
  a: 1,
  b: {
    c: 2,
    d: {
      e: 3
    }
  }
})
)

<button onclick="debounced()">debounce</button>
<button onclick="throttled()">throttle</button>
<ul id="list">
  <li>Item 1</li>
  <li>Item 2</li>
</ul>