1. Character group tokenizer
2. Classic tokenizer
- 结果：[ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog’s, bone ]
4. Keyword tokenizer
5. Letter tokenizer
6. Lowercase tokenizer
7. N-gram tokenzier
- 结果：[ Qui, uic, ick, Fox, oxe, xes ]
- 因为第一个token:2不满足 min_gram=3，所以这个token被丢弃了；
text 类型的 file_path 字段索引时，采用的是 standard analyzer，
搜索文本处理后：[user,bob,photos,2017,05]，ES 会返回所有的文档，且 bob 的文档相关性最高
file_path.tree子字段索引时，采用的是 forward path_hierarchy tokenizer,
去匹配指定目录下的文档，非常便捷
返回结果：”/User/alice/photos/2017/05/16/“目录下的三个my_photo1,2,3.jpg文档全部返回
file_path.tree_reversed子字段，使用 reverse path_hierarchy,
用来匹配任何目录下的满足文件名的文档，非常便捷
返回结果：
“/User/alice/photos/2017/05/16/my_photo1.jpg”
“/User/alice/photos/2017/05/15/my_photo1.jpg”
“/User/bob/photos/2017/05/16/my_photo1.jpg”
可以对其他类型的搜索进行文件路径的过滤
搜索文件路径中包含16，且是在 Alice 的目录下的文档
返回结果：”/User/alice/photos/2017/05/16/“目录下的文档都返回了
9. Pattern tokenizer
处理结果：[ value, value with embedded \” quote ]
11. Simple pattern split tokenizer
处理结果：[ an, underscored, phrase ]
13. Thai tokenizer
14. UAX URL email tokenzier
15. Whitespace tokenizer

1. Character group tokenizer

定义一个字符集合，每当遇到一个集合中的字符，char_group tokenizer 就会将文本进行拆分；
- 它主要用于，当你想使用 pattern tokenizer 但是它的性能又比较低的时候，就可以使用 char_group tokenizer 自定义一个简单的分词器来满足类似 pattern 的需求；
可选配置： | 参数 | 参数说明 | | :—-: | :—-: | | tokenize_on_chars | 用作分割符的字符集合，它的值可以是单个字符(如，”-“)，也可以是whitesapce(“ “ or “\n”)，letter(a, b, ï or 京)，digit(3 or 7)，punctuation(! or “)，symbol($ or √) |

举例：

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

2. Classic tokenizer

classic tokenizer，可以说是为英语而生的分词器。这个分词器对于英文的首字符缩写、公司名字、 email 、大部分网站域名都能很好的解决。但是，对于英语之外的其他语言，就不是很好使。
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | max_token_length | token允许的最大长度，默认255 |

