【面试题】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)