Elasticsearch重点内容归档

PublishedUpdated 帅哥林 研发笔记

文章中所有的知识点来自 《Elasticsearch 权威指南》，《Elasticsearch-PHP》与《Elasticsearch Reference 7.1》

在地狱公司频繁加班而后跳槽到正常的人间来后，终于得空能够重新复习巩固加深es从基础到深入的重点知识，感谢新老板。

文档案例将尽可能的减少对不同编程语言的依赖，而着重体现Elasticsearch（以下简称es）本身的功能与特性。一些博主偷懒的情况下，则会使用php来做演示。

1.第一印象

1.1.构成

$params = [
    'index' => 'database',
    'id' => 233333,
    'body' => [ 'testField' => 'abc']
];

明明刚说完 “尽可能减少对不同编程语言的依赖 ” ，转眼就用上了宇宙中最好的编程语言，不过这里真的不是因为偷懒。

上面的代码是es中最简单的数据存储方式，而被存储的数据中每个字段都将被索引，因此又称为 索引文档，它具备了三个重要的元素：index、id、body（文档主体）

新手常犯的错误则是过分解读 index 字段，导致理解困难。

我将es与传统关系型数据库做类比，它能更好的帮助新手更快的理解es的重要元素。index 与 database 相似，id+body = doc 与 数据库的一条数据(row)相似，不同的是：es缺少了相似table的表关系层，较好的解决方法是将表名写入到body中，以便筛选区分。

因此，它们之间的关系则是：index 一对多 doc，以及暂时不需要在乎的 cluster与node与index的关系。

最后通过不同编程语言的客户端输入转化为对 es服务端 的一条REST风格API的请求，例如上面的php代码：

PUT /database/_doc/233333   /{index}/_doc/{id}
{
  "testField" : "abc"
}

es 响应体如下所示：

{
    "_index": "database",
    "_type": "_doc",
    "_id": "233333",
    "_version": 1,
    "result": "created",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

1.2.服务端与客户端

通过阅读1.1.构成，我们明白如何去创建一条数据，接下来则是存储与获取，在此之前，我们需要安装好服务端以及准备好客户端。

从官方服务下载页可以获取到各种平台可用的java服务端，当你下载并解压后，通常能找到 elasticsearch-<version>/bin/elasticsearch 可执行程序，不需要做任何的参数配置，它将以新手友好的默认参数配置运行服务端。

不同的编程语言通常具备包管理器，你可以从中获取到客户端的拓展应用。
就像上面说过的，es服务端提供REST风格接口，你甚至可以直接使用终端充当客户端去存取数据。你可以在这里获取更详细的使用说明。

当你成功运行es服务端，并且拥有任意一个客户端后，我们就可以开干了。

1.3.开干

按照1.1.构成中给定的最基本的结构，我们可以开始向es服务器中插入数据了。

PUT /animals/_doc/1
{
	"table":"cat",
	"name":"三花猫",
	"sex":"female",
	"age":5,
	"favorite":[
		"clew","piano"
	]
}

response：

{
    "_index": "animals",
    "_type": "_doc",
    "_id": "1",
    "_version": 1,
    "result": "created",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

从结果上看，我们成功的创建了一只出身低微，但爱好优雅的三花猫。

PUT /animals/_doc/2
{"table":"cat","name":"波斯猫","sex":"male","age":2,"favorite":["clew","piano","milk"]}

我们又创建了一只猫，它不仅出生高贵，爱好优雅，还喝牛奶。

PUT /animals/_doc/3
{
	"table":"cat",
	"name":"美国短毛猫",
	"sex":"公猫",
	"age":"三岁",
	"favorite":[
		"牛奶","中文"
	]	
}

RESPONSE:
{
    "error": {
        "root_cause": [
            {
                "type": "mapper_parsing_exception",
                "reason": "failed to parse field [age] of type [long] in document with id '3'"
            }
        ],
        "type": "mapper_parsing_exception",
        "reason": "failed to parse field [age] of type [long] in document with id '3'",
        "caused_by": {
            "type": "illegal_argument_exception",
            "reason": "For input string: \"三岁\""
        }
    },
    "status": 400
}

当我们想要创建一只爱好是中文的美国短毛猫时，es服务端的响应是抛出异常：
“reason”: “failed to parse field [age] of type [long] in document with id ‘3’”，很显然，es根据我们第一条创建的猫的资料，将age字段 映射类型 为 long 类型，而这只爱好中文的猫显然已经病入膏肓了,将age填成了中文才导致抛出错误。

POST /animals/_doc
{
	"table":"cat",
	"name":"美国短毛猫",
	"sex":"male",
	"age":3,
	"favorite":[
		"牛奶","中文"
	]
}

RESPONSE:
{
    "_index": "animals",
    "_type": "_doc",
    "_id": "CF17RWsBCJ-Tu1mX2s2O",
    "_version": 1,
    "result": "created",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 2,
    "_primary_term": 1
}

喜欢中文的🐱仍旧打算另辟蹊径，区别于前面两次创建数据的方式，使用POST请求，并且请求的uri没有携带指定id，因此es为它生成了属于它的id。

我们拥有了三只猫，接下来要搜索所有的猫。

GET /animals/_search
{
	"query":{
		"match":{
			"name":"猫"
		}
	}
}

RESPONSE:
{
    "took": 2,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 3,
            "relation": "eq"
        },
        "max_score": 0.14426158,
        "hits": [
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "1",
                "_score": 0.14426158,
                "_source": {
                    "table": "cat",
                    "name": "三花猫",
                    "sex": "female",
                    "age": 5,
                    "favorite": [
                        "clew",
                        "piano"
                    ]
                }
            },
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "2",
                "_score": 0.14426158,
                "_source": {
                    "table": "cat",
                    "name": "波斯猫",
                    "sex": "male",
                    "age": 2,
                    "favorite": [
                        "clew",
                        "piano",
                        "milk"
                    ]
                }
            },
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "CF17RWsBCJ-Tu1mX2s2O",
                "_score": 0.116239555,
                "_source": {
                    "table": "cat",
                    "name": "美国短毛猫",
                    "sex": "male",
                    "age": 3,
                    "favorite": [
                        "牛奶",
                        "中文"
                    ]
                }
            }
        ]
    }
}

