xinbaiyu的博客

【代码】vue3个人网站电子宠物。

首先建立两个数组board、tetris用来存储当前已经堆积在棋盘的方块与正在下落的方块。这两个是一维数组当需要在页面画棋盘时就对其每一项转成二进制（看计算属性tetrisBoard），其中1（红色）0（白色）。判断是否可以下落：对board、tetris每一项 &（与操作），如果都为0则还可以下落，否则停止下落。判断是否触底：tetris的最后一项是否为0如果不为0则说明已经触底了： ：对board、tetris每一项 &（与操作），如果都为0则还可以移动，否则停止移动。

有人可能会使用时间戳作为这个query，但是在v-for这个场景下是不实用的，因为v-for循环出来的是同一个时间戳（我已经试验过了），所以才采用的Math.random()

treeData的数据结构大概如下。

【代码】cytoscapejs获取被点击节点位置，并在该节点附近进行双击展示弹窗。

【代码】前端代码雨。

nodejs删除某个文件夹

情形let arr = new Array(11).fill([1,2])arr[0][0]=100解决方法1new Array(11).fill().map(()=>{return [1,2]})let arr = new Array(11).fill().map(()=>{return [1,2]})arr[0][0]=100解决方法2Array.apply(null, { length: 11 }).map(() => ([1, 2]))let arr

// 判断是否里边还有没拍扁的数组 function haveArr(arr) { return arr.some(item => { return item instanceof Array }) } function flatern(arr) { let resArr = [].concat(...arr) if (haveArr(resArr)) { return flatern(resArr) }.

