1. Performance API 的用处

Performance API
是浏览器中内置的一组工具，用于测量和记录页面加载和执行过程中的各类性能指标。它的主要用处包括：

• 监控页面资源加载
  ：跟踪页面中的资源（如 CSS、JavaScript、图片）的加载时间。
• 分析页面加载时间
  ：从导航到页面完全渲染的所有时间点。
• 衡量用户交互性能
  ：测量用户点击、输入等操作的响应时间。
• 优化性能瓶颈
  ：通过标记特定的代码片段和事件，精准定位性能瓶颈。

这些数据帮助开发者更好地理解页面表现，进而对性能进行优化和改进。

2. Performance API 常用的 API

在使用 Performance API 时，以下几个 API 是开发者最常用的工具：
getEntries()
、
mark()
、以及
PerformanceObserver
。这些 API 提供了从获取性能数据到观察性能事件的全面能力。

2.1 performance.getEntries()

performance.getEntries()
是 Performance API 提供的一个方法，它返回所有的性能条目（entries）。这些条目记录了从页面加载到当前时刻，各类资源的加载和交互的性能数据。性能条目包括页面加载资源（如 CSS、JS、图片等）以及自定义的事件标记。

//获取页面中所有资源的性能条目
const entries =performance.getEntries();

console.log(entries);

通过
getEntries()
，你可以获取资源加载时间、开始时间、结束时间等详细信息。这对于了解页面中每个资源的加载耗时十分有帮助。

2.2 entries 的类型

getEntries()
返回的每个性能条目对象都属于以下几种类型，开发者可以根据需要筛选和分析不同类型的数据：

• navigation
  ：与页面导航相关的条目，通常用于分析页面加载的时间点。
• resource
  ：所有通过网络请求加载的资源条目，包括 JS、CSS、图片等。
• mark
  ：开发者自定义的标记，用于记录特定事件的开始或结束。
• measure
  ：通过
  performance.measure()
  生成的条目，用于测量两个标记之间的时间间隔。

例如，使用
performance.getEntriesByType('resource')
可以只获取资源加载的性能数据：

//获取所有资源加载的性能条目
const resourceEntries = performance.getEntriesByType('resource');

console.log(resourceEntries);

通过这种方式，开发者可以轻松获取页面资源的加载时间及其详情。

2.3 performance.mark()

performance.mark()
是 Performance API 提供的一个方法，允许开发者在代码中手动创建标记。这些标记可以用于记录特定事件的发生时间，从而在分析性能时，更加精确地掌握代码中某个关键操作的时机。

//创建自定义标记
performance.mark('start-task');//执行某个任务
doSomething();//创建结束标记
performance.mark('end-task');//测量开始和结束之间的时间
performance.measure('Task Duration', 'start-task', 'end-task');

mark()
非常适合用于衡量应用程序中某段代码的执行时间，与
measure()
一起使用可以提供更加详细的性能分析。

2.4 PerformanceObserver

PerformanceObserver
是 Performance API 的一个高级特性，它可以监听性能事件的发生，并在事件触发时执行回调。这种观察模式可以帮助开发者实时监控页面中的资源加载、导航和其他性能相关的事件。

//创建 PerformanceObserver 实例，监听资源加载的事件
const observer = new PerformanceObserver((list) =>{const entries =list.getEntries();

  entries.forEach(entry=>{

    console.log(`${entry.name}: ${entry.duration}ms`);

  });

});//监听资源类型的性能条目
observer.observe({ entryTypes: ['resource'] });

通过
PerformanceObserver
，你可以监听特定类型的性能条目，如
resource
或
mark
，并实时分析其数据。对于监控资源加载、关键操作或用户交互时的性能表现非常有用。

总结

Performance API 是前端开发者进行性能监控的强大工具，它提供了对页面加载、资源加载以及用户交互的详细分析能力。常用的 API，如
getEntries()
、
mark()
、以及
PerformanceObserver
，可以帮助开发者实时获取和分析性能数据。

通过合理地使用 Performance API，你可以更好地了解页面中各类操作的性能表现，从而有效地优化 Web 应用的加载速度和用户体验。

manim
提供了
通用多边形
模块，可以绘制任意的多边形。

