Answer 1

我建议使用 enum 为此：

types.d.ts

export enum PluginNames {
   PluginA = 'pluginA',
   PluginB = 'pluginB',
   PluginC = 'pluginC',
}

interface Plugin {
   name: PluginNames
}

src/plugins/plugina/index.ts.ts

const pluginA: Plugin = {
  name: PluginNames.PluginA
}

export default pluginA

src/plugins/ index.ts

import pluginA from "./pluginA"
import pluginB from "./pluginB"
...

export default {
  [PluginNames.PluginA]: pluginA
  [PluginNames.PluginB]: pluginB
  ...
}

您也可以使用类型工会进行相同的操作：

interface Plugin {
   name: 'pluginA' | 'pluginB' | 'pluginC'
}

Answer 2

我在 Android flag_secure

只是出于好奇：您如何允许屏幕屏幕拍摄而不屏幕录制？

Answer 3

首先，您创建发布数据的动作，然后发送数据：

export const postData = createAsyncThunk(
  "type/postData",
  async (data) => {
    try {
      const response = await axios.post("https://reqres.in/api/users", data);
      // If you want to get something back
      return response.data;
    } catch (err) {
      console.error(err)
    }
  }
);

然后在要发送数据的地方，只需使用 data 参数，发送：

const handlePost = () => {
  // whatever you want to send
  const data = .........
  
  dispatch(postData(data));
}

如果您愿意，也可以为此操作修改 extrareducer 。

Answer 4

看看

简短，更新以匹配以下内容：

const App = () => {
  return (
    <Router>
      <Routes>
        <Route path="/" element={<Master />} />
        <Route path="/days" element={<Appone />} />
      </Routes>
    </Router>
  );
};

Answer 5

if(context.mounted)
    Navigator.push(
          context,
          PageTransition(
              type: PageTransitionType.rightToLeft,
              child: const ResetEmailScreen()
          )
    );

Answer 6

参数是按值传递的，除非函数签名另有指定：

• in void foo（type arg）， arg arg 都按值传递，无论 type> type> type> type 是一种简单的类型，一种指针类型或类型类型，
• 在 void foo（type＆amp; arg）， arg 通过参考将传递。

如果存在数组，则传递的值是指向数组的第一个元素的指针。如果您知道编译时数组的大小，则也可以通过参考传递数组： void foo（type（＆amp; arg）[10] [10]）。

Answer 7

我找到了解决方案：

alphaNumeric=({L}+|{L}+{D}+)+
email={alphaNumeric}"@"{alphaNumeric}"."({L}+|{L}+"."{L}+)

这是正则表达式

Answer 8

@netwave专注于该怎么做，我想解释为什么。

有两个问题：实施问题和设计问题。

实现问题是通过引起ICE的仿制物的编译（内部编译器错误，编译器的崩溃）的各种错误（很多）错误，我认为甚至误解和健全问题。

设计问题更有问题：此表达不像那样微不足道。如果溢出怎么办？

在某种情况下，常数表达式溢出，我们。溢出只是一个考虑因素：有很多原因可能导致表达式无法编译（例如，数组太大或访问范围）。当常数不通用时，很容易拒绝它们。但是，使用通用常数这样做要困难得多。我们有两个选择：

第一个是像C ++。也就是说，如果实际上发生发生，则允许编译和错误，就像C ++对其模板一样。

问题在于，Rust在一般情况下故意选择了不是 ，并且与特质界限的方法一样，即要求代码能够将其编译为通用，而不是单态化时要求它编译。这是有充分理由的原因：变性后错误确实很严重（例如C ++），并且类型检查这很昂贵 - 货物检查不在后验证后错误上保释，只有 货物构建。这可能导致货物构建失败了为什么货物检查成功，那真的很糟糕。我们已经有一些变频器后错误，实际上这就是它们发生的事情：

trait Trait {
    const MAY_FAIL: u8;
}
struct S<const BASE: u8>;
impl<const BASE: u8> Trait for S<BASE> {
    const MAY_FAIL: u8 = BASE + 1;
}

fn cause_post_mono_error<T: Trait>() {
    _ = T::MAY_FAIL;
}

fn main() {
    // This will pass `cargo check`, but fail `cargo build`!
    cause_post_mono_error::<S<255>>();
}

第二种方法，这是 gen> generic_const_exprs 今天使用的方法是需要在签名中未能重复的每个表达式。我们通过这样做获得了两件事：

1. 我们只能检查签名，因此在呼叫网站上我们知道此表达式将失败 - 它不满足要求。
2. 添加一个可能失败的功能主体的表达，这是一个破坏的变化，必须反映在签名上 - 这是很好的，因为Rust的哲学是 每个破裂的变化都必须反映在签名上。这样可以防止诸如C ++之类的危险，即使使用广泛的测试套件，您也永远无法确定某些更改不会给某些客户带来一些变化。

问题是，需要重复签名中的每个表达式，ah，重复。并不明显。因此，我们仍在寻求想法（这是一个）。而且我们无法稳定 generic_const_exprs 设计问题和实现问题。

Answer 9

