# 反向索引 Elasticsearch uses a structure called an _inverted index_ which is designedto allow very fast full text searches. An inverted index consists of a listof all the unique words that appear in any document, and for each word, a listof the documents in which it appears. For example, let's say we have two documents, each with a `content` fieldcontaining: 1. ``The quick brown fox jumped over the lazy dog'' 1. ``Quick brown foxes leap over lazy dogs in summer'' To create an inverted index, we first split the `content` field of eachdocument into separate words (which we call _terms_ or _tokens_), create asorted list of all the unique terms, then list in which document each termappears. The result looks something like this: ~~~ Term Doc_1 Doc_2-------------------------Quick | | XThe | X |brown | X | Xdog | X |dogs | | Xfox | X |foxes | | Xin | | Xjumped | X |lazy | X | Xleap | | Xover | X | Xquick | X |summer | | Xthe | X |------------------------ ~~~ Now, if we want to search for `"quick brown"` we just need to find thedocuments in which each term appears: ~~~ Term Doc_1 Doc_2-------------------------brown | X | Xquick | X |------------------------Total | 2 | 1 ~~~ Both documents match, but the first document has more matches than the second.If we apply a naive _similarity algorithm_ which just counts the number ofmatching terms, then we can say that the first document is a better match --is _more relevant_ to our query -- than the second document. But there are a few problems with our current inverted index: 1. `"Quick"` and `"quick"` appear as separate terms, while the user probablythinks of them as the same word. 1. `"fox"` and `"foxes"` are pretty similar, as are `"dog"` and `"dogs"`-- they share the same root word. 1. `"jumped"` and `"leap"`, while not from the same root word, are similarin meaning -- they are synonyms. With the above index, a search for `"+Quick +fox"` wouldn't match anydocuments. (Remember, a preceding `+` means that the word must be present).Both the term `"Quick"` and the term `"fox"` have to be in the same documentin order to satisfy the query, but the first doc contains `"quick fox"` andthe second doc contains `"Quick foxes"`. Our user could reasonably expect both documents to match the query. We can dobetter. If we normalize the terms into a standard format, then we can find documentsthat contain terms that are not exactly the same as the user requested, butare similar enough to still be relevant. For instance: 1. `"Quick"` can be lowercased to become `"quick"`. 1. `"foxes"` can be _stemmed_ -- reduced to its root form -- tobecome `"fox"`. Similarly `"dogs"` could be stemmed to `"dog"`. 1. `"jumped"` and `"leap"` are synonyms and can be indexed as just thesingle term `"jump"`. Now the index looks like this: ~~~ Term Doc_1 Doc_2-------------------------brown | X | Xdog | X | Xfox | X | Xin | | Xjump | X | Xlazy | X | Xover | X | Xquick | X | Xsummer | | Xthe | X | X------------------------ ~~~ But we're not there yet. Our search for `"+Quick +fox"` would _still_ fail,because we no longer have the exact term `"Quick"` in our index. However, ifwe apply the same normalization rules that we used on the `content` field toour query string, it would become a query for `"+quick +fox"`, which wouldmatch both documents! IMPORTANT: This is very important. You can only find terms that actually exist in yourindex, so: _both the indexed text and and query string must be normalizedinto the same form_. This process of tokenization and normalization is called _analysis_, which wediscuss in the next section.