Typescript 在参数上指定接口或编号类型

Question

I have an interface for a parameter which can be either an object or a number.

I'm trying to write a method whereby a person can specify an object like {min: 0, max: 99} or they can specify a number which would be just a number.

eg: number(9) or number({min: 2, max:991})

I get this error:

Property 'max' does not exist on type 'number | NumberOptionsType'.

interface NumberOptionsType {
  max?: number;
  min?: number;
}

number(options?: NumberOptionsType | number): number {
    let possible: NumberOptionsType = {};
    if (!options) {
      // define a min and max
    }
    if (typeof options === 'object') {
      possible = options;
    }

    if (typeof options === 'number') {
      possible.max = 99999;
      possible.min = 0;
    }

    const max = (options && options.max) || 99999; //options.max raises the error
    const min = (options && options.min) || 0; //options.min raises the error

    const randomNumber = Math.floor(Math.random() * (max - min + 1) + min);

    return randomNumber;
  }

Answer 1

Just assert the type, ie:

 const max = (options && (options as NumberOptionsType).max) || 99999; //no longer throws error
 const min = (options && (options as NumberOptionsType).min) || 0; //no longer throws error

as a side note, since your code uses same values for when you pass in a number or when you pass in nothing, you code can be simplified like:

    interface NumberOptionsType {
      max?: number;
      min?: number;
    }

    function getNumber(options?: NumberOptionsType | number): number {
      const defaultMax = 99999;
      const defaultMin = 0;
      let max = (options as NumberOptionsType)?.max || defaultMax;
      let min = (options as NumberOptionsType)?.max || defaultMin;

      const randomNumber = Math.floor(Math.random() * (max - min + 1) + min);

      return randomNumber;
    }

Answer 2

Just check on type of options, as mentioned in the comments:

  function number(options?: NumberOptionsType | number): number {
      let possible: NumberOptionsType = {};
      if (!options) {
        // define a min and max
      }
      if (typeof options === 'object') {
        possible = options;
      }
  
      if (typeof options === 'number') {
        possible.max = 99999;
        possible.min = 0;
      }
  
      const max = typeof options === 'object'? options.max: 99999; //options.max raises the error
      const min = typeof options === 'object'? options.min: 0;; //options.min raises the error
  
      const randomNumber = Math.floor(Math.random() * (max - min + 1) + min);
  
      return randomNumber;
    }

Answer 3

In order to handle such kind of cases, you usually need split your function into several smaller. See this example:

interface NumberOptionsType {
  max?: number;
  min?: number;
}

const toRequired = ({ min, max }: NumberOptionsType): Required<NumberOptionsType> => ({
  min: min || 0,
  max: max || 99999
})

const getDefault = (): Required<NumberOptionsType> => ({ min: 0, max: 99999 })

const handleObject = (obj: Required<NumberOptionsType>) => {
  const { max, min } = obj

  return Math.floor(Math.random() * (max - min + 1) + min)
}

const number = (options?: NumberOptionsType | number) => {

  if (typeof options === 'object') {
    return handleObject(toRequired(options))
  }

  return handleObject(getDefault())
}

Playground

I don't understand why you have provided possible variable, this is why I have removed it. As far as I understood, if options is undefined you should apply default values. The same way you treat regular number , this is why I check only for typeof options === 'object' .