elasticSearch之API：文本分词，分词器的使用（中）

秃了也弱了。2026-01-27 8:58

文章目录

书接上文

官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/7.10/analysis-tokenfilters.html

五、Token过滤器使用

1、内置过滤器：apostrophe撇号

删除引号之后的所有字符，包括引号本身。

这个过滤器被包含在 Elasticsearch 自带的 土耳其语分析器 中。该分析器使用了 Lucene 的 ApostropheFilter 这一专为土耳其语设计的过滤器。

json 复制代码 
GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["apostrophe"],
  "text" : "Istanbul'a veya Istanbul'dan"
}

// 结果数组：去掉撇号和撇号之后的
[ Istanbul, veya, Istanbul ]
json 复制代码 
PUT /apostrophe_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_apostrophe": {
          "tokenizer": "standard",
          "filter": [ "apostrophe" ] // 添加到分析器中
        }
      }
    }
  }
}

2、内置过滤器：asciifolding转拉丁文

asciifolding会将那些不属于基本拉丁文Unicode区块内的字母、数字和符号字符转换为它们的ASCII等效形式（如果这样的ASCII编码存在的话）。例如，该过滤器会将"à"转换为"a"。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["asciifolding"],
  "text" : "açaí à la carte"
}
// 结果数组：
[ acai, a, la, carte ]

// 将过滤器添加到分析器中
PUT /asciifold_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_asciifolding": {
          "tokenizer": "standard",
          "filter": [ "asciifolding" ]
        }
      }
    }
  }
}

可选参数：
preserve_original：

json 复制代码 
PUT /asciifold_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_asciifolding": {
          "tokenizer": "standard",
          "filter": [ "my_ascii_folding" ]
        }
      },
      "filter": {
        "my_ascii_folding": {
          "type": "asciifolding",
          "preserve_original": true // 配置修改为true
        }
      }
    }
  }
}

3、内置过滤器：cjk_bigram 双字符组合

cjk_bigram从CJK（中文、日文和韩文）标记中形成二元词组。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["cjk_bigram"],
  "text" : "東京都は、日本の首都であり"
}
// 结果数组：
[ 東京, 京都, 都は, 日本, 本の, の首, 首都, 都で, であ, あり ]
// 添加到分析器
PUT /cjk_bigram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_cjk_bigram": {
          "tokenizer": "standard",
          "filter": [ "cjk_bigram" ]
        }
      }
    }
  }
}

可选参数：
ignored_scripts：用于禁用二元组合的字符脚本数组。（可选值：han - 韩文、hangul - 朝鲜文、hiragana - 平假名、katakana - 片假名）所有非中文字符输入内容都会原封不动地被传递过去。
output_unigrams：（可选，布尔值）如果设置为true，则需以二元组以及单字的形式来生成令牌；如果设置为false，那么当某个中文字符没有相邻字符时，该字符就会以单字的形式被输出。默认值为false。

json 复制代码 
// 定制
PUT /cjk_bigram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "han_bigrams": {
          "tokenizer": "standard",
          "filter": [ "han_bigrams_filter" ]
        }
      },
      "filter": {
        "han_bigrams_filter": {
          "type": "cjk_bigram",
          "ignored_scripts": [
            "hangul",
            "hiragana",
            "katakana"
          ],
          "output_unigrams": true
        }
      }
    }
  }
}

4、内置过滤器：cjk_width（统一全半角）

cjk_width以如下方式消除中文、日文和韩文字符之间的宽度差异：

将全宽ASCII字符形式折叠为相应的基本拉丁字符形式。

将半宽幅的片假名字符变体折叠成相应的普通片假名字符。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "standard",
  "filter" : ["cjk_width"],
  "text" : "ｼｰｻｲﾄﾞﾗｲﾅｰ"
}
// 结果
シーサイドライナー
// 添加到分析器中
PUT /cjk_width_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_cjk_width": {
          "tokenizer": "standard",
          "filter": [ "cjk_width" ]
        }
      }
    }
  }
}

5、内置过滤器：classic

classic过滤器会删除单词末尾的英语所有格符号（"'s"），同时也会去掉缩写词中的点号。它使用了Lucene的ClassicFilter插件来实现这一功能。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "classic",
  "filter" : ["classic"],
  "text" : "The 2 Q.U.I.C.K. Brown-Foxes jumped over the lazy dog's bone."
}
// 结果
[ The, 2, QUICK, Brown, Foxes, jumped, over, the, lazy, dog, bone ]

// 添加到分析器中使用
PUT /classic_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "classic_analyzer": {
          "tokenizer": "classic",
          "filter": [ "classic" ]
        }
      }
    }
  }
}

6、内置过滤器：common_grams

common_grams为指定的一组常用词汇生成个二元词组。

例如，你可以将 is 和 the 视为常见词汇。该过滤器会随后将标记 [the, quick, fox, is, brown] 转换为标记 [the, the_quick, quick, fox, fox_is, is, is_brown, brown]。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "whitespace",
  "filter" : [
    {
      "type": "common_grams",
      "common_words": ["is", "the"]
    }
  ],
  "text" : "the quick fox is brown"
}

// 结果：
[ the, the_quick, quick, fox, fox_is, is, is_brown, brown ]
// 添加到分析器
PUT /common_grams_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "index_grams": {
          "tokenizer": "whitespace",
          "filter": [ "common_grams" ]
        }
      },
      "filter": {
        "common_grams": {
          "type": "common_grams",
          "common_words": [ "a", "is", "the" ]
        }
      }
    }
  }
}

