1. pages 用来存放所有小程序的页面（官方建议把所有小程序的页面，都存放在 pages 目录中，以单独的文件夹存在）
   1. index 首页
      1. index.js 页面的脚本文件
      2. index.json 页面的配置文件
      3. index.wxml 页面的模板结构文件
      4. index.wxss 页面的样式表文件
   2. logs 日志页
      1. logs.js
      2. logs.json
      3. logs.wxml
      4. logs.wxss
2. utils 用来存放工具性质的模块（例如：格式化时间的自定义模块）
3. app.js 小程序项目的入口文件
4. app.json 小程序项目的全局配置文件
5. app.wxss 小程序项目的全局样式文件
6. project.config.json 项目的配置文件
7. sitemap.json 用来配置小程序及其页面是否允许被微信索引

微信小程序项目结构

1. 项目根目录中的 app.json 配置文件
   1. app.json 是当前小程序的全局配置，包括了小程序的所有页面路径、窗口外观、界面表现、底部 tab 等，如下：

      ```
      {
        "pages":[
          "pages/index/index",
          "pages/logs/logs"
        ],
        "window":{
          "backgroundTextStyle":"light",
          "navigationBarBackgroundColor": "#fff",
          "navigationBarTitleText": "Weixin",
          "navigationBarTextStyle":"black"
        },
        "style": "v2",
        "sitemapLocation": "sitemap.json"
      }
      
      ```
   2. 全局配置中的4个配置项的作用：
      1. pages：用来记录当前小程序所有页面的路径
      2. window：全局定义小程序所有页面的背景色、文字颜色等
      3. style：全局定义小程序组件所使用的样式版本
      4. sitemapLocation：用来指明 sitemap.json 的位置
2. 项目根目录中的 project.config.json 配置文件
   1. project.config.json 是项目配置文件，用来记录我们对小程序开发工具所做的个性化配置，如下：

      ```
      {
        "description": "项目配置文件",
        "packOptions": {
          "ignore": [],
          "include": []
        },
        "setting": {
          "bundle": false,
          "userConfirmedBundleSwitch": false,
          "urlCheck": true,
          "scopeDataCheck": false,
          "coverView": true,
          "es6": true,
          "postcss": true,
          "compileHotReLoad": false,
          "lazyloadPlaceholderEnable": false,
          "preloadBackgroundData": false,
          "minified": true,
          "autoAudits": false,
          "newFeature": false,
          "uglifyFileName": false,
          "uploadWithSourceMap": true,
          "useIsolateContext": true,
          "nodeModules": false,
          "enhance": true,
          "useMultiFrameRuntime": true,
          "useApiHook": true,
          "useApiHostProcess": true,
          "showShadowRootInWxmlPanel": true,
          "packNpmManually": false,
          "enableEngineNative": false,
          "packNpmRelationList": [],
          "minifyWXSS": true,
          "showES6CompileOption": false,
          "minifyWXML": true,
          "babelSetting": {
            "ignore": [],
            "disablePlugins": [],
            "outputPath": ""
          },
          "condition": false
        },
        "compileType": "miniprogram",
        "libVersion": "2.19.4",
        "appid": "wx0000000000000000",
        "projectname": "miniprogram-92",
        "condition": {},
        "editorSetting": {
          "tabIndent": "insertSpaces",
          "tabSize": 2
        }
      }
      
      ```
   2. 其中：
      1. setting 中保存了编译相关的配置
      2. projectname 中保存的是项目名称
      3. appid 中保存的是小程序的账号 ID
3. 项目根目录中的 sitemap.json 配置文件
   1. 微信现已开放小程序内搜索，效果类似于 PC 网页的 SEO。sitemap.json 文件用来配置小程序页面是否允许微信索引
   2. 当开发者允许微信索引时，微信会通过爬虫的形式，为小程序的页面内容建立索引。当用户的搜索关键字和页面的索引匹配成功的时候，小程序的页面将可能展示在搜索结果中
   3. 注意：sitemap 的索引提示是默认开启的，如需要关闭 sitemap 的索引提示，可在小程序项目配置文件 project.config.json 的 setting 中配置字段 checkSiteMap 为 false
4. 每个页面文件夹中的 .json 配置文件
   1. 小程序中的每一个页面，可以使用 .json 文件来对本页面的窗口外观进行配置，页面中的配置项会覆盖 app.json 的 window 中相同的配置项

微信小程序项目中的4种 JSON 配置文件

### 题目要求：

