Tag:编程题

All the articles with the tag "编程题".

• 请在不使用 setTimeout 的前提下，实现 setInterval

  Posted on:2024年9月19日 |  at 01:40

  可以通过递归调用函数来实现 setInterval，而不使用 setTimeout。 下面是一个简单的实现示例： function mySetInterval(callback, interval) { let start = Date.now(); function loop() { const now = Date.now(); const elapsed = now - start; if

• 实现一个方法，可以对两个数组的维数进行对比

  Posted on:2024年9月10日 |  at 11:30

  “维度”是指数组的嵌套层级。例如，[1, 2] 是一个 1 维数组，而 [[1], [2]] 是一个 2 维数组。 以下是一个示例函数，用于计算数组的维度并对比两个数组的维度： // 计算数组的维度 function getArrayDepth(arr) { if (!Array.isArray(arr)) return 0; return 1 + (arr.length > 0 ? getArr

• 实现一个可以用 for...of 遍历的对象

  Posted on:2024年9月9日 |  at 01:27

  要实现一个可以使用 for...of 遍历的对象，你需要使该对象符合 JavaScript 的迭代协议。这意味着对象必须有一个 [Symbol.iterator] 方法，该方法返回一个迭代器。迭代器需要实现 next 方法，该方法返回一个对象，包含两个属性：value（当前值）和 done（布尔值，表示是否遍历结束）。 下面是一个简单的示例，展示了如何实现一个可以使用 for...of 遍历的对象

• 实现管道函数

  Posted on:2024年9月3日 |  at 13:14

  管道函数（Pipeline Function）是一种函数式编程的概念，用于将多个函数连接起来，将每个函数的输出作为下一个函数的输入。实现管道函数可以简化函数的组合过程，提高代码的可读性和可维护性。 实现管道函数 以下是一个简单的 JavaScript 实现： // 创建管道函数 function pipe(...fns) { return function(initialValue) { retu

• 斐波拉契数列是什么，用 JS 实现，用尾调优化斐波拉契数列

  Posted on:2024年8月23日 |  at 05:26

  斐波那契数列（Fibonacci Sequence）是一种经典的数列，每个数都是前两个数的和。通常的数列从 0 和 1 开始，数列的定义如下： ( F(0) = 0 ) ( F(1) = 1 ) 对于 ( n > 1 )，( F(n) = F(n-1) + F(n-2) ) JavaScript 实现 斐波那契数列可以用递归方法、迭代方法或尾调用优化方法来实现。尾调用优化（Tail Call Op

• 实现数组的flat方法，支持深度层级参数

  Posted on:2024年8月23日 |  at 05:25

  实现 Array.prototype.flat 方法，支持指定深度层级的数组扁平化，可以按照以下步骤进行： 定义函数：创建一个 flat 方法，接受一个可选的深度层级参数。 递归处理：根据深度层级递归地将嵌套的数组元素展开。 处理非数组元素：将非数组元素直接添加到结果中。 实现代码 Array.prototype.myFlat = function(depth = 1) { // 如果深度为 0，

• 手写实现 Object.create

  Posted on:2024年8月23日 |  at 05:23

  Object.create 方法用于创建一个新对象，使用指定的原型对象和可选的属性描述符来初始化新对象。手写实现 Object.create 涉及到设置新对象的原型并定义可选的属性。 以下是 Object.create 的简单手写实现： 实现 function create(proto, propertiesObject) { // 创建一个临时构造函数 function Temp() {} //

• 手写实现一个缓存函数 memoize

  Posted on:2024年8月22日 |  at 11:07

  缓存函数（memoize）是一个优化技术，用于缓存函数的计算结果，以避免重复计算相同的输入。 下面是一个简单的手写 memoize 函数实现： 实现 function memoize(fn) { // 创建一个 Map 对象，用于存储缓存结果 const cache = new Map(); // 返回一个新的函数，这个函数会使用缓存 return function(...args) { // 将

• 如何做 promise 缓存？上一次调用函数的 promise 没有返回， 那么下一次调用函数依然返回上一个 promise

  Posted on:2024年8月15日 |  at 23:17

  为了实现 Promise 缓存，即在函数被调用时，如果之前已经有相同的 Promise 正在执行，则返回之前的 Promise，而不是创建一个新的，可以使用一个缓存机制来存储 Promise 对象。这种做法可以避免对相同请求的重复发起，从而提高性能。 以下是一个简单的示例来实现 Promise 缓存： // 创建一个缓存对象 const promiseCache = new Map(); func

• 请实现一个 add 函数

  Posted on:2024年8月15日 |  at 14:00

  满足以下功能： add(1).getValue(); // 1 add(1)(2).getValue(); // 3 add(1)(2)(3).getValue()； // 6 add(1)(2, 3).getValue(); // 6 add(1, 2)(3).getValue(); // 6 add(1, 2, 3).getValue(); // 6 function add(...args)

• 给定两个数组，写一个方法来计算它们的交集？

  Posted on:2024年8月14日 |  at 23:59

  要计算两个数组的交集，可以使用多种方法。 下面是一个使用 Set 数据结构的高效实现： 使用 Set 数据结构 function intersection(arr1, arr2) { // 将第一个数组转换为 Set const set1 = new Set(arr1); // 使用 filter 方法过滤出存在于 set1 中的元素 return arr2.filter(item => set1

• 实现 (5).add(3).minus(2) 功能

  Posted on:2024年8月14日 |  at 23:55

  可以通过在 Number 原型上定义 add 和 minus 方法来实现该功能，代码如下： Number.prototype.add = function(num) { return this + num; }; Number.prototype.minus = function(num) { return this - num; }; console.log((5).add(3).minus(2

• 如何实现可过期的 localStorage 数据?

  Posted on:2024年8月14日 |  at 20:16

  实现可过期的 localStorage 数据，可以通过在存储数据时附加过期时间，并在读取数据时检查是否过期。 以下是一个简单的实现方法： 1. 存储数据 在存储数据时，可以将数据和过期时间一起存储。在本例中，使用一个对象来保存数据和过期时间的时间戳。 示例代码 function setItemWithExpiry(key, value, ttl) { const now = new Date();

• 手写实现 Promise.allSettled

  Posted on:2024年8月14日 |  at 20:03

  手写实现 Promise.allSettled 方法，涉及创建一个新的 Promise 对象，该对象在所有输入的 Promise 对象都完成（无论成功还是失败）时解决，并返回每个 Promise 对象的状态和结果。 实现步骤 接收输入：接受一个 Promise 对象的可迭代对象（通常是数组）。 初始化：创建一个新的 Promise 对象，用于最终的结果。 处理每个 Promise：遍历输入的 Pr

• 实现：setObjectValue(obj: object, keys: string[], value: any) 方法， 支持安全设置对象的值

  Posted on:2024年8月14日 |  at 19:59

  要实现一个 setObjectValue 方法，能够安全地设置对象的值，并支持通过键路径访问和设置值，可以按照以下步骤进行： 功能说明 obj: 需要修改的对象。 keys: 一个字符串数组，表示键路径，例如 ['a', 'b', 'c'] 代表 obj.a.b.c。 value: 要设置的值。 实现代码 function setObjectValue(obj: object, keys: str

• 虚拟 dom 原理是什么，手写一个简单的虚拟 dom 实现

  Posted on:2024年8月14日 |  at 19:46

  虚拟 DOM（Virtual DOM） 是一种通过用 JavaScript 对象来模拟真实 DOM 的机制。它可以提高网页的性能和响应速度，减少直接对 DOM 的操作，从而优化 UI 渲染。 虚拟 DOM 的原理 创建虚拟 DOM： 使用 JavaScript 对象来表示 DOM 元素。虚拟 DOM 结构类似于真实 DOM，但它是轻量级的，可以在内存中快速操作。 比较差异（Diffing）： 当组

• 实现银行卡号每隔四位加一个空格， 例如：6222023100014763381 -->6222 0231 0001 4763 381

  Posted on:2024年8月14日 |  at 14:14

  1. 使用正则表达式 function formatCardNumber(cardNumber) { // 移除非数字字符（如果有的话） const cleaned = cardNumber.replace(/\D/g, ''); // 使用正则表达式在每四位后插入一个空格 const formatted = cleaned.replace(/(.{4})/g, '$1 ').trim(); re

• 实现一个双向链表， 具备添加节点、删除节点、在特定位置插入节点、查找节点、遍历等功能

  Posted on:2024年8月14日 |  at 14:03

  要实现一个双向链表（Doubly Linked List），需要定义一个节点类和一个链表类。 双向链表中的每个节点都有两个指针，一个指向下一个节点（next），一个指向上一个节点（prev）。 链表类则包含了各种操作链表的方法，如添加节点、删除节点、在特定位置插入节点、查找节点和遍历链表。 以下是一个实现双向链表的示例： 1. 节点类（Node Class） class Node { constr

• 请手写“基数排序”

  Posted on:2024年8月10日 |  at 21:17

  算法简介 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。 算法描述 具体算法描述如下： 取得数组中的最大数，并取得位数； arr为原始数组，从最低位开始取每个位组成radix数组；

• 请手写“计数排序”

  Posted on:2024年7月22日 |  at 11:43

  算法简介 计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。 算法描述 具体算法描述如下： 找出待排序的数组中最大和最小的元素； 统计数组中每个值为i的元素出现的次数，存入数组C的第i项； 对所有的计数累加（从C中的第一个元素开始，每一项和前

• 请手写“桶排序”

  Posted on:2024年7月22日 |  at 11:43

  算法简介 桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排 算法描述 具体算法描述如下： 设置一个定量的数组当作空桶； 遍历输入数据，并且把数据一个一个放到对应的桶里去； 对每个不是空的桶进行排序； 从不是空的桶里把排好序的数据拼接起来。 代码实现 /*方法说明：桶排序

• 改造下面的代码，让它输出1，2，3，4，5

  Posted on:2024年7月22日 |  at 10:55

  for(var i = 1; i <= 5; i ++){ setTimeout(function timer(){ console.log(i) }, 0) } 解决方法： 利用IIFE(立即执行函数表达式)当每次for循环时，把此时的i变量传递到定时器中 for(var i = 1;i <= 5;i++){ (function(j){ setTimeout(function timer(){

• 使用Promise实现红绿灯交替重复亮

  Posted on:2024年3月18日 |  at 20:33

  红灯3秒亮一次，绿灯2秒亮一次，黄灯1秒亮一次；如何让三个灯不断交替重复亮灯？ 要求：用Promise实现 三个亮灯函数已经存在： function red() { console.log('red'); } function green() { console.log('green'); } function yellow() { console.log('yellow'); } functio

• 利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3

  Posted on:2024年3月12日 |  at 21:45

  下面是实现示例： function compressString(str) { let compressed = ''; let count = 1; for (let i = 0; i < str.length; i++) { if (str[i] === str[i + 1]) { // 如果当前字符与下一个字符相同，增加计数器 count++; } else { // 否则，将当前字符及其计

• 如何实现一个轮播图组件？

  Posted on:2023年12月19日 |  at 11:13

  可以按照以下步骤来进行： HTML 结构：首先，在 HTML 中创建一个容器元素，用于包裹轮播图的内容。在容器内部，使用 <ul> 元素创建一个无序列表，并为每个轮播项（图片或其他内容）创建一个 <li> 元素。 <div class="carousel-container"> <ul class="carousel-list"> <li><img src="slide1.jpg" alt="Sl

• 将下面的数组转成树状结构

  Posted on:2023年12月17日 |  at 18:38

  根据 id 和 parent_id 的对应关系，进行下面的转换。 原始数据： [ { "id": 12, "parent_id": 1, "name": "朝阳区" }, { "id": 241, "parent_id": 24, "name": "田林街道" }, { "id": 31, "parent_id": 3, "name": "广州市" }, { "id": 13, "parent_i

• 编写一个vue组件，组件内部使用插槽接收外部内容，v-model双向绑定，实现折叠展开的功能

  Posted on:2023年12月17日 |  at 18:31

  下面是示例代码： <template> <div> <button @click="toggleCollapse"> {{ collapsed ? '展开' : '折叠' }} </button> <div v-show="!collapsed"> <slot></slot> </div> </div> </template> <script> export default { model: {

• 实现lodash的set和get方法

  Posted on:2023年10月30日 |  at 10:38

  set 方法可以根据提供的路径（以点分隔）设置对象的值，如果路径上的嵌套对象不存在，则会递归创建。 get 方法会根据提供的路径获取对象中的值，如果路径上的某个键不存在或对象中断，返回 undefined。 下面是提供的参考： function set(object, path, value) { const keys = path.split('.'); let current = objec

• 实现一个批量请求函数，要求能够限制并发量

  Posted on:2023年9月24日 |  at 18:36

  这道题比较有意思，其实就是要实现一个限制最大并发的 Promise.all()。 实现思路也比较简单，就是在每个请求结束后，看队列中是否有未完成的请求，如果有，就按顺序进行下一个请求。 function multiRequest(urls = [], maxNum) { // 请求总数量 const sum = urls.length; // 根据请求数量创建一个数组来保存请求的结果 const

• 树转数组

  Posted on:2023年8月20日 |  at 21:21

  将以下结构的数据转成数组。 const listTree = [ { id: 1, name: '部门1', pid: 0, children: [ { id: 2, name: '部门1-1', pid: 1, children: [ { id: 4, name: '部门1-1-1', pid: 2, children: [] } ] }, { id: 3, name: '部门1-2', pid

• 数组转树

  Posted on:2023年8月20日 |  at 21:21

  将下列数组进行转换： const list = [ {id: 1, name: '部门1', pid: 0}, {id: 2, name: '部门1-1', pid: 1}, {id: 3, name: '部门1-2', pid: 1}, {id: 4, name: '部门1-1-1', pid: 2}, {id: 5, name: '部门1-2-1', pid: 3}, {id: 6, name

• 删除链表的一个节点

  Posted on:2023年7月8日 |  at 15:59

  可以通过以下步骤实现： 遍历链表，找到待删除节点的前一个节点。 将待删除节点的前一个节点的 next 指针指向待删除节点的下一个节点。 将待删除节点置为 null。 下面是示例代码，假设链表的每个节点都有 val 和 next 两个属性： function deleteNode(head, val) { // 如果要删除的节点是头节点，则直接返回 head.next if (head.val ==

• 请实现一个函数，要求能在页面请求很多时，尽可能快地按照顺序输出返回的结果。

  Posted on:2023年7月8日 |  at 15:58

  const promiseList = [ new Promise((resolve) => { setTimeout(resolve, 1000) }), new Promise((resolve) => { setTimeout(resolve, 2000) }), new Promise((resolve) => { setTimeout(resolve, 3000) }), new Pro

• 实现一个请求函数：fetchWithRetry，要求会最多自动重试 3 次，任意一次成功就直接返回

  Posted on:2023年7月8日 |  at 15:54

  下面是一个简单的示例实现，并未包含对异常情况的处理、超时设置等较复杂的功能： function fetchWithRetry(url, options, maxRetry = 3) { return new Promise((resolve, reject) => { const doFetch = async (attempt) => { try { const response = await

• 链表中，环的入口节点

  Posted on:2023年7月8日 |  at 15:51

  给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 不

• 多叉树指定层节点的个数

  Posted on:2023年7月8日 |  at 15:41

  可以使用递归的方式遍历树，并计算每层节点的数量 function getNodeCountAtLevel(tree, level) { // 递归终止条件：当当前节点为null时，返回0 if (!tree) { return 0; } // 当层数为0时，表示找到目标层级，返回1 if (level === 0) { return 1; } let count = 0; // 遍历当前节点的所有

• 使用 js 实现有序数组原地去重

  Posted on:2023年6月26日 |  at 08:53

  原地去重有序数组，也就是在不创建新数组的情况下修改原始数组。 可以使用双指针的方法，以下是一个示例的实现： function removeDuplicates(nums) { if (nums.length === 0) { return 0; } let slow = 0; for (let fast = 1; fast < nums.length; fast++) { if (nums[fa

• 计算出下面数组中的平均时间

  Posted on:2023年6月6日 |  at 09:22

  const arr = ["8:15", "6:35", "11:22"] 将时间转换为分钟数，计算平均值后再将结果转换回小时和分钟即可。具体步骤如下： 遍历数组中的每个时间，将其转换为分钟数并求和。 将总分钟数除以时间数量得到平均值，取整数部分作为小时数，余数部分作为分钟数。 如果分钟数小于 10，则在前面添加一个零以保持两位数格式。 将小时数和分钟数组合成字符串形式的时间表示。 const a

• 实现 compose 函数, 类似于 koa 的中间件洋葱模型

  Posted on:2023年6月4日 |  at 11:54

  // 题目需求 let middleware = [] middleware.push((next) => { console.log(1) next() console.log(1.1) }) middleware.push((next) => { console.log(2) next() console.log(2.1) }) middleware.push((next) => { cons

• 请按以下要求实现方法 fn ：遇到退格字符就删除前面的字符，遇到两个退格就删除两个字符

  Posted on:2023年6月1日 |  at 09:27

  // 比较含有退格的字符串，"<-"代表退格键，"<"和"-"均为正常字符 // 输入："a<-b<-", "c<-d<-"，结果：true，解释：都为"" // 输入："<-<-ab<-", "<-<-<-<-a"，结果：true，解释：都为"a" // 输入："<-<ab<-c", "<<-<a<-<-c"，结果：false，解释："<ac" !== "c" function fn(str1,

• 实现一个函数, 可以间隔输出

  Posted on:2023年5月31日 |  at 19:55

  function createRepeat(fn, repeat, interval) {} const fn = createRepeat(console.log, 3, 4); fn('helloWorld'); // 每4秒输出一次helloWorld, 输出3次 可以使用 JavaScript 中的定时器函数 setInterval 来实现，具体如下： function createRep

• 不定长二维数组的全排列

  Posted on:2023年5月23日 |  at 09:29

  给定任意二维数组，输出所有的排列组合项。 比如 [['A','B'], ['a','b'], [1, 2]]，输出 ['Aa1','Aa2','Ab1','Ab2','Ba1','Ba2','Bb1','Bb2'] 可以采用动态规划的方式，下一次的结果，依赖上一次的结果，比如第一次的结果是 ['A', 'B'],下一个增加了 ['a', 'b'] 就可以在上一次的基础上变为 ['Aa', 'Ab'

• 两个字符串对比, 得出结论都做了什么操作, 比如插入或者删除

  Posted on:2023年5月23日 |  at 09:20

  pre = 'abcde123' now = '1abc123' a前面插入了1, c后面删除了de 思路：编辑距离 动态规划求编辑距离 倒着将变化输出。dp[i] === dp[i - 1] + 1 function compareStrings(pre, now) { const m = pre.length; const n = now.length; const dp = new Arra

• 实现一个方法，从某个数值数组中，获取最小正数（非零非负数）的索引值

  Posted on:2023年4月28日 |  at 10:32

  function findNonZeroMinIndex(arr) { let min = Infinity; let index = -1; for (let i = 0; i < arr.length; i++) { if (arr[i] > 0 && arr[i] < min) { min = arr[i]; index = i; } } return index; } 使用循环和条件判断来

• 实现一个等待函数，支持让 async 函数在执行时暂停一段时间，函数的入参为暂停的时间

  Posted on:2023年4月23日 |  at 20:18

  在使用 async/await 时，可以用 await 关键字等待一个 Promise 对象的结果，然后执行一些操作。在等待过程中，函数会暂停执行，直到 Promise 对象的状态发生改变。 下面是一个示例代码，其中定义了一个名为 wait 的等待函数，它可以让 async 函数在执行时暂停一段时间： function wait(ms) { return new Promise(resolve =

• 使用正则表达式实现以下需求：筛选出数组中只包含大小写字母的字符串，并将结果转换成大写

  Posted on:2023年4月23日 |  at 20:15

  可以先使用正则表达式 /^[a-zA-Z]+$/ 来匹配只包含大小写字母的字符串，使用 Array.prototype.filter() 方法来筛选符合条件的元素，然后使用 Array.prototype.map() 方法将每个元素转换成大写，最终得到了一个新的数组 filteredArr。 参考代码如下： const arr = ['Abc', 'DeF', '123', '_ghI']; co

• 实现一个将多维数组展示的方法

  Posted on:2023年3月12日 |  at 22:57

  方法一：ES6新增的数组扩展方法flat() let arr = [1,2,3,[4,5],6]; let res = arr.flat();//[1,2,3,4,5,6] 可能会有小伙伴说flat()默认只能拉伸一层，如果需要处理的是多层嵌套数组呢？ let arr1 = [1,2,3,[4,5,[6,7]],8]; let res1 = arr.flat(3); //参数3代表三维数组的展开，

• 根据运算优先级添加括号

  Posted on:2023年3月4日 |  at 22:54

  现已知一个字符串是由正整数和加减乘除四个运算符(+ - * /)组成。 例如存在字符串 const str = '11+2-3*4+5/2*4+10/5'，现在需要将高优先级运算，用小括号包裹起来，例如结果为 '11+2-(3*4)+(5/2*4)+(10/5)'。注意可能会出现连续的乘除运算，需要包裹到一起。 请用 javascript 实现这一过程 介绍一种只需遍历一次的实现方式，思路比较简单

• 用es5如何实现 let 和 const ？

  Posted on:2022年7月5日 |  at 09:39

  实现 let let 大家应该用的非常熟悉了，定义一个仅作用于该代码块的变量。如果去 babel 上面在线转换一下，大家可以看到结果是 var。在 es6 出现以前我们一般使用无限接近闭包的形式或者立即执行函数的形式来定义不会被污染的变量。 我们这也可以做类似的操作。 (function(){ var a = 1; console.log(a) })(); console.log(a) 效果不错，

• 手写一个 jsonp

  Posted on:2022年5月22日 |  at 19:55

  JSONP 核心原理：script 标签不受同源策略约束，所以可以用来进行跨域请求，优点是兼容性好，但是只能用于 GET 请求； const jsonp = ({ url, params, callbackName }) => { const generateUrl = () => { let dataSrc = '' for (let key in params) { if (params.ha

• 实现一个类，其实例可以链式调用，它有一个 sleep 方法，可以 sleep 一段时间后再后续调用

  Posted on:2022年5月16日 |  at 12:31

  const boy = new PlayBoy('Tom') boy.sayHi().sleep(1000).play('王者').sleep(2000).play('跳一跳') // 输出 // 大家好我是Tom // 1s 之后 // 我在玩王者 // 2s 之后 // 我在玩跳一跳 实现思想：创建一个任务队列，在每个方法中都往任务队列里追加一个函数，利用队列的先进先出的思想来控制函数的执行顺

• 实现 Promise.race 函数

  Posted on:2022年5月10日 |  at 22:33

  Promise.race 函数返回一个 Promise，它将与参数中第一个完成的promise状态相同。它可以是完成（ resolves），也可以是失败（rejects），这要取决于第一个完成的方式是两个中的哪个。 如果传的迭代是空的，则返回的 promise 将永远等待。 如果迭代包含一个或多个非承诺值和/或已解决/拒绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。 Pro

• 实现lodash中的get方法

  Posted on:2022年4月10日 |  at 16:08

  使用 lodash 中的 get 函数可避免长链的 key 时获取不到属性而出现问题，此时进行异常避免时及其服务，如 o.a && o.a.b && o.a.b.c && o.a.b.c.d 实现类似 lodash.get ，有以下测试用例: var object = { 'a': [{ 'b': { 'c': 3 } }] }; get(object, 'a[0].b.c'); // => 3

• 实现斐波那契数列

  Posted on:2022年4月10日 |  at 09:34

  斐波那契数，指的是这样一个数列：1、1、2、3、5、8、13、21、…… 在数学上，斐波那契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=Fn-1+Fn-2（n>=2，n∈N*），用文字来说，就是斐波那契数列由 0 和 1 开始，之后的斐波那契数列系数就由之前的两数相加。 常用的计算斐波那契数列的方法分为两大类：递归和循环。 递归 方法一：普通递归 代码优美逻辑清晰。但是有重复计算的问题

• 请按以下要求实现 compose 方法

  Posted on:2022年4月5日 |  at 18:14

  var list = [['热', '冷', '冰'], ['大', '中', '小'], ['重辣', '微辣'], ['重麻', '微麻']]; // 输出所有维度的组合，如 [['热', '冷''], ['大', '中']] => 热+大，热+中，冷+大，冷+中 function compose(list) { console.log('hello world'); } compose(li

• a == 1 && a == 2 && a == 3 可能为 true 吗？

  Posted on:2021年12月26日 |  at 16:06

  第一种方案 把 a 定义为一个对象，通过重写toString方法。根据规则，== 左边为对象类型，右边为Number，在比较时会调用 a 的toString方法，所以每次调用时都将返回值加1。 const a = { value: 1, toString: function () { return a.value++ } } console.log(a == 1 && a == 2 && a ==

• 如何查找一篇英文文章中出现频率最高的单词？

  Posted on:2021年11月17日 |  at 22:51

  function findMostWord(article) { // 合法性判断 if (!article) return; // 参数处理 article = article.trim().toLowerCase(); let wordList = article.match(/[a-z]+/g), visited = [], maxNum = 0, maxWord = ""; article

• 封装一个 javascript 的类型判断函数

  Posted on:2021年11月17日 |  at 22:50

  function getType(value) { // 判断数据是 null 的情况 if (value === null) { return value + ""; } // 判断数据是引用类型的情况 if (typeof value === "object") { let valueClass = Object.prototype.toString.call(value), type = v

• 如何判断一个对象是否为空对象？

  Posted on:2021年11月17日 |  at 22:48

  function checkNullObj(obj) { return Object.keys(obj).length === 0; }

• 实现一个对象的 flatten 方法

  Posted on:2021年11月17日 |  at 19:52

  实现以下转换： const obj = { a: { b: 1, c: 2, d: { e: 5 } }, b: [1, 3, {a: 2, b: 3}], c: 3 } flatten(obj){} 结果返回如下 // { // 'a.b': 1, // 'a.c': 2, // 'a.d.e': 5, // 'b[0]': 1, // 'b[1]': 3, // 'b[2].a': 2, //

• 实现 Promise.all

  Posted on:2021年8月13日 |  at 10:14

  // 简易版 Promise.myAll = function(promiseArr) { return new Promise((resolve, reject) => { const ans = []; let index = 0; for (let i = 0; i < promiseArr.length; i++) { promiseArr[i] .then(res => { ans[i]

• 解析url

  Posted on:2021年7月25日 |  at 10:32

  /** 解析一个url，并生成window.location对象包含的域 location: { href: '包含完整的url', origin: '包含协议到pathname之前的内容', protocol: 'url使用的协议，包含末尾的:', username: '用户名', // 暂时不支持 password: '密码', // 暂时不支持 host: '完整主机名，包含:和端口', h

• 反转链表

  Posted on:2021年7月25日 |  at 10:32

  给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] 提示： 链表中节点的数目范围是 [0, 5000] -5000 <= Node.val <= 5000 /** * Definitio

• 回文链表

  Posted on:2021年7月25日 |  at 10:31

  请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 方案一 利用链表的后续遍历，使用函数调用栈作为后序遍历栈，来判断是否回文 var isPalindrome = function(head) { let left = head; function traverse(right) { if (right ==

• 实现数字的千分位逗号分割

  Posted on:2021年7月25日 |  at 10:31

  方案一：数组循环 function thousands(num) { var result = [], counter = 0; num = (num || 0).toString().split(''); for (var i = num.length - 1; i >= 0; i--) { counter++; result.unshift(num[i]); if (!(counter % 3

• 大数相加

  Posted on:2021年7月25日 |  at 10:31

  手写一个add方法，实现两个大数相加 方案一 思路：判断两个字符串长度，通过补0的方式，让他们长度相同，由于我们在学生时代，这种加减法都是从右往左，所以，我们对数组进行反转，这样就可以让计算机按照我们的想法去实现，做的过程中，一定要考虑满10进1的情况，全部算完后，再反转回来，通过join合并成字符串进行返回。 // a 和 b 都为字符串，调用add后，返回一个相加的字符串 // a = '12

• 实现柯里化

  Posted on:2021年7月11日 |  at 16:10

  柯里化是什么：是指这样一个函数，它接收函数 A，并且能返回一个新的函数，这个新的函数能够处理函数 A 的剩余参数 function createCurry(func, args) { var argity = func.length; var args = args || []; return function () { var _args = [].slice.apply(arguments);

• 实现一个方法，清除字符串前后的空格。

  Posted on:2021年7月7日 |  at 00:14

  function trim(str) { if (str & typeof str === "string") { return str.replace(/(^s*)|(s*)$/g,""); //去除前后空白符 } }

• 实现有并行限制的Promise调度器

  Posted on:2021年7月7日 |  at 00:13

  class Scheduler { constructor() { this.queue = []; this.maxCount = 2; this.runCounts = 0; } add(promiseCreator) { this.queue.push(promiseCreator); } taskStart() { for (let i = 0; i < this.maxCount; i+

• 字符串解析问题

  Posted on:2021年7月7日 |  at 00:13

  实现函数使得将str字符串中的{}内的变量替换，如果属性不存在保持原样（比如{a.d}） var a = { b: 123, c: '456', e: '789', } var str=`a{a.b}aa{a.c}aa {a.d}aaaa`; // => 'a123aa456aa {a.d}aaaa' const fn1 = (str, obj) => { let res = ''; // 标志位

• 实现 event模块

  Posted on:2021年7月7日 |  at 00:13

  实现node中回调函数的机制，node中回调函数其实是内部使用了观察者模式。 观察者模式：定义了对象间一种一对多的依赖关系，当目标对象Subject发生改变时，所有依赖它的对象Observer都会得到通知。 function EventEmitter() { this.events = new Map(); } // 需要实现的一些方法： // addListener、removeListener

• 实现AJAX

  Posted on:2021年7月7日 |  at 00:13

  const getJSON = function(url) { return new Promise((resolve, reject) => { const xhr = XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Mscrosoft.XMLHttp'); xhr.open('GET', url, false); xhr.s

• 实现JSONP

  Posted on:2021年7月7日 |  at 00:13

  const jsonp = ({ url, params, callbackName }) => { const generateUrl = () => { let dataSrc = ''; for (let key in params) { if (Object.prototype.hasOwnProperty.call(params, key)) { dataSrc += `${key}=$

• 实现 Promise

  Posted on:2021年7月7日 |  at 00:13

  // 模拟实现Promise // Promise利用三大手段解决回调地狱： // 1. 回调函数延迟绑定 // 2. 返回值穿透 // 3. 错误冒泡 // 定义三种状态 const PENDING = 'PENDING'; // 进行中 const FULFILLED = 'FULFILLED'; // 已成功 const REJECTED = 'REJECTED'; // 已失败 class

• 实现深拷贝

  Posted on:2021年7月7日 |  at 00:13

  const cloneDeep1 = (target, hash = new WeakMap()) => { // 对于传入参数处理 if (typeof target !== 'object' || target === null) { return target; } // 哈希表中存在直接返回 if (hash.has(target)) return hash.get(target); co

• 实现Object.assign

  Posted on:2021年7月7日 |  at 00:13

  Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象（请注意这个操作是浅拷贝） Object.defineProperty(Object, 'assign', { value: function(target, ...args) { if (target == null) { return new TypeError('Cannot conv

• 实现 instanceof

  Posted on:2021年7月7日 |  at 00:13

  instanceof运算符用于检测构造函数的prototype属性是否出现在某个实例对象的原型链上。 const myInstanceof = (left, right) => { // 基本数据类型都返回false if (typeof left !== 'object' || left === null) return false; let proto = Object.getPrototyp

• 函数珂里化

  Posted on:2021年7月7日 |  at 00:13

  实现方法add： add(1)(2)(3)(4)=10; add(1)(1,2,3)(2)=9; function add() { const _args = [...arguments]; function fn() { _args.push(...arguments); return fn; } fn.toString = function() { return _args.reduce((s

• 实现 throttle（节流）函数

  Posted on:2021年7月7日 |  at 00:13

  高频时间触发,但n秒内只会执行一次,所以节流会稀释函数的执行频率。 const throttle = (fn, time) => { let flag = true; return function() { if (!flag) return; flag = false; setTimeout(() => { fn.apply(this, arguments); flag = true; }, t

• 实现 debounce（防抖）函数

  Posted on:2021年7月7日 |  at 00:13

  触发高频时间后n秒内函数只会执行一次,如果n秒内高频时间再次触发,则重新计算时间。 const debounce = (fn, time) => { let timeout = null; return function() { clearTimeout(timeout) timeout = setTimeout(() => { fn.apply(this, arguments); }, time

• 实现 Function.prototype.bind

  Posted on:2021年7月7日 |  at 00:13

  Function.prototype.bind = function(context, ...args) { if (typeof this !== 'function') { throw new Error("Type Error"); } // 保存this的值 var self = this; return function F() { // 考虑new的情况 if(this instanc

• 实现 Function.prototype.call

  Posted on:2021年7月7日 |  at 00:13

  Function.prototype.call = function(context = window, ...args) { if (typeof this !== 'function') { throw new TypeError('Type Error'); } const fn = Symbol('fn'); context[fn] = this; const res = context[

• 实现 Function.prototype.apply()

  Posted on:2021年7月7日 |  at 00:12

  第一个参数是绑定的this，默认为window，第二个参数是数组或类数组 Function.prototype.apply = function(context = window, args) { if (typeof this !== 'function') { throw new TypeError('Type Error'); } const fn = Symbol('fn'); conte

• 实现 Array.prototype.reduce()

  Posted on:2021年7月7日 |  at 00:12

  Array.prototype.reduce = function(callback, initialValue) { if (this == undefined) { throw new TypeError('this is null or not defined'); } if (typeof callback !== 'function') { throw new TypeError(cal

• 实现 Array.prototype.forEach()

  Posted on:2021年7月7日 |  at 00:12

  Array.prototype.forEach = function(callback, thisArg) { if (this == null) { throw new TypeError('this is null or not defined'); } if (typeof callback !== "function") { throw new TypeError(callback + '

• 实现 Array.prototype.map()

  Posted on:2021年7月7日 |  at 00:12

  Array.prototype.map = function(callback, thisArg) { if (this == undefined) { throw new TypeError('this is null or not defined'); } if (typeof callback !== 'function') { throw new TypeError(callback +

• 类数组转化为数组

  Posted on:2021年7月7日 |  at 00:12

  类数组是具有length属性，但不具有数组原型上的方法。常见的类数组有arguments、DOM操作方法返回的结果。 方法一：Array.from Array.from(document.querySelectorAll('div')) 方法二：Array.prototype.slice.call() Array.prototype.slice.call(document.querySelecto

• 数组去重

  Posted on:2021年7月7日 |  at 00:12

  const arr = [1, 1, '1', 17, true, true, false, false, 'true', 'a', {}, {}]; // => [1, '1', 17, true, false, 'true', 'a', {}, {}] 方法一：利用Set const res1 = Array.from(new Set(arr)); 方法二：两层for循环+splice con