举例： ```json PUT my_index { “settings”: { “analysis”: {

"analyzer": {
  "my_analyzer": {
    "tokenizer": "my_tokenizer"
  }
},
"tokenizer": {
  "my_tokenizer": {
    "type": "classic",
    "max_token_length": 5
  }
}

} } }

POST my_index/_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 ]


<a name="gZV5h"></a>
# 3. Edge n-gram tokenizer

- **edge_ngram** tokenizer，会根据配置项 token_chars 中定义的指定字符集合来对文本进行拆分，然后对每个拆分后的单词进行 N-grams 处理，N-grams 处理后的 token 都是以单词的首字母作为开始；
- Edge N-Grams 适用于 search-as-you-type 查询
   - 但是当你键入的文本是类似电影名、歌曲名这类广为人知的被人熟悉的词时，completion suggester 是比 Edge N-Grams 更有效率的选择；
   - Edge N-Grams 处理普通单词的 autocomplete 时比较合适；

- **可选参数：**
| **参数** | **参数说明** |
| :---: | :---: |
| min_gram | gram分词后允许的最小长度，默认值1 |
| max_gram | gram分词后允许的最大长度，默认值2 |
| token_chars | ES将会以不在字符类型所属的字符为分割符，默认值：[]，保持文本内容不变；<br />例如，digit，会以非数字的字符作为分割符切分文本，token 中一定包含 digit；<br />支持：<br />- letter —  for example a, b, ï or 京<br />- digit —  for example 3 or 7<br />- whitespace —  for example " " or "\\n"<br />- punctuation — for example ! or "<br />- symbol —  for example $ or √<br />- custom —  custom characters which need to be set using the custom_token_chars setting.<br /> |
| custom_token_chars | **尚不明白用法** |

:::tips

- max_gram 参数的限制：
   - max_gram 限制了 token 的最大长度，例如 apple 做 N-Grams 处理后的词就是：[a, ap]；
   - 如果将 edge_ngram tokenizer 作为 Index Analyzer，那么搜索关键词（如 apple）长于 max_gram 时，可能没有任何能匹配的结果；
   - 面对上面的情况，又两种解决办法：
      - 搜索的时候，使用 truncate token filter 作为 search analyzer，将搜索关键词（如 apple）裁剪长度到 max_gram （如 ap）；但是这种情况会返回很多不相关的结果（如 apply，snapped）;
      - 索引的时候将 max_gram 增大，这样处理完的 token 仍会保留完整的单词（如 apple：[a,ap,app,appl,apple]），搜索的时候使用不同于索引时的 analyzer，搜索使用 standard analyzer 就可以将关键词 apple 匹配到正确的结果；
:::

:::info

- 通常 ES 建议 Search Analyzer 要与 Index Analyzer 保持一致；
- 但是当 edge_ngram tokenizer 作为 Index Analyzer 时，情况却不同，我们的目的是在将文本切分成不完整的 token 并且索引，这样在搜索的时候，当用户输入单词字符，例如：Quick Fo，不完整的单词字符 Fo 也能作为查询条件，返回相关的结果；
:::

- **举例：**how to set up a field for search-as-you-type
   - Index Analyzer 的 max_gram 设置为10，最大可被索引的 token 是10个字符，超过10个字符的搜索关键词不会又匹配结果返回；
```json
PUT my_index
{
  "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/_doc/1
{
  "title": "2 Quick Foxes" 
}
#因为索引使用 edge_ngram tokenizer，而token_chars是letter，切分的token一定包含letter,是 Quick Foxes；
#token经过 Edge N-Grams 处理的结果： [qu, qui, quic, quick, fo, fox, foxe, foxes]。

POST my_index/_refresh

GET my_index/_search
{
  "query": {
    "match": {
      "title": {
        "query": "Quick Fo", 
        "operator": "and"
      }
    }
  }
}
# 使用lowercase作为search analyzer的token filter，搜索文本处理结果：[quick, fo]，有匹配结果；

4. Keyword tokenizer

keyword tokenzier，将整个文本作为一个唯一的 token；
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | buffer_size | 一次性读取字符到 term buffer 中的大小，默认255。当 term buffer 不够时，会自动再增长255大小，直至读完文本。建议不要更改此设置； |

举例：

POST _analyze
{
"tokenizer": "keyword",
"filter": [ "lowercase" ],
"text": "john.SMITH@example.COM"
}
#####结果：[ john.smith@example.com ]

5. Letter tokenizer

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 ]

6. Lowercase tokenizer

lowercase tokenizer，和 letter tokenizer 一样，每当遇到不是字母的字符时，都会将文本分解为 Term，但它也会将所有 Term 都小写化。
它在功能上等同于 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 ]

7. N-gram tokenzier

ngram tokenizer，遇见指定字符集合中的字符时就将文本进行拆分，然后对每个切分后的单词进行 N-grams 处理；
N-grams 就像一个滑动窗口，它在单词上移动，就像一个指定长度的连续字符序列。它们对于查询不使用空格或具有长复合词（如德语）的语言非常有用。
- 文本：”Quick Fox”；
- 处理结果：[ Q, Qu, u, ui, i, ic, c, ck, k, “k “, “ “, “ F”, F, Fo, o, ox, x ]
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | min_gram | gram分词后允许的最小长度，默认值1 | | max_gram | gram分词后允许的最大长度，默认值2 | | token_chars | ES将会以不在字符类型所属的字符为分割符，默认值：[]，保持文本内容不变；
例如，digit，会以非数字的字符作为分割符切分文本，token 中一定包含 digit；
支持：
- letter — for example a, b, ï or 京
- digit — for example 3 or 7
- whitespace — for example “ “ or “\n”
- punctuation — for example ! or “
- symbol — for example $ or √
- custom — custom characters which need to be set using the custom_token_chars setting.
| | custom_token_chars | 尚不明白用法 |

