过滤与筛选 #

// 等于
filters: 'brand:Apple'

// 不等于
filters: 'brand != Apple'

// 比较运算
filters: 'price < 1000'
filters: 'price <= 1000'
filters: 'price > 500'
filters: 'price >= 500'

// AND
filters: 'brand:Apple AND price < 1000'

// OR
filters: 'brand:Apple OR brand:Samsung'

// NOT
filters: 'NOT brand:Apple'

// 组合
filters: '(brand:Apple OR brand:Samsung) AND price < 1000'

// 精确匹配
filters: 'name:"iPhone 15 Pro"'

// 前缀匹配（需要特殊处理）
filters: 'name:iPhone'

// 包含空格的值需要引号
filters: 'category:"Smart Phones"'

// 布尔值
filters: 'inStock:true'
filters: 'featured:false'

// 数组字段匹配任意元素
filters: 'tags:phone'

// 多个标签
filters: 'tags:phone AND tags:5g'

// 使用点号访问嵌套属性
filters: 'specs.ram:8GB'
filters: 'author.name:John'

// 单个分面值
facetFilters: ['brand:Apple']

// 多个条件（AND关系）
facetFilters: [
  'brand:Apple',
  'category:Phones',
  'inStock:true'
]

// 同一分面多选（OR关系）
facetFilters: [
  ['brand:Apple', 'brand:Samsung', 'brand:Google']
]

// 复杂组合
facetFilters: [
  ['brand:Apple', 'brand:Samsung'],  // Apple或Samsung
  'category:Phones',                  // 且是手机
  ['color:Black', 'color:White'],    // 且是黑色或白色
  'inStock:true'                      // 且有库存
]

// 单个条件
numericFilters: ['price < 1000']

// 多个条件
numericFilters: [
  'price >= 500',
  'price <= 1000',
  'rating > 4'
]

numericFilters: [
  'price >= 500',
  'price <= 1000',
  'stock > 0',
  'rating >= 4'
]

// 单个标签
tagFilters: ['phone']

// 多个标签（AND关系）
tagFilters: ['phone', '5g']

// OR关系
tagFilters: [['phone', 'tablet']]

// 记录结构
{
  "_tags": ["phone", "5g", "apple"]
}

// 或使用tags字段
{
  "tags": ["phone", "5g", "apple"]
}

// filters - 更灵活
filters: 'brand:Apple AND (price < 1000 OR rating > 4)'

// facetFilters - 更简单
facetFilters: ['brand:Apple']  // 只能做简单的AND/OR

// optionalFilters - 不影响搜索结果，只影响排名
index.search('phone', {
  optionalFilters: ['brand:Apple<score=2>'],
  filters: 'inStock:true'
});

// Apple品牌的结果排名更高，但不排除其他品牌

// 为过滤器设置评分权重
index.search('phone', {
  optionalFilters: [
    'brand:Apple<score=5>',
    'brand:Samsung<score=3>'
  ]
});

function buildFilters(conditions) {
  const parts = [];
  
  if (conditions.brand) {
    parts.push(`brand:${conditions.brand}`);
  }
  
  if (conditions.minPrice || conditions.maxPrice) {
    const priceFilters = [];
    if (conditions.minPrice) {
      priceFilters.push(`price >= ${conditions.minPrice}`);
    }
    if (conditions.maxPrice) {
      priceFilters.push(`price <= ${conditions.maxPrice}`);
    }
    parts.push(`(${priceFilters.join(' AND ')})`);
  }
  
  if (conditions.inStock) {
    parts.push('inStock:true');
  }
  
  return parts.join(' AND ');
}

// 使用
const filters = buildFilters({
  brand: 'Apple',
  minPrice: 500,
  maxPrice: 1000,
  inStock: true
});
// 结果: "brand:Apple AND (price >= 500 AND price <= 1000) AND inStock:true"

