Eager 和 Lazy 关系

    2. import { Category } from "./Category";
    4. @Entity()
    5. export class Question {
    6.   @PrimaryGeneratedColumn()
    7.   id: number;
    9.   @Column()
    10.   title: string;
    12.   @Column()
    13.   text: string;
    14.   @ManyToMany(type => Category, category => category.questions, {
    15.     eager: true
    16.   })
    18.   categories: Category[];
    19. }

    现在当你加载 questions 时，不需要加入或指定要加载的关系。它们将自动加载：

    Eager 关系只有在使用find *方法时才有效。如果你使用QueryBuilder，则禁用 eager 关系，并且必须使用leftJoinAndSelect来加载。Eager 的关系只能用于关系的一方，在关系的两边使用eager：true是不允许的。

    Lazy 关系

    1. import { Entity, PrimaryGeneratedColumn, Column, ManyToMany } from "typeorm";
    2. import { Question } from "./Question";
    4. @Entity()
    5. export class Category {
    6.   @PrimaryGeneratedColumn()
    7.   id: number;
    9.   @Column()
    11.   @ManyToMany(type => Question, question => question.categories)
    12.   questions: Promise<Question[]>;
    13. }

    categories 是一个 Promise. 这意味着它是 lazy 的，它只能存储一个带有值的 promise。

    例如：

    1. const category1 = new Category();
    2. category1.name = "animals";
    3. await connection.manager.save(category1);
    5. const category2 = new Category();
    6. category2.name = "zoo";
    7. await connection.manager.save(category2);
    9. const question = new Question();
    10. question.categories = Promise.resolve([category1, category2]);
    11. await connection.manager.save(question);

    如何在 Lazy 关系中加载对象：

    注意：如果你来自其他语言（Java，PHP 等）并且习惯于在任何地方使用 lazy 关系，请小心使用。这些语言不是异步的，延迟加载是以不同的方式实现的，这就是为什么不能使用 promises 的原因。在 JavaScript 和 Node.JS 中，如果你想拥有延迟加载的关系，你必须使用 promises。但是这是非标准技术，而且在 TypeORM 中被认为是实验性的。