可选参数：
common_words：（必填项，字符串数组）这些令牌的列表。过滤器会为这些令牌生成二元组合。必须选择这两个选项中的一个，或者同时使用参数common_words_path。
common_words_path：（必填项，字符串类型）包含令牌列表的文件的路径。该过滤器会针对这些令牌生成二元组。这条路径必须是相对于 config 位置的绝对路径或相对路径。该文件必须采用 UTF-8 编码格式，文件中的每个数据项都必须用换行符分隔开来。必须选择这两个选项中的一个，或者同时使用参数common_words。
ignore_case：不区分大小写。默认设置为false
query_mode：（可选，布尔值）如果设置为true，则该过滤器会从输出结果中排除以下内容：常见单词的单词形式、由术语加上常见单词构成的单词组合。默认值为false。我们建议为个search 分析器启用此参数。例如，你可以启用这个参数，并将 is 和 the 视为常见词汇。该过滤器会将标记 [the, quick, fox, is, brown] 转换为 [the_quick, quick, fox_is, is_brown,]。

json 复制代码 
// 定制一个分析器
PUT /common_grams_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "index_grams": {
          "tokenizer": "whitespace",
          "filter": [ "common_grams_query" ]
        }
      },
      "filter": {
        "common_grams_query": {
          "type": "common_grams",
          "common_words": [ "a", "is", "the" ],
          "ignore_case": true,
          "query_mode": true
        }
      }
    }
  }
}

7、内置过滤器：condition

condition将一组token过滤器应用于那些符合所提供谓词脚本中设定条件的token。

json 复制代码 
// 示例：匹配那些在THE QUICK BROWN FOX中长度小于5个字符的字符串。随后，该请求会对这些符合条件的字符串应用lowercase过滤条件，将其转换为小写形式。
GET /_analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "condition",
      "filter": [ "lowercase" ],
      "script": {
        "source": "token.getTerm().length() < 5"
      }
    }
  ],
  "text": "THE QUICK BROWN FOX"
}
// 结果：
[ the, QUICK, BROWN, fox ]

可选配置：
filter：（必填项，表示令牌过滤器的数组）该数组用于存储令牌过滤器。如果某个令牌与 script 参数中的谓词脚本相匹配，那么这些过滤器就会按照指定的顺序对该令牌进行处理。这些过滤器可以包括在索引映射中定义的自定义令牌过滤器。
script：（必需项，脚本对象）用于应用令牌过滤器的谓词脚本。如果某个令牌与该脚本匹配，那么filter参数中定义的过滤器就会被应用于该令牌。

json 复制代码 
// 示例，自定义分析器：会匹配流中的第一个标记，随后会利用reverse过滤器来反转这个被匹配到的标记。
PUT /palindrome_list
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_reverse_first_token": {
          "tokenizer": "whitespace",
          "filter": [ "reverse_first_token" ]
        }
      },
      "filter": {
        "reverse_first_token": {
          "type": "condition",
          "filter": [ "reverse" ],
          "script": {
            "source": "token.getPosition() === 0"
          }
        }
      }
    }
  }
}

8、内置过滤器：decimal_digit数字转换

decimal_digit将Unicode中属于"通用类别"编号Decimal_Number的所有数字都转换为编号0-9。例如，该过滤器会将孟加拉语中的数字编号৩转换为编号3。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["decimal_digit"],
  "text" : "१-one two-२ ३"
}
// 结果：
[ 1-one, two-2, 3]

// 添加到分析器
PUT /decimal_digit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_decimal_digit": {
          "tokenizer": "whitespace",
          "filter": [ "decimal_digit" ]
        }
      }
    }
  }
}

9、内置过滤器：delimited_payload 边界数据载荷

旧名称delimited_payload_filter已经过时了，不应再用于新的索引中。请使用delimited_payload代替它。

例如，你可以使用带有 delimited_payload 分隔符的 | 过滤器，将 the|1 quick|2 fox|3 分解为 the、quick 和 fox 这三个标记，它们对应的有效载荷分别为 1、2 和 3。

请注意，analyze API并不会返回存储的负载数据。

json 复制代码 
// 示例：采用默认的|分隔符来将the|0 brown|10 fox|5 is|0 quick|10内容分割成各个标记和数据字段。
GET _analyze
{
  "tokenizer": "whitespace",
  "filter": ["delimited_payload"],
  "text": "the|0 brown|10 fox|5 is|0 quick|10"
}
// 结果：
[ the, brown, fox, is, quick ]
// 添加到分析器
PUT delimited_payload
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_delimited_payload": {
          "tokenizer": "whitespace",
          "filter": [ "delimited_payload" ]
        }
      }
    }
  }
}

可选配置：
delimiter：（可选，字符串类型）用于区分标记与数据内容的字符。默认值为|。
encoding：（可选，字符串类型）用于存储数据的内容类型。有效值包括：float、identity、int。

json 复制代码 
// 示例：使用+分隔符来将数据中的标记与实际负载内容区分开来。这些负载内容会被编码为整数形式。
PUT delimited_payload_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_plus_delimited": {
          "tokenizer": "whitespace",
          "filter": [ "plus_delimited" ]
        }
      },
      "filter": {
        "plus_delimited": {
          "type": "delimited_payload",
          "delimiter": "+",
          "encoding": "int"
        }
      }
    }
  }
}

（1）返回存储的负载数据

