【面试题】JavaScript

第一题 合并

const a = {
    name: "zhangsan",
    age: 22
}

const b = {
    name: "lisi",
    age: 55
}

a，b对象，并且不改变a，b，把合并后的对象转为字符串打印到控制台

答案: 

var c = {}
c.a = JSON.parse(JSON.stringify(a));
c.b = JSON.parse(JSON.stringify(b));
var string = "";
function fn(object) {
    for (const key in object) {
        if (object.hasOwnProperty(key)) {
            const element = object[key];
            if(typeof element == "object"){
                fn(element);
            }else {
                string += "," + key + ":" + element 
            }
        }
    }
}

fn(c);
console.log(string.slice(1))

 第二题 把setTimeout(()=>{return 3+4;})封装在Promise中并获得其值

new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(3 + 4);
    })
}).then((data) => {
    console.log(data)
})

 第三题 随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。

/**
 * 一个产生10个长度随机整数数组的函数
*/
function getRandomInt() {
    let arr = [];
    for (let index = 0; index < 10; index++) {
        arr.push(Math.round(Math.random() * 50));
    }
    return arr;
}

let arr = getRandomInt();
/**
    * 数组去重  排序
    */
arr = Array.from(new Set(arr)).sort((a, b) => {
    return a - b;
});

/**
    * 0-9一组
    * 10-19一组 类推
    */
var result = [];
arr.forEach(function (val) {
    let index = parseInt(val / 10);
    if (!result[index]) {
        result[index] = [];
    }
    result[index].push(val);
})
console.log(result);

 第四题 反转链表，每 k 个节点反转一次，不足 k 就保持原有顺序

// 创建节点类
class Node {
    constructor(data) {
        this.data = data;
        this.next = null
    }
}
// 创建链表类
class LinkList {
    constructor() {
        this.head = null;
        this.tail = null;
        this.length = 0;
    }
    // 追加节点
    append(data) {
        // 创建节点
        let newNode = new Node(data);
        if (this.head === null) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
    }
}
// 创建链表
function createLinkList(...arr) {
    let list = new LinkList()
    arr.forEach((item) => {
        list.append(item)
    })
    return list;
}

// 翻转head到tail之间的部分，不包括head和tail
// 返回原链表的第一个元素，也就是翻转后的最后一个元素
function reverseList(head, tail) {
    if (head === null || head.next === null) return head;
    // 从要反转的第一个节点开始
    let current = head.next,
        first = head.next;
    let pre = head; // 这里就是翻转不包括head的原因
    while (current !== tail) {
        // 这里就是翻转不包括tail的原因
        // 反转相邻两个节点的顺序
        const next = current.next;
        current.next = pre;
        //  pre和current依次后移一位
        pre = current;
        current = next;
    }
    // 拼接
    head.next = pre;
    first.next = current;

    return first;
}

function reverseKGroup(list, k) {
    if (list.head === null || k === 1) {
        return head;
    }

    let cnt = 0;
    const dummy = {
        next: list.head
    };
    // 在目标链表前设置一个虚拟节点
    let start = dummy;
    let end = list.head;
    while (end !== null) {
        cnt++;
        // 不足k的链表不反转
        if (cnt % k !== 0) {
            end = end.next;
        } else {
            start = reverseList(start, end.next);
            end = start.next;
        }
    }
    return dummy.next;
};
reverseKGroup(createLinkList(1,2,3,4,5,6,7,8,9,10,11),3)