Đặt giá trị mặc định cho đối tượng TypeScript được truyền làm đối số

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

Tôi đã tưởng tượng một cái gì đó như thế này có thể hoạt động:

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

Rõ ràng nếu đây là những lý lẽ đơn giản bạn có thể làm điều đó với:

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

sayName('bob');

Và trong coffeescript bạn có quyền truy cập vào toán tử tồn tại có điều kiện để có thể làm:

param.lastName ?= 'smith'

Biên dịch nào cho javascript:

if (param.lastName == null) {
    param.lastName = 'smith';
}

Trên thực tế, có một cách đơn giản. Đoạn mã sau hoạt động trong TypeScript 1.5:

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

sayName({ first: 'Bob' });

Mẹo đầu tiên là đặt trong ngoặc những phím nào bạn muốn chọn từ đối tượng đối số, với key=valuebất kỳ giá trị mặc định nào. Thực hiện theo đó với :và một khai báo loại.

Điều này khác một chút so với những gì bạn đã cố gắng thực hiện, vì thay vì có một paramsđối tượng nguyên vẹn , thay vào đó bạn có các biến được quy định.

Nếu bạn muốn làm cho nó tùy chọn để chuyển bất cứ thứ gì vào hàm, hãy thêm một ?cho tất cả các khóa trong loại và thêm mặc định ={}sau khi khai báo kiểu:

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

sayName();

Bản in hỗ trợ các tham số mặc định ngay bây giờ:

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

Ngoài ra, việc thêm một giá trị mặc định cho phép bạn bỏ qua khai báo kiểu, bởi vì nó có thể được suy ra từ giá trị mặc định:

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

sayName('Bob');

Đối tượng phá hủy đối tượng tham số là điều mà nhiều câu trả lời ở trên đang hướng tới và Typecript hiện có các phương thức để làm cho nó dễ đọc và dễ hiểu hơn bằng trực giác.

Khái niệm cơ bản về phá hủy: Bằng cách phá hủy một đối tượng, bạn có thể chọn các thuộc tính từ một đối tượng theo tên khóa. Bạn có thể xác định ít hoặc nhiều thuộc tính bạn muốn và các giá trị mặc định được đặt theo cú pháp cơ bản là let {key = default} = object.

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

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

Viết một giao diện, loại hoặc lớp cho đối tượng tham số sẽ cải thiện mức độ dễ đọc.

type FullName = {
  firstName: string;
   
  /** @default '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'
});

Không, TypeScript không có cách tự nhiên để đặt mặc định cho các thuộc tính của một đối tượng được xác định giống như trong đó một đối tượng có mặc định và đối tượng kia thì không. Bạn có thể định nghĩa một cấu trúc phong phú hơn:

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

    }
}

Và sử dụng nó thay cho định nghĩa loại nội tuyến.

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

Bạn không thể làm điều gì đó như thế này không may:

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

} 

Vì nó sẽ chỉ đặt mặc định nếu nameđược undefined.

Đây có thể là một cách hay để làm điều đó không liên quan đến các nhà xây dựng dài

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

Đây là một cái gì đó để thử, sử dụng giao diện và phá hủy với các giá trị mặc định. Xin lưu ý rằng "họ" là tùy chọn.

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

Không phá hủy, bạn có thể tạo một thông số mặc định và chuyển nó vào

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

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

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