事实上，现在似乎有一个简单的方法。下面的代码在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现在支持默认参数：
https://www.typescriptlang.org/docs/handbook/functions.html
此外，添加默认值允许您省略类型声明，因为它可以从默认值推断出来：

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

sayName('Bob');

Object destructuring参数对象是上面许多答案的目标，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'
});

不，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时设置默认值。

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

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'}))

这里有一些尝试，使用接口和解构与默认值。请注意，“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" })

不需要解构，你可以创建一个defaults参数并将其传入

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())