小编ple*_*top的帖子

这段代码:

import * as React from 'react';                                                                                              

const Component = () => <div/>;                                                  

function culprit<P>(node: React.ReactElement<P>) {
  console.log(node);
}

culprit(<Component/>);

...使用TypeScript进行编译时产生此编译错误:

error TS2345: Argument of type 'Element' is not assignable to parameter of type 'ReactElement<any>'.
  Type 'null' is not assignable to type 'ReactElement<any>

仅当strictNullChecks TypeScript编译标志设置为时才会发生这种情况true.

是的我可以禁用该标志,但我想要它以增加编译时检查/安全性.

如果我将最后一行更改为:

culprit( (<Component/> as React.ReactElement<any>) );

...它适用于设置为的标志true.

我最近尝试在React项目中从"普通"JavaScript迁移到TypeScript,这使我的所有测试都瘫痪,因此将所有TypeScript类型断言添加到测试代码中的所有这些事件将是一件痛苦的事.

这是一个错误,还是我别无选择？

说我有这样的代码:

import { Action, Dispatch } from 'redux';
import { ThunkAction } from 'redux-thunk';

interface StateTree {
  field: string;
}

function myFunc(action: Action | ThunkAction<void, StateTree, void>,
                dispatch: Dispatch<StateTree>) {
  dispatch(action); // <-- This is where the error comes from
}

...我从TypeScript编译器中得到此错误:

ERROR in myFile.ts:x:y
TS2345: Argument of type 'Action | ThunkAction<void, StateTree, void>' is not assignable to parameter of type 'Action'.
  Type 'ThunkAction<void, StateTree, void>' is not assignable to type 'Action'.
  Property 'type' is missing in type 'ThunkAction<void, StateTree, …

我有一堆单元测试文件，所有这些文件都由 django.test.TestCase 类组成。

自己写了一个小 shell 脚本来取消注释/注释我的 __init__.py 文件中的测试文件导入，因此我可以根据我提供的命令行参数从某些测试文件运行测试。我还能够一次性运行所有测试文件的所有测试（用于回归测试）。

我有一个包含一些 JSON 固定装置的测试文件，第一个测试检查某个模型/表中是否有 3 条记录（由 JSON 固定装置定义）。

所以问题来了：当我自己运行这个测试文件时，它的测试以优异的成绩通过，但是当我用所有其他测试运行测试时，我提到的那个特定的测试用例失败了。

当我运行所有测试时，数据库说表/模型中有 6 条记录，但应该只有 3 条（来自夹具），就像测试文件本身运行时一样。

我还尝试使用其他一些测试文件（不是全部）运行该测试文件，并且它通过了。所以唯一没有的时候，是当所有测试文件都运行时。

对我来说，这似乎是 Django 或 PostgreSQL（我正在使用的数据库）中的一个错误，因为 Django TestCases 不应该在每个测试方法之间自动刷新/重置数据库，更不用说测试类了？

我有一个像这样结构的Django项目:

appname/
   models/
      __init__.py
      a.py
      base.py
      c.py

... appname/models/__ init__.py只包含这样的语句:

from appname.models.base import Base
from appname.models.a import A
from appname.models.c import C

...以及appname/models/base.py包含的位置:

import django.db.models


class Base(django.db.models.Model):
   ...

以及appname/models/a.py包含的位置:

import appname.models as models


class A(models.Base):
   ....

...同样适用于appname/models/c.py等.

我很满意我的代码结构,但当然它不起作用,因为循环导入.

当appname/__ init__.py运行时,appname/models/a.py将运行,但该模块导入"appname.models",尚未完成执行.经典循环导入.

所以这应该表明我的代码结构很差,需要重新设计以避免循环依赖.

有什么选择呢？

我能想到的一些解决方案,以及为什么我不想使用它们:

1. 将我的所有模型代码合并到一个文件中:在我看来,在同一个文件中有20多个类比我尝试做的(使用单独的文件)更糟糕.
2. 将"Base"模型类移动到"appname/models"之外的另一个包中:这意味着我最终会在我的项目中包含包含基类/父类的包,这些类理想情况下应该拆分为其子/子包中的包课程位于.为什么我应该在同一个包中有模型,表单,视图等的基类/父类,而不是它们自己的包(子/子类所在的位置),除了避免循环导入？

所以我的问题不仅仅是如何避免循环导入,而是以一种与我试图实现的方式一样干净(如果不是更干净)的方式.

有没有人有更好的方法？

我知道，如果您SubmissionError从handleSubmit()函数中抛出a ，则redux-form代码将填充相应字段和/或表单本身的错误。

但是，设置字段/表单错误的API将我们的实现紧密结合在一起handleSumbit()，成为了redux-form代码的调用者（其中包含SubmissionError异常处理程序）。

我的用例是这样的：

function asyncActionDispatcher(values) {                                     
  return (dispatch, getState) => {                                           
    // I'm using getState, which is not accessible in handleSubmit()         
    // But I'd also like to be able to set errors on the form fields and/or the
    // form.                                                                 
  };                                                                         
}                                                                            

function handleSubmit(values, dispatch) {                                    
  dispatch(                                                                  
    asyncActionDispatcher(values)                                            
  );                                                                         
} 

我不能抛出SubmissionErrorin，asyncActionDispatcher()因为它是by redux和not 调用的redux-form。

是否redux-form有其他API可以在字段/表单上设置错误？

interface A {
  a: number;
}

let myVar: A = {
  a: 123
};

myVar = Object.assign({}, myVar, {
  b: 456
});

为什么TypeScript不会抱怨myVar通过Object.assign()调用重新分配？

鉴于该Object.assign()调用的类型定义是:

assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;

...和我的调用中三种类型的(返回类型)交集不匹配interface A,编译器不应该选择那个吗？

问题与TypeScript无法推断函数调用中的类型无关,因为如果我将代码更改为:

interface A {
  a: number;
}

interface B {
  b: number;
}

interface C {}

let myVar: A = {
  a: 345
};

myVar = Object.assign<C, A, B>({}, myVar, {
  b: 345 …