[非聚集索引 Non-Clustered ...]的搜索结果

...就数据表的规范化、表索引优化、容量设计、事务处理等诸多方面与程序员进行卓有成效的沟通和协作，那么日常的前台管理工作将会变得大为轻松,因为在某种意义上，数据库管理系统就相当于操作系统，在系统中占有同样重要的位置。 这正是SQL SERVER等数据库管理系统和dBASEX、ACCESS等数据库文件系统的本质区别，所以，对数据库管理系统操作能力的强弱在某种程度上也折射出了网管的水平——个人认为，称得上优秀的Admin,至少应该是一个称职的DBA（数据库管理员）。 下面以SQL SERVER（下称 SQLS）为例，将数据库管理中难于理解的“索引原理”问题给各位朋友作一个深入浅出的介绍。其他的数据库管理系统如Oracle、Sybase等，朋友们可以融会贯通，举一反三。 一、数据表的基本结构 建立数据库的目的是管理大量数据，而建立索引的目的就是提高数据检索效率，改善数据库工作性能，提高数据访问速度。对于索引，我们要知其然，更要知其所以然，关键在于认识索引的工作原理，才能更好的管理索引。 为认识索引工作原理，首先有必要对数据表的基本结构作一次全面的复习。 SQLS当一个新表被创建之时，系统将在磁盘中分配一段以8K为单位的连续空间，当字段的值从内存写入磁盘时，就在这一既定空间随机保存，当一个8K用完的时候，SQLS指针会自动分配一个8K的空间。这里，每个8K空间被称为一个数据页（Page），又名页面或数据页面，并分配从0-7的页号,每个文件的第0页记录引导信息，叫文件头（File header）；每8个数据页（64Ｋ）的组合形成扩展区（Extent），称为扩展。全部数据页的组合形成堆（Heap）。 SQLS规定行不能跨越数据页，所以，每行记录的最大数据量只能为8K。这就是char和varchar这两种字符串类型容量要限制在8K以内的原因，存储超过8K的数据应使用text类型，实际上，text类型的字段值不能直接录入和保存，它只是存储一个指针，指向由若干8K的文本数据页所组成的扩展区，真正的数据正是放在这些数据页中。 页面有空间页面和数据页面之分。 当一个扩展区的8个数据页中既包含了空间页面又包括了数据或索引页面时，称为混合扩展（Mixed Extent）,每张表都以混合扩展开始；反之，称为一致扩展（Uniform Extent），专门保存数据及索引信息。 表被创建之时，SQLS在混合扩展中为其分配至少一个数据页面，随着数据量的增长，SQLS可即时在混合扩展中分配出7个页面，当数据超过8个页面时，则从一致扩展中分配数据页面。 空间页面专门负责数据空间的分配和管理，包括：PFS页面（Page free space）：记录一个页面是否已分配、位于混合扩展还是一致扩展以及页面上还有多少可用空间等信息；GAM页面（Global allocation map）和SGAM页面(Secodary global allocation map)：用来记录空闲的扩展或含有空闲页面的混合扩展的位置。SQLS综合利用这三种类型的页面文件在必要时为数据表创建新空间； 数据页或索引页则专门保存数据及索引信息，SQLS使用4种类型的数据页面来管理表或索引：它们是IAM页、数据页、文本/图像页和索引页。 在WINDOWS中，我们对文件执行的每一步操作，在磁盘上的物理位置只有系统（system）才知道；SQL SERVER沿袭了这种工作方式，在插入数据的过程中，不但每个字段值在数据页面中的保存位置是随机的，而且每个数据页面在“堆”中的排列位置也只有系统（system）才知道。 这是为什么呢？众所周知，OS之所以能管理DISK，是因为在系统启动时首先加载了文件分配表：FAT（File Allocation Table），正是由它管理文件系统并记录对文件的一切操作，系统才得以正常运行；同理，作为管理系统级的SQL SERVER,也有这样一张类似FAT的表存在，它就是索引分布映像页：IAM（Index Allocation Map）。 IAM的存在，使SQLS对数据表的物理管理有了可能。 IAM页从混合扩展中分配，记录了8个初始页面的位置和该扩展区的位置，每个IAM页面能管理512,000个数据页面，如果数据量太大，SQLS也可以增加更多的IAM页，可以位于文件的任何位置。第一个IAM页被称为FirstIAM,其中记录了以后的IAM页的位置。 数据页和文本/图像页互反，前者保存非文本/图像类型的数据，因为它们都不超过8K的容量，后者则只保存超过8K容量的文本或图像类型数据。而索引页顾名思义，保存的是与索引结构相关的数据信息。了解页面的问题有助我们下一步准确理解SQLS维护索引的方式，如页拆分、填充因子等。 二、索引的基本概念 索引是一种特殊类型的数据库对象，它与表有着密切的联系。 索引是为检索而存在的。如一些书籍的末尾就专门附有索引，指明了某个关键字在正文中的出现的页码位置，方便我们查找，但大多数的书籍只有目录，目录不是索引，只是书中内容的排序，并不提供真正的检索功能。可见建立索引要单独占用空间；索引也并不是必须要建立的，它们只是为更好、更快的检索和定位关键字而存在。 再进一步说，我们要在图书馆中查阅图书，该怎么办呢？图书馆的前台有很多叫做索引卡片柜的小柜子，里面分了若干的类别供我们检索图书，比如你可以用书名的笔画顺序或者拼音顺序作为查找的依据，你还可以从作者名的笔画顺序或拼音顺序去查询想要的图书，反正有许多检索方式，但有一点很明白，书库中的书并没有按照这些卡片柜中的顺序排列——虽然理论上可以这样做，事实上，所有图书的脊背上都人工的粘贴了一个特定的编号①，它们是以这个顺序在排列。索引卡片中并没有指明这本书摆放在书库中的第几个书架的第几本，仅仅指明了这个特定的编号。管理员则根据这一编号将请求的图书返回到读者手中。这是很形象的例子，以下的讲解将会反复用到它。 SQLS在安装完成之后，安装程序会自动创建master、model、tempdb等几个特殊的系统数据库，其中master是SQLS的主数据库，用于保存和管理其它系统数据库、用户数据库以及SQLS的系统信息，它在SQLS中的地位与WINDOWS下的注册表相当。 master中有一个名为sysindexes的系统表，专门管理索引。SQLS查询数据表的操作都必须用到它，毫无疑义，它是本文主角之一。 查看一张表的索引属性，可以在查询分析器中使用以下命令：select from sysindexes where id=object_id(‘tablename’) ；而要查看表的索引所占空间的大小，可以使用系统存储过程命令：sp_spaceused tablename，其中参数tablename为被索引的表名。 三、平衡树 如果你通过书后的索引知道了一个关键字所在的页码，你有可能通过随机的翻寻，最终到达正确的页码。但更科学更快捷的方法是：首先把书翻到大概二分之一的位置，如果要找的页码比该页的页码小，就把书向前翻到四分之一处，否则，就把书向后翻到四分之三的地方，依此类推，把书页续分成更小的部分，直至正确的页码。这叫“两分法”，微软在官方教程MOC里另有一种说法：叫B树（B-Tree，Balance Tree），即平衡树。 一个表索引由若干页面组成，这些页面构成了一个树形结构。B树由“根”（root）开始，称为根级节点，它通过指向另外两个页，把一个表的记录从逻辑上分成两个部分：“枝”—--非叶级节点（Non-Leaf Level）；而非叶级节点又分别指向更小的部分：“叶”——叶级节点（Leaf Level）。根节点、非叶级节点和叶级节点都位于索引页中，统称为索引节点，属于索引页的范筹。这些“枝”、“叶”最终指向了具体的数据页（Page）。在根级节点和叶级节点之间的叶又叫数据中间页。 “根”（root）对应了sysindexes表的Root字段，其中记载了非叶级节点的物理位置（即指针）；非叶级节点位于根节点和叶节点之间，记载了指向叶级节点的指针；而叶级节点则最终指向数据页。这就是“平衡树”。 四、聚集索引和非聚集索引 从形式上而言，索引分为聚集索引（Clustered Indexes）和非聚集索引（NonClustered Indexes）。 聚集索引相当于书籍脊背上那个特定的编号。如果对一张表建立了聚集索引，其索引页中就包含着建立索引的列的值（下称索引键值），那么表中的记录将按照该索引键值进行排序。比如，我们如果在“姓名”这一字段上建立了聚集索引，则表中的记录将按照姓名进行排列；如果建立了聚集索引的列是数值类型的，那么记录将按照该键值的数值大小来进行排列。 非聚集索引用于指定数据的逻辑顺序，也就是说，表中的数据并没有按照索引键值指定的顺序排列，而仍然按照插入记录时的顺序存放。其索引页中包含着索引键值和它所指向该行记录在数据页中的物理位置，叫做行定位符（RID：Row ID）。好似书后面的的索引表，索引表中的顺序与实际的页码顺序也是不一致的。而且一本书也许有多个索引。比如主题索引和作者索引。 SQL Server在默认的情况下建立的索引是非聚集索引，由于非聚集索引不对表中的数据进行重组，而只是存储索引键值并用一个指针指向数据所在的页面。一个表如果没有聚集索引时,理论上可以建立249个非聚集索引。每个非聚集索引提供访问数据的不同排序顺序。 五、数据是怎样被访问的 若能真正理解了以上索引的基础知识，那么再回头来看索引的工作原理就简单和轻松多了。 （一）SQLS怎样访问没有建立任何索引数据表： Heap译成汉语叫做“堆”，其本义暗含杂乱无章、无序的意思，前面提到数据值被写进数据页时，由于每一行记录之间并没地有特定的排列顺序，所以行与行的顺序就是随机无序的，当然表中的数据页也就是无序的了，而表中所有数据页就形成了“堆”，可以说，一张没有索引的数据表，就像一个只有书柜而没有索引卡片柜的图书馆，书库里面塞满了一堆乱七八糟的图书。当读者对管理员提交查询请求后，管理员就一头钻进书库，对照查找内容从头开始一架一柜的逐本查找，运气好的话，在第一个书架的第一本书就找到了，运气不好的话，要到最后一个书架的最后一本书才找到。 SQLS在接到查询请求的时候，首先会分析sysindexes表中一个叫做索引标志符(INDID: Index ID)的字段的值，如果该值为0，表示这是一张数据表而不是索引表，SQLS就会使用sysindexes表的另一个字段——也就是在前面提到过的FirstIAM值中找到该表的IAM页链——也就是所有数据页集合。 这就是对一个没有建立索引的数据表进行数据查找的方式，是不是很没效率？对于没有索引的表，对于一“堆”这样的记录，SQLS也只能这样做，而且更没劲的是，即使在第一行就找到了被查询的记录，SQLS仍然要从头到尾的将表扫描一次。这种查询称为“遍历”，又叫“表扫描”。 可见没有建立索引的数据表照样可以运行，不过这种方法对于小规模的表来说没有什么太大的问题，但要查询海量的数据效率就太低了。 （二）SQLS怎样访问建立了非聚集索引的数据表： 如前所述，非聚集索引可以建多个,具有B树结构，其叶级节点不包含数据页，只包含索引行。假定一个表中只有非聚集索引，则每个索引行包含了非聚集索引键值以及行定位符（ROW ID,RID），他们指向具有该键值的数据行。每一个RID由文件ID、页编号和在页中行的编号组成。 当INDID的值在2-250之间时，意味着表中存在非聚集索引页。此时，SQLS调用ROOT字段的值指向非聚集索引B树的ROOT，在其中查找与被查询最相近的值，根据这个值找到在非叶级节点中的页号，然后顺藤摸瓜，在叶级节点相应的页面中找到该值的RID，最后根据这个RID在Heap中定位所在的页和行并返回到查询端。 例如：假定在Lastname上建立了非聚集索引，则执行Select From Member Where Lastname=’Ota’时，查询过程是：①SQLS查询INDID值为2；②立即从根出发，在非叶级节点中定位最接近Ota的值“Martin”，并查到其位于叶级页面的第61页；③仅在叶级页面的第61页的Martin下搜寻Ota的RID，其RID显示为N∶706∶4，表示Lastname字段中名为Ota的记录位于堆的第707页的第4行，N表示文件的ID值，与数据无关；④根据上述信息，SQLS立马在堆的第 707页第4行将该记录“揪”出来并显示于前台（客户端）。视表的数据量大小，整个查询过程费时从百分之几毫秒到数毫秒不等。 在谈到索引基本概念的时候，我们就提到了这种方式： 图书馆的前台有很多索引卡片柜，里面分了若干的类别，诸如按照书名笔画或拼音顺序、作者笔画或拼音顺序等等，但不同之处有二：① 索引卡片上记录了每本书摆放的具体位置——位于某柜某架的第几本——而不是“特殊编号”；② 书脊上并没有那个“特殊编号”。管理员在索引柜中查到所需图书的具体位置（RID）后，根据RID直接在书库中的具体位置将书提出来。 显然，这种查询方式效率很高，但资源占用极大，因为书库中书的位置随时在发生变化，必然要求管理员花费额外的精力和时间随时做好索引更新。 （三）SQLS怎样访问建立了聚集索引的数据表： 在聚集索引中，数据所在的数据页是叶级，索引数据所在的索引页是非叶级。 查询原理和上述对非聚集索引的查询相似，但由于记录是按照聚集索引中索引键值进行排序，换句话说，聚集索引的索引键值也就是具体的数据页。 这就好比书库中的书就是按照书名的拼音在排序，而且也只按照这一种排序方式建立相应的索引卡片，于是查询起来要比上述只建立非聚集索引的方式要简单得多。仍以上面的查询为例： 假定在Lastname字段上建立了聚集索引，则执行Select From Member Where Lastname=’Ota’时，查询过程是：①SQLS查询INDID值为1，这是在系统中只建立了聚集索引的标志；②立即从根出发，在非叶级节点中定位最接近Ota的值“Martin”，并查到其位于叶级页面的第120页；③在位于叶级页面第120页的Martin下搜寻到Ota条目，而这一条目已是数据记录本身；④将该记录返回客户端。 这一次的效率比第二种方法更高，以致于看起来更美，然而它最大的优点也恰好是它最大的缺点——由于同一张表中同时只能按照一种顺序排列，所以在任何一种数据表中的聚集索引只能建立一个；并且建立聚集索引需要至少相当于源表120%的附加空间，以存放源表的副本和索引中间页！ 难道鱼和熊掌就不能兼顾了吗？办法是有的。 （四）SQLS怎样访问既有聚集索引、又有非聚集索引的数据表： 如果我们在建立非聚集索引之前先建立了聚集索引的话，那么非聚集索引就可以使用聚集索引的关键字进行检索，就像在图书馆中，前台卡片柜中的可以有不同类别的图书索引卡，然而每张卡片上都载明了那个特殊编号——并不是书籍存放的具体位置。这样在最大程度上既照顾了数据检索的快捷性，又使索引的日常维护变得更加可行，这是最为科学的检索方法。 也就是说，在只建立了非聚集索引的情况下，每个叶级节点指明了记录的行定位符（RID）；而在既有聚集索引又有非聚集索引的情况下，每个叶级节点所指向的是该聚集索引的索引键值，即数据记录本身。 假设聚集索引建立在Lastname上，而非聚集索引建立在Firstname上，当执行Select From Member Where Firstname=’Mike’时，查询过程是：①SQLS查询INDID值为2；②立即从根出发，在Firstname的非聚集索引的非叶级节点中定位最接近Mike的值“Jose”条目；③从Jose条目下的叶级页面中查到Mike逻辑位置——不是RID而是聚集索引的指针；④根据这一指针所指示位置，直接进入位于Lastname的聚集索引中的叶级页面中到达Mike数据记录本身；⑤将该记录返回客户端。 这就完全和我们在“索引的基本概念”中讲到的现实场景完全一样了，当数据发生更新的时候，SQLS只负责对聚集索引的健值驾以维护，而不必考虑非聚集索引，只要我们在ID类的字段上建立聚集索引，而在其它经常需要查询的字段上建立非聚集索引，通过这种科学的、有针对性的在一张表上分别建立聚集索引和非聚集索引的方法，我们既享受了索引带来的灵活与快捷，又相对规避了维护索引所导致的大量的额外资源消耗。 六、索引的优点和不足 索引有一些先天不足：1：建立索引，系统要占用大约为表的1.2倍的硬盘和内存空间来保存索引。2：更新数据的时候，系统必须要有额外的时间来同时对索引进行更新，以维持数据和索引的一致性——这就如同图书馆要有专门的位置来摆放索引柜，并且每当库存图书发生变化时都需要有人将索引卡片重整以保持索引与库存的一致。 当然建立索引的优点也是显而易见的：在海量数据的情况下，如果合理的建立了索引，则会大大加强SQLS执行查询、对结果进行排序、分组的操作效率。 实践表明，不恰当的索引不但于事无补，反而会降低系统性能。因为大量的索引在进行插入、修改和删除操作时比没有索引花费更多的系统时间。比如在如下字段建立索引应该是不恰当的：1、很少或从不引用的字段；2、逻辑型的字段，如男或女(是或否)等。 综上所述，提高查询效率是以消耗一定的系统资源为代价的，索引不能盲目的建立，必须要有统筹的规划，一定要在“加快查询速度”与“降低修改速度”之间做好平衡，有得必有失，此消则彼长。这是考验一个DBA是否优秀的很重要的指标。 至此，我们一直在说SQLS在维护索引时要消耗系统资源，那么SQLS维护索引时究竟消耗了什么资源？会产生哪些问题？究竟应该才能优化字段的索引？ 在上篇中，我们就索引的基本概念和数据查询原理作了详细阐述，知道了建立索引时一定要在“加快查询速度”与“降低修改速度”之间做好平衡，有得必有失，此消则彼长。那么，SQLS维护索引时究竟怎样消耗资源？应该从哪些方面对索引进行管理与优化？以下就从七个方面来回答这些问题。 一、页分裂 微软MOC教导我们：当一个数据页达到了8K容量，如果此时发生插入或更新数据的操作，将导致页的分裂(又名页拆分)： 1、有聚集索引的情况下：聚集索引将被插入和更新的行指向特定的页，该页由聚集索引关键字决定； 2、只有堆的情况下：只要有空间就可以插入新的行，但是如果我们对行数据的更新需要更多的空间，以致大于了当前页的可用空间，行就被移到新的页中，并且在原位置留下一个转发指针，指向被移动的新行，如果具有转发指针的行又被移动了，那么原来的指针将重新指向新的位置； 3、如果堆中有非聚集索引，那么尽管插入和更新操作在堆中不会发生页分裂，但是在非聚集索引上仍然产生页分裂。 无论有无索引，大约一半的数据将保留在老页面，而另一半将放入新页面，并且新页面可能被分配到任何可用的页。所以，频繁页分裂，后果很严重，将使物理表产生大量数据碎片，导致直接造成I/O效率的急剧下降，最后，停止SQLS的运行并重建索引将是我们的唯一选择! 二、填充因子 然而在“混沌之初”，就可以在一定程度上避免不愉快出现：在创建索引时，可以为这个索引指定一个填充因子，以便在索引的每个叶级页面上保留一定百分比的空间，将来数据可以进行扩充和减少页分裂。填充因子是从0到100的百分比数值，设为100时表示将数据页填满。只有当不会对数据进行更改时(例如只读表中)才用此设置。值越小则数据页上的空闲空间越大，这样可以减少在索引增长过程中进行页分裂的需要，但这一操作需要占用更多的硬盘空间。 填充因子只在创建索引时执行，索引创建以后，当表中进行数据的添加、删除或更新时，是不会保持填充因子的，如果想在数据页上保持额外的空间，则有悖于使用填充因子的本意，因为随着数据的输入，SQLS必须在每个页上进行页拆分，以保持填充因子指定的空闲空间。因此，只有在表中的数据进行了较大的变动，才可以填充数据页的空闲空间。这时，可以从容的重建索引，重新指定填充因子，重新分布数据。 反之，填充因子指定不当，就会降低数据库的读取性能，其降低量与填充因子设置值成反比。例如，当填充因子的值为50时，数据库的读取性能会降低两倍！所以，只有在表中根据现有数据创建新索引，并且可以预见将来会对这些数据进行哪些更改时，设置填充因子才有意义。 三、两道数学题 假定数据库设计没有问题，那么是否象上篇中分析的那样，当你建立了众多的索引，在查询工作中SQLS就只能按照“最高指示”用索引处理每一个提交的查询呢？答案是否定的！ 上篇“数据是怎样被访问的”章节中提到的四种索引方案只是一种静态的、标准的和理论上的分析比较，实际上，将在外，军令有所不从，SQLS几乎完全是“自主”的决定是否使用索引或使用哪一个索引！ 这是怎么回事呢？ 让我们先来算一道题：如果某表的一条记录在磁盘上占用1000字节(1K)的话，我们对其中10字节的一个字段建立索引，那么该记录对应的索引大小只有10字节(0.01K)。上篇说过，SQLS的最小空间分配单元是“页（Page）”，一个页面在磁盘上占用8K空间，所以一页只能存储8条“记录”，但可以存储800条“索引”。现在我们要从一个有8000条记录的表中检索符合某个条件的记录(有Where子句)，如果没有索引的话，我们需要遍历8000条×1000字节/8K字节=1000个页面才能够找到结果。如果在检索字段上有上述索引的话，那么我们可以在8000条×10字节/8K字节=10个页面中就检索到满足条件的索引块，然后根据索引块上的指针逐一找到结果数据块，这样I/O访问量肯定要少得多。 然而有时用索引还不如不用索引快！ 同上，如果要无条件检索全部记录(不用Where子句)，不用索引的话，需要访问8000条×1000字节/8K字节=1000个页面；而使用索引的话，首先检索索引，访问8000条×10字节/8K字节=10个页面得到索引检索结果，再根据索引检索结果去对应数据页面，由于是检索全部数据，所以需要再访问8000条×1000字节/8K字节=1000个页面将全部数据读取出来，一共访问了1010个页面，这显然不如不用索引快。 SQLS内部有一套完整的数据索引优化技术，在上述情况下，SQLS会自动使用表扫描的方式检索数据而不会使用任何索引。那么SQLS是怎么知道什么时候用索引，什么时候不用索引的呢？因为SQLS除了维护数据信息外，还维护着数据统计信息！ 四、统计信息 打开企业管理器，单击“Database”节点，右击Northwind数据库→单击“属性”→选择“Options”选项卡，观察“Settings”下的各项复选项，你发现了什么？ 从Settings中我们可以看到，在数据库中，SQLS将默认的自动创建和更新统计信息，这些统计信息包括数据密度和分布信息，正是它们帮助SQLS确定最佳的查询策略：建立查询计划和是否使用索引以及使用什么样的索引。 在创建索引时，SQLS会创建分布数据页来存放有关索引的两种统计信息：分布表和密度表。查询优化器使用这些统计信息估算使用该索引进行查询的成本(Cost)，并在此基础上判断该索引对某个特定查询是否有用。 随着表中的数据发生变化，SQLS自动定期更新这些统计信息。采样是在各个数据页上随机进行。从磁盘读取一个数据页后，该数据页上的所有行都被用来更新统计信息。统计信息更新的频率取决于字段或索引中的数据量以及数据更改量。比如，对于有一万条记录的表，当1000个索引键值发生改变时，该表的统计信息便可能需要更新，因为1000 个值在该表中占了10%，这是一个很大的比例。而对于有1千万条记录的表来说，1000个索引值发生更改的意义则可以忽略不计，因此统计信息就不会自动更新。 至于它们帮助SQLS建立查询计划的具体过程，限于篇幅，这里就省略了，请有兴趣的朋友们自己研究。 顺便多说一句，SQLS除了能自动记录统计信息之外，还可以记录服务器中所发生的其它活动的详细信息，包括I/O 统计信息、CPU 统计信息、锁定请求、T-SQL 和 RPC 统计信息、索引和表扫描、警告和引发的错误、数据库对象的创建/除去、连接/断开、存储过程操作、游标操作等等。这些信息的读取、设置请朋友们在SQLS联机帮助文档(SQL Server Books Online)中搜索字符串“Profiler”查找。 五、索引的人工维护 上面讲到,某些不合适的索引将影响到SQLS的性能,随着应用系统的运行,数据不断地发生变化,当数据变化达到某一个程度时将会影响到索引的使用。这时需要用户自己来维护索引。 随着数据行的插入、删除和数据页的分裂，有些索引页可能只包含几页数据，另外应用在执行大量I/O的时候，重建非聚聚集索引可以维护I/O的效率。重建索引实质上是重新组织B树。需要重建索引的情况有： 1) 数据和使用模式大幅度变化； 2)排序的顺序发生改变； 3)要进行大量插入操作或已经完成； 4)使用I/O查询的磁盘读次数比预料的要多； 5)由于大量数据修改，使得数据页和索引页没有充分使用而导致空间的使用超出估算； 6)dbcc检查出索引有问题。 六、索引的使用原则 接近尾声的时候，让我们再从另一个角度认识索引的两个重要属性----唯一性索引和复合性索引。 在设计表的时候，可以对字段值进行某些限制，比如可以对字段进行主键约束或唯一性约束。 主键约束是指定某个或多个字段不允许重复，用于防止表中出现两条完全相同的记录，这样的字段称为主键，每张表都可以建立并且只能建立一个主键，构成主键的字段不允许空值。例如职员表中“身份证号”字段或成绩表中“学号、课程编号”字段组合。 而唯一性约束与主键约束类似，区别只在于构成唯一性约束的字段允许出现空值。 建立在主键约束和唯一性约束上的索引，由于其字段值具有唯一性，于是我们将这种索引叫做“唯一性索引”，如果这个唯一性索引是由两个以上字段的组合建立的，那么它又叫“复合性索引”。 注意，唯一索引不是聚集索引，如果对一个字段建立了唯一索引，你仅仅不能向这个字段输入重复的值。并不妨碍你可以对其它类型的字段也建立一个唯一性索引，它们可以是聚集的，也可以是非聚集的。 唯一性索引保证在索引列中的全部数据是唯一的，不会包含冗余数据。如果表中已经有一个主键约束或者唯一性约束，那么当创建表或者修改表时，SQLS自动创建一个唯一性索引。但出于必须保证唯一性，那么应该创建主键约束或者唯一性键约束，而不是创建一个唯一性索引。当创建唯一性索引时，应该认真考虑这些规则：当在表中创建主键约束或者唯一性键约束时， SQLS钭自动创建一个唯一性索引；如果表中已经包含有数据，那么当创建索引时，SQLS检查表中已有数据的冗余性，如果发现冗余值，那么SQLS就取消该语句的执行，并且返回一个错误消息，确保表中的每一行数据都有一个唯一值。 复合索引就是一个索引创建在两个列或者多个列上。在搜索时，当两个或者多个列作为一个关键值时，最好在这些列上创建复合索引。当创建复合索引时，应该考虑这些规则：最多可以把16个列合并成一个单独的复合索引，构成复合索引的列的总长度不能超过900字节，也就是说复合列的长度不能太长；在复合索引中，所有的列必须来自同一个表中，不能跨表建立复合列；在复合索引中，列的排列顺序是非常重要的，原则上，应该首先定义最唯一的列，例如在（COL1，COL2）上的索引与在（COL2，COL1）上的索引是不相同的，因为两个索引的列的顺序不同；为了使查询优化器使用复合索引，查询语句中的WHERE子句必须参考复合索引中第一个列；当表中有多个关键列时，复合索引是非常有用的；使用复合索引可以提高查询性能，减少在一个表中所创建的索引数量。 综上所述，我们总结了如下索引使用原则： 1)逻辑主键使用唯一的成组索引，对系统键（作为存储过程）采用唯一的非成组索引，对任何外键列采用非成组索引。考虑数据库的空间有多大，表如何进行访问，还有这些访问是否主要用作读写。 2)不要索引memo/note 字段，不要索引大型字段（有很多字符），这样作会让索引占用太多的存储空间。 3)不要索引常用的小型表 4)一般不要为小型数据表设置过多的索引，假如它们经常有插入和删除操作就更别这样作了，SQLS对这些插入和删除操作提供的索引维护可能比扫描表空间消耗更多的时间。 七、大结局 查询是一个物理过程，表面上是SQLS在东跑西跑，其实真正大部分压马路的工作是由磁盘输入输出系统(I/O)完成，全表扫描需要从磁盘上读表的每一个数据页，如果有索引指向数据值，则I/O读几次磁盘就可以了。但是，在随时发生的增、删、改操作中，索引的存在会大大增加工作量，因此，合理的索引设计是建立在对各种查询的分析和预测上的，只有正确地使索引与程序结合起来,才能产生最佳的优化方案。 一般来说建立索引的思路是： (1)主键时常作为where子句的条件，应在表的主键列上建立聚聚集索引，尤其当经常用它作为连接的时候。 (2)有大量重复值且经常有范围查询和排序、分组发生的列，或者非常频繁地被访问的列，可考虑建立聚聚集索引。　　 (3)经常同时存取多列，且每列都含有重复值可考虑建立复合索引来覆盖一个或一组查询，并把查询引用最频繁的列作为前导列，如果可能尽量使关键查询形成覆盖查询。 (4)如果知道索引键的所有值都是唯一的，那么确保把索引定义成唯一索引。 (5)在一个经常做插入操作的表上建索引时，使用fillfactor(填充因子)来减少页分裂，同时提高并发度降低死锁的发生。如果在只读表上建索引，则可以把fillfactor置为100。 (6)在选择索引字段时，尽量选择那些小数据类型的字段作为索引键，以使每个索引页能够容纳尽可能多的索引键和指针，通过这种方式，可使一个查询必须遍历的索引页面降到最小。此外，尽可能地使用整数为键值，因为它能够提供比任何数据类型都快的访问速度。 SQLS是一个很复杂的系统，让索引以及查询背后的东西真相大白，可以帮助我们更为深刻的了解我们的系统。一句话，索引就象盐，少则无味多则咸。 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_28052907/article/details/75194926。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...都很顺利，数据导入、索引创建啥的都没问题。但当我尝试对某些节点进行操作时，突然蹦出了这么一行错误： org.elasticsearch.cluster.block.ClusterBlockException: blocked by: [SERVICE_UNAVAILABLE/2/no active shards]; 当时我心里那个急啊！赶紧去查文档，发现这是NodeNotActiveException的表现之一。简单说吧，就好比某个关键的小哥突然“罢工”了，可能是因为它内存不够用，或者网络断了啥的，结果整个团队的工作都乱套了，没法正常运转了。 我当时就纳闷了：“这不是应该自动恢复吗？为啥还要报错呢？”后来才明白，虽然ElasticSearch确实有自我修复机制，但有时候我们需要手动干预才能让它恢复正常。 --- 2. 理解背后的逻辑 为什么会出现这种问题？ 在深入了解之前，我觉得有必要先搞清楚这个异常的根本原因。其实NodeNotActiveException并不是什么特别复杂的概念，它主要出现在以下几种情况： - 节点宕机：某个节点由于硬件故障或者网络问题离线了。 - 磁盘空间不足：如果某个节点的磁盘满了，ElasticSearch会自动将其标记为不可用。 - 配置错误：比如分配给节点的资源不够，导致其无法启动。 对于我来说，问题出在第二个点上——磁盘空间不足。我当时为了省钱，给服务器分配的空间少得可怜，结果没多久就发现磁盘直接爆满，把自己都吓了一跳！于是ElasticSearch很生气，直接把该节点踢出了集群。 --- 3. 解决方案一 扩容磁盘空间 既然问题找到了，那就动手解决吧！首先，我决定先扩展磁盘容量。这一步其实很简单，只要登录服务器，增加磁盘大小就行。具体步骤如下： bash 查看当前磁盘状态 df -h 扩展磁盘（假设你已经购买了额外的存储） sudo growpart /dev/xvda 1 sudo resize2fs /dev/xvda1 完成后记得重启ElasticSearch服务： bash sudo systemctl restart elasticsearch 重启之后，神奇的事情发生了——我的节点重新上线了！不过这里有个小技巧分享给大家：如果你不确定扩容是否成功，可以通过以下命令检查磁盘使用情况： bash df -h 看到磁盘空间变大了，心里顿时舒坦了不少。 --- 4. 解决方案二 调整ElasticSearch配置 当然啦，仅仅扩容还不够，还需要优化ElasticSearch的配置文件。特别是那些容易导致内存不足或磁盘占用过高的参数，比如indices.memory.index_buffer_size和indices.store.throttle.max_bytes_per_sec。修改后的配置文件大概长这样： yaml cluster.routing.allocation.disk.threshold_enabled: true cluster.routing.allocation.disk.watermark.low: 85% cluster.routing.allocation.disk.watermark.high: 90% cluster.routing.allocation.disk.watermark.flood_stage: 95% cluster.info.update.interval: 30s 这些设置的意思是告诉ElasticSearch，当磁盘使用率达到85%时开始警告，达到90%时限制写入，超过95%时完全停止操作。这样可以有效避免再次出现类似的问题。 --- 5. 实战演练 代码中的应对策略 除了调整配置，我们还可以通过编写脚本来监控和处理NodeNotActiveException。比如，下面这段Java代码展示了如何捕获异常并记录日志： java import org.elasticsearch.client.RestHighLevelClient; import org.elasticsearch.client.RestClient; import org.elasticsearch.client.indices.CreateIndexRequest; import org.elasticsearch.client.indices.CreateIndexResponse; public class ElasticSearchExample { public static void main(String[] args) { RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(new HttpHost("localhost", 9200, "http"))); try { CreateIndexRequest request = new CreateIndexRequest("test_index"); CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT); System.out.println("Index created: " + response.isAcknowledged()); } catch (Exception e) { if (e instanceof ClusterBlockException) { System.err.println("Cluster block detected: " + e.getMessage()); } else { System.err.println("Unexpected error: " + e.getMessage()); } } finally { try { client.close(); } catch (IOException ex) { System.err.println("Failed to close client: " + ex.getMessage()); } } } } 这段代码的作用是在创建索引时捕获可能发生的异常，并根据异常类型采取不同的处理方式。如果遇到ClusterBlockException，我们可以选择延迟重试或者其他补偿措施。 --- 6. 总结与反思 成长路上的一课 通过这次经历，我深刻体会到，作为一名开发者，不仅要掌握技术细节，还要学会从实际问题出发，找到最优解。NodeNotActiveException这个错误看着不起眼，但其实背后有不少门道呢！比如说，你的服务器硬件是不是有点吃不消了？集群那边有没有啥小毛病没及时发现？还有啊，咱们平时运维的时候是不是也有点松懈了？这些都是得好好琢磨的地方！ 最后，我想说的是，技术学习的过程就像爬山一样，有时候会遇到陡峭的山坡，但只要坚持下去，总能看到美丽的风景。希望这篇文章能给大家带来一些启发和帮助！如果还有其他疑问，欢迎随时交流哦~