上面的搜索语句实际上等价于轻量搜索：

127.0.0.1:9200/animals/_search?q=name:猫

但实际上当你将搜索的关键词从 “猫” 换成 “三只猫”，被筛选出的数据仍旧是熟悉的它们。

127.0.0.1:9200/animals/_search?q=name:三只猫
{
    "took": 3,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 3,
            "relation": "eq"
        },
        "max_score": 1.2039074,
        "hits": [
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "1",
                "_score": 1.2039074,
                "_source": {
                    "table": "cat",
                    "name": "三花猫",
                    "sex": "female",
                    "age": 5,
                    "favorite": [
                        "clew",
                        "piano"
                    ]
                }
            },
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "2",
                "_score": 0.14426158,
                "_source": {
                    "table": "cat",
                    "name": "波斯猫",
                    "sex": "male",
                    "age": 2,
                    "favorite": [
                        "clew",
                        "piano",
                        "milk"
                    ]
                }
            },
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "CF17RWsBCJ-Tu1mX2s2O",
                "_score": 0.116239555,
                "_source": {
                    "table": "cat",
                    "name": "美国短毛猫",
                    "sex": "male",
                    "age": 3,
                    "favorite": [
                        "牛奶",
                        "中文"
                    ]
                }
            }
        ]
    }
}

但细心的你发现了它们的排序不同了，这是因为es将你的搜索关键词通过 分析器 拆分成单词，再分别搜索文档，接着根据匹配的 相关性 给予不同的索引文档不同的评分(_score),最终按照评分作出高低排序。因此关键词被拆分成“三”，“只”，“猫”，而三花猫显然是相关性评分(暂时先忽略评分过程) 是最高的，因此被排在了第一位。

就像关系型数据库一样，es查询结果也具备分页功能，size就像limit，from则像offset。需要注意的是，在分布式系统中深度分页是非常消耗性能的，例如请求1000页以上的分页时。

GET /_search?size=10&from=20

那么当你只需要三花猫相关信息时怎么办？

GET /animals/_search
{
    "query":{
	"match_phrase":{
	    "name":"花猫"
	}
    },
    "highlight": {
        "fields" : {
            "name" : {}
        }
    }
}