function escapeFilterValue(value) {
  // 转义特殊字符
  return value.replace(/([\\'"(){}[\]:])/g, '\\$1');
}

// 使用
const userInput = "O'Reilly";
const safeValue = escapeFilterValue(userInput);
filters: `brand:"${safeValue}"`

// 使用数组形式避免注入
const brand = "O'Reilly";
const filters = `brand:${JSON.stringify(brand)}`;

// ✅ 推荐：使用facetFilters
facetFilters: ['brand:Apple', 'category:Phones']

// ⚠️ 可行但较慢：使用filters
filters: 'brand:Apple AND category:Phones'

// ❌ 避免：过度嵌套
filters: '((brand:Apple OR brand:Samsung) AND (price < 1000 OR rating > 4)) OR (brand:Google AND price < 800)'

// ✅ 推荐：简化条件
filters: 'brand:Apple AND price < 1000'

async function filterProducts(options) {
  const {
    query = '',
    brands = [],
    categories = [],
    minPrice,
    maxPrice,
    inStock,
    minRating,
    colors = [],
    sizes = []
  } = options;
  
  const filterParts = [];
  
  // 品牌过滤
  if (brands.length > 0) {
    filterParts.push(`(${brands.map(b => `brand:${b}`).join(' OR ')})`);
  }
  
  // 分类过滤
  if (categories.length > 0) {
    filterParts.push(`(${categories.map(c => `category:${c}`).join(' OR ')})`);
  }
  
  // 价格范围
  if (minPrice !== undefined || maxPrice !== undefined) {
    const priceParts = [];
    if (minPrice !== undefined) priceParts.push(`price >= ${minPrice}`);
    if (maxPrice !== undefined) priceParts.push(`price <= ${maxPrice}`);
    filterParts.push(`(${priceParts.join(' AND ')})`);
  }
  
  // 库存过滤
  if (inStock !== undefined) {
    filterParts.push(`inStock:${inStock}`);
  }
  
  // 评分过滤
  if (minRating !== undefined) {
    filterParts.push(`rating >= ${minRating}`);
  }
  
  // 颜色过滤
  if (colors.length > 0) {
    filterParts.push(`(${colors.map(c => `color:${c}`).join(' OR ')})`);
  }
  
  // 尺寸过滤
  if (sizes.length > 0) {
    filterParts.push(`(${sizes.map(s => `size:${s}`).join(' OR ')})`);
  }
  
  return await index.search(query, {
    filters: filterParts.join(' AND '),
    facets: ['brand', 'category', 'color', 'size']
  });
}

async function filterContent(options) {
  const {
    query = '',
    types = [],
    authors = [],
    tags = [],
    dateFrom,
    dateTo,
    status = 'published'
  } = options;
  
  const filterParts = [];
  
  // 状态过滤
  filterParts.push(`status:${status}`);
  
  // 类型过滤
  if (types.length > 0) {
    filterParts.push(`(${types.map(t => `type:${t}`).join(' OR ')})`);
  }
  
  // 作者过滤
  if (authors.length > 0) {
    filterParts.push(`(${authors.map(a => `author.id:${a}`).join(' OR ')})`);
  }
  
  // 标签过滤
  if (tags.length > 0) {
    filterParts.push(`(${tags.map(t => `tags:${t}`).join(' OR ')})`);
  }
  
  // 日期范围
  if (dateFrom || dateTo) {
    const dateParts = [];
    if (dateFrom) dateParts.push(`publishedAt >= ${dateFrom}`);
    if (dateTo) dateParts.push(`publishedAt <= ${dateTo}`);
    filterParts.push(`(${dateParts.join(' AND ')})`);
  }
  
  return await index.search(query, {
    filters: filterParts.join(' AND '),
    facets: ['type', 'author.name', 'tags']
  });
}

async function geoSearch(options) {
  const {
    query = '',
    lat,
    lng,
    radius = 10000,  // 10公里
    country,
    city
  } = options;
  
  const searchParams = {
    facets: ['country', 'city']
  };
  
  // 地理位置过滤
  if (lat && lng) {
    searchParams.aroundLatLng = `${lat},${lng}`;
    searchParams.aroundRadius = radius;
  }
  
  // 国家/城市过滤
  const filterParts = [];
  if (country) filterParts.push(`country:${country}`);
  if (city) filterParts.push(`city:${city}`);
  
  if (filterParts.length > 0) {
    searchParams.filters = filterParts.join(' AND ');
  }
  
  return await index.search(query, searchParams);
}

class FilterBuilder {
  constructor() {
    this.filters = [];
  }
  
  equals(field, value) {
    this.filters.push(`${field}:${JSON.stringify(value)}`);
    return this;
  }
  
  notEquals(field, value) {
    this.filters.push(`${field} != ${JSON.stringify(value)}`);
    return this;
  }
  
  in(field, values) {
    const conditions = values.map(v => `${field}:${JSON.stringify(v)}`);
    this.filters.push(`(${conditions.join(' OR ')})`);
    return this;
  }
  
  range(field, min, max) {
    const conditions = [];
    if (min !== undefined) conditions.push(`${field} >= ${min}`);
    if (max !== undefined) conditions.push(`${field} <= ${max}`);
    this.filters.push(`(${conditions.join(' AND ')})`);
    return this;
  }
  
  greaterThan(field, value) {
    this.filters.push(`${field} > ${value}`);
    return this;
  }
  
  lessThan(field, value) {
    this.filters.push(`${field} < ${value}`);
    return this;
  }
  
  boolean(field, value) {
    this.filters.push(`${field}:${value}`);
    return this;
  }
  
  build() {
    return this.filters.join(' AND ');
  }
}

// 使用
const builder = new FilterBuilder();
const filters = builder
  .in('brand', ['Apple', 'Samsung'])
  .range('price', 500, 1000)
  .boolean('inStock', true)
  .greaterThan('rating', 4)
  .build();
// 结果: "(brand:Apple OR brand:Samsung) AND (price >= 500 AND price <= 1000) AND inStock:true AND rating > 4"