...scover页面创建索引模式时选择任意一个远程集群的索引了。例如： json POST .kibana/_index_template/my_cross_cluster_search_template { "index_patterns": ["cluster_1:index_name", "cluster_2:another_index"], "template": { "settings": {}, "mappings": {} }, "composed_of": [] } 这样，在Discover面板搜索时，就可以同时查询到"cluster_1:index_name"和"cluster_2:another_index"两个不同集群的数据了。 5. 深入思考与探讨 跨集群搜索的功能对于那些拥有大量分布式数据源的企业来说，无疑是一个福音。然而，这并不意味着我们可以无限制地增加集群数量。当我们的集群规模逐渐扩大时，性能消耗和复杂程度也会像体重秤上的数字一样蹭蹭上涨。所以在实际操作中，咱们就得像个精打细算的家庭主妇，根据自家业务的具体需求和资源现状，好好掂量一下，做出最划算、最明智的选择。 此外，虽然Kibana跨集群搜索带来了极大的便利性，但在处理跨集群数据权限、数据同步延迟等问题上仍需谨慎对待。在尽情享受技术带来的种种便利和高效服务时，咱们也别忘了时刻关注并确保数据的安全性以及实时更新的重要性。 总结起来，配置Kibana跨集群搜索不仅是一项技术实践，更是对我们如何在复杂数据环境中优化工作流程，提升数据价值的一次有益探索。每一次尝试和挑战都是我们在数据分析道路上不断进步的动力源泉。