Object.create(obj1)就是将obj2创建为一个空对象并将他的隐式原型对象指向obj1 let obj1 = { a: 10, b: 20 } let obj2 = Object.create(obj1)特例let obj2 = Object.create(null）这时obj2没有原型对象

[10, 20, 30].map(parseInt)等同于下边的代码 [10, 20, 30].map((item,index)=>{ return parseInt(item,index) })

function isEqual(obj1, obj2) { // 先判断这俩是不是对象或者数组类型的 if (typeof (obj1) !== "object" && obj1 !== null && typeof (obj2) !== "object" && obj2 !== null) { return obj1 === obj2 } // 如果特意传的就是两个指向同一地址的对象 i.

问题简述当我们使用下面代码时会产生一个长度为10的数组new Array(10).fill([false, false])但是由于fill的是一个引用数据类型，会导致填充的所有[false，false]其实指向的都是同一个数组，所以只要改变其中一个剩余九个都会一起跟着改变。下边举个例子解决方法var arr = Array.apply(null, {length: 10}).map(() => ([false, false]))或者var arr = new Array(10)

为什么DOM要进行性能优化呢？因为操作DOM消耗的内存资源是非常昂贵的，所以要尽量避免重复操作DOM元素怎么进行优化1. 将频繁的DOM操作改为一次性操作比如往id为list的容器中插入10个li，按照以前的做法就是通过for循环进行十次list.appendchild(li)，这样就是在频繁操作DOM下边我们先建个虚拟的容器frag，这个frag并不是DOM树里的节点所以你在appendchild时候也就不会触发DOM的渲染，等你10个li都加入到frag这个虚拟容器之后，再一次性加到list

手写bind Function.prototype.bind1 = function () { var arr = [...arguments] var _this = arr.shift() let fn = this return function () { return fn.apply(_this, arr) } }手写call Function.prototype.myCall = function (c

var permute = function(nums) { var res = [] function backtrack(path){ if(path.length==nums.length){ res.push(path) return } nums.forEach(n=>{ if(path.includes(n)){return} ba

冒泡排序function bubbleSort(arr) { var len = arr.length; for (var i = 0; i < len - 1; i++) { for (var j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { // 相邻元素两两对比 var temp = arr[j+1]; /

function binarySearch(arr, item) { let low = 0 let high = arr.length - 1 while (low <= high) { const mid = Math.floor((high + low) / 2); const element = arr[mid] if (element < item) { low = mid .

/** * @param {number[][]} heights * @return {number[][]} */var pacificAtlantic = function(heights) { if(!heights||!heights[0]){return []} // 这道题让咱从高点往低点流 咱们可以逆向思维让大西洋和太平洋的水逆向流动到高点 var r = heights.length var c = heights[0].length //

图的深度优先遍历做/** * // Definition for a Node. * function Node(val, neighbors) { * this.val = val === undefined ? 0 : val; * this.neighbors = neighbors === undefined ? [] : neighbors; * }; *//** * @param {Node} node * @return {Node} */var clon

var json = { a: { b: { c: 1 } }, d: [25, 26] } function dfs(root, path) { console.log(root, path); Object.keys(root).forEach(k => { dfs(root[k], path.concat(k)) }) } dfs(json, [])

原理A instanceof Binstanceof用于检测对象A是不是对象B的实例，而检测是基于原型链进行查找的，也就是说对象B的prototype有没有在对象A的__proto__原型链上，如果有就返回true,否则返回false代码实现function instanceOf(A, B) { while (A) { A = A.__proto__ if (A === B.prototype) { return true

主要就是利用栈的后进先出的特性，将靠后的数据先弹出并存入到暂时的数组中存起来 var arr = [1, 2, 3, 4, 5, 6] var temp = [] var length = arr.length for (let i = 0; i < length; i++) { temp.push(arr.pop()) } arr = temp console.log(arr);...

因为运行js代码是内存分为栈（调用栈）和堆。所以垃圾回收也分为栈垃圾回收和堆垃圾回收栈垃圾回收看这段代码function foo(){ var a = 1 var b = {name:"极客邦"} function showName(){ var c = 2 var d = {name:"极客时间"} } showName()}foo()在执行showName函数时调用栈和堆空间如下所示此同时，还有一个记录当前执行状态的指针（

先来看段代码function bar() { console.log(myName)}function foo() { var myName = "极客邦" bar()}var myName = "极客时间"foo()这个代码的输出结果是：极客时间这个里边在foo函数作用域中声明了一次myName，在全局作用域也声明了一次myName，这个就是迷惑点。想要知道为什么就要理解作用域链什么是作用域链？这张图其实画的并不全面。其实在每个执行上下文的变量环境中，都包含

let myname= '极客时间'{ console.log(myname) let myname= '极客邦'}上面代码的执行结果是什么？为什么会报错？【分析原因】：在块作用域内，let声明的变量被提升，但变量只是创建被提升，初始化并没有被提升(初始化就是给变量先赋值成undefined)，在初始化之前使用变量，就会形成一个暂时性死区。【拓展】var的创建和初始化被提升，赋值不会被提升。let的创建被提升，初始化和赋值不会被提升。function的创建、初始化和赋值均会.

先来看一段代码showName()console.log(myname)var myname = '极客时间'function showName() { console.log('函数showName被执行');}思考一下它的输出为什么myname在声明之前就可以输出到控制台=>这就是因为变量提升上面的代码等价于下边的代码/** 变量提升部分*/// 把变量 myname提升到开头，// 同时给myname赋值为undefinedvar myname = un

function fullpermutate(str) { var result = []; if (str.length > 1) { //遍历每一项 for (var m = 0; m < str.length; m++) { //拿到当前的元素 var left = str[m]; //除当前元素的其他元素组合 var rest = str.slice(0, m) + str.slice(m + 1, str.length);

var a = 10 function k() { return a + 10 } function k1() { var a = 20 console.log(k()) } set k1()问：结果输出啥正确答案：20解析：函数内部找不到a这个变量，它就会去父级作用域中去找，而k函数的父级作用域是全局作用域所以...

深拷贝与浅拷贝什么是浅拷贝浅拷贝只拷贝一层，更深层次对象级别的只会拷贝引用（地址）第一种浅拷贝方法（slice）var arr1=[1,2]var arr2=arr1.slice();arr1[0]=100console.log(arr1);//[100,2]console.log(arr2);//[1,2]第二种浅拷贝方法（concat）var arr1=[1,2]var arr2=arr1.concat();arr1[0]=100console.log(arr1)

/** * Definition for singly-linked list. * function ListNode(val, next) { * this.val = (val===undefined ? 0 : val) * this.next = (next===undefined ? null : next) * } *//** * @param {ListNode} head * @return {ListNode} */var sortList = fu

/** * @param {number} k */var MyCircularQueue = function(k) { this.list = new Array(k) this.maxLength = k this.tou = 0 this.wei = 0};/** * @param {number} value * @return {boolean} */MyCircularQueue.prototype.enQueue = function(.

/** * @param {string[]} ops * @return {number} */var calPoints = function(ops) { let resultArr = []; ops.forEach(item=>{ switch(item){ case 'C': if(resultArr.length>0){ resultArr.pop

/** * @param {number[]} nums * @return {number} */var firstMissingPositive = function(nums) { // 过滤掉所有的0和负数 let arr= nums.filter(item=>item>0) // 升序排列 arr.sort((a,b)=>a-b) console.log(arr) if(arr[0]!=1){ return

/** * @param {number[]} nums * @param {number} k * @return {number} */var findKthLargest = function(nums, k) { for(let i =0;i<nums.length-1;i++){ let max = i for(let j =i+1;j<nums.length;j++){ if(nums[max]<nums

第一种/** * @param {number[]} nums * @return {number[]} */var sortArrayByParityII = function(nums) { // 先对数组进行排序 for(let i =0;i<nums.length-1;i++){ var min =i for(let j =i+1;j<nums.length;j++){ if(nums[min]>nu

冒泡排序/** * @param {number[]} nums * @return {number[]} */var sortArray = function(nums) { let temp = 0 for(let i = 0;i<nums.length-1;i++){ for(let j = 0;j<nums.length-i-1;j++){ if(nums[j]>nums[j+1]){

/** * @param {string} s * @return {boolean} */var repeatedSubstringPattern = function(s) { let str = /^(\w+)\1+$/ return str.test(s)};这里的\w代表的是任意的字母，数字或下划线+代表重复1次以上\1代表重复第一个（）匹配的字符（注意一定是已经匹配成功的字符）最后的+代表重复重复第一个（）匹配的字符一次或者多次例如（\w+）匹配成功了‘he

第一种方法/** * @param {number[]} flowerbed * @param {number} n * @return {boolean} */var canPlaceFlowers = function(flowerbed, n) { let num = 0 // 如果数组只有一个则这么判断 if(flowerbed.length==1){ if(flowerbed[0]==0){ num= 1