通用多边形模块有两种，
Polygon
和
Polygram
。

Polygon
是一个几何学术语，主要指的是由三条或三条以上的线段首尾顺次连接所组成的平面图形，

而
Polygram
的含义更加广泛一些，它除了可以绘制传统的多边形，还能绘制非闭合的多边形，各部分不相连的多边形等等。

对于一般的几何问题，使用
Polygon
就足够了，只有在需要表达一些图形的组合或序列时，才会用到
Polygram
。

manim
中关于
Polygon
和
Polygram
的模块主要有4个：

1. Polygon
   ：任意多边形
2. RegularPolygon
   ：任意
   正
   多边形
3. Polygram
   ：广义的多边形
4. RegularPolygram
   ：广义的
   正
   多边形

Polygon
和
Polygram
其实也可以绘制
正
多边形，只不过用
RegularPolygon
和
RegularPolygram
会更加方便。

这4个模块的继承关系如上图所示。

1. 主要参数

Polygon
的参数很简单，就是提供一系列的顶点坐标。

绘制时会依照提供的顶点顺序依次连线，最后一个点会连接第一个点，形成一个闭合的多边形。

RegularPolygon
的参数也很简单：

Polygram
的参数是多组的顶点，每组有多个顶点，与之相比，
Polygon
的参数只有一组顶点。

RegularPolygram
的参数有：

RegularPolygon
比较简单，就是顺序连接各个顶点形成多边形，

而
RegularPolygram
有个
density
参数，可以控制跳跃几个顶点来连接。

设置
density=1
的话，
RegularPolygram
和
RegularPolygon
的图形是一样的，后面示例中详细演示。

2. 主要方法

Polygram
作为最通用的多边形，提供了3个方法。

get_vertex_groups
和
get_vertices
主要区别在于：

get_vertex_groups
以分组的形式返回顶点坐标，这对于
Polygram
模块比较有用，因为
Polygram
模块的参数可以传入多组顶点；

get_vertices
则是将所有的坐标作为一个列表返回出来。

round_corners
用来调整多边形尖角的曲率。

# 创建3个广义正六边形
p1 = RegularPolygram(6)
p2 = RegularPolygram(6)
p3 = RegularPolygram(6)

# p2的尖角曲率设为0.1
p2.round_corners(radius=0.1)

# p3的尖角曲率设为0.3
p3.round_corners(radius=0.3)

其他3个模块没有什么重要的方法。

3. 使用示例

3.1. 多边形示例

多变形就是按照传入的顶点的顺序逐个连接成一个闭合图形。

# 凸多边形
points = [
    LEFT * 2.5,
    LEFT * 1.5 + UP,
    LEFT * 0.5,
    LEFT * 0.5 + DOWN * 1.5,
    LEFT * 2.5 + DOWN * 1.5,
]
Polygon(*points)

# 凹多边形
points = [
    RIGHT * 0.5 + UP,
    RIGHT * 1.5 + DOWN,
    RIGHT * 2.5 + UP,
    RIGHT * 2.5 + DOWN * 1.5,
    RIGHT * 0.5 + DOWN * 1.5,
]
Polygon(*points)

3.2. 正多边形

正多边形最简单，只要传入边的数量即可。

RegularPolygon(n=6)
RegularPolygon(n=8)
RegularPolygon(n=12)

3.3. 广义多边形

广义多边形更像是多个多边形的组合，它可以传入多个组的的顶点，然后根据每个组的顶点来构造图形。

下面的示例中，第一个图形有3个组顶点，第二个图形有2个组顶点。

group_points = [
    [[-2.5,0,0], [-1.5,1,0], [-0.5,0,0]],
    [[-2,0,0], [-2,-1.5,0]],
    [[-1,0,0], [-1,-1.5,0]],
]
Polygram(*group_points)

group_points = [
    [[0.5,0,0], [1.5,1,0], [2.5,0,0]],
    [[0.5,-1,0], [1.5,0,0], [2.5,-1,0]],
]
Polygram(*group_points)

3.4. 广义正多边形

广义正多边形可以调整顶点的连接顺序（通过属性
density
），逐个连接时，和普通正多边形是一样的。