...们常常会遇到需要通过索引来优化查询性能的需求。那么，如何创建一个可以显示值出来的索引呢？接下来，我将详细阐述这一过程，并给出一些实例代码。 创建索引 在PostgreSQL中，我们可以使用CREATE INDEX语句来创建索引。首先，咱们得先搞清楚到底要给哪个表格建索引，还有具体打算对哪些字段进行索引设置。例如，如果我们有一个名为"articles"的表，其中包含"a", "b", "c"三个字段，我们可以使用以下代码来创建一个基于"a"字段的索引： sql CREATE INDEX idx_articles_a ON articles(a); 上述代码将会在"articles"表的"a"字段上创建一个名为"idx_articles_a"的索引。嘿，你知道吗？索引名这个家伙其实可以任你自由定制！不过在大多数情况下，我们会倾向于选择一个跟字段名“沾亲带故”的命名方式，这样一来，不仅能让我们更轻松地理解索引是干嘛的，还能方便我们日后的管理和维护工作，是不是听起来更人性化、更好理解啦？ 除了基本的CREATE INDEX语句外，PostgreSQL还支持一些高级的索引创建选项。例如，我们可以使用CLUSTER BY子句来指定哪些字段应该被用作聚簇键。你知道吗，聚簇键其实是个挺神奇的小东西，它就像是数据库里的超级分类员。这个特殊的索引能帮我们飞快地找到那些拥有相同数值的一堆记录，就像一个魔法师挥挥魔杖，唰的一下就把同类项全部给召唤出来一样！以下是创建一个基于"a"字段的聚簇索引的示例代码： sql CLUSTER articles USING idx_articles_a; 上述代码将会把"articles"表中的所有行按照"a"字段的值重新排列，并且在这个新的顺序下创建一个新的索引（名为"idx_articles_a"）。这样一来，当我们想找带有特定"a"字段值的那些行时，就完全可以跳过翻完整个表的繁琐过程，直接在我们新建的这个索引里轻松找到啦！ 显示索引 一旦我们创建了一个索引，我们可以通过EXPLAIN或EXPLAIN ANALYZE语句来查看其详细信息。这两个语句都可以用来查看查询的执行计划，包括哪些索引被使用了，以及它们的效率如何等信息。以下是使用EXPLAIN语句查看索引的示例代码： sql EXPLAIN SELECT FROM articles WHERE a = 'value'; 上述代码将会返回一个查询执行计划，其中包含了索引"idx_articles_a"的相关信息。如果索引被正确地使用了，那么查询的速度就会大大提高。 总结 总的来说，创建一个可以显示值出来的索引并不复杂，只需要使用CREATE INDEX语句指定要创建索引的表和字段即可。但是，想要构建一个恰到好处的索引真心不是个轻松活儿，这中间要考虑的因素可多了去了，像什么表的大小啊、查询的频率和复杂程度啊、数据分布的情况等等，都得琢磨透彻才行。所以在实际操作里头，咱们往往得不断试错、反复调校，才能摸清最高效的索引方法。这就像炒菜一样，不经过多次实践尝试，哪能调出最美味的佐料比例呢？同时呢，咱们也得时刻留意着索引的使用状况，一旦发现有啥苗头不对劲的地方，就得赶紧出手把它解决掉，避免出现更大的麻烦。

...,"minimum_index_compatibility_version" : "6.0.0-beta1"},"tagline" : "You Know, for Search"} 4、思考：用kibana连接elasticsearch? 思考(kibana连接elasticsearch)网络如何连接过去 ☺ 参考来源： 狂神的B站视频《【狂神说Java】Docker最新超详细版教程通俗易懂》 https://www.bilibili.com/video/BV1og4y1q7M4 如果本文对你有帮助的话记得给一乐点个赞哦，感谢！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_45630258/article/details/124785912。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...eslint/no-non-null-assertion': 0,// 是否对返回值类型进行定义校验'@typescript-eslint/explicit-function-return-type': 0,'@typescript-eslint/member-delimiter-style': ['error', { multiline: { delimiter: 'none' } }],// 结合eslint 'no-use-before-define': 'off'，不然会有报错，需要关闭eslint这个校验，主要是增加了对于type\interface\enum'no-use-before-define': 'off','@typescript-eslint/no-use-before-define': ['error'],'@typescript-eslint/explicit-module-boundary-types': 'off','@typescript-eslint/no-unused-vars': ['error',{ignoreRestSiblings: true,varsIgnorePattern: '^_',argsIgnorePattern: '^_',},],'@typescript-eslint/explicit-member-accessibility': ['error', { overrides: { constructors: 'no-public' } }],'@typescript-eslint/consistent-type-imports': 'error','@typescript-eslint/indent': 0,'@typescript-eslint/naming-convention': ['error',{selector: 'interface',format: ['PascalCase'],},],// 不允许使用 var'no-var': 'error',// 如果没有修改值，有些用const定义'prefer-const': ['error',{destructuring: 'any',ignoreReadBeforeAssign: false,},],// 关于vue3 的一些语法糖校验// 超过 4 个属性换行展示'vue/max-attributes-per-line': ['error',{singleline: 4,},],// setup 语法糖校验'vue/script-setup-uses-vars': 'error',// 关于箭头函数'vue/arrow-spacing': 'error','vue/html-indent': 'off',},} 4、加入单元测试   单元测试，根据自己项目体量及重要性而去考虑是否要增加，当然单测可以反推一些组件 or 方法的设计是否合理，同样如果是一个稳定的功能在加上单元测试，这就是一个很nice的体验； 我们单元测试是基于jest来去做的，具体安装单测的办法如下，跟着我的步骤一步步来； 安装jest单测相关的依赖组件库 pnpm add @testing-library/vue @testing-library/user-event @testing-library/jest-dom @types/jest jest @vue/test-utils -D 安装完成后，发现还需要安装前置依赖 @testing-library/dom @vue/compiler-sfc我们继续补充 安装babel相关工具，用ts写的单元测试需要转义，具体安装工具如下pnpm add @babel/core babel-jest @vue/babel-preset-app -D，最后我们配置babel.config.js module.exports = {presets: ['@vue/app'],} 配置jest.config.js module.exports = {roots: ['<rootDir>/test'],testMatch: [// 这里我们支持src目录里面增加一些单层，事实上我并不喜欢这样做'<rootDir>/src//__tests__//.{js,jsx,ts,tsx}','<rootDir>/src//.{spec,test}.{js,jsx,ts,tsx}',// 这里我习惯将单层文件统一放在test单独目录下，不在项目中使用，降低单测文件与业务组件模块混合在一起'<rootDir>/test//.{spec,test}.{js,jsx,ts,tsx}',],testEnvironment: 'jsdom',transform: {// 此处我们单测没有适用vue-jest方式，项目中我们江永tsx方式来开发，所以我们如果需要加入其它的内容// '^.+\\.(vue)$': '<rootDir>/node_modules/vue-jest','^.+\\.(js|jsx|mjs|cjs|ts|tsx)$': '<rootDir>/node_modules/babel-jest',},transformIgnorePatterns: ['<rootDir>/node_modules/','[/\\\\]node_modules[/\\\\].+\\.(js|jsx|mjs|cjs|ts|tsx)$','^.+\\.module\\.(css|sass|scss|less)$',],moduleFileExtensions: ['ts', 'tsx', 'vue', 'js', 'jsx', 'json', 'node'],resetMocks: true,}   具体写单元测试的方法，可以参考项目模板中的组件单元测试写法，这里不做过多的说明； 5、封装axios请求库   这里呢其实思路有很多种，如果有自己的习惯的封装方式，就按照自己的思路，下面附上我的封装代码，简短的说一下我的封装思路: 1、基础的请求拦截、相应拦截封装，这个是对于一些请求参数格式化处理等，或者返回值情况处理 2、请求异常、错误、接口调用成功返回结果错误这些错误的集中处理，代码中请求就不再做trycatch这些操作 3、请求函数统一封装（代码中的 get、post、axiosHttp） 4、泛型方式定义请求返回参数，定义好类型，让我们可以在不同地方使用有良好的提示 import type { AxiosRequestConfig, AxiosResponse } from 'axios'import axios from 'axios'import { ElNotification } from 'element-plus'import errorHandle from './errorHandle'// 定义数据返回结构体(此处我简单定义一个比较常见的后端数据返回结构体，实际使用我们需要按照自己所在的项目开发)interface ResponseData<T = null> {code: string | numberdata: Tsuccess: booleanmessage?: string[key: string]: any}const axiosInstance = axios.create()// 设定响应超时时间axiosInstance.defaults.timeout = 30000// 可以后续根据自己http请求头特殊邀请设定请求头axiosInstance.interceptors.request.use((req: AxiosRequestConfig<any>) => {// 特殊处理，后续如果项目中有全局通传参数，可以在这儿做一些处理return req},error => Promise.reject(error),)// 响应拦截axiosInstance.interceptors.response.use((res: AxiosResponse<any, any>) => {// 数组处理return res},error => Promise.reject(error),)// 通用的请求方法体const axiosHttp = async <T extends Record<string, any> | null>(config: AxiosRequestConfig,desc: string,): Promise<T> => {try {const { data } = await axiosInstance.request<ResponseData<T>>(config)if (data.success) {return data.data}// 如果请求失败统一做提示(此处我没有安装组件库，我简单写个mock例子)ElNotification({title: desc,message: ${data.message || '请求失败，请检查'},})} catch (e: any) {// 统一的错误处理if (e.response && e.response.status) {errorHandle(e.response.status, desc)} else {ElNotification({title: desc,message: '接口异常，请检查',})} }return null as T}// get请求方法封装export const get = async <T = Record<string, any> | null>(url: string, params: Record<string, any>, desc: string) => {const config: AxiosRequestConfig = {method: 'get',url,params,}const data = await axiosHttp<T>(config, desc)return data}// Post请求方法export const post = async <T = Record<string, any> | null>(url: string, data: Record<string, any>, desc: string) => {const config: AxiosRequestConfig = {method: 'post',url,data,}const info = await axiosHttp<T>(config, desc)return info} 请求错误（状态码错误相关提示） import { ElNotification } from 'element-plus'function notificat(message: string, title: string) {ElNotification({title,message,})}/ @description 获取接口定义 @param status {number} 错误状态码 @param desc {string} 接口描述信息/export default function errorHandle(status: number, desc: string) {switch (status) {case 401:notificat('用户登录失败', desc)breakcase 404:notificat('请求不存在', desc)breakcase 500:notificat('服务器错误，请检查服务器', desc)breakdefault:notificat(其他错误${status}, desc)break} } 6、关于vue-router 及 pinia   这两个相对来讲简单一些，会使用vuex状态管理，上手pinia也是很轻松的事儿，只是更简单化了、更方便了，可以参考模板项目里面的用法example，这里附上router及pinia配置方法，路由守卫，大家可以根据项目的要求再添加 import type { RouteRecordRaw } from 'vue-router'import { createRouter, createWebHistory } from 'vue-router'// 配置路由const routes: Array<RouteRecordRaw> = [{path: '/',redirect: '/home',},{name: 'home',path: '/home',component: () => import('page/Home'),},]const router = createRouter({routes,history: createWebHistory(),})export default router 针对与pinia，参考如下： import { createPinia } from 'pinia'export default createPinia() 在入口文件将router和store注入进去 import { createApp } from 'vue'import App from './App'import store from './store/index'import './style/index.css'import './style/index.scss'import 'element-plus/dist/index.css'import router from './router'// 注入全局的storeconst app = createApp(App).use(store).use(router)app.mount('app')   说这些比较枯燥，建议大家去github参考项目说明文档，下载项目，自己过一遍，喜欢的朋友收藏点赞一下，如果喜欢我构建好的项目给个star不丢失，谢谢各位看官的支持。 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_37764929/article/details/124860873。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...，在一个没有被整理好索引的列上尝试进行排序操作，Hive这个家伙可就抓瞎了，因为它找不到合适的扫描方法，这时候它就会毫不客气地抛出一个错误给你。 sql SELECT FROM my_table ORDER BY non_indexed_column; 这样的话，你需要检查你的查询语句，确保它们是正确的。 2.2 计算资源不足 Hive在处理复杂的查询时，需要大量的计算资源。如果你的Hive集群中的资源（如内存、CPU）不足以支持你的查询，那么查询就会失败。 这种情况通常发生在你的查询过于复杂，或者你的Hive集群中的节点数量不足的时候。要解决这个问题，你有两个选择：一是给你的集群添点新节点，让它更强大；二是让查询变得更聪明、更高效，也就是优化一下查询的方式。 3. 如何解决这些问题？ 以下是一些可能的解决方案： 3.1 检查并修复查询语句 如果你的查询语句中有错误，你需要花时间检查它并进行修复。在动手执行查询前，有个超级实用的小窍门，那就是先翻翻Hive的元数据这个“小字典”，确保你想要捞出来的数据，是对应到正确的列和行哈。别到时候查了半天，发现找的竟然是张“错片儿”，那就尴尬啦！ 3.2 优化查询 有时候，问题并不是在于查询本身，而在于你的数据。如果数据分布不均匀，或者包含了大量的重复值，那么查询可能会变得非常慢。在这种情况下，你可以考虑使用分区和聚类来优化你的数据。 3.3 增加计算资源 如果你的查询确实需要大量的计算资源，但你的集群中没有足够的资源，那么你可能需要考虑增加你的集群规模。你可以添加更多的节点，或者升级现有的节点，以提高其性能。 3.4 使用外部表 如果你的查询涉及到了大量的数据，但这些数据又不适合存储在Hive中，那么你可以考虑使用外部表。这样一来，你完全无需改动原有的查询内容，就能轻轻松松地把其他系统的查询结果搬到Hive里面去。就像是你从一个仓库搬东西到另一个仓库，连包装都不用换，直接搬运过去就OK啦！ 总的来说，虽然Hive是一个强大的工具，但在使用过程中我们也可能会遇到各种各样的问题。当我们把这些难题的原因摸得门儿清的时候，就能找到真正管用的解决办法，进而更好地把Hive的功能发挥到极致。

