灯的个人博客

forever young,forever weeping.

0%

发表于 更新于 分类于

nestjs 无法注入服务

问题发现

  • 在 viewService 里面导入 UserService,发现一直提示错误，没有找到可以注入的内容
  • 检查了一遍代码，确认逻辑代码没有问题
  • 怀疑是不是循环依赖了，检查代码，发现代码基本与其他 Moduel 的服务相同，没有出现循环依赖的情况
  • 打印 ModuleContainer，在当前 ViewModule 里面找到了导入的 UserModule，也存在 UserService

view.service.ts 尝试打印是否成功导入 UserModule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Injectable()
export class ViewService {
  constructor(
    private modulesContainer: ModulesContainer,
    private userService: UserService,
    @InjectRepository(ViewEntity)
    private viewEntityRepository: Repository<ViewEntity>
  ) {
    [...modulesContainer.values()].map((module) => {
      if (module.metatype.name === "ViewModule") {
        console.log("=======imports=======");
        console.log(module.imports);
        console.log("=======providers======");
        console.log(module.providers);
        console.log("=======exports======");
        console.log(module.exports);

        console.log("\n\n\n\n\n");
        console.log("=======UserModule exports======");
        [...module.imports.values()].map((innerModule) => {
          if (innerModule.metatype.name === "UserModule") {
            console.log(innerModule.exports);
          }
        });
      }
    });
  }
}

view.module.ts

1
2
3
4
5
6
7
@Module({
  imports: [TypeOrmModule.forFeature([ViewEntity, ViewLikeStatEntity]), UserModule],
  controllers: [ViewController],
  providers: [ViewService],
  exports: [ViewService],
})
export class ViewModule {}

view.service.ts 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
export type ViewRelationType = "topic";
export interface JoinListInterface {
  uid: string;
  avatar: string;
  nickname: string;
  roler: number;
}
@Injectable()
export class ViewService {
  constructor(private readonly userService: UserService, @InjectRepository(ViewEntity) private readonly viewRepository: Repository<ViewEntity>) {}

  create(createViewDto: CreateViewDto) {
    return "This action adds a new view";
  }
  ...
}

控制台

1
2
3
4
5
6
7
8
[error] 2021-07-28 18:11:32.1 [ExceptionHandler] Nest can't resolve dependencies of the ViewService (?, ViewEntityRepository). Please make sure that the argument dependency at index [0] is available in the ViewModule context.

Potential solutions:
- If dependency is a provider, is it part of the current ViewModule?
- If dependency is exported from a separate @Module, is that module imported within ViewModule?
  @Module({
    imports: [ /* the Module containing dependency */ ]
  })

解决问题

  • 再次检查代码，发现 view.service.ts 导出了三个东西，一个 type，一个 interface，还有一个 viewService 服务
  • 全文查找导出的接口，发现在一个实体里面有这个类型的引入，就是 JoinListInterface.

topic.entity.ts

1
2
3
4
5
6
7
8
9
10
@Entity("topics", { schema: "42how" })
export class TopicEntity {
  @PrimaryGeneratedColumn({ type: "bigint", name: "id", unsigned: true })
  id: number;

  join: {
    count?: number;
    list?: JoinListInterface[];
  } = { count: 0, list: [] };
}

  • 尝试删除 JoinListInterface ，服务注入成功

  • 原本以为 ts 的 interface，type 是不参与到编译过后的 js 文件，检查编译后 topic.entity.js 文件，发现 const view_service_1 = require("../modules/view/view.service"); 这一句，虽然 interface 没有被使用，但是这个 js 文件被引入了。因为这个实体类被引入的比较多，产生了循环依赖，在 nestjs 进行注入的时候，这个文件导出是 undefined，查找不到服务，无法注入。

总结

  • ts 中 export 的类型文件应该单独定义，不要跟逻辑代码放在一个文件。
  • 类型文件虽然没有参与编译，但是会引入文件，如果引用的过于复杂，会导致循环依赖的情况
  • 感谢青木大佬的帮助

发表于 更新于 分类于

想在局域网内访问 wsl 端口

主要工作环境都在wsl里面，有时候想用真机调试，需要局域网访问

TODO
有空写吧

发表于 更新于 分类于

wsl 默认服务启动

原因

习惯了linux的命令行，在windows开发环境下装了wsl2的环境,但是每次windows重启，再打开wsl，服务全都挂了，而且wsl2也没有systemd这种服务，所以想每次打开wsl2的时候，服务都是启动状态