json 复制代码 
// 1、使用创建索引的API来创建一个满足以下条件的索引：
// 其中包含一个用于存储带有负载信息的术语向量的字段。
// 使用带delimited_payload过滤功能的自定义索引分析器。
PUT text_payloads
{
  "mappings": {
    "properties": {
      "text": {
        "type": "text",
        "term_vector": "with_positions_payloads",
        "analyzer": "payload_delimiter"
      }
    }
  },
  "settings": {
    "analysis": {
      "analyzer": {
        "payload_delimiter": {
          "tokenizer": "whitespace",
          "filter": [ "delimited_payload" ]
        }
      }
    }
  }
}
// 2、向索引中添加包含有效负载的文档。
POST text_payloads/_doc/1
{
  "text": "the|0 brown|3 fox|4 is|0 quick|10"
}
// 3、使用术语向量API可获取文档中的标记信息及其经过Base64编码的数据内容。
GET text_payloads/_termvectors/1
{
  "fields": [ "text" ],
  "payloads": true
}
// 4、API返回以下响应内容：
{
  "_index": "text_payloads",
  "_type": "_doc",
  "_id": "1",
  "_version": 1,
  "found": true,
  "took": 8,
  "term_vectors": {
    "text": {
      "field_statistics": {
        "sum_doc_freq": 5,
        "doc_count": 1,
        "sum_ttf": 5
      },
      "terms": {
        "brown": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 1,
              "payload": "QEAAAA=="
            }
          ]
        },
        "fox": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 2,
              "payload": "QIAAAA=="
            }
          ]
        },
        "is": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 3,
              "payload": "AAAAAA=="
            }
          ]
        },
        "quick": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 4,
              "payload": "QSAAAA=="
            }
          ]
        },
        "the": {
          "term_freq": 1,
          "tokens": [
            {
              "position": 0,
              "payload": "AAAAAA=="
            }
          ]
        }
      }
    }
  }
}

10、内置过滤器：dictionary_decompounder

在大多数情况下，我们建议使用速度更快的hyphenation_decompounder标记过滤器来替代这个过滤器。不过，在将某个词表应用到dictionary_decompounder过滤器中之前，你也可以使用hyphenation_decompounder过滤器来检查该词表的质量。

dictionary_decompounder使用预先指定的单词列表，并通过暴力搜索方法在复合词中查找子词。若找到相应的子词，它们就会被包含在最终的输出结果中。

json 复制代码 
// 示例：使用了dictionary_decompounder过滤机制来在Donaudampfschiff中查找子词。该过滤机制随后会将这些子词与指定的单词列表Donau、dampf、meer和schiff进行比对。
GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "dictionary_decompounder",
      "word_list": ["Donau", "dampf", "meer", "schiff"]
    }
  ],
  "text": "Donaudampfschiff"
}
// 结果数组：
[ Donaudampfschiff, Donau, dampf, schiff ]

可选配置：
word_list：（必填*，字符串数组）这是在令牌流中需要查找的子词列表。如果找到相应的子词，它将被包含在令牌输出中。必须指定这个参数或word_list_path中的其中一个。
word_list_path：（必填*，字符串类型）包含需在标记流中查找的子词列表的文件路径。若找到相应子词，它将被包含在标记输出结果中。该路径必须是以config位置为基准的绝对路径或相对路径，且文件必须采用UTF-8编码。文件中的每个内容单元都必须用换行符分隔。必须指定这个参数或word_list中的其中一个。
max_subword_size：（可选，整数）子词的最大字符长度。超过此长度的子词将被排除在输出结果之外。默认值为15
min_subword_size：（可选，整数）子词的最小字符长度。长度过短的子词将被排除在输出结果之外。默认值为2
min_word_size：（可选，整数）单词的最小字符长度。长度过短的单词将被排除在输出结果之外。默认值为5
only_longest_match：（可选，布尔值）如果true仅包含最长的匹配子词。默认值为false

json 复制代码 
// 示例：这个自定义的dictionary_decompounder过滤器会从analysis/example_word_list.txt文件中查找子词。长度超过22个字符的子词不会被包含在过滤结果中。
PUT dictionary_decompound_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_dictionary_decompound": {
          "tokenizer": "standard",
          "filter": [ "22_char_dictionary_decompound" ]
        }
      },
      "filter": {
        "22_char_dictionary_decompound": {
          "type": "dictionary_decompounder",
          "word_list_path": "analysis/example_word_list.txt",
          "max_subword_size": 22
        }
      }
    }
  }
}

11、内置过滤器：edge_ngram

从某个标记的起始位置开始，形成长度为n的n元组。

例如，你可以使用edge_ngram标记过滤器将quick替换为qu。

在未进行自定义设置的情况下，该过滤器会默认生成长度为1个字符的 edge n-grams。

json 复制代码 
// 示例：将the quick brown fox jumps转换为由1个或2个字符组成的边n-gram格式：
GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    { "type": "edge_ngram",
      "min_gram": 1,
      "max_gram": 2
    }
  ],
  "text": "the quick brown fox jumps"
}
// 结果数组：
[ t, th, q, qu, b, br, f, fo, j, ju ]
// 添加到分析器中
PUT edge_ngram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_edge_ngram": {
          "tokenizer": "standard",
          "filter": [ "edge_ngram" ]
        }
      }
    }
  }
}

