« Built-in analyzer reference Token filter reference »

› ›

分词器参考

分词器参考

一个分词器接收一个字符流，将其分解成单独的词元（通常是单个单词），并输出一个词元流。例如，一个空白分词器在看到任何空白时将文本分解成词元。它会将文本"Quick brown fox!"转换为词元[Quick, brown, fox!]。

分词器还负责记录以下内容：

每个词项的顺序或位置（用于短语和词接近查询）
原始词的开始和结束字符偏移量，该词项所代表的（用于高亮搜索片段）。
词元类型，每个词项的分类，例如、或。更简单的分析器只产生word词元类型。

Elasticsearch 有许多内置的分词器，可以用来构建自定义分析器。

面向单词的分词器

以下分词器通常用于将全文分词为单个单词：

Standard Tokenizer: standard 分词器根据 Unicode 文本分段算法在单词边界上将文本分割成词条。它会移除大多数标点符号。它是大多数语言的最佳选择。
Letter Tokenizer: The letter tokenizer 在遇到不是字母的字符时将文本分割成词条。
Lowercase Tokenizer: The lowercase tokenizer（小写分词器），类似于letter tokenizer（字母分词器），在遇到非字母字符时将文本分割成词条，但它还会将所有词条转换为小写。
Whitespace Tokenizer: The whitespace tokenizer 在遇到任何空白字符时将文本分割成词项。
UAX URL Email Tokenizer: uax_url_email 分词器类似于 standard 分词器，但它将 URL 和电子邮件地址识别为单个标记。
Classic Tokenizer: The classic tokenizer 是基于语法的英语分词器。
Thai Tokenizer: The thai 分词器将泰语文本分割成单词。

部分词标记器

这些分词器将文本或单词分解成小片段，用于部分单词匹配：

N-Gram Tokenizer: ngram 分词器可以在遇到任何指定的字符列表（例如空白或标点符号）时将文本分解成单词，然后返回每个单词的 n-gram：一个连续字母的滑动窗口，例如 quick → [qu, ui, ic, ck]。
Edge N-Gram Tokenizer: edge_ngram 分词器可以在遇到任何指定的字符列表（例如空格或标点符号）时将文本分解成单词，然后返回每个单词的n-gram，这些n-gram锚定在单词的开头，例如 quick → [q, qu, qui, quic, quick]。

结构化文本分词器

以下分词器通常用于结构化文本，如标识符、电子邮件地址、邮政编码和路径，而不是用于全文：

Keyword Tokenizer: keyword 分词器是一个“无操作”分词器，它接受任何给定的文本，并输出与输入完全相同的文本作为一个单一的词项。它可以与分词过滤器（如 lowercase）结合使用，以规范化分析的词项。
Pattern Tokenizer: The pattern tokenizer 使用正则表达式在匹配到单词分隔符时将文本分割成词条，或者将匹配的文本捕获为词条。
Simple Pattern Tokenizer: simple_pattern 分词器使用正则表达式来捕获匹配的文本作为词条。它使用了一组受限制的正则表达式特性，并且通常比 pattern 分词器更快。
Char Group Tokenizer: char_group 分词器可以通过设置字符集来进行分割，这通常比运行正则表达式更高效。
Simple Pattern Split Tokenizer: simple_pattern_split 分词器使用与 simple_pattern 分词器相同的受限正则表达式子集，但会在匹配处拆分输入，而不是将匹配项作为词项返回。
Path Tokenizer: path_hierarchy 分词器接受一个类似文件系统路径的分层值，根据路径分隔符进行分割，并为树中的每个组件生成一个词项，例如 /foo/bar/baz → [/foo, /foo/bar, /foo/bar/baz ]。

字符组分词器

The char_group tokenizer 在遇到定义集合中的字符时，会将文本分解为词项。它主要适用于需要简单自定义分词的场景，并且使用 pattern tokenizer 的开销不可接受的情况。

配置

The char_group tokenizer 接受一个参数：

