什么是声明式事务怎么实现开发？

来源：蜘蛛抓取(WebSpider) 时间：2022-11-04 19:14 标签：声明式事务怎么实现

首先声明，我不是标题党，刻意诱惑点击或夸大描述。我打算证明，无论有没有金钱方面的考虑，通过设计和实现，PostgreSQL都可以客观，可衡量地比当前可用的数据库更好。

究竟我怎样才能证明这样一种崇高的说法是正确的呢?

继续阅读，可爱的读者。我保证不会浪费您的时间。

PostgreSQL有一个安全邮件列表。PostgreSQL项目组与其他所有人在同时学习入侵向量。没有什么是隐藏的，任何发现的东西都以使商业供应商头晕目眩的速度进行工作。供应商提供了正在审查的软件，他们所提供的的缺陷列表会更简短。

这意味着所有已知的攻击载体一旦公开就会被处理。这种安全响应能力在商业领域甚至是不可估量的。对于商业供应商来说，在问题得到解决之前保密对补救至关重要。PostgreSQL却没有这样的限制，这是不是很棒呢！

多版本并发控制对您有好处

PostgreSQL选择了一种并发控制方法，该方法最适合高INSERT和SELECT工作负载。

PostgreSQL的设计非常简单，只需记住更新和删除的跟踪开销。重要的是，如果您尊重数据，则应该尝试拥抱PostgreSQL为您提供的数据安全性。

PostgreSQL中DDL也能参与事务。完全迁移或完全无效（最糟糕的一种无效方法是近乎马上完成的废弃）。测试用例也可以重建。需要重置测试工具吗？答案是只需回滚事务。

PostgreSQL支持符合标准的事务隔离形式，包括序列化，已提交读和可重复读。这些方法完全符合ACID标准。

那么，您想使用NoSQL、Riak、REACT、Redis、Mongo等的功能吗？PostgreSQL都具备这种能力。不可否认，不能包括原始产品的所有细节。例如，PostgreSQL不会为您创建新的分片，那仍然是一个手动过程。但总有办法，譬如pg_partman。

您想要列数据存储吗？hstore可供选择。

您不想再培训员工吗？使用您已选择的语言继续拓展业务。

您要部分复制吗？流式逻辑复制适合您。

您要从其他系统提取数据吗？PostgreSQL具有所有数据库中最活跃的联邦对象集合-外部数据包装器（FDW），您可以用胶带和拉链将PostgreSQL挂接鳄鱼身上。可以对他像对待您自己的数据一样。

很难想到一个PostgreSQL不具备的功能，或者没有PostgreSQL扩展所能提供的功能。

可以说PostGIS社区可能比PostgreSQL社区本身更大。PostgreSQL的映射功能将其放在了一个类中，即使与非常昂贵的替代品相比也是如此。

PostGIS项目之所以选择PostgreSQL作为平台，是因为其易扩展性和丰富的数据功能。这些功能可以直接公开给其他任何项目使用。任何其他供应商，无论是商业的还是开源的，都无法回答这些问题。

PostgreSQL在开源领域正在引领发展

PostgreSQL项目是开源软件中最引人注目的组织之一。随着社区庞大的力量和巨大的增长，现在可以说它所存在的任何不足都会在其他供应商意想不到的时间内被解决。

几乎每天都有新的企业级功能特性发布，维护这些特性的员工是从每家公司都希望聘用的天才中挑选出来的，只是人手远远不够。

PostgreSQL建立了长期稳定的解决方案

PostgreSQL在内核中内置了逻辑复制。这允许跨版本迁移。您没有被锁定到特定的硬件或软件版本。该解决方案可以无限升级。

此外，许多平台都支持PostgreSQL，包括Linux的超稳定版本。你是否需要一个比典型的3~5年投资回报率还长的解决方案?即使你从来没有升级过硬件，PostgreSQL也会永远支持你。费用很容易计算，0美元。

数据库语言通常是声明性的。也就是说，您使用自己选择的内置语言编写了一个查询，描述了您希望看到的结果。该数据库尝试解码您的意图，并提供适当的结果。这是所有声明式编程模型的基础。在PostgreSQL中，这可以归结为将函数映射到SQL语言中的关键字，有时还会有几个算法选择来精确地实现每个声明。

在关于命令式与声明式编程模型的古老争论中，我觉得声明式编程只是一种伪装的命令式编程。数据库查询语言中的每个声明性令牌最终都映射到一种或几种以命令式术语应用声明的算法。因此，由Henrietta定义的阻抗失配最终是由开发人员决定的。也就是说，如果开发人员的思维方式与数据库函数程序员的思维方式完全一致，那么就不会出现不匹配。

那么，假设一个模型只是另一个模型的调用特征，那么声明式模型最终将比命令模型更好吗？很高兴您这么问，因为这正是我要强调的一点。

PostgreSQL开发人员比较聪明。我不是开玩笑或忸怩作态。从字面上看，成千上万的贡献者为PostgreSQL项目做出了数以百万计的贡献，其中许多是对其他贡献者的改进。你头脑中想到的任何情况比起已经实现的功能更好的机会是非常低的。而且，即使你的想法更好，你也应该把它们贡献给PostgreSQL项目，以造福所有人，从而提高其他人的标准。

那么，是什么让PostgreSQL那么精彩呢？无需考虑公司利益即可在全球范围内共享思想。成千上万的开发人员正在花费数十万小时来做出更好的算法选择。因此，您的软件在每个版本中都会变得更好，通常不需要做任何特别的事情。

您说，这难道不是软件的本质吗？嗯,是的。但远不及整个世界范围的人才都参与到你的项目中来。PostgreSQL在开源社区中享有非常显著的地位。商业供应商将永远无法跟上开源项目在这个层次上所能提供的变化速度。向开源(尤其是PostgreSQL)的迁移就是证明。