RESPONSE:
{
    "took": 55,
    "timed_out": false,
    "_shards": {
        "total": 1,
        "successful": 1,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": {
            "value": 1,
            "relation": "eq"
        },
        "max_score": 1.2039074,
        "hits": [
            {
                "_index": "animals",
                "_type": "_doc",
                "_id": "1",
                "_score": 1.2039074,
                "_source": {
                    "table": "cat",
                    "name": "三花猫",
                    "sex": "female",
                    "age": 5,
                    "favorite": [
                        "clew",
                        "piano"
                    ]
                },
                "highlight": {
                    "name": [
                        "三<em>花</em><em>猫</em>"
                    ]
                }
            }
        ]
    }
}

不好意思，我漏掉了“三”字，但显然“花猫”已经足以匹配到三花猫了，这就是短语搜索了。这里额外增加了 highlight 参数，符合匹配搜索的文字被嵌套上 em 标签，以便用于高亮显示使用。

现在我们明白，当你使用match查询时 更像是(但更复杂) 单词拆分形式模糊搜索，例如三花猫则类似（但更复杂）mysql的 %三%花%猫%，而match_phrase则类似 %三花猫% 。

下面还有一些基础操作是你会用到的：

//创建索引文档 当文档不存在时(put-if-absent)则创建
PUT /{index}/_doc/{id}?op_type=create
//创建索引文档，并存储在 hash("cat") % number_of_primary_shards 值匹配的分片中，以便管理
PUT /{index}/_doc/{id}?routing=cat

//删除索引文档
DELETE /{index}/_doc/{id}       example:/animals/_doc/1

//删除匹配查询结果的文档，不传递scroll_size参数情况下取符合查询的1000条数据。
POST /{index}/_delete_by_query(?scroll_size=1000)
{
  "query":{...}
}

//部分更新索引文档
POST /{index}/_update/{id}
{
  "doc": {body}
}
//也可以是简单的脚本 这里的ctx._source指代指定id的文档数据
{
  "script":"ctx._source.age += 3"
}

//乐观锁更新索引文档
POST /{index}/_update/{id}?version={num}
{
  "doc":{body}
}

//获取一个索引文档
GET /{index}/_doc/{id}

//批量获取索引文档
GET /_mget
{
    "docs" : [
        {
            "_index" : "animals",
            "_type" : "_doc",
            "_id" : "1"
        },
        {
            "_index" : "animals",
            "_type" : "_doc",
            "_id" : "2"
        }
    ]
}

//或者更简单的
GET /{index}/_doc/_mget
{
    "ids" : ["1", "2"]
}

//还可以指定符合hash值的分片块的内容
GET /_mgt?routing=key1

//检查一个文档是否存在 当状态码为200时则存在，为404时则不存在
HEAD /{index}/_doc/{id}

//批量请求
POST /_bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "animals", "_id" : "2" } }
{ "create" : { "_index" : "animals", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "animals"} }
{ "doc" : {"field2" : "value2"} }

//当批量操作的数据都来自同个index
POST /{index}/_bulk
{ "create" : { "_id" : "3"} }
{ "field1" : "value3" }
{ "update" : {"_id" : "2"} }
{ "doc" : {"field2" : "value2"} }

现在你已经学会了使用es了，只要留意磁盘空间你就可以将它部署到小型项目中了。

2.进一步理解的准备

你现在已经成功运行es并具备了使用它的基本方法，但还不足以达到游刃有余的地步，在更好的运用它之前，你需要沉下心来去理解关键的几个原理，用于更好的理解它。

2.1.Index——索引(名词)

最开始，我将Index类比为传统关系型数据库的database，这样能够更好的帮助新童鞋的理解，但这是片面的。

Index是保存数据的地方，它实际上是指向一个或多个物理 分片 的 逻辑命名空间 。而分片则是一个数据的容器，区分为 主分片 与 副本分片 ，所有的文档被存储在主分片中，而副本分片则存储主分片的拷贝用于故障冗余备份并负责 读 操作。分片的分配在你更深入理解es前则交由es自行负责显然是更好的选择。

当你在存储一个文档时，通常是建立匹配文档的映射，再存入Index中。在我们 1.3.开干 中我们忽略了这一步，因此es会自行根据我们提供的内容自行建立映射，它虽然方便，但因此也变得笨拙，我们会在搜索与映射中仔细介绍相关内容。