`tokenize_on_chars`	包含用于对字符串进行分词的字符列表。每当遇到此列表中的字符时，就会开始一个新的标记。这接受单个字符，例如 `-`，或字符组：`空白`、`字母`、`数字`、`标点符号`、`符号`。
`max_token_length`	最大标记长度。如果遇到超过此长度的标记，则会在`max_token_length`间隔处分割。默认为`255`。

示例输出

POST _analyze
{
  "tokenizer": {
    "type": "char_group",
    "tokenize_on_chars": [
      "whitespace",
      "-",
      "\n"
    ]
  },
  "text": "The QUICK brown-fox"
}

返回

{
  "tokens": [
    {
      "token": "The",
      "start_offset": 0,
      "end_offset": 3,
      "type": "word",
      "position": 0
    },
    {
      "token": "QUICK",
      "start_offset": 4,
      "end_offset": 9,
      "type": "word",
      "position": 1
    },
    {
      "token": "brown",
      "start_offset": 10,
      "end_offset": 15,
      "type": "word",
      "position": 2
    },
    {
      "token": "fox",
      "start_offset": 16,
      "end_offset": 19,
      "type": "word",
      "position": 3
    }
  ]
}

经典分词器

The classic tokenizer 是一种基于语法的分词器，适用于英语文档。该分词器具有对首字母缩略词、公司名称、电子邮件地址和互联网主机名的特殊处理规则。然而，这些规则并不总是有效，并且该分词器对于除英语之外的大多数语言效果不佳：

它会在大多数标点符号处拆分单词，并去除标点符号。然而，如果没有跟随空格的点被视为标记的一部分。
它会在连字符处拆分单词，除非标记中有数字，在这种情况下，整个标记被解释为产品编号，不会被拆分。
它将电子邮件地址和互联网主机名识别为一个标记。

示例输出

