算法（Algorithm）是解决特定问题的有限步骤序列，是一系列定义明确的指令。在计算机科学和数学中，算法通常用于数据处理、计算和自动推理任务。正确的算法会在给定输入的情况下按预定步骤执行并最终产生输出或确认解决方案。

算法

### Knuth-Morris-Pratt（KMP）算法的应用

KMP算法是一种用于字符串搜索的算法，它可以在一个主文本字符串S内查找一个词W的出现位置。这种算法通过避免重新检查之前已匹配的字符来提高搜索效率。

#### 应用举例：

1. **文本编辑软件**：在文本编辑软件中，用户经常需要查找特定的单词或短语，KMP算法能够高效地帮助实现这一功能。
2. **数据挖掘**：在数据挖掘中，经常需要在大量文本中查找或匹配特定模式，KMP通过减少不必要的比较，加快搜索速度。
3. **网络安全**：在网络安全领域，例如入侵检测系统中，KMP算法可以用来查找和匹配恶意代码或特定的字符串模式。
4. **生物信息学**：在DNA序列分析中，常常需要在DNA字符串中查找特定的序列，KMP算法提供了一种有效的搜索方法。

### Knuth-Morris-Pratt（KMP）算法的实现

KMP算法的核心在于一个"部分匹配"表（也称为"前缀函数"），该表用于在发生不匹配时，决定搜索中下一步匹配的起始位置，以此避免从头开始匹配。

#### 实现步骤：

1. **构建部分匹配表**：
 - 这个表为每一个位置保存了一个数值，该数值表示当前位置之前的字符串中有多大长度的相同前缀后缀。
 - 例如，对于字符串"ABCDABD"，部分匹配表是 `[0, 0, 0, 0, 1, 2, 0]`。

2. **使用部分匹配表进行搜索**：
 - 在主字符串S中，从第一个字符开始尝试匹配词W。
 - 当发现不匹配时，可以利用部分匹配表中记录的数值，跳过一些无需比较的字符，直接从潜在的匹配位置开始。

#### 代码示例（Python）：

```python
def KMP_search(text, pattern):
 # 计算部分匹配表
 def compute_lps(pattern):
 lps = [0] * len(pattern)
 length = 0
 i = 1
 while i < len(pattern):
 if pattern[i] == pattern[length]:
 length += 1
 lps[i] = length
 i += 1
 else:
 if length != 0:
 length = lps[length - 1]
 else:
 lps[i] = 0
 i += 1
 return lps

 lps = compute_lps(pattern)
 i = j = 0 # i是文本的索引，j是模式的索引
 while i < len(text):
 if pattern[j] == text[i]:
 i += 1
 j += 1

 if j == len(pattern):
 print(f"Found pattern at index {i - j}")
 j = lps[j - 1]

 # mismatch后，利用部分匹配表决定下一步的匹配位置
 elif i < len(text) and pattern[j] != text[i]:
 if j != 0:
 j = lps[j - 1]
 else:
 i += 1

KMP_search("ABABDABACDABABCABAB", "ABABCABAB")
```

以上是KMP算法的简要介绍、应用和实现示例。通过这种方式，KMP算法能够有效地减少不必要的比较，从而提高字符串匹配的效率。

Discuss the application and implementation of the Knuth-Morris-Pratt (KMP) algorithm.

最小生成树（MST）是一种用于图论中的数据结构，具体来讲是在一个加权无向图中找到一个子图（这个子图也必须是一棵树），使得连接图中所有顶点的总边权最小。这个数据结构在多种场景，如网络设计（如电话网络、电网络等）、路径寻找、最优化问题等领域有广泛的应用。

### 基本概念

在更详细地描述之前，我们先定义几个基本概念：

- **图**：由顶点（或节点）以及连接顶点的边组成的集合。
- **加权图**：每条边都分配了一个重量或成本。
- **无向图**：图中的边没有方向。

### MST的性质

- MST连接图中的所有顶点且没有任何环。
- MST的总边权要尽可能小。
- 对于含有n个顶点的图，其MST有n-1条边。

### 算法

构建最小生成树的常用算法有Kruskal算法和Prim算法：

1. **Kruskal算法**  
   - 初始状态下，森林中每个顶点都是一个独立的树。
   - 按照边的权重顺序（从小到大）将边加入森林中，但是在添加边的时候要保证不会形成环。
   - 重复上述过程，直到森林中所有的顶点都连通。

2. **Prim算法**  
   - 从图中的任意顶点u开始，生成树G的初始状态只包含u。
   - 从所有连接生成树G与图中其他未包含在G中的顶点的边中，挑选权重最小的边，并将这条边及其对应的顶点加入到G中。
   - 重复上述过程，直到G包含图中的所有顶点。

### 应用实例

**网络设计**：假设需要设计一个新的电信网络来连接多个城市，城市之间铺设网络线路的成本不同。使用最小生成树可以帮助找到成本最低的网络铺设方案，确保任何两个城市之间至少有一条直接或间接的连接线路，而且总成本是最低的。

通过以上说明，最小生成树不仅是一个理论上的数学概念，它还有着非常实际的应用价值，能够解决实际生活中的许多最优化问题。

Describe minimum spanning tree (MST) data structure?

采用几种不同的方法来解决这个问题。这里我会介绍两种比较常见的方法，一种是使用哈希表，另一种是使用异或操作。

### 方法一：使用哈希表

使用哈希表来记录数组中每个元素出现的次数，然后遍历哈希表找到只出现一次的数字。

**步骤如下：**

1. 初始化一个空的哈希表。
2. 遍历数组，对于每个元素，如果它不在哈希表中，就添加进去并设置计数为1；如果已经在哈希表中，就将其计数加1。
3. 再次遍历哈希表，寻找计数为1的元素。

**代码示例（Python）：**

```python
def singleNumber(nums):
    count_map = {}
    for num in nums:
        if num in count_map:
            count_map[num] += 1
        else:
            count_map[num] = 1
  
    for num, count in count_map.items():
        if count == 1:
            return num
```

### 方法二：使用异或操作

异或（XOR）操作有一个非常有趣的性质：任何数和0做异或运算结果都是数本身，任何数和自己做异或运算结果都是0。利用这个性质，我们可以轻松找到只出现一次的数字。

**步骤如下：**

1. 初始化一个变量 `result`为0。
2. 遍历数组，将每个元素与 `result`进行异或操作。
3. 由于数组中除了一个数字之外，其他的数字都出现了两次，它们将被抵消。
4. 最终 `result`的值就是只出现一次的数字。

**代码示例（Python）：**

```python
def singleNumber(nums):
    result = 0
    for num in nums:
        result ^= num
    return result
```

### 总结

如果考虑到时间和空间效率，使用异或操作的方法更为高效，因为它的时间复杂度是O(n)，且空间复杂度为O(1)。而使用哈希表的方法虽然时间复杂度也是O(n)，但空间复杂度是O(n)，因为需要额外的空间来存储元素及其计数信息。


这两种情况的解决方案有所不同，但我可以为两种情况提供思路。

### 情况1：寻找只出现一次的数字，其余数字均出现两次或多次

如果数组中所有元素都是成对出现的，除了一个数字只出现一次，那么这个问题的一个非常高效的解决方法是使用异或运算（XOR）。异或运算有以下几个特点：  

- 一个数和它本身做异或运算结果为0，即 `a ^ a = 0`。
- 一个数和0做异或运算结果为它本身，即 `a ^ 0 = a`。
- 异或运算满足交换律和结合律，即 `a ^ b ^ a = (a ^ a) ^ b = 0 ^ b = b`。

因此，我们可以通过对数组中所有元素进行异或运算，成对出现的数字会两两抵消为0，最终剩下的结果就是唯一一个只出现一次的数字。这个方法的时间复杂度是O(n)，空间复杂度是O(1)，非常高效。

例如，数组 `[4, 1, 2, 1, 2]` 中，使用异或运算：

```
4 ^ 1 ^ 2 ^ 1 ^ 2 = (1 ^ 1) ^ (2 ^ 2) ^ 4 = 0 ^ 0 ^ 4 = 4
```

最终结果就是 `4`，这是唯一只出现一次的数字。

### 情况2：寻找只出现一次的数字，无其他限制

如果数组中数字出现的次数没有限制，那么使用异或运算的方法可能不适用。在这种情况下，我们可以考虑使用哈希表（Hash Table）来记录每个数字出现的次数。

具体步骤如下：

1. 遍历数组，将每个元素作为键存入哈希表，值是该元素出现的次数。
2. 再次遍历哈希表，找到值为1的键，即为只出现一次的数字。

这种方法的时间复杂度和空间复杂度都是O(n)。例如，数组 `[4, 1, 2, 1, 2, 4, 3]`，构建哈希表：

```plaintext
{
  1: 2,
  2: 2,
  3: 1,
  4: 2
}
```

遍历哈希表后，我们发现数字 `3` 的出现次数为1，因此 `3` 就是唯一只出现一次的数字。

How to find the only number in an array that doesn't occur twice

在Python中，计算算法的运行时间主要有几种常用方法：

### 1. 使用 `time` 模块

最基本的方法是使用内置的`time`模块。你可以在算法执行前后分别获取时间戳，然后相减得到运行时间。

```python
import time

start_time = time.time() # 获取开始时间

# 这里放置你的算法代码
for i in range(1000000):
 pass

end_time = time.time() # 获取结束时间
elapsed_time = end_time - start_time # 计算运行时间
print(f"运行时间：{elapsed_time}秒")
```

### 2. 使用 `timeit` 模块

对于需要更精确测量时间，或者想要自动化重复运行以获取更稳定的结果的场景，可以使用`timeit`模块。这个模块专门用于小代码片段的时间测试。

```python
import timeit

code_to_test = """
a = [1, 2, 3, 4, 5]
b = [x + 1 for x in a]
"""

# timeit.repeat可以自动多次运行并返回一个列表，包含每次运行的时间
elapsed_time = min(timeit.repeat(stmt=code_to_test, repeat=3, number=1000))
print(f"运行时间：{elapsed_time}秒")
```

### 3. 使用 `datetime` 模块

这种方法类似于使用`time`模块，但使用`datetime`模块可以提供更多的日期和时间格式化选项。

```python
from datetime import datetime

start_time = datetime.now()

# 算法代码
for i in range(1000000):
 pass

end_time = datetime.now()
elapsed_time = end_time - start_time
print(f"运行时间：{elapsed_time}")
```

### 实际应用示例

假设我们需要衡量一个排序算法（比如快速排序）的性能：

```python
import time

def quick_sort(arr):
 if len(arr) <= 1:
 return arr
 pivot = arr[len(arr) // 2]
 left = [x for x in arr if x < pivot]
 middle = [x for x in arr if x == pivot]
 right = [x for x in arr if x > pivot]
 return quick_sort(left) + middle + quick_sort(right)

# 测试数据
data = [3, 6, 8, 10, 1, 2, 1]

start_time = time.time()
sorted_data = quick_sort(data)
end_time = time.time()

print(f"排序后的数据: {sorted_data}")
print(f"快速排序的运行时间：{end_time - start_time}秒")
```

通过这种方式，我们不仅可以了解算法的实际运行时间，还可以通过调整数据的大小和复杂度来进一步探索算法的性能。

How to measure running time of algorithms in python

在C++中，从容器中获取随机元素是一种常见的操作，尤其是在需要随机化算法或测试数据的场合。C++标准库中的容器如`vector`, `deque`, `list`, `set`, `map`等都可以用来存储数据，但获取它们中的随机元素的方法可能会有所不同。以下是几种常见容器的处理方法及示例：

### 1. 对于顺序容器（如`vector`, `deque`）

这些容器提供了通过下标访问元素的能力，因此获取随机元素较为简单。可以使用`<random>`头文件中的功能来生成随机下标。示例代码如下：

```cpp
#include <iostream>
#include <vector>
#include <random>

int main() {
 std::vector<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

 // 随机数生成器
 std::random_device rd;
 std::mt19937 gen(rd());
 std::uniform_int_distribution<> distrib(0, data.size() - 1);

 // 获取随机元素
 int random_element = data[distrib(gen)];
 std::cout << "Random Element: " << random_element << std::endl;

 return 0;
}
```

### 2. 对于关联容器和无序容器（如`set`, `map`, `unordered_map`）

这些容器不支持直接通过下标访问元素。如果要获取随机元素，我们可以通过获取一个随机的迭代器来实现。示例代码如下：

```cpp
#include <iostream>
#include <set>
#include <random>
#include <iterator>

int main() {
 std::set<int> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

 // 随机数生成器
 std::random_device rd;
 std::mt19937 gen(rd());
 std::uniform_int_distribution<> distrib(0, data.size() - 1);

 // 获取随机迭代器
 auto it = data.begin();
 std::advance(it, distrib(gen));

 // 输出随机元素
 std::cout << "Random Element: " << *it << std::endl;

 return 0;
}
```

### 注意事项

- 当使用随机设备和生成器时，确保你的编译器支持C++11或更高版本，因为`<random>`库是在C++11中引入的。
- 对于`set`和`map`这类容器，上述方法可能效率不高，特别是在容器元素非常多时。如果性能是关键考虑，可能需要考虑其他数据结构或算法。

通过这些示例，你可以看到如何在不同类型的C++容器中获取随机元素，并理解每种方法的适用场景和潜在的性能影响。

How to get a random element from a C++ container?

回溯算法的时间复杂度计算通常涉及分析算法的递归树。回溯算法常用于解决决策问题，如排列、组合、子集生成以及一些图论问题中的路径和匹配问题。这些问题通常有多个阶段，每个阶段都有多个选择。

要计算回溯算法的时间复杂度，我们需要考虑以下几个因素：

1. **选择的数量（分支因子）**：在递归树的每一层，有多少种不同的选择可以进行下一步操作。这个因素决定了递归树的宽度。

2. **问题求解的深度**：决策需要进行多少步才能到达终点（或无法继续进行的点）。这个因素决定了递归树的深度。

3. **剪枝效率**：在搜索过程中，能有效减少不必要路径的剪枝策略能显著减少递归树的规模，从而降低时间复杂度。

具体来说，回溯算法的时间复杂度计算示例可以参照这样的步骤：