...IN，若关联字段没有索引或分区，则可能导致性能瓶颈 SELECT a., b. FROM large_table_a a JOIN large_table_b b ON (a.key = b.key); - 缺乏合理分区与索引：未对表进行合理分区设计或者缺失必要的索引，会导致Hive无法高效定位所需数据。 - 计算密集型操作：如GROUP BY、SORT BY等操作，如果处理的数据量过大且未优化，也会导致查询速度变慢。 3. 解决策略 从源头提升查询效率 - 减少数据扫描： - WHERE子句过滤：尽量精确地指定WHERE条件，减少无效数据的读取。 sql SELECT FROM large_table WHERE key = 'specific_value' AND date = '2022-01-01'; - 创建分区表：根据业务需求对表进行分区，使得查询可以只针对特定分区进行。 sql CREATE TABLE large_table_parted ( ... ) PARTITIONED BY (date STRING); - 优化JOIN操作： - 避免笛卡尔积：确保JOIN条件足够具体，限制JOIN后的数据规模。 - 考虑小表驱动大表：尽可能让数据量小的表作为JOIN操作的左表。 - 利用索引：虽然Hive原生支持的索引功能有限，但在某些场景下（如ORC文件格式），我们可以利用Bloom Filter索引加速查询。 sql ALTER TABLE large_table ADD INDEX idx_key ON KEY; - 分桶策略：对于GROUP BY、JOIN等操作，可尝试对相关字段进行分桶，从而分散计算负载。 sql CREATE TABLE bucketed_table (...) CLUSTERED BY (key) INTO 10 BUCKETS; 4. 总结与思考 面对Hive查询速度慢的问题，我们需要具备一种“侦探”般的洞察力，从查询语句本身出发，结合业务特点和数据特性，有针对性地进行优化。其实呢，上面提到的这些策略啊，都不是一个个单打独斗的“孤胆英雄”，而是需要咱们把它们巧妙地糅合在一起，灵活运用，最终才能编织出一套真正行之有效的整体优化方案。所以，你懂的，把这些技巧玩得贼溜，可不光是能让你查数据的速度嗖嗖提升，更关键的是，当你面对海量数据的时候，就能像切豆腐一样轻松应对，让Hive在大数据分析这片天地里，真正爆发出惊人的能量，展现它应有的威力。同时，千万记得要时刻紧跟Hive社区的最新动态，像追剧一样紧随其步伐，把那些新鲜出炉的优化技术和工具统统收入囊中。这样一来，咱们就能提前准备好充足的弹药，应对那日益棘手、复杂的数据难题啦！

...admin用户查看索引列表： bash curl -X GET "https://localhost:9200/_cat/indices?v" \ -u admin:changeme 如果一切正常，你应该能看到所有索引的信息。 3.3 RBAC（基于角色的访问控制） 除了内置角色外，Elasticsearch还支持RBAC。你可以给每个角色设定超级详细的权限，比如说准不准用某个API，能不能访问特定的索引之类的。 json { "role": "custom_role", "cluster": ["monitor"], "indices": [ { "names": [ "logstash-" ], "privileges": [ "read", "view_index_metadata" ] } ] } 这段JSON定义了一个名为custom_role的角色，允许用户读取logstash-系列索引的数据。 --- 4. 日志审计与监控 最后，咱们得关注日志审计和监控。即使你做了所有的安全措施，也不能保证万无一失。定期检查日志和监控系统可以帮助我们及时发现问题。 4.1 日志审计 Elasticsearch自带的日志功能非常强大。你可以通过配置日志级别来记录不同级别的事件。例如，启用调试日志： yaml logger.org.elasticsearch: debug 将这条配置添加到logging.yml文件中即可。 4.2 监控工具 推荐使用Kibana来监控Elasticsearch的状态。装好Kibana之后，你就能通过网页界面瞅一眼你的集群健不健康、各个节点都在干嘛，还能看看性能指标啥的，挺直观的！ 4.2.1 配置Kibana 在Kibana的配置文件kibana.yml中，添加以下内容： yaml elasticsearch.hosts: ["https://localhost:9200"] elasticsearch.username: "kibana_system" elasticsearch.password: "changeme" 然后重启Kibana服务，打开浏览器访问http://localhost:5601即可。 --- 5. 总结 好了，朋友们，今天的分享就到这里啦！优化Elasticsearch的安全性并不是一件容易的事，但只要我们用心去做，就能大大降低风险。从SSL/TLS加密到用户认证，再到日志审计和监控，每一个环节都很重要。 我希望这篇文章对你有所帮助，如果你还有其他问题或者经验分享，欢迎随时留言交流！让我们一起打造更安全、更可靠的Elasticsearch集群吧！

