Javascript 如何对返回状态片的函数的flowtype进行注释？

背景：

export type LazyloadProviderState = {
  targets?: TargetHash,
  otherProps: any,
  id: number,
  meta: any,
};

export type Hash = string;

export type TargetHashMap = {
  [key: Hash]: Target,
};

export type Target = {
  key: Hash,
  current: Node,
  visibility: boolean,
};

static registerOneTarget(
    target
  ) : (LazyloadProviderState => LazyloadProviderState) // wrong!
  {
    return ps => {
      return {
        targets: {
          ...ps.targets,
          ...LazyloadProvider.createElement(target),
        },
      };
    };
  }

目前，我的

registerOneTarget

方法被注释为返回整个

LazyloadProviderState

，这是错误的，因为它只返回完整状态的一部分。我的

registerOneTarget

方法接收一个目标并返回一个函数，该函数返回一个状态片

问题：

export type LazyloadProviderState = {
  targets?: TargetHash,
  otherProps: any,
  id: number,
  meta: any,
};

export type Hash = string;

export type TargetHashMap = {
  [key: Hash]: Target,
};

export type Target = {
  key: Hash,
  current: Node,
  visibility: boolean,
};

static registerOneTarget(
    target
  ) : (LazyloadProviderState => LazyloadProviderState) // wrong!
  {
    return ps => {
      return {
        targets: {
          ...ps.targets,
          ...LazyloadProvider.createElement(target),
        },
      };
    };
  }

如何为较大类型的单个键（

LazyloadProviderState

）添加注释？换句话说，我们如何明确地键入

LazyloadProviderState.targets

，而不注释整个

LazyloadProviderState

类型

状态+类型：

export type LazyloadProviderState = {
  targets?: TargetHash,
  otherProps: any,
  id: number,
  meta: any,
};

export type Hash = string;

export type TargetHashMap = {
  [key: Hash]: Target,
};

export type Target = {
  key: Hash,
  current: Node,
  visibility: boolean,
};

static registerOneTarget(
    target
  ) : (LazyloadProviderState => LazyloadProviderState) // wrong!
  {
    return ps => {
      return {
        targets: {
          ...ps.targets,
          ...LazyloadProvider.createElement(target),
        },
      };
    };
  }

返回类型有问题的函数：

export type LazyloadProviderState = {
  targets?: TargetHash,
  otherProps: any,
  id: number,
  meta: any,
};

export type Hash = string;

export type TargetHashMap = {
  [key: Hash]: Target,
};

export type Target = {
  key: Hash,
  current: Node,
  visibility: boolean,
};

static registerOneTarget(
    target
  ) : (LazyloadProviderState => LazyloadProviderState) // wrong!
  {
    return ps => {
      return {
        targets: {
          ...ps.targets,
          ...LazyloadProvider.createElement(target),
        },
      };
    };
  }

全班上课，如果有助于理解

类LazyloadProvider扩展组件<
懒汉提供道具，
懒洋洋
> {
建造师（道具）{
超级（道具）；
this.state={targets:{}}；
}
静态createHash（）：哈希{
设d，r；
返回“xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxx”。替换（/[xy]/g，c=>{
r=（new Date（）.getTime（）+Math.random（）*16）%16 | 0；
d=数学楼层（d/16）；
返回（c=='x'？r:（r&0x3）| 0x8）；
});
}
静态createElement（目标）：TargetHash{
const key=LazyloadProvider.createHash（）；
常量可见性=假；
返回{
[钥匙]：{
……目标，
钥匙
能见度，
},
};
}
静态注册目标(
目标
)：LazyloadProviderState=>LazyloadProviderState{
返回ps=>{
返回{
目标：{
…ps.目标，
…LazyloadProvider.createElement（目标），
},
};
};
}
获取引擎（）{
返回{
州：这个州，
寄存器：目标=>{
this.setState（LazyloadProvider.RegisterOnTarget（目标））；
},
取消注册：目标=>{}，
};
}
render（）{
返回(
{this.props.children}
);
}
}

您可以尝试：

复制提供的类型的形状，但将每个字段标记为可选

因此，您的函数注释将是：

LazyloadProviderState => $Shape<LazyloadProviderState>

接下来，您可以将完整类型定义为包含部分类型：

export type LazyloadProviderState = { 
  otherProps: any,
  id: number,
  meta: any,
} & LazyloadProviderPartialState;

然后定义函数变得非常容易：

LazyloadProviderState => LazyloadProviderPartialState;

---

最好明确说明返回的是状态的哪一部分-

{targets:TargetHash}

export type LazyloadProviderState = {
  targets?: TargetHash,
  otherProps: any,
  id: number,
  meta: any,
};

static registerOneTarget(
    target
  ) : (LazyloadProviderState => {targets: TargetHash})
  {
    return ps => {
      return {
        targets: {
          ...ps.targets,
          ...LazyloadProvider.createElement(target),
        },
      };
    };
  }