标签：web安全 - 76433|LUHANXIN|JUWENZHANG

luhanxin-community

前端设计

音乐足迹后台瞬间总结首页

已删除用户

该用户已被删除。

累计撰写 25 篇文章
累计创建 15 个分类
累计收到 5 条评论

导航
- project
  - luhanxin-community
    - 前端设计
- 计划
  - ai
- 音乐
- 足迹
- 后台
- 瞬间
- 总结
- 首页

76433

XIAOLUER|76433|LUHANXIN|JUWENZHANG

标签
web安全

web安全以及防护

2026-02-08 10:53
8
0
0
24.8℃

web安全

https://www.bilibili.com/video/BV1AQ4y1E729/?spm_id_from=333.337.search-card.all.click&vd_source=bb20

标签

track express mini web安全 typescript rust react原理 tencent bundle javascript nodejs hybird 知识海洋 http monitor

luhanxin

最新文章

Javascript 手写题收集
学习网站
openspec 实践总结
typescript
微信小程序

分类更多

typescript 1
mini 1
tencent 2
web安全 1
rust 1
track 2
monitor 2
hybird 2
bundle 2
react原理 3

音乐

标签云

track express mini web安全 typescript rust react原理 tencent bundle javascript nodejs hybird 知识海洋 http monitor

最新评论

luhanxin|juwenzhang
2026-02-02

