手写题 ​

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
arr.sort(function () {
    return Math.random() - 0.5
})

//(1)
function unique(arr) {
    let newArr = [];
    for(let i = 0; i < arr.length; i++){
        if(newArr.indexOf(arr[i]) === -1) {
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

let demo = unique(['a', 'c', 'z', 'a', 'x', 'c', 'b'])
console.log(demo);

//(2)
// var unique = arr => [...new Set(arr)]

//(3)
// function unique(arr) {
//     var res = arr.filter(function(item, index, array) {
//         return array.indexOf(item) === index
//     })
//     return res
// }

//第一种：直接使用.flat
// console.log([1, [1,2],[1,[2]]].flat(3));
//第二种：递归+数组API
//(1)
function flatten(arr) {
    var result = [];
    for(var i = 0, len = arr.length; i < len; i++) {
        if(Array.isArray(arr[i])) {  //  Array.isArray 判断是否为数组
            result = result.concat(flatten(arr[i]))  // concat() 方法用于连接两个或多个数组
        } else {
            result.push(arr[i])
        }
    }
    return result;
}
console.log(flatten([1, [1, 2], [1, [2]]]));
//加上遍历深度之后的写法
function flatten(arr, depth = 1) {
    var result = [];
    for(var i = 0, len = arr.length; i < len; i++) {
        if(Array.isArray(arr[i])) {  // Array.isArray 判断是否为数组
            if(depth > 0) { // 深度大于0时继续扁平化
                result = result.concat(flatten(arr[i], depth - 1))  // concat() 方法用于连接两个或多个数组
            } else { // 深度为0时直接加入结果数组
                result.push(arr[i]);
            }
        } else {
            result.push(arr[i])
        }
    }
    return result;
}
console.log(flatten([1, [1, 2], [1, [2]]])); // [1, 1, 2, 1, [2]]
console.log(flatten([1, [1, 2], [1, [2]]], 2)); // [1, 1, 2, 1, 2]
//(2)
// function flatten(arr) {
//     return arr.reduce((pre, cur) => {
//         return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
//     }, []);
// }
// console.log(flatten([1, [1, 2], [1, [2]]]));

const getJSON = function(url) {
    return new Promise((resolve, reject) => {
        const xhr = XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP');
        xhr.open('GET', url, false);
        xhr.setRequestHeader('Accept', 'application/json');
        xhr.onreadystatechange = function() {
            if (xhr.readyState !== 4) return;
            if (xhr.status === 200 || xhr.status === 304) {
                resolve(xhr.responseText);
            } else {
                reject(new Error(xhr.responseText));
            }
        }
        xhr.send();
    })
}

Promise.all = function(promiseArr) {
    let index = 0, result = []
    return new Promise((resolve, reject) => {
        promiseArr.forEach((p, i) => {
            Promise.resolve(p).then(val => {
                index++
                result[i] = val
                if (index === promiseArr.length) {
                    resolve(result)
                }
            }, err => {
                reject(err)
            })
        })
    })
}

let s = "thisIsTest";
//replace()函数接收两个参数，第一个参数是一个正则表达式或字符串，用于匹配需要替换的内容，第二个参数是一个字符串或一个函数，用于指定替换后的内容
//正则表达式/([A-Z])/g 表示匹配所有大写字母，其中 [A-Z] 表示匹配所有大写字母，() 表示将匹配结果分组。/g 表示全局匹配
//$1表示第一个匹配分组，也就是匹配到的大写字母。在这里，我们将匹配到的大写字母转换为小写，并在前面添加一个连字符
s = s.replace(/([A-Z])/g, "-$1").toLowerCase();

function toHump(name) {
  return name.replace(/\-(\w)/g, function(all, letter){
    console.log(all) //"_T"
    console.log(letter) //"T"
    return letter.toUpperCase();
  });
}