js刷题ing--------2

PS:本文承接上一篇博客“js刷题ing--------1”.文章大体趋势为由易到难，若觉得前面的比较简单可从后面的看起

写一个 RecentCounter 类来计算特定时间范围内最近的请求。
请实现 RecentCounter 类：
RecentCounter() 初始化计数器，请求数为 0 。
int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
保证 每次对 ping 的调用都使用比之前更大的 t 值。

示例：
输入：
inputs = [“RecentCounter”, “ping”, “ping”, “ping”, “ping”]
inputs = [[], [1], [100], [3001], [3002]]
输出：[null, 1, 2, 3, 3]

解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3

var RecentCounter = function() {
    this.time = []
};

/** 
 * @param {number} t
 * @return {number}
 */
RecentCounter.prototype.ping = function(t) {
    this.time.push(t)
    while(this.time[0]<t-3000){
        this.time.shift()
    }
    return this.time.length
};

/**
 * Your RecentCounter object will be instantiated and called as such:
 * var obj = new RecentCounter()
 * var param_1 = obj.ping(t)
 */

给定一个非负整数 x ，计算并返回 x 的平方根，即实现 int sqrt(int x) 函数。
正数的平方根有两个，只输出其中的正数平方根。
如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。

/**
 * @param {number} x
 * @return {number}
 */
var mySqrt = function(x) {
    if(x === 0){
        return 0;
    }
    let left =0;
    let right = x;
    while(left <= right){
        let mid = Math.floor((left+right)/2);
        if(mid*mid === x){
            return mid;
        }else if(mid*mid < x){
            left = mid +1;
        }else{
            right = mid -1;
        }  
    }
    return right;
};
//Math.trunc()去除小数

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。
给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例 1：
输入：words = [“hello”,“leetcode”], order = “hlabcdefgijkmnopqrstuvwxyz”
输出：true
解释：在该语言的字母表中，‘h’ 位于 ‘l’ 之前，所以单词序列是按字典序排列的。

示例 2：
输入：words = [“word”,“world”,“row”], order = “worldabcefghijkmnpqstuvxyz”
输出：false
解释：在该语言的字母表中，‘d’ 位于 ‘l’ 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：
输入：words = [“apple”,“app”], order = “abcdefghijklmnopqrstuvwxyz”
输出：false
解释：当前三个字符 “app” 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 “apple” > “app”，因为 ‘l’ > ‘∅’，其中 ‘∅’ 是空白字符，定义为比任何其他字符都小（更多信息）。

/*
先利用题目给的字母表顺序 orderorder 结合ASCII值，将 wordswords 里的每一个外星语翻译成编程语言可判断的字符串，
所谓的翻译就是从hlabcdefgijkmnopqrstuvwxyz到abcdefghigklmnopqrstuvwxyz的映射，之后判断字符串大小即可。
*/
/**
 * @param {string[]} words
 * @param {string} order
 * @return {boolean}
 */
var isAlienSorted = function(words, order) {
    const dict = {}
    for(let i = 0; i < order.length; i++) dict[order[i]] = i
    words = words.map((word) => {
        return word.split('').reduce((res, w) => {
            return res + String.fromCharCode(97 + dict[w])
        }, '')
    })
    for(let i = 1; i < words.length; i++){
        if(words[i] < words[i - 1]) return false
    }
    return true
};
//字符串的比较为unicode编码的比较

给定两个数组，arr1 和 arr2，
arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例：
输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

var relativeSortArray = function(arr1, arr2) {
    	var obj = {}
	for(let i = 0; i<arr2.length; i++){
		obj[arr2[i]] = i
	}
	arr1 = arr1.sort((a,b)=>{
		if(obj[a] === undefined) obj[a]=arr2.length+a;
		if(obj[b] === undefined) obj[b]=arr2.length + b;
		return obj[a] - obj[b]
	})
	return arr1
};