<pre><code>const str = "info.adress.street" const obj = { info: { adress: { city: "beijing", street: "123 street" } } } function getObjValue(obj, str) { // 1. 进行字符串的切割吧 const strArr = str.split("."); let res = obj; let key = undefined; while (strArr.length) { // 首先获取得出第一个属性名出来吧 key = strArr.shift(); if (key in res) { res = res[key]; } else { return undefined; } } return res; } console.log(getObjValue(obj, str)); </code></pre><p></p>
luhanxin|juwenzhang
2026-02-01

<pre><code>/** * 通用 n 数之和，返回所有不重复的数值组合 * @param {number[]} nums - 原数组 * @param {number} n - 几数之和（n ≥ 2） * @param {number} target - 目标和 * @returns {number[][]} 所有不重复的组合 */ function nSum(nums, n, target) { const res = []; // 边界条件：n<2 或数组长度不足n，直接返回空 if (n < 2 || nums.length < n) return res; // 步骤1：排序（核心，为去重、双指针、剪枝服务） nums.sort((a, b) => a - b); // 递归辅助函数：从start索引开始，找count数之和为sum的组合，path是当前已选的数 function dfs(start, count, sum, path) { const len = nums.length; // 剪枝：剩余数字不够选，直接返回 if (len - start < count) return; // 剪枝：升序数组，最小的count个数之和 > sum → 不可能满足 if (nums[start] * count > sum) return; // 剪枝：升序数组，最大的count个数之和 < sum → 不可能满足 if (nums[len - 1] * count < sum) return; // 终止条件：拆解到2数之和，用双指针求解 if (count === 2) { let left = start; let right = len - 1; while (left < right) { const curSum = nums[left] + nums[right]; const leftVal = nums[left]; const rightVal = nums[right]; if (curSum === sum) { // 收集结果：当前路径 + 双指针的两个数 res.push([...path, leftVal, rightVal]); // 双指针去重：左指针跳过重复值 while (left < right && nums[left] === leftVal) left++; // 双指针去重：右指针跳过重复值 while (left < right && nums[right] === rightVal) right--; } else if (curSum < sum) { // 和太小，左指针右移增大值 left++; } else { // 和太大，右指针左移减小值 right--; } } return; } // 非终止条件：递归拆解（固定1个数，找count-1数之和） for (let i = start; i < len; i++) { // 固定数去重：和前一个数相同，跳过（避免重复组合） if (i > start && nums[i] === nums[i - 1]) continue; // 递归：起始索引i+1（不重复选当前数），剩余个数count-1，剩余目标sum-nums[i]，当前路径追加nums[i] dfs(i + 1, count - 1, sum - nums[i], [...path, nums[i]]); } } // 初始调用：从索引0开始，找n数之和为target，当前路径为空 dfs(0, n, target, []); return res; } /** * 通用 n 数之和，返回所有不重复的索引组合 * @param {number[]} nums - 原数组 * @param {number} n - 几数之和（n ≥ 2） * @param {number} target - 目标和 * @returns {number[][]} 所有不重复的索引组合 */ function nSumIndex(nums, n, target) { const res = []; if (n < 2 || nums.length < n) return res; // 步骤1：构建「值-原始索引」数组，并按值排序 const arr = nums.map((v, i) => ({ v, i })).sort((a, b) => a.v - b.v); const len = arr.length; function dfs(start, count, sum, path) { if (len - start < count) return; if (arr[start].v * count > sum) return; if (arr[len - 1].v * count < sum) return; if (count === 2) { let left = start, right = len - 1; while (left < right) { const curSum = arr[left].v + arr[right].v; if (curSum === sum) { // 收集索引组合，并排序（避免[0,1]和[1,0]重复） const indexPath = [...path, arr[left].i, arr[right].i].sort((a, b) => a - b); res.push(indexPath); // 跳过值重复的项（索引自然不同） while (left < right && arr[left].v === arr[left + 1].v) left++; while (left < right && arr[right].v === arr[right - 1].v) right--; left++; right--; } else if (curSum < sum) { left++; } else { right--; } } return; } for (let i = start; i < len; i++) { // 固定数去重：值重复则跳过 if (i > start && arr[i].v === arr[i - 1].v) continue; dfs(i + 1, count - 1, sum - arr[i].v, [...path, arr[i].i]); } } dfs(0, n, target, []); return res; } </code></pre><p></p>
luhanxin|juwenzhang
2026-02-01

<pre><code>def threeSum(nums): nums.sort() res = [] n = len(nums) for i in range(n - 2): if i > 0 and nums[i] == nums[i - 1]: continue left, right = i + 1, n - 1 while left < right: total = nums[i] + nums[left] + nums[right] if total < 0: left += 1 elif total > 0: right -= 1 else: res.append([nums[i], nums[left], nums[right]]) # 跳过重复元素 while left < right and nums[left] == nums[left + 1]: left += 1 while left < right and nums[right] == nums[right - 1]: right -= 1 left += 1 right -= 1 return res</code></pre><ul><li><p>核心思路是进行二分操作获取得到元素即可，以及需要进行的是跳过重复元素吧</p></li></ul><p></p>
luhanxin|juwenzhang
2026-02-01

<p>准备算法之前的话核心需要提前知道的是：<br />数据结构的特点和常用的 API 操作吧：<strong>数组、哈希表、列表、链表、树、图，栈，队列</strong>等数据结构，在日常开发中的话，常操作的就是我们的字符串，数组，哈希表这三种数据类型吧<br />在整个过程中穿插着对于<strong>数据的排序、去重，格式化，清洗，CRUD </strong>的操作吧<br />在实际开发中正则表达式也是一种方式来帮助我们完成有一些业务需求吧</p>
luhanxin|juwenzhang
2026-02-01

<pre><code>两数之和的升级思考，就是如何进行对应的收集所有结果并且返回 function twoSumAll(nums, target) { const res = []; const numToIndices = new Map(); for (let i = 0; i < nums.length; i++) { const num = nums[i]; numToIndices.set(num, numToIndices.has(num) ? [...numToIndices.get(num), i] : [i]); } for (const num of numToIndices.keys()) { const diff = target - num; if (!numToIndices.has(diff) || num > diff) continue; const indices1 = numToIndices.get(num); const indices2 = numToIndices.get(diff); if (num === diff) { for (let i = 0; i < indices1.length; i++) { for (let j = i + 1; j < indices1.length; j++) { res.push([indices1[i], indices1[j]].sort().join(',')); } } } else { for (const i of indices1) { for (const j of indices2) { res.push([i, j].sort().join(',')); } } } } return res; }</code></pre><pre><code> def twoSum(nums, target): map = {} for i, num in enumerate(nums): diff = target - num if diff in map: return [map[diff], i] map[num] = i return [] def twoSumAll(nums, target): res = [] map = {} # 遍历元素，构建基于元素的 hash 表 for i in range(len(nums)): curEle = nums[i] if curEle not in map: map[curEle] = [i] else: map[curEle].append(i) for num in map: diff = target - num if diff not in map: continue if diff < num: continue indices1 = map[num] indices2 = map[diff] # 核心分为两种情况处理 if num == diff: # 处理同一个数的不同索引组合 for i in range(len(indices1)): for j in range(i+1, len(indices1)): pair = sorted([indices1[i], indices1[j]]) res.append(pair) else: # 处理不同数的索引组合 for i in indices1: for j in indices2: pair = sorted([i, j]) res.append(pair) return res arr = [2, 7, 2, 7, 11, 15] target = 9 print(twoSum(arr, target)) print(twoSumAll(arr, target)) </code></pre><p></p>

弹

© 2026 76433京ICP备2025152606号Powered by Halo & Dream

京ICP备2025152606号-1