2.2.ID

id 是一个字符串，它与 index 配合唯一标识一个文档。你可以在创建索引文档时指派一个id，也可以不指派id，交由es自行生成一个id。
就像 1.1.构成 部分所说，es与关系型数据库类比缺少了table层，因此，我们唯一标识一个文档时可能会额外加上自定义的类似“table / type” 这样的字段。
我的建议是将es的索引文档id与关系型数据库里的id同步，这能更好的管理你的数据。

2.3.冲突处理

当一个文档在同一时刻具有多次并发操作时，冲突产生了。

最终结果99并不是我们想要的。有过一定经验的童鞋就会想到上锁：
悲观锁：
这种方法被关系型数据库广泛使用，它假定有变更冲突可能发生，因此阻塞访问资源以防止冲突。 一个典型的例子是读取一行数据之前先将其锁住，确保只有放置锁的线程能够对这行数据进行修改
乐观锁：
es 中使用的这种方法假定冲突是不可能发生的，并且不会阻塞正在尝试的操作。 然而，如果源数据在读写当中被修改，更新将会失败。应用程序接下来将决定该如何解决冲突。 例如，可以重试更新、使用新的数据、或者将相关情况报告给用户。

当你创建一个文档时，你会发现返回值中有个字段 _version ，之后对该文档的每次修改都将使该字段 +1，这是文档当前的版本号，是乐观锁更新时参考的依据。

POST /animals/_update/1?version=1
{
	"doc":{
		"age":6
	}
}

RESPONSE：
{
    "_index": "animals",
    "_type": "_doc",
    "_id": "1",
    "_version": 2,
    "result": "updated",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 3,
    "_primary_term": 1
}

我们可以看到版本号被自增为2。于是我们尝试第二次更新，仍旧是同样的修改请求，修改对象仍旧是版本1。

POST /animals/_update/1?version=1
{
	"doc":{
		"age":7
	}
}

RESPONSE：
{
    "_index": "animals",
    "_type": "_doc",
    "_id": "1",
    "_version": 2,
    "result": "noop",
    "_shards": {
        "total": 0,
        "successful": 0,
        "failed": 0
    }
}

显然更新没有被执行。

2.4.理解返回值

_shards ：
执行操作时参与的总分片数、成功数、失败数、忽略数。
hists ：
搜索返回的结果，其中包含 total:匹配搜索的总条目数，
hists：文档内容，took：查询消耗毫秒数，max_score：最高匹配评分

2.5.全文搜索 与 精确值

es 中的数据可以概括的分为两类：精确值和全文。

精确值很好理解，它就像 sql WHERE id = 5 直接匹配二进制值，结果 true 或 false，精确值便于你更好的过滤、聚合、排序相关的字段。
精确值搜索时会使用 过滤器 filters 优化查询执行速度，它避开了查询评分阶段 _score 并且便于缓存。

全文搜索则更复杂一些，为了使搜索引擎尽可能理解使用者的意图，大多数情况下当你在传入搜索关键词时并不是直接将其递交给搜索引擎，而是首先递交给 分析器 analyze 分析成适合 倒排索引 的词条并统一为标准格式提高可搜索性，最后再递交给搜索引擎。
同样的，当你存储的一个文档中包含全文搜索字段时，es同样会将其交给 分析器 分析，而后再建立索引文档。

为了让我们更好的理解全文搜索的关键 分析器（分词器）这里简单说明es自带分析器与拓展的ik中文分析器。

2.5.1.搜索的第一个关键：分析器

standard (标准分析器)：它是es默认使用的分析器，它根据 Unicode 联盟 定义的 单词边界 划分文本。删除绝大部分标点。最后，将词条小写。

whitespace (空格分析器): 它在空格的地方划分文本。

simple (简单分析器): 它在任何不是字母的地方分隔文本，将词条小写。

stop (停止分析器): 它与simple分析器相似，添加了无用词条的删除(例如 the, and)

keyword (不分词): 不做分词。

英语分析器: 各种语言分析器。

市面上有一些其它的中文分析器，它们各有特点，感兴趣的童鞋可以自行寻找，这里仅简略介绍ik中文分析器。