### 1. 确定递归树的形状
首先，画出完整的递归树，这棵树表示了执行过程中所有可能的决策路径。递归树的每个节点代表算法中的一个递归调用。

### 2. 计算树的节点总数
时间复杂度和递归树的节点总数密切相关。对于完全树，节点总数可以通过分支因子和深度来计算。假设每个决策点有 `b` 个分支，且深度为 `d`，那么节点总数大致为 `O(b^d)`。

### 3. 考虑每个节点的计算复杂度
了解每个节点上的操作复杂度也很重要。例如，如果每次递归调用的复杂度为 `O(n)`，则总的时间复杂度将是节点总数乘以每个节点的复杂度。

### 4. 考虑剪枝策略
剪枝可以减少需要探索的节点数。例如，如果通过剪枝，我们可以排除一半的分支，则递归树的实际大小将大幅减少。

**例子：N皇后问题**

在 N 皇后问题中，我们要在 N×N 的棋盘上放置 N 个皇后，使任何两个皇后都不在同一行、同一列或同一斜线上。用回溯算法解决时：

- **选择的数量**: 最坏情况下，我们对棋盘上的每一列都有 N 个选择（放置皇后的位置）。
- **问题的深度**: 深度为 N，因为我们需要放置 N 个皇后。
- **剪枝效率**: 通过检查攻击线，我们可以在放置每个皇后时剪枝，从而减少递归树的大小。

最坏情况下，时间复杂度为 `O(N!)`，但由于剪枝的存在，实际的时间复杂度通常远低于这个上界。

计算回溯算法的时间复杂度是一项估算的工作，通常取决于问题的具体情况和剪枝策略的有效性。

How to calculate time complexity of backtracking algorithm?

首先，我需要明确“具有一定性质”的具体含义。这个性质可能是数学上的一个特性，比如说素数、完全数、回文数等。比如，如果我们要找出在大整数A和B之间（包括A和B）的所有素数，我们可以使用以下步骤：

1. **验证输入**：确认A和B是整数，且A小于等于B。

2. **确定性质**：明确“具有一定性质”的含义。例如，如果性质是“素数”，则定义一个函数来检查一个给定的数是否是素数。

3. **筛选算法**：选择一个适合的算法来筛选具有该性质的数字。对于素数，可以使用埃拉托斯特尼筛法（Sieve of Eratosthenes）或更高效的筛法，如Atkin筛法。

4. **迭代与检查**：从A开始迭代到B，对每个数使用第2步定义的函数来检查它是否具有该性质。

5. **收集结果**：将检查通过的数收集起来。

6. **输出结果**：将所有符合条件的数以列表或其他形式输出。

举一个具体的例子，比如我们需要找出大整数A = 10^9 和 B = 10^9 + 50 之间所有的素数。

我们可以编写一个检查素数的函数，然后对于每个数x，从A到B，用这个函数检查x是否为素数。如果是，则将其添加到结果列表中。最后，输出这个结果列表。

这只是一个简化的描述，实际的实现中，我们可能需要考虑性能优化，比如减少不必要的除法操作，使用高效的数据结构等。如果具体性质不同，算法的选择和实现也将不同。如果您能提供更具体的性质描述，我可以提供更详尽的算法描述和可能的代码实现。

How to count integers between large A and B with a certain property?

计算两个矩形重叠部分的面积是计算重叠度的常用方法。以下是计算两个矩形重叠度的步骤：

### 1. 理解矩形的表示
通常情况下，一个矩形可以由它的左下角和右上角的坐标来表示，假设有两个矩形 A 和 B，它们可以表示为：
- 矩形 A: (Ax1, Ay1) 到 (Ax2, Ay2)，其中 (Ax1, Ay1) 是左下角坐标，(Ax2, Ay2) 是右上角坐标。
- 矩形 B: (Bx1, By1) 到 (Bx2, By2)，同样的表示方法。

### 2. 计算重叠部分的坐标
重叠部分矩形的左下角坐标由矩形 A 和 B 左下角的最大横纵坐标组成，右上角坐标由矩形 A 和 B 右上角的最小横纵坐标组成。即：
- 重叠部分左下角坐标：(max(Ax1, Bx1), max(Ay1, By1))
- 重叠部分右上角坐标：(min(Ax2, Bx2), min(Ay2, By2))

### 3. 检查矩形是否重叠
只有当重叠矩形的两个坐标都是合法的，即左下角的横纵坐标都小于或等于右上角的横纵坐标时，矩形才重叠。可以表示为：
- 如果 max(Ax1, Bx1) < min(Ax2, Bx2) 且 max(Ay1, By1) < min(Ay2, By2)，则矩形重叠。

### 4. 计算重叠部分的面积
如果矩形重叠，重叠部分的面积可以通过下面的公式计算：
- 重叠面积 = (min(Ax2, Bx2) - max(Ax1, Bx1)) * (min(Ay2, By2) - max(Ay1, By1))

### 5. 计算重叠度
重叠度通常表示为重叠面积与两个矩形面积之和的比例。可以表示为：
- 重叠度 = 重叠面积 / (面积A + 面积B - 重叠面积)

其中，面积 A 和面积 B 分别为：
- 面积 A = (Ax2 - Ax1) * (Ay2 - Ay1)
- 面积 B = (Bx2 - Bx1) * (By2 - By1)

### 示例
假设有两个矩形 A 和 B 的坐标分别为：
- A: (1, 1) 到 (3, 4)
- B: (2, 3) 到 (5, 6)

1. 计算重叠部分的坐标：
 - 左下角坐标：(max(1, 2), max(1, 3)) = (2, 3)
 - 右上角坐标：(min(3, 5), min(4, 6)) = (3, 4)
2. 判断是否重叠：
 - 因为 2 < 3 且 3 < 4，所以矩形 A 和 B 重叠。
3. 计算重叠面积：
 - 重叠面积 = (3 - 2) * (4 - 3) = 1
4. 分别计算两个矩形的面积：
 - 面积 A = (3 - 1) * (4 - 1) = 6
 - 面积 B = (5 - 2) * (6 - 3) = 9
5. 计算重叠度：
 - 重叠度 = 1 / (6 + 9 - 1) = 1 / 14 ≈ 0.0714 或 7.14%

因此，矩形 A 和 B 的重叠度大约为 7.14%。

How much do two rectangles overlap?

文档差异算法通常用于比较两个文本文件的内容差异，并且可以用来实现版本控制系统中的差异检测功能。实现文档差异算法的一种常见方法是使用“最长公共子序列”（Longest Common Subsequence, LCS）算法。下面我会详细描述LCS算法的工作原理以及如何用它来实现文档差异。

### 最长公共子序列（LCS）算法

LCS算法用于查找两个序列（在这个场景中是两个文档中的字符串）的最长公共子序列，这个子序列不需要在原字符串中连续，但必须保持原有的顺序。例如，对于字符串"ABCD"和"ACBD"，它们的一个最长公共子序列是"ABD"。

### LCS算法实现步骤

1. **初始化二维数组**：创建一个(m+1) x (n+1)的二维数组`dp`，其中m和n分别是两个文档的长度。`dp[i][j]`将会存储文档1的前i个字符和文档2的前j个字符的最长公共子序列的长度。

2. **填充数组**：
   - 如果`A[i] == B[j]`（文档1的第i个字符和文档2的第j个字符相同），则`dp[i][j] = dp[i-1][j-1] + 1`。
   - 如果`A[i] != B[j]`，则`dp[i][j] = max(dp[i-1][j], dp[i][j-1])`。

3. **从数组构建LCS**：从`dp[m][n]`开始，反向遍历数组，根据`dp`数组的值来确定LCS的字符。

### 找出差异

一旦我们有了LCS，就可以通过以下步骤来确定两个文档的差异：

1. **遍历原始文档**：从头开始遍历两个文档，与LCS进行比较。
2. **标识差异**：如果当前字符不在LCS中，那么它是一处差异。如果它在文档1中而不在文档2中，那么它是被删除的部分；反之，它是被添加的部分。

### 例子

举个例子，我们要比较两个字符串：

- Document 1: `ABCDFG`
- Document 2: `ABEDFHG`

首先，我们按照上述方法计算LCS，它是`ABDFG`。然后，我们逐字符遍历每个文档，与LCS比较，得到以下差异：

- 在Document 1中，`C`不在LCS中，表示它在Document 2中被删除或修改。
- 在Document 2中，`E`和`H`不在LCS中，表示它们是新添加的字符。

最终，我们可以生成一个差异报告，告诉用户如何从Document 1修改到Document 2。

### 优化和替代算法

- LCS算法的时间复杂度是O(m*n)，空间复杂度也是O(m*n)，对于大文件来说可能会很慢。可以通过只存储当前行和上一行的动态规划数组来减少空间复杂度。
- 对于更高效的差异检测，可以使用其他算法如 Myers' diff algorithm，它在实践中比LCS更快，特别是在处理大型文件时。
- 现代版本控制系统如 `git` 使用的是一种基于 Myers 算法的变体，进行了进一步的优化和调整，以处理实际应用中的各种情况。

在实际应用中，文档差异工具通常还会包含诸如忽略空白差异、格式化差异展示等功能。这些工具也会有一些交互式界面的特性以方便用户理解和应用这些差异。

How do document diff algorithms work?

### 对于如何找到最大生成树的问题

在图论中，生成树是一个无环的连通子图，并包括图中所有的顶点。最大生成树则是指边的权值和最大的生成树。寻找最大生成树的问题经常出现在网络设计、电路设计等领域。解决这个问题的常用算法有两种：普里姆算法（Prim's Algorithm）和克鲁斯卡尔算法（Kruskal's Algorithm）。这两种算法通常用于寻找最小生成树，但是通过对权值的处理，同样可以用来寻找最大生成树。

#### 普里姆算法

普里姆算法的基本思想是从图中的某一顶点开始，逐渐长出一棵包含所有顶点的生成树。每次迭代添加与当前生成树连接的最大权值的边。

1. 选取图中的任意一个顶点作为开始。
2. 找到连接当前生成树和图中剩余顶点的最大权值的边。
3. 将这条边以及其对应的顶点加入到当前生成树中。
4. 重复步骤2和3，直到所有的顶点都被包含在生成树中。

#### 克鲁斯卡尔算法

克鲁斯卡尔算法的基本思想是将图中的所有边按照权值从大到小进行排序，然后按照顺序选取边，构造最大生成树。

1. 将图中所有的边按照权值从大到小进行排序。
2. 初始化只包含所有顶点但不包含任何边的森林（每个顶点自成一个连通分量）。
3. 依序考虑每一条边，如果这条边连接的两个顶点属于不同的连通分量，则添加这条边，并合并相应的连通分量。
4. 重复步骤3，直到所有的顶点都在同一个连通分量中，即构成了一个生成树。

#### 示例

假设我们有一个图，它包含4个顶点和5条边，边的权值分别是：

- A-B: 7
- A-D: 6
- B-C: 9
- B-D: 8
- C-D: 5

使用克鲁斯卡尔算法寻找最大生成树的步骤如下：

1. 对边进行排序：B-C(9), B-D(8), A-B(7), A-D(6), C-D(5)。
2. 从权值最大的边开始添加：首先添加B-C。
3. 接着添加B-D，这时我们的生成树中包含了顶点B, C, D。
4. 然后添加A-B，此时所有顶点都包含在生成树中。
5. 此时，最大生成树包含的边为：B-C, B-D, A-B，总权值为24。

使用普里姆算法也可以获得同样的最大生成树，只不过迭代的过程有所不同。

这两种算法，无论是寻找最大生成树还是最小生成树，关键都在于如何定义和比较边的权值。通过对权值的相反数处理，我们可以利用这些算法找到最大生成树。

How to find maximum spanning tree?

推荐系统是一种信息过滤系统，它的目的是预测用户可能感兴趣的物品或内容。它们在众多应用中发挥作用，从电子商务网站推荐产品，到社交媒体平台推荐内容，再到流媒体服务推荐电影和音乐。推荐系统通常利用以下几种主要技术：协同过滤、内容基过滤和混合方法。

**协同过滤**是一种利用用户的历史行为数据来预测他们可能喜欢的项目的方法。它又可以细分为用户基和物品基推荐。

- **用户基协同过滤**侧重于找到与目标用户拥有相似品味的用户，并推荐那些相似用户喜欢的物品。例如，如果用户A和用户B在过去喜欢了很多相同的电影，系统会认为他们有相似的口味，因此会向用户A推荐用户B喜欢的电影，反之亦然。

- **物品基协同过滤**则是基于物品之间的相似度进行推荐。如果电影X和电影Y被很多用户同时喜欢，那么喜欢电影X的用户可能会收到电影Y的推荐。

**内容基过滤**侧重于物品本身的特性，比如描述、关键词、类别等。这种方法会分析用户过去喜欢的内容的特征，并推荐具有相似特征的新内容。举个例子，如果一个用户经常观看科幻电影，系统可能会发现这一趋势，并推荐其他具有相似风格、主题或导演的科幻电影。

**混合方法**将协同过滤和内容基过滤相结合，以克服单一方法的限制。例如，Netflix的推荐算法就采用了混合方法。这种方式可以通过整合不同类型的数据和算法来提高推荐的准确性和多样性。

除了这些传统技术，现代推荐系统还可能利用复杂的机器学习模型，包括基于矩阵分解的模型、深度学习方法等。这些模型可以从大量的数据中学习用户行为的复杂模式，并做出更精确的个性化推荐。

例如，我曾参与开发一个个性化新闻推荐系统，我们使用了混合推荐方法。系统分析了用户阅读历史中的文章属性，如主题、作者和阅读时间长度，并结合了用户与其他类似阅读喜好的用户的交互数据。这样，我们不仅能推荐内容上和用户历史兴趣相符的新闻，还能发现其他相似用户喜欢的内容，进而提供更广泛的、个性化的新闻推荐。

How do recommendation systems work?

要在Java中高效且安全地生成随机字母数字字符串，我们可以使用`java.security.SecureRandom`类，因为它提供了一个加密强随机数生成器 (RNG)。以下是一个生成安全的随机字母数字字符串的步骤和代码示例：

### 步骤：