商业供应商可以指出的明显优势已经所剩无几了。其中包括SMP支持、双向复制和外部工具。猜猜社区现在正在做什么，很可能这些在未来几年将得以发布。

PostgreSQL有一个充满活力的编写辅助软件的技术社区。这包括插入您喜欢的任何语言，并使用它以有用的任何方式扩展PostgreSQL。您是否喜欢perl字符串处理？好的，可以使用它。Python地图支持怎么样？当然，只需插入python就可以进城了。是否想使用PostgreSQL后端编写Web服务？太棒了，PostgreSQL会帮上忙。JSON？好。XML？PostgreSQL对所有这些都有直接的支持，并且提供了无限的支持。如果您认为可以使用一种很好的语言，则将其插入PostgreSQL，然后将其放在服务器端即可。

您可以创建自己的函数，数据类型，运算符，集合，窗口函数或几乎其他任何东西。没有看到您喜欢的功能？从源代码拷贝并自定义它。由于许可证，您可以自由地这样做。

PostgreSQL还提供了一些钩子函数，允许您扩展数据库而不必进行极端的编程。

这种吸收任何其他语言特性的能力是PostgreSQL所独有的。您可以使用现有的任何标准库来提供任何特性。你可以遵循标准，跟上变化，可以在PostgreSQL尚在运行时对其进行更新，并且可以免费完成所有操作。

PostgreSQL具有多种功能，可以充分利用已提供的硬件平台。分区，并行执行，部分索引，表空间，缓存和并行非阻塞维护例程（PostgreSQL中几乎所有东西最近都在使用CONCURRENTLY关键字）

如果这还不足以满足您的需求，那么物理流复制将以便宜的价格为您提供您所需数量的可读从节点。分片、内存缓存、队列、负载平衡和连接池都可以在PostgreSQL中使用。还不够吗？逻辑流复制怎么样？您想对世界范围的数据库进行地理分区吗？好了，欢迎使用双向复制。

而且价格仍然是0美元。

PostgreSQL支持如此多的索引列表，以至于使人难以确定如何使用它们。GiST、spi - GiST、KNN GiST、GIN、BRIN和Btree都是可用的。还有很多其他功能可以通过扩展实现，例如Bloom过滤器等。

PostgreSQL可以将它们与函数驱动的索引，部分索引，覆盖索引和全文搜索一起使用。这些扩展功能不是互斥的。您可以同时使用它们。

已经提到的几种技术使PostgreSQL成为了出色的数据集成和分发平台。多种形式的复制与联合为几乎任何类型的数据系统提供了推、拉技术。

它们可以无限配置、组合在一起，以桥接数据库存储解决方案。所有这些都不需要任何ETL/ELT处理程序包。PostgreSQL就是这样做的。这个地球上最快的单一事实来源数据库是通过完全不将数据从源系统移出来实现的。这意味着数据始终是最新的，并且可以管理响应时间。

如果您无法忍受源系统的不可靠性，或者希望在查询端获得更好的性能，您还可以使用物化视图定期缓存数据，这些视图可以在查询时进行更新。

译者注：推手是太极术语，本地引入目的是描述数据的推送和拉取。

PostgreSQL有自己的许可证，主要基于BSD许可证。这允许更大的使用和分发自由。

该许可证适用于主要项目的所有代码，主要贡献扩展，客户端库，连接管理器以及大多数相关工具。

它是高度宽容的，原文许可描述中，并不涉及可供购买。

PostgreSQL项目要求任何提交代码的开发人员都要提供建议描述文档。该建议用于创建功能的说明，建议文档以多种格式提供。此文档还用于评估功能模块本身，并作为未来开发功能模块的参考。

总之，这意味着PostgreSQL依赖于文档。有很多PostgreSQL的开发人员已经学会了用C语言编码，数据库是如何工作的，以及如何管理PostgreSQL项目。这份文件是首屈一指的。

PostgreSQL经过了广泛、详尽的测试。每个错误都会通过测试来验证其存在，并编写代码来满足该测试。首先通过创建测试（和文档）来编写新功能，然后对其进行编码，直到实现该功能为止。

这些测试已集成到组建场中进行回归，因此bug不会(重新)出现在PostgreSQL的未来版本中。这意味着在每个构建周期中，将为每个版本的PostgreSQL运行每个测试（当前测试）。这是大量的测试，它确保PostgreSQL仍然是可用的最稳定的数据库。

PostgreSQL仅在所有回归测试通过后才发布。这提供了“ 0个已知错误”版本。

PostgreSQL的开发人员来自世界各地。自PostgreSQL成为大学毕业生项目以来，他们就一直在使用多种本地语言工作。国际化和本地化已经成为PostgreSQL的标准做法，而PostgreSQL不再是吸引全球商业市场的一个螺钉。

尽管PostgreSQL出于兼容性原因将某些国际化委托给操作系统，但许多翻译都嵌入到系统中，从而提供了无缝的语言过渡体验。

PostgreSQL在云架构中使用ansible、kubernetes和来自多个云供应商的专有工具。有几种本地云实现可供选择，以匹配您的架构。

如果您想像牛而不是宠物那样对待服务器，PostgreSQL也为您提供了云服务。

PostgreSQL在项目的整个生命周期内一直是标准的。由于PostgreSQL起源于大学的研究生课程，因此它已被用作许多SQL标准的参考实现。

根据出色的文档描述，“ PostgreSQL支持SQL:2016的大部分主要功能。完整的核心一致性需要179个强制性的特性，PostgreSQL至少符合160个。这几乎超过了任何其他数据库引擎。

PostgreSQL实现了公共表表达式(CTE)、语言控制结构(if、for、case等)、结构化错误处理，以及您期望从成熟过程语言中获得的所有好处。