可选配置：
max_gram：（可选，整数）词元的最大字符长度。对于自定义令牌过滤器，默认值为2；对于内置的edge_ngram过滤器，默认值为1。
min_gram：（可选，整数）标签的最小字符长度。默认值为1。
preserve_original：（可选，布尔值）设置为该值时会输出原始令牌，默认值为false。
side：（可选，字符串类型）已过时。该参数用于指定是否需要截断 front 或 back 中的字符序列。默认值为 front。无需使用back值，你可以在reverse过滤器前后使用edge_ngram标记过滤器来达到相同的效果。

json 复制代码 
// 自定义：以下请求会创建一个自定义的edge_ngram过滤器，该过滤器用于生成由3到5个字符组成的n元组。
PUT edge_ngram_custom_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "3_5_edgegrams" ]
        }
      },
      "filter": {
        "3_5_edgegrams": {
          "type": "edge_ngram",
          "min_gram": 3,
          "max_gram": 5
        }
      }
    }
  }
}

12、内置过滤器：elision

会删除标记开头处的指定省略内容。例如，可以使用此过滤器将l'avion替换为avion。

在未进行自定义设置的情况下，该过滤器会默认删除以下法语语言中的省略形式：
l', m', t', qu', n', s', j', d', c', jusqu', quoiqu', lorsqu', puisqu'

json 复制代码 
// 示例：从j'examine près du wharf中删除了j'
GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["elision"],
  "text" : "j'examine près du wharf"
}
// 结果：
[ examine, près, du, wharf ]
// 添加到分析器：
PUT /elision_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_elision": {
          "tokenizer": "whitespace",
          "filter": [ "elision" ]
        }
      }
    }
  }
}

可选配置：
articles：（必填，字符串数组）需要删除的元素列表。若要删除该省略符号，它必须位于某个标记的起始位置，并且其后必须紧跟着一个撇号。此时，省略符号与撇号都需要被删除。对于自定义的elision过滤器，必须指定此参数或articles_path中的其中一个。
articles_path：（必填*，字符串类型）包含需删除内容的文件路径。该文件中列出了需要删除的所有项目。该路径必须是相对于config位置的绝对路径或相对路径，且文件必须采用UTF-8编码。文件中的每条内容都必须以换行符分隔。若要删除该省略符号，它必须位于某个字符的起始位置，并且其后必须紧跟着一个撇号。此时，省略符号与撇号都需要被删除。对于自定义的elision过滤器，必须指定此参数或articles中的其中一个。
articles_case：（可选，布尔值）如果true省略匹配不区分大小写。默认false

json 复制代码 
// 示例：创建一个自定义的、不区分大小写的过滤规则。该规则会删除elision、l'、m'、t'、qu'、n'及s'这些内容。
PUT /elision_case_insensitive_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "elision_case_insensitive" ]
        }
      },
      "filter": {
        "elision_case_insensitive": {
          "type": "elision",
          "articles": [ "l", "m", "t", "qu", "n", "s", "j" ],
          "articles_case": true
        }
      }
    }
  }
}

13、内置过滤器：fingerprint

从令牌流中筛选并删除重复的令牌，随后将剩余的令牌连接成单个输出令牌。

例如，该过滤器会按如下方式修改[ the, fox, was, very, very, quick ]标记流：

1.按字母顺序对令牌进行排序，最终得到[ fox, quick, the, very, very, was ]。

2.删除重复的very令牌实例。

3.将令牌流连接成单个输出令牌：[fox quick the very was ]

json 复制代码 
// 示例：为文本zebra jumps over resting resting dog生成了一个唯一的输出令牌：
GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["fingerprint"],
  "text" : "zebra jumps over resting resting dog"
}
// 结果：
[ dog jumps over resting zebra ]
// 添加到分析器中
PUT fingerprint_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_fingerprint": {
          "tokenizer": "whitespace",
          "filter": [ "fingerprint" ]
        }
      }
    }
  }
}

可选配置：
max_output_size：（可选，整数）输出标记的最大字符长度，包括空白字符。默认值为255，长度超过此限制的连续字符序列将不会产生任何输出结果。
separator：（可选，字符串类型）用于连接令牌流输入内容的字符。默认值为空格。

json 复制代码 
// 例如，以下请求用于创建一个自定义的fingerprint过滤器；该过滤器使用+方法将多个令牌流连接起来。同时，该过滤器还会将输出内容的字符长度限制在100个或更少。
PUT custom_fingerprint_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_": {
          "tokenizer": "whitespace",
          "filter": [ "fingerprint_plus_concat" ]
        }
      },
      "filter": {
        "fingerprint_plus_concat": {
          "type": "fingerprint",
          "max_output_size": 100,
          "separator": "+"
        }
      }
    }
  }
}

14、内置过滤器：synonym_graph（不常用）

synonym_graph可简化由图令牌过滤器生成的令牌图，例如synonym_graph或word_delimiter_graph所生成的格式。

如果可能的话，应避免使用flatten_graph过滤器。请仅在搜索分析器中使用图谱标记过滤器。这样一来就无需使用flatten_graph过滤器了。

15、内置过滤器：hunspell（不常用）

该功能基于所提供的Hunspell词典，实现字典词干提取功能。hunspell过滤器需要通过配置来指定一个或多个特定语言的Hunspell词典。

如果条件允许，我们建议在使用hunspell标记过滤器之前，先尝试使用适用于您所使用语言的算法化词干提取工具。实际上，算法化词干提取器的效果通常优于基于词典的词干提取器。