...的全文搜索库，它在搜索引擎领域有着举足轻重的地位。话说在咱们聊Lucene之前，我得先吐槽一下最近在开发中遇到的一个超级烦人的bug——就是那个“javalangNullPointerException: null”。简直让人抓狂啊！这个异常常常会出现在我们的代码中，特别是在处理复杂数据结构时。那么，让我们一边学习如何优雅地使用Lucene，一边看看如何巧妙地避开NullPointerException吧！ 二、Lucene的魅力所在 从概念到实践 首先，让我们来了解一下Lucene的基本概念。Lucene可真是个厉害的角色，它是个超级能打的文本搜索小能手，给咱们提供了全套的工具，不管是建索引、搜东西还是让搜索结果更给力，都能搞定！简单来说，Lucene就像是你电脑上的超级搜索引擎，但它的能力远不止于此。 2.1 创建你的第一个索引 在开始之前，你需要确保已经在你的项目中引入了Lucene的相关依赖。接下来，让我们通过一些简单的步骤来创建一个基本的索引： java import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.store.Directory; import org.apache.lucene.store.RAMDirectory; public class SimpleIndexer { public static void main(String[] args) throws Exception { // 创建内存中的目录，用于存储索引 Directory directory = new RAMDirectory(); // 创建索引配置 IndexWriterConfig config = new IndexWriterConfig(new StandardAnalyzer()); // 创建索引写入器 IndexWriter indexWriter = new IndexWriter(directory, config); // 创建文档对象 Document doc = new Document(); doc.add(new Field("content", "Hello Lucene!", Field.Store.YES, Field.Index.ANALYZED)); // 添加文档到索引 indexWriter.addDocument(doc); // 关闭索引写入器 indexWriter.close(); } } 在这个例子中，我们首先创建了一个内存中的目录（RAMDirectory），这是为了方便演示。接着，我们定义了索引配置，并使用StandardAnalyzer对文本进行分析。最后，我们创建了一个文档，并将它添加到了索引中。是不是很简单呢？ 2.2 解决NullPointerException：预防胜于治疗 现在，让我们回到那个恼人的NullPointerException问题上。在用Lucene做索引的时候，经常会被空指针异常坑到，特别是当你试图去访问那些还没被初始化的对象或者字段时。为了避免这种情况，我们需要养成良好的编程习惯，比如： - 检查null值：在访问任何对象前，先检查是否为null。 - 初始化变量：确保所有对象在使用前都被正确初始化。 - 使用Optional类：Java 8引入的Optional类可以帮助我们更好地处理可能为空的情况。 例如，假设我们在处理索引文档时遇到了一个可能为空的字段，我们可以这样处理： java // 假设我们有一个可能为空的内容字段 String content = getContent(); // 这里可能会返回null if (content != null) { doc.add(new Field("content", content, Field.Store.YES, Field.Index.ANALYZED)); } else { System.out.println("内容字段为空！"); } 三、深入探索 Lucene的高级特性 3.1 搜索：不仅仅是查找 除了创建索引外，Lucene还提供了强大的搜索功能。让我们来看一个简单的搜索示例： java import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.queryparser.classic.QueryParser; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.search.Query; import org.apache.lucene.search.ScoreDoc; import org.apache.lucene.search.TopDocs; import org.apache.lucene.store.Directory; public class SimpleSearcher { public static void main(String[] args) throws Exception { Directory directory = new RAMDirectory(); IndexWriterConfig config = new IndexWriterConfig(new StandardAnalyzer()); IndexWriter indexWriter = new IndexWriter(directory, config); Document doc = new Document(); doc.add(new Field("content", "Hello Lucene!", Field.Store.YES, Field.Index.ANALYZED)); indexWriter.addDocument(doc); indexWriter.close(); DirectoryReader reader = DirectoryReader.open(directory); IndexSearcher searcher = new IndexSearcher(reader); QueryParser parser = new QueryParser("content", new StandardAnalyzer()); Query query = parser.parse("lucene"); TopDocs results = searcher.search(query, 10); for (ScoreDoc scoreDoc : results.scoreDocs) { System.out.println(searcher.doc(scoreDoc.doc).get("content")); } reader.close(); } } 这段代码展示了如何使用QueryParser解析查询字符串，并使用IndexSearcher执行搜索操作。通过这种方式，我们可以轻松地从索引中检索出相关的文档。 3.2 高级搜索技巧：优化你的查询 当你开始构建更复杂的搜索逻辑时，Lucene提供了许多高级功能来帮助你优化搜索结果。比如说，你可以用布尔查询把好几个搜索条件拼在一起，或者用模糊匹配让搜索变得更灵活一点。这样找东西就方便多了！ java import org.apache.lucene.index.Term; import org.apache.lucene.search.BooleanClause; import org.apache.lucene.search.BooleanQuery; import org.apache.lucene.search.FuzzyQuery; // 构建布尔查询 BooleanQuery booleanQuery = new BooleanQuery(); booleanQuery.add(new TermQuery(new Term("content", "hello")), BooleanClause.Occur.MUST); booleanQuery.add(new FuzzyQuery(new Term("content", "lucen")), BooleanClause.Occur.SHOULD); TopDocs searchResults = searcher.search(booleanQuery, 10); 在这个例子中，我们创建了一个布尔查询，其中包含两个子查询：一个是必须满足的精确匹配查询，另一个是可选的模糊匹配查询。这种组合可以显著提升搜索的准确性和相关性。 四、结语 享受编码的乐趣 通过这篇文章，我们不仅学习了如何使用Apache Lucene来创建和搜索索引，还一起探讨了如何有效地避免NullPointerException。希望这些示例代码和技巧能对你有所帮助。记住，编程不仅仅是一门技术，更是一种艺术。尽情享受编程的乐趣吧，一路探索和学习，你会发现自己的收获多到让人惊喜！如果你有任何问题或想法，欢迎随时与我交流！ --- 以上就是关于Apache Lucene与javalangNullPointerException: null的讨论。希望能通过这篇文章点燃你对Lucene的热情，让你在实际开发中游刃有余，玩得更嗨！让我们一起继续探索更多有趣的技术吧！

...息岛屿？这就是全文检索引擎如 Apache Lucene 所承担的使命。哎呀，Lucene这玩意儿，那可是真挺牛的！在处理海量文本数据的时候，无论是建立索引还是进行搜索，它都能玩得飞起，简直就像是个搜索界的超级英雄！它的效率高，用起来又非常灵活，想怎么调整都行，真是让人大呼过瘾。然而，即便是如此强大的工具，也并非没有挑战。本文将深入探讨一个常见的错误——org.apache.lucene.analysis.TokenStream$EOFException: End of stream，并尝试通过实例代码来揭示其背后的原因与解决之道。 第一部分：理解 TokenStream 和 EOFException TokenStream 是 Lucene 提供的一个抽象类，它负责将输入的文本分割成一系列可处理的令牌（tokens），这些令牌是构成文本的基本单位，例如单词、符号等。当 TokenStream 遇到文件末尾（EOF），即无法获取更多令牌时，就会抛出 EOFException。 示例代码：创建 TokenStream 并处理 EOFException 首先，我们编写一段简单的代码来生成一个 TokenStream，并观察如何处理可能出现的 EOFException。 java import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.analysis.tokenattributes.OffsetAttribute; import org.apache.lucene.document.Document; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.store.Directory; import org.apache.lucene.store.RAMDirectory; import org.apache.lucene.util.Version; import java.io.IOException; public class TokenStreamDemo { public static void main(String[] args) throws IOException { // 创建 RAMDirectory 实例 Directory directory = new RAMDirectory(); // 初始化 IndexWriterConfig IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, new StandardAnalyzer()); // 创建 IndexWriter 并初始化索引 IndexWriter writer = new IndexWriter(directory, config); // 添加文档至索引 Document doc = new Document(); doc.add(new TextField("content", "这是一个测试文档，用于演示 Lucene 的 TokenStream 功能。", Field.Store.YES, Field.Index.ANALYZED)); writer.addDocument(doc); // 关闭 IndexWriter writer.close(); // 创建 IndexReader IndexReader reader = DirectoryReader.open(directory); // 使用 IndexSearcher 查找文档 IndexSearcher searcher = new IndexSearcher(reader); // 获取 TokenStream 对象 org.apache.lucene.search.IndexSearcher.SearchContext context = searcher.createSearchContext(); org.apache.lucene.analysis.standard.StandardAnalyzer analyzer = new org.apache.lucene.analysis.standard.StandardAnalyzer(Version.LATEST); org.apache.lucene.analysis.TokenStream tokenStream = analyzer.tokenStream("content", context.reader().getTermVector(0, 0).getPayload().toString()); // 检查是否有异常抛出 while (tokenStream.incrementToken()) { System.out.println("Token: " + tokenStream.getAttribute(CharTermAttribute.class).toString()); } // 关闭 TokenStream 和 IndexReader tokenStream.end(); reader.close(); } } 在这段代码中，我们首先创建了一个 RAMDirectory，并使用它来构建一个索引。接着，我们添加了一个包含测试文本的文档到索引中。之后，我们创建了 IndexSearcher 来搜索文档，并使用 StandardAnalyzer 来创建 TokenStream。在循环中，我们逐个输出令牌，直到遇到 EOFException，这通常意味着已经到达了文本的末尾。 第二部分：深入分析 EOFException 的原因与解决策略 在实际应用中，EOFException 通常意味着 TokenStream 已经到达了文本的结尾，这可能是由于以下原因： - 文本过短：如果输入的文本长度不足以产生足够的令牌，TokenStream 可能会过早地报告结束。 - 解析问题：在复杂的文本结构下，解析器可能未能正确地分割文本，导致部分文本未被识别为有效的令牌。 为了应对这种情况，我们可以采取以下策略： - 增加文本长度：确保输入的文本足够长，以生成多个令牌。 - 优化解析器配置：根据特定的应用场景调整分析器的配置，例如使用不同的分词器（如 CJKAnalyzer）来适应不同语言的需求。 - 错误处理机制：在代码中加入适当的错误处理逻辑，以便在遇到 EOFException 时进行相应的处理，例如记录日志、提示用户重新输入更长的文本等。 结语：拥抱挑战，驾驭全文检索 面对 org.apache.lucene.analysis.TokenStream$EOFException: End of stream 这样的挑战，我们的目标不仅仅是解决问题，更是通过这样的经历深化对 Lucene 工作原理的理解。哎呀，你猜怎么着？咱们在敲代码、调参数的过程中，不仅技术越来越溜，还能在处理那些乱七八糟的数据时，感觉自己就像个数据处理的小能手，得心应手的呢！就像是在厨房里，熟练地翻炒各种食材，做出来的菜品色香味俱全，让人赞不绝口。编程也是一样，每一次的实践和调试，都是在给我们的技能加料，让我们的作品越来越美味，越来越有营养！嘿！兄弟，听好了，每次遇到难题都像是在给咱的成长加个buff，咱们得一起揭开全文检索的神秘面纱，掌控技术的大棒，让用户体验到最棒、最快的搜索服务，让每一次敲击键盘都能带来惊喜！ --- 以上内容不仅涵盖了理论解释与代码实现，还穿插了人类在面对技术难题时的思考与探讨，旨在提供一种更加贴近实际应用、充满情感与主观色彩的技术解读方式。

...个信息爆炸的时代，搜索引擎的性能和灵活性成为了用户体验的关键因素之一。Apache Lucene，作为一款强大的全文搜索库，为我们提供了丰富的查询选项，其中之一就是FuzzyQuery，它允许我们在搜索时处理模糊匹配，即使用户输入的关键词可能不完全精确。今天，我们将深入剖析如何在实际项目中利用FuzzyQuery，让搜索体验更加人性化。 二、什么是FuzzyQuery 1. 概念解析 FuzzyQuery是Lucene中用于执行模糊搜索的核心工具，它通过计算查询词与索引中的单词之间的Levenshtein距离（也称编辑距离），找到那些相似度超过预设阈值的文档。你知道吗，编辑距离这玩意儿就像个搞笑的测谎游戏，它比量两个词串之间的亲密度，简单说就是，你要么得添字、减字或者动动手脚换个别字，最少几次才能让这两个词串变成亲兄弟一样挨着。 三、FuzzyQuery的使用示例 2. 编码实现 以下是一个简单的Java代码片段，展示了如何使用FuzzyQuery进行模糊搜索： java import org.apache.lucene.analysis.Analyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.TextField; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.queryparser.classic.QueryParser; import org.apache.lucene.search.; import org.apache.lucene.store.Directory; import org.apache.lucene.store.RAMDirectory; public class FuzzySearchExample { public static void main(String[] args) throws Exception { Directory indexDir = new RAMDirectory(); // 创建内存索引 Analyzer analyzer = new StandardAnalyzer(); // 使用标准分析器 // 假设我们有一个文档集合，这里只创建一个简单的文档 Document doc = new Document(); doc.add(new TextField("content", "Lucene is awesome", Field.Store.YES)); IndexWriterConfig config = new IndexWriterConfig(analyzer); IndexWriter writer = new IndexWriter(indexDir, config); writer.addDocument(doc); writer.close(); String queryTerm = "Lucenes"; // 用户输入的模糊查询词 float fuzziness = 1f; // 设置模糊度，例如1代表允许一个字符的差异 QueryParser parser = new QueryParser("content", analyzer); FuzzyQuery fuzzyQuery = new FuzzyQuery(parser.parse(queryTerm), fuzziness); IndexReader reader = DirectoryReader.open(indexDir); TopDocs topDocs = searcher.search(fuzzyQuery, 10); // 返回最多10个匹配结果 for (ScoreDoc scoreDoc : topDocs.scoreDocs) { Document hitDoc = searcher.doc(scoreDoc.doc); System.out.println("Score: " + scoreDoc.score + ", Hit: " + hitDoc.get("content")); } reader.close(); } } 这段代码首先创建了一个简单的索引，然后构造了一个FuzzyQuery实例，指定要搜索的关键词和允许的最大编辑距离。搜索时，我们能看到即使用户输入的不是完全匹配的"Lucene"，而是"Lucenes"，FuzzyQuery也能返回相关的结果。 四、FuzzyQuery优化策略 3. 性能与优化 当处理大量数据时，FuzzyQuery可能会变得较慢，因为它的计算复杂度与搜索词的长度和索引的大小有关。为了提高效率，可以考虑以下策略： - 前缀匹配：使用PrefixQuery结合FuzzyQuery，仅搜索具有相同前缀的文档，这可以减少搜索范围。 - 阈值调整：根据应用需求调整模糊度阈值，更严格的阈值可以提高精确度，但搜索速度会下降。 - 分批处理：如果搜索结果过多，可以分批处理，先缩小范围，再逐步细化。 五、结论 4. 未来展望与总结 FuzzyQuery在提高搜索灵活性的同时，也对性能提出了挑战。要想在项目里游刃有余，得深入理解那些神奇的机制和巧妙的策略，这样才能精准又高效，就像个武林高手一样，既能一击即中，又能快如闪电。Lucene那强大的模糊搜索绝不仅仅是纠错能手，它还能在你打字时瞬间给出超贴心的拼写建议，让找东西变得超级简单，简直提升了搜寻乐趣好几倍！随着科技日新月异，Lucene这家伙也越变越聪明，咱们可真盼着瞧见那些超酷的新搜索招数，让找东西这事变得更聪明又快捷，就像点穴一样精准！ 在构建现代应用程序时，了解并善用这些高级查询工具，无疑会让我们的搜索引擎更具竞争力。希望这个简单示例能帮助你开始在项目中运用FuzzyQuery，提升搜索的精准度和易用性。

...og-output=NONE general-log=0 general_log_file="DESKTOP-NF9QETB.log" slow-query-log=0 slow_query_log_file="DESKTOP-NF9QETB-slow.log" long_query_time=10 Binary Logging. 二进制日志。 log-bin Error Logging. 错误日志记录。 log-error="DESKTOP-NF9QETB.err" Server Id. server-id=1 Indicates how table and database names are stored on disk and used in MySQL. 指示表名和数据库名如何存储在磁盘上并在MySQL中使用。 Value = 0: Table and database names are stored on disk using the lettercase specified in the CREATE TABLE or CREATE DATABASE statement. Name comparisons are case sensitive. You should not set this variable to 0 if you are running MySQL on a system that has case-insensitive file names (such as Windows or macOS). Value = 0:表名和数据库名使用CREATE Table或CREATE database语句中指定的lettercase存储在磁盘上。名称比较区分大小写。如果您在一个具有不区分大小写文件名(如Windows或macOS)的系统上运行MySQL，则不应将该变量设置为0。 Value = 1: Table names are stored in lowercase on disk and name comparisons are not case-sensitive. MySQL converts all table names to lowercase on storage and lookup. This behavior also applies to database names and table aliases. 表名以小写存储在磁盘上，并且名称比较不区分大小写。MySQL在存储和查找时将所有表名转换为小写。此行为也适用于数据库名称和表别名。 Value = 3, Table and database names are stored on disk using the lettercase specified in the CREATE TABLE or CREATE DATABASE statement, but MySQL converts them to lowercase on lookup. Name comparisons are not case sensitive. This works only on file systems that are not case-sensitive! InnoDB table names and view names are stored in lowercase, as for Value = 1.表名和数据库名使用CREATE Table或CREATE database语句中指定的lettercase存储在磁盘上，但是MySQL在查找时将它们转换为小写。名称比较不区分大小写。这只适用于不区分大小写的文件系统!InnoDB表名和视图名以小写存储，Value = 1。 NOTE: lower_case_table_names can only be configured when initializing the server. Changing the lower_case_table_names setting after the server is initialized is prohibited. lower_case_table_names=1 Secure File Priv. 权限安全文件 secure-file-priv="C:/ProgramData/MySQL/MySQL Server 8.0/Uploads" The maximum amount of concurrent sessions the MySQL server will allow. One of these connections will be reserved for a user with SUPER privileges to allow the administrator to login even if the connection limit has been reached. MySQL服务器允许的最大并发会话量。这些连接中的一个将保留给具有超级特权的用户，以便允许管理员登录，即使已经达到连接限制。 max_connections=151 The number of open tables for all threads. Increasing this value increases the number of file descriptors that mysqld requires. Therefore you have to make sure to set the amount of open files allowed to at least 4096 in the variable "open-files-limit" in 为所有线程打开的表的数量。增加这个值会增加mysqld需要的文件描述符的数量。因此，您必须确保在[mysqld_safe]节中的变量“open-files-limit”中将允许打开的文件数量至少设置为4096 section [mysqld_safe] table_open_cache=2000 Maximum size for internal (in-memory) temporary tables. If a table grows larger than this value, it is automatically converted to disk based table This limitation is for a single table. There can be many of them. 内部(内存)临时表的最大大小。如果一个表比这个值大，那么它将自动转换为基于磁盘的表。可以有很多。 tmp_table_size=94M How many threads we should keep in a cache for reuse. When a client disconnects, the client's threads are put in the cache if there aren't more than thread_cache_size threads from before. This greatly reduces the amount of thread creations needed if you have a lot of new connections. (Normally this doesn't give a notable performance improvement if you have a good thread implementation.) 我们应该在缓存中保留多少线程以供重用。当客户机断开连接时，如果之前的线程数不超过thread_cache_size，则将客户机的线程放入缓存。如果您有很多新连接，这将大大减少所需的线程创建量(通常，如果您有一个良好的线程实现，这不会带来显著的性能改进)。 thread_cache_size=10 MyISAM Specific options The maximum size of the temporary file MySQL is allowed to use while recreating the index (during REPAIR, ALTER TABLE or LOAD DATA INFILE. If the file-size would be bigger than this, the index will be created through the key cache (which is slower). MySQL允许在重新创建索引时(在修复、修改表或加载数据时)使用临时文件的最大大小。如果文件大小大于这个值，那么索引将通过键缓存创建(这比较慢)。 myisam_max_sort_file_size=100G If the temporary file used for fast index creation would be bigger than using the key cache by the amount specified here, then prefer the key cache method. This is mainly used to force long character keys in large tables to use the slower key cache method to create the index. myisam_sort_buffer_size=179M Size of the Key Buffer, used to cache index blocks for MyISAM tables. Do not set it larger than 30% of your available memory, as some memory is also required by the OS to cache rows. Even if you're not using MyISAM tables, you should still set it to 8-64M as it will also be used for internal temporary disk tables. 如果用于快速创建索引的临时文件比这里指定的使用键缓存的文件大，则首选键缓存方法。这主要用于强制大型表中的长字符键使用较慢的键缓存方法来创建索引。 key_buffer_size=8M Size of the buffer used for doing full table scans of MyISAM tables. Allocated per thread, if a full scan is needed. 用于对MyISAM表执行全表扫描的缓冲区的大小。如果需要完整的扫描，则为每个线程分配。 read_buffer_size=256K read_rnd_buffer_size=512K INNODB Specific options INNODB特定选项 innodb_data_home_dir= Use this option if you have a MySQL server with InnoDB support enabled but you do not plan to use it. This will save memory and disk space and speed up some things. 如果您启用了一个支持InnoDB的MySQL服务器，但是您不打算使用它，那么可以使用这个选项。这将节省内存和磁盘空间，并加快一些事情。skip-innodb skip-innodb If set to 1, InnoDB will flush (fsync) the transaction logs to the disk at each commit, which offers full ACID behavior. If you are willing to compromise this safety, and you are running small transactions, you may set this to 0 or 2 to reduce disk I/O to the logs. Value 0 means that the log is only written to the log file and the log file flushed to disk approximately once per second. Value 2 means the log is written to the log file at each commit, but the log file is only flushed to disk approximately once per second. 如果设置为1,InnoDB将在每次提交时将事务日志刷新(fsync)到磁盘，这将提供完整的ACID行为。如果您愿意牺牲这种安全性，并且正在运行小型事务，您可以将其设置为0或2，以将磁盘I/O减少到日志。值0表示日志仅写入日志文件，日志文件大约每秒刷新一次磁盘。值2表示日志在每次提交时写入日志文件，但是日志文件大约每秒只刷新一次磁盘。 innodb_flush_log_at_trx_commit=1 The size of the buffer InnoDB uses for buffering log data. As soon as it is full, InnoDB will have to flush it to disk. As it is flushed once per second anyway, it does not make sense to have it very large (even with long transactions).InnoDB用于缓冲日志数据的缓冲区大小。一旦它满了，InnoDB就必须将它刷新到磁盘。由于它无论如何每秒刷新一次，所以将它设置为非常大的值是没有意义的(即使是长事务)。 innodb_log_buffer_size=5M InnoDB, unlike MyISAM, uses a buffer pool to cache both indexes and row data. The bigger you set this the less disk I/O is needed to access data in tables. On a dedicated database server you may set this parameter up to 80% of the machine physical memory size. Do not set it too large, though, because competition of the physical memory may cause paging in the operating system. Note that on 32bit systems you might be limited to 2-3.5G of user level memory per process, so do not set it too high. 与MyISAM不同，InnoDB使用缓冲池来缓存索引和行数据。设置的值越大，访问表中的数据所需的磁盘I/O就越少。在专用数据库服务器上，可以将该参数设置为机器物理内存大小的80%。但是，不要将它设置得太大，因为物理内存的竞争可能会导致操作系统中的分页。注意，在32位系统上，每个进程的用户级内存可能被限制在2-3.5G，所以不要设置得太高。 innodb_buffer_pool_size=20M Size of each log file in a log group. You should set the combined size of log files to about 25%-100% of your buffer pool size to avoid unneeded buffer pool flush activity on log file overwrite. However, note that a larger logfile size will increase the time needed for the recovery process. 日志组中每个日志文件的大小。您应该将日志文件的合并大小设置为缓冲池大小的25%-100%，以避免在覆盖日志文件时出现不必要的缓冲池刷新活动。但是，请注意，较大的日志文件大小将增加恢复过程所需的时间。 innodb_log_file_size=48M Number of threads allowed inside the InnoDB kernel. The optimal value depends highly on the application, hardware as well as the OS scheduler properties. A too high value may lead to thread thrashing. InnoDB内核中允许的线程数。最优值在很大程度上取决于应用程序、硬件以及OS调度程序属性。过高的值可能导致线程抖动。 innodb_thread_concurrency=9 The increment size (in MB) for extending the size of an auto-extend InnoDB system tablespace file when it becomes full. 增量大小(以MB为单位)，用于在表空间满时扩展自动扩展的InnoDB系统表空间文件的大小。 innodb_autoextend_increment=128 The number of regions that the InnoDB buffer pool is divided into. For systems with buffer pools in the multi-gigabyte range, dividing the buffer pool into separate instances can improve concurrency, by reducing contention as different threads read and write to cached pages. InnoDB缓冲池划分的区域数。对于具有多gb缓冲池的系统，将缓冲池划分为单独的实例可以提高并发性，因为不同的线程对缓存页面的读写会减少争用。 innodb_buffer_pool_instances=8 Determines the number of threads that can enter InnoDB concurrently. 确定可以同时进入InnoDB的线程数 innodb_concurrency_tickets=5000 Specifies how long in milliseconds (ms) a block inserted into the old sublist must stay there after its first access before it can be moved to the new sublist. 指定插入到旧子列表中的块必须在第一次访问之后停留多长时间(毫秒)，然后才能移动到新子列表。 innodb_old_blocks_time=1000 It specifies the maximum number of .ibd files that MySQL can keep open at one time. The minimum value is 10. 它指定MySQL一次可以打开的.ibd文件的最大数量。最小值是10。 innodb_open_files=300 When this variable is enabled, InnoDB updates statistics during metadata statements. 当启用此变量时，InnoDB会在元数据语句期间更新统计信息。 innodb_stats_on_metadata=0 When innodb_file_per_table is enabled (the default in 5.6.6 and higher), InnoDB stores the data and indexes for each newly created table in a separate .ibd file, rather than in the system tablespace. 当启用innodb_file_per_table(5.6.6或更高版本的默认值)时，InnoDB将每个新创建的表的数据和索引存储在单独的.ibd文件中，而不是系统表空间中。 innodb_file_per_table=1 Use the following list of values: 0 for crc32, 1 for strict_crc32, 2 for innodb, 3 for strict_innodb, 4 for none, 5 for strict_none. 使用以下值列表:0表示crc32, 1表示strict_crc32, 2表示innodb, 3表示strict_innodb, 4表示none, 5表示strict_none。 innodb_checksum_algorithm=0 The number of outstanding connection requests MySQL can have. This option is useful when the main MySQL thread gets many connection requests in a very short time. It then takes some time (although very little) for the main thread to check the connection and start a new thread. The back_log value indicates how many requests can be stacked during this short time before MySQL momentarily stops answering new requests. You need to increase this only if you expect a large number of connections in a short period of time. MySQL可以有多少未完成连接请求。当MySQL主线程在很短的时间内收到许多连接请求时，这个选项非常有用。然后，主线程需要一些时间(尽管很少)来检查连接并启动一个新线程。back_log值表示在MySQL暂时停止响应新请求之前的短时间内可以堆多少个请求。只有当您预期在短时间内会有大量连接时，才需要增加这个值。 back_log=80 If this is set to a nonzero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk. This option is best used only on systems with minimal resources. 如果将该值设置为非零值，则每隔flush_time秒关闭所有表，以释放资源并将未刷新的数据同步到磁盘。这个选项最好只在资源最少的系统上使用。 flush_time=0 The minimum size of the buffer that is used for plain index scans, range index scans, and joins that do not use 用于普通索引扫描、范围索引扫描和不使用索引执行全表扫描的连接的缓冲区的最小大小。 indexes and thus perform full table scans. join_buffer_size=200M The maximum size of one packet or any generated or intermediate string, or any parameter sent by the mysql_stmt_send_long_data() C API function. 由mysql_stmt_send_long_data() C API函数发送的一个包或任何生成的或中间字符串或任何参数的最大大小 max_allowed_packet=500M If more than this many successive connection requests from a host are interrupted without a successful connection, the server blocks that host from performing further connections. 如果在没有成功连接的情况下中断了来自主机的多个连续连接请求，则服务器将阻止主机执行进一步的连接。 max_connect_errors=100 Changes the number of file descriptors available to mysqld. You should try increasing the value of this option if mysqld gives you the error "Too many open files". 更改mysqld可用的文件描述符的数量。如果mysqld给您的错误是“打开的文件太多”，您应该尝试增加这个选项的值。 open_files_limit=4161 If you see many sort_merge_passes per second in SHOW GLOBAL STATUS output, you can consider increasing the sort_buffer_size value to speed up ORDER BY or GROUP BY operations that cannot be improved with query optimization or improved indexing. 如果在SHOW GLOBAL STATUS输出中每秒看到许多sort_merge_passes，可以考虑增加sort_buffer_size值，以加快ORDER BY或GROUP BY操作的速度，这些操作无法通过查询优化或改进索引来改进。 sort_buffer_size=1M The number of table definitions (from .frm files) that can be stored in the definition cache. If you use a large number of tables, you can create a large table definition cache to speed up opening of tables. The table definition cache takes less space and does not use file descriptors, unlike the normal table cache. The minimum and default values are both 400. 可以存储在定义缓存中的表定义的数量(来自.frm文件)。如果使用大量表，可以创建一个大型表定义缓存来加速表的打开。与普通的表缓存不同，表定义缓存占用更少的空间，并且不使用文件描述符。最小值和默认值都是400。 table_definition_cache=1400 Specify the maximum size of a row-based binary log event, in bytes. Rows are grouped into events smaller than this size if possible. The value should be a multiple of 256. 指定基于行的二进制日志事件的最大大小，单位为字节。如果可能，将行分组为小于此大小的事件。这个值应该是256的倍数。 binlog_row_event_max_size=8K If the value of this variable is greater than 0, a replication slave synchronizes its master.info file to disk. (using fdatasync()) after every sync_master_info events. 如果该变量的值大于0，则复制奴隶将其主.info文件同步到磁盘。(在每个sync_master_info事件之后使用fdatasync())。 sync_master_info=10000 If the value of this variable is greater than 0, the MySQL server synchronizes its relay log to disk. (using fdatasync()) after every sync_relay_log writes to the relay log. 如果这个变量的值大于0,MySQL服务器将其中继日志同步到磁盘。(在每个sync_relay_log写入到中继日志之后使用fdatasync())。 sync_relay_log=10000 If the value of this variable is greater than 0, a replication slave synchronizes its relay-log.info file to disk. (using fdatasync()) after every sync_relay_log_info transactions. 如果该变量的值大于0，则复制奴隶将其中继日志.info文件同步到磁盘。(在每个sync_relay_log_info事务之后使用fdatasync())。 sync_relay_log_info=10000 Load mysql plugins at start."plugin_x ; plugin_y". 开始时加载mysql插件。“plugin_x;plugin_y” plugin_load The TCP/IP Port the MySQL Server X Protocol will listen on. MySQL服务器X协议将监听TCP/IP端口。 loose_mysqlx_port=33060 本篇文章为转载内容。原文链接：https://blog.csdn.net/mywpython/article/details/89499852。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...进行日志收集、分析和索引。在Etcd中，通过设置启动参数--log-format=json，可以使得Etcd产生的日志内容遵循JSON格式规范，方便后续对接日志管理系统或进行大数据分析。

...3.1 第一步：创建索引模式 首先，我们需要确保你的数据已经被正确地存储到Elasticsearch中，并且可以通过Kibana访问。如果还没有创建索引模式，可以按照以下步骤操作： bash 登录Kibana界面 1. 点击左侧菜单栏中的“Management”。 2. 找到“Stack Management”部分，点击“Index Patterns”。 3. 点击“Create index pattern”按钮。 4. 输入你的索引名称（例如 "logstash-"），然后点击“Next step”。 5. 选择时间字段（通常是@timestamp），点击“Create index pattern”完成配置。 > 思考点：这里的关键在于选择合适的索引名称和时间字段。如果你的时间字段命名不规范，后续可能会导致数据无法正确筛选哦！ 3.2 第二步：设置索引生命周期策略 接下来，我们要为索引创建生命周期策略。这是Kibana中最核心的部分，直接决定了数据的保留方式。 示例代码： javascript PUT _ilm/policy/my_policy { "policy": { "phases": { "hot": { "actions": { "rollover": { "max_size": "50gb", "max_age": "30d" } } }, "delete": { "min_age": "1y", "actions": { "delete": {} } } } } } 这段代码的意思是： - 热阶段（Hot Phase）：当索引大小达到50GB或者超过30天时，触发滚动操作。 - 删除阶段（Delete Phase）：超过1年后，自动删除该索引。 > 小贴士：这里的max_size和max_age可以根据你的实际需求调整。比如，如果你的服务器内存较小，可以将max_size调低一点。 3.3 第三步：将策略应用到索引 设置好生命周期策略后，我们需要将其绑定到具体的索引上。具体步骤如下： bash POST /my-index/_settings { "index.lifecycle.name": "my_policy", "index.lifecycle.rollover_alias": "my_index" } 这段代码的作用是将之前创建的my_policy策略应用到名为my-index的索引上。同时，通过rollover_alias指定滚动索引的别名。 --- 4. 实战案例 数据保留策略的实际效果 为了让大家更直观地理解数据保留策略的效果，我特意准备了一个小案例。假设你是一名电商公司的运维工程师，每天都会收到大量的订单日志，格式如下： json { "order_id": "123456789", "status": "success", "timestamp": "2023-09-01T10:00:00Z" } 现在，你想对这些日志进行生命周期管理，具体要求如下： - 最近3个月的数据需要保留。 - 超过3个月的数据自动归档到冷存储。 - 超过1年的数据完全删除。 实现方案： 1. 创建索引模式，命名为orders-。 2. 定义生命周期策略 javascript PUT _ilm/policy/orders_policy { "policy": { "phases": { "hot": { "actions": { "rollover": { "max_size": "10gb", "max_age": "3m" } } }, "warm": { "actions": { "freeze": {} } }, "delete": { "min_age": "1y", "actions": { "delete": {} } } } } } 3. 将策略绑定到索引 bash POST /orders-/_settings { "index.lifecycle.name": "orders_policy", "index.lifecycle.rollover_alias": "orders" } 运行以上代码后，你会发现： - 每隔3个月，新的订单日志会被滚动到一个新的索引中。 - 超过3个月的旧数据会被冻结，存入冷存储。 - 超过1年的数据会被彻底删除，释放存储空间。 --- 5. 总结与展望 通过今天的分享，相信大家对如何在Kibana中设置数据保留策略有了更深的理解。虽然设置过程看似繁琐，但实际上只需要几步就能搞定。而且啊，要是咱们好好用数据保留这招，不仅能让系统跑得更快、更顺畅，还能帮咱们把那些藏在数据里的宝贝疙瘩给挖出来，多好呀！ 最后，我想说的是，技术学习是一个不断探索的过程。如果你在实践中遇到问题，不妨多查阅官方文档或者向社区求助。毕竟，我们每个人都是技术路上的探索者，一起努力才能走得更远！ 好了，今天的分享就到这里啦！如果你觉得这篇文章有用，记得点赞支持哦~咱们下次再见！

...example/; index index.html index.htm; if ($http_user_agent ~ "Trident|MSIE") { rewrite ^(.) https://www.example.com$1 permanent; } } } 在这个代码中，我们首先监听了80端口，然后设置了服务器名。接着，我们指定了项目的根目录和索引文件。最后，我们使用if语句检查用户的浏览器类型。如果用户的浏览器是IE的话，我们就将其重定向到https://www.example.com。 五、总结 总的来说，通过在Nginx下部署Vue项目，并且使用Nginx的URL重写功能，我们可以很好地避免用户访问旧页面，让他们能够尽快地看到新版本的内容。虽然这事儿可能需要咱们掌握点技术，积累点经验，但只要我们把相关的知识、技巧都学到手，那妥妥地就能搞定它。 在未来的工作中，我会继续深入研究Nginx和其他相关技术，以便能够更好地服务于我的客户。我觉得吧，只有不断学习和自我提升，才能真正踩准时代的鼓点，然后设计出更棒的产品、提供更贴心的服务。你看，就像跑步一样，你得不停向前跑，才能不被大部队甩开，对不对？

...作为一款强大的全文搜索引擎，其核心功能在于高效地存储和检索文本数据。不过，当你看到好多用户一起挤在同一个索引上操作的时候，你会发现，确保数据安全，给不同权限的用户分配合适的“查看范围”，这可真是个大问题，而且是相当关键的一步！本文将深入探讨如何在多用户场景下集成Lucene，并实现基于角色的权限控制。 二、Lucene基础知识 首先，让我们回顾一下Lucene的基本工作原理。Lucene的核心组件包括IndexWriter用于创建和更新索引，IndexReader用于读取索引，以及QueryParser用于解析用户输入的查询语句。一个简单的索引创建示例： java import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.store.Directory; // 创建索引目录 Directory directory = FSDirectory.open(new File("indexdir")); // 分析器配置 Analyzer analyzer = new StandardAnalyzer(); // 索引配置 IndexWriterConfig config = new IndexWriterConfig(analyzer); config.setOpenMode(IndexWriterConfig.OpenMode.CREATE); // 创建索引写入器 IndexWriter indexWriter = new IndexWriter(directory, config); // 添加文档 Document doc = new Document(); doc.add(new TextField("content", "This is a test document.", Field.Store.YES)); indexWriter.addDocument(doc); // 关闭索引写入器 indexWriter.close(); 三、权限模型的构建 对于多用户场景，我们通常会采用基于角色的权限控制模型（Role-Based Access Control, RBAC）。例如，我们可以为管理员（Admin）、编辑（Editor）和普通用户（User）定义不同的索引访问权限。这可以通过在索引文档中添加元数据字段来实现： java Document doc = new Document(); doc.add(new StringField("content", "This is a protected document.", Field.Store.YES)); doc.add(new StringField("permissions", "Admin,Editor", Field.Store.YES)); // 添加用户权限字段 indexWriter.addDocument(doc); 四、权限验证与查询过滤 在处理查询时，我们需要检查用户的角色并根据其权限决定是否允许访问。以下是一个简单的查询处理方法： java public List search(String query, String userRole) { QueryParser parser = new QueryParser("content", analyzer); Query q = parser.parse(query); IndexSearcher searcher = new IndexSearcher(directory); Filter filter = null; if (userRole.equals("Admin")) { // 对所有用户开放 filter = Filter.ALL; } else if (userRole.equals("Editor")) { // 只允许Editor和Admin访问 filter = new TermFilter(new Term("permissions", "Editor,Admin")); } else if (userRole.equals("User")) { // 只允许User访问自己的文档 filter = new TermFilter(new Term("permissions", userRole)); } if (filter != null) { TopDocs results = searcher.search(q, Integer.MAX_VALUE, filter); return searcher.docIterator(results.scoreDocs).toList(); } else { return Collections.emptyList(); } } 五、权限控制的扩展与优化 随着用户量的增长，我们可能需要考虑更复杂的权限策略，如按时间段或特定资源的访问权限。这时，可以使用更高级的权限管理框架，如Spring Security与Lucene集成，来动态加载和管理角色和权限。 六、结论 在多用户场景下，Apache Lucene的强大检索能力与权限控制相结合，可以构建出高效且安全的数据管理系统。通过巧妙地设计索引布局，搭配上灵动的权限管理系统，再加上精准无比的查询筛选机制，我们能够保证每个用户都只能看到属于他们自己的“势力范围”内的数据，不会越雷池一步。这不仅提高了系统的安全性，也提升了用户体验。当然，实际应用中还需要根据具体需求不断调整和优化这些策略。 记住，Lucene就像一座宝库，它的潜力需要开发者们不断挖掘和适应，才能在各种复杂场景中发挥出最大的效能。

...et" href="index.css"><script src="index.js"></script></head><body><div id="pop_star"><div id="targetScore">Target Score : 2000</div><div id="nowScore">Current Score : 0</div><div id="selectScore">0 blocks 0 scores</div></div></body></html> css / 常用页面初始化 /{margin:0;padding:0;}html,body{height: 100%;width: 100%;}pop_star{height: 100%;width: 500px;margin: 0 auto;background: url("./pic/background.png");position: relative; /父元素，为了使之后的子元素都相对于他进行定位，此处设为relative/color:white;background-size: cover; /使背景图片保持比例覆盖整个背景区域/}/ 以下三个元素为现实面板，其样式相同 /targetScore{width: 100%;height: 50px;position: relative;line-height: 50px;text-align: center;font-size: 20px;background-size: cover;}nowScore{width: 100%;height: 50px;position: relative;line-height: 50px;text-align: center;font-size: 20px;background-size: cover;}selectScore{width: 100%;height: 50px;position: relative;line-height: 50px;text-align: center;font-size: 20px;background-size: cover;opacity:0;/不透明度/} js var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.position = "absolute"; //相对于背景绝对定位temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function refresh(){ //重绘画板，每次鼠标点击后刷新for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){squareSet[i][j].style.backgroundImage = "url(./pic/" + squareSet[i][j].num + ".png)"squareSet[i][j].style.left = squareSet[i][j].col squareWidth + "px"; // 别忘了加"px"squareSet[i][j].style.bottom = squareSet[i][j].row squareWidth + "px";} }}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面for(var i = 0 ; i < boardWidth; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 效果 第二阶段：鼠标选中后，闪烁 只有JavaScript需要修改 var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息var baseScore = 5; //第一块的分数var stepScore = 10; //每多一块的累加分数var totalScore = 0; //当前总分var targetScore = 1500; //目标分var choose = []; //选中的连通小方块var timer = null; //闪烁定时器var flag = true; //锁，防止点击事件中响应其他点击或移入时间var tempSquare = null; //临时方块function refresh(){for (var i = 0; i < squareSet.length; i++) {for (var j = 0; j < squareSet[i].length; j++) {squareSet[i][j].style.background="url(pic/"+squareSet[i][j].num+".png)"squareSet[i][j].style.left=squareSet[i][j].colsquareWidth+"px";squareSet[i][j].style.bottom=squareSet[i][j].rowsquareWidth+"px";} }}function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.position = "absolute"; //相对于背景绝对定位temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function goBack(){ //还原样式if(timer != null){ //清空计时器clearInterval(timer);}for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){squareSet[i][j].style.border = "0px solid white";squareSet[i][j].style.transform = "scale(0.95)";} }}function checkLinked(square , arr){ // 递归连通图算法arr.push(square); // 将当前方块放入选中数组中// check leftif( square.col > 0 && //未到边界squareSet[square.row][square.col - 1].num == square.num && //颜色相同arr.indexOf(squareSet[square.row][square.col - 1]) == -1) { //不在choose中，避免循环判断checkLinked(squareSet[square.row][square.col - 1] , arr);}// check rightif( square.col < boardWidth - 1 &&squareSet[square.row][square.col + 1].num == square.num &&arr.indexOf(squareSet[square.row][square.col + 1]) == -1) {checkLinked(squareSet[square.row][square.col + 1] , arr);}// check upif( square.row < boardWidth - 1 &&squareSet[square.row + 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row + 1][square.col]) == -1) {checkLinked(squareSet[square.row + 1][square.col] , arr);}// check downif( square.row > 0 &&squareSet[square.row - 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row - 1][square.col]) == -1) {checkLinked(squareSet[square.row - 1][square.col] , arr);} }function flicker(arr){ // 选中连通的小方块可以闪烁var num = 0;timer = setInterval(function(){for(var i = 0 ; i < arr.length ; i ++){arr[i].style.border = "3px solid BFEFFF";//有个框arr[i].style.transform = "scale(" + (0.9 + (0.05 Math.pow(-1 , num))) + ")";//一闪一闪}num ++; // 注意这里所采用的数学技巧，仍然使用transform:scale(val)来进行缩放。},300);//闪烁的时间}function mouseOver(obj){ //鼠标移入区域响应// 还原所有样式goBack();// 检查相邻choose = [];checkLinked(obj , choose);// 闪烁flicker(choose);// 显示分数selectScore();}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面document.getElementById('targetScore').innerHTML = "Target Score : " + targetScore; //显示目标分数用innerHTML// 循环初始化星星区域for(var i = 0 ; i < boardWidth ; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);// 鼠标移入事件square.onmouseover = function(){mouseOver(this);}squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 效果2.1 加入这段代码，便会计算闪烁方块得分 function selectScore(){ //可以显示当前选中小方块的得分var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}document.getElementById('selectScore').innerHTML = choose.length + " blocks " + score + " points";document.getElementById('selectScore').style.opacity = 1;// 设置时间间隔1秒后显示消失的过渡动画setTimeout(function(){document.getElementById('selectScore').style.opacity = 0;document.getElementById('selectScore').style.transition = "opacity 1s";},1000);} 完整代码为： var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息var baseScore = 5; //第一块的分数var stepScore = 10; //每多一块的累加分数var totalScore = 0; //当前总分var targetScore = 1500; //目标分var choose = []; //选中的连通小方块var timer = null; //闪烁定时器var flag = true; //锁，防止点击事件中响应其他点击或移入时间var tempSquare = null; //临时方块function refresh(){for (var i = 0; i < squareSet.length; i++) {for (var j = 0; j < squareSet[i].length; j++) {squareSet[i][j].style.background="url(pic/"+squareSet[i][j].num+".png)"squareSet[i][j].style.left=squareSet[i][j].colsquareWidth+"px";squareSet[i][j].style.bottom=squareSet[i][j].rowsquareWidth+"px";} }}function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.position = "absolute"; //相对于背景绝对定位temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function goBack(){ //还原样式if(timer != null){ //清空计时器clearInterval(timer);}for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){squareSet[i][j].style.border = "0px solid white";squareSet[i][j].style.transform = "scale(0.95)";} }}function checkLinked(square , arr){ // 递归连通图算法arr.push(square); // 将当前方块放入选中数组中// check leftif( square.col > 0 && //未到边界squareSet[square.row][square.col - 1].num == square.num && //颜色相同arr.indexOf(squareSet[square.row][square.col - 1]) == -1) { //不在choose中，避免循环判断checkLinked(squareSet[square.row][square.col - 1] , arr);}// check rightif( square.col < boardWidth - 1 &&squareSet[square.row][square.col + 1].num == square.num &&arr.indexOf(squareSet[square.row][square.col + 1]) == -1) {checkLinked(squareSet[square.row][square.col + 1] , arr);}// check upif( square.row < boardWidth - 1 &&squareSet[square.row + 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row + 1][square.col]) == -1) {checkLinked(squareSet[square.row + 1][square.col] , arr);}// check downif( square.row > 0 &&squareSet[square.row - 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row - 1][square.col]) == -1) {checkLinked(squareSet[square.row - 1][square.col] , arr);} }function flicker(arr){ // 选中连通的小方块可以闪烁var num = 0;timer = setInterval(function(){for(var i = 0 ; i < arr.length ; i ++){arr[i].style.border = "3px solid BFEFFF";//有个框arr[i].style.transform = "scale(" + (0.9 + (0.05 Math.pow(-1 , num))) + ")";//一闪一闪}num ++; // 注意这里所采用的数学技巧，仍然使用transform:scale(val)来进行缩放。},300);//闪烁的时间}function selectScore(){ //可以显示当前选中小方块的得分var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}document.getElementById('selectScore').innerHTML = choose.length + " blocks " + score + " points";document.getElementById('selectScore').style.opacity = 1;// 设置时间间隔1秒后显示消失的过渡动画setTimeout(function(){document.getElementById('selectScore').style.opacity = 0;document.getElementById('selectScore').style.transition = "opacity 1s";},1000);}function mouseOver(obj){ //鼠标移入区域响应// 还原所有样式goBack();// 检查相邻choose = [];checkLinked(obj , choose);// 闪烁flicker(choose);// 显示分数selectScore();}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面document.getElementById('targetScore').innerHTML = "Target Score : " + targetScore; //显示目标分数用innerHTML// 循环初始化星星区域for(var i = 0 ; i < boardWidth ; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);// 鼠标移入事件square.onmouseover = function(){mouseOver(this);}squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 效果2.2 第三阶段：消灭星星（只消灭一次） 只消除选中的星星，但是不会掉下来。 在function init(){}里面添加以下代码： // 鼠标点击事件square.onclick = function(){//为移除增加一个延迟动画，为了防止闭包，这里采用立即执行函数for(var i = 0 ; i < choose.length ; i ++){(function(i){setTimeout(function(){squareSet[choose[i].row][choose[i].col] = null; //为状态数组置空table.removeChild(choose[i]); //将其从桌面上移除} , i 100);})(i);} } 效果 使得星星移动（原作者这里出现错误） function move(){//纵向下落，采用快慢指针算法for(var i = 0 ; i < boardWidth ; i ++){var pointer = 0; //慢指针for(var j = 0 ; j < boardWidth ; j ++){if(squareSet[j][i] != null){ //按行遍历if(pointer != j){ //快慢指针不同步说明中间有空元素squareSet[pointer][i] = squareSet[j][i]; //慢指针设成快指针元素squareSet[j][i].row = pointer;squareSet[j][i] = null; //快指针处置空}pointer ++; //该行非空时慢指针增加} }} 完整代码如下： var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息var baseScore = 5; //第一块的分数var stepScore = 10; //每多一块的累加分数var totalScore = 0; //当前总分var targetScore = 1500; //目标分var choose = []; //选中的连通小方块var timer = null; //闪烁定时器var flag = true; //锁，防止点击事件中响应其他点击或移入时间var tempSquare = null; //临时方块function refresh(){for (var i = 0; i < squareSet.length; i++) {for (var j = 0; j < squareSet[i].length; j++) {squareSet[i][j].style.background="url(pic/"+squareSet[i][j].num+".png)"squareSet[i][j].style.left=squareSet[i][j].colsquareWidth+"px";squareSet[i][j].style.bottom=squareSet[i][j].rowsquareWidth+"px";} }}function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.position = "absolute"; //相对于背景绝对定位temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function goBack(){ //还原样式if(timer != null){ //清空计时器clearInterval(timer);}for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){squareSet[i][j].style.border = "0px solid white";squareSet[i][j].style.transform = "scale(0.95)";} }}function checkLinked(square , arr){ // 递归连通图算法arr.push(square); // 将当前方块放入选中数组中// check leftif( square.col > 0 && //未到边界squareSet[square.row][square.col - 1].num == square.num && //颜色相同arr.indexOf(squareSet[square.row][square.col - 1]) == -1) { //不在choose中，避免循环判断checkLinked(squareSet[square.row][square.col - 1] , arr);}// check rightif( square.col < boardWidth - 1 &&squareSet[square.row][square.col + 1].num == square.num &&arr.indexOf(squareSet[square.row][square.col + 1]) == -1) {checkLinked(squareSet[square.row][square.col + 1] , arr);}// check upif( square.row < boardWidth - 1 &&squareSet[square.row + 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row + 1][square.col]) == -1) {checkLinked(squareSet[square.row + 1][square.col] , arr);}// check downif( square.row > 0 &&squareSet[square.row - 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row - 1][square.col]) == -1) {checkLinked(squareSet[square.row - 1][square.col] , arr);} }function flicker(arr){ // 选中连通的小方块可以闪烁var num = 0;timer = setInterval(function(){for(var i = 0 ; i < arr.length ; i ++){arr[i].style.border = "3px solid BFEFFF";//有个框arr[i].style.transform = "scale(" + (0.9 + (0.05 Math.pow(-1 , num))) + ")";//一闪一闪}num ++; // 注意这里所采用的数学技巧，仍然使用transform:scale(val)来进行缩放。},300);//闪烁的时间}function selectScore(){ //可以显示当前选中小方块的得分var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}document.getElementById('selectScore').innerHTML = choose.length + " blocks " + score + " points";document.getElementById('selectScore').style.opacity = 1;// 设置时间间隔1秒后显示消失的过渡动画setTimeout(function(){document.getElementById('selectScore').style.opacity = 0;document.getElementById('selectScore').style.transition = "opacity 1s";},1000);}function mouseOver(obj){ //鼠标移入区域响应// 还原所有样式goBack();// 检查相邻choose = [];checkLinked(obj , choose);// 闪烁flicker(choose);// 显示分数selectScore();}function move(){//纵向下落，采用快慢指针算法for(var i = 0 ; i < boardWidth ; i ++){var pointer = 0; //慢指针for(var j = 0 ; j < boardWidth ; j ++){if(squareSet[j][i] != null){ //按行遍历if(pointer != j){ //快慢指针不同步说明中间有空元素squareSet[pointer][i] = squareSet[j][i]; //慢指针设成快指针元素squareSet[j][i].row = pointer;squareSet[j][i] = null; //快指针处置空}pointer ++; //该行非空时慢指针增加} }}// 横向移动（当出现一列为空时）for(var i = 0 ; i < squareSet[0].length ;){ //必须注意循环结束条件的判断if(squareSet[0][i] == null){ //逻辑：只需判断最低层为空，该行则全为空for(var j = 0 ; j < boardWidth ; j ++){squareSet[j].splice(i , 1); //splice删除数组squareSet[j]中从i开始的1个元素}continue;//注意移动后i不应改变了}i ++;}refresh();}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面document.getElementById('targetScore').innerHTML = "Target Score : " + targetScore; //显示目标分数用innerHTML// 循环初始化星星区域for(var i = 0 ; i < boardWidth ; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);// 鼠标移入事件square.onmouseover = function(){mouseOver(this);}// 鼠标点击事件square.onclick = function(){//对锁进行控制if(!flag || choose.length == null){return;}flag = false;tempSquare = null;//更新分数var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}totalScore += score;document.getElementById('nowScore').innerHTML = "Current Score : " + totalScore;//为移除增加一个延迟动画，为了防止闭包，这里采用立即执行函数for(var i = 0 ; i < choose.length ; i ++){(function(i){setTimeout(function(){squareSet[choose[i].row][choose[i].col] = null; //为状态数组置空table.removeChild(choose[i]); //将其从桌面上移除} , i 100);})(i);}//需要等星星消除完毕后再移动，故需增加一个延迟setTimeout(function(){move(); //调用移动函数},choose.length 100);}squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 效果（下降成功，但是有点小bug只有部分下降了） 解决方案：只需要在function refresh(){}的双循环里面增加以下代码： if(squareSet[i][j] == null) continue; 完整代码如下： var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息var baseScore = 5; //第一块的分数var stepScore = 10; //每多一块的累加分数var totalScore = 0; //当前总分var targetScore = 1500; //目标分var choose = []; //选中的连通小方块var timer = null; //闪烁定时器var flag = true; //锁，防止点击事件中响应其他点击或移入时间var tempSquare = null; //临时方块function refresh(){for (var i = 0; i < squareSet.length; i++) {for (var j = 0; j < squareSet[i].length; j++) {if(squareSet[i][j] == null) continue; // 点击后数组中可能有空值需要跳过squareSet[i][j].style.background="url(pic/"+squareSet[i][j].num+".png)"squareSet[i][j].style.left=squareSet[i][j].colsquareWidth+"px";squareSet[i][j].style.bottom=squareSet[i][j].rowsquareWidth+"px";} }}function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.position = "absolute"; //相对于背景绝对定位temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function goBack(){ //还原样式if(timer != null){ //清空计时器clearInterval(timer);}for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){squareSet[i][j].style.border = "0px solid white";squareSet[i][j].style.transform = "scale(0.95)";} }}function checkLinked(square , arr){ // 递归连通图算法arr.push(square); // 将当前方块放入选中数组中// check leftif( square.col > 0 && //未到边界squareSet[square.row][square.col - 1].num == square.num && //颜色相同arr.indexOf(squareSet[square.row][square.col - 1]) == -1) { //不在choose中，避免循环判断checkLinked(squareSet[square.row][square.col - 1] , arr);}// check rightif( square.col < boardWidth - 1 &&squareSet[square.row][square.col + 1].num == square.num &&arr.indexOf(squareSet[square.row][square.col + 1]) == -1) {checkLinked(squareSet[square.row][square.col + 1] , arr);}// check upif( square.row < boardWidth - 1 &&squareSet[square.row + 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row + 1][square.col]) == -1) {checkLinked(squareSet[square.row + 1][square.col] , arr);}// check downif( square.row > 0 &&squareSet[square.row - 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row - 1][square.col]) == -1) {checkLinked(squareSet[square.row - 1][square.col] , arr);} }function flicker(arr){ // 选中连通的小方块可以闪烁var num = 0;timer = setInterval(function(){for(var i = 0 ; i < arr.length ; i ++){arr[i].style.border = "3px solid BFEFFF";//有个框arr[i].style.transform = "scale(" + (0.9 + (0.05 Math.pow(-1 , num))) + ")";//一闪一闪}num ++; // 注意这里所采用的数学技巧，仍然使用transform:scale(val)来进行缩放。},300);//闪烁的时间}function selectScore(){ //可以显示当前选中小方块的得分var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}document.getElementById('selectScore').innerHTML = choose.length + " blocks " + score + " points";document.getElementById('selectScore').style.opacity = 1;// 设置时间间隔1秒后显示消失的过渡动画setTimeout(function(){document.getElementById('selectScore').style.opacity = 0;document.getElementById('selectScore').style.transition = "opacity 1s";},1000);}function mouseOver(obj){ //鼠标移入区域响应// 还原所有样式goBack();// 检查相邻choose = [];checkLinked(obj , choose);// 闪烁flicker(choose);// 显示分数selectScore();}function move(){//纵向下落，采用快慢指针算法for(var i = 0 ; i < boardWidth ; i ++){var pointer = 0; //慢指针for(var j = 0 ; j < boardWidth ; j ++){if(squareSet[j][i] != null){ //按行遍历if(pointer != j){ //快慢指针不同步说明中间有空元素squareSet[pointer][i] = squareSet[j][i]; //慢指针设成快指针元素squareSet[j][i].row = pointer;squareSet[j][i] = null; //快指针处置空}pointer ++; //该行非空时慢指针增加} }}// 横向移动（当出现一列为空时）for(var i = 0 ; i < squareSet[0].length ;){ //必须注意循环结束条件的判断if(squareSet[0][i] == null){ //逻辑：只需判断最低层为空，该行则全为空for(var j = 0 ; j < boardWidth ; j ++){squareSet[j].splice(i , 1); //splice删除数组squareSet[j]中从i开始的1个元素}continue;//注意移动后i不应改变了}i ++;}refresh();}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面document.getElementById('targetScore').innerHTML = "Target Score : " + targetScore; //显示目标分数用innerHTML// 循环初始化星星区域for(var i = 0 ; i < boardWidth ; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);// 鼠标移入事件square.onmouseover = function(){mouseOver(this);}// 鼠标点击事件square.onclick = function(){//对锁进行控制if(!flag || choose.length == null){return;}flag = false;tempSquare = null;//更新分数var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}totalScore += score;document.getElementById('nowScore').innerHTML = "Current Score : " + totalScore;//为移除增加一个延迟动画，为了防止闭包，这里采用立即执行函数for(var i = 0 ; i < choose.length ; i ++){(function(i){setTimeout(function(){squareSet[choose[i].row][choose[i].col] = null; //为状态数组置空table.removeChild(choose[i]); //将其从桌面上移除} , i 100);})(i);}//需要等星星消除完毕后再移动，故需增加一个延迟setTimeout(function(){move(); //调用移动函数},choose.length 100);}squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 第四阶段：消灭全部星星，返回结果 最终完整版代码如下： var table; //游戏桌面var squareWidth = 50; //方块宽高var boardWidth = 10; //行列数var squareSet = []; //方块信息集合（二维数组）每个元素保存该方块的全部信息var baseScore = 5; //第一块的分数var stepScore = 10; //每多一块的累加分数var totalScore = 0; //当前总分var targetScore = 1500; //目标分var choose = []; //选中的连通小方块var timer = null; //闪烁定时器var flag = true; //锁，防止点击事件中响应其他点击或移入时间var tempSquare = null; //临时方块function refresh(){ //重绘画板，每次鼠标点击后刷新for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){if(squareSet[i][j] == null) continue; // 点击后数组中可能有空值需要跳过squareSet[i][j].row = i; //更新当前的行列数squareSet[i][j].col = j;squareSet[i][j].style.backgroundImage = "url(./pic/" + squareSet[i][j].num + ".png)"squareSet[i][j].style.backgroundSize = "cover"; //占满范围squareSet[i][j].style.transform = "scale(0.95)"; //美观效果让不同星星之间留出空隙（缩小至0.95倍大小）squareSet[i][j].style.left = squareSet[i][j].col squareWidth + "px"; // 别忘了加"px"squareSet[i][j].style.bottom = squareSet[i][j].row squareWidth + "px";squareSet[i][j].style.transition = "left 0.3s, bottom 0.3s";} }}function createSquare(value,row,col){ //创建小方块，传入参数为颜色、行、列，初始化时使用。var temp = document.createElement('div'); //创建div dom对象temp.style.height = squareWidth + "px";temp.style.width = squareWidth + "px";temp.style.display = "inline-block"; //需要让对象元素能排列一排temp.style.position = "absolute"; //相对于背景绝对定位temp.style.boxSizing = "border-box"; //重要：不会使增加的边框溢出覆盖到旁边的元素temp.style.borderRadius = "12px";temp.num = value;temp.col = col;temp.row = row;return temp; //返回这个创建出来的对象}function goBack(){ //还原样式if(timer != null){ //清空计时器clearInterval(timer);}for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){if(squareSet[i][j] == null) continue;squareSet[i][j].style.border = "0px solid white";squareSet[i][j].style.transform = "scale(0.95)";} }}function checkLinked(square , arr){ // 递归连通图算法if(square == null) return; // 递归边界arr.push(square); // 将当前方块放入选中数组中// check leftif( square.col > 0 && //未到边界squareSet[square.row][square.col - 1] && //左侧有块squareSet[square.row][square.col - 1].num == square.num && //颜色相同arr.indexOf(squareSet[square.row][square.col - 1]) == -1) { //不在choose中，避免循环判断checkLinked(squareSet[square.row][square.col - 1] , arr);}// check rightif( square.col < boardWidth - 1 &&squareSet[square.row][square.col + 1] &&squareSet[square.row][square.col + 1].num == square.num &&arr.indexOf(squareSet[square.row][square.col + 1]) == -1) {checkLinked(squareSet[square.row][square.col + 1] , arr);}// check upif( square.row < boardWidth - 1 &&squareSet[square.row + 1][square.col] &&squareSet[square.row + 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row + 1][square.col]) == -1) {checkLinked(squareSet[square.row + 1][square.col] , arr);}// check downif( square.row > 0 &&squareSet[square.row - 1][square.col] &&squareSet[square.row - 1][square.col].num == square.num &&arr.indexOf(squareSet[square.row - 1][square.col]) == -1) {checkLinked(squareSet[square.row - 1][square.col] , arr);} }function flicker(arr){ // 选中连通的小方块可以闪烁var num = 0;timer = setInterval(function(){for(var i = 0 ; i < arr.length ; i ++){arr[i].style.border = "3px solid BFEFFF";arr[i].style.transform = "scale(" + (0.9 + (0.05 Math.pow(-1 , num))) + ")";}num ++; // 注意这里所采用的数学技巧，仍然使用transform:scale(val)来进行缩放。},300);}function selectScore(){ //可以显示当前选中小方块的得分var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}if(score == 0) return;document.getElementById('selectScore').innerHTML = choose.length + " blocks " + score + " points";document.getElementById('selectScore').style.opacity = 1;document.getElementById('selectScore').style.transition = null;// 设置时间间隔1秒后显示消失的过渡动画setTimeout(function(){document.getElementById('selectScore').style.opacity = 0;document.getElementById('selectScore').style.transition = "opacity 1s";},1000);}function mouseOver(obj){ //鼠标移入区域响应// 加锁，点击事件过程中不允许其他点击事件与移入事件if(!flag){tempSquare = obj;return;}// 还原所有样式goBack();// 检查相邻choose = [];checkLinked(obj , choose);if(choose.length <= 1){choose = [];return;}// 闪烁flicker(choose);// 显示分数selectScore();}function move(){ //下落移动控制//纵向下落，采用快慢指针算法for(var i = 0 ; i < boardWidth ; i ++){var pointer = 0; //慢指针for(var j = 0 ; j < boardWidth ; j ++){if(squareSet[j][i] != null){ //按行遍历if(pointer != j){ //快慢指针不同步说明中间有空元素squareSet[pointer][i] = squareSet[j][i]; //慢指针设成快指针元素squareSet[j][i].row = pointer;squareSet[j][i] = null; //快指针处置空}pointer ++; //该行非空时慢指针增加} }}// 横向移动（当出现一列为空时）for(var i = 0 ; i < squareSet[0].length ;){ // 注意循环终止条件的判断！！！因为数组长度会更新if(squareSet[0][i] == null){ //逻辑：只需判断最低层为空，该行则全为空for(var j = 0 ; j < boardWidth ; j ++){squareSet[j].splice(i , 1); //splice删除数组squareSet[j]中从i开始的1个元素}continue;//注意移动后i不应改变了}i ++;}refresh();}function isFinish(){ //判断游戏结束flag = true; //重要：需要先解锁，保证后续鼠标事件可以被响应for(var i = 0 ; i < squareSet.length ; i ++){for(var j = 0 ; j < squareSet[i].length ; j ++){if(squareSet[i][j] == null) continue; //遍历每一元素判断连通var temp = [];checkLinked(squareSet[i][j] , temp);if(temp.length > 1) return false; //若有某一元素仍有多块连通，则游戏未结束} }return flag;}function init(){ // JS调用入口table = document.getElementById('pop_star'); // 获取到最外层的父元素作为桌面document.getElementById('targetScore').innerHTML = "Target Score : " + targetScore; //显示目标分数用innerHTML// 循环初始化星星区域for(var i = 0 ; i < boardWidth ; i ++){squareSet[i] = new Array(); //二维数组的创建，对每一个元素new Array()创建新数组for(var j = 0 ; j < boardWidth ; j ++){var square = createSquare(Math.floor(Math.random() 5) , i , j);// 鼠标移入事件square.onmouseover = function(){mouseOver(this);}// 鼠标点击事件square.onclick = function(){//对锁进行控制if(!flag || choose.length == null){return;}flag = false;tempSquare = null;//更新分数var score = 0;for(var i = 0 ; i < choose.length ; i ++){score += (baseScore + i stepScore);}totalScore += score;document.getElementById('nowScore').innerHTML = "Current Score : " + totalScore;//为移除增加一个延迟动画，为了防止闭包，这里采用立即执行函数for(var i = 0 ; i < choose.length ; i ++){(function(i){setTimeout(function(){squareSet[choose[i].row][choose[i].col] = null; //为状态数组置空table.removeChild(choose[i]); //将其从桌面上移除} , i 50);})(i);}//需要等星星消除完毕后再移动，故需增加一个延迟setTimeout(function(){move(); //调用移动函数setTimeout(function(){var judge = isFinish();if(judge){ //游戏达到结束条件if(totalScore > targetScore){alert('Congratulations! You win!');}else{alert('Mission Failed!');} }else{flag = true;choose = [];mouseOver(tempSquare); //处理可能存在的冲突} },300 + choose.length 75); //需要一个判断延迟},choose.length 50);}squareSet[i][j] = square; //必须将新创建的方块放回到数组中table.appendChild(square); //需要将创建的新元素添加到桌面上} }refresh(); //每次页面内容发生变化需要重绘页面}window.onload = function(){init();} // window.onload 保证了在页面全部加载完毕后再执行JS代码 效果 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_56471396/article/details/128681321。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...存中按顺序排列，通过索引进行访问和操作。 列表（List） , 在Python编程语言中，列表是一种有序的可变序列容器，可以容纳任意数量和类型的Python对象。列表使用方括号 来表示，元素之间用逗号分隔。例如，文章中的my_list = 1, 3, 5, 7, 9 就是一个包含整数元素的列表。列表支持多种操作，如添加、删除、修改元素，以及获取长度、查找最大最小值、求和、计算平均值等统计分析操作。 索引（Index） , 在Python列表中，索引是用于定位和访问列表内元素的唯一标识符。列表的索引是从0开始计数的整数，正索引表示从左向右读取元素的位置，而负索引则从右向左计数，-1表示最后一个元素。例如，在代码index = my_list.index(7)中，index变量将被赋值为列表my_list中数字7首次出现的索引位置，即它的索引编号。

...这个文章已经提交给搜索引擎或被搜索引擎已经索引了。 这样当搜索引擎隔一段时间再回来的时候，会发现你的文章被删除了，如果这种情况比较多，会认为你的站点不稳定。 2. 一定会被惩罚吗？ 有时候，对于相对模糊的错误，比如这里的例子，不稳定!=惩罚。 搜索引擎会采用一些积分制的方式衡量是否会惩罚站点，当你违反了条件1，-10分，违反了条件2，-15分....以此类推，当你的犯规分数达到一定的额度，可能就会采取惩罚。 搜索引擎的惩罚算法，我也不了解，只是举着个例子，就当安慰一下手误删除文章的站长！ 3. 如何处理？ 方法一：不能不管吧，至少得返回个友好的报错界面吧 如果页面返回的直接就是nginx的404，这......说不过去吧，说明站点做的不认真，容错比较差，搜索引擎和用户看了都会摇摇头。 所以，至少把“文章不存在”这种错误，封装一下，返回一个有好的界面，友好的提示用户“文章可能被作者删除了，看看其它文章吧！” 至少，在用户看来，这个提示是友好的，毕竟非技术人员看到nginx的404都会认为“呵，破网站，挂了！” 方法二：方法一是个错误，会引擎搜索引擎的反感 啥？你说了半天方法一，还是个错误？ 尤其是你的被删的文章比较多的时候，搜索引擎每次来访，都会提取到文案“文章可能被作者删除了，看看其它文章吧！”，这... 第一，没什么价值，搜索引擎会认为低质量！这很严重 第二，更大的麻烦，这个文字是重复的，搜索引擎会认为你的站点有大量的重复！这很严重 方法三：正确的处理方法是返回404或410 404大家比较熟悉，410是啥，其实和404差不多： 但是二者在seo上的区别，当搜索引擎拿到410后，可能会更快地在索引库中删除被删除的文件。 当然，返回404和410在这里都可以。至少是老实承认问题的态度，让搜索引擎可以根据404或410做出正确的下一步操作。 java代码可以用这个返回404： response.setStatus(HttpServletResponse.SC_NOT_FOUND); 方法四：返回301状态码跳转到另一篇文章 301是跳转，永久性跳转，但这种跳转是被搜索引擎唯一接受、不认为是作弊的跳转。 不要使用302跳转、任何js跳转、meta刷新等方式，都会被搜索引擎认为是作弊哦！ 所以，当文章不存在的时候，使用301跳转到另一篇文章（但最好主体相关的、或另起炉灶新写一篇弥补手误删除的错误），这样，有两个好处： 第一，搜索引擎不会惩罚 第二，会把老文章的权重301传到新文章，一举两得 java代码可以用这个返回301： // response.sendRedirect(getRandomArticleByCategoryHref(category)); // 这种是302 response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); // 这种是301，se唯一认可的非作弊的跳转方式 response.setHeader("Location",新路径); 方法五：死链提交 站长后台都支持死链提交，如果你确定一个url里面的文章确实被删除了，可以手动提交死链。主动承认链接问题。 下图是谷歌站长后台的入口：

...组中的计数值，将对应索引的元素按照升序填充到一个新的已排序集合中。由于其利用了元素的出现频率进行排序，因此在数据范围有限且分布均匀的情况下，具有较高的排序效率，时间复杂度为O(n+k)。 非比较型排序（Non-comparative Sorting） , 非比较型排序算法是指一类不依赖于元素之间相互比较来进行排序的算法，如计数排序、基数排序和桶排序等。这类算法通常通过对元素直接操作或间接统计信息完成排序，相比于比较型排序算法（如快速排序、归并排序），在特定条件下可以达到更优的时间性能。在本文所描述的Python实现的计数排序算法中，排序过程并不涉及元素间的比较，而是通过统计每个元素的出现频次来决定其在输出序列中的位置。 空间效率（Space Efficiency） , 空间效率是衡量算法在运行过程中所需内存资源的一种指标。在讨论排序算法时，空间效率主要关注算法在执行过程中额外占用存储空间的多少。Python实现的计数排序算法的空间效率受到数据范围的影响。当处理的数据范围较大时，需要创建一个与数据范围大小成正比的计数数组，这可能导致较大的内存开销，从而降低了算法的空间效率。在实际应用中，尤其是在处理大规模数据集时，需要权衡排序算法的时间效率和空间效率以选择最合适的解决方案。

...Lucene的开源搜索引擎，能够进行全文搜索、实时分析和索引管理。它的设计理念是提供一种易于扩展、高性能且实时的搜索解决方案。 三、Painless scripting编程实践 在ElasticSearch中，我们可以通过脚本语言进行各种复杂的操作。这就是我要详细介绍的Painless scripting。 四、Painless scripting的基本概念 Painless是ElasticSearch的一种新的脚本语言，它被设计成一种易学易用的语言，可以方便地与ElasticSearch的数据模型集成。 五、Painless scripting的优势 1. 简单易学 Painless script语言的设计目标就是使用户能够快速上手，并且其语法也尽可能接近Java。 2. 高性能 Painless script语言是在JVM上运行的，因此它的性能非常优秀。 3. 安全性 ElasticSearch对Painless script语言进行了严格的安全检查，防止恶意攻击。 六、Painless scripting的应用场景 1. 数据过滤 我们可以使用Painless脚本来过滤出我们需要的数据。 2. 数据转换 如果我们需要对数据进行一些特殊的处理，例如计算某个字段的平均值或者总和，也可以使用Painless脚本来实现。 3. 数据聚合 Painless脚本可以帮助我们对大量的数据进行聚合操作，例如计算某段时间内的日均访问量。 七、Painless scripting的基本语法 1. 变量定义 在Painless脚本中，我们可以使用var关键字来定义变量。 2. 控制结构 Painless脚本支持if/else、for等控制结构。 3. 函数调用 我们可以直接调用ElasticSearch中的函数，例如avg()、sum()等。 4. 异常处理 在Painless脚本中，我们可以使用try/catch来捕获并处理异常。 八、Painless scripting的示例代码 java GET my-index/_search { "script_fields": { "average_price": { "script": { "source": """ Double total = doc['price'].value(); int count = doc['count'].value(); return total / count; """, "lang": "painless" } } } } 在这段代码中，我们使用了Painless脚本来计算文档中价格的平均值。 九、结论 总的来说，Painless scripting是一种强大而灵活的工具，它可以让我们在ElasticSearch中实现许多复杂的功能。学习并熟练掌握Painless scripting这项技能后，我真心相信咱们的工作效率绝对会蹭蹭往上涨，效果显著到让你惊讶。