Проверка предварительных условий в машинописи

Question

У меня есть класс typescript, где есть методы для проверки типа переменных. Как определить в начале doProcess(), какой метод использовать для обработки следующего?

class MyClass {

public static arr : any[] = [];

// main method
public static doProcess(object : object , justForObjects : boolean = false){
    if (justForObjects){
        // here should specify which checking method use in *** line
    } else {

    }

    for (let key in object){
        if (object.hasOwnProperty(key)){
            if (/* *** */){
                MyClass.doProcess(object[key] , justObjects)
            } else {
                MyClass.arr.push(object[key])
            }
        }
    }

return MyClass.arr;

}

 // check variables type methods
 private static is_object(value : any){
     return !!(typeof value === 'object' && !(value instanceof Array) && value);
 }
 private static is_object_or_array(value : any){
     return !!(typeof value === 'object' && value);
 }

}

let object = {
 'main color' : 'black',
 'other colors' : {
     'front color' : 'purple',
     'back color' : 'yellow',
     'inside colors' : {
         'top color' : 'red',
         'bottom color' : 'green'
     }
 }
}

MyClass.doProcess(object , true);

Я знаю, что это можно сделать так же для l oop (как показано ниже), но Я хотел бы сначала найти способ сделать это.

    for (let key in object){
        if(object.hasOwnProperty(key)){
            if (justForObjects){
                if (MyClass.is_object(object[key])){
                    // do something
                }
            } else {
                if (MyClass.is_object_or_array(object[key])){
                    // do something else
                }
            }
        }

    }

Спасибо за ваши советы

Answer 1

Функции могут быть просто присвоены переменным, например:

public static doProcess(obj : object , justForObjects : boolean = false) {

    var check_fn = justForObjects ? MyClass.is_object : MyClass.is_object_or_array;

    for (let key in obj) {
        if (check_fn(obj[key])) ...
    }

}

 // check variables type methods
 private static is_object(value : any) : boolean { ... }
 private static is_object_or_array(value : any) : boolean { ... }

Answer 2

Посмотрите, поможет ли вам рекурсивный метод:

interface CustomObject {
  [path: string]: ObjectValue;
}

type ObjectValue = string | CustomObject | CustomObject[];

class MyClass {
  /**
   *
   *
   * @recursive
   */
  public static doProcess(
    object: CustomObject,
    justForObjects: boolean = false
  ) {
    for (const key in object) {
      const value = object[key];

      if (this.isObjectOrArray(value, justForObjects)) {
        this.doProcess(value as CustomObject, justForObjects);
        continue;
      } else {
        // do something;
        continue;
      }
    }
  }
  /**
   *
   *
   * Check is object or array
   */
  private static isObjectOrArray(
    value: ObjectValue,
    justForObjects: boolean = false
  ) {
    // objects and arrays
    if (!justForObjects) return !!(typeof value === "object" && value);

    if (Array.isArray(value)) throw new TypeError("Array value not allowed");

    // only objects
    return !!(typeof value === "object" && !(value instanceof Array) && value);
  }
}

let object = {
  "main color": "black",
  "other colors": {
    "front color": "purple",
    "back color": "yellow",
    "inside colors": {
      "top color": "red",
      "bottom color": "green"
    }
  }
} as CustomObject;

MyClass.doProcess(object, true);