# 正九边形，逐个连接顶点
RegularPolygram(9, density=1)

# 正九边形，隔一个顶点连接
RegularPolygram(9, density=2)

# 正九边形，隔两个顶点连接
RegularPolygram(9, density=3)

4. 附件

文中完整的代码放在网盘中了（
polygon02.py
），

下载地址:
完整代码
(访问密码: 6872)

前言

在C# 9版本中引入了一项新特性：
顶级语句
，这一特性允许在不显式定义 Main 方法的情况下直接编写代码。

传统的写法

namespace TestStatements
{
    internal class Program
    {
        static void Main(string[] args)
        {
            foreach (var arg in args)
            {
                Console.WriteLine(arg);
            }
            Console.WriteLine("Hello, 追逐时光者!");
        }
    }
}

顶级语句写法

foreach (var arg in args)
{
    Console.WriteLine(arg);
}
Console.WriteLine("Hello, 追逐时光者!");

顶级语句的优势

• 省去了 Main 方法和命名空间声明，使得代码更加简洁。
• 特别适合编写简单的控制台应用、脚本和演示代码。
• 对于初学者来说，不需要了解太多复杂的语法结构就可以开始编写 C# 程序。

顶级语句的不足

• 顶级语句更适合于简单的程序，对于大型复杂的项目，传统的 Main 方法和命名空间这些还是非常有必要的。
• 对于习惯了传统结构的开发者来说，顶级语句可能会让代码的组织结构显得不够明确。
• 如果与其他 C# 版本或一些特定的项目结构混用，可能会导致兼容性问题。

最后总结

顶级语句通过简化代码结构，降低了学习曲线并提高了开发效率，特别适合初学者和编写简单程序的场景。然而，在大型项目中，传统的代码结构依然是必要的。因此，顶级语句和传统方法各有其适用的场景和优势，开发者可以根据具体需求选择使用哪种方式。对于我个人而言还是比较喜欢传统的写法，看起来更直观且代码的组织结构分明。

参考文章

• https://learn.microsoft.com/zh-cn/dotnet/csharp/fundamentals/program-structure/top-level-statements

图形界面使用

bucket

bucket创建

图形界面创建bucket。

特性：

• Versioning
  开启版本控制，开启版本控制则允许在同一键下保持同一对象的多个版本。

• Object Locking
  对象锁定防止对象被删除，需要支持保留和合法持有，只能在创建桶时启用。

• Quita
  配额限制bucket中的数据量。

• Retention
  保留会施加规则，在一段时间内防止对象删除。为了设置桶保留策略，必须启用版本控制。

确认创建成功，查看bucket详情。

Anonymous：配置Access Poilcy为custom，可以自己定义那些前缀是只读，那些前缀是读写的等。

Events：事件，设置Bucket绑定那些事件通知。

Lifecycle：生命周期，配置bucket的生命周期。
类型选择Expiry代表是过期直接删除，选择Transition就是过期后转移到目标存储服务器，需要搭配Tiering使用。

Prefix：文件名前缀。
After：代表多少天后过期。

测试上传

测试上传文件。

Access keys

创建Access Keys

图形界面创建AK和SK。

强烈建议对锁创建的key进行记录：

xuq70VZxkfwPvDG5Mfga
t3FgyXTOhfyKowWFbMvFpTPJ9rJQh0RiTLEnJ2F5

也可将所创建的Key下载到本地。

配置权限

授予权限

Minio 的存储桶默认是不和任何 Acess Key 关联，同时 Minio 支持标准 S3 协议，可以在创建 bucket 和 ak 后给 Access Key 授予某个 Bucket 存储桶的访问权限，实现 Key 和 Bucket 的绑定。

Policy

MinIO使用基于策略的访问控制(PBAC)来定义经过身份验证的用户有权访问的授权操作和资源。
每个策略描述一个或多个操作和条件，这些操作和条件概括了一个用户或一组用户的权限。
MinIO PBAC是为了兼容AWS IAM策略语法、结构和行为而构建的。
每个用户只能访问内置角色显式授予的资源和操作。
默认情况下，MinIO拒绝访问任何其他资源或操作。