解决

看到印度老哥写的一个脚本

1
2
3
4
5
6
7
8
# /etc/init.wsl
#! /bin/bash
lsof -i:9000 > /dev/null || systemctl start php-fpm
lsof -i:80 > /dev/null || systemctl start nginx
lsof -i:3306 > /dev/null || systemctl start mysqld
lsof -i:6379 > /dev/null || redis-server /etc/redis.conf
# systemctl 是使用的github上一个老哥写的python脚本，好像是这个
# 地址：https://github.com/gdraheim/docker-systemctl-replacement

找个地方保存

然后再打开 .zshrc 或者 .bashrc 再里面把文件的路径填到里面

我的是放再.zshrc里面

1
/etc/init.wsl

这样子每次启动wsl的时候就会启动这些服务

发表于 更新于 分类于

题目

请你判断一个 9x9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

  • 数字 1-9 在每一行只能出现一次。
  • 数字 1-9 在每一列只能出现一次。
  • 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
    数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

注意：

  • 一个有效的数独（部分已被填充）不一定是可解的。
  • 只需要根据以上规则，验证已经填入的数字是否有效即可。

题解

  • 暴力解法，用set存数据看是否有重复的
  • 难点在于 方块3*3的计算公式，不知道怎么推导出来的。
  • 自己写的话，需要花好长的时间去慢慢试出来这个公式
  • Math.floor(Math.floor(Math.floor(i / 3) * 3) + Math.floor(j / 3));
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    function isValidSudoku(board: string[][]): boolean {
      for (let i = 0; i < 9; i++) {
        let rowSet = new Set();
        let colSet = new Set();
        let squareSet = new Set();
        for (let j = 0; j < 9; j++) {
          if (board[i][j] != "." && rowSet.has(board[i][j])) {
            return false;
          }
          rowSet.add(board[i][j]);
          if (board[j][i] != "." && colSet.has(board[j][i])) {
            return false;
          }
          colSet.add(board[j][i]);
          let a = Math.floor(Math.floor(Math.floor(i / 3) * 3) + Math.floor(j / 3));
          let b = Math.floor((i % 3) * 3 + (j % 3));
          if (board[a][b] != "." && squareSet.has(board[a][b])) {
            return false;
          }
          squareSet.add(board[a][b]);
        }
      }
      return true;
    }

参考链接

发表于 更新于 分类于

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

1
2
3
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

1
2
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

1
2
输入：nums = [3,3], target = 6
输出：[0,1]

提示：

1
2
3
4
5
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

题解

暴力破解

1
2
3
4
5
6
7
8
9
function twoSum(nums: number[], target: number): number[] {
  for (let i = 0; i < nums.length - 1; i++) {
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[i] + nums[j] === target) {
        return [i, j];
      }
    }
  }
}

双指针排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function twoSum(nums: number[], target: number): number[] {
  let numsMap = nums.reduce((current, next, index) => {
    current.set(index, next);
    return current;
  }, new Map());
  nums = nums.sort((a, b) => a - b);
  let rightIndex = nums.findIndex((item) => item > target);
  let leftIndex = 0;
  rightIndex = rightIndex === -1 ? nums.length - 1 : rightIndex;
  while (true) {
    if (nums[leftIndex] + nums[rightIndex] === target) {
      return [numsMap.get(nums[leftIndex]), numsMap.get(nums[rightIndex])];
    }
    if (leftIndex % 2 === 0) {
      leftIndex++;
    } else {
      rightIndex--;
    }
  }
}

map表

1
2
3
4
5
6
7
8
9
10
11
12
function twoSum(nums: number[], target: number): number[] {
  let sumMap = new Map();
  for (let i = 0; i < nums.length; i++) {
    let indexObj = sumMap.get(target - nums[i]);
    if (indexObj) {
      return [indexObj.index, i];
    }
    sumMap.set(nums[i], {
      index: i,
    });
  }
}
  • map表解法最优

参考链接

发表于 更新于 分类于

题目

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

1
2
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

说明:

1
2
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

题解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 Do not return anything, modify nums in-place instead.
 */