16、内置过滤器：hyphenation_decompounder（不常用）

使用基于XML的连字符分割规则来识别复合词中的潜在子词。这些子词随后会与指定的词汇列表进行比对；未出现在列表中的子词将被排除在输出结果之外。

17、内置过滤器：keep_types（保留、排除类型）

用于保留或删除特定类型的标记。例如，你可以使用此过滤器将"3 quick foxes"替换为"quick foxes"，同时仅保留"<ALPHANUM>"这种字母数字格式的标记。

在将字符转换为标记时，标记类型由分词器来确定。不同分词器的标记类型可能有所不同。

例如，standard分词器能够生成多种类型的标记，包括<ALPHANUM>、<HANGUL>和<NUM>。而较简单的分析器，如lowercase分词器，仅能生成word这种类型的标记。

某些标记过滤器还可以添加新的标记类型。例如，synonym过滤器便可添加<SYNONYM>这种标记类型。

json 复制代码 
// 示例：保留数字类型
GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "keep_types",
      "types": [ "<NUM>" ]
    }
  ],
  "text": "1 quick fox 2 lazy dogs"
}
// 结果数组：
[ 1, 2 ]
json 复制代码 
// 示例：排除数字类型
GET _analyze
{
  "tokenizer": "standard",
  "filter": [
    {
      "type": "keep_types",
      "types": [ "<NUM>" ],
      "mode": "exclude"
    }
  ],
  "text": "1 quick fox 2 lazy dogs"
}
// 结果数组：
[ quick, fox, lazy, dogs ]

可选配置：
types：（必填项，字符串数组）需要保留或删除的令牌类型列表。
mode：（可选，字符串类型）用于指示是保留还是删除指定的令牌类型。有效值包括：include（保留，默认） 、 exclude（排除）

json 复制代码 
// 示例：保留<ALPHANUM>（字母数字字符）
PUT keep_types_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "standard",
          "filter": [ "extract_alpha" ]
        }
      },
      "filter": {
        "extract_alpha": {
          "type": "keep_types",
          "types": [ "<ALPHANUM>" ]
        }
      }
    }
  }
}

18、内置过滤器：keep（保留指定词汇）

keep仅保留指定词汇表中的词条。

json 复制代码 
// 示例：保留指定词汇表中的词条
GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "keep",
      "keep_words": [ "dog", "elephant", "fox" ]
    }
  ],
  "text": "the quick fox jumps over the lazy dog"
}
// 示例：
[ fox, dog ]

可选参数：
keep_words：（必填，字符串数组）需要保留的单词列表。只有与该列表中的单词匹配的条目才会被包含在输出结果中。必须指定这个参数或keep_words_path中的其中一个。
keep_words_path：（必填*，字符串数组）包含需保留的单词列表的文件路径。只有与该列表中的单词匹配的词条才会被包含在输出结果中。该路径必须是以config位置为基准的绝对路径或相对路径，且文件必须采用UTF-8编码。文件中的每个单词之间需用换行符分隔。必须指定这个参数或keep_words中的其中一个。
keep_words_case：（可选，布尔值）如果true所有单词均使用小写形式。默认设置为false。

json 复制代码 
// 示例：保留指定词汇或者文件中的词汇
PUT keep_words_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_keep_word_array": {
          "tokenizer": "standard",
          "filter": [ "keep_word_array" ]
        },
        "standard_keep_word_file": {
          "tokenizer": "standard",
          "filter": [ "keep_word_file" ]
        }
      },
      "filter": {
        "keep_word_array": {
          "type": "keep",
          "keep_words": [ "one", "two", "three" ]
        },
        "keep_word_file": {
          "type": "keep",
          "keep_words_path": "analysis/example_word_list.txt"
        }
      }
    }
  }
}

19、内置过滤器：keyword_marker

20、内置过滤器：keyword_repeat

21、内置过滤器：kstem词干提取

该工具为英语提供了基于KStem的词干提取功能。其kstem过滤机制结合了算法化的词干提取技术与内置的词典。

kstem过滤器在去除词干时的力度通常不如其他英语词干提取过滤器，比如porter_stem过滤器。

kstem过滤器相当于stemmer过滤器的light_english版本。

json 复制代码 
// 示例：提取词干
GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "kstem" ],
  "text": "the foxes jumping quickly"
}
// 结果数组：
[ the, fox, jump, quick ]
// 分析器中使用
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "whitespace",
          "filter": [
            "lowercase",
            "kstem"
          ]
        }
      }
    }
  }
}

22、内置过滤器：length

length会删除长度小于或大于指定字符数的字符串。例如，使用length过滤器可以排除长度少于2个字符或超过5个字符的字符串。

length过滤器会删除所有令牌。如果您希望将令牌缩短为特定长度，可使用truncate过滤器。

json 复制代码 
// 示例：剔除长度超过4个字符的字符串
GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "length",
      "min": 0,
      "max": 4
    }
  ],
  "text": "the quick brown fox jumps over the lazy dog"
}
// 结果数组：
[ the, fox, over, the, lazy, dog ]
// 添加到分析器
PUT length_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_length": {
          "tokenizer": "standard",
          "filter": [ "length" ]
        }
      }
    }
  }
}

可选参数：
min：（可选，整数）令牌的最小字符长度。过短的令牌将被排除在输出结果之外。默认值为0
max：（可选，整数）令牌的最大字符长度。超过该长度的令牌将不会被包含在输出结果中。默认值为Integer.MAX_VALUE