即通过策略来管理用户是否有权进行操作和可访问的资源等等。

• Policy语句
  语句中的信息均含在一系列的元素内。
  Version：指定要使用的策略语言版本。建议您使用最新的 2012-10-17 版本。
  Statement：将该主要策略元素作为以下元素的容器。可以在一个策略中包含多个语句。
  Sid（可选）：包括可选的语句 ID 以区分不同的语句。
  Effect：使用 Allow 或 Deny 指示策略是允许还是拒绝访问。
  Principal（仅在某些情况下需要）：如果创建基于资源的策略，必须指示要允许或拒绝访问的账户、用户、角色或联合身份用户。如果要创建 IAM 权限策略以附加到用户或角色，则不能包含该元素。主体暗示为该用户或角色。
  Action：包括策略允许或拒绝的操作列表。
  Resource（仅在某些情况下需要）：如果创建 IAM 权限策略，必须指定操作适用的资源列表。如果创建基于资源的策略，则该元素是可选的。如果不包含该元素，则该操作适用的资源是策略附加到的资源。
  Condition（可选）：指定策略在哪些情况下授予权限。

更多IMA参考：
IAM 中的策略和权限
。

User

User：MinIO用户由唯一的access key (username) 和 对应的 secret key (password)组成。

客户端必须通过指定现有MinlO用户的有效access key (username)和相应的secret key (password)来验证其身份。
Groups提供了一种简化的方法，用于管理具有通用访问模式和工作负载的用户之间的共享权限。
User通过所属组继承对数据和资源的访问权限。

MinlO使用基于策略的访问控制(PBAC)来定义经过身份验证的用户有权访问的授权操作和资源。
每个策略描述一个或多个操作和条件，这些操作和条件概括了一个用户或一组用户的权限。
每个用户只能访问内置角色显式授予的资源和操作。

默认情况下，MinlO拒绝访问任何其他资源或操作。

创建User。

Groups

Groups可以有一个附加的IAM策略，该组中具有成员资格的所有用户都继承该策略。
Groups支持更简化的MinIO租户用户权限管理，即可以通过用户组来管理用户组下的用户权限，多对多的关系，一个组下面有可以选择多个组员，一个组员可以属于多个用户组。

创建一个组。

确认创建成功。

设置Groups的Policy。

勾选已创建的Policy。

确认创建完成。

关联策略，关联用户成员，从而实现更方便的批量权限管理。

Monitoring

Metrics

Metrics指标，MinIO 支持 Prometheus 用于指标和警报。
Prometheus 是一个开源系统和服务监控系统 支持基于收集的指标进行分析和警报。
Prometheus 生态系统包括多个 integrations ,允许广泛的处理和存储范围收集的指标。

MinIO 发布了 Prometheus 兼容的集群获取endpoint和节点级指标。
看 指标 为了 更多信息。
对于警报，请使用 Prometheus Alerting Rules 和 Alert Manager 根据收集的指标触发警报。

MinIO 使用 Prometheus 兼容数据发布收集的指标数据结构。
任何与 Prometheus 兼容的抓取软件都可以获取和处理 MinIO 指标以进行分析、可视化和警报。

如下图所示，可以看到基本信息相关的监控指标。

Trace

追踪，选择那些Trace的调用，然后开启Trace，下面就会记录所有的Trace，如时间，名称。状态，等等。

Events

时间通知，MinIO桶通知允许管理员就某些对象或桶事件向受支持的外部服务发送通知。MinIO支持桶级和对象级S3事件，类似于Amazon S3事件通知。

本质是Minio操作完成后通过事件的形式对外进行通知。

Minio支持多种事件的通知，如下图所示：

Tiering

对象生命周期管理：Tiering由MinIO对象生命周期管理使用，它允许创建基于时间或日期的对象自动转换或到期规则。对于对象迁移，MinIO会自动将对象迁移到已配置的远端存储层。

对于对象到期，MinIO 会自动删除该对象。
即对象生命周期可以用户自定义管理，但是对象过期了处理方式，Minio提供了两种选择，要么直接删除该对象，要么把该对象转换到远端的存储服务上去。