function moveZeroes(nums: number[]): void {
  let leftIndex = 0;
  let rightIndex = nums.length - 1;
  while (leftIndex <= rightIndex) {
    if (nums[leftIndex] !== 0) {
      leftIndex++;
      continue;
    }
    nums.splice(leftIndex, 1);
    nums.push(0);
    rightIndex--;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
impl Solution {
    pub fn move_zeroes(nums: &mut Vec<i32>) {
        let mut left = 0;
        let mut right = nums.len();
        while left < right {
            if nums[left] == 0 {
                nums.splice(left..left + 1, []);
                nums.push(0);
                right = right - 1;
            } else {
                left = left + 1;
            }
        }
    }
}

参考链接

发表于 更新于 分类于

题目

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

1
2
3
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：

1
2
3
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：

1
2
输入：digits = [0]
输出：[1]

提示：

1
2
1 <= digits.l`ength <= 100
0 <= digits[i] <= 9

题解

  • 倒序循环该数组
  • 如果当前位+1 不等于10，跳出循环，返回数组
  • 如果当前位+1 等于10，当前位等于0，继续循环到下一位加1，判断是否等于10
  • 循环结束判断第一位是否等于0，如果等于0，第一位添加1
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    function plusOne(digits: number[]): number[] {
      let index = digits.length - 1;
      while (index >= 0) {
        let currentNum = digits[index] + 1;
        if (currentNum !== 10) {
          digits[index] = currentNum;
          break;
        }
        digits[index] = 0;
        index--;
      }
      if (digits[0] === 0) {
        digits.unshift(1);
      }
      return digits;
    }

参考链接

发表于 更新于 分类于

题目

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

1
2
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

1
2
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

说明：

  • 输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。

  • 我们可以不考虑输出结果的顺序。
    进阶：

  • 如果给定的数组已经排好序呢？你将如何优化你的算法？

  • 如果 nums1 的大小比 nums2 小很多，哪种方法更优？

  • 如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

题解

直觉版

1
2
3
4
5
6
7
8
9
10
11
12
13
function intersect(nums1: number[], nums2: number[]): number[] {
  if (nums1.length > nums2.length) {
    [nums1, nums2] = [nums2, nums1];
  }
  return nums1.filter((item) => {
    let index = nums2.findIndex((cItem) => item === cItem);
    if (index === -1) {
      return false;
    }
    nums2.splice(index, 1);
    return true;
  });
}

双指针版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function intersect(nums1: number[], nums2: number[]): number[] {
  nums1 = nums1.sort((a, b) => a - b);
  nums2 = nums2.sort((a, b) => a - b);
  let rightIndex = 0;
  let leftIndex = 0;
  let result = [];
  while (leftIndex < nums1.length && rightIndex < nums2.length) {
    if (nums1[leftIndex] === nums2[rightIndex]) {
      result.push(nums1[leftIndex]);
      leftIndex++;
      rightIndex++;
      continue;
    } else if (nums2[rightIndex] > nums1[leftIndex]) {
      leftIndex++;
      continue;
    } else {
      rightIndex++;
    }
  }
  return result;
}

参考

发表于 更新于 分类于

题目

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

1
2
输入: [2,2,1]
输出: 1

示例 2:

1
2
输入: [4,1,2,1,2]
输出: 4

题解

常规set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
function singleNumber(nums: number[]): number {
  let numSet: Set<number> = new Set();
  for (let i = 0; i < nums.length; i++) {
    if (numSet.has(nums[i])) {
      numSet.delete(nums[i]);
    } else {
      numSet.add(nums[i]);
    }
  }
  return [...numSet][0];
}
``` 

位运算
- 1 ^ 1 = 0
- 0 ^ 1 = 1;
- 1 ^ 1 ^ 2 = 2;
- 2 ^ 2 ^ 1 = 1
- 相同的数字或运算等于0,0与人气其他数字或运算等于此数字
- 2 ^ 2 ^ 3 ^ 3 ^ 1 =  1
```typescript
function singleNumber(nums: number[]): number {
  let result = 0;
  for (let i = 0; i < nums.length; i++) {
    result ^= nums[i];
  }
  return result;
}

参考链接

发表于 更新于 分类于

题目

给定一个整数数组，判断是否存在重复元素。

如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

示例 1:

1
2
输入: [1,2,3,1]
输出: true

示例 2:

1
2
输入: [1,2,3,4]
输出: false

示例 3:

1
2
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

题解

1
2
3
4
5
6
7
8
9
10
function containsDuplicate(nums: number[]): boolean {
  let numSet = new Set();
  for (let i = 0; i < nums.length; i++) {
    if (numSet.has(nums[i])) {
      return true;
    }
    numSet.add(nums[i]);
  }
  return false;
}

参考链接