:::tips

通常建议将 min-gram 和 max_gram 设置成相同的值；
长度越小，匹配的文档越多，但匹配的质量越低。长度越长，匹配越具体。
长度可以先从3开始设置，然后进行测试调整，tri-gram (长度3) 是一个很好的开始；
Index Settings 中可通过设置 index.max_gram_diff 来控制 max_gram 与 min_gram 之间允许的最大值； :::
举例：
- 将字母和数字以外的字符作为分割符，并且做 tri-grams 处理，token中不满足 min_grams 的将被丢弃； ```json PUT my_index { “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/_analyze { “analyzer”: “my_analyzer”, “text”: “2 Quick Foxes.” }

结果：[ Qui, uic, ick, Fox, oxe, xes ]

因为第一个token:2不满足 min_gram=3，所以这个token被丢弃了；


<a name="KkGnC"></a>
# 8. Path hierarchy tokenizer

- **path_hierarchy** tokenizer，接收一个类似文件系统路径的层次结构值，通过路径分割符拆分，将树结构中每个层级作为一个 term 输出；
   - 文本："/one/two/three"；
   - 处理结果：[ /one, /one/two, /one/two/three ]；
   - 最终输出的 token 一定是树状结构中的某一个部分值；
- **可选参数：**
| **参数** | **参数说明** |
| :---: | :---: |
| delimiter | 路径分割符，默认 "/" |
| replacement | 用于 delimiter 的可选替换字符。默认为 delimiter |
| buffer_size | 一次传递中读入 term buffer 的字符数，默认1024，term buffer 将按此大小增长，直到所有文本都被读完。建议不要更改此设置 |
| reverse | 如果设置为 true，则以相反的顺序输出 token，默认为false（注意参考举例：正常层级数的[123]，reverse后[321]） |
| skip | 要跳过的初始 token，默认为0。 |

- **举例：**
   - 分割符使用 "-"，且最后 term 中用 "/" 替换 "-"，且前两个初始 token 丢弃不要；
```json
PUT my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "path_hierarchy",
          "delimiter": "-",
          "replacement": "/",
          "skip": 2
        }
      }
    }
  }
}

POST my_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": "one-two-three-four-five"
}
####树状结构：one/two/three/four/five

#initial token：one two three four five
#reverse是false时：从树状结构顶部开始作为第一层级，从上往下数，层级数[123]
#skip 2 token：three four five
#最终输出的一定是树状结构中的某一个部分，只是要由 token 组成
#replacement /: ["/three","/three/four","/three/four/five"]

#########如果 path_hierarchy tokenizer 增加了 reverse:true
#initial token：one two three four five
#reverse是true时：从树状结构底部开始作为第一层级，从下往上数，层级数[321]
#skip 2 token：one two three
#最终输出的一定是树状结构中的某一个部分，只是要由 token 组成
#replacement /: ["one/two/three/","two/three/","three/"]