MinIO支持创建对象转移的生命周期管理规则，MinIO可以自动将对象移动到远程存储“Tiering”：
MinIO支持以下Tier类型:

Site Replication

复制站点：网站复制，此特性允许将使用相同外部IDentity Provider (IDP)的多个独立MinIO站点(或集群)配置为副本。。

即复制一个副本出来，到目标网站，快速搭建集群，以及迁移，无需再繁琐的配置等。

如下图所示，填写对应的站点信息，包括名字、端地址、Access Key，Secret Key。
需要填写本站的，目标站的，目标站可以多个。

客户端使用

mc客户端安装

MinIO Client mc命令行工具提供了ls、cat、cp、mirror和diff等命令，支持文件系统和Amazon s3兼容的云存储服务。

mc命令行工具是为与AWS S3 API兼容而构建的，并在MinIO和AWS S3上测试了预期的功能和行为。

安装mc：

[root@master01 minio]# curl https://dl.min.io/client/mc/release/linux-amd64/mc \
  --create-dirs \
  -o /usr/local/bin/mc

[root@master01 minio]# chmod +x /usr/local/bin/mc
[root@master01 minio]# mc --autocompletion              #mc自动补全

[root@master01 minio]# mc --help

连接minio：
使用mc alias set命令将Amazon s3兼容的服务添加到mc配置中，将alias替换为要关联到S3服务的名称。
mc命令通常需要alias作为参数来标识要对哪个S3服务执行，如果省略ACCESS_KEY和SECRET_KEY，执行命令时会提示在CLI中输入这些值。

[root@master01 minio]# mc alias set myminio https://api.linuxsb.com minio minio123
Added `myminio` successfully.
[root@master01 minio]# mc admin info myminio

bucket管理

• 创建bucket

[root@master01 ~]# mc mb myminio/mybucket02                 #创建bucket

[root@master01 ~]# mc ls myminio                            #列出bucket
[2024-09-06 04:14:49 CST]     0B mybucket/
[2024-09-09 07:29:20 CST]     0B mybucket02/

• 删除bucket

[root@k8s-master ~]# mc rb myminio/mybucket02               #删除没有object的bucket

[root@k8s-master ~]# mc rb myminio/mybucket02 --force       #强制删除bucket，即使含有文件

object管理

• 上传下载

[root@master01 ~]# echo "This is my test file!" > test01.txt
[root@master01 ~]# mc cp test01.txt myminio/mybucket/test01.txt                 #上传测试文件

[root@master01 ~]# mkdir testdir                                                #创建测试目录

[root@master01 ~]# echo "This is my test02 file!" > testdir/test02.txt
[root@master01 ~]# mc cp testdir myminio/mybucket --recursive                   #上传测试目录，且递归上传

[root@master01 ~]# mc ls myminio/mybucket                                       #查看minio存储
[2024-09-10 09:32:04 CST]    22B STANDARD test01.txt
[2024-09-10 09:32:45 CST]     0B testdir/

[root@master01 ~]# mkdir download
[root@master01 ~]# mc cp myminio/mybucket/test01.txt download/                  #下载文件
[root@master01 ~]# mc cp myminio/mybucket/testdir download/ --recursive         #下载目录，且递归下载

[root@master01 ~]# ll download/                                                 #查看文件
total 4.0K
-rw-r--r-- 1 root root 22 Sep 10 09:33 test01.txt
drwxr-xr-x 2 root root 24 Sep 10 09:34 testdir

[root@master01 ~]# ll download/testdir/
total 4.0K
-rw-r--r-- 1 root root 24 Sep 10 09:34 test02.txt

• 删除

[root@master01 ~]# mc rm myminio/mybucket/test01.txt                            #删除文件

[root@master01 ~]# mc rm myminio/mybucket/testdir --recursive --force           #删除目录，即使包含文件

[root@master01 ~]# mc ls myminio/mybucket                                       #查看minio存储

Policy管理

查看policy

列出 MinIO 上的所有预设策略。

[root@master01 ~]# mc admin policy list myminio
diagnostics
mypolicy
readonly
readwrite
writeonly
consoleAdmin

删除policy

[root@master01 ~]# mc admin policy remove myminio listbucketsonly

创建policy