安装 : ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.1.1/elasticsearch-analysis-ik-7.1.1.zip

你可以将其中的加粗数字版本号更换为你当前的es版本号。

它提供了用于存储时分词的 ik_max_word 分析器与 搜索时分词的 ik_smart。

我们可以通过使用一个请求来了解分析器的过程和结果。

GET /_analyze
{
	"analyzer":"ik_max_word",   //你也可以换成 "ik_smart"
	"text":"Set the shape to semi-transparent by calling set_trans(5).今天是星期五，我在街上遇到了帅气的吴亦凡。"
}

RESPONSE:
{
    "tokens": [
        {
            "token": "set",
            "start_offset": 0,
            "end_offset": 3,
            "type": "ENGLISH",
            "position": 0
        },
        {
            "token": "shape",
            "start_offset": 8,
            "end_offset": 13,
            "type": "ENGLISH",
            "position": 1
        },
        {
            "token": "semi-transparent",
            "start_offset": 17,
            "end_offset": 33,
            "type": "LETTER",
            "position": 2
        },
        {
            "token": "semi",
            "start_offset": 17,
            "end_offset": 21,
            "type": "ENGLISH",
            "position": 3
        },
        {
            "token": "transparent",
            "start_offset": 22,
            "end_offset": 33,
            "type": "ENGLISH",
            "position": 4
        },
        {
            "token": "calling",
            "start_offset": 37,
            "end_offset": 44,
            "type": "ENGLISH",
            "position": 5
        },
        {
            "token": "set_trans",
            "start_offset": 45,
            "end_offset": 54,
            "type": "LETTER",
            "position": 6
        },
        {
            "token": "set",
            "start_offset": 45,
            "end_offset": 48,
            "type": "ENGLISH",
            "position": 7
        },
        {
            "token": "trans",
            "start_offset": 49,
            "end_offset": 54,
            "type": "ENGLISH",
            "position": 8
        },
        {
            "token": "5",
            "start_offset": 55,
            "end_offset": 56,
            "type": "ARABIC",
            "position": 9
        },
        {
            "token": "今天是",
            "start_offset": 58,
            "end_offset": 61,
            "type": "CN_WORD",
            "position": 10
        },
        {
            "token": "今天",
            "start_offset": 58,
            "end_offset": 60,
            "type": "CN_WORD",
            "position": 11
        },
        {
            "token": "是",
            "start_offset": 60,
            "end_offset": 61,
            "type": "CN_CHAR",
            "position": 12
        },
        {
            "token": "星期五",
            "start_offset": 61,
            "end_offset": 64,
            "type": "CN_WORD",
            "position": 13
        },
        {
            "token": "星期",
            "start_offset": 61,
            "end_offset": 63,
            "type": "CN_WORD",
            "position": 14
        },
        {
            "token": "五",
            "start_offset": 63,
            "end_offset": 64,
            "type": "TYPE_CNUM",
            "position": 15
        },
        {
            "token": "我",
            "start_offset": 65,
            "end_offset": 66,
            "type": "CN_CHAR",
            "position": 16
        },
        {
            "token": "在街",
            "start_offset": 66,
            "end_offset": 68,
            "type": "CN_WORD",
            "position": 17
        },
        {
            "token": "街上",
            "start_offset": 67,
            "end_offset": 69,
            "type": "CN_WORD",
            "position": 18
        },
        {
            "token": "遇到",
            "start_offset": 69,
            "end_offset": 71,
            "type": "CN_WORD",
            "position": 19
        },
        {
            "token": "到了",
            "start_offset": 70,
            "end_offset": 72,
            "type": "CN_WORD",
            "position": 20
        },
        {
            "token": "帅气",
            "start_offset": 72,
            "end_offset": 74,
            "type": "CN_WORD",
            "position": 21
        },
        {
            "token": "的",
            "start_offset": 74,
            "end_offset": 75,
            "type": "CN_CHAR",
            "position": 22
        },
        {
            "token": "吴",
            "start_offset": 75,
            "end_offset": 76,
            "type": "CN_CHAR",
            "position": 23
        },
        {
            "token": "亦",
            "start_offset": 76,
            "end_offset": 77,
            "type": "CN_CHAR",
            "position": 24
        },
        {
            "token": "凡",
            "start_offset": 77,
            "end_offset": 78,
            "type": "CN_CHAR",
            "position": 25
        }
    ]
}