要使用 fetch 将URL参数添加到请求中，您需要将它们附加到fetch url（还设置了正确的标题名称）：

const params = new URLSearchParams({ name });

if (this.customLookupAddress) {
  params.set('lookup', this.customLookupAddress);
}
if (this.customGatewayAddress) {
  params.set('gateway', this.customGatewayAddress);
}
fetch(`${targetUrl}?${params}`, { headers: { 'Accept': 'application/json' } })
  .then(res => res.json())
  // ...

Answer 10

如果您假设所有“子阵列”均来自相同的长度，则可以进行基本迭代，如下所示：

double[][] newAllArray = new double[allArray.length()][allArray.getJSONArray(0).length()];
for (int i = 0; i < allArray.length(); i++) {
  for (int j = 0; j < allArray.getJSONArray(i).length(); j++) {
    double originalValue = allArray.getJSONArray(i).getDouble(j);
    newAllArray[i][j] = originalValue;
  }
}

Answer 11

您不能使用等待使用它的方式。 等待应仅在 async 函数内使用。

尝试以下操作：

async function a(){
        return 'a';
    }
    console.log(a());

Answer 12

您不能使用 strendot 做到这一点，因为那是一个图形函数。但是您可以使用 kdeplot 并提供轴对象：

ax = plt.axes()
sns.kdeplot(SD_frame_A, ax=ax)
sns.kdeplot(SD_frame_S, ax=ax)
sns.kdeplot(SD_frame_D, ax=ax)
plt.show()

Answer 13

首先，按钮已经具有您可以使用的图像视图，因此请不要这样做：

[btn addSubview:imgArrow];

相反，请执行此操作：

[btn setImage:[UIImage imageNamed:@"arrow.jpeg"] forState:UIControlStateNormal];

然后，在您的 section> sectionOpentoggle method（假设它看起来像这样），请更改图像：

- (void)sectionOpenToggle:(UIButton *)sender {
    [sender setImage:[UIImage imageNamed:@"other-arrow.jpeg"] forState:UIControlStateNormal];
    // whatever else you want to do
}

Answer 14

您可以通过终端操作 collect（collectors.tomap（））将每个学生的ID映射，然后处理碰撞案例以将您的不同学生实例合并为新的实例。

到那时，在启用新的学生时，您可以实现嵌套流以合并两个碰撞实例的标记。通过应用第二个 collect（collectors.tomap（）），您可以按主题ID进行分组，然后通过合并标记的值再次处理碰撞案例。

在下面的摘要中，我通过添加第二个 student 来丰富您的测试用例：

List<Student> list = new ArrayList<>(List.of(
        new Student(1, new ArrayList<>(List.of(new Marks(1, 10), new Marks(2, 10)))),
        new Student(1, new ArrayList<>(List.of(new Marks(1, 15), new Marks(3, 10)))),
        new Student(2, new ArrayList<>(List.of(new Marks(1, 5), new Marks(2, 10)))),
        new Student(2, new ArrayList<>(List.of(new Marks(2, 5), new Marks(3, 10))))
));

//Temporary map
Map<Integer, Student> mapTemp = list.stream()
        .collect(Collectors.toMap(Student::getStudentId,                                        //grouping by student id
                Function.identity(),                                                            //setting as value the student
                (s1, s2) -> new Student(s1.getStudentId(), new ArrayList<>(                     //Creating a new Student whose list of marks is given by the merged marks of the two colliding students
                        Stream.concat(s1.getMarkList().stream(), s2.getMarkList().stream())     //Chaining the two lists of marks into a single stream
                                .collect(Collectors.toMap(Marks::getSubjectId,                  //Grouping by the marks by the subject id
                                        Function.identity(),                                    //Setting as value the mark
                                        (m1, m2) -> new Marks(m1.getSubjectId(), m1.getMark() + m2.getMark())))  //Handling the colliding marks by summing them together
                                .values())))                                                    //Retrieving the collection of merged marks
        );

//Result list with the merged students
List listRes = new ArrayList(mapTemp.values());
System.out.println(listRes);

这里还有一个链接来测试上面的代码：

https://ideone.com/0i6zqg

Answer 15

通常， usememo 用于缓存重新订阅者之间计算的结果；似乎这更适合您的情况，因为您正在调用 renderfooter 并将其结果作为道具传递。

请注意，还可以使用 usememo 进行优化渲染，在 docs ：

function Parent({ a, b }) {
  // Only re-rendered if `a` changes:
  const child1 = useMemo(() => <Child1 a={a} />, [a]);
  // Only re-rendered if `b` changes:
  const child2 = useMemo(() => <Child2 b={b} />, [b]);
  return (
    <>
      {child1}
      {child2}
    </>
  )
}

之所以在这里起作用的原因可能是由于以下事实：在重新渲染期间，react 看到对相同的反应元素的引用放置在组件层次结构中，它跳过重新渲染它。这发生在此处是因为通过使用 usememo 来创建 child1 和 child2 elements，我们确保在随后的渲染中返回相同的元素参考它的依赖性没有改变。

USECALLBACK 使您可以缓存功能定义。