SOURCE

const func=(str)=>{
    const map = new Map();
    for(let char of str) {
        map.set(char,(map.get(char)||0)+1);
    }
    return Array.from(map).sort((a,b)=>b[1]-a[1])[0][0];
}
const func2=(str)=>{
    const map = new Map();
    let maxChar = "";
    let maxLength = 0;
    for(let char of str) {
        let count = (map.get(char)||0)+1
        map.set(char,count);
        if(count>maxLength) {
            maxLength = count;
            maxChar = char;
        }
    }
    return maxChar;
}
const str = "aabbbccc";
// console.log(func2(str));

const anagram=(str1,str2)=>{
    if(str1.length===0&&str2.length===0
    &&str1===""&&str2==="") return true;
    if(str1.length===str2.length) {
        const map1 = new Map();
        const map2 = new Map();
        for(let char of str1) {
            map1.set(char,(map1.get(char)||0)+1);
        }
        for(let char of str2) {
            map2.set(char,(map2.get(char)||0)+1);
        }
        if(map1.size!==map2.size) return false;
        for(const [key,value] of map1) {
            if(!map2.has(key)||map2.get(key)!==value) return false;
        }
        return true;
    }
    return false;
}
const str1 = "listen";
const str2 = "sitenl";
const str3 = "listes"
// console.log(anagram(str1,str2));

const shuffle=(arr)=>{
    for (let i = arr.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1)); // [0, i]
    [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 set = new Set();
    let ans = [];
    for(let item of arr) {
        let key = typeof item==='object'&&item!==null
        ?JSON.stringify(item)
        :item;

        if(!set.has(key)) {
            set.add(key);
            ans.push(item);
        }
    }
    return ans;
}
// 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 sleep=(ms)=>{
    return new Promise((resolve,reject)=>{
        setTimeout(()=>{resolve()},ms)
    })
}
async function demo() {
  console.log("Start");
  await sleep(2000);     // 等待 1 秒
  console.log("End after 1s");
}
// demo();
             
const promiseImg=(url)=>{
    return new Promise((resolve,reject)=>{
        let img = new Image();
        img.onload = ()=>resolve(img);
        img.onerror = ()=>reject(new Error("failed to load img"));
        img.src = url;
    })
}
// promiseImg("https://example.com/image.jpg")
// .then(console.log("success"))
// .catch(err=>console.log("error"))

const shallowEqual=(obj1,obj2)=>{
    if(obj1===obj2) return true;
    if(typeof obj1!=='object'
    ||typeof obj2!=='object'
    ||obj1===null||obj2===null
    ) return false;

    if(Object.keys(obj1).length!==Object.keys(obj2).length) return false;
    for(const key of Object.keys(obj1)) {
        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 deepClone=(source)=>{
    if(typeof source!=='object'||source===null) return source;
    let clone = Array.isArray(source)?[]:{}
    
    for(const key in source) {
        clone[key] = deepClone(source[key])
    }
    return clone;
}
const source = {
  a: 1,
  b: { c: 2, d: [3, 4] }
};
const copy = deepClone(source);

// console.log(copy.b.d === source.b.d);  // false（值一样，但引用不一样）
// console.log(copy); // { a: 1, b: { c: 2, d: [3, 4] } }

const outer=()=>{
    let count = 0;
    return ()=>{
        count++;
        return count;
    }
}
// const counter = outer();  // outer 已经执行完
// console.log(counter());  // 输出 1 ✅
// console.log(counter());  // 输出 2 ✅

const 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) {
            flattenObject(obj[key],fullKey,result)
        }
        else {
            result[fullKey] = value;
        }
    }
    return result;
}

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