我们可以看到，ik_max_word将一句话尽可能拆解成许多词语，这样以便去匹配最合适的文档，你也可以使用ik_smart来分析这句话，看看有什么不同。

当分析器分析完成并索引后，用户搜索的关键词匹配上述内容后则是一条被有效搜索到的结果，接着按照es的评分规则进行评分与排序。

2.5.2.搜索的另一个关键：映射

我们晓得了 全文搜索与精确值 的工作原理，接下来我们通过 映射 来告诉es，当我们存储一个文档时，文档的一些或全部字段应该以什么类型去存储，它在es中又扮演着什么角色。

2.5.2.1.映射类型

每个索引都有且仅有一个映射类型，用于确定文档的索引方式。
映射类型具有：
元字段
映射的元字段分别是： _index , _id , _source, _field_names, _ignored, _meta, _routing, _type 。
字段或属性
文档的所有字段与相关属性 properties 的列表。

2.5.2.2.字段数据类型

每个字段都有一个用来表示数据类型的属性 type ，可以是以下类型之一，如果你对某些字段不了解，可自行查询资料，这里不做详解，类型：

一个映射创建例子：

PUT my_index 
{
  "mappings": {
    "properties": { 
      "title":    {
                      "type": "text",
                      "analyzer": "ik_max_word"
                  }, 
      "name":     { "type": "text"  }, 
      "pageview": { "type": "integer" },
      "belong_user_name: { 
        "type":    "object",
        "properties": { 
          "full":  { "type": "string" },
          "first": { "type": "string" },
          "last": { "type": "string" }
        }
      },
      "animal": { 
        "type": "keyword",
        "fields": {
          "search": {
            "type": "text"
          }
        }
      }
      "created":  {
        "type":   "date", 
        "format": "strict_date_optional_time||epoch_millis"
      }
    }
  }
}

认真阅读的同学应该明白上述例子大多内容，这里可能有三块内容需要进一步解释，如果你不明白可以详细了解。

belong_user_name: object

该字段存储类型为 object ，实际上从有这个字段开始，这个映射所关系的文 档就是多层结构,因此它又嵌套了一个 properties 属性列表来声明该对象字段内部所包含的字段属性，实际上它甚至可以继续嵌套添加 object 字段来体现更多层级的文档内容。

created: date

一个 date 类型的字段，format 是该字段可自定义的格式化方式，strict_date_optional_time||epoch_millis ：
实际上是 date 类型格式化的缺省默认值，因此你可以省略 format ,它表示接受一个 符合ISO日期时间格式 或 Epoch Time ( Unix Time ) 以来的毫秒时间戳。

format 还可以自定义更多格式：
“format”: “yyy-MM-dd HH:mm:ss||yyyy-MM-dd||basic_date”

animal: keyword and text

为不同目的以不同方式索引相同字段通常很有用。例如，一个 string 字符串字段可以索引为 text 用于全文搜索，同时也索引为 keyword 字段用于排序或聚合。

实际上属性 properties 的可选参数要较例子上的更多，如果有足够时间，你应该去详细阅读它。

3.等待更新

Golang学习笔记

PublishedUpdated 帅哥林 研发笔记

1.基础重点

指针

指针是一种直接存储了变量的内存地址的数据类型，也是可见的内存地址，& 操作符可以返回一个变量的内存地址，并且 * 操作符可以获取指针指向的变量内容。

如果用“var x int”声明语句声明一个x变量，那么&x表达式（取x变量的内存地址）将产生一个指向该整数变量的指针，指针对应的数据类型是 *int，指针被称之为“指向int类型的指针”。
如果指针名字为p，那么*p表达式对应p指针指向的变量的值，因此它是左值时表示给指针指向的变量赋值，而是右值时表示获取指针指向的变量。

x := 1
p := &x         // 类型是 *int 的指针p , 指向 x
fmt.Println(*p) // "1"
*p = 2          // 等同于 x = 2
fmt.Println(x)  // "2"

new函数