给你一个链表的头节点 head，请你编写代码，反复删去链表中由 总和 值为 0 的连续节点组成的序列，直到不存在这样的序列为止。

删除完毕后，请你返回最终结果链表的头节点。

你可以返回任何满足题目要求的答案。

（注意，下面示例中的所有序列，都是对 ListNode 对象序列化的表示。）

示例 1：

```
输入：head = [1,2,-3,3,1]
输出：[3,1]
提示：答案 [1,2,1] 也是正确的。
```

示例 2：

```
输入：head = [1,2,3,-3,4]
输出：[1,2,4]
```

示例 3：

```
输入：head = [1,2,3,-3,-2]
输出：[1]
```

提示：

* 给你的链表中可能有 1 到 1000 个节点。
* 对于链表中的每个节点，节点的值：1000 <= node.val <= 1000.

### 题解：

```
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeZeroSumSublists(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        Map<Integer, ListNode> seen = new HashMap<>();
        int prefix = 0;
        for (ListNode node = dummy; node != null; node = node.next) {
            prefix += node.val;
            seen.put(prefix, node);
        }
        prefix = 0;
        for (ListNode node = dummy; node != null; node = node.next) {
            prefix += node.val;
            node.next = seen.get(prefix).next;
        }
        return dummy.next;
    }
}
```

### 补充图解：

以输入[1,2,-3,3,1,-4,5]为例，输出为[5]