对 file_path 路径字段在索引时，使用两个自定义的 path_hierarchy tokenizer，path token 生成分别是 forward 和 reverse； ```json UT 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” }

text 类型的 file_path 字段索引时，采用的是 standard analyzer，

搜索文本处理后：[user,bob,photos,2017,05]，ES 会返回所有的文档，且 bob 的文档相关性最高

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

file_path.tree子字段索引时，采用的是 forward path_hierarchy tokenizer,

去匹配指定目录下的文档，非常便捷

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

返回结果：”/User/alice/photos/2017/05/16/“目录下的三个my_photo1,2,3.jpg文档全部返回

file_path.tree_reversed子字段，使用 reverse path_hierarchy,

用来匹配任何目录下的满足文件名的文档，非常便捷

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

返回结果：

“/User/alice/photos/2017/05/16/my_photo1.jpg”

“/User/alice/photos/2017/05/15/my_photo1.jpg”

“/User/bob/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” } } } } }

返回结果：”/User/alice/photos/2017/05/16/“目录下的文档都返回了


   - path_hierarchy tokenizer，forward 和 reverse 效果比较：
```json
POST file-path-test/_analyze
{
  "analyzer": "custom_path_tree",
  "text": "/User/alice/photos/2017/05/16/my_photo1.jpg"
}
#处理结果：
#/User
#/User/alice
#/User/alice/photos
#....
#/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"
}
#处理结果：
# /User/alice/photos/2017/05/16/my_photo1.jpg
# User/alice/photos/2017/05/16/my_photo1.jpg
# alice/photos/2017/05/16/my_photo1.jpg
# photos/2017/05/16/my_photo1.jpg
# 2017/05/16/my_photo1.jpg
# 05/16/my_photo1.jpg
# 16/my_photo1.jpg
# my_photo1.jpg

9. Pattern tokenizer