我仍然可以谈论用户组、IRC频道、有解决方案的网站、博客文章和导师的奇妙社区。对于数据库是跨平台、跨体系结构和跨文化的，我可以从哲学的角度进行阐述。有无数个小时的演讲、视频和讲座。

或者，您可以直接下载它，看看它是否超出您的想象。我想您会感到非常惊喜。

PG考试相关详情：.cn/

特别声明：以上内容(如有图片或视频亦包括在内)为自媒体平台“网易号”用户上传并发布，本平台仅提供信息存储服务。

结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合，也叫结构。

结构体和其他类型基础数据类型一样，例如int类型，char类型只不过结构体可以做成你想要的数据类型。以方便日后的使用。

在实际项目中，结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。由于C语言无法操作数据库，所以在项目中通过对结构体内部变量的操作将大量的数据存储在内存中，以完成对数据的存储和操作。

在实际问题中有时候我们需要几种数据类型一起来修饰某个变量。

例如一个学生的信息就需要学号（字符串），姓名（字符串），年龄（整形）等等。

这些数据类型都不同但是他们又是表示一个整体，要存在联系，那么我们就需要一个新的数据类型。

——结构体，它就将不同类型的数据存放在一起，作为一个整体进行处理。

结构体在函数中的作用不是简便，其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么，只要根据定义使用就可以了。

结构体的大小不是结构体元素单纯相加就行的，因为我们现在主流的计算机使用的都是32Bit字长的CPU，对这类型的CPU取4个字节的数要比取一个字节要高效，也更方便。所以在结构体中每个成员的首地址都是4的整数倍的话，取数据元素时就会相对更高效，这就是内存对齐的由来。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragmapack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。

1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragmapack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragmapack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

3、结合1、2可推断：当#pragmapack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。

在C语言中，可以定义结构体类型，将多个相关的变量包装成为一个整体使用。在结构体中的变量，可以是相同、部分相同，或完全不同的数据类型。在C语言中，结构体不能包含函数。在面向对象的程序设计中，对象具有状态（属性）和行为，状态保存在成员变量中，行为通过成员方法（函数）来实现。C语言中的结构体只能描述一个对象的状态，不能描述一个对象的行为。在C++中，考虑到C语言到C++语言过渡的连续性，对结构体进行了扩展，C++的结构体可以包含函数，这样，C++的结构体也具有类的功能，与class不同的是，结构体包含的函数默认为public，而不是private。

这个声明描述了一个由两个字符数组和一个float变量组成的结构体。

但是注意，它并没有创建一个实际的数据对象，而是描述了一个组成这类对象的元素。

因此，我们有时候也将结构体声明叫做模板，因为它勾勒出数据该如何存储，并没有实例化数据对象。

下面介绍一下上面的结构体声明；

1、首先使用关键字struct，它表示接下来是一个结构体。

2、后面是一个可选的标志（book），它是用来引用该结构体的快速标记。

因此我们以后就可以这样创建数据对象

3、接下来就是一个花括号，括起了结构体成员列表，及每个成员变量，使用的都是其自己的声明方式来描述，用分号来结束描述；

例如：char title[MAXTITL];字符数组就是这样声明的，用分号结束；

注意：其中每个成员可以使用任何一种C数据结构甚至是其他的结构体，也是可以的；

4、在结束花括号后的分号表示结构体设计定义的结束。

关于其struct声明的位置，也就是这段代码要放到哪里。同样这也是具有作用域的。

这种声明如果放在任何函数的外面，那么则可选标记可以在本文件中，该声明的后面的所有函数都可以使用。

如果这种声明在某个函数的内部，则它的标记只能在内部使用，并且在其声明之后；

关于我们不断说的，标记名是可选的，那么我们什么时候可以省略，什么时候一定不能省略呢？

如果是上面那种声明定义的方法，并且想在一个地方定义结构体设计，而在其他地方定义实际的结构体变量，那么就必须使用标记；

可以省略，设计的同时就创建该结构体变量，但是这种设计是一次性的。

struct 结构体名(也就是可选标记名）{ 成员变量；}；//使用分号表示定义结束。

C语言结构体定义的三种方式

之前我们结构体类型的定义（结构体的声明）只是告诉编译器该如何表示数据，但是它没有让计算机为其分配空间。

我们要使用结构体，那么就需要创建变量，也就是结构体变量；

看到这条指令，编译器才会创建一个结构体变量library，此时编译器才会按照book模板为该变量分配内存空间，并且这里存储空间都是以这个变量结合在一起的。

这也是后面访问结构体变量成员的时候，我们就要用到结构体变量名来访问。

在结构体声明中，struct book所起到的作用就像int，，，，等基础数据类型名作用一样。

定义两个struct book结构体类型的结构体变量，还定义了一个指向该结构体的指针，其ss指针可以指向s1，s2，或者任何其他的book结构体变量。

这两种是等效的，只是第一种可以减少代码的编写量；

现在还是回到刚才提及的那个问题，可选标志符什么时候可以省略；

//注意这里不再是定义声明结构体类型，而是直接创建结构体变量了，这个编译器会分配内存的；

//这样的确可以省略标识符也就是结构体名，但是只能使用一次；因为这是；声明结构体的过程和定义结构体变量的过程和在了一起；并且个成员变量没有初始化的；

//如果你想多次使用一个结构体模块，这样子是行不通的；

用typedef定义新类型名来代替已有类型名，即给已有类型重新命名；

一般格式为；typedef 已有类型新类型名；

总结一下关于结构体变量的定义；

1、先定义结构体类型后再定义结构体变量；

格式为；struct 结构体名变量名列表；

2、在定义结构体类型的同时定义结构体变量；

直接定义结构体类型变量，就是第二种中省略结构体名的情况；

这种方式不能指明结构体类型名而是直接定义结构体变量，并且在值定义一次结构体变量时适用，无结构体名的结构体类型是无法重复使用的。

也就是说，后面程序不能再定义此类型变量了，除非再写一次重复的struct。

对于结构体变量的初始化

先回忆一下关于基本数据类型和数组类型的初始化；

回忆一下数组初始化问题；

再回到结构体变量的初始化吧？

关于结构体变量的初始化与初始化数组类似；

也是使用花括号括起来，用逗号分隔的初始化好项目列表，注意每个初始化项目必须要和要初始化的结构体成员类型相匹配。

加入一点小知识；关于结构体初始化和存储类时期的问题；如果要初始化一个具有静态存储时期的结构体，初始化项目列表中的值必须是常量表达式；

注意如果在定义结构体变量的时候没有初始化，那么后面就不能全部一起初始化了；意思就是：

'yuwen',//title为字符串 22.5

};//这样就是不行的，只能在定义的时候初始化才能全部赋值，之后就不能再全体赋值了，只能单个赋值；