POST _analyze
{
  "tokenizer": "classic",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述句子将生成以下术语：

[ The, 2, QUICK, Brown, Foxes, jumped, over, the, lazy, dog's, bone ]

配置

The classic tokenizer 接受以下参数：

max_token_length

最大标记长度。如果遇到超过此长度的标记，则会在max_token_length间隔处分割。默认为255。

示例配置

在这个示例中，我们将 classic 分词器配置为具有 5 的 max_token_length（仅用于演示目的）：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "classic",
          "max_token_length": 5
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述示例产生以下术语：

[ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog's, bone ]

边缘n-gram分词器

The edge_ngram tokenizer首先在遇到指定字符列表中的一个字符时将文本分解为单词，然后它发出每个单词的N-grams，其中N-gram的开始锚定在单词的开头。

Edge N-Grams 对于 边输入边搜索 查询非常有用。

当你需要对具有广泛已知顺序的文本（如电影或歌曲标题）进行即时搜索时，完成建议器比边缘N-grams更为高效。边缘N-grams在尝试自动完成可以以任何顺序出现的单词时具有优势。

示例输出

使用默认设置，edge_ngram 分词器将初始文本视为一个单一的词元，并生成最小长度为 1 和最大长度为 2 的 N-grams：

POST _analyze
{
  "tokenizer": "edge_ngram",
  "text": "Quick Fox"
}

上述句子将生成以下术语：

[ Q, Qu ]

这些默认的gram长度几乎完全无用。在使用edge_ngram之前，您需要对其进行配置。

配置

The edge_ngram tokenizer 接受以下参数：

min_gram

字符在n-gram中的最小长度。默认为1。

max_gram

一个词组中的最大字符长度。默认为 2。

参见 max_gram 参数的限制。

token_chars

应包含在标记中的字符类。Elasticsearch 将分割不属于指定类别的字符。默认值为 []（保留所有字符）。

字符类可以是以下任意一种：

letter — 例如 a, b, ï 或 京
digit — 例如 3 或 7
whitespace — 例如 " " 或 "\n"
punctuation — 例如 ! 或 "
symbol — 例如 $ 或 √
custom — 自定义字符，需要使用 custom_token_chars 设置进行设置。

custom_token_chars

自定义字符，应视为标记的一部分。例如，将其设置为 +-_ 将使分词器将加号、减号和下划线符号视为标记的一部分。

`max_gram`参数的限制

The edge_ngram tokenizer的max_gram值限制了token的字符长度。当edge_ngram tokenizer与索引分析器一起使用时，这意味着搜索词的长度超过max_gram长度可能不会匹配任何索引的词。

例如，如果 max_gram 是 3，搜索 apple 将不会匹配索引项 app。

为了解决这个问题，你可以使用 truncate 词元过滤器与搜索分析器来将搜索词缩短到 max_gram 字符长度。然而，这可能会返回不相关的结果。

例如，如果 max_gram 是 3 并且搜索词被截断为三个字符，搜索词 apple 被缩短为 app。这意味着搜索 apple 会返回任何匹配 app 的索引词，例如 apply、approximate 和 apple。

我们建议测试这两种方法，以了解哪种最适合您的用例和所需的搜索体验。

示例配置

在这个示例中，我们配置了 edge_ngram 分词器，使其将字母和数字视为标记，并生成最小长度为 2 和最大长度为 10 的n-gram：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "edge_ngram",
          "min_gram": 2,
          "max_gram": 10,
          "token_chars": [
            "letter",
            "digit"
          ]
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "2 Quick Foxes."
}

上述示例产生以下术语：

[ Qu, Qui, Quic, Quick, Fo, Fox, Foxe, Foxes ]

通常我们建议在索引时和搜索时使用相同的analyzer。在edge_ngram分词器的情况下，建议有所不同。仅在索引时使用edge_ngram分词器才有意义，以确保部分单词可用于索引中的匹配。在搜索时，只需搜索用户输入的术语，例如：Quick Fo。

下面是一个如何为即时搜索设置字段的示例。

请注意，索引分析器的 max_gram 值为 10，这限制了索引项最多为10个字符。搜索词不会被截断，这意味着超过10个字符的搜索词可能不会匹配任何索引项。

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "autocomplete": {
          "tokenizer": "autocomplete",
          "filter": [
            "lowercase"
          ]
        },
        "autocomplete_search": {
          "tokenizer": "lowercase"
        }
      },
      "tokenizer": {
        "autocomplete": {
          "type": "edge_ngram",
          "min_gram": 2,
          "max_gram": 10,
          "token_chars": [
            "letter"
          ]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "analyzer": "autocomplete",
        "search_analyzer": "autocomplete_search"
      }
    }
  }
}

PUT my-index-000001/_doc/1
{
  "title": "Quick Foxes" 
}

POST my-index-000001/_refresh

GET my-index-000001/_search
{
  "query": {
    "match": {
      "title": {
        "query": "Quick Fo", 
        "operator": "and"
      }
    }
  }
}

	The `autocomplete` analyzer indexes the terms `[qu, qui, quic, quick, fo, fox, foxe, foxes]`.
	The `autocomplete_search` analyzer searches for the terms `[quick, fo]`, both of which appear in the index.

关键词分词器

The keyword tokenizer 是一个“noop”分词器，它接受任何给定的文本，并将其原样输出为一个单一的词条。它可以与分词过滤器结合使用以规范化输出，例如将电子邮件地址转换为小写。

示例输出

POST _analyze
{
  "tokenizer": "keyword",
  "text": "New York"
}

上述句子将生成以下术语：

[ New York ]

与分词过滤器结合

您可以将 keyword 分词器与分词过滤器结合使用，以规范化结构化数据，例如产品ID或电子邮件地址。

例如，以下analyze API请求使用keyword分词器和lowercase过滤器将电子邮件地址转换为小写。

POST _analyze
{
  "tokenizer": "keyword",
  "filter": [ "lowercase" ],
  "text": "john.SMITH@example.COM"
}

请求生成以下令牌：

[ john.smith@example.com ]

配置

The keyword tokenizer 接受以下参数：

buffer_size

在单次传递中读入术语缓冲区的字符数。默认为 256。术语缓冲区将按此大小增长，直到所有文本都被消耗完。建议不要更改此设置。

字母分词器