pattern tokenizer，使用正则表达式在匹配到分割符时拆分文本，或者将匹配到的文本捕获为 terms；
默认的匹配表达式是 \W+，遇到非单词时拆分文本；
pattern tokenizer 使用 Java 正则表达式；
写得不好的正则表达式可能运行的非常慢，甚至会抛出 StackOverflowError 并导致运行它的节点崩溃；
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | pattern | Java正则表达式，默认 \W+ | | flags | Java正则中的 flags，可以多个值，但是要用管道符 “|” 来分隔 | | group | 哪个 group 去抽取数据。默认是 to -1 (用pattern作为分割符去split). |
flags 参数的取值说明： | 编译标志 | 效果 | | :—-: | :—-: | | Pattern.CANON_EQ | 当且仅当两个字符的”正规分解(canonical decomposition)”都完全相同的情况下，才认定匹配。比如用了这个标志之后，表达式”a/u030A”会匹配”?”。默认情况下，不考虑”规范相等性(canonical equivalence)”。 | | Pattern.CASE_INSENSITIVE
(?i) | 默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。这个标志能让表达式忽略大小写进行匹配。要想对Unicode字符进行大小不明感的匹配，只要将UNICODE_CASE与这个标志合起来就行了。 | | Pattern.COMMENTS
(?x) | 在这种模式下，匹配时会忽略(正则表达式里的)空格字符(注：不是指表达式里的”//s”，而是指表达式里的空格，tab，回车之类)。注释从#开始，一直到这行结束。可以通过嵌入式的标志来启用Unix行模式。 | | Pattern.DOTALL
(?s) | 在这种模式下，表达式’.’可以匹配任意字符，包括表示一行的结束符。默认情况下，表达式’.’不匹配行的结束符。 | | Pattern.MULTILINE
(?m) | 在这种模式下，’^’和’$’分别匹配一行的开始和结束。此外，’^’仍然匹配字符串的开始，’$’也匹配字符串的结束。默认情况下，这两个表达式仅仅匹配字符串的开始和结束。 | | Pattern.UNICODE_CASE
(?u) | 在这个模式下，如果你还启用了CASE_INSENSITIVE标志，那么它会对Unicode字符进行大小写不明感的匹配。默认情况下，大小写不明感的匹配只适用于US-ASCII字符集。 | | Pattern.UNIX_LINES
(?d) | 在这个模式下，只有’/n’才被认作一行的中止，并且与’.’，’^’，以及’$’进行匹配。 |
group 捕获组参数说明：
- 普通捕获组（Expression）：从正则表达式左侧开始，每出现一个左括号”(“记做一个分组，分组编号从 1 开始。0 代表整个表达式。例如：对于时间字符串：2017-04-25，表达式如下 (\d{4})-((\d{2})-(\d{2}))
  - group(0)，捕获组 (\d{4})-((\d{2})-(\d{2}))，匹配 2017-04-25；
  - group(1)，捕获组 (\d{4})，匹配 2017；
  - group(2)，捕获组 ((\d{2})-(\d{2}))，匹配 04-25；
  - group(3)，捕获组 (\d{2})，匹配 04；
  - group(4)，捕获组 (\d{2})，匹配 25；
- 命名捕获组（?Expression）：每个以左括号开始的捕获组，都紧跟着 ?，而后才是正则表达式。例如：对于时间字符串：2017-04-25，表达式如下 (?
  \d{4})-(?
  (?
  \d{2})-(?\d{2}))
  
  group(0)，捕获组 (\d{4})-((\d{2})-(\d{2}))，匹配 2017-04-25；
  group(“year”)，捕获组 (\d{4})，匹配 2017；
  group(“md”)，捕获组 ((\d{2})-(\d{2}))，匹配 04-25；
  group(“month”)，捕获组 (\d{2})，匹配 04；
  group(“date”)，捕获组 (\d{2})，匹配 25；
  命名的捕获组同样也可以使用编号获取相应值。
- 非捕获组（?:Expression）：在左括号后紧跟 ?:，而后再加上正则表达式。例如：对于时间字符串：2017-04-25，表达式如下 (?:\d{4})-((\d{2})-(\d{2}))
  - group(0)，捕获组 (\d{4})-((\d{2})-(\d{2}))，匹配 2017-04-25；
  - group(1)，捕获组 ((\d{2})-(\d{2}))，匹配 04-25；
  - group(2)，捕获组 (\d{2})，匹配 04；
  - group(3)，捕获组 (\d{2})，匹配 25；
  - 这个正则表达式虽然有四个左括号，理论上有 4 个捕获组。但是第一组 (?:\d{4})，其实是被忽略的。当使用 matcher.group(4) 时，系统会报错 IndexOutOfBoundsException。
举例：
- “((?:\“|[^”]|\“)*)” 正则表达式：通过 pattern 去捕获双引号内的文本，但是忽略文本中的引号，仅仅将它当作一个引号字符；
- 注意：在 JSON 中写 pattern 正则表达式，” 和 \ 字符都需要转义； ```json PUT my_index { “settings”: { “analysis”: { “analyzer”: { “my_analyzer”: {
```
 "tokenizer": "my_tokenizer"
```
  } }, “tokenizer”: { “my_tokenizer”: {
```
 "type": "pattern",
 "pattern": "\"((?:\\\\\"|[^\"]|\\\\\")+)\"",
 "group": 1
```
  } } } } }

POST my_index/_analyze { “analyzer”: “my_analyzer”, “text”: “\”value\”, \”value with embedded \\” quote\”” }

处理结果：[ value, value with embedded \” quote ]


<a name="FMZlU"></a>
# 10. Simple pattern tokenizer

- **simple_pattern** tokenizer，使用正则表达式来捕获匹配的文本作为 terms。它支持的正则表达式比 pattern tokenizer 更有限，但是 simple_pattern 通常更快；
- simple_pattern 的 pattern 的只能用来捕获文本生成 terms，不能像 pattern tokenizer 支持用 pattern 作为分割符去分割文本；
- 使用 Lucene 正则表达式；
- 默认 pattern 是空字符串，它不生成任何 terms。所以 simple_pattern 应该使用非默认 pattern；
- **可选参数：**
| **参数** | **参数说明** |
| :---: | :---: |
| pattern | Lucene正则表达式，默认空字符串 |

- **举例：**
```json
PUT my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "simple_pattern",
          "pattern": "[0123456789]{3}"
        }
      }
    }
  }
}

POST my_index/_analyze
{
  "analyzer": "my_analyzer",
  "text": "fd-786-335-514-x"
}
#处理结果：[ 786, 335, 514 ]

11. Simple pattern split tokenizer

simple_pattern_split tokenizer，使用正则表达式将匹配到的内容作为分割符对文本进行拆分；
- 比 pattern tokenizer 支持的正则更有限，但是更快；
使用 Lucene 正则表达式；
默认 pattern 是空字符串，它将整个文本作为 term，使用的时候不要使用默认pattern；
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | pattern | Lucene正则表达式，默认空字符串 |