创建一个新的policy。

[root@master01 ~]# vim listbucketsonly.json              #编写新的策略规则
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListAllMyBuckets"
      ],
      "Resource": [
        "arn:aws:s3:::*"
      ]
    }
  ]
}

[root@master01 ~]# mc admin policy create myminio listbucketsonly ./listbucketsonly.json

User管理

• 创建用户

[root@master01 ~]# mc admin user add myminio newuser newuser123
Added user `newuser` successfully.

[root@master01 ~]# mc admin user add myminio newuser02 newuser123
Added user `newuser02` successfully.

[root@master01 ~]# mc admin user add myminio newuser03 newuser123
Added user `newuser03` successfully.

• 禁用用户

[root@master01 ~]# mc admin user disable myminio newuser
Disabled user `newuser` successfully.

• 启用用户

[root@master01 ~]# mc admin user enable myminio newuser
Enabled user `newuser` successfully.

• 给用户关联策略

[root@master01 ~]# mc admin policy attach myminio listbucketsonly --user newuser
Attached Policies: [listbucketsonly]
To User: newuser

• 创建用户组及关联用户
  创建用户组，并关联用户。

[root@master01 ~]# mc admin group add myminio somegroup newuser
Added members `newuser` to group `somegroup` successfully.

[root@master01 ~]# mc admin group add myminio somegroup newuser02
Added members `newuser02` to group `somegroup` successfully.

• 给用户组关联策略

[root@master01 ~]# mc admin policy attach myminio listbucketsonly --group somegroup
Attached Policies: [listbucketsonly]
To Group: somegroup

• 列出用户
  列出用户，或以json格式列出。

[root@master01 ~]# mc admin user list myminio
enabled    newuser               listbucketsonly     
enabled    newuser02                                 
enabled    newuser03                                 

[root@master01 ~]# mc admin user list myminio --json
{
 "status": "success",
 "accessKey": "newuser02",
 "userStatus": "enabled"
}
{
 "status": "success",
 "accessKey": "newuser03",
 "userStatus": "enabled"
}
{
 "status": "success",
 "accessKey": "newuser",
 "policyName": "listbucketsonly",
 "userStatus": "enabled",
 "memberOf": [
  {
   "name": "somegroup",
   "policies": [
    "listbucketsonly"
   ]
  }
 ]
}

• 显示用户信息
  显示用户详细信息。

[root@master01 ~]# mc admin user info myminio newuser
AccessKey: newuser
Status: enabled
PolicyName: listbucketsonly
MemberOf: [somegroup]

• 删除用户

[root@master01 ~]# mc admin user remove myminio newuser03
Removed user `newuser03` successfully.

Groups管理

• 创建用户组并添加用户

创建用户组并添加用户

• 从组中移除用户

[root@master01 ~]# mc admin group remove myminio somegroup newuser02
Removed members {newuser02} from group somegroup successfully.

• 列出用户组

[root@master01 ~]# mc admin group list myminio
mygroups
somegroup

• 禁用用户组

[root@master01 ~]# mc admin group disable myminio somegroup
Disabled group `somegroup` successfully.

• 启用用户组

[root@master01 ~]# mc admin group enable myminio somegroup
Enabled group `somegroup` successfully.

• 显示用户组信息

[root@master01 ~]# mc admin group info myminio somegroup
Group: somegroup
Status: enabled
Policy: listbucketsonly
Members: newuser

• 删除用户组
  只有当用户组为空，即用户组里不存在用户时，才可删除。

[root@master01 ~]# mc admin group remove myminio somegroup
mc: <ERROR> Could not perform remove operation. The specified group is not empty - cannot remove it. (Specified group is not empty - cannot remove it).

[root@master01 ~]# mc admin group info myminio somegroup                #查看用户组信息
Group: somegroup
Status: enabled
Policy: listbucketsonly
Members: newuser

[root@master01 ~]# mc admin group remove myminio somegroup newuser      #删除仅存的用户
Removed members {newuser} from group somegroup successfully.

[root@master01 ~]# mc admin group remove myminio somegroup              #再次删除用户组
Removed group somegroup successfully.

config管理

[root@master01 ~]# mc admin config export myminio                       #获取集群配置