1. **创建`SecureRandom`实例**：`SecureRandom`实例应该被重用而不是每次需要时都被创建，以提高效率并减少资源消耗。
 
2. **定义一个字符集**：创建一个包含所有可能字符的字符串，例如所有大写和小写字母以及数字。

3. **随机选择字符**：对于所需的随机字符串长度，从字符集中随机选取字符。

4. **构建随机字符串**：使用`StringBuilder`或类似工具来逐步构建最终的随机字符串。

### 代码示例：

```java
import java.security.SecureRandom;

public class SecureRandomStringGenerator {

 // 定义可能的字符集
 private static final String ALPHA_NUMERIC_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 private static final SecureRandom random = new SecureRandom();

 public static String generateRandomAlphaNumeric(int length) {
 StringBuilder builder = new StringBuilder(length);

 for (int i = 0; i < length; i++) {
 // 随机选择字符
 int randomIndex = random.nextInt(ALPHA_NUMERIC_STRING.length());
 builder.append(ALPHA_NUMERIC_STRING.charAt(randomIndex));
 }

 return builder.toString();
 }

 public static void main(String[] args) {
 // 生成一个16位长度的随机字符串
 String secureRandomString = generateRandomAlphaNumeric(16);
 System.out.println("Secure Random String: " + secureRandomString);
 }
}
```

### 使用示例说明：

在上述代码中，`generateRandomAlphaNumeric`方法接受生成字符串的长度作为参数。在方法内部，我们创建了一个`StringBuilder`来高效地构建字符串，并利用`SecureRandom`实例从定义好的字符集中随机选择字符。

使用`SecureRandom`是生成随机字母数字字符串的安全做法，因为它足够强大以对抗暴力破解和预测攻击，这对于密码、会话标识符或其他敏感信息的生成至关重要。此外，重用`SecureRandom`实例和使用`StringBuilder`可以提高代码的效率。

How to generate a secure random alphanumeric string in Java efficiently?

`use strict`是JavaScript中的一个指令，用于开启严格模式。它于ECMAScript 5引入，主要有以下几个作用：

1. **消除Javascript语法的一些不严谨之处**：严格模式下，一些原本不会报错的编码习惯会抛出错误。例如，给未声明的变量赋值会抛出一个错误。

   ```javascript
   'use strict';
   undeclaredVariable = 1; // ReferenceError: undeclaredVariable is not defined
   ```

2. **消除一些静默错误**：在非严格模式中，一些类型错误会被静默忽略。但在严格模式下，这些错误会被抛出，便于开发者发现并修复。

   ```javascript
   'use strict';
   false.true = '';         // TypeError: Cannot create property 'true' on boolean 'false'
   (14).sailing = 'home';   // TypeError: Cannot create property 'sailing' on number '14'
   ```

3. **提高编译器效率，增加运行速度**：因为严格模式规避了一些语言特性，JavaScript引擎可以更容易地进行代码优化。

4. **禁用了一些语言上容易混淆的特性**：
   - 不能使用`with`语句，因为它会改变作用域并导致优化问题。
   - 为对象的不可写属性赋值，为对象的只读属性赋值，为对象的不可扩展属性添加新属性，为禁止扩展的对象添加新属性，删除不可删除的属性等行为会抛出错误。
   - 函数的参数不能有同名属性，否则也会抛出错误。

   ```javascript
   'use strict';
   function duplicateParam(p, p) { // SyntaxError: Duplicate parameter name not allowed in this context
       return p + p;
   }
   ```

5. **为将来新版本的JavaScript做好准备**：严格模式禁用了一些在未来语言标准中可能会被赋予新意义的语法，从而可以减少向后兼容问题。

如何应用`use strict`：
- 可以应用于整个脚本，只需在脚本顶部添加`'use strict';`。
- 也可以应用于单个函数，将它放在函数体的顶部。

```javascript
function myFunction() {
  'use strict';
  // Function-level strict mode syntax
  var v = "Hi! I'm a strict mode script!";
}
```

使用严格模式有助于提升代码质量和可维护性，并且使得JavaScript代码更加安全。不过，也需要注意在混合使用严格模式和非严格模式代码时可能会遇到的兼容性问题。

This to me sounds like a reasonably common problem that junior to intermediate developers tend to face at some point: they either don't know or don't trust the contracts they are participating in and defensively overcheck for nulls. Additionally, when writing their own code, they tend to rely on returning nulls to indicate something thus requiring the caller to check for nulls.
To put this another way, there are two instances where null checking comes up:
<ol>
<li>Where null is a valid response in terms of the contract; and
</li>
<li>Where it isn't a valid response.
</li>
</ol>
(2) is easy. As of Java 1.7 you can use <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Objects.html#requireNonNull(T)" rel="noreferrer"><code>Objects.requireNonNull(foo)</code></a>. (If you are stuck with a previous version then <a href="https://docs.oracle.com/javase/7/docs/technotes/guides/language/assert.html" rel="noreferrer"><code>assert</code>ions</a> may be a good alternative.)
"Proper" usage of this method would be like below. The method returns the object passed into it and throws a <code>NullPointerException</code> if the object is null. This means that the returned value is always non-null. The method is primarily intended for validating parameters.
<pre class="lang-java s-code-block"><code class="hljs language-java">public Foo(Bar bar) {
 this.bar = Objects.requireNonNull(bar);
}
</code></pre>
It can also be used like an <code>assert</code>ion though since it throws an exception if the object is null. In both uses, a message can be added which will be shown in the exception. Below is using it like an assertion and providing a message.
<pre class="lang-java s-code-block"><code class="hljs language-java">Objects.requireNonNull(someobject, "if someobject is null then something is wrong");
someobject.doCalc();
</code></pre>
Generally throwing a specific exception like <code>NullPointerException</code> when a value is null but shouldn't be is favorable to throwing a more general exception like <code>AssertionError</code>. This is the approach the Java library takes; favoring <code>NullPointerException</code> over <code>IllegalArgumentException</code> when an argument is not allowed to be null.
(1) is a little harder. If you have no control over the code you're calling then you're stuck. If null is a valid response, you have to check for it.
If it's code that you do control, however (and this is often the case), then it's a different story. Avoid using nulls as a response. With methods that return collections, it's easy: return empty collections (or arrays) instead of nulls pretty much all the time.
With non-collections it might be harder. Consider this as an example: if you have these interfaces:
<pre class="lang-java s-code-block"><code class="hljs language-java">public interface Action {
 void doSomething();
}

public interface Parser {
 Action findAction(String userInput);
}
</code></pre>
where Parser takes raw user input and finds something to do, perhaps if you're implementing a command line interface for something. Now you might make the contract that it returns null if there's no appropriate action. That leads the null checking you're talking about.
An alternative solution is to never return null and instead use the <a href="https://en.wikipedia.org/wiki/Null_Object_pattern" rel="noreferrer">Null Object pattern</a>:
<pre class="lang-java s-code-block"><code class="hljs language-java">public class MyParser implements Parser {
 private static Action DO_NOTHING = new Action() {
 public void doSomething() { /* do nothing */ }
 };

 public Action findAction(String userInput) {
 // ...
 if ( /* we can't find any actions */ ) {
 return DO_NOTHING;
 }
 }
}
</code></pre>
Compare:
<pre class="lang-java s-code-block"><code class="hljs language-java">Parser parser = ParserFactory.getParser();
if (parser == null) {
 // now what?
 // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
 // do nothing
} else {
 action.doSomething();
}
</code></pre>
to
<pre class="lang-java s-code-block"><code class="hljs language-java">ParserFactory.getParser().findAction(someInput).doSomething();
</code></pre>
which is a much better design because it leads to more concise code.
That said, perhaps it is entirely appropriate for the findAction() method to throw an Exception with a meaningful error message -- especially in this case where you are relying on user input. It would be much better for the findAction method to throw an Exception than for the calling method to blow up with a simple NullPointerException with no explanation.
<pre class="lang-java s-code-block"><code class="hljs language-java">try {
 ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
 userConsole.err(anfe.getMessage());
}
</code></pre>
Or if you think the try/catch mechanism is too ugly, rather than Do Nothing your default action should provide feedback to the user.
<pre class="lang-java s-code-block"><code class="hljs language-java">public Action findAction(final String userInput) {
 /* Code to return requested Action if found */
 return new Action() {
 public void doSomething() {
 userConsole.err("Action not found: " + userInput);
 }
 }
}
</code></pre>

If you use (or planning to use) a Java IDE like <a href="https://www.jetbrains.com/idea/" rel="noreferrer">JetBrains IntelliJ IDEA</a>, <a href="https://www.eclipse.org/" rel="noreferrer">Eclipse</a> or <a href="https://netbeans.org/" rel="noreferrer">Netbeans</a> or a tool like findbugs then you can use annotations to solve this problem.

Basically, you've got <code>@Nullable</code> and <code>@NotNull</code>.

You can use in method and parameters, like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">@NotNull public static String helloWorld() {
 return "Hello World";
}
</code></pre>

or

<pre class="lang-java s-code-block"><code class="hljs language-java">@Nullable public static String helloWorld() {
 return "Hello World";
}
</code></pre>

The second example won't compile (in IntelliJ IDEA).

When you use the first <code>helloWorld()</code> function in another piece of code:

<pre class="lang-java s-code-block"><code class="hljs language-java">public static void main(String[] args)
{
 String result = helloWorld();
 if(result != null) {
 System.out.println(result);
 }
}
</code></pre>

Now the IntelliJ IDEA compiler will tell you that the check is useless, since the <code>helloWorld()</code> function won't return <code>null</code>, ever.

Using parameter

<pre class="lang-java s-code-block"><code class="hljs language-java">void someMethod(@NotNull someParameter) { }
</code></pre>

if you write something like:

<pre class="lang-java s-code-block"><code class="hljs language-java">someMethod(null);
</code></pre>

This won't compile.

Last example using <code>@Nullable</code>

<pre class="lang-java s-code-block"><code class="hljs language-java">@Nullable iWantToDestroyEverything() { return null; }
</code></pre>

Doing this

<pre class="lang-java s-code-block"><code class="hljs language-java">iWantToDestroyEverything().something();
</code></pre>

And you can be sure that this won't happen. :)

It's a nice way to let the compiler check something more than it usually does and to enforce your contracts to be stronger. Unfortunately, it's not supported by all the compilers.

In IntelliJ IDEA 10.5 and on, they added support for any other <code>@Nullable</code> <code>@NotNull</code> implementations.

See blog post <a href="https://blog.jetbrains.com/idea/2011/03/more-flexible-and-configurable-nullublenotnull-annotations/" rel="noreferrer">More flexible and configurable @Nullable/@NotNull annotations</a>.

<h2>If null-values are not allowed</h2>

If your method is called externally, start with something like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">public void method(Object object) {
 if (object == null) {
 throw new IllegalArgumentException("...");
 }
</code></pre>

Then, in the rest of that method, you'll know that <code>object</code> is not null.

If it is an internal method (not part of an API), just document that it cannot be null, and that's it.

Example:

<pre class="lang-java s-code-block"><code class="hljs language-java">public String getFirst3Chars(String text) {
 return text.subString(0, 3);
}
</code></pre>

However, if your method just passes the value on, and the next method passes it on etc. it could get problematic. In that case you may want to check the argument as above.

<h2>If null is allowed</h2>

This really depends. If find that I often do something like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">if (object == null) {
 // something
} else {
 // something else
}
</code></pre>

So I branch, and do two completely different things. There is no ugly code snippet, because I really need to do two different things depending on the data. For example, should I work on the input, or should I calculate a good default value?

<hr>

It's actually rare for me to use the idiom "<code>if (object != null &amp;&amp; ...</code>".

It may be easier to give you examples, if you show examples of where you typically use the idiom.

Wow, I almost hate to add another answer when we have 57 different ways to recommend the <code>NullObject pattern</code>, but I think that some people interested in this question may like to know that there is a proposal on the table for Java 7 to add <a href="http://tech.puredanger.com/java7/#null" rel="noreferrer">"null-safe handling"</a>—a streamlined syntax for if-not-equal-null logic.

The example given by Alex Miller looks like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">public String getPostcode(Person person) { 
 return person?.getAddress()?.getPostcode(); 
} 
</code></pre>

The <code>?.</code> means only de-reference the left identifier if it is not null, otherwise evaluate the remainder of the expression as <code>null</code>. Some people, like Java Posse member Dick Wall and the <a href="http://blog.joda.org/2008/12/jdk-7-language-changes-devoxx-votes_3751.html" rel="noreferrer">voters at Devoxx</a> really love this proposal, but there is opposition too, on the grounds that it will actually encourage more use of <code>null</code> as a sentinel value.

<hr>

Update: An <a href="http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000047.html" rel="noreferrer">official proposal</a> for a null-safe operator in Java 7 has been submitted under <a href="http://openjdk.java.net/projects/coin/" rel="noreferrer">Project Coin.</a> The syntax is a little different than the example above, but it's the same notion.

<hr>

Update: The null-safe operator proposal didn't make it into Project Coin. So, you won't be seeing this syntax in Java 7.

<h2>If undefined values are not permitted:</h2>

You might configure your IDE to warn you about potential null dereferencing. E.g. in Eclipse, see Preferences &gt; Java &gt; Compiler &gt; Errors/Warnings/Null analysis.

<h2>If undefined values are permitted:</h2>

If you want to define a new API where undefined values make sense, use the <a href="http://www.codecommit.com/blog/scala/the-option-pattern" rel="noreferrer">Option Pattern</a> (may be familiar from functional languages). It has the following advantages:

<ul>
<li>It is stated explicitly in the API whether an input or output exists or not.</li>
<li>The compiler forces you to handle the "undefined" case.</li>
<li><a href="http://james-iry.blogspot.com/2007/08/martians-vs-monads-null-considered.html" rel="noreferrer">Option is a monad</a>, so there is no need for verbose null checking, just use map/foreach/getOrElse or a similar combinator to safely use the value <a href="http://blog.tackley.net/2010/09/option-in-scala-vs-null-in-java.html" rel="noreferrer">(example)</a>.</li>
</ul>