只能；s1.title =

对于结构体的指定初始化；

结构体就像一个超级数组，在这个超级数组内，一个元素可以是char类型，下个元素就可以是flaot类型，再下个还可以是int数组型，这些都是存在的。

在数组里面我们通过下标可以访问一个数组的各个元素，那么如何访问结构体中的各个成员呢？

用结构成员运算符点（.）就可以了；

结构体变量名.成员名;

注意，点其结合性是自左至右的，它在所有的运算符中优先级是最高的；

然后就可以像字符数组那样使用s1.title,像使用float数据类型一样使用s1.value；

注意，s1；虽然是个结构体，但是s1.value却是float型的。

因此s1.value就相当于float类型的变量名一样，按照float类型来使用；

按照道理我们应该将（s1。value括起来，因为他们是整体，表示s1的value部分）但是我们不括起来也是一样的，因为点的优先级要高于&。

如果其成员本身又是一种结构体类型，那么可以通过若干个成员运算符，一级一级的找到最低一级成员再对其进行操作；

结构体变量名.成员.子成员………最低一级子成员;

可以将一个结构体变量作为一个整体赋值给另一相同类型的结构体变量，可以到达整体赋值的效果；这个成员变量的值都将全部整体赋值给另外一个变量；

不能将一个结构体变量作为一个整体进行输入和输出；在输入输出结构体数据时，必须分别指明结构体变量的各成员；

小结：除去“相同类型的结构体变量可以相互整体赋值”外，其他情况下，不能整体引用，只能对各个成员分别引用；

那么，下面这个结构体类型占几个字节呢？

通过下面的方式，可以清楚知道为什么是8字节。

1、定义20个char元素的数组

2、定义结构体类型的指针ps指向ss数组

可以看到addr和name都只占一个字节，但是未满4字节，跳过2字节后才是id的值，这就是4字节对齐。结构体成员有int型，会自动按照4字节对齐。

把结构体成员顺序调换位置，



                  可见，结构体成员顺序优化，可节省空间。

如果全部成员都是char型，会按照1字节对齐，即

结构体嵌套结构体方式：

先定义结构体类型PERSON，再定义结构体STUDENT，PERSON作为它的一个成员。

按照前面的方法，打印各成员的值。

2、打印输出各成员和长度



                  调换STUDENT成员顺序，即

结构体嵌套其实没有太意外的东西，只要遵循一定规律即可：

特别的,可以一边定义结构体B，一边就使用上：

但是如果嵌套的结构体B是在A内部才声明的，并且没定义一个对应的对象实体b，这个结构体B的大小还是不算进结构体A中。

（结构体长度、结构体字节对齐、结构体嵌套内容来源于公众号“0基础学单片机”，作者：森林木，感谢原作者的分享）

struct结构体，在结构体定义的时候不能申请内存空间，不过如果是结构体变量，声明的时候就可以分配——两者关系就像C++的类与对象，对象才分配内存（不过严格讲，作为代码段，结构体定义部分“.text”真的就不占空间了么？当然，这是另外一个范畴的话题）。

结构体的大小通常（只是通常）是结构体所含变量大小的总和，下面打印输出上述结构体的size：

对于结构体中比较小的成员，可能会被强行对齐，造成空间的空置，这和读取内存的机制有关，为了效率。通常32位机按4字节对齐，小于的都当4字节，有连续小于4字节的，可以不着急对齐，等到凑够了整，加上下一个元素超出一个对齐位置，才开始调整，比如3+2或者1+4，后者都需要另起（下边的结构体大小是8bytes），相关例子就多了，不赘述。

相应的，64位机按8字节对齐。不过对齐不是绝对的，用#pragma pack()可以修改对齐，如果改成1，结构体大小就是实实在在的成员变量大小的总和了。

和C++的类不一样，结构体不可以给结构体内部变量初始化，。

PS：结构体的声明也要注意位置的，作用域不一样。

C++的结构体变量的声明定义和C有略微不同，说白了就是更“面向对象”风格化，要求更低。

为什么有些函数的参数是结构体指针型

如果函数的参数比较多，很容易产生“重复C语言代码”，例如：

上述C语言代码定义了三个函数：get_video() 用于获取一段视频信息，包括：视频的名称，地址，大小，时间，编码算法。



                      然后 handle_video() 函数根据视频的这些参数处理视频，之后 send_video() 负责将处理后的视频发送出去。下面是一次调用：

从上面这段C语言代码来看，为了完成视频的一次“获取”——“处理”——“发送”操作，C语言程序不得不定义多个变量，并且这些变量需要重复写至少三遍。

虽说C语言程序的代码风格因人而异，但是“重复的代码”永远是应尽力避免的，原因本专栏已经分析多次。不管怎么说，每次使用这几个函数，都需要定义很多临时变量，总是非常麻烦的。所以，这种情况下，完全可以使用C语言的结构体语法：

定义好 video_info 结构体后，上述三个C语言函数的参数可以如下写，请看：