The letter tokenizer 在遇到非字母字符时会将文本分解为词条。它对大多数欧洲语言表现良好，但对于一些亚洲语言则表现糟糕，因为在这些语言中单词之间没有空格。

示例输出

POST _analyze
{
  "tokenizer": "letter",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述句子将生成以下术语：

[ The, QUICK, Brown, Foxes, jumped, over, the, lazy, dog, s, bone ]

配置

The letter 分词器是不可配置的。

小写分词器

与letter tokenizer类似，lowercase tokenizer在遇到非字母字符时将文本拆分为词项，但它还会将所有词项转换为小写。它在功能上等同于letter tokenizer与lowercase token filter的结合，但由于它在单次遍历中执行这两个步骤，因此效率更高。

示例输出

POST _analyze
{
  "tokenizer": "lowercase",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述句子将生成以下术语：

[ the, quick, brown, foxes, jumped, over, the, lazy, dog, s, bone ]

配置

The lowercase tokenizer 是不可配置的。

N-gram 分词器

The ngram tokenizer首先在遇到指定字符列表中的一个字符时将文本分解为单词，然后它发出指定长度的每个单词的N-grams。

N-grams 就像一个滑动窗口，它在单词上移动 - 一个指定长度的连续字符序列。它们对于查询不使用空格或具有长复合词的语言（如德语）非常有用。

示例输出

使用默认设置，ngram 分词器将初始文本视为一个单一的标记，并生成最小长度为 1 和最大长度为 2 的 N-grams：

POST _analyze
{
  "tokenizer": "ngram",
  "text": "Quick Fox"
}

上述句子将生成以下术语：

[ Q, Qu, u, ui, i, ic, c, ck, k, "k ", " ", " F", F, Fo, o, ox, x ]

配置

The ngram tokenizer 接受以下参数：

`min_gram`	n-gram 中最小字符长度。默认为 `1`。
`max_gram`	n-gram 中字符的最大长度。默认为 `2`。
`token_chars`	应包含在标记中的字符类。Elasticsearch 将分割不属于指定类的字符。默认值为 `[]`（保留所有字符）。字符类可以是以下任意一种： `letter` — 例如 `a`、`b`、`ï` 或 `京` `digit` — 例如 `3` 或 `7` `whitespace` — 例如 `" "` 或 `"\n"` `punctuation` — 例如 `!` 或 `"` `symbol` — 例如 `$` 或 `√` `custom` — 需要使用 `custom_token_chars` 设置进行设置的自定义字符。
`自定义令牌字符`	自定义字符，应被视为标记的一部分。例如，将其设置为 `+-_` 将使分词器将加号、减号和下划线符号视为标记的一部分。

通常将 min_gram 和 max_gram 设置为相同的值是有意义的。长度越小，匹配的文档越多，但匹配的质量越低。长度越长，匹配的越具体。三元组（长度 3）是一个不错的起点。

索引级别设置 index.max_ngram_diff 控制 max_gram 和 min_gram 之间的最大允许差异。

示例配置

在这个示例中，我们配置 ngram 分词器将字母和数字视为标记，并生成三元组（长度为 3 的组）：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "ngram",
          "min_gram": 3,
          "max_gram": 3,
          "token_chars": [
            "letter",
            "digit"
          ]
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "2 Quick Foxes."
}

上述示例产生以下术语：

[ Qui, uic, ick, Fox, oxe, xes ]

路径层次分词器

The path_hierarchy tokenizer 接受一个类似文件系统路径的分层值，根据路径分隔符进行分割，并为树中的每个组件生成一个术语。The path_hierarcy tokenizer 在底层使用了 Lucene 的 PathHierarchyTokenizer。

示例输出

POST _analyze
{
  "tokenizer": "path_hierarchy",
  "text": "/one/two/three"
}

上述文本将生成以下术语：

[ /one, /one/two, /one/two/three ]

配置

The path_hierarchy tokenizer 接受以下参数：

`分隔符`	用于路径分隔符的字符。默认为 `/`。
`替换`	一个可选的替换字符，用于分隔符。默认为`delimiter`。
`buffer_size`	单次传递中读入词项缓冲区的字符数。默认为 `1024`。词项缓冲区将按此大小增长，直到所有文本都被消耗完。建议不要更改此设置。
`reverse`	如果为`true`，则使用Lucene的 ReversePathHierarchyTokenizer，该分词器适用于类似域名的层次结构。默认为`false`。
`跳过`	要跳过的初始令牌数量。默认为 `0`。

示例配置

在这个示例中，我们配置了 path_hierarchy 分词器，使其在 - 字符上进行分割，并用 / 替换它们。前两个标记被跳过：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "path_hierarchy",
          "delimiter": "-",
          "replacement": "/",
          "skip": 2
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "one-two-three-four-five"
}