Java 8 has a built-in <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Optional.html" rel="noreferrer"><code>Optional</code></a> class (recommended); for earlier versions, there are library alternatives, for example <a href="http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained" rel="noreferrer">Guava</a>'s <a href="https://google.github.io/guava/releases/19.0/api/docs/com/google/common/base/Optional.html" rel="noreferrer"><code>Optional</code></a> or <a href="http://code.google.com/p/functionaljava" rel="noreferrer">FunctionalJava</a>'s <a href="http://www.functionaljava.org/javadoc/4.4/functionaljava/fj/data/Option.html" rel="noreferrer"><code>Option</code></a>. But like many functional-style patterns, using Option in Java (even 8) results in quite some boilerplate, which you can reduce using a less verbose JVM language, e.g. Scala or Xtend.

If you have to deal with an API which might return nulls, you can't do much in Java. Xtend and Groovy have the <a href="https://www.eclipse.org/xtend/documentation.html#operators" rel="noreferrer">Elvis operator</a> <code>?:</code> and the <a href="https://www.eclipse.org/xtend/documentation.html#nullSafeFeatureCalls" rel="noreferrer">null-safe dereference operator</a> <code>?.</code>, but note that this returns null in case of a null reference, so it just "defers" the proper handling of null.

Only for this situation -

Not checking if a variable is null before invoking an equals method (a string compare example below):

<pre class="lang-java s-code-block"><code class="hljs language-java">if ( foo.equals("bar") ) {
 // ...
}
</code></pre>

will result in a <code>NullPointerException</code> if <code>foo</code> doesn't exist.

You can avoid that if you compare your <code>String</code>s like this:

<pre class="lang-java s-code-block"><code class="hljs language-java">if ( "bar".equals(foo) ) {
 // ...
}
</code></pre>

Java 8 introduced the <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html" rel="nofollow noreferrer"><code>java.util.Optional</code></a> class that addresses some of the problem. One can at least say that it improves the readability of the code, and in the case of public APIs make the contract clearer to the client developer.
They work as follows:
An optional object for a given type (<code>Fruit</code>) is created as the return type of a method. It can be empty or contain a <code>Fruit</code> object:
<pre class="lang-java s-code-block"><code class="hljs language-java">public static Optional&lt;Fruit&gt; find(String name, List&lt;Fruit&gt; fruits) {
 for (Fruit fruit : fruits) {
 if (fruit.getName().equals(name)) {
 return Optional.of(fruit);
 }
 }
 return Optional.empty();
}
</code></pre>
Now look at this code where we search a list of <code>Fruit</code> (<code>fruits</code>) for a given Fruit instance:
<pre class="lang-java s-code-block"><code class="hljs language-java">Optional&lt;Fruit&gt; found = find("lemon", fruits);
if (found.isPresent()) {
 Fruit fruit = found.get(); // Prefer found.orElseThrow() in Java 9+
 String name = fruit.getName();
}
</code></pre>
You can use the <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#map(java.util.function.Function)" rel="nofollow noreferrer"><code>map</code></a> method to perform a computation on — or extract a value from —&nbsp;an optional object. The <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#orElse(T)" rel="nofollow noreferrer"><code>orElse</code></a> method lets you provide a fallback for missing values, converting an <code>Optional</code> to a non-nullable value.
<pre class="lang-java s-code-block"><code class="hljs language-java">String nameOrFallback = find("lemon", fruits)
 .map(f -&gt; f.getName())
 .orElse("empty-name");
</code></pre>
Of course, handling the null/empty value is still necessary, but at least the developer is conscious that the value might be empty and the risk of forgetting to check is limited.
In an API built from scratch using <code>Optional</code> whenever a return value might be empty, and returning a plain object only when it cannot be <code>null</code> (convention), the client code might abandon null checks on simple object return values.
Of course <code>Optional</code> could also be used as a method argument, perhaps a better way to indicate optional arguments than 5 or 10 overloading methods in some cases. Be aware that using it in this manner is <a href="https://stackoverflow.com/a/26328555/1108305">recommended against</a> by Java Language Architect Brian Goetz: "You should almost never use <code>Optional</code> as […] a method parameter."
<code>Optional</code> offers other convenient methods, such as <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#orElseGet(java.util.function.Supplier)" rel="nofollow noreferrer"><code>orElseGet</code></a> that calculates a default value only if the <code>Optional</code> is empty, and <a href="https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Optional.html#ifPresent(java.util.function.Consumer)" rel="nofollow noreferrer"><code>ifPresent</code></a> that peforms an operation only if the <code>Optional</code> is non-empty, both of which work with <a href="https://en.wikipedia.org/wiki/Anonymous_function" rel="nofollow noreferrer">lambda expressions</a>.
I invite you to read this article (the main source for writing this answer) in which the problematic behavior of <code>NullPointerException</code> (and in general null pointer) and the (partial) solution brought by <code>Optional</code> are well explained: <a href="http://java.dzone.com/articles/java-optional-objects" rel="nofollow noreferrer">Java Optional Objects</a>.

Depending on what kind of objects you are checking you may be able to use some of the classes in the apache commons such as: <a href="http://commons.apache.org/lang/" rel="noreferrer">apache commons lang</a> and <a href="http://commons.apache.org/collections/" rel="noreferrer">apache commons collections</a>

Example: 

<pre class="lang-java s-code-block"><code class="hljs language-java">String foo;
...
if( StringUtils.isBlank( foo ) ) {
 ///do something
}
</code></pre>

or (depending on what you need to check):

<pre class="lang-java s-code-block"><code class="hljs language-java">String foo;
...
if( StringUtils.isEmpty( foo ) ) {
 ///do something
}
</code></pre>

The StringUtils class is only one of many; there are quite a few good classes in the commons that do null safe manipulation.

Here follows an example of how you can use null vallidation in JAVA when you include apache library(commons-lang-2.4.jar)

<pre class="lang-java s-code-block"><code class="hljs language-java">public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
 Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
 return read(new StringReader(xml), true, validationEventHandler);
}
</code></pre>

And if you are using Spring, Spring also has the same functionality in its package, see library(spring-2.4.6.jar) 

Example on how to use this static classf from spring(org.springframework.util.Assert)

<pre class="lang-java s-code-block"><code class="hljs language-java">Assert.notNull(validationEventHandler,"ValidationHandler not Injected");
</code></pre>

<ul>
<li>If you consider an object should not be null (or it is a bug) use an assert.</li>
<li>If your method doesn't accept null params say it in the javadoc and use an assert.</li>
</ul>

You have to check for object != null only if you want to handle the case where the object may be null...

There is a proposal to add new annotations in Java7 to help with null / notnull params:
<a href="http://tech.puredanger.com/java7/#jsr308" rel="noreferrer">http://tech.puredanger.com/java7/#jsr308</a>

I'm a fan of "fail fast" code. Ask yourself - are you doing something useful in the case where the parameter is null? If you don't have a clear answer for what your code should do in that case... i.e. - it should never be null in the first place, then ignore it and allow a <code>NullPointerException</code> to be thrown. The calling code will make just as much sense of an NPE as it would an <code>IllegalArgumentException</code>, but it'll be easier for the developer to debug and understand what went wrong if an NPE is thrown rather than your code attempting to execute some other unexpected contingency logic - which ultimately results in the application failing anyway.

In Java 1.7 or later, the standard way to do this is as follows:

<pre class="lang-java s-code-block"><code class="hljs language-java">import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);
</code></pre>

See <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ThreadLocalRandom.html#nextInt(int,int)" rel="noreferrer">the relevant JavaDoc</a>. This approach has the advantage of not needing to explicitly initialize a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html" rel="noreferrer">java.util.Random</a> instance, which can be a source of confusion and error if used inappropriately.

However, conversely there is no way to explicitly set the seed so it can be difficult to reproduce results in situations where that is useful such as testing or saving game states or similar. In those situations, the pre-Java 1.7 technique shown below can be used.

Before Java 1.7, the standard way to do this is as follows:

<pre class="lang-java s-code-block"><code class="hljs language-java">import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * &lt;code&gt;Integer.MAX_VALUE - 1&lt;/code&gt;.
 *
 * @param min Minimum value
 * @param max Maximum value. Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

 // NOTE: This will (intentionally) not run as written so that folks
 // copy-pasting have to think about how to initialize their
 // Random instance. Initialization of the Random instance is outside
 // the main scope of the question, but some decent options are to have
 // a field that is initialized once and then re-used as needed or to
 // use ThreadLocalRandom (if using at least Java 1.7).
 // 
 // In particular, do NOT do 'Random rand = new Random()' here or you
 // will get not very good / not very random results.
 Random rand;

 // nextInt is normally exclusive of the top value,
 // so add 1 to make it inclusive
 int randomNum = rand.nextInt((max - min) + 1) + min;

 return randomNum;
}
</code></pre>

See <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html#nextInt(int)" rel="noreferrer">the relevant JavaDoc</a>. In practice, the <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Random.html" rel="noreferrer">java.util.Random</a> class is often preferable to <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html#random()" rel="noreferrer">java.lang.Math.random()</a>.

In particular, there is no need to reinvent the random integer generation wheel when there is a straightforward API within the standard library to accomplish the task.

Note that this approach is more biased and less efficient than a <code>nextInt</code> approach, <a href="https://stackoverflow.com/a/738651/360211">https://stackoverflow.com/a/738651/360211</a>

One standard pattern for accomplishing this is:

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (int)(Math.random() * ((Max - Min) + 1))
</code></pre>

The <a href="http://en.wikipedia.org/wiki/Java_%28programming_language%29" rel="noreferrer">Java</a> Math library function Math.random() generates a double value in the range <code>[0,1)</code>. Notice this range does not include the 1.

In order to get a specific range of values first, you need to multiply by the magnitude of the range of values you want covered. 

<pre class="lang-java s-code-block"><code class="hljs language-java">Math.random() * ( Max - Min )
</code></pre>

This returns a value in the range <code>[0,Max-Min)</code>, where 'Max-Min' is not included.

For example, if you want <code>[5,10)</code>, you need to cover five integer values so you use

<pre class="lang-java s-code-block"><code class="hljs language-java">Math.random() * 5
</code></pre>

This would return a value in the range <code>[0,5)</code>, where 5 is not included.

Now you need to shift this range up to the range that you are targeting. You do this by adding the Min value.

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (Math.random() * (Max - Min))
</code></pre>

You now will get a value in the range <code>[Min,Max)</code>. Following our example, that means <code>[5,10)</code>:

<pre class="lang-java s-code-block"><code class="hljs language-java">5 + (Math.random() * (10 - 5))
</code></pre>

But, this still doesn't include <code>Max</code> and you are getting a double value. In order to get the <code>Max</code> value included, you need to add 1 to your range parameter <code>(Max - Min)</code> and then truncate the decimal part by casting to an int. This is accomplished via:

<pre class="lang-java s-code-block"><code class="hljs language-java">Min + (int)(Math.random() * ((Max - Min) + 1))
</code></pre>

And there you have it. A random integer value in the range <code>[Min,Max]</code>, or per the example <code>[5,10]</code>:

<pre class="lang-java s-code-block"><code class="hljs language-java">5 + (int)(Math.random() * ((10 - 5) + 1))
</code></pre>

Use:

<pre class="lang-java s-code-block"><code class="hljs language-java">Random ran = new Random();
int x = ran.nextInt(6) + 5;
</code></pre>

The integer <code>x</code> is now the random number that has a possible outcome of <code>5-10</code>.

Use:
<pre class="lang-java s-code-block"><code class="hljs language-java">minValue + rn.nextInt(maxValue - minValue + 1)
</code></pre>

With <a href="https://www.oracle.com/java/technologies/java8.html" rel="noreferrer">Java 8</a> they introduced the method <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Random.html#ints-int-int-" rel="noreferrer"><code>ints(int randomNumberOrigin, int randomNumberBound)</code></a> in the <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Random.html" rel="noreferrer"><code>Random</code></a> class.
For example if you want to generate five random integers (or a single one) in the range [0, 10], just do:
<pre class="lang-java s-code-block"><code class="hljs language-java">Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
</code></pre>
The first parameter indicates just the size of the <code>IntStream</code> generated (which is the overloaded method of the one that produces an unlimited <code>IntStream</code>).
If you need to do multiple separate calls, you can create an infinite primitive iterator from the stream:
<pre class="lang-java s-code-block"><code class="hljs language-java">public final class IntRandomNumberGenerator {

 private PrimitiveIterator.OfInt randomIterator;

 /**
 * Initialize a new random number generator that generates
 * random numbers in the range [min, max]
 * @param min - the min value (inclusive)
 * @param max - the max value (inclusive)
 */
 public IntRandomNumberGenerator(int min, int max) {
 randomIterator = new Random().ints(min, max + 1).iterator();
 }

 /**
 * Returns a random number in the range (min, max)
 * @return a random number in the range (min, max)
 */
 public int nextInt() {
 return randomIterator.nextInt();
 }
}
</code></pre>
You can also do it for <code>double</code> and <code>long</code> values.

You can edit your second code example to:

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
</code></pre>

Just a small modification of your first solution would suffice.

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);
</code></pre>

<hr>

See more here for implementation of <a href="https://insight.io/github.com/lambdalab-mirror/jdk8u-jdk/blob/master/src/share/classes/java/util/Random.java?line=77" rel="noreferrer"><code>Random</code></a>

<code>ThreadLocalRandom</code> equivalent of class <code>java.util.Random</code> for multithreaded environment. Generating a random number is carried out locally in each of the threads. So we have a better performance by reducing the conflicts. 

<pre class="lang-java s-code-block"><code class="hljs language-java">int rand = ThreadLocalRandom.current().nextInt(x,y);
</code></pre>

<code>x</code>,<code>y</code> - intervals e.g. (1,10)

The <code>Math.Random</code> class in <a href="http://en.wikipedia.org/wiki/Java_%28programming_language%29" rel="noreferrer">Java</a> is 0-based. So, if you write something like this: 

<pre class="lang-java s-code-block"><code class="hljs language-java">Random rand = new Random();
int x = rand.nextInt(10);
</code></pre>

<code>x</code> will be between <code>0-9</code> inclusive.

So, given the following array of <code>25</code> items, the code to generate a random number between <code>0</code> (the base of the array) and <code>array.length</code> would be:

<pre class="lang-java s-code-block"><code class="hljs language-java">String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );
</code></pre>

Since <code>i.length</code> will return <code>25</code>, the <code>nextInt( i.length )</code> will return a number between the range of <code>0-24</code>. The other option is going with <code>Math.Random</code> which works in the same way.

<pre class="lang-java s-code-block"><code class="hljs language-java">index = (int) Math.floor(Math.random() * i.length);
</code></pre>

For a better understanding, check out forum post <a href="http://web.archive.org/web/20070308142422/http://www.kirupa.com/forum/showthread.php?s=&amp;postid=81565" rel="noreferrer">Random Intervals (archive.org)</a>.

It can be done by simply doing the statement:
<pre class="lang-java s-code-block"><code class="hljs language-java">Randomizer.generate(0, 10); // Minimum of zero and maximum of ten
</code></pre>
Below is its source code.
<h3>File Randomizer.java</h3>
<pre class="lang-java s-code-block"><code class="hljs language-java">public class Randomizer {
 public static int generate(int min, int max) {
 return min + (int)(Math.random() * ((max - min) + 1));
 }
}
</code></pre>
It is just clean and simple.

in your terminal type
<pre><code>cd /
</code></pre>
then use this command:
<pre><code>du -h --max-depth=1
</code></pre>
it will take some time, but you will get folder list with sizes
<a href="https://i.sstatic.net/i850f.jpg" rel="nofollow noreferrer"><img src="https://i.sstatic.net/i850f.jpg" alt="enter image description here"></a>
as explained in details here:
<a href="https://floyk.com/en/post/how-to-find-which-folders-are-taking-the-disk-space-by-using-terminal-on-linux" rel="nofollow noreferrer">https://floyk.com/en/post/how-to-find-which-folders-are-taking-the-disk-space-by-using-terminal-on-linux</a>

It could be coming from Jenkins, Docker or any other process. To solve that, you should <a href="https://puvox.software/blog/solution-clean-full-disk-space-by-dev-vda1/" rel="nofollow noreferrer">clean logs and set it's size</a>.

From the above output of 'df -h' the disk space is used by some file or folders in '/' location. As you are able to SSH in to the server follow the below steps and that will show the files that are using more space.

<ul>
<li>cd /</li>
<li>ls -lSr | tail -10</li>
</ul>

The first command [cd space slash] will direct you to the '/' folder and second command will list files based on its size. Please post the output of the above command. This will show the files that are using more space on the current directory. Once you can find this you will be able to remove the unused files (if any). Or you can contact the hosting provider to mount another harddisk space to '/' to migrate those files and free more space.

<pre class="lang-js s-code-block"><code class="hljs language-javascript">const usernameChangeHandler = async (event) =&gt; {
 await setEnteredUsername(event.target.value);
 console.log(enteredUsername, enteredAge); 
};
</code></pre>
<code>enteredUsername</code> is never going to change. It's a closure variable that's local to this single time you rendered the component. It's usually a <code>const</code>, but even if it was made with <code>let</code>, <code>setEnteredUsername</code> does not even attempt to change its value. What <code>setEnteredUsername</code> does is ask react to rerender the component. When the render eventually happens, a new local variable will be created with the new value, but code from your old render has no access to that.
If you need to run some code after calling <code>setEnteredUsername</code>, but you don't actually care if the component has rerendered yet, the just use the value in <code>event.target.value</code>, since you know that's going to be the new value of the state:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">const usernameChangeHandler = (event) =&gt; {
 setEnteredUsername(event.target.value);
 console.log(event.target.value, enteredAge);
}
</code></pre>
If instead you need to make make sure that the component has rerendered and then do something after that, you can put your code in a useEffect. Effects run after rendering, and you can use the dependency array to make it only run if the values you care about have changed:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">const [enteredUsername, setEnteredUsername] = useState('');

useEffect(() =&gt; {
 console.log('rendering complete, with new username', enteredUsername);
}, [enteredUsername]);

const usernameChangeHandler = (event) =&gt; {
 setEnteredUsername(event.target.value);
};
</code></pre>

the act of setting state is asynchronous; therefore, console logging directly after setting your state will not accurately provide you with how state currently looks. Instead as many have suggested you can utilize the useEffect lifecycle hook to listen for changes in your enteredUserName state like so:
<pre class="lang-js s-code-block"><code class="hljs language-javascript">useEffect(() =&gt; {
 console.log(enteredUsername);
}, [enteredUsername]);
</code></pre>
listening for changes within the useEffect will allow you to create side effects once state has updated and caused your component to rerender. This in turn will trigger your useEffect with the enteredUsername dependency, as the enteredUserName state has changed.