修改后的C语言代码明显精简多了，在函数内部，视频的各个信息可以通过结构体指针 vinfo 访问，例如：

事实上，使用结构体 video_info 封装视频信息的各个参数后，调用这几个修改后的函数也是非常简洁的：

从上述C语言代码可以看出，使用修改后的函数只需定义一个临时变量，整个代码变得非常精简。

既然 handle_video() 和 send_video() 函数只需要读取参数信息，那我们就无需再使用指针型了呀？的确如此，这两个函数的参数直接使用 struct video_info 型也是可以的：

似乎这种写法和使用  struct video_info  *指针型 参数的区别，无非就是函数内部访问数据的方式改变了而已。但是，如果读者能够想到我们之前讨论过的C语言函数的“栈帧”概念，应该能够发现，使用指针型参数的 handle_video() 和 send_video() 函数效率更好，开销更小。

`嵌入式开发中，C语言位结构体用途详解`

在嵌入式开发中，经常需要表示各种系统状态，位结构体的出现大大方便了我们，尤其是在进行一些硬件层操作和数据通信时。但是在使用位结构体的过程中，是否深入思考一下它的相关属性？是否真正用到它的便利性，来提高系统效率？

下面将进行一些相关实验（这里以项目开发中的实际代码为例）：

分析：这里定义了一个位结构体类型SYMBOL_STRUCT，那么用该类型定义的变量都哪些属性呢？

开始以为：reserved_1和SYMBOL_TYPE不在一个地址上，因为他们5+4共9位，超过了1个字节地址，但实际他们共用首地址了；而且reserved_2只定义了8位，竟然实际占用了4个字节（0x1fff0834 - 0x1fff0830），我本来是想让他占用1个字节的。WORDS整体占了8个字节（0x1fff0834
                              - 0x1fff082c），设计时分析占用5个字节

8，地址也是一样的，都是以uint_32为单位取地址。

同理，上面的5个变量，共用一个地址就不足为奇了。而且有效位的分配不是连续进行的，例如SYMBOL_TYPE+reserved_1 共9位，超过了一个字节，索性系统就分配两个字节给他们，每人一个；SYMBOL_NUMBER+SYMBOL_ACTIVE 共8位，一个字节就能搞定。

2、修改数据结构，验证上述猜想

0x1fff069e)，其他变量也都符合上面的结论猜想。但是，注意看上面黄色和红色的语句，总感觉有些勉强，那么我又会想，前两个变量数据域是9位，那么他们实际上是不是真正的独立呢？虽然在uint_8上面他们是不同的地址，在uint_32的时候是不是也是不同的地址空间呢？

3、分析结构体内部的数据域是否连续，看下图及结果



                              本来假设： 由前2次试验的结论，一共占用8个字节，节空间占用：(2+4)+(4+4)+(2+2+4)+(2+2)+(6)。可是，实际效果并不是想的那样。实际只占用了4个字节，系统并没有按照预想的方式，为RESERVED变量分配4个字节。

这些数据域，整体相加一共32位，占用4个字节(不考虑数据对齐问题)。而实际确实是占用了4个字节，唯一的原因就是：这些数据域以紧凑的方式链接，没有任何空闲位。实际是不是这样呢？



                              这里为了验证是否紧凑链接，用到了一个union数据，后面会讲到用union不会对数据组织方式有任何影响，看实际与上次的一样，也能分析出来。

主要是分析第2和第3个数据域是否紧密链接的。OBJECT_ACTIVE_PRE赋值0b，NUMBER_ACTIVE赋值0b，其他变量都是0，看到WORD数值0b0。分析WORD数据，可以看到这款MCU还是小端格式(高位数据在高端，低位数据在低端，这里不对大小端进行讨论)，断开数据变成(0)10111
                              ，正好是，OBJECT_ACTIVE_PRE数据域，跨越了两个字节，并不是刚开始设想的那样。这就印证了上面的紧密链接的结论，也符合数据结果输出。

4、再次实验，分析数据是否紧密链接，看下图和结果



                              可以看到，RESERVED数据域已经不再属于4个地址空间内了(0x1fff0518 -
                              0x1fff051b)，但是他们整体加起来还是32个位域。这说明数据中间肯定有“空隙”存在了，空隙在哪？看一下NUMBER_STATE，如果紧密的话它应该跟NUMBER_ACTIVE在同一个字节地址上，可是他们并不在一块，“空隙”就存在这里。

这两个结构体有什么不一样？数据类型不一致，一个是uint_32，一个是uint_8。综上所述：数据类型影响的是编译器在分配物理空间时的大小单位，uint_32是以4个字节为单位，而后面的位域则是指在已经分配好的物理空间内部再紧凑的方式分配数据位，当物理空间不能满足位域时，那么系统就再次以一定大小单位进行物理空间分配，这个单位就是上面提到的uint_8或者uint_32。

举例：上面uint_32时，这些位域不管是不是在一个字节地址上，如果能够紧凑的分配在一个4字节空间大小上，就直接紧凑分配。如果不能则继续分配(总空间超过4字节)，则再次以4字节空间分配，并把新的位域建立在新的地址空间上(条目1上的就是)。当uint_8时，很明显如果位域不能紧凑的放在一个字节空间上，那么就从新分配新的1字节空间大小，道理是一样的。

5、结构体组合、共用体组合是否影响上述结论



                        可以看到，系统并没有因为位结构体上面有uint_4的4字节变量或者共用体类型，就改变分配策略把位域都挤到4字节之内，看来他们是没有什么实质性联系的。这里把uint_32改成uint_8，或者把位结构体也替换掉，经我试验证明，都是没有任何影响的。

1、在操作位结构体时，要关注变量的位域是否在一个变量类型（uint_32或者uint_8）上，判断占用空间大小