上述示例产生以下术语：

[ /three, /three/four, /three/four/five ]

如果我们把reverse设置为true，它将产生以下结果：

[ one/two/three/, two/three/, three/ ]

详细示例

一个常见的使用场景是使用path_hierarchy分词器来过滤文件路径的结果。如果在索引文件路径及其数据时，使用path_hierarchy分词器来分析路径，可以允许通过文件路径字符串的不同部分来过滤结果。

此示例配置了一个索引，使其具有两个自定义分析器，并将这些分析器应用于存储文件名的file_path文本字段的多字段。其中两个分析器之一使用了反向分词。然后索引一些示例文档，以表示两个不同用户的照片文件夹中的某些文件路径。

PUT file-path-test
{
  "settings": {
    "analysis": {
      "analyzer": {
        "custom_path_tree": {
          "tokenizer": "custom_hierarchy"
        },
        "custom_path_tree_reversed": {
          "tokenizer": "custom_hierarchy_reversed"
        }
      },
      "tokenizer": {
        "custom_hierarchy": {
          "type": "path_hierarchy",
          "delimiter": "/"
        },
        "custom_hierarchy_reversed": {
          "type": "path_hierarchy",
          "delimiter": "/",
          "reverse": "true"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "file_path": {
        "type": "text",
        "fields": {
          "tree": {
            "type": "text",
            "analyzer": "custom_path_tree"
          },
          "tree_reversed": {
            "type": "text",
            "analyzer": "custom_path_tree_reversed"
          }
        }
      }
    }
  }
}

POST file-path-test/_doc/1
{
  "file_path": "/User/alice/photos/2017/05/16/my_photo1.jpg"
}

POST file-path-test/_doc/2
{
  "file_path": "/User/alice/photos/2017/05/16/my_photo2.jpg"
}

POST file-path-test/_doc/3
{
  "file_path": "/User/alice/photos/2017/05/16/my_photo3.jpg"
}

POST file-path-test/_doc/4
{
  "file_path": "/User/alice/photos/2017/05/15/my_photo1.jpg"
}

POST file-path-test/_doc/5
{
  "file_path": "/User/bob/photos/2017/05/16/my_photo1.jpg"
}

在文本字段中搜索特定文件路径字符串会匹配所有示例文档，由于标准分析器生成的术语之一也是bob，Bob的文档排名最高，从而提高了Bob文档的相关性。

GET file-path-test/_search
{
  "query": {
    "match": {
      "file_path": "/User/bob/photos/2017/05"
    }
  }
}

使用 file_path.tree 字段，可以简单地匹配或过滤存在于特定目录中的文件路径文档。

GET file-path-test/_search
{
  "query": {
    "term": {
      "file_path.tree": "/User/alice/photos/2017/05/16"
    }
  }
}

通过为这个分词器设置reverse参数，还可以从文件路径的另一端进行匹配，例如单个文件名或深层子目录。下面的示例展示了通过在映射中配置使用reverse参数的file_path.tree_reversed字段，在任何目录中搜索所有名为my_photo1.jpg的文件。

GET file-path-test/_search
{
  "query": {
    "term": {
      "file_path.tree_reversed": {
        "value": "my_photo1.jpg"
      }
    }
  }
}

查看通过正向和反向生成的令牌有助于展示为相同文件路径值创建的令牌。

POST file-path-test/_analyze
{
  "analyzer": "custom_path_tree",
  "text": "/User/alice/photos/2017/05/16/my_photo1.jpg"
}

POST file-path-test/_analyze
{
  "analyzer": "custom_path_tree_reversed",
  "text": "/User/alice/photos/2017/05/16/my_photo1.jpg"
}

当与其他类型的搜索结合使用时，能够根据文件路径进行过滤也非常有用，例如这个示例，查找任何包含 16 的文件路径，并且这些文件路径必须位于 Alice 的照片目录中。

GET file-path-test/_search
{
  "query": {
    "bool" : {
      "must" : {
        "match" : { "file_path" : "16" }
      },
      "filter": {
        "term" : { "file_path.tree" : "/User/alice" }
      }
    }
  }
}

模式分词器

The pattern tokenizer 使用正则表达式在匹配单词分隔符时将文本拆分为词条，或者将匹配的文本捕获为词条。

默认模式是 \W+，它会在遇到非单词字符时分割文本。

当心病态的正则表达式

模式分词器使用 Java 正则表达式。

一个编写糟糕的正则表达式可能会运行得非常缓慢，甚至抛出StackOverflowError，并导致运行它的节点突然退出。

了解更多关于病态正则表达式及其避免方法。

示例输出

POST _analyze
{
  "tokenizer": "pattern",
  "text": "The foo_bar_size's default is 5."
}

上述句子将生成以下术语：

[ The, foo_bar_size, s, default, is, 5 ]

配置

The pattern tokenizer 接受以下参数：

`模式`	一个 Java 正则表达式，默认为 `\W+`。
`标志`	Java 正则表达式标志。标志应使用竖线分隔，例如 `"CASE_INSENSITIVE\|COMMENTS"`。
`组`	要提取为标记的捕获组。默认为 `-1`（拆分）。

示例配置

在这个例子中，我们配置了 pattern 分词器，当遇到逗号时将文本拆分为标记：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "pattern",
          "pattern": ","
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "comma,separated,values"
}

上述示例产生以下术语：

[ comma, separated, values ]

在下一个示例中，我们配置了 pattern 分词器来捕获用双引号括起来的值（忽略嵌入的转义引号 \"）。正则表达式本身如下所示：

"((?:\\"|[^"]|\\")*)"