It's not documented (at time of asking), but NPM can filter workspace commands to subdirectories of workspaces by giving the <code>--workspace</code> flag a path as its value. For example:
<pre><code>npm run --workspace packages/presets --workspace packages/plugins build
</code></pre>
This will find workspaces that are directly in <code>$project_root/packages/presets/</code> or <code>$project_root/packages/plugins/</code>, but not workspaces in subdirectories of these subdirectories.
Deeper-nested subdirectories can be included using <code>/**</code>, like:
<pre><code>npm run --workspace packages/** build
</code></pre>
<hr>
The above examples would work with workspaces organised into subdirectories, defined in package.json like:
<pre><code> "workspaces": [
 "packages/plugins/*",
 "packages/presets/*",
 ...more
 ],
</code></pre>
...or a catch-all like:
<pre><code> "workspaces": [
 "packages/**",
 ...more
 ],
</code></pre>
<hr>
While pointing <code>--workspace</code> to subdirectories of workspaces instead of individual workspaces like this doesn't seem to be documented anywhere at time of writing, it does appear to be an intentional, planned, supported feature. I found a note proposing it <a href="https://github.com/npm/rfcs/pull/117" rel="noreferrer">deep in one of the rfcs</a>:
<blockquote>
Note: Globs are not supported as a valid --workspace argument value, the proposed alternative is to use npm --workspace= in which is a folder containing multiple workspaces.
</blockquote>
I couldn't find anything explicitly stating that this proposal was implemented, but I tried reorganising my monorepo into subdirectories and using a subdirectory with the <code>--workspace</code> flag, and it worked.
Their reason for choosing paths rather than glob patterns in workspace names (like yarn does and lerna did) appears to be because of the:
<blockquote>
many pitfalls of supporting globs in the variety of supported shells and operational systems
</blockquote>

<a href="https://stackoverflow.com/a/71350662/3404438">This answer</a> is very complete. Just a couple of tweaks that worked for me:
I needed to use the npm command/script before the --workspace flag, and I did not needed to use the <code>/**</code> at the end.
<pre><code>npm run &lt;script-name&gt; --workspace parent/directory/
</code></pre>
Examples:
<pre><code>npm publish --workspace packages/public/
npm run build --workspace packages/helpers/
</code></pre>
This is documented in other parts of npm so it took a bit of digging. The information is generally the same in all places, because the <code>--workspace</code> flag is a configuration for multiple npm commands:
<pre><code>Valid values for the workspace config are either:

Workspace names
Path to a workspace directory
Path to a parent workspace directory (will result in selecting all workspaces within that folder)
</code></pre>
I found it documented <a href="https://docs.npmjs.com/cli/v8/using-npm/config#workspace" rel="nofollow noreferrer">here</a> and <a href="https://docs.npmjs.com/cli/v8/commands/npm-publish#workspace" rel="nofollow noreferrer">here</a>.
Unfortunately there does not seem to be a way to use globs. Only way to group things would be by parent directory.
Disclaimer: I was going to add a comment to <a href="https://stackoverflow.com/a/71350662/3404438">this answer</a> but it was becoming too long and details might have been missed. I think that is the right answer.

this error is Conflicts between adb versions
<a href="https://github.com/Genymobile/scrcpy/blob/master/FAQ.md#conflicts-between-adb-versions" rel="nofollow noreferrer">https://github.com/Genymobile/scrcpy/blob/master/FAQ.md#conflicts-between-adb-versions</a>
Solution is set ADB env is path to Android Sdk platform-tools adb
<blockquote>
/home//Android/Sdk/platform-tools/adb
</blockquote>
in Linux, you can
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">export ADB=/path/to/your/adb
</code></pre>
in Win,
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">set ADB=/path/to/your/adb
</code></pre>

Same things was happened for me in Android Studio during Flutter App development.
So my solution for Android Studio running on Ubuntu 20.04 is given below:
Solution:
Please do the following steps:
<ol>
<li>If you have "Android SDK Platform tools" installed then please uninstall it from "Android Studio --&gt; Tools --&gt; SDK Manager --&gt; SDK Tools(Tab)"
</li>
<li>Now, please mark "Android SDK Platform tools" from the list that is found under "SDK Tools(Tab)". The path of "SDK Tools(Tab)" is "Android Studio --&gt; Tools --&gt; SDK Manager --&gt; SDK Tools(Tab)". After that, press "OK" button to install.
</li>
<li>Then, from terminal, please type following command to check the presence of "adb" file under "Android --&gt; Sdk --&gt; platform-tools"
</li>
</ol>
"cd /home//Android/Sdk/platform-tools/ &amp;&amp; ls"
<ol start="4">
<li>After that, please remove current adb file from "/usr/bin" and then copy adb file to "/usr/bin" from "/home//Android/Sdk/platform-tools/" using following commands:</li>
</ol>
"sudo rm /usr/bin/adb &amp;&amp; sudo cp /home//Android/Sdk/platform-tools/adb /usr/bin/"
<ol start="5">
<li>Finally, please restart the adb server using following commands:</li>
</ol>
"kill adb-server &amp;&amp; start adb-server"
<ol start="6">
<li>Now, please check either everything is ok or not using following commands:</li>
</ol>
"adb version &amp;&amp; adb devices"

Since you're on Linux, you can take the adb path:
1. First get your adb path.
example: /home/Your-User/Android/Sdk/platform-tools/adb
2. Second open your terminal or terminal emulator and paste the line in the example to edit the .bashrc file.
example:
<code>code ~/.bashrc</code>
at the end of the line add this:
<code>export ADB=/home/Your-User/Android/Sdk/platform-tools/adb</code>
save the changes and return to the terminal then refresh the shell with this: <code>source ~/.bashrc</code> or close the terminal and reopen it.
<s>3. You must always run this command when restarting your terminal.</s>
no need for step 3. NB: adb must follow after <code>platform-tools/</code>

Ok I have recently found solution for this issue. Since it is impossible 2 adb work in the same time, you should use one of them. To implement this:
<ol>
<li>open vscode</li>
<li>in vscode terminal $export ADB=/home/your_username/Android/Sdk/platform-tools/adb scrcpy run this command</li>
<li>Then run $scrcpy command as well.
I hope it works. However you should do above steps every time you open vscode!</li>
</ol>

If you're using Ubuntu try this, open up your terminal: <code>ctrl + alt + t</code>
First check if you have adb in your platform-tools directory.
Enter this commands to check first:
<code>cd /home/change-this-to-your-username/Android/Sdk/platform-tools/</code>
<code>ls</code>
You should see adb listed in your terminal.
If yes, do not close your terminal yet, and open up another terminal: <code>ctrl + alt + t</code>
Enter command:
<ol>
<li><code>cd /usr/bin</code> - changes directory to usr/bin
</li>
<li><code>sudo rm adb</code> - this will remove adb
</li>
</ol>
Now go back to your previous terminal.
Enter command:
<code>sudo cp adb /usr/bin</code> - this will copy your existing adb from platform-tools directory to usr/bin where you deleted another version of adb.
now if you run: <code>scrcpy</code>
Terminal will show a log that you don't have adb installed.
Go back to your terminal and run: <code>vim .bashrc</code>
<blockquote>
If you don't have vim installed on your machine, enter: <code>sudo apt install vim</code>
</blockquote>
Press 'i' key on your keyboard to insert path: <code>export ADB='/usr/bin/adb'</code>
<code>ctrl + shift + v</code> to paste it in terminal
Press 'esc' key on your keyboard and type a colon <code>:</code> or <code>shift + ;</code> type x and hit 'enter' key to save.
run: <code>scrcpy</code>

I found a simple solution for this issue, simply connect your phone tcpip using scrcpy.adb, and not adb.
Example:
When connecting adb for debugging purpose in VSCODE, you normally run in terminal
Step1:
NB: this command runs after connecting via a good USB, and by enabling usb debugging and wireless debugging.
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">adb tcpip 5555
</code></pre>
step2:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">adb connect &lt;ip address&gt;
</code></pre>
usage: <code>adb connect 103.20.440.22</code> // replace these numbers with your phone's ip address. found in settings/about phone/ on android 13.
when you specifically want to use scrcpy only.
Step1:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">scrcpy.adb tcpip 5555
</code></pre>
step2:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart"> scrcpy.adb connect &lt;ip address&gt;
</code></pre>
usage: <code>scrcpy.adb connect 103.20.440.22</code> // replace these numbers with your phone's ip address. found in settings/about phone/ on android 13.
that's all, the key is to use scrcpy.adb for adb purpose and adb only for vscode debugging.

Rather than using already existing npm modules, what i suggest is to write yuor own stuff for this.

i think Modals from react-native would help you achieve this, you could easily place different Modals which would have your feature-introductory text/image and you could easily keep on toggling visibility of these texts/images.

say you overlay a Modal first which in initial state has descriptor text for 'menu' feature and then you could set its visibility to false when user clicks in the background and turn the next item visible and so on, on the last item you want to get displayed you can set the Modal itselfs visibility to false and move on with the main app flow.

does that sound convincing? ?

I recommended to try the plug-in below.
<a href="https://github.com/jasongaare/react-native-walkthrough-tooltip" rel="nofollow noreferrer">https://github.com/jasongaare/react-native-walkthrough-tooltip</a>

Tooltip functionality can be implemented using this lib: <a href="https://www.npmjs.com/package/rn-tooltip" rel="nofollow noreferrer">rn-tooltip</a>

You may not be interested in using a framework for a single component, but in terms of popular and well-supported libraries, React Native Paper <a href="https://callstack.github.io/react-native-paper/docs/components/Tooltip/" rel="nofollow noreferrer">has a tooltip component</a>, and is a robust and widely-used library.

I prefer to create my own component in this case as one of the answers, BUT you can use this component: <a href="https://github.com/eveningkid/react-native-popable" rel="nofollow noreferrer">react-native-popable</a>
I am using it in some apps and it played really well.

You might want to try the following package:
<a href="https://github.com/jasongaare/react-native-walkthrough-tooltip" rel="nofollow noreferrer">https://github.com/jasongaare/react-native-walkthrough-tooltip</a>

Have you tried create your own <code>tabBarComponent</code> ?
<a href="https://reactnavigation.org/docs/navigators/tab#TabNavigatorConfig" rel="nofollow noreferrer">https://reactnavigation.org/docs/navigators/tab#TabNavigatorConfig</a>

You may copy build-in <a href="https://github.com/react-navigation/react-navigation/blob/master/src/views/TabView/TabBarBottom.js" rel="nofollow noreferrer">tabComponent</a> and add your ToolTip components to render

Since you are using <a href="https://yarnpkg.com/blog/2017/08/02/introducing-workspaces/" rel="noreferrer">Yarn Workspaces</a> and it manages the dependencies of all projects (workspaces), you should add dependencies of each project to its own <code>package.json</code>, not the workspace root. Yarn uses only one <code>yarn.lock</code> file that is placed in the workspace root. Also, it tries to move dependencies of all projects to <code>node_modules</code> of workspace root to prevent duplication as much as possible. Although some dependencies need to be placed in <code>node_modules</code> of their own project; e.g. when the workspace root has a <code>devDependency</code> to <code>awesome-package@2.1.1</code> while a project has a dependency to the same package with another version, say <code>1.2.5</code> which they are not compatible. Suppose the directory structure of your workspaces is like the following:

<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">├── workspace-root
| ├── package.json
| ├── workspace-a
| | ├── package.json
| ├── workspace-b
| | ├── package.json
</code></pre>

After running <code>yarn</code> either in the workspace root or in any workspace directory, you will have the following directory structure:

<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">├── workspace-root
| ├── node_modules
| ├── package.json
| ├── yarn.lock
| ├── workspace-a
| | ├── package.json
| | ├── node_modules
| ├── workspace-b
| | ├── package.json
| | ├── node_modules
</code></pre>

Only add a dependency to workspace root when you want to run a script from workspace root and it needs a dependency. In this case, the projects are independent of that dependency, so you can ignore that warning. 

<h3>Why does yarn warn?</h3>

If you add the common dependencies of the projects to the workspace root, it won't come in <code>package.json</code> of the projects. Therefore, if you separate a project, it won't have all of its dependencies in its own <code>package.json</code> so running <code>yarn install</code> for the separated project leads to not having all the dependencies in its own <code>node_modules</code>. Obviously the separated project cannot work and you need to fix the absent dependencies problem to resolve the issue.

<h3>More about Yarn Workspaces</h3>

Yarn Workspaces is a feature for the sake of easier managing dependencies of projects that are related to each other. For example, when your projects have similar dependencies, you can declare each project as a workspace. It prevents a lot of duplication. Another important use case is monorepos:

<blockquote>
 Those who have tried splitting a project into multiple packages know
 how hard it is to make changes across multiple packages at one time.
 To make the process easier, some big projects adopted a monorepo
 approach, or multi-package repositories, which reduces the burden of
 writing code across packages.
 
 Several projects used every day by JavaScript developers are managed
 as monorepos: Babel, React, Jest, Vue, Angular.
</blockquote>

Using Yarn Workspaces brings the following benefits:

<blockquote>
 <ul>
 <li>It allows you to setup multiple packages in such a way that you only need to run yarn install once to install all of them in a
 single pass.</li>
 <li>Your dependencies can be linked together, which means that your workspaces can depend on one another while always using the most up-to-date code available.</li>
 <li>This is also a better mechanism than <code>yarn link</code> since it only affects your workspace tree rather than your whole system.</li>
 <li>All your project dependencies will be installed together, giving Yarn more latitude to better optimize them.</li>
 <li>Yarn will use a single lockfile rather than a different one for each project, which means fewer conflicts and easier reviews.</li>
 </ul>
</blockquote>

If you have "workspaces" declared in your package.json; you've opted into workspaces and setup must be correct. This appears to only make sense if you're using a mono-repo. As it pertains to this, a mono-repo is one large repo with a "root" package.json where workspaces are declared as well as dev-dependencies. Inside it will be other "packages" (projects with their own package.json, but not their own repo).

When you want to add packages to those "workspaces" ( see <a href="https://yarnpkg.com/lang/en/docs/workspaces/" rel="noreferrer">https://yarnpkg.com/lang/en/docs/workspaces/</a> ) or "packages" and you're working from the root folder, you must specify the workspace you're targeting the Yarn action with.

If it's a dev-dependency for the root, this is a non-issue. Since it's assumed that your "root" project won't have it's own "production" dependencies and they should only be in the workspaces. If it's not a dev-dependency and you don't specify the workspace ( <a href="https://yarnpkg.com/en/docs/cli/workspace" rel="noreferrer">https://yarnpkg.com/en/docs/cli/workspace</a> ), then you will see the warning and how to override.

<h2>Simple Answer</h2>
You may not have indexed into the correct directory of your app.
For example, you may have a <code>next.js</code> app structured like this:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">myApp
- /app
- /functions
</code></pre>
Yarn will throw this warning if you're trying to remove a package while in the <code>myApp</code> directory in your IDE terminal. So, the solution may be as simple as this:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">cd /app
yarn remove somePackage
</code></pre>

Thanks to Dart's <a href="https://dart.dev/language/constructors#factory-constructors" rel="noreferrer">factory constructors</a>, it's easy to build a singleton:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class Singleton {
 static final Singleton _singleton = Singleton._internal();
 
 factory Singleton() {
 return _singleton;
 }
 
 Singleton._internal();
}
</code></pre>
You can construct it like this
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">main() {
 var s1 = Singleton();
 var s2 = Singleton();
 print(identical(s1, s2)); // true
 print(s1 == s2); // true
}
</code></pre>

Here is a comparison of several different ways to create a singleton in Dart.
<h2>1. Factory constructor</h2>
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class SingletonOne {

 SingletonOne._privateConstructor();

 static final SingletonOne _instance = SingletonOne._privateConstructor();

 factory SingletonOne() {
 return _instance;
 }

}
</code></pre>
<h2>2. Static field with getter</h2>
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class SingletonTwo {

 SingletonTwo._privateConstructor();

 static final SingletonTwo _instance = SingletonTwo._privateConstructor();

 static SingletonTwo get instance =&gt; _instance;
 
}
</code></pre>
<h2>3. Static field</h2>
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class SingletonThree {

 SingletonThree._privateConstructor();

 static final SingletonThree instance = SingletonThree._privateConstructor();
 
}
</code></pre>
<h2>How to instantiate</h2>
The above singletons are instantiated like this:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">SingletonOne one = SingletonOne();
SingletonTwo two = SingletonTwo.instance;
SingletonThree three = SingletonThree.instance;
</code></pre>
Note:
I originally asked this as a <a href="https://stackoverflow.com/q/54057958/3681880">question</a>, but discovered that all of the methods above are valid and the choice largely depends on personal preference.

Here is a simple answer:
<ul>
<li>Class should have a <code>private</code> and <code>static</code> property of its type.</li>
<li>The constructor should be <code>private</code> to prevent external object initialization.</li>
<li>Check if the instance is <code>null</code>, if yes create an instance and return it, otherwise return the existing instance.</li>
</ul>
Implementation (Factory Contractor)
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class Singleton {
 static Singleton? _instance;

 Singleton._();

 factory Singleton() =&gt; _instance ??= Singleton._();

 void someMethod() {
 // ...
 }
}
</code></pre>
Usage
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">Singleton().someMethod();

// prints "Same Singleton instance? true"
print('Same Singleton instance? ${Singleton().hashCode == Singleton().hashCode}');
</code></pre>
Implementation (Lazy Loading)
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class Singleton {
 static Singleton? _instance;

 Singleton._();

 static Singleton get instance =&gt; _instance ??= Singleton._();

 void someMethod() {
 ...
 }

 ...
}
</code></pre>
Implementation (Eager Loading)
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class Singleton {
 static Singleton _instance = Singleton._();

 Singleton._();

 static Singleton get instance =&gt; _instance;

 void someMethod() {
 ...
 }

 ...
}
</code></pre>
Usage
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">Singleton.instance.someMethod();
</code></pre>

I don't find it very intuitive reading <code>new Singleton()</code>. You have to read the docs to know that <code>new</code> isn't actually creating a new instance, as it normally would.

Here's another way to do singletons (Basically what Andrew said above).

lib/thing.dart



<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">library thing;

final Thing thing = new Thing._private();

class Thing {
 Thing._private() { print('#2'); }
 foo() {
 print('#3');
 }
}
</code></pre>

main.dart

<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">import 'package:thing/thing.dart';

main() {
 print('#1');
 thing.foo();
}
</code></pre>

Note that the singleton doesn't get created until the first time the getter is called due to Dart's lazy initialization.

If you prefer you can also implement singletons as static getter on the singleton class. i.e. <code>Thing.singleton</code>, instead of a top level getter.

Also read Bob Nystrom's take on <a href="http://gameprogrammingpatterns.com/singleton.html" rel="noreferrer">singletons from his Game programming patterns book</a>.

What about just using a global variable within your library, like so?



<code>single.dart</code>:

<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">library singleton;

var Singleton = new Impl();

class Impl {
 int i;
}
</code></pre>

<code>main.dart</code>:

<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">import 'single.dart';

void main() {
 var a = Singleton;
 var b = Singleton;
 a.i = 2;
 print(b.i);
}
</code></pre>

Or is this frowned upon?

The singleton pattern is necessary in Java where the concept of globals doesn't exist, but it seems like you shouldn't need to go the long way around in Dart.

Here is another possible way:



<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">void main() {
 var s1 = Singleton.instance;
 s1.somedata = 123;
 var s2 = Singleton.instance;
 print(s2.somedata); // 123
 print(identical(s1, s2)); // true
 print(s1 == s2); // true
 //var s3 = new Singleton(); //produces a warning re missing default constructor and breaks on execution
}

class Singleton {
 static final Singleton _singleton = new Singleton._internal();
 Singleton._internal();
 static Singleton get instance =&gt; _singleton;
 var somedata;
}
</code></pre>

Singleton that can't change the object after the instantiation
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class User {
 final int age;
 final String name;
 
 User({
 this.name,
 this.age
 });
 
 static User _instance;
 
 static User getInstance({name, age}) {
 if(_instance == null) {
 _instance = User(name: name, age: age);
 return _instance;
 }
 return _instance;
 }
}

 print(User.getInstance(name: "baidu", age: 24).age); //24
 
 print(User.getInstance(name: "baidu 2").name); // is not changed //baidu

 print(User.getInstance()); // {name: "baidu": age 24}
</code></pre>

Dart singleton by const constructor &amp; factory

<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class Singleton {
 factory Singleton() =&gt;
 Singleton._internal_();
 Singleton._internal_();
}
 
 
void main() {
 print(new Singleton() == new Singleton());
 print(identical(new Singleton() , new Singleton()));
}
</code></pre>

In this example I do other things that are also necessary when wanting to use a Singleton. For instance:
<ul>
<li>pass a value to the singleton's constructor</li>
<li>initialize a value inside the constructor itself</li>
<li>set a value to a Singleton's variable</li>
<li>be able to access AND access those values.</li>
</ul>
Like this:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class MySingleton {

 static final MySingleton _singleton = MySingleton._internal();

 late String _valueToBeSet;
 late String _valueAlreadyInSingleton;
 late String _passedValueInContructor;

 get getValueToBeSet =&gt; _valueToBeSet;

 get getValueAlreadyInSingleton =&gt; _valueAlreadyInSingleton;

 get getPassedValueInConstructor =&gt; _passedValueInContructor;

 void setValue(newValue) {
 _valueToBeSet = newValue;
 }

 factory MySingleton(String passedString) {
 _singleton._valueAlreadyInSingleton = "foo";
 _singleton._passedValueInContructor = passedString;

 return _singleton;
 }

 MySingleton._internal();
}
</code></pre>
Usage of MySingleton:
<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">void main() {

MySingleton mySingleton = MySingleton("passedString");
mySingleton.setValue("setValue");
print(mySingleton.getPassedValueInConstructor);
print(mySingleton.getValueToBeSet);
print(mySingleton.getValueAlreadyInSingleton);

}
</code></pre>

After reading all the alternatives I came up with this, which reminds me a "classic singleton":

<pre class="lang-dart s-code-block"><code data-highlighted="yes" class="hljs language-dart">class AccountService {
 static final _instance = AccountService._internal();

 AccountService._internal();

 static AccountService getInstance() {
 return _instance;
 }
}
</code></pre>

You can think of Gradle as goodness of Ant and Maven put together minus the noise of XML. And scriptability with groovy is very big plus.

<ul>
<li>Gradle gives you conventions but still gives you power to override them easily. </li>
<li>Gradle build files are less verbose as they are written in groovy. </li>
<li>It provides very nice DSL for writing build tasks. </li>
<li>Has lot of good plugins and vibrant ecosystem</li>
</ul>

<blockquote>
 When to use Gradle and When to use Maven ?
</blockquote>

Almost everywhere for creating java/groovy project. The build files are much terse.

With Google choosing Gradle as the new build system for Android SDK and mature libraries like Spring, Hibernate, Grails, Groovy etc. already using it to power their builds, there is no doubt that Gradle is becoming de-facto build system for the Java ecosystem.

<blockquote>
 Gradle is the next evolutionary step in JVM-based build tools. It draws on lessons 
 learned from established tools like Ant and Maven and takes their best ideas to the next 
 level. Following a build-by-convention approach, Gradle allows for declaratively modeling your problem domain using a powerful and expressive Domain-Specific Language (DSL) 
 implemented in Groovy instead of XML. As Gradle is a JVM native, it allows you to write 
 custom logic in the language you are most comfortable with, be it Java or Groovy
</blockquote>

For more information here: <a href="https://manning-content.s3.amazonaws.com/download/3/afbfcda-28e7-4589-b1e4-1b089519b2fd/GradleinAction_CH02.pdf" rel="noreferrer">Next generation builds with Gradle</a>

This might help

<pre><code>lsof -n -i4TCP:8080 
</code></pre>

The PID is the second field in the output.

Or try:

<pre><code>lsof -i -P
</code></pre>

<h2>Fast and quick solution:</h2>
<code>lsof -n -i4TCP:8080</code>
<code>PID</code> is the second field. Then, kill that process:
<code>kill -9 PID</code>
<h2>Less fast but permanent solution</h2>
<ol>
<li>Go to <code>/usr/local/bin/</code> (Can use command+shift+g in finder)
</li>
<li>Make a file named <code>stop</code>. Paste the below code in it:
</li>
</ol>
<pre class="lang-sh s-code-block"><code data-highlighted="yes" class="hljs language-bash">#!/bin/bash
touch temp.text
lsof -n -i4TCP:$1 | awk '{print $2}' &gt; temp.text
pidToStop=`(sed '2q;d' temp.text)`
&gt; temp.text
if [[ -n $pidToStop ]]
then
kill -9 $pidToStop
echo "Congrates!! $1 is stopped."
else
echo "Sorry nothing running on above port"
fi
rm temp.text
</code></pre>
<ol start="3">
<li>Save this file.</li>
<li>Make the file executable <code>chmod 755 stop</code></li>
<li>Now, go to terminal and write <code>stop 8888</code> (or any port)</li>
</ol>

In case above-accepted answer did not work, try below solution. 
You can use it for port 8080 or for any other ports.

<pre><code>sudo lsof -i tcp:3000 
</code></pre>

Replace 3000 with whichever port you want. Run below command to kill that process.

<pre><code>sudo kill -9 PID
</code></pre>

PID is process ID you want to kill.

Below is the output of commands on mac Terminal.

<a href="https://i.sstatic.net/2VM1Q.png" rel="noreferrer"><img src="https://i.sstatic.net/2VM1Q.png" alt="Command output"></a>

Use the following command:
<code>lsof -n -i4TCP:8080 | awk '{print$2}' | tail -1 | xargs kill -9</code>
The process id of port 8080 will be picked and killed forcefully using <code>kill -9</code>.

I needed to kill processes on different ports so I created a bash script:
<pre><code>killPort() {
 PID=$(echo $(lsof -n -i4TCP:$1) | awk 'NR==1{print $11}')
 kill -9 $PID
}
</code></pre>
Just add that to your .bashrc and run it like this:
<pre><code>killPort 8080
</code></pre>
You can pass whatever port number you wish

<pre><code>sudo lsof -i:8080
</code></pre>

By running the above command you can see what are all the jobs running.

<pre><code>kill -9 &lt;PID Number&gt;
</code></pre>

Enter the PID (process identification number), so this will terminate/kill the instance.

To script this:

<pre><code>pid=$(lsof -ti tcp:8080)
if [[ $pid ]]; then
 kill -9 $pid
fi
</code></pre>

The <code>-t</code> argument makes the output of lsof "terse" which means that it only returns the PID.

I needed to run this command

<pre><code>sudo lsof -i :80 # checks port 8080
</code></pre>

Then i got 

<pre><code>COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
acwebseca 312 root 36u IPv4 0x34ae935da20560c1 0t0 TCP 192.168.1.3:50585-&gt;104.25.53.12:http (ESTABLISHED)
</code></pre>

show which service is using the PID

<pre><code>ps -ef 312
</code></pre>

Then I got this

<pre><code> UID PID PPID C STIME TTY TIME CMD
 0 312 58 0 9:32PM ?? 0:02.70 /opt/cisco/anyconnect/bin/acwebsecagent -console
</code></pre>

To uninstall cisco web security agent run

<pre><code>sudo /opt/cisco/anyconnect/bin/websecurity_uninstall.sh
</code></pre>

credits to: <a href="http://tobyaw.livejournal.com/315396.html" rel="nofollow noreferrer">http://tobyaw.livejournal.com/315396.html</a>

It can be Cisco AnyConnect. 
Check if /Library/LaunchDaemons/com.cisco.anyconnect.vpnagentd.plist exists. Then unload it with launchctl and delete from /Library/LaunchDaemons

Run: <code>nmap -p 8080 localhost</code> (Install nmap with MacPorts or Homebrew if you don't have it on your system yet)
<blockquote>
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00034s latency).
Other addresses for localhost (not scanned): ::1
PORT STATE SERVICE
8080/tcp open http-proxy
</blockquote>
Run: <code>ps -ef | grep http-proxy</code>
<blockquote>
UID PID PPID C STIME TTY TIME CMD
640 99335 88310 0 12:26pm ttys002 0:00.01 grep http-proxy"
</blockquote>
Run: <code>ps -ef 640</code> (replace 501 with your UID)
<blockquote>
/System/Library/PrivateFrameworks/PerformanceAnalysis.framework/Versions/A/XPCServices/com.apple.PerformanceAnalysis.animationperfd.xpc/Contents/MacOS/com.apple.PerformanceAnalysis.animationperfd
</blockquote>
Port 8080 on mac osx is used by something <a href="https://github.com/phracker/MacOSX-SDKs/tree/master/MacOSX10.10.sdk/System/Library/PrivateFrameworks" rel="nofollow noreferrer">installed with XCode SDK</a>

<a href="https://github.com/microsoft/TypeScript/commit/5a342742d0e8539abfc15e905de50a7643628e11" rel="noreferrer">The types for <code>Promise.allSettled()</code></a> were only merged in January, and will apparently be released in TypeScript 3.8.

As an interim solution, you can declare a mock-ish type for the function yourself:

<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">declare interface PromiseConstructor {
 allSettled(promises: Array&lt;Promise&lt;any&gt;&gt;): Promise&lt;Array&lt;{status: 'fulfilled' | 'rejected', value?: any, reason?: any}&gt;&gt;;
}
</code></pre>

To get this running on Linux, I needed the latest typescript version:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">npm install -g typescript@latest
</code></pre>
Then in your tsconfig you currently need the ES2020.Promise lib. My full tsconfig:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">{
 "compilerOptions": {
 "sourceMap": true,
 "module": "commonjs",
 "target": "es5",
 "jsx": "react",
 "esModuleInterop": true,
 "allowJs": true,
 "outDir": "./dist",
 "lib": [
 "ES2020.Promise",
 ]
 },
 "include": [
 "./src"
 ],
 "exclude": [
 "./node_modules",
 "./build"
 ],
 "compileOnSave": true,
 "parserOptions": {
 "ecmaFeatures": {
 "jsx": true
 }
 }
}
</code></pre>
Usage: <code>const results = await Promise.allSettled(BatchOfPromises);</code>

Workaround to use it with older Typescript version
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">await (Promise as any).allSettled(promises);
</code></pre>

It's ES2020 and at Stage 4, so not available everywhere without a polyfill. It got typed and merged into <a href="https://github.com/microsoft/TypeScript/pull/34065" rel="noreferrer">TS</a>. Try installing the latest @types/node package and see if that pulls it in.

Update: Looks like it will be adding <code>es2020.promise</code> to the libs, when it does land.

Update: <code>npm i typescript@3.8.0-beta</code> woot woot!

What worked for me was to simply add "es2020" into the "lib" attribute of tsconfig.json file
<a href="https://i.sstatic.net/vpON8.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/vpON8.png" alt="tsconfig.json file with the value &quot;es2020&quot; included in the &quot;lib&quot; attribute; &quot;lib&quot; attribute is circled in red"></a>

There is a shim library available that provides identical functionality (<a href="https://www.npmjs.com/package/promise.allsettled" rel="nofollow noreferrer">https://www.npmjs.com/package/promise.allsettled</a>), but note that it requires an explicit import (<code>var allSettled = require('promise.allsettled');</code>).
If you are working in typescript, the equivalent typed package is <a href="https://www.npmjs.com/package/@types/promise.allsettled" rel="nofollow noreferrer">https://www.npmjs.com/package/@types/promise.allsettled</a>, but note that the type names do not match the official ES2020 implementation, so if you want an exact drop-in replacement, you will need to add a new TS file to alias the types and make available in the global namespace:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">import { PromiseRejection, PromiseResolution, PromiseResult } from 'promise.allsettled';

// https://stackoverflow.com/a/59499895/323177
export {}

// TechDebt: Remove once project is migrated to ES2020
// Global type aliases are required because the promise.allsettled shim doesn't match the types of the actual 
// ES2020 implementation
declare global {
 export type PromiseFulfilledResult&lt;T&gt; = PromiseResolution&lt;T&gt;;
 
 export type PromiseRejectedResult = PromiseRejection&lt;any&gt;;
 
 export type PromiseSettledResult&lt;T&gt; = PromiseResult&lt;T, any&gt;;

 export class PromiseConstructor {
 /**
 * Creates a Promise that is resolved with an array of results when all
 * of the provided Promises resolve or reject.
 * @param values An array of Promises.
 * @returns A new Promise.
 */
 allSettled&lt;T extends readonly unknown[] | readonly [unknown]&gt;(values: T):
 Promise&lt;{ -readonly [P in keyof T]: PromiseSettledResult&lt;T[P] extends PromiseLike&lt;infer U&gt; ? U : T[P]&gt; }&gt;;

 /**
 * Creates a Promise that is resolved with an array of results when all
 * of the provided Promises resolve or reject.
 * @param values An array of Promises.
 * @returns A new Promise.
 */
 allSettled&lt;T&gt;(values: Iterable&lt;T&gt;): Promise&lt;PromiseSettledResult&lt;T extends PromiseLike&lt;infer U&gt; ? U : T&gt;[]&gt;;
 }
}
</code></pre>

