为作为参数传递的 TypeScript 对象设置默认值

function sayName(params: {firstName: string; lastName?: string}) {
params.lastName = params.lastName || 'smith';  // <<-- any better alternative to this?
var name = params.firstName + params.lastName
alert(name);
}


sayName({firstName: 'bob'});

我曾经想象过这样的事情可能会奏效:

function sayName(params: {firstName: string; lastName: string = 'smith'}) {

显然，如果这些是简单的论点，你可以这样做:

function sayName(firstName: string, lastName = 'smith') {
var name = firstName + lastName;
alert(name);
}


sayName('bob');

在咖啡脚本中，你可以访问条件存在运算符，所以可以这样做:

param.lastName ?= 'smith'

编译成 javascript:

if (param.lastName == null) {
param.lastName = 'smith';
}
388351 次浏览
小开

不，TypeScript没有一种自然的方法来为对象的属性设置默认值，比如一个有默认值，另一个没有。你可以定义一个更丰富的结构:

class Name {
constructor(public first : string,
public last: string = "Smith") {


}
}

用它来代替内联类型定义。

function sayName(name: Name) {
alert(name.first + " " + name.last);
}

不幸的是，你不能这样做:

function sayName(name : { first: string; last?:string }
/* and then assign a default object matching the signature */
= { first: null, last: 'Smith' }) {


}

因为它只会在name为undefined时设置默认值。

小开
最佳答案

实际上，现在似乎有一种简单的方法。以下代码适用于TypeScript 1.5:

function sayName({ first, last = 'Smith' }: {first: string; last?: string }): void {
const name = first + ' ' + last;
console.log(name);
}


sayName({ first: 'Bob' });

诀窍是首先将你想从参数对象中选择的键放在括号中，任何默认值都使用key=value。后面跟着:和一个类型声明。

这与您尝试做的事情略有不同，因为您拥有的不是完整的params对象，而是解引用的变量。

如果你想让传递任何东西给函数都是可选的，为类型中的所有键添加?，并在类型声明后添加默认值={}:

function sayName({first='Bob',last='Smith'}: {first?: string; last?: string}={}){
var name = first + " " + last;
alert(name);
}


sayName();
小开

对象解构参数对象是上面许多答案的目标，Typescript现在有适当的方法，使它更容易阅读和直观地理解。

解构基础知识:通过析构对象，你可以通过键名从对象中选择属性。你可以定义任意数量的属性，默认值由let {key = default} = object的基本语法设置。

let {firstName, lastName = 'Smith'} = myParamsObject;


//Compiles to:
var firstName = myParamsObject.firstName,
_a = myParamsObject.lastName,
lastName = _a === void 0 ? 'Smith' : _a;

为参数对象编写接口、类型或类可以提高易读性。

type FullName = {
firstName: string;
   

/** @defaultValue 'Smith' */
lastName ? : string;
}


function sayName(params: FullName) {


// Set defaults for parameter object
var { firstName, lastName = 'Smith'} = params;


// Do Stuff
var name = firstName + " " + lastName;
alert(name);
}


// Use it
sayName({
firstName: 'Bob'
});

小开

这是一种不涉及长构造函数的好方法

class Person {
firstName?: string = 'Bob';
lastName?: string = 'Smith';


// Pass in this class as the required params
constructor(params: Person) {
// object.assign will overwrite defaults if params exist
Object.assign(this, params)
}
}


// you can still use the typing
function sayName(params: Person){
let name = params.firstName + params.lastName
alert(name)
}


// you do have to call new but for my use case this felt better
sayName(new Person({firstName: 'Gordon'}))
sayName(new Person({lastName: 'Thomas'}))
小开

Typescript现在支持默认参数:

https://www.typescriptlang.org/docs/handbook/functions.html

另外，添加默认值可以省略类型声明，因为它可以从默认值推断出来:

function sayName(firstName: string, lastName = "Smith") {
const name = firstName + ' ' + lastName;
alert(name);
}


sayName('Bob');
小开

这里有一些东西可以尝试，使用默认值的接口和解构。请注意，“lastName”是可选的。

interface IName {
firstName: string
lastName?: string
}


function sayName(params: IName) {
const { firstName, lastName = "Smith" } = params
const fullName = `${firstName} ${lastName}`


console.log("FullName-> ", fullName)
}


sayName({ firstName: "Bob" })
小开

不需要解构，您可以创建一个默认的params并将其传入

interface Name {
firstName: string;
lastName: string;
}


export const defaultName extends Omit<Name, 'firstName'> {
lastName: 'Smith'
}


sayName({ ...defaultName, firstName: 'Bob' })
小开

还有另一种不需要解构的方法，就是用这样的类型设置默认值:

function name(param1:type=defaultValue1, paramr2:type=defaultvalue2,...) {//}

一个例子是

function addTwoNumbers(first:number = 1, second:number = 3):number {return first+second}
console.log(addTwoNumbers())

提交答案