json 复制代码 
// 以下请求会创建一个自定义的length过滤器，该过滤器会删除长度小于2个字符或超过10个字符的字符串：
PUT length_custom_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_length_2_to_10_char": {
          "tokenizer": "whitespace",
          "filter": [ "length_2_to_10_char" ]
        }
      },
      "filter": {
        "length_2_to_10_char": {
          "type": "length",
          "min": 2,
          "max": 10
        }
      }
    }
  }
}

23、内置过滤器：limit（限制长度）

limit过滤器常用于根据令牌数量来控制文档字段值的长度。

默认情况下，limit过滤器仅保留数据流中的第一个元素。例如，该过滤器可将数据流[ one, two, three ]中的内容转换为[ one ]形式。

可选配置：
max_token_count：（可选，整数值）可保留的最大令牌数量。达到此限制后，任何剩余的令牌都将被排除在输出结果之外。默认值为1.
consume_all_tokens：（可选，布尔值）如果true过滤器会过滤掉令牌流中的所有内容，即便其中包含某些东西也不例外。默认值为false。

json 复制代码 
// 示例：保留前两个token
GET _analyze
{
  "tokenizer": "standard",
    "filter": [
    {
      "type": "limit",
      "max_token_count": 2
    }
  ],
  "text": "quick fox jumps over lazy dog"
}
// 结果数组：
[ quick, fox ]
// 添加到分析器
PUT limit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_one_token_limit": {
          "tokenizer": "standard",
          "filter": [ "limit" ]
        }
      }
    }
  }
}
json 复制代码 
// 自定义分析器：保留前五个token
PUT custom_limit_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_five_token_limit": {
          "tokenizer": "whitespace",
          "filter": [ "five_token_limit" ]
        }
      },
      "filter": {
        "five_token_limit": {
          "type": "limit",
          "max_token_count": 5
        }
      }
    }
  }
}

24、内置过滤器：lowercase（转小写）

将标记文本转换为小写。例如，可以使用lowercase过滤器将THE Lazy DoG转换为the lazy dog。

除了默认过滤器外，lowercase令牌过滤器还提供了针对希腊语、爱尔兰语和土耳其语的Lucene语言专用小写转换功能。

json 复制代码 
// 示例：转小写
GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["lowercase"],
  "text" : "THE Quick FoX JUMPs"
}
// 结果：
[ the, quick, fox, jumps ]
// 添加到分析器
PUT lowercase_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "whitespace_lowercase": {
          "tokenizer": "whitespace",
          "filter": [ "lowercase" ]
        }
      }
    }
  }
}

可选参数：
language：（可选，字符串类型）需使用的语言特定小写字符过滤规则。有效值包括：（greek、irish-爱尔兰语、turkish-土耳其语）

json 复制代码 
// 示例：为希腊语创建一个自定义的lowercase过滤器
PUT custom_lowercase_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "greek_lowercase_example": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["greek_lowercase"]
        }
      },
      "filter": {
        "greek_lowercase": {
          "type": "lowercase",
          "language": "greek"
        }
      }
    }
  }
}

25、内置过滤器：min_hash

26、内置过滤器：multiplexer

27、内置过滤器：ngram（指定提取长度）

从某个标记中提取出长度为至n的指定长度的n-gram序列。

例如，你可以使用ngram标记过滤器将fox替换为[ f, fo, o, ox, x ]。

json 复制代码 
// 示例：将Quick fox转换成由1个或2个字符组成的n-gram字符串：
GET _analyze
{
  "tokenizer": "standard",
  "filter": [ "ngram" ],
  "text": "Quick fox"
}
// 结果：
[ Q, Qu, u, ui, i, ic, c, ck, k, f, fo, o, ox, x ]
// 添加到分析器
PUT ngram_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "standard_ngram": {
          "tokenizer": "standard",
          "filter": [ "ngram" ]
        }
      }
    }
  }
}

可选参数：
max_gram：（可选，整数）一个词组中字符的最大长度。默认值为2.
min_gram：（可选，整数）gram中字符的最小长度。默认值为1.
preserve_original：（可选，布尔值）设置为true值时会输出原始令牌。默认值为false

你可以使用index.max_ngram_diff这一索引级设置来控制max_gram与min_gram数值之间允许的最大差异。

json 复制代码 
// 自定义：以下请求会创建一个自定义的ngram过滤器，该过滤器用于生成由3到5个字符组成的n-gram字符串。同时，该请求还会将index.max_ngram_diff设置的值调整为2。
PUT ngram_custom_example
{
  "settings": {
    "index": {
      "max_ngram_diff": 2
    },
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "3_5_grams" ]
        }
      },
      "filter": {
        "3_5_grams": {
          "type": "ngram",
          "min_gram": 3,
          "max_gram": 5
        }
      }
    }
  }
}

28、内置过滤器：Normalization （特殊字符标准化）

29、内置过滤器：pattern_capture（正则捕捉）

30、内置过滤器：pattern_replace（正则替换）

使用正则表达式来匹配并替换相应的子字符串。

json 复制代码 
// 示例：将watch添加到dog中foxes jump lazy dogs这个子字符串的前面。
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "pattern_replace",
      "pattern": "(dog)",
      "replacement": "watch$1"
    }
  ],
  "text": "foxes jump lazy dogs"
}
// 结果：
[ foxes, jump, lazy, watchdogs ]