内容如下：

一个字面量 "
开始捕获：
- 一个字面量 \" 或除 " 之外的任何字符
- 重复直到没有更多字符匹配
一个字面量闭合 "

当模式在JSON中指定时，" 和 \ 字符需要进行转义，因此模式最终看起来像：

\"((?:\\\\\"|[^\"]|\\\\\")+)\"

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "pattern",
          "pattern": "\"((?:\\\\\"|[^\"]|\\\\\")+)\"",
          "group": 1
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "\"value\", \"value with embedded \\\" quote\""
}

上述示例产生以下两个术语：

[ value, value with embedded \" quote ]

简单模式分词器

The simple_pattern tokenizer 使用正则表达式来捕获匹配的文本作为词条。它支持的正则表达式功能比 pattern tokenizer 更有限，但分词速度通常更快。

此分词器不支持在模式匹配上拆分输入，与pattern分词器不同。要在使用相同受限正则表达式子集的模式匹配上进行拆分，请参阅simple_pattern_split分词器。

此分词器使用 Lucene 正则表达式。有关支持的功能和语法的解释，请参阅正则表达式语法。

默认模式是空字符串，不会生成任何词项。此分词器应始终配置为非默认模式。

配置

The simple_pattern tokenizer 接受以下参数：

`模式`	Lucene 正则表达式，默认为空字符串。

示例配置

此示例配置了 simple_pattern 分词器以生成三位数的术语

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "simple_pattern",
          "pattern": "[0123456789]{3}"
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "fd-786-335-514-x"
}

上述示例生成以下术语：

[ 786, 335, 514 ]

简单模式分割分词器