将函数 fn 的执行上下文改为 obj 对象
输入：function () {return this.greeting + ', ’ + this.name + ‘!!!’;}, {greeting: ‘Hello’, name: ‘Rebecca’}
输出：Hello, Rebecca!!!

关于call、apply、bind的用法可参考这位大神写的

实现函数 functionFunction，调用之后满足如下条件：
1、返回值为一个函数 f
2、调用返回的函数 f，返回值为按照调用顺序的参数拼接，拼接字符为英文逗号加一个空格，即 ', ’
3、所有函数的参数数量为 1，且均为 String 类型
输入：functionFunction(‘Hello’)(‘world’)
输出：Hello, world

// 一个闭包完美解决
function functionFunction(str) {
    return f = function(arr){
        return str+", "+arr;
    };
     
}

实现函数 callIt，调用之后满足如下条件
1、返回的结果为调用 fn 之后的结果
2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {
   let r = [...arguments];
   let s = r.slice(1);
    return fn.apply(null,s);
}

二次封装函数：
实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
    var r=[...arguments]
    var s=r.slice(1)
    return result=function(){
        return fn.apply(this,s.concat([...arguments]))
    }
}

获取数字 num 二进制形式第 bit 位的值。注意：
1、bit 从 1 开始
2、返回 0 或 1
3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

function valueAtBit(num, bit) {
    if(bit < 1) return 
    let arr= num.toString(2).split('').reverse()
    return arr[bit-1]
}

给定二进制字符串，将其换算成对应的十进制数字

function base10(str) {
    return parseInt(str,2)
}

将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。

function convertToBinary(num) {
    let res=num.toString(2);
   return res.length<8?new Array(8-res.length).fill(0).join('')+res:res;
}

实现函数 makeClosures，调用之后满足如下条件：
1、返回一个函数数组 result，长度与 arr 相同
2、运行 result 中第 i 个函数，即 resulti，结果与 fn(arr[i]) 相同
示例：
var arr = [1,2,3];
var fn = function (x) {
return x * x;
}
var result = makeClosures(arr,fn);
(result1 === 4) === (fn(arr[1]) === 4) === true

function makeClosures(arr, fn) {
    var result=[]
    for(let i = 0; i < arr.length ; i ++){
            let fun=function(){
                return fn(arr[i])
            }
           result.push(fun)
    }
    return result
}

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。
输入：1, 2, 3, 4
输出：10

//常规for
function useArguments() {
    let sum = 0;
    for(let i = 0; i < arguments.length; i++){
        sum += arguments[i];
    }
    return sum;
}
//由于arguments只是类数组，并没有一些数组的方法，可将其转为数组后累加
function useArguments() {
    let arr = [...arguments];
    return arr.reduce((total, num)=> total += num)
}

实现函数 partialUsingArguments，调用之后满足如下条件：
1、返回一个函数 result
2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
    var arg=[...arguments].slice(1)
    return function(){
        return fn.apply(this,arg.concat([...arguments]))
    }
}

柯里化：
已知 fn 为一个预定义函数，实现函数 curryIt，调用之后满足如下条件：
1、返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）
2、调用 a 之后，返回一个函数 b, b 的 length 属性值为 1
3、调用 b 之后，返回一个函数 c, c 的 length 属性值为 1
4、调用 c 之后，返回的结果与调用 fn 的返回值一致
5、fn 的参数依次为函数 a, b, c 的调用参数

//粗暴
function curryIt(fn) {
    return function(a){
        return function(b){
            return function(c){
                return fn.call(this,a,b,c)
            }
        }
    }
}

//柯里化
function curryIt(fn) {
    return function fun(a){
        if(fn.length===1)return fn(a)
        fn=fn.bind(this,a)
        return fun
    }
}

模块：
完成函数 createModule，调用之后满足如下要求：
1、返回一个对象
2、对象的 greeting 属性值等于 str1， name 属性值等于 str2
3、对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ’ + name属性值

function createModule(str1, str2) {
    return{
        greeting:str1,
        name:str2,
        sayIt:function(){
            return this.greeting+', '+this.name
        }
    }
}