可选参数：
all：默认true，将所有匹配的字符串都替换，如果为false只会替换第一个匹配到的。
pattern：（必填，字符串类型）以正则表达式形式编写的字符串。
replacement：（可选，字符串类型）替换子字符串。默认值为空字符串。

json 复制代码 
// 示例：使用正则表达式[£|€]来识别并删除货币符号£及€。该过滤器的all参数为false，这意味着每个字符串中仅会删除第一个匹配到的货币符号。
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "keyword",
          "filter": [
            "my_pattern_replace_filter"
          ]
        }
      },
      "filter": {
        "my_pattern_replace_filter": {
          "type": "pattern_replace",
          "pattern": "[£|€]",
          "replacement": "",
          "all": false
        }
      }
    }
  }
}

31、内置过滤器：phonetic（音标）

32、内置过滤器：porter_stem（词干提取）

33、内置过滤器：predicate_token_filter（脚本）

会删除与所提供的谓词脚本不匹配的标记。该过滤器仅支持内嵌式的"简单易用"格式的脚本。

json 复制代码 
// 示例：仅显示长度超过三个字符的令牌
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [
    {
      "type": "predicate_token_filter",
      "script": {
        "source": """
          token.term.length() > 3
        """
      }
    }
  ],
  "text": "the fox jumps the lazy dog"
}
// 结果：
[ jumps, lazy ]

34、内置过滤器：remove_duplicates （去重）

删除处于相同位置的重复令牌。

json 复制代码 
GET _analyze
{
  "tokenizer": "whitespace",
  "filter": [
    "keyword_repeat",
    "stemmer",
    "remove_duplicates" // 去重
  ],
  "text": "jumping dog"
}
// 添加到分析器中：
PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_custom_analyzer": {
          "tokenizer": "standard",
          "filter": [
            "keyword_repeat",
            "stemmer",
            "remove_duplicates"
          ]
        }
      }
    }
  }
}

35、内置过滤器：reverse

反转流中的每个字符顺序。例如，可以使用reverse过滤器将cat转换为tac。

反向标记对于基于后缀的搜索非常有用------例如查找以-ion结尾的单词，或根据文件扩展名来搜索文件。

json 复制代码 
// 示例：
GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["reverse"],
  "text" : "quick fox jumps"
}
// 结果：
[ kciuq, xof, spmuj ]
// 添加到分析器
PUT reverse_example
{
  "settings" : {
    "analysis" : {
      "analyzer" : {
        "whitespace_reverse" : {
          "tokenizer" : "whitespace",
          "filter" : ["reverse"]
        }
      }
    }
  }
}

36、内置过滤器：shingle（组词）

默认情况下，shingle标记过滤器会输出由两个单词组成的词段以及单字。

例如，许多分词器会将the lazy dog转换为[ the, lazy, dog ]。你可以使用shingle过滤器来为该数据流添加由两个单词组成的片段：[ the, the lazy, lazy, lazy dog, dog ]。

json 复制代码 
GET /_analyze
{
  "tokenizer": "whitespace",
  "filter": [ "shingle" ],
  "text": "quick brown fox jumps"
}
// 结果：
[ quick, quick brown, brown, brown fox, fox, fox jumps, jumps ]

可选配置：
max_shingle_size：（可选，整数值）生成分片时可连接的最大令牌数量。默认值为2。该值不得低于min_shingle_size参数所设定的数值，其默认值为2。该值与min_shingle_size参数之间的差值不得超过index.max_shingle_diff所规定的索引级限制，其默认值为3。
min_shingle_size：（可选，整数值）在生成分片时需连接的最少令牌数量。默认值为1。
output_unigrams：（可选，布尔值）如果true,输出中包含原始输入的字符序列。默认值为true.
output_unigrams_if_no_shingles：如果选择true，则只有在没有产生"瓦片"结构时，输出中才会包含原始输入内容；若产生了"瓦片"结构，输出中仅包含这些"瓦片"内容。默认值为false。如果此参数与output_unigrams参数均为true，则仅使用output_unigrams参数。
token_separator：（可选，字符串类型）在Shingles中用于替代那些不包含任何标记的空位置的字符串。这种填充标记仅用于Shingles格式，而不适用于原始的单字符数据。默认值为下划线 (_)。

json 复制代码 
// 示例：生成的片段长度为2至5个单词。该过滤器还包含output_unigrams中的false参数，这意味着最终输出中仅包含这样的片段。
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "en": {
          "tokenizer": "standard",
          "filter": [ "my_shingle_filter" ]
        }
      },
      "filter": {
        "my_shingle_filter": {
          "type": "shingle",
          "min_shingle_size": 2,
          "max_shingle_size": 5,
          "output_unigrams": false
        }
      }
    }
  }
}

37、内置过滤器：snowball（多语言词干提取）

38、内置过滤器：stemmer（词干提取）

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "stemmer" ],
  "text": "the foxes jumping quickly"
}
// 结果：
[ the, fox, jump, quickli ]

39、内置过滤器：stemmer_override（按规则词干提取）

通过应用自定义映射来覆盖词干提取算法，从而防止这些词被词干提取工具修改。该规则必须置于任何词干提取过滤器之前。

40、内置过滤器：stop（停用词）

从令牌流中删除停用词。

在未进行自定义设置的情况下，该过滤器会默认删除以下英文停用词：a, an, and, are, as, at, be, but, by, for, if, in, into, is, it, no, not, of, on, or, such, that, the, their, then, there, these, they, this, to, was, will, with。