![](https://image.hackertalk.net/images/6d3ac6a1-6f61-412b-9950-63ee9f974d71)

LC1171 从链表中删去总和值为零的连续节点题解

**本文不讨论二叉树层次遍历**

刷题的时候看到一些二叉树遍历的解法，整理在这里作为笔记，也分享给大家

语言是 Java 的，我会采取代码+图解+说明形式来尽可能讲明白每种遍历方式

# 一些准备

为了便于整理和展示，我建立了一个简单的纯 Java 工程来测试各种解法

### 树节点类代码（TreeNode）

一个简单的树节点类：

```
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
```

### 树节点类图解

这是一棵二叉树，它拥有四个树节点，左侧虚线框内是它的简化图

![](https://image.hackertalk.net/images/e7b05c92-8e88-4367-bc12-48fdba5948bf)

### 工程文件结构

![](https://image.hackertalk.net/images/67484347-5d4e-4d7f-8f29-19ffc852a847)

### 工程文件说明

* TreeNode：树节点类
* RecursiveTraversal：递归遍历二叉树的各种实现
* IterativeTraversal：迭代遍历二叉树的各种实现
* MorrisTraversal：Morris 遍历二叉树的各种实现

# 递归解法（RecursiveTraversal）

![](https://image.hackertalk.net/images/b039288d-d22e-4de4-b99a-9c0521f7db63)

* 二叉树天然是一种递归结构，因此递归解法是最简洁的，代码量最少
  * 简洁不一定可读性好；对于不熟悉递归思想的人来说，递归解的可读性并不高
* 显而易见，递归解法总是会消耗大量栈空间
  * 而且，Java 编译器不支持尾递归优化（这与 Java 语言的设计哲学和实现细节有关）
* 另一方面，递归导致的大量函数调用，会产生一定不必要的开销

### 递归解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(n)  |

### 前序（递归）

根左右

```
public static void preOrder(TreeNode root) {
    if (root == null) return;

    System.out.print(root.val + " ");
    preOrder(root.left);
    preOrder(root.right);
}
```

### 中序（递归）

左根右

```
public static void inOrder(TreeNode root) {
    if (root == null) return;

    inOrder(root.left);
    System.out.print(root.val + " ");
    inOrder(root.right);
}
```

### 后序（递归）

左右根

```
public static void postOrder(TreeNode root) {
    if (root == null) return;

    postOrder(root.left);
    postOrder(root.right);
    System.out.print(root.val + " ");
}
```

# 迭代解法（IterativeTraversal）

* 使用辅助数据结构（自定义栈）代替系统栈，有效降低栈空间消耗和溢出风险
* 避免了大量函数调用所产生的开销
* 代码复杂度相对较高
  * 然而，这并不意味着迭代解法更难以理解

### 迭代解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(n)  |

### 前序（迭代，单层循环）

需要区分的一点是：

* 递归中，进入的是子树
* 迭代中，压入的是节点

尽管子树和节点看起来都是一个 TreeNode，但它们之间存在一些区别！

另外，这里使用 LinkedList（双向链表），而非 Stack

因为 Stack 底层是基于数组实现的，对于频繁插入和删除的场景下，并不太适合

> 注意：选择数组或链表实现栈的优劣取决于二叉树的分布特点

对于单层循环方式，我们利用栈的后进先出特点，要先压入右子节点，再压入左子节点

```
public static void preOrder1(TreeNode root) { // 前序单层循环
    if (root == null) return;

    Deque<TreeNode> stack = new LinkedList<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        System.out.print(node.val + " ");
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
}
```

### 前序（迭代，双层循环）

内循环中压入子树的所有左子节点

```
public static void preOrder2(TreeNode root) { // 前序双层循环
    if (root == null) return;

    TreeNode node = root;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            System.out.print(node.val + " ");
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        node = node.right;
    }
}
```

### 中序（迭代，双层循环）

对于单层循环方式，我们必须先把根节点压入栈中，所以它无法实现中序遍历

内循环中压入子树的所有左子节点

```
public static void inOrder(TreeNode root) { // 中序双层循环
    if (root == null) return;

    TreeNode node = root;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        System.out.print(node.val + " ");
        node = node.right;
    }
}
```

### 后序（迭代，单层循环）

对于单层循环方式，后序遍历可以采用一个讨巧的办法：逆序输出

这需要额外的开销（对于下面的代码，既有辅助栈的空间开销，也有逆序的时间开销）

```
public static void postOrder1(TreeNode root) { // 后序单层循环
    if (root == null) return;

    Deque<TreeNode> stack1 = new LinkedList<>();
    Deque<TreeNode> stack2 = new LinkedList<>();
    stack1.push(root);
    while (!stack1.isEmpty()) {
        TreeNode node = stack1.pop();
        stack2.push(node);
        if (node.left != null) stack1.push(node.left);
        if (node.right != null) stack1.push(node.right);
    }
    while (!stack2.isEmpty()) {
        System.out.print(stack2.pop().val + " ");
    }
}
```

### 后序（迭代，双层循环）

内循环中压入子树的所有左子节点

```
public static void postOrder2(TreeNode root) { // 后序双层循环
    if (root == null) return;

    TreeNode node = root;
    TreeNode prev = null;
    Deque<TreeNode> stack = new LinkedList<>();
    while (!stack.isEmpty() || node != null) {
        while (node != null) {
            stack.push(node);
            node = node.left;
        }
        node = stack.pop();
        if (node.right == null || node.right == prev) {
            System.out.print(node.val + " ");
            prev = node;
            node = null;
        } else {
            stack.push(node);
            node = node.right;
        }
    }
}
```

### 5种迭代解法图解

我绘制了5种解法的核心代码 N-S 图，以便于横向对比

![](https://image.hackertalk.net/images/4ab675a6-0b47-47ba-8323-86ba2d7f27d7)

# Morris 解法（MorrisTraversal）

* 本质上，Morris 解法利用了二叉树节点中指向 null 的 left 和 right 属性（空闲指针），将原本的二叉树改造成临时线性结构，从而实现空间复杂度 O(1) 的遍历
* 在传统的线索二叉树中，我们一般需要使用左右 tag 来标识指向的是左右节点还是前驱或后继节点；Morris 解法可以看作是一种不使用 tag 的线索化二叉树方法
* Morris 解法不能直接适用于后序遍历，需要额外的操作才能实现（本文不展示）
* Morris 解法在遍历过程中修改了树的结构，因此不是线程安全的

### Morris 解法复杂度

| 时间复杂度 | 空间复杂度 |
| ----- | ----- |
| O(n)  | O(1)  |

### 前序（Morris）

```
public static void preOrder(TreeNode root) {
    if (root == null) return;

    TreeNode cur1 = root;
    TreeNode cur2 = null;
    while (cur1 != null) {
        cur2 = cur1.left;
        if (cur2 != null) {
            // 找到左子树的最右叶子节点
            while (cur2.right != null && cur2.right != cur1) {
                cur2 = cur2.right;
            }
            if (cur2.right == null) {
                cur2.right = cur1;
                System.out.print(cur1.val + " ");
                cur1 = cur1.left;
                continue;
            } else {
                cur2.right = null;
            }
        } else {
            System.out.print(cur1.val + " ");
        }
        cur1 = cur1.right;
    }
}
```

### 中序（Morris）

```
public static void inOrder(TreeNode root) {
    if (root == null) return;

    TreeNode cur1 = root;
    TreeNode cur2 = null;
    while (cur1 != null) {
        cur2 = cur1.left;
        if (cur2 != null) {
            // 找到左子树的最右叶子节点
            while (cur2.right != null && cur2.right != cur1) {
                cur2 = cur2.right;
            }
            if (cur2.right == null) {
                cur2.right = cur1;
                cur1 = cur1.left;
                continue;
            } else {
                cur2.right = null;
            }
        }
        System.out.print(cur1.val + " ");
        cur1 = cur1.right;
    }
}
```

整理：Java 二叉树遍历（递归、迭代、Morris）原创图解+代码

刚发现不能给自己点赞了

手搭我的世界基岩版后台网站 LiteloaderBDS - SQLite - Spring Boot - Vue：从零开始构建基于RESTful API 的后台系统；使用 Element-UI Plus 和 Three.js 实现可视化展览界面

昨天刷到一道题，做完后发现自己的解法和官方题解有一些差别，故分享一下

---

### 题目要求：

给定四个整数 rows ,   cols ,  rCenter 和 cCenter 。有一个 rows * cols 的矩阵，你在单元格上的坐标是 (rCenter, cCenter) 。

返回矩阵中的所有单元格的坐标，并按与 (rCenter, cCenter) 的 **距离** 从最小到最大的顺序排。你可以按 **任何** 满足此条件的顺序返回答案。

单元格(r1, c1) 和 (r2, c2) 之间的距离为|r1 - r2| + |c1 - c2|。

示例 1：

```
输入：rows = 1, cols = 2, rCenter = 0, cCenter = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]
```

示例 2：

```
输入：rows = 2, cols = 2, rCenter = 0, cCenter = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。
```

示例 3：

```
输入：rows = 2, cols = 3, rCenter = 1, cCenter = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。
```

提示：

* 1 <= rows, cols <= 100
* 0 <= rCenter < rows
* 0 <= cCenter < cols

### 官方题解：

* 基础的是二维矩阵存储曼哈顿距离，排序后输出
* 进阶一点，进行分桶排序，降低时间复杂度
* 几何法，从中心向外枚举曼哈顿距离，用广度优先搜索

### 我的思路图如下（生长方块）：

---

![](https://content.hackertalk.net/pub/gqeBw6-7d2zmAe)

---

首先手动放置中心位置的上下左右四个方块（可能不足四个，根据输入情况）到队列中，它们有各自的方向，可以根据方向进行生长

每一轮生长的方块都放置到队列中，这样取出的方块与中心的曼哈顿距离正是从小到大

步骤是先从队列中取出方块，让方块生长，新方块放置到队尾，然后将此取出方块的坐标填入数组中

switch 处利用了穿透

### 我的代码如下：

```java
class Solution {
    public static int[][] allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        GrowthBlock.rows = rows;
        GrowthBlock.cols = cols;
        int[][] answer = new int[rows * cols][2];
        answer[0][0] = rCenter;
        answer[0][1] = cCenter;
        int i = 1;
        Queue<GrowthBlock> blocks = new LinkedList<>();
        if (rCenter - 1 >= 0) {
            blocks.offer(new GrowthBlock(rCenter - 1, cCenter, 6));
        }
        if (rCenter + 1 < rows) {
            blocks.offer(new GrowthBlock(rCenter + 1, cCenter, 2));
        }
        if (cCenter - 1 >= 0) {
            blocks.offer(new GrowthBlock(rCenter, cCenter - 1, 0));
        }
        if (cCenter + 1 < cols) {
            blocks.offer(new GrowthBlock(rCenter, cCenter + 1, 4));
        }
        while (!blocks.isEmpty()) {
            GrowthBlock block = blocks.poll();//取出一个block
            answer[i++] = block.getInts();//输出到答案
            for (GrowthBlock b : block.growth()) {//生长并填入新的block
                blocks.offer(b);
            }
        }
        return answer;
    }
}

class GrowthBlock {//生长块
    public static int rows;
    public static int cols;
    byte x;
    byte y;
    byte growthDir;//生长方向

    //0右上 1右 2右下 3下 4左下 5左 6左上 7上
    public GrowthBlock(int x, int y, int growthDir) {
        this.x = (byte) x;
        this.y = (byte) y;
        this.growthDir = (byte) growthDir;
    }

    public int[] getInts() {//返回坐标
        return new int[]{x, y};
    }

    public List<GrowthBlock> growth() {//生长并返回
        List<GrowthBlock> bs=new ArrayList<>();
        switch (growthDir) {
            case 0:
                if (y - 1 >= 0) {
                    bs.add(new GrowthBlock(x, y - 1, 0));
                }
            case 1:
                if (x + 1 < rows) {
                    bs.add(new GrowthBlock(x + 1, y, 1));
                }
                break;
            case 2:
                if (x + 1 < rows) {
                    bs.add(new GrowthBlock(x + 1, y, 2));
                }
            case 3:
                if (y + 1 < cols) {
                    bs.add(new GrowthBlock(x, y + 1, 3));
                }
                break;
            case 4:
                if (y + 1 < cols) {
                    bs.add(new GrowthBlock(x, y + 1, 4));
                }
            case 5:
                if (x - 1 >= 0) {
                    bs.add(new GrowthBlock(x - 1, y, 5));
                }
                break;
            case 6:
                if (x - 1 >= 0) {
                    bs.add(new GrowthBlock(x - 1, y, 6));
                }
            case 7:
                if (y - 1 >= 0) {
                    bs.add(new GrowthBlock(x, y - 1, 7));
                }
                break;
        }
        return bs;
    }
}
```

LC1030 距离顺序排列矩阵单元格题解（生长方块）

JavaFX实现坦克大战

如题，下面的陈述内容来自《Java编程思想》：

9.8	嵌套接口

接口可以嵌套在类或其他接口中。这揭示了许多非常有趣的特性：

```java
package chapter_09;

class A{
	interface B{void f();}
	public class BImp implements B{public void f() {};}
	private class BImp2 implements B{public void f() {};}
	public interface C{void f();}
	class CImp implements C{public void f() {};}
	private class CImp2 implements C{public void f() {};}
	private interface D{void f();}
	private class DImp implements D{public void f() {};}
	public class DImp2 implements D{public void f() {};}
	public D getD() {return new DImp2();}
	private D dRef;
	public void receiveD(D d) {
		dRef=d;
		dRef.f();
	}
}

interface E{
	interface G{void f();}
	public interface H{void f();}//Redundant "public"
	void g();
	//Cannot be private within an interface:
//	private interface I{};
}

public class NestingInterfaces {
	public class BImp implements A.B{
		public void f() {}
	}
	class CImp implements A.C{
		public void f() {}
	}
	//Cannot implement a private interface except
	//within that interface's defining class:
//	class DImp implements A.D{
//		public void f() {}
//	}
	class EImp implements E{
		public void g() {};
	}
	class EGImp implements E.G{
		public void f() {};
	}
	class EImp2 implements E{
		public void g() {}
		class EG implements E.G{
			public void f() {}
		}
	}
	public static void main(String[] args) {
		A a=new A();
		//Can't access A.D:
//		A.D ad=a.getD();
		//Doesn't return anything but A.D:
//		A.DImp2 di2=a.getD();
		//Cannot access a member of the interface:
//		a.getD().f();
		//Only another A can do anything with getD():
		A a2=new A();
		a2.receiveD(a.getD());
	}
}///:~
```

在类中嵌套接口的语法是相当显而易见的，就像非嵌套接口一样，可以拥有public和“包访问”两种可视性

作为一种新添加的方式，接口也可以被实现为private的，就像在A.D中所看到的（相同的语法既适用于嵌套接口，也适用于嵌套类）。那么private的嵌套接口能带来什么好处呢？读者可能会猜想，它只能够被实现为DImp中的一个private内部类，但是A.DImp2展示了它同样可以被实现为public类。但是，A.DImp2只能被其自身所使用。你无法说它实现了一个private接口D。因此，实现一个private接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）

getD()方法使我们陷入了一个进退两难的境地，这个问题与private接口相关：它是一个返回对private接口的引用的public方法。你对这个方法的返回值能做些什么呢？在main()中，可以看到数次尝试使用返回值的行为都失败了。只有一种方式可成功，那就是将返回值交给有权使用它的对象。在本例中，是另一个A通过receiveD()方法来实现的

接口E说明接口彼此之间也可以嵌套。然而，作用于接口的各种规则，特别是所有的接口元素都必须是public的，在此都会被严格执行。因此，嵌套在另一个接口中的接口自动就是public的，而不能声明为private的

NestingInterfaces展示了嵌套接口的各种实现方式，特别要注意的是，当实现某个接口时，并不需要实现嵌套在其内部的任何接口。而且，private接口不能在定义它的类之外被实现

添加这些特性的最初原因可能是出于对严格的语法一致性的考虑，但是我总认为，一旦你了解了某种特性，就总能够找到它的用武之地

提问贴：Java一个类内部的private接口可以有哪些实际应用

详解Java实现小游戏2048（使用JavaFX）

点击顶部菜单栏Window->Show View->Project Explorer

从Project Explorer栏展开到要生成类图的对应java文件，然后拖曳，从Navigator栏进行拖曳是无效的

Eclipse插件AmaterasUML创建Class Diagram后拖曳java文件生成类图无反应的解决方法

“通常为了减少时间损失，采用猜测法，即当条件转移指令从取指阶段进入执行阶段时，指令部件仍按顺序预取下一条指令。这样，如果条件不成立，转移没有发生，则没有时间损失；若条件成立，转移发生，则所取的指令必须丢掉，并再取新的指令”

上面是CPU硬件层面的行为。那么这是否能表明在高级语言如c或java里将最可能发生的事件放在if语句块里而非else语句块里是更高效的

高级语言条件语句效率问题

别问我为什么要搞这个工具？

Golang实现的Linux防误删命令grm，带删除日志方便恢复文件时用。

定时清空回收站crontab配置

0 0 */2 * * rm -rf /tmp/.trash/*


视频地址：https://www.bilibili.com/video/BV1gh4y1A7J9

仓库地址：https://gitee.com/dabpop139/share/tree/master/PJ03



rm -rf删库跑路？Golang实现的Linux防误删命令grm

正在找实习，目前大四，学过的技术有HTML，CSS，JavaScript，Vue.js，uniapp，微信小程序，Node.js，还有Python的Django，目前就有一个简单的个人博客，还有一个图书管理的项目，大家有没有推荐的项目给我练练手，谢谢 :pray:  :pray: 

找实习，做项目练手

一直以来写 rust 都是用 idea 或 clion 的 rust 插件，但每种语言都有特定的调试工具，如果能定制一个 IDE 专门写 rust 那是极好的  :grin: , RustRover 的目标就是改善 Rust 的开发体验，比如智能补全：

![](https://image.hackertalk.net/images/82a44e24-aa68-4558-b3d3-d79646438b2f)

RustRover 现在还是 preview 阶段，可以免费在[官网下载](https://www.jetbrains.com/rust/)使用，也可以在 Toolbox 上直接安装，不知道后面会不会加入到 JB 全家桶套餐中  :smiley: 

![](https://image.hackertalk.net/images/b194402e-e43e-4cb7-aeba-f82b5db33443)

[Introducing RustRover – A Standalone Rust IDE by JetBrains](https://blog.jetbrains.com/rust/2023/09/13/introducing-rustrover-a-standalone-rust-ide-by-jetbrains/)

Jetbrains 推出 Rust 专属 IDE

好消息，godot中国社区也在积极响应unity的最新协议！

![](https://image.hackertalk.net/images/f83a732c-1c20-4f00-8d73-e4af2b6f6d37)

![](https://image.hackertalk.net/images/a888a203-e00e-4c39-aa50-8916d551e434)
为了让国内用户更方便地切换godot引擎进行继续开发，我们在gitee上传了仓库:

![](https://image.hackertalk.net/images/bf64fd63-8294-4921-9c1a-13f3ba688699)

godot二进制文件，godot学习文档，godot大量开发案例，unity工程转移godot，大家无需翻墙，自行编译即可快速使用。

![](https://image.hackertalk.net/images/efcff9e4-6530-4572-92f5-3e3d2c4aebc7)

![](https://image.hackertalk.net/images/2d5b7155-9695-4323-b2b9-cf74a1ed762e)

[godotengine_mirror地址](https://gitee.com/godotengine_mirror/)

之后也会陆续更新大家可能会需要的内容，如果有新的需求可以直接联系我，回复邮箱，或者直接提交issues。
当前参与企业编辑人数为2/5，欢迎大家留下自己的邮箱，参与到godot中国社区的建设！

Godot中国社区也在积极响应unity的最新协议

我向一个开源项目发起了pr，但是这个pr里出现了我上一次pr的commits。我按照这个[博客](https://www.codetd.com/article/13673067)，rebase了一下代码（也可能是我打开的方式不对），然后本来是有10条commits（2条本次pr，8条上次pr）的，现在我有20条了😂...

这里是[pr](https://github.com/dgilland/cacheout/pull/31)的地址

请教一下各位大佬，这种情况该如何操作，才能让pr只包含本次提交的2条commits

请教一个有关pull request的问题

欢迎大家给鄙人提供一些有趣的想法

大家有没有知道一门相对冷门且有趣的编程语言？

有大手子谈一下真相吗？关于编码效率、兼容性、对python依赖的可用性。