求 a 和 b 相乘的值，a 和 b 可能是小数，需要注意结果的精度问题
输入：3, 0.0001
输出：0.0003

function multiply(a, b) {
var str1=a.toString()
var str2=b.toString()
var lenA=(str1.indexOf('.')===-1?0:str1.length-str1.indexOf('.')-1)
var lenB=(str2.indexOf('.')===-1?0:str2.length-str2.indexOf('.')-1)
var len=Math.max(lenA,lenB)
return (a*b).toFixed(len)
}

给定一个构造函数 constructor，请完成 alterObjects 方法，将 constructor 的所有实例的 greeting 属性指向给定的 greeting 变量。
考察原型链

function alterObjects(constructor, greeting) {
    return constructor.prototype.greeting = greeting
}

找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
1、返回数组，格式为 key: value
2、结果数组不要求顺序

//1、Object.keys(obj) 只会遍历实例属性key值，不会遍历原型上的属性
 
function iterate(obj) {
    const keyArr = Object.keys(obj)
    const temp = []
    for(let i in keyArr){
        temp[i] = keyArr[i].concat(': ',obj[keyArr[i]])
    }
    return temp
}
//2、for in可以遍历到obj的原型属性和方法，如果不想遍历原型上的，可以在循环内通过obj.hasOwnProperty()判断其是否是自己的实例属性
 
function iterate(obj) {
    const temp = []
    for(let key in obj){
        if(obj.hasOwnProperty(key)){
            temp.push(key.concat(': ',obj[key]))
        }
    }
    return temp
}

给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false

 // 数字有0-9,判断字符串里是否含有0-9数字
    for(let i=0;i<10;i++) {
        if(str.indexOf(i)!==-1) return true
    }
    return false

给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false

function containsRepeatingLetter(str) {
    var reg=/[a-zA-Z]/g
    for(let i = 0;i < str.length-1; i++){
        if(str[i]===str[i+1] && reg.test(str[i])) return true
    }
    return false
}

给定字符串 str，检查其是否以元音字母结尾
1、元音字母包括 a，e，i，o，u，以及对应的大写
2、包含返回 true，否则返回 false

function endsWithVowel(str) {
    const a = str.slice(-1)
    const reg = /a|e|i|o|u/i
    return reg.test(a)
}

描述
给定字符串 str，检查其是否符合美元书写格式
1、以 $ 开始
2、整数部分，从个位起，满 3 个数字用 , 分隔
3、如果为小数，则小数部分长度为 2
4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3

function isUSD(str) {
    let red = /^\$\d{1,3}(,\d{3})*(\.\d{2})*$/
    return red.test(str)
}

将 rgb 颜色字符串转换为十六进制的形式，如 rgb(255, 255, 255) 转为 #ffffff

1. rgb 中每个 , 后面的空格数量不固定
2. 十六进制表达式使用六位小写字母
3. 如果输入不符合 rgb 格式，返回原始输入
   输入：‘rgb(255, 255, 255)’
   输出：#ffffff

function rgb2hex(sRGB) {
     // 去除 sRGB 的空格
    const newSRGB = sRGB.replace(/\s+/g,"");
    // 定义 rbg 的正则表达式
    const exp = /rgb\((0|1\d{0,2}|2[0-5]{2}),(0|1\d{0,2}|2[0-5]{2}),(0|1\d{0,2}|2[0-5]{2})\)/;
    // 若不符合规则，则返回原字符串
    if (!exp.test(newSRGB)) return sRGB
    // 剔除 'rgb(' 和 ')', 剩下 'xx,xx,xx' 的字符串
    const rgbString = newSRGB.substring(4, newSRGB.length - 1)
    // 拆分上述字符串，生成数组
    const arr = rgbString.split(',')
 
    let color = '#'
    // 遍历数组，将每个元素转成16进制的字符串
    for (const item of arr) {
        console.log(item)
        const str = Number(item).toString(16)
        color += str.length === 2 ? str : `0${str}`
    }
    return color
}