除了英语外，该过滤器还支持多种语言的预定义停用词列表。你也可以以数组或文件的形式自定义停用词。

json 复制代码 
// 示例
GET /_analyze
{
  "tokenizer": "standard",
  "filter": [ "stop" ],
  "text": "a quick fox jumps over the lazy dog"
}
// 结果：
[ quick, fox, jumps, over, lazy, dog ]

可选配置：
stopwords：（可选，字符串类型或字符串数组）语言代码值，例如_arabic_或_thai_。默认值为_english_。每个语言对应的值都对应着Lucene中预定义的停用词列表。对于空白的停用词列表，请使用_none_。
stopwords_path：（可选，字符串类型）包含需删除的停用词列表的文件路径。
ignore_case：（可选，布尔值）如果true停用词匹配不区分大小写。默认值为false
remove_trailing：（可选，布尔值）如果选择true，则流中的最后一个标记若为停用词将被删除。默认值为true。

json 复制代码 
// 创建一个自定义的、区分大小写的过滤规则，该规则仅删除停用词stop、and和is：
PUT /my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "default": {
          "tokenizer": "whitespace",
          "filter": [ "my_custom_stop_words_filter" ]
        }
      },
      "filter": {
        "my_custom_stop_words_filter": {
          "type": "stop",
          "ignore_case": true,
          "stopwords": [ "and", "is", "the" ]
        }
      }
    }
  }
}

41、内置过滤器：synonym（同义词）

42、内置过滤器：synonym_graph（同义词）

43、内置过滤器：trim（去空格）

trim 会删除流中每个标记前后多余的空白字符。虽然这可能会改变标记的长度，但trim过滤器不会改变标记在流中的位置。

json 复制代码 
// 使用trim过滤器
PUT trim_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "keyword_trim": {
          "tokenizer": "keyword",
          "filter": [ "trim" ]
        }
      }
    }
  }
}

44、内置过滤器：truncate（截断）

truncate会截断超过指定字符长度的字符串。默认限制为10个字符，但可通过length参数进行自定义设置。

json 复制代码 
GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["truncate"],
  "text" : "the quinquennial extravaganza carried on"
}
// 
// 示例：超过5个词截断
PUT 5_char_words_example
{
  "settings": {
    "analysis": {
      "analyzer": {
        "lowercase_5_char": {
          "tokenizer": "lowercase",
          "filter": [ "5_char_trunc" ]
        }
      },
      "filter": {
        "5_char_trunc": {
          "type": "truncate",
          "length": 5
        }
      }
    }
  }
}

可选参数：
length：（可选，整数）每个标记的最大字符数。超过此限制的标记将被截断。默认值为10.

45、内置过滤器：unique（去重）

从数据流中删除重复的标记。例如，可以使用unique过滤器将the lazy lazy dog替换为the lazy dog。

如果将only_on_same_position参数设置为true，那么unique过滤器仅会删除位于相同位置的重复字符。

当only_on_same_position等于true时，unique过滤器的功能与remove_duplicates过滤器完全相同。

json 复制代码 
GET _analyze
{
  "tokenizer" : "whitespace",
  "filter" : ["unique"],
  "text" : "the quick fox jumps the lazy fox"
}
// 结果：
[ the, quick, fox, jumps, lazy ]

46、内置过滤器：uppercase（转大写）

将标记文本转换为大写。例如，可以使用uppercase过滤器将the Lazy DoG转换为THE LAZY DOG。

根据不同语言的规定，一个大写字符可能对应多个小写字符。使用uppercase过滤器可能会导致小写字符信息丢失。为避免这种损失同时仍保持字母大小写的一致性，可使用lowercase过滤器。

json 复制代码 
GET _analyze
{
  "tokenizer" : "standard",
  "filter" : ["uppercase"],
  "text" : "the Quick FoX JUMPs"
}
// 结果：
[ THE, QUICK, FOX, JUMPS ]

47、内置过滤器：word_delimiter

48、内置过滤器：word_delimiter_graph

相关推荐
萤丰信息2 小时前
四大核心技术领航，智慧园区重构产业生态新范式
java·大数据·人工智能·智慧城市·智慧园区
H7998742422 小时前
2026动态捕捉推荐：8款专业产品全方位测评
大数据·前端·人工智能
virtaitech2 小时前
趋动科技OrionX社区版免费申请
大数据·人工智能·科技·免费·池化技术
秃了也弱了。2 小时前
elasticSearch之API：文本分词，分词器的使用（下）
大数据·elasticsearch
财经三剑客2 小时前
蔚来汽车2025年共交付32.6万辆，同比增长46.9%
大数据·汽车
LJ97951112 小时前
告别“通稿地狱”：Infoseek智能媒体发布如何重塑内容分发的游戏规则
大数据·人工智能
草莓熊Lotso2 小时前
Qt 按钮与显示类控件实战：从交互到展示全攻略
大数据·开发语言·c++·人工智能·qt·microsoft·交互
TechubNews2 小时前
Techub News 專訪高鋒集團合夥人、Web3Labs行政總裁黃俊瑯：以資本與生態，賦能傳統企業Web3轉型
大数据·网络·人工智能·区块链
火星数据-Tina2 小时前
体育平台搭建：如何高效引入赛事直播与比分数据
大数据·前端·网络
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04Open Code教程（四）| 高级配置与集成05UV安装并设置国内源06Linux下V2Ray安装配置指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09Antigravity AI编程工具添加和使用Skill完整教程10安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）