举例： ```json PUT my_index { “settings”: { “analysis”: {

"analyzer": {
  "my_analyzer": {
    "tokenizer": "my_tokenizer"
  }
},
"tokenizer": {
  "my_tokenizer": {
    "type": "simple_pattern_split",
    "pattern": "_"
  }
}

} } }

POST my_index/_analyze { “analyzer”: “my_analyzer”, “text”: “an_underscored_phrase” }

处理结果：[ an, underscored, phrase ]


<a name="dK5xf"></a>
# 12. Standard tokenizer

- **standard **tokenizer，提供了基于语法的拆分文本（基于Unicode文本分割算法），并且适用于大多数语言。
- **可选参数：**
| **参数** | **参数说明** |
| :---: | :---: |
| max_token_length | token允许的最大长度，如果超过了就按照max_token_length拆分它，默认255 |

- 举例：
```json
PUT my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "tokenizer": "my_tokenizer"
        }
      },
      "tokenizer": {
        "my_tokenizer": {
          "type": "standard",
          "max_token_length": 5
        }
      }
    }
  }
}

POST my_index/_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 ]

13. Thai tokenizer

thai tokenizer，用 Java 附带的泰语分段算法将泰语文本分割成单词。一般来说，其他语言中的文本处理将与 standard tokenizer 相同。
注意：并非所有的 JRE 都支持它，但是可以与 Sun/Oracle 和 OpenJDK 一起工作；
如果想要程序应用可完全移植，可以使用 ICU tokenizer（不是内置的）；
没有可选参数；

14. UAX URL email tokenzier

uax_url_email tokenizer，与 standard tokenizer 类似，只是它将 url 和电子邮件地址识别为单个 token。
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | max_token_length | token允许的最大长度，如果超过了就按照max_token_length拆分它，默认255 |

举例：

POST _analyze
{
"tokenizer": "uax_url_email",
"text": "Email me at john.smith@global-international.com"
}
#处理结果：[ Email, me, at, john.smith@global-international.com ]

15. Whitespace tokenizer

whitespace tokenizer，遇到空格时对文本进行拆分；
可选参数： | 参数 | 参数说明 | | :—-: | :—-: | | max_token_length | token允许的最大长度，如果超过了就按照max_token_length拆分它，默认255 |

举例：

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. ]

搜索引擎 ElasticSearch

Tokenizer 详解

1. Character group tokenizer

2. Classic tokenizer

结果：[ The, 2, QUICK, Brown, Foxes, jumpe, d, over, the, lazy, dog’s, bone ]

4. Keyword tokenizer

5. Letter tokenizer

6. Lowercase tokenizer

7. N-gram tokenzier

结果：[ Qui, uic, ick, Fox, oxe, xes ]

因为第一个token:2不满足 min_gram=3，所以这个token被丢弃了；

text 类型的 file_path 字段索引时，采用的是 standard analyzer，

搜索文本处理后：[user,bob,photos,2017,05]，ES 会返回所有的文档，且 bob 的文档相关性最高

file_path.tree子字段索引时，采用的是 forward path_hierarchy tokenizer,

去匹配指定目录下的文档，非常便捷

返回结果：”/User/alice/photos/2017/05/16/“目录下的三个my_photo1,2,3.jpg文档全部返回

file_path.tree_reversed子字段，使用 reverse path_hierarchy,

用来匹配任何目录下的满足文件名的文档，非常便捷

返回结果：

“/User/alice/photos/2017/05/16/my_photo1.jpg”

“/User/alice/photos/2017/05/15/my_photo1.jpg”

“/User/bob/photos/2017/05/16/my_photo1.jpg”

可以对其他类型的搜索进行文件路径的过滤

搜索文件路径中包含16，且是在 Alice 的目录下的文档

返回结果：”/User/alice/photos/2017/05/16/“目录下的文档都返回了

9. Pattern tokenizer

处理结果：[ value, value with embedded \” quote ]

11. Simple pattern split tokenizer

处理结果：[ an, underscored, phrase ]

13. Thai tokenizer

14. UAX URL email tokenzier

15. Whitespace tokenizer