css 中经常有类似 background-image 这种通过 - 连接的字符，通过 javascript 设置样式的时候需要将这种样式转换成 backgroundImage 驼峰格式，请完成此转换功能

1. 以 - 为分隔符，将第二个起的非空单词首字母转为大写
2. -webkit-border-image 转换后的结果为 webkitBorderImage

function cssStyle2DomStyle(sName) {
     // 先通过split('-')将原字符串拆分成由若干个字符串组成的数组，并删除空字符串项
  const arrs = sName.split('-').filter(item => item)
  // 定义一个用于记录的空字符串
  let name = ''
  // 循环arrs
  for (const i in arrs) {
      // 首个字符串不做处理
      if (i == 0) {
        name += arrs[i]
      } else {
         // 将对应字符串拆成以单个字母组成的临时数组
         const nameArr = arrs[i].split('')
         // 将index为0的字母转为大写
         nameArr[0] = nameArr[0].toUpperCase()
         // 再将该临时数组组成新的字符串并记录下来   
         name+= nameArr.join('')
      }
  }
 
  return name
}

请补全代码，要求当滑动id为"range"的滑块控件时可以改变id为"rect"的矩形旋转速度。要求如下：

1. id为"rect"的矩形初始动画周期为10秒
2. id为"range"的滑块控件默认值为1、最小值为、最大值为10、滑动间隔为1
3. 当滑动滑块值为1时，矩形动画周期为10秒、当…，为…、当滑动滑块值为10时，矩形动画周期为1秒
   注意：
4. 必须使用DOM0级标准事件（onchange）

请补全JavaScript代码，要求将页面中的"p"标签以键名的形式保存在Map对象中，键名所对应的键值为该"p"标签的文字内容。

 
    	
1
        
    

请补全JavaScript代码，实现以下效果：

1. 选中"全选"框，以下所有选项全部勾选。
2. 把"全选"框从选中状态勾选成未选中状态，其他复选框全部取消选中效果。
3. 当其他复选框全部选中，"全选框"为选中状态。
4. 当其他复选框有一个未选中，"全选框"取消选中状态。
   注意：
5. 必须使用DOM0级标准事件（onchange）

    
        
    
        
    
        

            
全选
            
Java
            
javaScript
            
C++
            
python
            
.net
        

        
    

Alice 有 n 枚糖，其中第 i 枚糖的类型为 candyType[i] 。Alice 注意到她的体重正在增长，所以前去拜访了一位医生。
医生建议 Alice 要少摄入糖分，只吃掉她所有糖的 n / 2 即可（n 是一个偶数）。Alice 非常喜欢这些糖，她想要在遵循医生建议的情况下，尽可能吃到最多不同种类的糖。
给你一个长度为 n 的整数数组 candyType ，返回： Alice 在仅吃掉 n / 2 枚糖的情况下，可以吃到糖的 最多 种类数

//我写的
var distributeCandies = function(candyType) {
    var count =Math.floor(candyType.length / 2);
    var arr = [];
    var sum = 0;
    for(let i = 0; i < candyType.length; i++){
        if(sum === count){
            return sum
        }
        if(arr.indexOf(candyType[i]) === -1){
            arr.push(candyType[i]);
            sum++
        }
    } 
    return sum
};

别人写的
var distributeCandies = function(candyType) {
    const set = new Set(candyType);
    return Math.min(set.size, candyType.length / 2);
};

一个字：靠

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
输入：s = " fly me to the moon "
输出：4
解释：最后一个单词是“moon”，长度为4。

var lengthOfLastWord = function(s) {
    var res = s.trim().split(' ')
    return res[res.length-1].length
}

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

var strStr = function(haystack, needle) {
    return haystack.indexOf(needle)
};

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。

使用动态规划。每个数都有加和不加两种情况
var maxSubArray = function(nums) {
    var pre = 0;
    var max = nums[0];
    nums.forEach((x)=>{
        pre = Math.max(pre + x, x);
        max = Math.max(pre, max)
    })
    return max
};