@types/node needs to be updated
A working version is here:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">npm i @types/node@17.0.33
</code></pre>
You can see versions from <a href="https://www.npmjs.com/package/@types/node" rel="nofollow noreferrer">here</a>

As other answers have already pointed out the key is adding "es2020" to the "lib" in your <code>tsconfig.json</code>. However, in case you have a monorepo using workspaces, be sure to add it to all <code>tsconfig.json</code> files which use the dependency with <code>Promise.allSettled</code>. 
E.g. suppose you have two packages common and app, where in common you export a function that uses <code>Promise.allSettled</code> and app imports it. Then be sure that you update <code>tsconfig.json</code> files in both common and app.

I came across your question in my search while I'm also having some hard times with the Next data caching, that can be really confusing sometimes.
Did you try to use these ?
<code>export const dynamic = 'force-dynamic'</code>
doc : <a href="https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#dynamic" rel="nofollow noreferrer">https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#dynamic</a>
or <code>export const revalidate: 0</code>
doc : <a href="https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#revalidate" rel="nofollow noreferrer">https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#revalidate</a>
I found this in my search too : <a href="https://nextjs.org/docs/app/api-reference/functions/unstable_noStore" rel="nofollow noreferrer">https://nextjs.org/docs/app/api-reference/functions/unstable_noStore</a>

Please, see the examples on the <a href="https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/jsx-wrap-multilines.md" rel="noreferrer">jsx-wrap-multilines rule page</a>:

You can either disable that rule, or wrap any multiline React element into parentheses:

<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">&lt;FormControlLabel
 control={( // starting paren here
 &lt;Checkbox
 checked={data.default}
 value="default"
 onChange={(e) =&gt; {
 return setData({ ...data, default: e.target.checked });
 }}
 /&gt;
 )} // ending paren here
 label="Make default"
/&gt;
</code></pre>

Tailwind's <a href="https://tailwindcss.com/docs/preflight" rel="noreferrer">Preflight</a> functionality will remove all of the browsers' default stylings for most elements, giving you a clean basis to start from, to make cross-browser styling more consistent.
You need to re-add the styles you wish, for example:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">className="underline text-blue-600 hover:text-blue-800 visited:text-purple-600"
</code></pre>
or:
<pre class="lang-css s-code-block"><code data-highlighted="yes" class="hljs language-css">a {
 @apply underline text-blue-600 hover:text-blue-800 visited:text-purple-600
}
</code></pre>

So the other answers correctly have pointed out that preflight and/or base will reset the components, but you can also use the <a href="https://tailwindcss.com/docs/functions-and-directives#layer" rel="noreferrer">@layer</a> and <a href="https://tailwindcss.com/docs/functions-and-directives#apply" rel="noreferrer">@apply</a> directives to apply classes to elements in bulk.
@layer gives you a bucket to put things into, the ones currently available in Tailwind would be like base, components, and utilities.
For example, if you wanted to set all links to blue and underline, you could do the following:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">@layer base {
 a {
 @apply text-blue underline
 }
}
</code></pre>
The linked examples show how you could group the elements to make a meta-class for styling buttons consistently.
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">@layer components {
 .btn-blue {
 @apply bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded;
 }
}
</code></pre>

EDIT: It appears that this extra configuration is not needed with Tailwind 3 (at least as tested with 3.1.1). It may still be needed if you use Tailwind 2. See Patrik's comment below for an example.
<hr>
As Luke correctly explained, Tailwind's Preflight removes all the browser defaults. You'll have to add the styling yourself:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">className="underline text-blue-600 hover:text-blue-800 visited:text-purple-600"
</code></pre>
However, you can't just use <code>visited:</code> with <code>text-purple-600</code> without some configuration (at least with Tailwind 2. I'm not familiar with older versions). You'll also need to add the following to your Tailwind config at your project root:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">// tailwind.config.js
module.exports = {
 // ...
 variants: {
 extend: {
 textColor: ['visited'],
 }
 },
}
</code></pre>
That way, Tailwind will make all the classes with <code>visited:</code> available for use with all the text color classes.
<a href="https://tailwindcss.com/docs/configuring-variants#enabling-extra-variants" rel="nofollow noreferrer">You can learn more about enabling extra variants in the Tailwind docs.</a>

I have to disagree with others here who suggest re-adding the default anchor tag styling as a solution. You can do this, but one annoyance of working with normal anchor tags is when you wrap a button in an anchor tag, the styling cascades into the text on the button, which is super annoying.
Instead, I would suggest creating your own utility class that applies these styles instead of changing the styles for all <code>&lt;a&gt;</code> tags. For example:
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">.hyperlink {
 @apply text-blue-600 underline
}