表达式new(T)将创建一个T类型的匿名变量，初始化为T类型的零值，然后返回变量地址，返回的指针类型为 *T。
用new创建变量和普通变量声明语句方式创建变量没有什么区别，除了不需要声明一个临时变量的名字外，我们还可以在表达式中使用new(T)。换言之，new函数类似是一种语法糖，而不是一个新的基础概念。

名称定义

如果一个名字是在函数内部定义，那么它就只在函数内部有效。如果是在函数外部定义，那么将在当前包的所有文件中都可以访问。名字的开头字母的大小写决定了名字在包外的可见性。如果一个名字是大写字母开头的，那么它将是导出的，也就是说可以被外部的包访问，例如fmt包的Printf函数就是导出的，可以在fmt包外部访问。包本身的名字一般总是用小写字母。

数组

在数组字面值中，如果在数组的长度位置出现的是“…”省略号，则表示数组的长度是根据初始化值的个数来计算。

q := [...]int{1, 2, 3}
fmt.Printf("%T\n", q) // "[3]int"

数组的长度是数组类型的一个组成部分，因此[3]int和[4]int是两种不同的数组类型。数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。

Slice(切片)

Slice（切片）代表变长的序列，序列中每个元素都有相同的类型。一个slice类型一般写作[]T，其中T代表slice中元素的类型；

因为slice值包含指向第一个slice元素的指针，因此向函数传递slice将允许在函数内部修改底层数组的元素。换句话说，复制一个slice只是对底层的数组创建了一个新的slice别名

和数组不同的是，slice之间不能比较，因此我们不能使用==操作符来判断两个slice是否含有全部相等元素。不过标准库提供了高度优化的bytes.Equal函数来判断两个字节型slice是否相等（[]byte），但是对于其他类型的slice，我们必须自己展开每个元素进行比较。

Map

初始化零值map有两种方式：

a := map[string]int{}
b := make(map[string]int)

使用内置的delete函数可以删除元素：

delete(ages, "alice") // remove element ages["alice"]

所有这些操作是安全的，即使这些元素不在map中也没有关系；如果一个查找失败将返回value类型对应的零值。

但是map中的元素并不是一个变量，因此我们不能对map的元素进行取址操作。

结构体

结构体与其成员同样遵循大写导出，小写非导出的命名规范。

结构体变量的成员可以通过点操作符访问：

dilbert.Salary -= 5000 // demoted, for writing too few lines of code

或者是对成员取地址，然后通过指针访问：

position := &dilbert.Position
*position = "Senior " + *position // promoted, for outsourcing to Elbonia

点操作符也可以和指向结构体的指针一起工作：

var employeeOfTheMonth *Employee = &dilbert
employeeOfTheMonth.Position += " (proactive team player)"

相当于下面语句

(*employeeOfTheMonth).Position += " (proactive team player)"

函数的返回值是结构体的指针时，则可以直接通过返回值配合 “.” 操作符来访问结构体的成员，因此它可以通过不断返回一个结构体的指针来达到链式操作的目的。

func EmployeeByID(id int) *Employee { /* ... */ }

fmt.Println(EmployeeByID(dilbert.ManagerID).Position) // "Pointy-haired boss"

id := dilbert.ID
EmployeeByID(id).Salary = 0 // fired for... no real reason

值得注意的是：如果返回值是非指针的结构体，那么则无法直接通过 “.” 操作符来更新返回值的成员，可以通过赋值给新变量后再做操作。

2. time format,快速理解时间格式化

月份 1,01,Jan,January
日　 2,02,_2
时　 3,03,15,PM,pm,AM,am
分　 4,04
秒　 5,05
年　 06,2006
时区 -07,-0700,Z0700,Z07:00,-07:00,MST
周几 Mon,Monday

您看出规律了么！哦是的，你发现了，这里面没有一个是重复的，所有的值表示都唯一对应一个时间部分。并且涵盖了很多格式组合。
比如小时的表示(原定义是下午3时，也就是15时)

3 用12小时制表示，去掉前导0
03 用12小时制表示，保留前导0
15 用24小时制表示，保留前导0
03pm 用24小时制am/pm表示上下午表示，保留前导0
3pm 用24小时制am/pm表示上下午表示，去掉前导0

又比如月份

1 数字表示月份，去掉前导0
01 数字表示月份，保留前导0
Jan 缩写单词表示月份
January 全单词表示月份