请补全JavaScript代码，请给参数对象添加拦截代理功能，并返回这个代理，要求每当通过代理调用该对象拥有的属性时，"count"值加1，否则减1

创建一个Proxy实例，该构造函数接收两个参数，第一个参数是被代理的对象，第二个参数是处理方法
在处理方法中设置“get”计算方法，该方法接收两个参数，第一个参数是被代理的对象，第二个参数是当前“get”读取的属性
当第二个参数在第一个参数中时，“count“加1，否则减1

let count = 0
const _proxy = object => {
    let proxy = new Proxy(object, {
        get: function(target, propKey) {
            if(propKey in target) {
                count ++
            } else {
                count --
            }
        }
    })
    return proxy
}

请补全JavaScript代码，请给参数对象添加拦截代理功能并返回这个代理。要求如下：

1. 该函数接收多个参数，首个参数为对象，从第二个参数（包括）往后皆是该对象的属性名
2. 通过该函数给首个参数对象添加拦截器功能，每当该对象访问到该函数第二个参数（包括）往后的属性时，返回"noright"字符串，表示无权限。

const _proxy = (object,...prototypes) => {
    let privatePrototype = prototypes
    return new Proxy(object, {
        get(object, prototype) {
            if(privatePrototype.includes(prototype)) return 'noright'
            return object[prototype]
        }
    })
}

请补全JavaScript代码，实现一个搜索字体高亮的效果。要求如下：

1. 在input框中输入要搜索的内容，当点击查询按钮时，被搜索的字体样式变为加粗，背景色变为’yellow’
2. 重新输入搜索文字，点击查询按钮时，去掉上一次的搜索效果，高亮显示效果只加在本次搜索文字上
3. 如果搜索不到相关内容，清除之前的效果
   注意：
4. 需要加粗的文字请使用b标签包裹
5. 必须使用DOM0级标准事件（onclick）

btn.onclick = () => {
    if (text.innerText.indexOf(search.value) != -1) {
        text.innerHTML = text.innerText.replace(new RegExp(search.value, 'g'), `${search.value}`)
    } else {
        let Btags = document.querySelectorAll("b")
        for (let i = 0; i < Btags.length; i++) {
            Btags[i].style.cssText = "background-color:transparent; color: unset; font-weight: unset;"
        }
    }
}

请补全JavaScript代码，完成函数的接口功能。要求如下：

1. 函数接收两种类型的参数，分别为"get?“和"update?name=xxx&to=yyy”，“name”、"to"为参数，“xxx”、"yyy"分别为参数对应的值。
2. 当参数为"get?"时，返回data数据
3. 当参数为"update?name=xxx&to=yyy"时，将data中所有"name"为"xxx"的项，更改为"name"值为"yyy"

const _api = string => {
	//补全代码
    let method = string.split('?')[0]
    switch(method) {
        case 'get': {
            return data
            break
        }
        case 'update': {
            let query = string.split('?')[1]
            let name = query.split('&')[0].split('=')[1]
            let to = query.split('&')[1].split('=')[1]
            for(item of data) {
                if(item.name === name) item.name = to
            }
            break
        }
        default: {
            return ''
        }
    }
}

请补全JavaScript代码，实现效果如下：

1. 当点击某个栏目（题库、面试、学习、求职）时，该栏目背景色变为’#25bb9b’，其它栏目背景色位’#fff’。
2. 当选中某个栏目时，下方内容就展示索引值相同的类名为".items"的"li"元素
   注意：
3. 必须使用DOM0级标准事件（onclick）
4. 已使用自定义属性存储了栏目的索引值。点击栏目获取索引值，使用索引值控制类名为"items"下的"li"元素