2、除了位域，还要关注变量定义类型，因为编译器空间分配始终是按类型分配的，位域只是指出了有效位(小于类型占用空间)，而且如果位域大于类型空间，编译器直接报错（如 uint_8  test  :15，可自行实验）。

3、这两个因素都影响变量占用空间大小，具体可以结合调试窗口，通过地址分配分析判断

4、最重要的一点：上面的所有结果，都是基于我自己的CodeWarrior10.2和MQX3.8分析出来的，不同的编译环境和操作系统，都可能会有不同的结果；而且即便是环境相同，编译器的配置和优化选项都有可能影响系统处理结果。结论并不重要，主要想告诉大家这一块隐藏陷阱，在以后处理类似问题时，要注意分析避让并掌握方法。

摘要： 问题很详细，插图很好看。

经授权转载，版权归原作者所有。

React是流行的javascript框架之一，在2019年及以后将会更加流行。React于2013年首次发布，多年来广受欢迎。它是一个声明性的、基于组件的、用于构建用户界面的高效javascript库。

以下是面试前必须了解的话题。

声明式编程 vs 命令式编程
什么是虚拟DOM及其工作原理
如何更新状态和不更新状态
如何在React中应用样式
什么是Redux及其工作原理
什么是React路由器及其工作原理
如何在重新加载页面时保留数据

声明式编程是一种编程范式，它关注的是你要做什么，而不是如何做。它表达逻辑而不显式地定义步骤。这意味着我们需要根据逻辑的计算来声明要显示的组件。它没有描述控制流步骤。声明式编程的例子有HTML、SQL等

声明式编程 vs 命令式编程

声明式编程的编写方式描述了应该做什么，而命令式编程描述了如何做。在声明式编程中，让编译器决定如何做事情。声明性程序很容易推理，因为代码本身描述了它在做什么。

下面是一个例子，数组中的每个元素都乘以 2，我们使用声明式map函数，让编译器来完成其余的工作，而使用命令式，需要编写所有的流程步骤。

函数式编程是声明式编程的一部分。javascript中的函数是第一类公民，这意味着函数是数据，你可以像保存变量一样在应用程序中保存、检索和传递这些函数。

函数式编程有些核心的概念，如下：

不可变性意味着不可改变。在函数式编程中，你无法更改数据，也不能更改。如果要改变或更改数据，则必须复制数据副本来更改。

例如，这是一个student对象和changeName函数，如果要更改学生的名称，则需要先复制　student　对象，然后返回新对象。

对象，应该使用Object.assign复制对象并返回新对象。

纯函数是始终接受一个或多个参数并计算参数并返回数据或函数的函数。它没有副作用，例如设置全局状态，更改应用程序状态，它总是将参数视为不可变数据。

我想使用 appendAddress 的函数向student对象添加一个地址。如果使用非纯函数，它没有参数，直接更改 student 对象来更改全局状态。

使用纯函数，它接受参数，基于参数计算，返回一个新对象而不修改参数。

我们讲了很多关于不可变性的内容，如果数据是不可变的，我们如何改变数据。如上所述，我们总是生成原始数据的转换副本，而不是直接更改原始数据。

再介绍一些 javascript内置函数，当然还有很多其他的函数，这里有一些例子。所有这些函数都不改变现有的数据，而是返回新的数组或对象。

高阶函数是将函数作为参数或返回函数的函数，或者有时它们都有。这些高阶函数可以操纵其他函数。

下面是另一个名为isPersonOld的高阶函数示例，该函数接受另外两个函数，分别是 message和isYoung 。

递归是一种函数在满足一定条件之前调用自身的技术。只要可能，最好使用递归而不是循环。你必须注意这一点，浏览器不能处理太多递归和抛出错误。

下面是一个演示递归的例子，在这个递归中，打印一个类似于楼梯的名称。我们也可以使用for循环，但只要可能，我们更喜欢递归。

在React中，我们将功能划分为小型可重用的纯函数，我们必须将所有这些可重用的函数放在一起，最终使其成为产品。将所有较小的函数组合成更大的函数，最终，得到一个应用程序，这称为组合。

实现组合有许多不同方法。我们从Javascript中了解到的一种常见方法是链接。链接是一种使用点表示法调用前一个函数的返回值的函数的方法。

我们有一个name，如果firstName和lastName大于5个单词的大写字母，刚返回，并且打印名称的名称和长度。

在React中，我们使用了不同于链接的方法，因为如果有30个这样的函数，就很难进行链接。这里的目的是将所有更简单的函数组合起来生成一个更高阶的函数。

React是一个简单的javascript UI库，用于构建高效、快速的用户界面。它是一个轻量级库，因此很受欢迎。它遵循组件设计模式、声明式编程范式和函数式编程概念，以使前端应用程序更高效。它使用虚拟DOM来有效地操作DOM。它遵循从高阶组件到低阶组件的单向数据流。

Angular是一个成熟的MVC框架，带有很多特定的特性，比如服务、指令、模板、模块、解析器等等。React是一个非常轻量级的库，它只关注MVC的视图部分。

Angular遵循两个方向的数据流，而React遵循从上到下的单向数据流。React在开发特性时给了开发人员很大的自由，例如，调用API的方式、路由等等。我们不需要包括路由器库，除非我们需要它在我们的项目。

React 使用 Virtual DOM 来更新真正的 DOM，从而提高效率和速度。我们来详细讨论这些。

浏览器遵循HTML指令来构造文档对象模型(DOM)。当浏览器加载HTML并呈现用户界面时，HTML文档中的所有元素都变成DOM元素。

DOM是从根元素开始的元素层次结构。例如，看看下面的HTML。

当在浏览器中加载这个HTML时，所有这些HTML元素都被转换成DOM元素，如下所示

