JavaScript面试题

1.大小写字母转换

let str = `AbDaz世界你好@1qq`; // =>aBd

const lower2uUpper = (str) => {
    let result = [];
    for (let i = 0; i < str.length; i++) {
        let code = str.charCodeAt(i);
        if (code >= 65 && code < 97) {// 大写
            console.log('大写=>', code, str[i], str[i].toLowerCase());
            result.push(str[i].toLowerCase());
        } else if (code >= 97 && code <= 122) {
            console.log('小写=>', code, str[i], str[i].toUpperCase());
            result.push(str[i].toUpperCase());
        }
    }
    return result.join('');
};
// console.log(lower2uUpper(str));

str = str.replace(/[a-zA-Z]/g, (content) => {
    return content.toUpperCase() === content ? content.toLowerCase() : content.toUpperCase();
});
console.log(str);

2.返回字符串匹配位置

let S = 'xianjs.com.abc.def';
let T = 'abc';
// 在字符串S中查找T返回位置,找不到返回-1
;(function () {
    function myIndexOf(T) {
        let str = this;
        let target = T;
        for (let i = 0; i < str.length - target.length + 1; i++) {
            // console.log(str.substr(i, target.length));
            if (str.substr(i, target.length) === target) {
                return i;
            }
        }
        return -1;
    }

    function myIndexOf2(T) {
        let reg = new RegExp(T);

        let ret = this.match(T);
        if (ret != null) {
            return ret.index;
        }
        return -1;
    }

    String.prototype.myIndexOf = myIndexOf;
    String.prototype.myIndexOf2 = myIndexOf2;
})();
console.log(S.myIndexOf(T));
console.log(S.myIndexOf2(T));

// 11
// 11

3.数组扁平化

let arr = [[[12, 3, [1, [[5]], ['AA', 'BB']]]]];

/*
* 1.reduce+递归
* */
const myFlat = (arr) => {
    return arr.reduce((prev = [], next) => {
        if (Array.isArray(next)) {
            return prev.concat(myFlat(next));
        } else {
            return prev.concat(next);
        }
    }, []);
};
/*
* 2.数组新方法flat
* */
console.log(arr.flat(Infinity));
/*
* 3.有缺陷
* */
const flatten = (arr) => {
    return arr.toString().split(',');
};

/*

4.扩展运算符
es6的扩展运算符能将二维数组变为一维

    [].concat(...[1, 2, 3, [4, 5]]);  // [1, 2, 3, 4, 5]
根据这个结果我们可以做一个遍历，若arr中含有数组则使用一次扩展运算符，直至没有为止。
*/

function flatten2(arr) {
    while (arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr);
    }
    return arr;
}

/*5.
join & split，join也可以将数组转换为字符串*/

function flatten3(arr) {
    return arr.join(',').split(',').map(function (item) {
        return parseInt(item);
    });
}

console.log(flatten(arr));

4.underscore数组扁平化

/**
 * 数组扁平化
 * @param  {Array} input   要处理的数组
 * @param  {boolean} shallow 是否只扁平一层
 * @param  {boolean} strict  是否严格处理元素，下面有解释
 * @param  {Array} output  这是为了方便递归而传递的参数
 * 源码地址：https://github.com/jashkenas/underscore/blob/master/underscore.js#L528
 */
function flatten(input, shallow, strict, output) {

    // 递归使用的时候会用到output
    output = output || [];
    var idx = output.length;

    for (var i = 0, len = input.length; i < len; i++) {

        var value = input[i];
        // 如果是数组，就进行处理
        if (Array.isArray(value)) {
            // 如果是只扁平一层，遍历该数组，依此填入 output
            if (shallow) {
                var j = 0, len = value.length;
                while (j < len) output[idx++] = value[j++];
            }
            // 如果是全部扁平就递归，传入已经处理的 output，递归中接着处理 output
            else {
                flatten(value, shallow, strict, output);
                idx = output.length;
            }
        }
        // 不是数组，根据 strict 的值判断是跳过不处理还是放入 output
        else if (!strict){
            output[idx++] = value;
        }
    }

    return output;

}