<style>
            ul {
                padding: 0;
                margin: 0;
                list-style: none;
            }

            .options li {
                float: left;
                width: 100px;
                height: 40px;
                line-height: 40px;
                text-align: center;
                border: solid 1px #ddd;
            }

            .items li {
                width: 405px;
                height: 405px;
                display: none;
                border: solid 1px #ddd;
            }
        </style>
    </head>
    <body>
        <ul class='options'>
            <li data-type="0" style='background-color: #25bb9b;'>题库</li>
            <li data-type="1">面试</li>
            <li data-type="2">学习</li>
            <li data-type="3">求职</li>
        </ul>
        <ul class='items'>
            <li style="display: block;">牛客题库，包含编程题、选择题等</li>
            <li>为你的面试提供一站式服务</li>
            <li>校招学习来牛客</li>
            <li>求职中有什么难题，可以联系我们</li>
        </ul>

        <script>
            var options = document.querySelector('.options');
            var optionItems = [].slice.call(document.querySelectorAll('.options li'));
            var items = [].slice.call(document.querySelectorAll('.items li'));
            // 补全代码
			options.onclick = function (event) {
   				 optionItems.forEach((item) => {
       				 item.style.backgroundColor = '#fff'
   				 })
    			event.target.style.backgroundColor = '#25bb9b'
   				 items.forEach((item) => {
       				 item.style.display = 'none'
    			})
   				 items[event.target.dataset.type].style.display = 'block'
				}
        </script>
    </body>

请补全JavaScript代码，要求如下：

1. 当点击"-"按钮时，商品数量减1
2. 当点击"+"按钮时，商品数量加1
3. 每当点击任意按钮时，购物面板中相关信息必须同步更新
   注意：
4. 必须使用DOM0级标准事件（onclick）

    <body>
    	<table>
            <thead>
                <caption>
                    商品
                </caption>
            </thead>
            <tbody>
                <tr>
                    <td>炸鸡</td>
                    <td>28元</td>
                    <td><button id="zjtaiduola">-</button></td>
                    <td><span id="zjsl">0</span></td>
                    <td><button id="zjtaishaola">+</button></td>
                </tr>
                <tr>
                    <td>可乐</td>
                    <td>5元</td>
                    <td><button id="kltaiduola">-</button></td>
                    <td><span id="klsl">0</span></td>
                    <td><button id="kltaishaola">+</button></td>
                </tr>
                <tr>
                    <td>总价：</td>
                    <td><span id="total">0</span></td>
                </tr>
            </tbody>
        </table>
        
        <script type="text/javascript">
            // 补全代码
           let total_zjsl = 0
let total_klsl = 0
let dom_zjtaiduola = document.querySelector('#zjtaiduola')
let dom_zjsl = document.querySelector('#zjsl')
let dom_zjtaishaola = document.querySelector('#zjtaishaola')
let dom_kltaiduola = document.querySelector('#kltaiduola')
let dom_klsl = document.querySelector('#klsl')
let dom_kltaishaola = document.querySelector('#kltaishaola')
let dom_total = document.querySelector('#total')
 
function redraw() {
    dom_zjsl.innerText = total_zjsl
    dom_klsl.innerText = total_klsl
    dom_total.innerText = total_zjsl * 28 + total_klsl * 5
}
 
dom_zjtaiduola.onclick = function() {
    if(total_zjsl > 0) total_zjsl --
    redraw()
}
dom_zjtaishaola.onclick = function() {
    total_zjsl ++
    redraw()
}
 
dom_kltaiduola.onclick = function() {
    if(total_klsl > 0) total_klsl --
    redraw()
}
dom_kltaishaola.onclick = function() {
    total_klsl ++
    redraw()
} 
        </script>
    </body>

请补全JavaScript代码，要求将对象参数转换为真实的DOM结构并返回。
注意：

1. tag为标签名称、props为属性、children为子元素、text为标签内容

