强制函数只接受特定结构的对象（在 typescript / js 中）

Question

I know some of typescript's advantages are enabling type-safe functions -
but is it possible to ensure my function can only get objects with specific keys, or in other words - objects of specific structure ?

I know of many elegant ways to test if a nested key exists, such as [this one][1] ,
and I can of course run a small check at the beginning of my function - but the reason I'm asking this is because my function will be used by many other programmers - and I want to ensure they can understand what input they should insert just from the function's signature.

Example:

function printName(user){
    console.log(user.details.name); // I want to ensure details.name exist
}

and I would wish to have some feature like:

function (user : {details: {name : string}}){
    //same ...
}


[1]: https://stackoverflow.com/questions/2631001/javascript-test-for-existence-of-nested-object-key#answer-4034468 "this one"

Answer 1

interface User {
    details:{name: string}
}

function printName(user:User){
    console.log(user.details.name); // I want to ensure details.name exist
}

Answer 2

This is exactly the feature you desire:

function printName(user: { [key: string]: any, details: { [key: string]: any, name: string }}) {
    console.log(user.details.name)
}

Allow any properties and require details + name .

More legible and protected against unintentional changes:

// oftentimes you put the following interfaces in extra files:
interface Details {
    readonly [key: string]: any // = allow other properties than "name"*
    readonly name: string
}
interface User {
    readonly [key: string]: any // = allow other properties than "details"*
    readonly details: Details
}
// *) consider explicitly specifying them

function printName(user: User) {
    console.log(user.details.name)
}

And use the following code if you know other developers may call your function from plain JavaScript code (not TypeScript code):

function printName(user: User) {
    const name = ((user || <User>{}).details || <Details>{}).name
    if(name == void 0) {
        console.error("user name missing")
    }
    console.log(name)
}

Code on TypeScript Playground

Answer 3

Use keyof if you want to retrieve a value from a specific property, this will highlight the incorrect property name.

You can also use Object.keys to check if the property exists.

interface UserProps {
  name: string;
  age: number;
}

export class User {
  constructor(private data: UserProps) {}

  get(propName: keyof UserProps): string | number {
    const dataKeys = Object.keys(this.data);
    if (!dataKeys.includes(propName)) {
      throw Error(`Property ${propName} does not exists on user object`);
    }
    return this.data[propName];
  }
}

Answer 4

You can use interfaces in typescript

export interface Details{
  name:string,
  age: number
}
export interface User{
  details :  {
        [key: string]: Details
    };
}

function printName(user : User){}