[root@master01 ~]# mc admin config export myminio > my-serverconfig     #获取集群配置并重定向至文件

集群管理

查看集群信息

mc工具

显示debug调试

[root@master01 ~]# mc admin info --debug myminio

json格式显示

指定显示格式。

[root@master01 ~]# mc admin info myminio --json

重启minio服务

service命令提供了一种重新启动和停止所有 MinIO 服务器的方法。

[root@master01 ~]# mc admin policy --help
[root@master01 ~]# mc admin service restart myminio
Service status: ▰▰▱ [DONE]
Summary:
    ┌───────────────┬─────────────────────────────┐
    │ Servers:      │ 4 online, 0 offline, 0 hung │
    │ Restart Time: │ 1.133381597s                │
    └───────────────┴─────────────────────────────┘

curl工具使用

curl工具参考：
curl客户端使用
。

C++17 特性示例

1. 结构化绑定（Structured Binding）

结构化绑定允许你用一个对象的元素或成员同时实例化多个实体。
结构化绑定允许你在声明变量的同时解构一个复合类型的数据结构（如 结构体，
std::tuple
，
std::pair
， 或者
std::array
）。这样可以方便地获取多个值，而不需要显式地调用
std::tie()
或者
.get()
方法。

使用结构化绑定，能大大提升代码的可读性：

#include <iostream>
#include <string>
#include <unordered_map>

int main() {

  std::unordered_map<std::string,std::string> mymap;
  mymap.emplace("k1","v1");
  mymap.emplace("k2","v2");
  mymap.emplace("k2","v3");

  for (const auto& elem : mymap)
      std::cout << "old: " << elem.first << " : " << elem.second << std::endl;

  for (const auto& [key,value] : mymap)
      std::cout << " new: " << "key: " << key << ", value: " << value  << std::endl;

  return 0;
}

### 细说结构化绑定
为了理解结构化绑定，必须意识到这里面其实有一个隐藏的匿名对象。结构化绑定时引入的新变量名其实都指向这个匿名对象的成员/元素。
绑定到一个匿名实体
如下初始化的精确行为：
struct MyStruct {
  int i = 0;
  std::string s;
};
MyStruct ms;
auto [u, v] = ms;
等价于我们用 ms初始化了一个新的实体 e，并且让结构化绑定中的 u和 v变成 e的成员的别名，类似于如下定义：
auto e = ms;
aliasname u = e.i;
aliasname v = e.s;
这意味着 u和 v仅仅是 ms的一份本地拷贝的成员的别名。然而，我们没有为 e声明一个名称，因此我们不能直接访问这个匿名对象。注意 u和 v并不是 e.i和 e.s的引用（而是它们的别名）。decltype(u)的结果是成员 i的类型，declytpe(v)的结果是成员 s的类型。因此：
std::cout << u << ' ' << v << '\n';
会打印出 e.i和 e.s（分别是 ms.i和 ms.s的拷贝）。

e的生命周期和结构化绑定的生命周期相同，当结构化绑定离开作用域时 e也会被自动销毁。另外，除非使用了引用，否则修改用于初始化的变量并不会影响结构化绑定引入的变量（反过来也一样）  