当涉及到SPA应用程序时，首次加载index.html，并在index.html本身中加载更新后的数据或另一个html。当用户浏览站点时，我们使用新内容更新相同的index.html。每当DOM发生更改时，浏览器都需要重新计算CSS、进行布局并重新绘制web页面。

React 使用 Virtual DOM 有效地重建 DOM。对于我们来说，这使得DOM操作的一项非常复杂和耗时的任务变得更加容易。 React从开发人员那里抽象出所有这些，以便在Virtual DOM的帮助下构建高效的UI。

虚拟DOM是如何工作的

虚拟DOM只不过是真实 DOM 的 javascript对象表示。与更新真实 DOM 相比，更新 javascript 对象更容易，更快捷。考虑到这一点，让我们看看它是如何工作的。

每当有更新时，它都会维护两个虚拟DOM，以比较之前的状态和当前状态，并确定哪些对象已被更改。例如，段落文本更改为更改。

现在，它通过比较两个虚拟DOM 差异，并将这些变化更新到实际DOM

一旦真正的DOM更新，它也会更新UI

JSX是javascript的语法扩展。它就像一个拥有javascript全部功能的模板语言。它生成React元素，这些元素将在DOM中呈现。React建议在组件使用JSX。在JSX中，我们结合了javascript和HTML，并生成了可以在DOM中呈现的react元素。

下面是JSX的一个例子。我们可以看到如何将javascript和HTML结合起来。如果HTML中包含任何动态变量，我们应该使用表达式{}。

代码部署后可能存在的BUG没法实时知道，事后为了解决这些BUG，花了大量的时间进行log 调试，这边顺便给大家推荐一个好用的BUG监控工具。

React 中一切都是组件。我们通常将应用程序的整个逻辑分解为小的单个部分。我们将每个单独的部分称为组件。通常，组件是一个javascript函数，它接受输入，处理它并返回在UI中呈现的React元素。

在React中有不同类型的组件。让我们详细看看。

函数/无状态/展示组件

函数或无状态组件是一个纯函数，它可接受接受参数，并返回react元素。这些都是没有任何副作用的纯函数。这些组件没有状态或生命周期方法，这里有一个例子。

类或有状态组件具有状态和生命周期方可能通过setState()方法更改组件的状态。类组件是通过扩展React创建的。它在构造函数中初始化，也可能有子组件,这里有一个例子。

受控组件是在 React 中处理输入表单的一种技术。表单元素通常维护它们自己的状态，而react则在组件的状态属性中维护状态。我们可以将两者结合起来控制输入表单。这称为受控组件。因此，在受控组件表单中，数据由React组件处理。

这里有一个例子。当用户在 todo 项中输入名称时，调用一个javascript函数handleChange捕捉每个输入的数据并将其放入状态，这样就在 handleSubmit中的使用数据。

大多数情况下，建议使用受控组件。有一种称为非受控组件的方法可以通过使用Ref来处理表单数据。在非受控组件中，Ref用于直接从DOM访问表单值，而不是事件处理程序。

定义Ref并传递该输入表单并直接从handleSubmit方法中的DOM访问表单值。

容器组件是处理获取数据、订阅 redux 存储等的组件。它们包含展示组件和其他容器组件，但是里面从来没有html。

高阶组件是将组件作为参数并生成另一个组件的组件。 Redux connect是高阶组件的示例。这是一种用于生成可重用组件的强大技术。

Props 是只读属性，传递给组件以呈现UI和状态，我们可以随时间更改组件的输出。

下面是一个类组件的示例，它在构造函数中定义了props和state，每当使用this.setState() 修改状态时，将再次调用

随着时间的推移，应用程序会变得越来越大，因此类型检查非常重要。PropTypes为组件提供类型检查，并为其他开发人员提供很好的文档。如果react项目不使用 Typescript，建议为组件添加

如果组件没有收到任何 props，我们还可以为每个组件定义要显示的默认 props。这里有一个例子。UserDisplay有三个

如何更新状态以及如何不更新

你不应该直接修改状态。可以在构造函数中定义状态值。直接使用状态不会触发重新渲染。React 使用this.setState()时合并状态。

使用this.setState()的第二种形式总是更安全的，因为更新的props和状态是异步的。这里，我们根据这些 props 更新状态。

组件在进入和离开DOM时要经历一系列生命周期方法，下面是这些生命周期方法。

在渲染前调用,在客户端也在服务端，它只发生一次。

在第一次渲染后调用，只在客户端。之后组件已经生成了对应的DOM结构，可以通过this.getDOMNode()来进行访问。如果你想和其他JavaScript框架一起使用，可以在这个方法中调用setTimeout, setInterval或者发送AJAX请求等操作(防止异部操作阻塞UI)。

在组件接收到一个新的 prop (更新后)时被调用。这个方法在初始化render时不会被调用。

返回一个布尔值。在组件接收到新的props或者state时被调用。在初始化时或者使用forceUpdate时不被调用。可以在你确认不需要更新组件时使用。

在组件接收到新的props或者state但还没有render时被调用。在初始化时不会被调用。

在组件完成更新后立即调用。在初始化时不会被调用。

件从 DOM 中移除的时候立刻被调用。

这个生命周期方法在ErrorBoundary类中使用。实际上，如果使用这个生命周期方法，任何类都会变成ErrorBoundary。这用于在组件树中出现错误时呈现回退UI，而不是在屏幕上显示一些奇怪的错误。

这个生命周期方法在ErrorBoundary类中使用。实际上，如果使用这个生命周期方法，任何类都会变成ErrorBoundary。这用于在组件树中出现错误时记录错误。

在React中，我们总是使用组合而不是继承。我们已经在函数式编程部分讨论了什么是组合。这是一种结合简单的可重用函数来生成高阶组件的技术。下面是一个组合的例子，我们在 dashboard

如何在React中应用样式

将样式应用于React组件有三种方法。

在此方法中，你可以将外部样式表导入到组件使用类中。但是你应该使用className而不是class来为React元素应用样式, 这里有一个例子。

