在 typescript 中定义一个对象数组

Question

我想在 typescript 中定义一个对象数组：

 const a = [{ name: 1, age: 2, car1: 8, car2: 8, car3: 8, name4: 1, age4: 2, car41: 8, car42: 8, car34: 8, }, { name: 1, age: 2, car1: 8, car2: 8, car3: 8, name4: 1, age4: 2, car41: 8, car42: 8, car34: 8, } ] const fun = (obj: Array < object > ) => { console.log(obj) } fun(a)

在我的情况下，使用这个结构是正确的： obj: Array <object>或者我应该定义我的 object 的每个键？

Answer 1

问题的解决方案取决于您要编程的场景。以下是您的代码可能出现的一些场景。

定义一个 object 并从中推断出它的密钥。

const persons = [
  { name: "John", age: 12 },
  { name: "Ben", age: 20 }
];

const fun = (info: typeof persons) => {
  //You will get intellisense here
  console.log(info[0].name);
};

您希望拥有具有固定键的对象，在这种情况下您可以使用类型和接口。

interface IPerson {
  id?: string; // ID is optional (use of ? operator)
  name: string; // Name is Required
  age: number;
}

const persons: Array<IPerson> = [
  { name: "John", age: 12 },
  { name: "Ben", age: 20 }
];

// Both are same: Array<IPerson> === IPerson[]
const fun = (info: Array<IPerson>) => {
  //You will get intellisense here
  console.log(info[0].name);
};

您希望 object 具有固定键，并且您希望提供部分信息。

interface IPerson {
  id?: string; // ID is optional (use of ? operator)
  name: string; // Name is Required
  age: number;
}

const persons: Array<Partial<IPerson>> = [
  { name: "John" }, // You can do it.
  { name: "Ben", age: 20 }
];

// Both are same: Array<IPerson> === IPerson[]
const fun = (info: Partial<IPerson>[]) => {
  //You will get intellisense here
  console.log(info[0].name);
};

附加信息，Typescript 不支持运行时类型检查，它只支持编译类型时的类型检查。

为了在运行时进行验证，您可以实现 function，如下所示：

const is_valid_person = (person: any): Boolean => {
  return (
    typeof person === "object" &&
    typeof person.name === "string" &&
    typeof person.age === "number" &&
    person.name.length >= 5 &&
    person.age >= 1
  );
};

console.log("Is person valid: ", is_valid_person({}));
console.log("Is person valid: ", is_valid_person("Invalid Person"));

我希望上述方法之一可以解决您的问题。

在我的情况下，使用这种结构是正确的：obj: Array 或者我应该定义我的 object 的每个键？

上述问题的答案是：

• 您可以使用上述任何一种方法，因为 typescript 可以帮助您编写更好的代码并在编译时减少错误。 一旦你的程序被编译，被执行的代码就是普通的 Javascript。 javascript 不会验证您的回复。

• 以上所有模式都生成相同的JavaScript代码，因此不存在性能问题。

Answer 2

正如您在文档中看到的，使用object可能有点懒惰。

假设数组中的所有对象都具有相同的属性，您可以像这样解决这个问题：

interface UserWithCars {
  name: number;
  age: number;
  // All other properties
}

const fun = (objectArray: Array<UserWithCars>): void => {
  console.log(objectArray);
}

如果所有对象都属于同一类型，您甚至可以创建一个 class （实际上应该是 go 的方式）：

class UserWithCars {
  name: number;
  age: number;
  // All other properties

  constructor(/* etc */) {
    // constructor operations
  }
}

const fun = (objectArray: Array<UserWithCars>): void => {
  console.log(objectArray);
}

Answer 3

您可以创建自己的自定义 object 类型：

type CustomObject = {
  name: number
  age: number
  car1: number
  car2: number
  car3: number
  name4: number
  age4: number
  car41: number
  car42: number
  car34: number
}

const arrayOfCustomObjects: CustomObject[] = [{
  name: 1,
  age: 2,
  car1: 8,
  car2: 8,
  car3: 8,
  name4: 1,
  age4: 2,
  car41: 8,
  car42: 8,
  car34: 8,
},
{
  name: 1,
  age: 2,
  car1: 8,
  car2: 8,
  car3: 8,
  name4: 1,
  age4: 2,
  car41: 8,
  car42: 8,
  car34: 8,
}
]

const fun = (objs: CustomObject[]) => {
    objs.forEach((obj) => {
        console.log(obj)
    })
}

fun(arrayOfCustomObjects)