### 示例代码
```cpp
#include <iostream>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>

struct MyStruct {
      int num {1};
      std::string str {"test"};
};

int main() {

  // 使用结构化绑定从 tuple 中提取值
  std::tuple<int, double, std::string> data = std::make_tuple(1, 3.14, "hello");
  auto [a, b, c] = data;
  std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;


  //value
  MyStruct my_struc;
  auto [num,str] = my_struc;
  std::cout << "num: " << num << ", str: " << str  << std::endl;
  my_struc.num = 2;
  str = "test2";
  std::cout << "num: " << num << ", str: " << str  << std::endl;


  //ref
  MyStruct my_struc2 {2,"test2"};
  const auto& [num2,str2] = my_struc2;
  std::cout << "num2: " << num2 << ", str2: " << str2  << std::endl;
  my_struc2.num = 4;
  std::cout << "num2: " << num2 << ", str2: " << str2  << std::endl;

  return 0;
}

### 总结
理论上讲，结构化绑定适用于任何有 public数据成员的结构体、C 风格数组和“类似元组 (tuple-like)的对
象”：
• 对于所有非静态数据成员都是 public的结构体和类，你可以把每一个成员绑定到一个新的变量名上。
• 对于原生数组，你可以把数组的每一个元素都绑定到新的变量名上。
• 对于任何类型，你可以使用 tuple-like API 来绑定新的名称，无论这套 API 是如何定义“元素”的。对于一个
类型 type这套 API 需要如下的组件：
– std::tuple_size<type>::value要返回元素的数量。
– std::tuple_element<idx, type>::type 要返回第 idx个元素的类型。
– 一个全局或成员函数 get<idx>()要返回第 idx个元素的值。
标准库类型 std::pair<>、std::tuple<>、std::array<> 就是提供了这些 API 的例子。如果结构体和类提供了 tuple-like API，那么将会使用这些 API 进行绑定，而不是直接绑定数据成员。

## 2. 拷贝消除（Copy Elision）

从技术上讲，C++17引入了一个新的规则：当以值传递或返回一个临时对象的时候必须省略对该临时对象的拷贝。
从效果上讲，我们实际上是传递了一个未实质化的对象 (unmaterialized object)。

自从第一次标准开始，C++就允许在某些情况下省略 (elision)拷贝操作，即使这么做可能会影响程序的运行结果（例如，拷贝构造函数里的一条打印语句可能不会再执行）。当用临时对象初始化一个新对象时就很容易出现这种情况，尤其是当一个函数以值传递或返回临时对象的时候。例如：
```cpp
#include <iostream>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <complex>


class MyClass
{
public:
  // 没有拷贝/移动构造函数的定义
  MyClass(const MyClass&) = delete;
  MyClass(MyClass&&) = delete;
};

MyClass bar() {
  return MyClass{};       // 返回临时对象
}

int main() {
  MyClass x = bar();  // 使用返回的临时对象初始化x

  return 0;
}
上面的代码用c++14会报错，c++17已经不报错了

然而，注意其他可选的省略拷贝的场景仍然是可选的，这些场景中仍然需要一个拷贝或者移动构造函数。例如：
MyClass foo()
{
  MyClass obj;
  ...
  return obj; // 仍 然 需 要 拷 贝/移 动 构 造 函 数 的 支 持
}
这里，foo()中有一个具名的变量 obj （当使用它时它是左值 (lvalue)）。因此，具名返回值优化 (named returnvalue optimization)(NRVO) 会生效，然而该优化仍然需要拷贝/移动支持。当 obj是形参的时候也会出现这种情况：
MyClass bar(MyClass obj) // 传 递 临 时 变 量 时 会 省 略 拷 贝
{
  ...
  return obj; // 仍 然 需 要 拷 贝/移 动 支 持
}

当传递一个临时变量（也就是纯右值 (prvalue)）作为实参时不再需要拷贝/移动，但如果返回这个参数的话仍然需要拷贝/ 移动支持因为返回的对象是具名的。 

### 作用
这个特性的一个显而易见的作用就是减少拷贝会带来更好的性能。尽管很多主流编译器之前就已经进行了这种优化，但现在这一行为有了标准的保证。尽管移动语义能显著的减少拷贝开销，但如果直接不拷贝还是能带来很大的性能提升（例如当对象有很多基本类型成员时移动语义还是要拷贝每个成员）。另外这个特性可以减少输出参数的使用，转而直接返回一个值（前提是这个值直接在返回语句里创建）。另一个作用是可以定义一个总是可以工作的工厂函数，因为现在它甚至可以返回不允许拷贝或移动的对象。
例如，考虑如下泛型工厂函数：
```cpp
#include <iostream>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <complex>
#include <utility>
#include <memory>
#include <atomic>


template <typename T, typename... Args>
T create(Args&&... args)
{
  return T{std::forward<Args>(args)...};
}


int main() {
  int i = create<int>(42);
  std::unique_ptr<int> up = create<std::unique_ptr<int>>(new int{42});
  std::atomic<int> ai = create<std::atomic<int>>(42);
  std::cout << "ai: " << ai << std::endl;
  return 0;
}