How to using or operator in typeorm?

在TypeORM中，当您需要构建一个查询并且想要使用“OR”运算符来组合不同的查询条件时，可以使用Where语句的多种方法来实现。以下是几种使用“OR”运算符的方法：

使用 Where 对象

您可以通过Where对象构建的查询使用orWhere方法，例如:

typescript
import { getRepository } from 'typeorm';
import { User } from './entity/User';

const userRepository = getRepository(User);

userRepository
  .createQueryBuilder('user')
  .where('user.firstName = :firstName', { firstName: 'John' })
  .orWhere('user.lastName = :lastName', { lastName: 'Doe' })
  .getMany();

在上面的例子中，我们首先对user.firstName进行了过滤，然后使用orWhere方法增加了一个条件，即user.lastName。这两个条件将用“OR”运算符组合。

使用 find 方法与 FindOptions

在使用TypeORM的find方法时，可以通过传递FindOptions对象，并在其中指定where属性，该属性可以是一个条件数组，TypeORM将使用“OR”将它们组合起来：

typescript
import { getRepository } from 'typeorm';
import { User } from './entity/User';

const userRepository = getRepository(User);

userRepository.find({
  where: [
    { firstName: 'John' },
    { lastName: 'Doe' }
  ]
});

在这个例子中，where属性接受了一个条件数组，每一个对象代表一个条件，TypeORM将使用“OR”逻辑将这些条件组合在一起。

使用 Brackets 对象

使用Brackets对象可以创建更加复杂的“OR”查询，允许您嵌套查询条件，例如：

typescript
import { getRepository, Brackets } from 'typeorm';
import { User } from './entity/User';

const userRepository = getRepository(User);

userRepository
  .createQueryBuilder('user')
  .where(new Brackets(qb => {
    qb.where('user.firstName = :firstName', { firstName: 'John' })
      .orWhere('user.lastName = :lastName', { lastName: 'Doe' })
  }))
  .getMany();

在这个例子中，通过使用Brackets对象，我们创建了一个嵌套的查询条件，这允许我们在复杂查询时有更灵活的控制。

总结一下，TypeORM提供了多种方式来使用“OR”运算符。您可以根据查询的复杂性和个人喜好选择合适的方法。在实际应用中，根据查询的具体需求来选择使用orWhere方法、find方法结合FindOptions，或者是Brackets对象以构建更复杂的查询逻辑。

js
db.getRepository(MyModel).find({
  where: [
      { name: "john" },
      { lastName: "doe" }
  ]
})

将数组传递给 where即可实现要求

可以通过执行以下操作将“OR”子句与“AND”结合起来。

shell
db.getRepository(MyModel).find({
  where: [
      { name: "john", lastName: "doe" },
      { age: 20 }
  ]
})

最终执行SQL语句如下

sql
select * from model where (name = "john" and lastname = "doe") OR age = 20

我遇到了同样的问题，但我使用QueryBuilder解决了这个问题。

这就是一个例子。

shell
return await getRepository(MyModel)
  .createQueryBuilder()
  .where("name = :name OR lastName = :lastName", {
    name: "john",
    lastName: "doe"
  })
  .getMany();

要OR在 中使用sub-clause，我必须重复main-clause

shell
userRepository.find({
  where: [
    {
      firstName: 'Timber',
      lastName: 'Saw',
      project: {
        name: 'TypeORM',
      },
    },
    {
      firstName: 'Timber',
      lastName: 'Saw',
      project: {
        initials: 'TORM',
      },
    },
  ],
});

查找所有Timber Saw带有name = "TypeORM" 或 的项目initials = "TORM"

从版本0.3.18（2024-01-03 发布）开始，TypeORM 现在支持Or基本 .find* 方法中的运算符：

shell
const users = await db.getRepository(User).findBy({
    name: Or(Equal("John"), ILike("Jane%")),
})


-- Will generate the following query:
SELECT * FROM "user" WHERE "name" = 'John' OR "name" ILIKE 'Jane%'

不幸的是，这并不能解决您提出的场景，而只能解决仅涉及一个字段的情况。但它可能对其他用户仍然有用。

在 TypeScript 中，你可以使用多种方法来动态地为对象分配属性。以下是几种不同的方法：

方法 1: 使用索引签名

如果你提前知道属性的类型，但不知道属性的名称，你可以使用索引签名来定义一个对象，这个对象可以接受任意名称的属性。

typescript
// 定义一个索引类型
interface DynamicObject {
  [key: string]: any; // 可以使用 string, number, symbol
}

// 创建一个动态对象
const obj: DynamicObject = {};

// 动态添加属性
obj['newProperty'] = 'New Value';
obj.dynamicField = 123;

console.log(obj);

方法 2: 使用泛型和 keyof

如果你有一个特定的对象类型，并且想要添加或修改这个类型的属性，你可以使用泛型和 keyof。

typescript
type KnownObject = {
  existingProperty: string;
};

function setProperty<T, K extends keyof any, V>(
  obj: T,
  key: K,
  value: V
): T & Record<K, V> {
  return {
    ...obj,
    [key]: value,
  };
}

const knownObj: KnownObject = { existingProperty: 'Hello' };

const updatedObj = setProperty(knownObj, 'dynamicProperty', 456);

console.log(updatedObj);

方法 3: 使用 Object.assign()

Object.assign() 方法可以用来复制一个或多个源对象的所有可枚举自有属性到目标对象，返回目标对象。

typescript
const obj: {[key: string]: any} = {};

Object.assign(obj, { dynamicProperty: 'Dynamic' });

console.log(obj);

方法 4: 使用扩展运算符（Spread Operator）

扩展运算符可以用来将现有对象的属性复制到新对象中，并添加新的属性。

typescript
const obj = {};

const newProperty = 'dynamic';
const newObj = {
  ...obj,
  [newProperty]: 'Value',
};

console.log(newObj);

总结

以上是在 TypeScript 中动态分配对象属性的几种方法。在实际使用时，需要根据你的具体需求来选择合适的方法。使用索引签名和 Object.assign() 通常更灵活，而使用泛型和 keyof 可以为类型安全提供更强的保障。