Fatal编程技术网

Javascript 类型脚本函数参数

javascript angular typescript rxjs

Javascript 类型脚本函数参数,javascript,angular,typescript,rxjs,ngrx,Javascript,Angular,Typescript,Rxjs,Ngrx,我遇到了一个场景，在这个场景中，我有许多具有类似参数的函数，并且正在努力找到一个解决方案，使一切都易于维护。以以下为例： public func1(param1: string, param2: string, param3: string){} public func2(param1: string, param2: string, param3: string){} public func3(param1: string, param2: string, param3: string){}

我遇到了一个场景，在这个场景中，我有许多具有类似参数的函数，并且正在努力找到一个解决方案，使一切都易于维护。以以下为例：

public func1(param1: string, param2: string, param3: string){}
public func2(param1: string, param2: string, param3: string){}
public func3(param1: string, param2: string, param3: string){}

public func4(param1: string, param2: string, param3: string, param4: string){}
public func5(param1: string, param2: string, param3: string, param4: string){}
public func6(param1: string, param2: string, param3: string, param4: string){}

... Etc
最初我考虑的是一个界面，例如：

interface IMyInterface {
  param1: string;
  param2: string;
  param3: string;
}
并将其用于功能：

public func1(args: IMyInaterface) {

}
但是在函数4,5,6中，我不能在不创建新接口的情况下扩展它以接受N个额外的参数，并且我不想维护所有派生接口

我还希望保留我的键入（并非所有参数都是字符串，所有函数都有定义数量的参数），因此

func1(...args: string){}
不起作用

你知道怎么做才是最好的吗？

你可以用问号“？”来表示变量是否必要，例如：

public func4(param1?: string, param2?: string, param3?: string, param4?: string){}
在此函数中，您可以传递0、1、2、3或4个参数。

您可以使用问号“？”表示是否需要变量，例如：

public func4(param1?: string, param2?: string, param3?: string, param4?: string){}
在这个函数中，您可以传递0、1、2、3或4个参数。

自从TypeScript 3.0以来，我们已经能够传递这些参数。因此，您的用例可以由以下内容支持：

type ThreeStrings = [string, string, string];
type FourStrings = [string, string, string, string];

class Blarg {
  public func1(...param: ThreeStrings) {}
  public func2(...param: ThreeStrings) {}
  public func3(...param: ThreeStrings) {}
  //(method) Blarg.func3(param_0: string, param_1: string, param_2: string): void

  public func4(...param: FourStrings) {}
  public func5(...param: FourStrings) {}
  public func6(...param: FourStrings) {}
  // (method) Blarg.func6(param_0: string, param_1: string, param_2: string, param_3: string): void
}

const funct = (params: BaseParams) => {
...
}

//call it with the object you created
funct(params)
您可以看到IntelliSense显示的方法具有不同的参数，如
param_0
，
param_1
，等等

您还可以使用以下符号让IntelliSense跟踪参数名称：

type OtherParams = Parameters<
  (name: string, age: number, likesAsparagus: boolean) => void
>;


class Blarg {
  public func7(...param: OtherParams) {}
  public func8(...param: OtherParams) {}
  public func9(...param: OtherParams) {}
  // (method) Blarg.func9(name: string, age: number, likesAsparagus: boolean): void
}

键入OtherParams=参数<
（名称：string，年龄：number，likesaparagus:boolean）=>void
>;
阶级布拉格{
公共函数7（…参数：其他参数）{}
公共函数8（…参数：其他参数）{}
公共函数9（…参数：其他参数）{}
//（方法）Blarg.func9（名称：string，年龄：number，likesaparagus:boolean）：void
}
好的，希望能有帮助。祝你好运

自从TypeScript 3.0以来，我们已经能够。因此，您的用例可以由以下内容支持：

type ThreeStrings = [string, string, string];
type FourStrings = [string, string, string, string];

class Blarg {
  public func1(...param: ThreeStrings) {}
  public func2(...param: ThreeStrings) {}
  public func3(...param: ThreeStrings) {}
  //(method) Blarg.func3(param_0: string, param_1: string, param_2: string): void

  public func4(...param: FourStrings) {}
  public func5(...param: FourStrings) {}
  public func6(...param: FourStrings) {}
  // (method) Blarg.func6(param_0: string, param_1: string, param_2: string, param_3: string): void
}

const funct = (params: BaseParams) => {
...
}

//call it with the object you created
funct(params)
您可以看到IntelliSense显示的方法具有不同的参数，如
param_0
，
param_1
，等等

您还可以使用以下符号让IntelliSense跟踪参数名称：

type OtherParams = Parameters<
  (name: string, age: number, likesAsparagus: boolean) => void
>;


class Blarg {
  public func7(...param: OtherParams) {}
  public func8(...param: OtherParams) {}
  public func9(...param: OtherParams) {}
  // (method) Blarg.func9(name: string, age: number, likesAsparagus: boolean): void
}