.hyperlink:visited {
 @apply text-purple-600
}
</code></pre>
Now, use that class explicitly when you want it rather than applying it no matter what.
<pre class="lang-html s-code-block"><code data-highlighted="yes" class="hljs language-xml">&lt;a class="hyperlink" href="/foo/bar"&gt;Text link&lt;/a&gt;
&lt;a href="foo/bar"&gt;&lt;button&gt;Style-Free Button!&lt;/button&gt;&lt;/a&gt;
</code></pre>

<h3>Update</h3>
This applies to version <code>2.*</code>. It is not an issue in tailwind 3
<hr>
If you are using <code>@apply</code> note that the states (like hover) cannot be added in-line like you would pass to a class.
<pre class="lang-css s-code-block"><code data-highlighted="yes" class="hljs language-css">a {
 @apply underline text-blue-600 hover:text-blue-800 visited:text-purple-600
}
</code></pre>
They need to be broken out and matched to the css states like this:
<pre class="lang-css s-code-block"><code data-highlighted="yes" class="hljs language-css">a {
 @apply underline text-blue-600
}
a:hover {
 @apply text-blue-800
}
a:visited {
 @apply text-purple-600
}
</code></pre>

tailwind.config.js
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">extend: {
 content: {
 'externalLink': "url('images/icons/icon-external.svg')",
 }
},
</code></pre>
In css
<pre class="lang-css s-code-block"><code data-highlighted="yes" class="hljs language-css">a {
 @apply underline underline-offset-4 decoration-1 decoration-primary;

 &amp;:hover {
 @apply no-underline bg-tertiary/20;
 }

 &amp;:visited {
 @apply text-primary;
 }

 &amp;[target="_blank"]:after {
 @apply content-externalLink inline-block ml-1 mt-1;
 }
}
</code></pre>

You can run Espruino on it. I have the HiLetgo NodeMCU ESP-12E Module and was easily able to load the firmware.

<ol>
<li>Download and install flasher <a href="https://github.com/thingsSDK/flasher.js" rel="noreferrer">https://github.com/thingsSDK/flasher.js</a></li>
<li>Press and hold the flash button press the reset button once. It will flash once.</li>
<li>Open up flasher app and flash the firmware for Espruino.</li>
<li>Unplug the esp8266 and plug it back in</li>
<li>download the web ide for Espruino <a href="https://chrome.google.com/webstore/detail/espruino-web-ide/bleoifhkdalbjfbobjackfdifdneehpo?hl=en" rel="noreferrer">https://chrome.google.com/webstore/detail/espruino-web-ide/bleoifhkdalbjfbobjackfdifdneehpo?hl=en</a></li>
<li>Change the baud rate Settings --&gt; Communications --&gt; Baud Rate 115200</li>
<li>Connect and enjoy!</li>
</ol>

Some samples to try out 

<a href="https://github.com/mertenats/NodeMCU-and-JavaScript" rel="noreferrer">https://github.com/mertenats/NodeMCU-and-JavaScript</a>

I think you're confusing nodemcu, which is a firmware for the ESP8266 boards that interprets the language lua, with the javascript runtime node.js, which runs on computers.

So, the answer is you cannot run node.js on an ESP8266.

React-Router v6 removed path regular expressions. You can read more about it in <a href="https://reactrouter.com/en/main/start/faq#what-happened-to-regexp-routes-paths" rel="nofollow noreferrer">"What Happened to Regexp Routes Paths?"</a>.
If you would like to limit the routes that are matchable then you've a couple options.
<ol>
<li>Explicitly render the routes you want to render. You can map an array of the dynamic path segment values to discrete routes.
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">&lt;Routes&gt;
 ....
 {["value1", "value2", "value3"].map((someDynamicProperty) =&gt; (
 &lt;Route
 key={someDynamicProperty}
 path={generatePath("/some-path/:someDynamicProperty", {
 someDynamicProperty
 })}
 element={&lt;MyComponent /&gt;}
 /&gt;
 ))}
 ...
 &lt;Route path="/404" element={&lt;NotFound /&gt;} /&gt;
 &lt;Route path="*" element={&lt;Navigate to="/404" replace /&gt;} /&gt;
&lt;/Routes&gt;
</code></pre>
</li>
<li>Use a dynamic path segment that matches anything and perform the check in the component, redirecting if it is not a valid path segment.
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">&lt;Routes&gt;
 &lt;Route
 path="/some-segment/:someDynamicProperty"
 element={&lt;MyComponent /&gt;}
 /&gt;
 &lt;Route path="/404" element={&lt;NotFound /&gt;} /&gt;
 &lt;Route path="*" element={&lt;Navigate to="/404" replace /&gt;} /&gt;
&lt;/Routes&gt;
</code></pre>
<pre class="lang-js s-code-block"><code data-highlighted="yes" class="hljs language-javascript">const MyComponent = () =&gt; {
 const { someDynamicProperty } = useParams();
 const match = /(value1|value2|value3)/.test(someDynamicProperty);

 if (!match) return &lt;Navigate to="/404" replace /&gt;;

 return (
 ....
 );
};
</code></pre>
</li>
</ol>

When you [single-]click a file in the left sidebar's file browser or open it from the quick open menu (<kbd>Ctrl</kbd>-<kbd>P</kbd>, type the file name, <kbd>Enter</kbd>), Visual Studio Code opens it in what's called "Preview Mode", which allows you to quickly view files.
Preview Mode tabs are not kept open. As soon as you go to open another file from the sidebar, the existing Preview Mode tab (if one exists) is used. You can determine if a tab is in Preview Mode, by looking at its title in the tab bar. If the title is italic, the tab is in preview mode.
To open a file for editing (i.e. don't open in Preview Mode), double-click on the file in the sidebar, or single-click it in the sidebar then double click the title of its Preview Mode tab.
If you want to disable Preview Mode all together, you can do so by setting <code>"workbench.editor.enablePreview": false</code> in your settings file. You can also use the <code>"workbench.editor.enablePreviewFromQuickOpen"</code> option to disable it only from the quick open menu.
Before you can disable Preview Mode, you'll need to open your <a href="https://code.visualstudio.com/docs/customization/userandworkspace#_settings-file-locations" rel="noreferrer">Settings File</a>.
Pro Tip: You can use the <a href="https://code.visualstudio.com/docs/getstarted/userinterface#_command-palette" rel="noreferrer">Command Palette</a>(shortcut Ctrl+Shift+P) to open your settings file, just enter "<code>Preferences: Open User Settings</code>"!
Once you've opened your settings file (your settings file should be located on the right), add the <code>"workbench.editor.enablePreview"</code> property, and set its value to <code>false</code>.
You can learn more about Visual Studio Code's "Preview Mode" <a href="https://code.visualstudio.com/docs/editor/tabs#_preview-mode" rel="noreferrer">here</a>. 
See also article <a href="https://vscode.one/new-tab-vscode/" rel="noreferrer">How to Always Open Files in a New Tab - VSCode</a>

I came up with the same problem, and open setting.json file, add the following:
<pre class="lang-json prettyprint-override"><code>"workbench.editor.enablePreview": false
</code></pre>

If you don't want to disable preview mode you can explicitly tell <code>vscode</code> to keep a specific tab open. As mentioned above a tab heading with italic text is in preview mode.

To get a tab out of preview mode you can either right click on the tab and choose <code>keep open</code> or use the shortcut <kbd>cmd</kbd> + <kbd>k</kbd> <code>enter</code> that is mapped to the command <code>workbench.action.keepEditor</code>.

Furthermore, double-clicking on a tab also gets it out of preview mode (verified in <code>vscode</code> 1.44.0).

<h1>For 2020:</h1>
easy as pie, tap preferences (<kbd>command ⌘ </kbd> + <kbd>,</kbd> on Mac),
<h1>The secret is "Enable preview"</h1>
they added it right there:
<a href="https://i.sstatic.net/7m6vp.png" rel="noreferrer"><img src="https://i.sstatic.net/7m6vp.png" alt="enter image description here"></a>
Turn OFF (uncheck) for NORMAL behavior.
i.e., Turn OFF to avoid the "automatic closing" behavior.

Use <code>workbench.editor.enablePreview: false</code> to disable Preview mode completely. 

Use <code>workbench.editor.enablePreviewFromQuickOpen: false</code> to disable Preview mode for the files open from quick open menu.

Open in new Tab Solution:

<ol>
<li>Open the command palette by: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>K</kbd></li>
<li>Open settings file by: Preferences: Open Settings (JSON)</li>
<li>Under user setting, enable Tabs by: <code>"workbench.editor.showTabs": true</code></li>
</ol>

<h2>Watch for filenames in italic</h2>
Note that, the file name on the tab is formatted in italic if it has been opened in <code>Preview Mode</code>.
<h2>Quickly take a file out of Preview Mode</h2>
To keep the file always available in VSCode editor (that is, to take it out of <code>Preview Mode</code> into normal mode), you can double-click on the tab. Then, you will notice the name becomes non-italic.
Of course, you can simply double-click to open a file. This will open the file in a new tab, skipping the Preview Mode.
<h2>Feature or bug?</h2>
I believe Preview Mode is helpful especially when you have limited screen space and need to check many files.

<blockquote>
⚡ Actually, VSCode shows you the preview of a file.
</blockquote>
You can disable the preview with this:
<pre class="lang-json prettyprint-override"><code>"workbench.editor.enablePreview": false,
</code></pre>
⬇️ Basically just add these two settings and you're good to go.
<a href="https://VSCode.pro/tip/10" rel="noreferrer"><img src="https://i.sstatic.net/xTf2V.png" alt="VSCode tip"></a>

For anyone who don't want to disabled Preview Mode.

As I read whole of comments and I found what I preferred that is the shortcut key to pin the opened file from Quick Open/Ctrl+P or that's mean to keep the opened file to the editor, and yes also don't need to switch your hand to the mouse to double-click on files list.

Thanks to @jontem and @MattLBeck.

Call <code>save</code> command with <kbd>Ctrl</kbd>+<kbd>S</kbd> (<kbd>⌘</kbd>+<kbd>s</kbd> on Mac) is the easiest way to reach what I preferred.

And if you found out you do this to keep opened file to editor quite frequently, yes I preferred you should setting the option <code>"workbench.editor.enablePreview": false</code> or <code>"workbench.editor.enablePreviewFromQuickOpen": false</code> as others mentioned before.

Menu File → Preferences → User Settings: add this line
<code>"workbench.editor.enablePreviewFromQuickOpen": false</code>

Visual Studio Code 0.10.10 introduced this feature. To configure it, go to menu File → Preferences → Settings and add this to to your user or workspace settings:

<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"editor.rulers": [80,120]
</code></pre>

The color of the rulers can be customized like this:

<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"workbench.colorCustomizations": {
 "editorRuler.foreground": "#ff4081"
}
</code></pre>

In addition to global <code>"editor.rulers"</code> setting, it's also possible to set this on a per-language level.
For example, style guides for Python projects often specify either 79 or 120 characters vs. Git commit messages should be no longer than 50 characters.
So in your <code>settings.json</code>, you'd put:
<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"[git-commit]": {"editor.rulers": [50]},
"[python]": {
 "editor.rulers": [
 79,
 120
 ]
}
</code></pre>

With Visual Studio Code 1.27.2:

<ol>
<li>When I go to File &gt; Preference &gt; Settings, I get the following tab

<blockquote>
 <a href="https://i.sstatic.net/flZUX.png" rel="noreferrer"><img src="https://i.sstatic.net/flZUX.png" alt="Screenshot"></a>
</blockquote></li>
<li>I type rulers in Search settings and I get the following list of settings

<blockquote>
 <a href="https://i.sstatic.net/c6GQY.png" rel="noreferrer"><img src="https://i.sstatic.net/c6GQY.png" alt="screenshot"></a>
</blockquote></li>
<li>Clicking on the first Edit in settings.json, I can edit the user settings

<blockquote>
 <a href="https://i.sstatic.net/2TIXB.png" rel="noreferrer"><img src="https://i.sstatic.net/2TIXB.png" alt="screenshot"></a>
</blockquote></li>
<li>Clicking on the pen icon that appears to the left of the setting in Default user settings I can copy it on the user settings and edit it</li>
</ol>

With Visual Studio Code 1.38.1, the screenshot shown on the third point changes to the following one.

<a href="https://i.sstatic.net/k1Vf0.png" rel="noreferrer"><img src="https://i.sstatic.net/k1Vf0.png" alt="enter image description here"></a>

The panel for selecting the default user setting values isn't shown anymore.

In v1.43 is the ability to separately color the vertical rulers.
See issue <a href="https://github.com/microsoft/vscode/issues/54312" rel="noreferrer">Support multiple rulers with different colors </a> - (in settings.json):
<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"editor.rulers": [
 {
 "column": 80,
 "color": "#ff00FF"
 },
 100, // &lt;- a ruler in the default color or as customized (with "editorRuler.foreground") at column 100
 {
 "column": 120,
 "color": "#ff0000"
 },
]
</code></pre>
To change the default color for a ruler:
<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"workbench.colorCustomizations": {

 "editorRuler.foreground": "#fffa" 
 // or "#ffffffaa" - the a's are alpha transparency values
}
</code></pre>

Visual Studio Code: Version 1.14.2 (1.14.2)
<ol>
<li>Press <kbd>Shift</kbd> + <kbd>Command</kbd> + <kbd>P</kbd> to open palette
<ul>
<li>For non-macOS users, press <kbd>Ctrl</kbd>+<kbd>P</kbd></li>
</ul>
</li>
<li>Enter "settings.json" to open setting files.
</li>
<li>At default setting, you can see this:
<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">// Columns at which to show vertical rulers
"editor.rulers": [],
</code></pre>
This means the empty array won't show the vertical rulers.
</li>
<li>At right window "user setting", add the following:
</li>
</ol>
<pre class="lang-json s-code-block"><code data-highlighted="yes" class="hljs language-json">"editor.rulers": [140]
</code></pre>
Save the file, and you will see the rulers.

算法相关问题