The simple_pattern_split tokenizer 使用正则表达式在模式匹配处将输入分割成词条。它支持的正则表达式功能比 pattern tokenizer 更有限，但分词通常更快。

此分词器不会从匹配项本身生成词条。要使用相同的受限正则表达式子集中的模式从匹配项生成词条，请参阅simple_pattern 分词器。

此分词器使用 Lucene 正则表达式。有关支持的功能和语法的解释，请参阅正则表达式语法。

默认模式是空字符串，这将生成一个包含完整输入的词项。此分词器应始终配置为非默认模式。

配置

The simple_pattern_split tokenizer 接受以下参数：

`模式`	一个 Lucene 正则表达式，默认为空字符串。

示例配置

此示例配置了 simple_pattern_split 分词器，以在输入文本中以下划线进行分割。

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "simple_pattern_split",
          "pattern": "_"
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "an_underscored_phrase"
}

上述示例生成以下术语：

[ an, underscored, phrase ]

标准分词器

The standard tokenizer 提供基于语法的分词（基于 Unicode 文本分段算法，如在 Unicode 标准附件 #29 中指定），并且适用于大多数语言。

示例输出

POST _analyze
{
  "tokenizer": "standard",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述句子将生成以下术语：

[ The, 2, QUICK, Brown, Foxes, jumped, over, the, lazy, dog's, bone ]

配置

The standard tokenizer 接受以下参数：

max_token_length

最大标记长度。如果遇到超过此长度的标记，则会在max_token_length间隔处分割。默认为255。

示例配置

在这个示例中，我们将 standard 分词器配置为具有 5 的 max_token_length（仅用于演示目的）：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "standard",
          "max_token_length": 5
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述示例产生以下术语：

[ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog's, bone ]

泰语分词器

The thai tokenizer 将泰语文本分词为单词，使用Java中包含的泰语分词算法。其他语言的文本通常会被视为与standard tokenizer相同。

此分词器可能不被所有JRE支持。已知在Sun/Oracle和OpenJDK中可以正常工作。如果您的应用程序需要完全可移植，请考虑使用ICU Tokenizer。

示例输出

POST _analyze
{
  "tokenizer": "thai",
  "text": "การที่ได้ต้องแสดงว่างานดี"
}

上述句子将生成以下术语：

[ การ, ที่, ได้, ต้อง, แสดง, ว่า, งาน, ดี ]

配置

The thai 分词器不可配置。

UAX URL 电子邮件分词器

The uax_url_email tokenizer 类似于 standard tokenizer，除了它将 URL 和电子邮件地址识别为单个标记。

示例输出

POST _analyze
{
  "tokenizer": "uax_url_email",
  "text": "Email me at john.smith@global-international.com"
}

上述句子将生成以下术语：

[ Email, me, at, john.smith@global-international.com ]

而 standard 分词器会产生：

[ Email, me, at, john.smith, global, international.com ]

配置

The uax_url_email tokenizer 接受以下参数：

max_token_length

最大标记长度。如果遇到超过此长度的标记，则会在max_token_length间隔处分割。默认为255。

示例配置

在这个示例中，我们配置了 uax_url_email 分词器，使其具有 5 的 max_token_length（仅用于演示目的）：

PUT my-index-000001
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "uax_url_email",
          "max_token_length": 5
        }
      }
    }
  }
}

POST my-index-000001/_analyze
{
  "analyzer": "my_analyzer",
  "text": "john.smith@global-international.com"
}

上述示例产生以下术语：

[ john, smith, globa, l, inter, natio, nal.c, om ]

空白分词器

The whitespace tokenizer 在遇到空白字符时将文本分解为词项。

示例输出

POST _analyze
{
  "tokenizer": "whitespace",
  "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."
}

上述句子将生成以下术语：

[ The, 2, QUICK, Brown-Foxes, jumped, over, the, lazy, dog's, bone. ]

配置

The whitespace tokenizer 接受以下参数：

max_token_length

最大标记长度。如果遇到超过此长度的标记，则会在max_token_length间隔处分割。默认为255。

« Built-in analyzer reference Token filter reference »