键入OtherParams=参数<
（名称：string，年龄：number，likesaparagus:boolean）=>void
>;
阶级布拉格{
公共函数7（…参数：其他参数）{}
公共函数8（…参数：其他参数）{}
公共函数9（…参数：其他参数）{}
//（方法）Blarg.func9（名称：string，年龄：number，likesaparagus:boolean）：void
}
好的，希望能有帮助。祝你好运

好的，据我所知，您有两个选择

第一个：您可以创建一个接口，其中包含函数必须具有的所有参数作为基础，然后传递一个具有附加属性的对象。i、 e:

interface BaseParams {
  param1: string
  param2: string
}

const params = {
  param1 = 'the 3rd'
  param2 = 'is'
  param3 = 'additional'
}
这里的关键是不要将params对象添加为
BaseParams
的一部分，然后可以创建如下函数：

type ThreeStrings = [string, string, string];
type FourStrings = [string, string, string, string];

class Blarg {
  public func1(...param: ThreeStrings) {}
  public func2(...param: ThreeStrings) {}
  public func3(...param: ThreeStrings) {}
  //(method) Blarg.func3(param_0: string, param_1: string, param_2: string): void

  public func4(...param: FourStrings) {}
  public func5(...param: FourStrings) {}
  public func6(...param: FourStrings) {}
  // (method) Blarg.func6(param_0: string, param_1: string, param_2: string, param_3: string): void
}

const funct = (params: BaseParams) => {
...
}

//call it with the object you created
funct(params)
只有当您传递的对象具有您创建的接口中的字段时，Typescript才会求值

另一个不太为人所知的选项是使用Typescript中的
Partial
，它使您在界面中声明的所有属性都是可选的，因此您不必像
param1？：string那样传递每个参数。按照这个顺序，您必须创建一个包含所有可能参数的接口


interface Params {
 param1: string
 param2: string
 param3: string
 param4: string
 paramN: string
}

const funct = (params: Partial<Params>) => {
...
}



接口参数{
参数1：字符串
参数2：字符串
参数3：字符串
参数4：字符串
参数：字符串
}
常量函数=（参数：部分）=>{
...
}

好的，据我所知，您有两个选择

第一个：您可以创建一个接口，其中包含函数必须具有的所有参数作为基础，然后传递一个具有附加属性的对象。i、 e:


interface BaseParams {
  param1: string
  param2: string
}

const params = {
  param1 = 'the 3rd'
  param2 = 'is'
  param3 = 'additional'
}


这里的关键是不要将params对象添加为
BaseParams
的一部分，然后可以创建如下函数：


type ThreeStrings = [string, string, string];
type FourStrings = [string, string, string, string];

class Blarg {
  public func1(...param: ThreeStrings) {}
  public func2(...param: ThreeStrings) {}
  public func3(...param: ThreeStrings) {}
  //(method) Blarg.func3(param_0: string, param_1: string, param_2: string): void

  public func4(...param: FourStrings) {}
  public func5(...param: FourStrings) {}
  public func6(...param: FourStrings) {}
  // (method) Blarg.func6(param_0: string, param_1: string, param_2: string, param_3: string): void
}



const funct = (params: BaseParams) => {
...
}

//call it with the object you created
funct(params)


只有当您传递的对象具有您创建的接口中的字段时，Typescript才会求值

另一个不太为人所知的选项是使用Typescript中的
Partial
，它使您在界面中声明的所有属性都是可选的，因此您不必像
param1？：string那样传递每个参数。按照这个顺序，您必须创建一个包含所有可能参数的接口


interface Params {
 param1: string
 param2: string
 param3: string
 param4: string
 paramN: string
}

const funct = (params: Partial<Params>) => {
...
}



接口参数{
参数1：字符串
参数2：字符串
参数3：字符串
参数4：字符串
参数：字符串
}
常量函数=（参数：部分）=>{
...
}


在函数4,5,6中，如果不创建新的接口，我就不能真正扩展它以接受N个额外的参数

实际上，您可以使用交集类型来扩展接口“内联”：

在函数4,5,6中，如果不创建新的接口，我就不能真正扩展它以接受N个额外的参数

实际上，您可以使用交集类型来扩展接口“内联”：


一个有4个属性的普通对象开始？然后，您可以在以后添加任意数量的属性。您的函数的实现是否相同？如果我的答案不符合您的NED要求，请将代码扩展到更详细的用例。当您说“在不创建新接口的情况下扩展以接受N个附加参数”时，您可能希望更加明确，因为在参数（
func（newArg:boolean，param1:string，param2:string，param3:string）{}
）之前添加参数非常简单，但在附加参数（
func）时却非常笨拙/混乱（param1:string，param2:string，param3:string，newArg:boolean）{}
），我不确定
N
是否需要泛型。祝你好运！func1（…args:any[]）{}
？或者
func1（一：字符串，二：数字，…rest:any[]）{呢
，查看一个包含4个属性的普通对象？然后您可以在以后添加任意数量的属性。功能的实现是否相同？如果我的答案不符合您的NED，请将代码扩展到包含更详细用例的。当您说“扩展以接受N个附加属性”时