SOURCE

//查看对象是否为数组

const a = [12, 3, 4, 5]

// 第一种
const isArr = (arr) => {
    if (typeof arr === 'object') {
        console.log(111, Object.prototype.toString.call(arr))
        return Object.prototype.toString.call(arr) === '[object Array]'
    } else {
        return false
    }
}
console.log(isArr(a))

// 第二种
console.log(Array.isArray(a))


//第三种instanceof
console.log(instance(a, Object))

//手写instanceof
function instance(cur, target) {
    if (typeof cur !== 'object' || cur === null) {
        return false
    }
    let __proto__ = Object.getPrototypeOf(cur)

    while (__proto__) {
        console.log(__proto__)

        if (__proto__ === target.prototype) {
            console.log(target.prototype)
            return true
        }
        __proto__ = Object.getPrototypeOf(__proto__)
    }
    return false



}

// 第四种
console.log(11111, [].constructor === Array)



//------------------------------------


//冒泡

const line = [12, 3, 4, 5, 6, 7, 5, 4, 3, 32, 325, 6, 7]

const bubbleSort = (arr) => {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length - i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
            }
        }
    }
}


// bubbleSort(line)



//快排

const quickSort = (arr) => {
    if (arr.length < 2) {
        return arr
    }
    const middle = Math.floor(arr.length / 2)

    const [point] = arr.splice(middle, 1)
    const leftsort = []
    const rightsort = []

    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < point) {
            leftsort.push(arr[i])
        } else {
            rightsort.push(arr[i])
        }
    }

    return [...quickSort(leftsort), point, ...quickSort(rightsort)]

}

console.log(quickSort(line))


//获取字符串的字节数

function getByteCount(str) {
    let len = str.length
    for (let i = 0; i < str.length; i++) {
        str.charCodeAt(i) > 255 && len++
    }
    return len
}

console.log(getByteCount('1你好'))


//手写bind

function mybind(context, ...args) {
    const fn = this

    return function (...argument) {
        return fn.apply(context, [...argument, ...args])

    }
}

function clone(source, map = new WeakMap()) {
    if (source === null || typeof source !== 'object') {
        return source
    }
    if (map.has(source)) {
        map.get(source)
    }
    const object = source.constructor() //[] or {}

    map.set(source, object)
    for (let key in source) {
        if (source.hasOwnProperty(key))
            object[key] = clone(source[key], map)
    }
    return object


}


console.log(clone({ a: 1, b: [1, 2, 3,], c: { d: 1 } }))


//随机sort 10-100
const mySort = (start, end, count) => {
    // 1.算范围
    // 2.循环
    const range = end - start + 1
    const arr = []

    for (let i = 0; i <= count; i++) {
        //0~1*91+10 = 10~101向下取整
        arr.push(Math.floor(Math.random() * range + start))
    }
    arr.sort((a, b) => a - b)
    return arr
}
console.log(mySort(10, 100, 10))

//递归1-100


// function sum(start, end, total = 0) {
//     return start > end ? total : sum(start + 1, end, total + start)

// }
function sum(val) {
    if (val === 1) {
        return val
    }
    return val + sum(val - 1)
}

console.log(sum(100))


//提取url参数

const obj = {}

const organl_url = "https://example.com/?foo=bar&baz=qux";

// const url = new URL(organl_url).search

// const params = new URLSearchParams(url)

// for (let [key, value] of params) {
//     obj[key] = value
// }

// console.log(obj)

const params = organl_url.split('?')[1]
const search = params.split('&')
const type = search.map(item => item.split('='))

for (let [key, value] of type) {
    obj[key] = value
}
console.log(obj)


//实现trim()
const _trim = function (a) {
    return a.replace(/^\s+/, "").replace(/\s+$/, "")

}

ab = '              12312312312           '
console.log(_trim(ab))


//每秒打印1-到10
// let i= 1
// const cd = setInterval(()=>{
//     console.log(i++)
//     if(i>10){
//         clearInterval(cd)
//     }
// },1000)

// 数组扁平化处理 递归
const arrFlat = [1, 2, 3, 4, 5, 6, [1, 2, 34, 235, 6345, [123123, 5, 6, 7], ['abc'], ['qqqq', 'cccc']]]
const fnflat = (arr) => arr.reduce((pre, cur) => pre.concat(Array.isArray(cur) ? fnflat(cur) : cur),[])




console.log(fnflat(arrFlat))


//手写-查找数组公共前缀
// 示例 1：

// 输入：strs = ["flower","flow","flight"]
// 输出："fl"

var longestCommonPrefix = function (strs) {
    // 纵向比较,先拿一个出来和剩下的对比
    const target = strs[0]
    let res = ""
    for (let i = 0; i < target.length; i++) {
        single = target[i]
        for (let j = 1; j < strs.length; j++) {
            otherWord = strs[j]// 这里拿到的是一个单词
            if (otherWord[i] !== single || i === otherWord.length) {
                return res
            }
        }
        res +=single
    }
    return res

};