<script>
            var vnode = {
                tag: 'ul',
                props: {
                    class: 'list'
                },
                text: '',
                children: [
                    {
                        tag: "li",
                        props: {
                            class: "item"
                        },
                        text: '',
                        children: [
                            {
                                tag: undefined,
                                props: {},
                                text: '牛客网',
                                children: []
                            }
                        ]
                    },
                    {
                        tag: "li",
                        props: {},
                        text: '',
                        children: [
                            {
                                tag: undefined,
                                props: {},
                                text: 'nowcoder',
                                children: []
                            }
                        ]
                    }
                ]
            }
           const _createElm = vnode => {
    let { tag, props, children, text } = vnode
    if (typeof tag == "string") {
        vnode.el = document.createElement(tag)
        _setAttr(vnode.el,props)
        vnode.el.appendChild(document.createTextNode(text))
        children.forEach(child => {
            vnode.el.appendChild(_createElm(child))
        })
    } else {
        vnode.el = document.createTextNode(text)
    }
    return vnode.el
}
const _setAttr = (elem, attrs) => {
    for(key in attrs){
        elem.setAttribute(key,attrs[key])
    }
}
        </script>

按所给的时间格式输出指定的时间
格式说明
对于 2014.09.05 13:14:20
yyyy: 年份，2014
yy: 年份，14
MM: 月份，补满两位，09
M: 月份, 9
dd: 日期，补满两位，05
d: 日期, 5
HH: 24制小时，补满两位，13
H: 24制小时，13
hh: 12制小时，补满两位，01
h: 12制小时，1
mm: 分钟，补满两位，14
m: 分钟，14
ss: 秒，补满两位，20
s: 秒，20
w: 星期，为 [‘日’, ‘一’, ‘二’, ‘三’, ‘四’, ‘五’, ‘六’] 中的某一个，本 demo 结果为 五
示例：
输入：formatDate(new Date(1409894060000), ‘yyyy-MM-dd HH:mm:ss 星期w’)
输出：2014-09-05 13:14:20 星期五

function formatDate(date, format) {
    let addZero = function (data) {
        if (data < 10) {
            return '0' + data
        }
        return data
    }
    let obj = {
        'yyyy': date.getFullYear(),
        'yy': date.getFullYear() % 100,
        'MM': addZero(date.getMonth() + 1),
        'M': date.getMonth() + 1,
        'dd': addZero(date.getDate()),
        'd': date.getDate(),
        'HH': addZero(date.getHours()),
        'H': date.getHours(),
        'hh': addZero(date.getHours() % 12),
        'h': date.getHours() % 12,
        'mm': addZero(date.getMinutes()),
        'm': date.getMinutes(),
        'ss': addZero(date.getSeconds()),
        's': date.getSeconds(),
        'w': function () {
            arr = ['日', '一', '二', '三', '四', '五', '六']
            return arr[date.getDay()]
        }()
    }
    for (let i in obj) {
        format = format.replace(i, obj[i])
    }
    return format
}

倒计时是web开发中常见的组件，请完成second和render两个函数，完成倒计时的显示部分
1、second函数的输入为整数，返回{day: Int, hour: Int, min: Int, second: Int}
2、render函数的输入为second函数的输出，将数据在页面对应的DOM元素上显示出来，格式如html所示
3、如果day为0，隐藏对应的DOM元素，否则显示（请直接使用已经实现的css代码）
4、数值不足两位，前面补充0

<div id="jsCountdown">
    <span>01天</span>
    <span>02:</span>
    <span>03:</span>
    <span>04</span>
</div>

function second(second) {
    let sec = 1
    let mintue = 60 * sec
    let hour = 60 * mintue
    let day = 24 * hour
    let rs = {
        day: parseInt(second / day),
        hour: parseInt(second % day / hour),
        min: parseInt(second % hour / mintue),
        second: second % mintue,
    }
    return rs
}
 
function render(data) {
    function len2(d) {
        d = '00' + d
        return d[d.length-2]+d[d.length-1]
    }
    let ids = document.querySelector('#jsCountdown')
    let html = `
        ${data.day ==0? 'hide': ''}">${len2(data.day)}天
        ${len2(data.hour)}:
        ${len2(data.min)}:
        ${len2(data.second)}
        `
    ids.innerHTML = html
}