在这个方法中，我们可以直接将 props 传递给HTML元素，属性为style。这里有一个例子。这里需要注意的重要一点是，我们将javascript对象传递给style，这就是为什么我们使用

因为我们将javascript对象传递给style属性，所以我们可以在组件中定义一个style对象并使用它。下面是一个示例，你也可以将此对象作为 props

什么是Redux及其工作原理

Redux 是 React的一个状态管理库，它基于flux。 Redux简化了React中的单向数据流。 Redux将状态管理完全从React中抽象出来。

当Redux状态更改时，连接到Redux的组件将接收新的状态作为props。当组件接收到这些props时，它将进入更新阶段并重新渲染

让我们详细看看整个redux 循环细节。

Creators：这些是创建Actions的函数，因此我们在派发action时不必在组件中手动编写每个

作为参数,计算必要的逻辑并返回一个新r的state。这些 Reducers 没有任何副作用。它不会改变 state 而是总是返回 state

组件如何与 `redux` 进行连接

上，因此只要state发生变化，新 state 会重新映射到 props。这是订阅store的方式。

Route 用于路由匹配。
Link 组件用于在应用程序中创建链接。它将在HTML中渲染为锚标记。
NavLink是突出显示当前活动链接的特殊链接。
Switch 不是必需的，但在组合路由时很有用。

以下是 react router 组件的示例。如果你查看下面的示例，我们将匹配路径并使用Switch和Route呈现相应的组件。

在 React 中，我们通常有一个组件树。如果任何一个组件发生错误，它将破坏整个组件树。没有办法捕捉这些错误，我们可以用错误边界优雅地处理这些错误。

如果发生错误，显示回退UI

这两个生命周期方法的任何一下，，那么这个类就会成为ErrorBoundary。前者返回{hasError: true}来呈现回退UI，后者用于记录错误。

以下是我们如何在其中一个组件中使用ErrorBoundary。使用ErrorBoundary类包裹 ToDoForm和ToDoList。如果这些组件中发生任何错误，我们会记录错误并显示回退UI。

在React中，我们需要有一个父元素，同时从组件返回React元素。有时在DOM中添加额外的节点会很烦人。使用 Fragments，我们不需要在DOM中添加额外的节点。我们只需要用

默认情况下，所有子组件都在UI上呈现，具体取决于组件层次结构。Portal 提供了一种将子节点渲染到存在于父组件以外的 DOM 节点的优秀的方案。

这里有一个例子。默认情况下，父组件在DOM层次结构中有子组件。

有时我们必须将props 传递给组件树，即使所有中间组件都不需要这些props 。上下文是一种传递props 的方法，而不用在每一层传递组件树。

Hooks 是React版本16.8中的新功能。请记住，我们不能在函数组件中使用state ，因为它们不是类组件。Hooks 让我们在函数组件中可以使用state 和其他功能。

目前没有重大变化，我们不必放弃类组件。

Hook 不会影响你对 React 概念的理解。恰恰相反，Hook 为已知的 React 概念提供了更直接的 API：props， state，context，refs 以及生命周期。稍后我们将看到，Hook 还提供了一种更强大的方式来组合他们。

下面是 Hooks 的基本规则

Hooks 应该在外层使用，不应该在循环，条件或嵌套函数中使用
Hooks 应该只在函数组件中使用。

让我们看一个例子来理解 hooks。这是一个函数组件，它采用props并在UI上显示这些props。在useState钩子的帮助下，我们将这个函数组件转换为有状态组件。首先，我们在第5行定义状态，这相当于

this关键字的情况下直接使用的对象，setUser是一个可以用来设置用户点击第21行按钮的状态的函数，该函数等效于以下内容。

我们可以通过多种方式提高应用性能，以下这些比较重要：

适当地使用shouldComponentUpdate生命周期方法。它避免了子组件的不必要的渲染。如果树中有100个组件，则不重新渲染整个组件树来提高应用程序性能。
使用create-react-app来构建项目，这会创建整个项目结构，并进行大量优化。
不可变性是提高性能的关键。不要对数据进行修改，而是始终在现有集合的基础上创建新的集合，以保持尽可能少的复制，从而提高性能。
在显示列表或表格时始终使用 Keys，这会让 React 的更新速度更快
代码分离是将代码插入到单独的文件中，只加载模块或部分所需的文件的技术。

如何在重新加载页面时保留数据

单页应用程序首先在DOM中加载index.html，然后在用户浏览页面时加载内容，或者从同一index.html中的后端API获取任何数据。

如果通过点击浏览器中的重新加载按钮重新加载页面index.html，整个React应用程序将重新加载，我们将丢失应用程序的状态。如何保留应用状态？

每当重新加载应用程序时，我们使用浏览器localstorage来保存应用程序的状态。我们将整个存储数据保存在localstorage中，每当有页面刷新或重新加载时，我们从localstorage加载状态。

我们使用redux-thunk在React中调用API。因为reduce是纯函数，所以没有副作用，比如调用API。

中。Reducers 接收我们在上面的redux循环中讨论的数据，其余的过程也是相同的。

redux-thunk是一个中间件。一旦它被引入到项目中，每次派发一个action时，都会通过thunk传递。如果它是一个函数，它只是等待函数处理并返回响应。如果它不是一个函数，它只是正常处理。

这里有一个例子。sendEmailAPI是从组件中调用的函数，它接受一个数据并返回一个函数，其中dispatch作为参数。我们使用redux-thunk调用API apiservice，并等待收到响应。一旦接收到响应，我们就使用payload 派发一个action 。

要想有把握的面试，必须充分了解上述所有主题。即使你目前正在使用React，理解这些概念也能增强你在职场中信心。

转载本文请联系原作者获取授权，同时请注明本文来自昝涛科学网博客。