在我的mall电商实战项目中，有着从商品加入购物车到订单支付成功的一整套功能，这套功能的设计与实现对于有购物需求的网站来说，应该是一套通用设计了。今天给大家介绍下这套功能设计，涵盖购物车、生成确认单、生成订单、取消订单以及支付成功回调等内容，希望对大家有所帮助！

mall项目简介

这里还是简单介绍下mall项目吧，mall项目是一套基于 SpringBoot + Vue + uni-app 的电商系统（Github标星60K），采用Docker容器化部署。包括前台商城项目和后台管理系统，能支持完整的订单流程！涵盖商品、订单、购物车、权限、优惠券、会员、支付等功能，功能很强大！

• 项目地址：github.com/macrozheng/…


• 官方文档：http://www.macrozheng.com

后台管理系统演示

前台商城项目演示

功能设计

这里介绍下从商品加入购物车到订单支付成功的整个流程，涵盖流程的示意图和效果图。

流程示意图

以下是从商品加入购物车到订单支付成功的流程图。

流程效果图

以下是从商品加入购物车到订单支付成功的效果图，可以对照上面的流程示意图查看。

数据库设计

为了支持以上购物流程，整个订单模块的数据库设计如下。

设计要点

接下来介绍下整个购物流程中的一些设计要点，涵盖加入购物车、生成确认单、生成订单、取消订单以及支付成功回调等内容。

加入购物车

功能逻辑

用户将商品加入购物车后，可以在购物车中查看到商品。购物车的主要功能就是存储用户选择的商品信息及计算购物车中商品的优惠。

购物车优惠计算流程

相关注意点

• 购物车中商品优惠金额不会在购物车中体现，要在生成确认单时才会体现；


• 由于商品优惠都是以商品为单位来设计的，并不是以sku为单位设计的，所以必须以商品为单位来计算商品优惠；


• 代码实现逻辑可以参考mall项目中OmsPromotionServiceImpl类的calcCartPromotion方法。

生成确认单

功能逻辑

用户在购物车页面点击去结算后进入生成确认单页面。确认单主要用于用户确认下单的商品信息、优惠信息、价格信息，以及选择收货地址、选择优惠券和使用积分。

生成确认单流程

相关注意点

• 总金额的计算：购物车中所有商品的总价；


• 活动优惠的计算：购物车中所有商品的优惠金额累加；


• 应付金额的计算：应付金额=总金额-活动优惠；


• 代码实现逻辑可以参考mall项目中OmsPortalOrderServiceImpl类的generateConfirmOrder方法。

生成订单

功能逻辑

用户在生成确认单页面点击提交订单后生成订单，可以从订单详情页查看。生成订单操作主要对购物车中信息进行处理，综合下单用户的信息来生成订单。

下单流程

相关注意点

• 
  

  库存的锁定：库存从获取购物车优惠信息时就已经从pms_sku_stock表中查询出来了，lock_stock字段表示锁定库存的数量，会员看到的商品数量为真实库存减去锁定库存；

  
  


• 
  

  优惠券分解金额的处理：对全场通用、指定分类、指定商品的优惠券分别进行分解金额的计算：

  
  
  
  
  • 全场通用：购物车中所有下单商品进行均摊；
  
  
  • 指定分类：购物车中对应分类的商品进行均摊；
  
  
  • 指定商品：购物车中包含的指定商品进行均摊。
  
  
  
  


• 
  

  订单中每个商品的实际支付金额计算：原价-促销优惠-优惠券抵扣-积分抵扣，促销优惠就是购物车计算优惠流程中计算出来的优惠金额；

  
  


• 
  

  订单号的生成：使用Redis来生成，生成规则:8位日期+2位平台号码+2位支付方式+6位以上自增id；

  
  


• 
  

  优惠券使用完成后需要修改优惠券的使用状态；

  
  


• 
  

  代码实现逻辑可以参考mall项目中OmsPortalOrderServiceImpl类的generateOrder方法。

  
  

取消订单

功能逻辑

订单生成之后还需开启一个延时任务来取消超时的订单，用户也可以在订单未支付的情况下直接取消订单。

订单取消流程

相关注意点

• 代码实现逻辑可以参考mall项目中OmsPortalOrderServiceImpl类的cancelOrder方法。

支付成功回调

功能逻辑

前台用户订单支付完成后，第三方支付平台需要回调支付成功接口。

支付成功回调流程

相关注意点

• 代码实现逻辑可以参考mall项目中OmsPortalOrderServiceImpl类的paySuccess方法。

总结

今天给大家介绍了mall项目中整套购物流程的功能设计，其实对于很多网站来说都需要这么一套功能，说它是通用功能也不为过。从本文中大家可以看到，mall项目的整套购物流程设计的还是比较严谨的，考虑到了方方面面，如果你对mall项目整套购物流程实现感兴趣的话可以学习下mall项目的代码。

项目源码地址

github.com/macrozheng/…

一、Java掉到历史最低

从2023年6月开始Java掉到历史最低排到第4位

2023年10月tiobe编程语言排行榜，Java仍然还是排到了第4位，C# 和 Java 之间的差距从未如此之小。

top 10 编程语言1988年~2023年历史排名

引用tiobe官网上TIOBE Software 首席执行官的话：

10 月头条：C# 越来越接近 Java

C# 和 Java 之间的差距从未如此之小。目前，差距仅为 1.2%，如果保持这种趋势，C# 将在大约 2 个月的时间内超越 Java。在所有编程语言中，Java 的跌幅最大，为 -3.92%，C# 的涨幅最大，为 +3.29%（每年）。这两种语言一直在相似的领域中使用，因此二十多年来一直是竞争对手。Java 受欢迎程度下降的主要原因是 Oracle 在 Java 8 之后决定引入付费许可模式。微软在 C# 上采取了相反的做法。过去，C#只能作为商业工具Visual Studio的一部分。如今，C# 是免费且开源的，受到许多开发人员的欢迎。Java 的衰落还有其他原因。首先，Java 语言的定义在过去几年中没有发生太大变化，而其完全兼容的直接竞争对手 Kotlin 更易于使用且免费。——TIOBE Software 首席执行官 Paul Jansen

二、编程语言排行榜

编程语言排行榜是一种用来衡量编程语言的流行度或受欢迎程度的指标，它通常会根据一些数据或标准来对编程语言进行排序和评价。不同的编程语言排行榜可能会有不同的数据来源、计算方法和评估标准，因此它们的结果也可能会有所差异。

目前，最知名和权威的编程语言排行榜之一是 TIOBE 编程社区指数，它由成立于 2000 年 10 月位于荷兰埃因霍温的 TIOBE Software BV 公司创建和维护。TIOBE 编程社区指数通过对网络搜索引擎中涉及编程语言的查询结果数量进行计算，来衡量各种编程语言的受欢迎程度。TIOBE 编程社区指数每个月都会更新一次，并且每年还会评选出一门年度编程语言，表示该门语言在当年的排名中上升幅度最大。除了 TIOBE 编程社区指数之外，还有一些其他的编程语言排行榜，以下是列举的一些编程语言排行榜。

1、TIOBE编程语言排行榜

TIOBE是一家荷兰的编程软件质量评估公司，每月发布一份编程语言排行榜。它使用搜索引擎查询结果、开发者社区活跃度和其他指标来评估编程语言的受欢迎程度。

2023年10月TIOBE编程语言排行榜

2、Stack Overflow开发者调查

Stack Overflow每年进行一次开发者调查，其中包括有关最受欢迎编程语言的信息。Stack Overflow 开发者调查是最权威的编程语言排行榜之一，该调查可以反映全球开发者对编程语言的喜好和使用情况。在选择编程语言时，可以参考该调查的结果，但也需要根据自己的实际需求和开发环境进行综合考虑。

连续三年最受欢迎编程语言排名，可以明显的看出Java的占比在逐年的降低

3、GitHub编程语言趋势榜

GitHub提供了一个编程语言趋势页面，显示了开发者在GitHub上使用的编程语言趋势。虽然这不是正式的排行榜，但反映了实际的开发趋势。

GitHub在趋势榜比较前的基本者是Python或Go的项目

GitHub官网已经去掉了top的排名榜只保留了趋势榜，由一些GitHub的爱好者和贡献者创建和维护的www.github-zh.com的GitHub中文社区网站，是非官方github网站，它旨在为中文用户提供GitHub的相关资讯、教程、交流和协作平台，还可以查到Github项目排行榜。

三、展望Java

可以看到各种编程语言排行榜的数据，虽然会存在片面的情况，但也大体能表现出Java的地位在下降，遥想当年Java是排行榜霸榜老大哥。

虽然Java明显下降，或许正如TIOBE首席执行官说的“Java 受欢迎程度下降的主要原因是 Oracle 在 Java 8 之后决定引入付费许可模式。微软在 C# 上采取了相反的做法。”在这个开放的世界里真正的开源而不是利用开源来测试付费项目才能真正的让大家推崇。

Java的许可模式变化导致用户流失。自从Java 8之后，甲骨文公司决定对Java的商业使用收取费用，这使得一些企业和开发者转向其他免费或开源的语言，如C#、Python等 。

Java的竞争对手不断发展和创新，提供了更多的选择和优势。例如，C#在.NET平台上不断完善和扩展，支持跨平台、混合开发、WebAssembly等技术 ；Python在数据科学、人工智能、Web开发等领域有着广泛的应用和生态 ；Kotlin作为Android官方推荐的语言，兼容Java，并提供了更多的语法糖和功能 。

Java虽然在编程语言排行榜上有所下降，但并不意味着Java就没有前途和价值。Java仍然是一门成熟、稳定、高效、跨平台的语言，拥有庞大的用户群和丰富的生态系统。Oracle作为Mysql、Java等重量级项目的拥有者，也在不断地改进和创新Java，让Java能够适应时代的变化和需求。包括Java 17的免费、Kafka/Spring Boot新版本最低的Java版本为17、Java 21引入协程等，都是Oracle在努力让Java保持竞争力和活力的例证 。

未来在不断的变化，说不定马斯克的美女机器人就真的造出来了。。。

当然，我们也不能忽视其他编程语言的发展和优势，我们应该保持开放和学习的心态，了解不同语言的特点和适用场景，选择最合适的语言来解决问题。编程语言只是工具，重要的是我们能够用它们创造出有价值的产品和服务。

什么，鸭子还能调试代码？什么神奇的鸭子啊。

当然不是了，是鸭子帮你调试，那好像也有点儿厉害。

初听感觉是傻子，再听感觉是玄学。

什么是小黄鸭调试法

当然不是鸭子调试代码了，也不是鸭子帮你调试，其实还是靠你自己的。

小黄鸭调试法（Rubber Duck Debugging）是一种常用于解决编程问题的技巧，不是代码技术层面的技巧。

大致的调试过程是这样的：

1. 首先你写好了代码，或者有些逻辑一直写不出来，然后很有自信或者不自信；


2. 然后你找到一只鸭子，玩具鸭子，或者任意一个电脑旁边的物件；


3. 最后，把你的代码的逻辑尽量详细的讲个上一步找到的对象，比如一只玩具鸭子；


4. 通过讲解的过程，你很有可能发现代码上的漏洞，有时候还能发现隐藏的漏洞；

你还可以拉过旁边的人，对着他讲，前提是保证别人不会打你。

这个过程更像是一种review的过程，而且是那种非常具体的review，只不过是自己 review 自己的代码或逻辑。

它的核心是通过将问题或逻辑用语言描述出来，在这个过程中找到解决问题的线索。

虽然这个方法听起来可能有点奇怪，但它在实际中确实能够帮助很多人解决问题。解释问题的过程可能会强迫你慢下来，更仔细地思考，从而找到之前忽略的问题点。

另外，在进行这一些列操作的过程中，尽量保证周围没有人，不然别人可能觉得你是个傻子。

当然了，这个操作你可以在心里默默进行，也是一样的效果。

各位平时工作中有没有遇见过有人使用小黄鸭调试法呢？我看到这个概念的时候想了一下，好像还真碰到过。之前有同事在那儿写代码，一边写嘴里一边叨咕，也不知道在说啥，还开玩笑说这是不是你们这个星座的特质（某个星座）。

现在想想，人家当时用的是不是小黄鸭调试法呀，只恨当初孤陋寡闻，没有问清楚啊。

内在原理

小黄鸭调试法的内在原理其实是涉及到认知心理学中的一些概念的，并不真的是玄学和沙雕行为。

认知外部化

这是小黄鸭调试法的核心。当你将问题从内心中的思考状态转移到外部表达时，你会更加仔细地思考问题。解释问题需要你将问题的细节和步骤以清晰的语言描述出来，这个过程可以帮助你整理思路，更好地理解问题。

问题表达

描述问题的过程可以迫使你更具体地考虑问题。将问题分解为不同的部分，逐步地解释代码的执行流程，有助于你更好地理解代码中可能的缺陷或错误。

观察问题:

当你通过语言表达问题时，可能会注意到之前忽略的细节。这可能是因为你在描述问题时需要更仔细地审查代码和逻辑，从而让你注意到潜在的问题点。

听觉和口头处理

讲述问题的过程涉及到将问题从书面表达转化为口头表达。听觉和口头处理可以帮助你以不同的方式来理解问题，可能会在你的大脑中触发新的洞察力。

认知切换:

与代码一起工作时，你可能会一直陷入相同的思维模式中，难以看到问题。通过将问题从代码中抽离出来，并通过描述来关注它，你会进行认知切换，从而能够以不同的角度审视问题。

总结起来其实很简单，如果一个知识点你理解了，你一定能给别人讲出来，或者写出来，而且别人能够理解。如果你在讲的时候发现有模棱两可的地方，那说明你还没有百分百理解。

就像我们平时写技术文章一样，有时候碰到一些细节写半天也写不清楚，那就是还没有完全理解。

前段时间看了实习生的新项目，发现他启动不了项目，因为node版本太低，我让他去用nvm来管理node的版本，然后看到他切换版本的时候是这样的，先用nvm下载安装目标的node版本，然后在把安装好的node版本替换掉原先的node路径下的node_modules，而不是用命令行进行版本切换，才发现原来他使用nvm来切换node版本虽然显示切换成功，但全局的node版本一直是不变的，所以才用文件覆盖的方式强制进行解决，对于这个问题进行解决并且梳理

可以直接跳到第四步查看解决方案

1️⃣ 安装nvm

where nvm

找不到nvm路径的朋友可以用这个命令来找到nvm的安装路径，默认的安装路径都是差不多的

2️⃣ 查看目前node版本

可以看到目前的版本是node V16.14.2

3️⃣ nvm安装目标node版本

nvm的主要作用就是用来切换node的版本，为什么要切换node的版本，就是因为你的当前node版本和你要启动的项目不兼容，有两种可能，要么是你的项目太旧，你的node版本相对来说比较高，需要用到向下兼容；另外一种可能就是你项目用到的node比较新，你需要进行升级

先安装需要安装的目标版本，用isntall来安装你需要的对应node版本

回到你的nvm安装路径，就可以看到你已经安装的各种版本的node文件夹

当然也可以用命令行

nvm list

4️⃣ nvm切换到目标node版本

切换到目标node版本使用nvm use

nvm use

查看目前nvm安装了哪些版本 然后use来进行切换

到切换的时候发现了问题，这里无论怎么切换，node的版本依然不会变

可以看到我用的use来切换到15的版本，但是再次查看nvm的node历史版本，可以看到还是位于16.14.2的node版本，明明就是这么顺利的问题，出了一个让人摸不到头脑的事情

5️⃣寻找问题

既然nvm切换版本已经成功，那么为什么node版本不会变，有没有可能根本改的不是同一个node，或者是存在两个node，直到我打开环境变量一看，为啥会存在两个node的路径，可能的原因就是之前的node版本没有删除，node -v一直输出的是安装前的node

原来已经安装了一个node的，全局的node指向的node路径和nvm切换node的路径是不一样的

nvm切换的node是基于他文件夹中的nodejs

点进去看你会发现他也是有一个node.exe的程序的，所以问题是已经找到的了，目前系统上出现了两个node，并且nvm切换的node版本并不是全局的node，因为环境变量已经指向了旧的node，他的版本不会改变，那么nvm去怎么切换都是没有用的

6️⃣解决方案

看了网上的一些解决方案都是要在nvm中新建两个文件夹的方式来解决，但是其实直接把nodejs删除也是一个很直接的办法，先通过where node找到当前的node的安装目录，直接进行删除

最后是通过把另外一个目录的node进行删除，重新看一下node的安装路径，也就是重新执行一下 where node

可以看到在nvm配置正确的情况下是能直接指向nvm下的node的

最后重新切换一下node的版本，也就是上文的操作

PS

我指的手动切换是nvm下载node版本之后手动去替换node_modules，原来大家觉得用nvm use也是手动替换（确实是我的问题），经过评论区广大jym指正，可以尝试一下volta这个工具来进行切换版本，真正做到不用手动替换，后续我会亲自去体验一下并且发文，感谢评论区小伙伴

🙏 感谢您花时间阅读这篇文章！如果觉得有趣或有收获，请关注我的更新，给个喜欢和分享。您的支持是我写作的最大动力！

前言

最近项目需要封装一个图片加载组件，boss让我们实现类似电报的那种效果，直接上图：

就像把大象装入冰箱一样，图片加载拢共有三种状态：loading、success、fail。

首先是loading，电报的实现效果是底部展示blur image, 上面盖了个progress indicator。blur image有三方库可以实现：flutter_thumbhash | Flutter Package (pub.dev),但是这个库有个bug: 它使用到了MemoryImage, 并且MemoryImage的bytes参数每次都是重新生成的，因而无法使用缓存。所以上面的progress刷新时底部的blur image都会不停闪烁。

//MemoryImage

@override

bool operator ==(Object other) {

    if (other.runtimeType != runtimeType) {

      return false;

    }

    return other is MemoryImage

        && other.bytes == bytes

        && other.scale == scale;

}



@override

int get hashCode => Object.hash(bytes.hashCode, scale);

笔者覆写了equals和hashcode方法，通过listEquals方法来比较bytes，考虑到thumb_hash一般数据量都比较小估计不会有性能问题。
也有人给了个一次性比较8个byte的算法【StackOverflow摘抄】😄

/// Compares two [Uint8List]s by comparing 8 bytes at a time.

bool memEquals(Uint8List bytes1, Uint8List bytes2) {

  if (identical(bytes1, bytes2)) {

    return true;

  }



  if (bytes1.lengthInBytes != bytes2.lengthInBytes) {

    return false;

  }



  // Treat the original byte lists as lists of 8-byte words.

  var numWords = bytes1.lengthInBytes ~/ 8;

  var words1 = bytes1.buffer.asUint64List(0, numWords);

  var words2 = bytes2.buffer.asUint64List(0, numWords);



  for (var i = 0; i < words1.length; i += 1) {

    if (words1[i] != words2[i]) {

      return false;

    }

  }



  // Compare any remaining bytes.

  for (var i = words1.lengthInBytes; i < bytes1.lengthInBytes; i += 1) {

    if (bytes1[i] != bytes2[i]) {

      return false;

    }

  }



  return true;

}

图片加载和取消重试

电报在loading的时候可以手动取消下载，这个在Flutter官方Image组件和cached_network_iamge组件都是不支持的，因为在设计者看来既然图片加载失败了，那重试也肯定还是失败(By design)。
extended_image库对cancel和retry做了支持，这里要给作者点赞👍🏻

取消加载

加载图片是通过官方http库来实现的， 核心逻辑是：

final HttpClientRequest request = await httpClient.getUrl(resolved);

headers?.forEach((String name, String value) {

  request.headers.add(name, value);

});

final HttpClientResponse response = await request.close();

if (timeLimit != null) {

  response.timeout(

    timeLimit!,

  );

}

return response;

返回的response是个Stream对象,通过它来获取图片数据

final Uint8List bytes = await consolidateHttpClientResponseBytes(

        response,

        onBytesReceived: chunkEvents != null

            ? (int cumulative, int? total) {

                chunkEvents.add(ImageChunkEvent(

                  cumulativeBytesLoaded: cumulative,

                  expectedTotalBytes: total,

                ));

              }

            : null,

      );

图片加载进度就是通过ImageChunkEvent来获取的，cumulative代表当前已加载的长度，total是总长度，所有图片加载库都是通过它来显示进度的。所以，如何取消呢？这里就需要用到Flutter异步的一个API了：

Future.any(<Future<T>>[Future cancelTokenFuture, Future<Uint8List> imageLoadingFuture])

在加载的时候除了加载图片数据的Future，我们再额外生成一个Future，当需要取消加载的时候只需要后者抛出Error那加载就会直接终止，extended_image就是这么做的：

class CancellationTokenSource {

  CancellationTokenSource._();

  

  static Future<T> register<T>(

      CancellationToken? cancelToken, Future<T> future) {

    if (cancelToken != null && !cancelToken.isCanceled) {

      final Completer<T> completer = Completer<T>();

      cancelToken._addCompleter(completer);

      

      ///CancellationToken负责管理cancel completer

      return Future.any(<Future<T>>[completer.future, future])

          .then<T>((T result) async {

        cancelToken._removeCompleter(completer);

        return result;

      }).catchError((Object error) {

        cancelToken._removeCompleter(completer);

        throw error;

      });

    } else {

      return future;

    }

  }

}

这种取消机制有个问题：虽然上层会捕获抛出的异常终止加载，但是网络请求还是会继续下去直到加载完图片所有数据，我于是翻看了Flutter的API，发现上面提到的解析HttpResponse的方法consolidateHttpClientResponseBytes有个注释：

/// The `onBytesReceived` callback, if specified, will be invoked for every

/// chunk of bytes that is received while consolidating the response bytes.

/// If the callback throws an error, processing of the response will halt, and

/// the returned future will complete with the error that was thrown by the

/// callback. For more information on how to interpret the parameters to the

/// callback, see the documentation on [BytesReceivedCallback].

即onBytesReceived方法如果抛出异常那么就会终止数据传输，所以可以根据chunkEvents是否alive来判断是否需要继续传输，如果不需要就直接抛出异常，从而终止http请求。

重试

图片加载有两种重试：第一种是自动重试，笔者遇到了一个connection closed before full header was received错误，而且是高概率出现，目前没有好的解决办法，加上自动重试机制后好了很多。

第二种就是手动重试，自动重试达到阈值后还是失败，手动触发加载。我这里主要讲第二种，在电报里的展示效果是这样：

这里卡了我好久，主要是我对Flutter的ImageCache了解不深入导致的，首先看几个问题：

1. 页面有一张图片加载失败，退出页面重新进来图片会自动重新加载吗？

答案是不一定，Flutter图片缓存存储的是ImageStreamController对象，这个对象里有一个FlutterErrorDetails? _currentError;属性，当加载图片失败后_currentError会被赋值，所以退出后重进页面虽然会导致页面重新加载，但是获取到的缓存对象有Error，那就会直接进入fail状态。
缓存的清理是个很复杂的问题， ImageStreamCompleter的清理逻辑主要靠两个属性：_listeners和_keepAliveHandles：

List<ImageStreamListener> _listeners = [];



@mustCallSuper

void _maybeDispose() {

    if (!_hadAtLeastOneListener || _disposed || _listeners.isNotEmpty || _keepAliveHandles != 0) {

      return;

    }



    _currentImage?.dispose();

    _currentImage = null;

    _disposed = true;

}

_listerners的add和remove时机和Image组件有关

/// image.dart

/// 加载图片

void _resolveImage() {

    ......

    final ImageStream newStream =

      provider.resolve(createLocalImageConfiguration(

        context,

        size: widget.width != null && widget.height != null ? Size(widget.width!, widget.height!) : null,

      ));

    _updateSourceStream(newStream);

}



void _updateSourceStream(ImageStream newStream) {

    ......

    /// 向ImageStreamCompleter注册Listener

    _imageStream!.addListener(_getListener());

  }

既然有了_listeners那为什么还需要_keepAliveHandles属性呢，原因就是在image组件所在页面不在前台时会移除注册的listerner，如果没有_keepAliveHandles属性那缓存可能会被错误清理：

@override

void didChangeDependencies() {

    _updateInvertColors();

    _resolveImage();



    if (TickerMode.of(context)) {

       ///页面在前台的时候获取最新的ImageStreamCompleter对象

      _listenToStream();

    } else {

      ///页面不在前台移除Listener

      _stopListeningToStream(keepStreamAlive: true);

    }

    super.didChangeDependencies();

}

回到最开始的问题：如果加载失败的图片组件在其他页面不存在，那image组件dispose的时候就会清理掉缓存，第二次进入该页面的时候就会重新加载。反之，如果其他页面也在使用该缓存，那二次进入的时候就会直接fail。

一个很好玩的现象是，假如两个页面在加载同一张图片，那么其中一个页面图片加载失败另外一个页面也会同步失败。

2. 判定加载的是同一张图片

这里的相同很重要，因为它决定了ImageCache的存储，比如笔者自定义一个NetworkImage:

class _NetworkImage extends ImageProvider<_NetworkImage> {



  _NetworkImage(this.url);



  final String url;

  

  @override

  ImageStreamCompleter loadImage(NetworkImage key, ImageDecoderCallback decode);



  @override

  Future<ExtendedNetworkImageProvider> obtainKey();

}

obtainKey一般都会返回SynchronousFuture<_NetworkImage>(this)，它代表的是ImageCache使用的键，ImageCache判断当前是否存在缓存的时候会拿Key和缓存的所有键进行比对，这个时候equals和hashcode就开始起作用了：

@override

bool operator ==(Object other) {

    if (other.runtimeType != runtimeType) {

      return false;

    }

    return other is _NetworkImage

        && other.url == url;

}



@override

int get hashCode => Object.hash(url);

因为我们需要支持取消加载，所以最初我考虑加上cancel token到相同逻辑的判定，但是这会导致同一张图片被不停重复加载，缓存完全失效。

为了解决上面的问题，我对ImageCache起了歪脑筋：能不能在没有加载成功的时候允许并行下载，但是只要有一张图片成功，那后续都可以复用缓存？
如果要实现这个效果，那就必须缓存下所有下载成功的ImageProvider或者对应的CancelToken。下载成功的监听好办，在MultiFrameImageStreamCompleter加个监听就完事。难的是缓存消除的时机判断，ImageCache的缓存机制很复杂(_pendingImages,_cacheImage,_liveImages)，并且没有缓存移除的回调。

最终，我放弃了这个方案，不把cancel token放入ImageProvider的比较逻辑中。

3. 实现图片重新加载

首先，我给封装的图片组件加了个reloadFlag参数，当需要重新加载的时候+1即可：

@override

void didUpdateWidget(OldWidget old) {

    if(old.reloadFlag != widget.reloadFlag) {

        _resolveImage();

    }

}

但是，这个时候不会起作用，因为之前失败的缓存没被清理，ImageProvider的evict方法可实现清理操作。

4. 多图状态管理

我在适配折叠屏的时候发现了一个场景：多页面下载相同图片时有时无法联动，首先看cancel:

• A页面加载图片时使用CancelToken A,新建缓存


• B页面使用CancelToken B, 复用缓存

B的CancelToken完全没用到，所以是cancel不了的。为了解决这个问题，我创建了一个CancelTokenManager，按需生成CancelToken，并在加载成功或失败时清理掉。

然后是重试，多图无法同时触发重试，虽然可以复用同一个ImageStreamCompleter对象，但ImageStream对象却是Image组件单独生成的，所以只能借助状态管理框架或者事件总线来实现同步刷新。

就业的”就“不是让你将就

  是不是大家常常听到家里人唠叨的一句话：“有工作就行了啊，别那么挑剔，你都这么大了，还指望着家里养着你啊” 。还是老师说：“我们要建立优先就业再择业的就业观，不能一直不去就业呀”什么的叭叭叭。

  其实某方面来说他们并没有说错，我们已经成年了，需要独立自主。在漂亮国，到了18岁好像都要分家了吧。不过我们在中国，中国的国情肯定和漂亮国不一样。除此之外中国家庭从小的哭穷式教育，估计让许多孩子都想自己经济独立吧。这个现象导致了大家认为有工作就行了，我管他什么工作呢。

  但是从自身职业发展来讲，这是对自己极其不负责的表现，往往许多人的第一份工作就决定了人生轨迹，不论是以后决定发展的城市，还是以后工作的方向，其实已经早已埋下种子。你说你可以换工作啊，可以跳槽啊，现实往往会打醒你，你以为你没了应届生身份，凭着你那不到一年的工作经验，人家企业看中你什么。所以我们要就业要为自己，同时也要为自己的未来负责，我们要慎之又慎。所以我们要就业不过的选择自己合适的就业不能盲目就业，家长的思想大部分过时了，停留在了上了大学就有好工作的时代。我们只能参照而不能按部就班，对于老师，大部分是为了提高学校就业率完成指标而已，不必要太大理会，当然和你关系好的老师除外，但是相反如果和你关系好他一定会不会让你草草就业的。

择业的”择“也别太择

钱多事少离家近，位高权重责任轻。睡觉睡到自然醒，数钱数到手抽筋。

  说完就业再谈谈择业，相信上面这句话大家都听过，这简直就是梦中情职，所以择业在我看来无非四种：离家近的、工资高的、自己感兴趣的、清闲的。这四种涵盖了大部分职业了吧。所以我们怎么择业，选择一个适合自己的职位对于未来发展是事半功倍的。

  大家选择职业的时候不知道是从哪方面来选择的，首先离家近，相信很多女生都是考虑这个优先吧，感觉男生就是喜欢仗剑走天涯那种🤣。然后考虑清闲的，想想你二十几岁的年龄你还要工作四五十年可能，选个清闲一点的职业不过分吧，最好就是考一个公务员事业编了，实在不行就去央企国企了，当然这种工作大家都想去，虽然工资不高但是福利好啊。再者就是兴趣了，把自己的兴趣培养成自己的职业也是可以的，大学就是很好的时间，选那种课比较少的专业，这里不得不再次吐槽大学课程的无用性。然后自己选一个自己喜欢的职业，比如摄影、博主什么的。不过当喜欢的事变成职业很多人也就不喜欢了，比如电竞职业选手他们天天十几个小时训练打游戏，他们下班还会想打游戏嘛🤣。就是坚持很重要。再再者，有的人说自己天生无感对什么都没兴趣，那么恭喜你和我一样🤣，就是什么的不是很感兴趣，也不讨厌，那么我建议搞钱，选个高薪的职业搞到足够的钱就退休了，当初就是看程序员薪资高入行了，对钱总感兴趣了吧。总而言之择业择业选择自己合适的再就业。

  鱼和熊掌不可兼得。选择离家近的就得忍受小镇的慢节奏，没有快速的地铁，没有好玩的游乐场，有的只是街坊邻居的互相寒暄，没有夜晚的灯红酒绿，只有晚上八九点就安静的大街。选择清闲的公务员，那么就要懂的人情世故，还有每个月几千块钱的工资。选择自己感兴趣的，那么就得忍受孤独，经得起自我怀疑要有坚定的勇气。高工资的不用多说了吧，996，007时间就是金钱，加班是常态，通宵也是偶尔。所以没有哪份职业好坏，选择自己合适的，加油奋斗吧！

离开北京是计划

2013年去的北京，至今整十年，来去匆匆。

几年前就计划好了，赶在孩子上幼儿园之前离开北京，选一个城市定居。

给孩子一个稳定的环境，在这儿上学成长，建立稳定的、属于他自己的朋友圈。人一生中最珍贵的友谊都是在年少无知、天真烂漫的时候建立的。

我们希望孩子从他有正式的社交关系开始-幼儿园阶段，尽早适应一个省市的教育理念和节奏，不要等到中小学、甚至高中阶段突然的打断孩子的节奏，插班到一个陌生的班级。他同时要面临环境和学业的压力，不是每个孩子都能很快调整过来的。

我自己小学阶段换了好几次学校，成绩的波动很明显，不希望孩子再面临同样的风险。

另一方面，基于我们年龄的考虑，也要尽快离开，岁数太大了，换城市跳槽不一定能找到合适的岗位。

19年，基于对移动端市场的悲观，我开始考虑换一个技术方向。2020年公司内转岗，开始从事图形相关技术开发，计划2023年离开北京，是考虑要留给自己3年的时间从零开始积累一个领域的技术。

来深圳市是意外

这几年一直在关注其他城市的"落户政策"、"互联网市场"、"房价"、"政府公共服务"。有几个城市，按优先级：杭州、广州、武汉、深圳。这些都是容易落户的城市，我们想尽快解决户口的困扰。

看几组数据：

可以看到，杭州的房价排在第6位，但是收入和工作机会排进前4，所以首选杭州，性价比之王。

广州的房价和工作收入都排第5，中策。

武汉的工作机会排进前10，但是房价在10名开外，而且老家在那边，占尽地利，下策。

深圳的房价高的吓人，和这个城市提供的医疗、教育太不匹配，下下策。

最后选择深圳是形势所逼，今年行情史上最差，外面的机会很少。我和老婆都有机会内部转岗到深圳，所以很快就决定了。

初识深圳

来之前做了基本的调研，深圳本科45岁以内 + 1个月社保可以落户。我公司在南山，老婆的在福田，落户只能先落到对应的区。

我提前来深圳，一个星期租好了房子，确定了幼儿园。

老婆步行15分钟到公司，孩子步行500米到幼儿园，我步行 + 地铁1小时到公司。

福田和南山的教育资源相对充足，有些中小学名校今年都招不满，租房也能上，比龙华、宝安、龙岗等区要好很多。

听朋友说，在龙华一个很差的公立小学1000个小孩报名，只有500个学位。

有不少房东愿意把学位给租户使用，办理起来也不麻烦，到社区录入租房信息即可。和北京一样，采取学区划分政策，按积分排名录取，非常好的学校也要摇号碰运气。

租房

中介小哥陪我看了三四天房子，把这一片小区都看了个遍。考虑近地铁、近幼儿园、有电梯、装修良好等因素。

我本来想砍200房租，中介说先砍400，不行再加。结果我说少400，房东直接说好。我原地愣住了，之前排练的戏份都用不上了，或许今年行情不好，租房市场也很冷淡吧。

小区后面是小山，比较安静。

深圳的很多小区里都有泳池

夜晚的深圳，高楼林立，给人一种压迫感，和天空格格不入。明亮的霓虹灯，和北京一样忙碌。

对教育的看法

幸运的人一生都被童年治愈，不幸的人一生都在治愈童年--阿德勒

身边的朋友，有不少对孩子上什么学校有点焦虑，因为教育和高考的压力，有好友极力劝阻我来深圳。我认为在能力的范围内尽力就好，坦然面对一切。

焦虑是对自己无能为力的事情心存妄念。 如果一个人能坦然面对结果，重视当下，不虚度每一分每一秒，人生就不应该有遗憾。人生是来看风景的，结局都是一把灰，躺在盒子里，所以不要太纠结一定要结果怎么样。

学校是培养能力的地方，学历决定一个人的下限，性格和价值观决定上限，你终究成要为你想成为的人，不应该在自我介绍时除了学历能拿出手，一无是处。

不少人不能接受孩子比自己差。可是并没有什么科学依据能证明下一代的基因一定优于上一代吧，或许他们只是不能接受孩子比他们差，他们没有面子，老无所依。我天资一般，我也非常能接受孩子天资平庸，这是上天的旨意。

有些父母根本没有做好家庭教育，试图通过卷学校、一次性的努力把培养的责任寄托于学校。挣钱是成就自己，陪伴是成就孩子，成功的父母居中取舍。

陪伴是最好的家庭教育，如果因为工作而疏忽了孩子，我认为这个家庭是失败的，失败的家庭教育会导致家庭后半生矛盾重重，断送了全家人的幸福。

一个人缺少父爱，就缺少勇敢和力量，缺少母爱就缺少细腻与温和，孩子的性格很容易不健全。除非他自己很有天赋，能自己走出童年的阴影。

因为他长大面对的社会关系是复杂的，他需要在性格层面能融入不同的群体。性格不健全的孩子更容易走向偏激、自私、虚伪、或者懦弱，很多心理学家都是自我治疗的过程中，成为心理学大师。

一个人的一生中，学历不好带来的困扰是非常局部的，但是性格带来的问题将困扰其一生，包括工作、交朋结友、娶妻生子，并且还会传染给下一代。

榜样是最好的教育方法，没有人会喜欢听别人讲大道理，言传不如身教。有些人自己过的很可怜，拼命去鸡娃，那不是培养孩子，那是转移压力，过度投资，有赌棍的嫌疑。你自己过的很苦逼，你如何能说服孩子人生的意义是幸福？鸡娃的尽头是下一代鸡娃。

你只有自己充满能量，积极面对人生，你的孩子才会乐观向上；你只有自己持续的阅读、成长，你的孩子才会心悦诚服的学习；你只有自己做到追求卓越，你的孩子才会把优秀当成习惯。

不要给孩子传递一种信号，人生是苦的，要示范幸福的能力，培养孩子积极地入世观。

2023.9.29中秋节早晨，4个月的宝宝在旁边陪伴着我，记录了28岁一路以来的变化与成长。

关于我

5年前端，现定级为中级前端工程师，有一个很可爱的儿子，小名甜筒🍦，同时还有一个富有智慧的妻子，没错！我用了智慧一词，因为她在能力、为人处事、情绪管控以及子女教育方面优于一般人，这是我的荣幸~

职业发展

关于中级这个头衔，我并不是很满意，在我的规划中，五年作为一个成长的阶梯，仅仅在前端这个领域，应该是要成长为高级开发，毕竟人生能有几个黄金五年呢？

晋升

在我前三年的工作经历中，的确走了一些坎坷，在第二年的时候就已经担任了某私企前端leader的角色，在技术并不是特别拔尖的情况下去做管理工作，属实有点困难，毕竟要兼顾的东西多了，难免有些手忙脚乱，加上当时作为一个技术人的性格胜任这份工作，在沟通上还是吃了蛮多亏，说白了就是需要情商，即做事让人感动，说话让人舒服。关于前半句，我是感动了自己，而后半句呢，虽然没有拉仇恨，但还是差强人意！

感悟

当然了，犯错伴随着成长，在我看来这个过程中最大的收获大于自己的情绪管理和思维方式提升。

作为技术人内敛的性格在遇到问题时容易产生自我怀疑，内耗随之产生，而《非暴露沟通》给了我很多启发，不管是在工作或者家庭关系处理中增加了不少润滑油，以至于后面认识我的朋友给我贴了标签：情绪稳定、逆商高！

其实，更大的成长在于第四年，2022~2023年经历了父亲病痛、职业生涯选择和组建家庭。

在2022年初，我背上了房贷，那时候的薪资不高，只有16k左右，而房贷是一个非常吉利的数字：6666，与此同时父亲生病几个月期间让我意识到自己抗风险能力太低，加上自己除了在技术领域关注甚多，对于其他方面一窍不通，谈时事新闻，我不关注；谈房子车子，我不懂；谈商业逻辑，那真是咸菜炖豆腐，不必多言!。

于是对自己的职业生涯重新定位，除了技术管理这条路，我还能够做什么？对于家人，我又有多少时间陪伴？最终，我选择了离职，在一年空窗中，我尝试了其他非技术领域的项目，跟客户谈合作，跟人打交道，到处出差谈客户，而正是在这段经历中，我懂得了几点：

人性不可挑战：利益能够驱使人变的险恶，有些人为了金钱，不断打破自己的原则，触碰别人的底线，最后两败俱伤！

人的一生都在为自己的认知买单：我在房价最高的时候选择了入手，是因为听信于别人说现在不买以后房价更高了啊，谁谁谁买了不久之后涨了xxx倍啊，在没有多选择对比几个楼盘之后就入手，利率5.85%，同时还被忽悠可以返佣金，大概有三四万，当时还眼前一亮，但只是口头约定，并没有白纸黑字立据，随后就比较随意签了一大堆合同，其中包括首付贷利率10%，同时销售承诺免3年物业费，猴子吞大象，亏他张得开嘴，唯独就这次办事没有录音，最后签合同时一口咬定没有这回事，吃了哑巴亏；还有补充协议，写着房产证要在交房后720天之后才能拿到，这是最致命的，真是谢天谢地谢广坤。

与此同时，做技术也是一样，某个阶段因为自身技术能力、认知缺陷在技术选型或方案选择上存在误差，在一段时间之后产生了历史债务，以往业务在小程序框架选型上就栽了跟头，在没有做过多的调研之后选择了一个组内成员比较熟悉的框架，在后面的业务发展中逐渐显得鸡肋，如不支持多端，框架出现断崖式更新，社区不活跃等等问题，所以在技术选型方面，我们需要考虑包括但不限于以下因素：业务发展方向、行业解决方案对比、解决了什么问题、组内成员的熟悉度、社区活跃度等等。

重回技术

看了不少行业，见了不少人，对于一些思维框架也在实际中得到验证，掌握一些思维模型在解决工作生活问题更加快捷，比如MECE法则、结构化思维、透过现象看本质、逻辑链思维等等，站在更高的视角看问题，我重新选择技术道路，在互联网大裁员环境下，基础薪资涨幅也超过40%。着力于以下几点：

• 对于接触新的技术，一上来撸文档或看视频，是一种低效并且不持久的学习方式，零碎的知识点就像是每一个神经元，相互没有连接成网络最终会形成一盘散沙，大脑并不擅长处理这种结构。而要多方面去渗透理解，如发展历史，着重解决哪些问题，相比其他类似技术，优势在哪？从这些角度入手，容易形成自己的知识框架。例如，在node生态中，express解决了什么问题？之后为什么又诞生孪生兄弟koa，两者有什么区别？后起之秀nest凭借什么能够脱颖而出，成为目前最流行企业级框架之一？按照这个逻辑链，梳理形成属于自己的知识体系。


• 源动力，一切行动背后都应该有充分的理由。我的努力工作目的就是在大城市有属于自己的家，想让家人过得更好，让下一代起点高一些，同时摆脱原生家庭因素的影响。在我看来，即便做最基础的工作，都应该思考为什么而做。

生活

生活的琐碎会消磨人的意识，磨平人的棱角，正是因为这样，乐观看待未来的心态决定了一个人成长的速度。

就在前一晚还跟妻子争吵了一番，源于我的原生家庭并没有给予她应该有的尊重和对待，受到的不公平对待，感觉到委屈，这是我作为中间人失责的一方面。

过去的一年中，我们遭受了别人的诋毁、否定和质疑，但最后我们还是走向了婚姻的殿堂，还有了一个很乖、很可爱的宝宝，这是我们最大的欣慰。时间从来不语，但它会回答所有问题！

生活的逐渐变好源于家庭每一个成员的共同努力，很不庆幸在我原生家庭中存在一些负能量的人，她们的内耗能够将家庭其他成员的能量都消耗殆尽，当然啦，我无法改变这些人，但可以通过运动、鸡汤和励志电影不断让自己保持高能量状态，同时减少或不接触这类人，愿我们都能够成为高能量场的人。

总结与展望

失败是成功之母，总结是成功之父。复盘是我成长最大的途径，极客时间中也有关于该话题的专栏，推荐一看。同时，在我看来经历、改变是最宝贵的财富，是我心智成熟的一方面，源于《谁动了我的奶酪？》。

在不久后的将来，当宝宝看到这篇文章的时候，他可以清楚地知道爸爸的过去以及此时所感所悟，所言所想，为他以后的道路再点亮一颗星星⭐️。

引言

好久没有发感触了，之前一直在做讲师授课，接触了好多入门的程序员，有很多感触，但是在做讲师的时候有时候不方便说，在做开发又开始忙，所以就沉淀下来了，忽然今天收到了之前一个学习的小伙伴的消息，心里有些触动，本人也不是一个特别喜欢发朋友圈的人，但是总感觉想说点啥（矫情了，哈哈），所以写写做一个回顾吧。

编程行业从开始到现在被贴上了很多标签: 幸苦，掉头发，工资高，不愁工作等等，这些有好有坏，但是总结起来大多数人对编程行业的认知是：

1、需要一定的学历，尤其对数学和英语要求很高。

2、工作比较累，加班是便饭。

3、收入很可观，10k轻轻松松。

4、岗位比较多，是一个搞高级技术（嘿嘿嘿，之前一个家长和我聊的）的行业。

当然还有很多，但是就是上面这些认知让好多毕业迷茫、家境一般、工作遇到问题的人，把编程行业作为了一个全新开始的选择。于是，就有了市场，有了市场很快就有了资本，有了资本很快就有了营造焦虑氛围的营销策略，然后就有各种各样在掩盖在光鲜下的问题，又得真的很无奈，那么今天就聊聊吧。

问题

1、社会是你做程序员的第一绊脚石

啥意思，啥叫做社会，这里的社会不是一个群居的结构，而是人情世故（嘿嘿嘿），好多小伙伴是转行过来的，老话说的好，人往高处走，水往低处流，大部分转行的小伙伴不是来自于大家认知当中更好的行业（比如：公务员，医生，律师..嘿嘿嘿，扯远了），甚至编程本行业的也很少（程序员自学的能力还是很不错的）,所以大家在学习之前就已经在社会上摸爬滚打了很久，久历人情，好处是好沟通，不好的地方就是真的把人情世故看的比技术更重要了，这一点可能拉低这些小伙伴70%的学习效果，你要明白，程序员这个行业确实也有人情世故，但前提是大家可以在一个水平上，这个水平可以是技术，也可以是职级，但是如果开头就这么琢磨的话，没有一个扎实的编程基础，真的很难立足在这个行业。没有必要的谦让，习惯性的差不多损耗了太多的学习效果了，既然选择编程，首先请把技术学好，哪怕是基础（当然那个行业也会有浑水摸鱼的，但是对于转行的小伙伴来说，概率太低了）

2、学历重要，学力也很重要

编程行业是一个需要终生学习的行业，不论是前端，后端，测试，运维还是其他岗位，如果在做技术就一定需要学习，好多人会说学历不够所以干不了编程，但是在我个人的眼里，学历确实重要，但是并没有完全限制你进入编程行业，因为：

（1）任何行业都是有完整的岗位结构的，需要的高精尖人才是需要的，但是普通的岗位也少不了，编程行业也是如此，有些岗位的学历要求不是很高。

（2）在编程行业除了那些竞争激烈的大厂，自考学历是有一定的市场和认可程度的

但是，在学历背后的学力就不是这样一个概念了，这里想表述的是学习能力，包括：

（1）专注能力，好多小伙伴如果之前有一定的社会经历或者在大学过的比较懒散，在没有聊到学历之前，先决条件就是能静下心来学习，但是很多小伙伴专注力根本不达标，听课走神，练习坐不住...(其实个人感觉任何一个行业，能静下心来做，并且活下来的都不会很差)

（2）学习习惯，这里不贬低学历低的小伙伴，但是不能否认的是，参加高考后获得一个高学历的小伙伴能力不谈，但是99%都有一个很好的学习习惯。比如不会在学习的时候把手机放到旁边，科学的记笔记，有效的复习和预习等等，所以在担心学历之前，请先培养好自己的学习习惯（个人建议，如果真的没有一个好的学习习惯，那么学习的时候就不要在眼前出现多余的东西分散注意力，比如: 课桌上除了听课的电脑，不要有其他的，之前见过的容易分散注意力的：手机，水杯，指尖陀螺，魔方....）

3、不要在没有选择能力的时候做出选择

这里想聊的是一些学习恐慌的小伙伴的惯性，好多小伙伴在选择了一种学习方式（买书，看视频，加入培训班）之后，还会进行类比学习，比如：买了Python的一本基础书，然后再大数据或者小伙伴的推荐下又买了另外一本，或者参加了培训班，又去看其他的教学视频，这些对小白同学的学习伤害会很大，因为，本身对技术没有全面的理解，不同的书，不同的教程传递的教学方法是不一样的，混着来有点像老家喝酒掺着喝，白酒不醉，啤酒不醉，白加啤那么就不一定了（很大概率会醉），所以小白同学最总要的不是再学习的过程当中进行对比，而是可以最快最稳的完成基础感念的学习，在自己脑子当中有了基础概念再做选择。

当然了，还有很多，一次也聊不完，之后有时间再聊吧，今天就先写这么多，欢迎大家讨论交流。

作为一个没有啥家底的小镇做题家，在去年选Offer阶段时，工作强度是我最不看重的一个点，当时觉得自己年轻、身体好、精神足，996算起来一天不过12个小时，去掉吃饭时间，一天也就9到10个小时，完全没有任何问题，对当时热衷于外企、国企、考公的同学非常的不理解，于是毫不犹豫的签了一个外界风评不太佳但是包裹给的相对多的Offer，然后便有了现在的心酸感悟。

入职前的忐忑

在一波三折终于拿到学位证后，怀着忐忑的心入职了。忐忑的原因主要是入职之前我并不知道我要入职什么部门，很怕我一个只会Java的后端被分配去写C++，毕竟Java是最好的语言，打死不学C++（手动狗头）。 也担心被分配到一个没有啥业务复杂度、数据复杂度的业务部门，每天CRUD迎接着产品的一个又一个需求，最后活成了CRUD Boy没有什么技术沉淀。又担心去和钱相关的部门，害怕自己代码出Bug，导致公司产生资损。

就这样忐忑着听完了入职当日上午的培训，中午便被我的mentor接走了，很不幸，我被我的mentor告知，我恰好被分在了和钱最直接相关的部门，我的心陡然沉重起来。

这里给出我最诚挚的建议，选Offer最好选一个实习过的部分，次之就是签了三方后去实习一段时间，如果发现部门的味儿不对或者和自己八字不合，此时还有机会跑路，以很小的代价换一家公司，不然毕业后入职就宛如开盲盒，万一遇到了很不适应的部门，交了社保、几个月的工作经验，到了市场上可谓是爹不疼娘不爱，比着校招时候的境遇差太多了。

熟悉项目的第一个月

得益于和钱相关，我部门的需求都不是很紧急，领导的态度是宁愿需求不上，也不能上出问题。所以每一个需求都没有说产品火急火燎的推动着要上线，都是稳扎稳打的在做，给予了开发比较充足的自测时间。但是呢，另外一方面，由于部门的业务领域比较底层，所以接手的项目往往都已经有了两三年的历史，相信写过代码的同学都知道，写代码的场景中最痛苦的那就是读懂别人的代码然后在别人的基础上进行开发，尤其是读懂几年前已经几经几手的项目代码。

第一个月刚进入公司，只是在熟悉项目代码，没有啥需求上的压力，相对来说还是比较轻松。遇到不熟悉的直接问靠谱的mentor，mentor也给热心的解答还是很幸运的。每天吃完公司订的盒饭。下楼转悠一圈就觉得美滋滋。

这个时候其实觉得，996不过如此嘛，好像也没有啥压力，真不搞不明白有啥可怕的。

进入开发状态的第二个月

在熟悉的差不多后，我就开始慢慢接手业务需求了，坦白的说，由于我接手的项目比较成熟，新接入业务需求往往不需要做什么开发工作，只需要做一些配置项，需求就完成了。 然而呢，作为一个几年的老项目，当然是处处埋的有彩蛋，你永远不知道哪里就会给你来一个惊喜。于是呢，我的工作开始变成，寻找代码中的彩蛋，搞明白各个配置项的含义，以及他们究竟是怎么组合的，然后和上下游联合对数据，发现数据对不上，就需要再埋进项目中一丝一缕的分析。

这个时候已经有些许的压力了，如果因为自己成为整个需求的卡点，那太过意不去了。于是开始每天勤勤恳恳，吃盒饭也没有那么香了，饭后散步的脚步也不再那么的愉悦，这时候开始感受到了肩上的压力。

本来我是坚决第一个离开工位下班，决心整治职场的人，但是往往在debug的路上，不经历的就把下班时间延长了一点又一点。而又由于在北京、上海这种大城市，住在公司旁边往往是一种奢望，导致我每天有较长的通勤时间。工作日一天下来，差不多就是晚上回去睡觉，早上醒来没有多久就出门赶地铁。

日复一日，就有一种流水线上螺丝钉的麻木感，周末往往一觉睡醒就结束了，感觉日子很重复，没有一些自己生活过的痕迹。

努力调整状态的第三个月

积极主动，是《高效能人士的七个习惯》中的第一个习惯，也是我印象最深的一个习惯。既然困难无法克服，那么咱们就要主动解决。

工作中，努力开拓自己的视野，搭理好手中的一亩三分地的同时，仰头看看上游，低头往往下游，对他们的业务也多一些学习，理清楚自己工作的业务价值，同时呢，在当好一名螺丝钉之外，也尝试着找出整个流水线的可优化点和风险点，尝试着给出自己的解决方案，同时积极梳理已有的项目代码的技术难点，是如何通过配置化来应对复杂的业务场景，是如何通过自动重试保证数据一致性。

生活中，周末即使比较累了，但是努力也不再宅在家中，一刷手机一整天，而是尝试着做一些比较有挑战或者更有回忆的事情。比如沿着黄浦江骑行。

比如自己下厨做几个菜

比如邀请三五好友玩个桌游

比如通过图书馆借一些杂书来消遣

对后来人想说的话

部门与部门之间的差异，很有可能比公司之间的都要大，选择Offer尽可能的选一个实习过的、或者比较熟悉的部门，能有效避免开盲盒踩雷的风险。没有绝对完美的公司，即使好评如潮的外企、券商类公司，我仍然有一些不幸运的同学，遇到了很卷的部门，平时要自愿加班或者在公司“学习”。

即使遇到了困境，也需要保持积极良好的心态，退一万步想，即使工作丢了，但是咱们的身心健康不能丢。为了这几斗米，伤了身体，是非常得不偿失的。

在选Offer的时候尽量一步到位，以终为始，如果目标瞄定了二线城市，其实我个人不太建议为了某些原因比如对大厂技术的热衷、对一线城市繁华的向往而选择当北漂沪漂，漂泊在外的日子都比较苦，而且吃这种苦往往是没有啥意义的。

我是日暮与星辰之间，一名努力学习成长的后端练习生，创作不易，求点赞、求关注、求收藏，如果你有什么想法或者求职路上、工作路上遇到了什么问题，欢迎在评论区里和我一起交流讨论。

背景

距离毕业到已经三年多了, 距离实习到现在已经三年半了, 在主管的建议下, 8月17号在公司的研发部门做了
一场关于成长的分享, 从工作方式到技术能力提升对自己三年的成长进行了一个复盘, 幸运的是分享得到的反
馈非常好, 老板看了将录屏在整个研发部进行公布并且推荐大家观看, 这是部门内分享活动以来第一次公示与推荐录
屏的情况, 我自己也感觉非常感慨, 毕业以来, 一直朝着“一年入门, 三年高工、五年资深、七年架构”的目
标前进, 有时候回过头来会发现这一路还是挺有意思的, 借着这样一个平台, 以文字的形式描述出来, 期望
能够给前行路上的各位有一定的帮助

下面的描述中, 为了不暴露个人信息, 对公司名称的描述统一替换为 XX, 涉及到人名的我都会进行打码

一、为什么做这个分享(why)

1.1、原因一

主管说从实习加入XX三年半以来, 看到我成长了很多, 推荐我可以做一下关于个人成长这一块的分享

1.2、原因二

我个人仔细的想了一下, 三年半前加入XX, 当时公司才400多人, 没有一个正式的java团队(公司主c#), 三年半的时间, 公司发展到了750多人, 我经历了java团队从0到1的完整过程(目前已经有3个java团队, 加起来有接近30个java开发), 并且在这三年半的时间, 公司的后端业务项目开始从.net往java迁移, 有大量的重构项目和新的大型项目, 在此期间, 经历了可能有10个以上从0到1的大型项目的落地, 并且这些项目中我个人承担了绝大部分的核心功能开发, 在这些项目的锻炼下, 不管是技术还是工作方式方面, 都有学习到非常多的知识, 借着这样的机会复盘一下, 继续完善自己, 我主观认为这样的经历可能会有一定的参考价值, 期望能够通过这样的一个分享, 能够给一些可能遇到瓶颈或者跟我遇到一样问题的同学一些启发

二、工作方式上的成长及建议

2.1、需求方案的决策

Pre: 遇到问题 / 需求我应该怎么做, 还没有独当一面的能力

Now: 遇到问题 / 需求我思考可以怎么做, 并从自己的角度出发提出方案, 标识每个方案的优缺点, 询问应该怎么做(即使提出的方案都不是最优解, 但是有自己的思考, 并且在遇到更合适的方案时能有一个对比学习)

截图是两个例子, 在我实现功能的时候, 有不同的方案, 在把握不准哪种方案比较合适的情况下, 向主管进行询问, 对可行的方案的优缺点进行分析, 在主管多年的经验下确定最终的实施方案

2.2、需求功能的实现和上线

Pre: 需求处理完, 简单的自测或者压根就不自测, 测试流程走完以后发上线就不管了(在工作过程中其实有遇到许多同事也是这样), 在刚来实习以及刚毕业那段时间, 一个功能编码完以后测试反馈了许多的bug问题, 改了一个旧的出现一个新的, 之前有听过一个段子, 测试听到开发说的最多的是什么(我没改代码 / 网络问题 / 你再试试), 这个段子就在我身上出现了, 当时改一个功能, 连续几次都没改好(因为改完后没有充分验证就提测了), 见下图(2021年的聊天记录)

Now: 需求处理完, 充分的自测, 提测以后多次跟进测试同学的测试情况, 上线后跟进线上是否正常使用, 找产品进行验收流程

Suggest: owner意识、需求从哪里开始就从哪里结束, 回调产生事件的人, 形成闭环

owner意识是主管在小组中提出来的一个工作方式, 是说一个开发, 在多人协作的场景下, 不能只关注自己那一块的功能, 需要对整个流程有充分的了解, 以一个owner的角色参与到项目开发中, 跟进其他端的对接, 把控整个项目的进度, 要做到这个其实是很难的, 需要花费更多的精力, 但是一旦做到了, 对整个项目就有一种非常清晰的感觉, 能够更好的完成多人协作项目的落地, 需求从哪里开始就从哪里结束, 每次一个需求处理完以后, 我会严格按照 自测 -> 提测 -> 联调 -> 督促产品验收 -> 灰度环境发布及验收 -> 正式环境发布及验收 -> 同步所有有关开发自己的功能的发布情况

在这样一个闭环的链路中, 功能的落地和稳定有了非常明显的提高

2.3、句句有回应, 事事有着落

Pre: 忙的时候忘记回消息, 事情多的时候忘记一些临时分配的事情, 遇到的坑重复跳

Now: todoList、QQ置顶, 多检查(防止多次返工), 防止重复的问题重复出现(错别字)

todoList:
我是通过一个txt文件来进行一个记录的(当然有更合适的, 只是用习惯了), 会记录手上的需求有哪些, 每一个的进度是怎么样的, 上线流程是怎么样的, 我给自己定的上线流程中分为以下几步, 并且在上线的过程中严格的按照下面的流程进行操作, 这样极大的提高了上线的稳定性(特别是一些大版本的发布, 有这样的严格流程下, 稳定性有了非常明显的提高)

1、是否有旧数据需要处理

2、是否有sql脚本需要执行

3、是否依赖于其他人的功能

4、是否有单独服务器灰度的需求, 有些业务需要单独一台服务器来进行灰度, 然后通过nginx将部分流量转发过来验收

5、开始灰度, 灰度后产品验收, 全部负载发布完毕后回调需求开始的人, 形成闭环

QQ置顶: 我们公司是采用QQ作为沟通工具的(可能是因为很早之前就是用这个, 即使现在有企业微信, 但是沟通这一块大家都不太倾向于切到企业微信), 当在外面或者遇到其他比较紧急事情时有人找或者发消息, 可能看完就忘记回了, 于是我养成一个习惯, 有人发消息没时间回的, 第一时间置顶, 等有空后再来跟进, 跟进完后取消置顶

防止重复的问题重复出现: 我们需要写周报, 刚开始的时候有出现错别字、格式不正确、周报字数过多的情况(主管规定周报不能超过250个字), 后面为了避免这种情况, 我每次写完都会阅读两遍内容, 防止之前产生的问题重复发生, 每个人都有粗心的时候, 也不能保证不出现错误, 但是我们可以通过一些方式方法来尽量的避免错误的重复发生

2.4、学习别人优秀的地方

人无完人, 比如我有时候说话会比较直接(好吧, 我是直男....), 那时主管就让我在沟通这一块多跟斜对面的同事学习一下, 后面我就观察他的沟通方式, 然后自己从模仿开始, 慢慢的也学会了怎么进行有效的沟通、委婉的拒绝等, 学习别人优秀的地方也是成长中比较重要的一环

2.5、批量接口的重要性

Pre: 对需求的时候遇到一个问题就问一次, 效率低, 刚来实习的时候, 不熟悉业务, 当时接触到一块比较复杂的涉及到购物车优惠计算的业务, 当时跟对方讨论的时候, 遇到一个不懂的就直接去问, 多次打断他的工作, 效率非常低

Now: 对整个需求进行梳理, 整理所有的疑问一次性请教, 效率提高了很多, 也不会容易打断别人的工作(反到现在我经常被别人打断=,=看到了曾经的我....)

2.6、做的事太简单, 没有挑战性

今年带了一个实习生, 刚开始给他分配的工作都是比较简单的, 主要是修bug、小需求, 但是即使是这样简单的功能, 他做的也是磕磕碰碰, 比如代码规范不达标、空指针异常判断不全面、业务涉及到的点想的不全面等等许多瑕疵, 多次需要我来进行一个兜底, 后面他跟HR反馈说太简单没有挑战性, 于是我就分配了一个稍微大的一点需求给他, 结果做的惨不忍睹, 后面他实习结束时这个需求才做到一半, 我转给其他同事帮忙接手....结果那个同事看到代码后对我吐槽了许久....

当时收到反馈后, 我及时的找他进行沟通, 我的观点是他做的每一个简单的需求, 需求的完整稳定上线都是为了给主管建立一个做事靠谱的印象, 如果做事不靠谱, 经常需要他人来进行兜底, 那么谁也不敢把复杂重要的任务交给你做, 公司很多业务都涉及到商家的钱, 一旦这种重要的业务出问题, 那么会给公司造成巨大损失, 其实仔细想想, 自己实习那会也差不多, 想要做很厉害的项目, 用很流行的技术, 但是如果自己给人的感觉是不靠谱的, 那么主管自然就不敢把这些项目交给我了, 明白了这一点后, 当时我毕业一年给主管的目标是一个需求功能下来, 不管大小, 测试反馈的bug不能超过3个, 一个月产生的线上事故不能超过1次, 我努力做到了这一点, 线上事故几乎没发生过, 随之而来的是小组中绝大部分核心的业务、基础组件的开发都由我来处理, 以及一波大的涨薪

2.7、内卷

维基百科: 原是一个社会学概念，指一种文化模式发展到一定水平后，无法突破自身，只能在内部继续发展、复杂化的过程。大约从2018年开始，“内卷”一词在中国大陆变得广为人知，并引申表示付出大量努力却得不到等价的回报，必须在竞争中超过他人的社会文化，包含了恶性竞争、逐底竞争等更为负面的含义。

我们公司965几乎不加班, 所以我们6点会有比较充足的时间, 我一般去楼下吃完饭以后就会回到公司学习, 三年半的时间阅读了大量的源码书籍、学习了许多知识, 个人认为, 深入学习技术, 提高自己其实不属于内卷, 无意义的加班, 内耗等才是内卷, 其他小组也有人说我比较卷, 但是我们小组(包括主管)都是知道我晚上下班后是在公司学习的, 也很少会加班, 借着分享的机会我也跟大家澄清了这样的情况, 并且我们小组的氛围并没有因为我下班后的学习而导致整个小组都晚下班的情况(公司7点左右就基本空了.....)

三、技术能力上的成长及建议

3.1、如何学习

一、我学习一门未接触过的技术时, 会先看视频学习, 建立基本认识, 并且能够从讲师身上学到一些经验, 即先学会简单的使用
二、在了解了基本使用, 并且用起来的情况下, 我会查找跟该技术有关的权威书籍, 对权威书籍的学习是为了建立完整的知识体系

这个学习方式是我从大学以来就保持的, 而我认为这也是对我来说是最合适的学习方式

3.2、打地基-基础知识的重要性

基础知识对一个程序员来说是非常重要的, 个人认为基础越扎实的同学往往在学习技术的时候会吸收的更快, 并且也能够走的更远

一、数据结构, 我学习数据结构的时候, 会手写每个数据结构, 即使是最难的红黑树, 我也手写出来了(当时在大学的时候花了一个下午就为了写一个新增节点和删除节点的方法), 对于数据结构的学习, 我推荐: 恋上数据结构 这套视频, 讲的非常好, 大家如果有兴趣的话可以各显神通的去找找=,=

二、计算机网络, 计算机网络我是通过看视频加书籍的方式来学习的, 视频推荐: 韩立刚, B站就能搜到, 讲的通俗易懂, 我推荐了几个朋友看, 都反馈非常棒, 书籍推荐 计算机网络 第六版(考研408专用)

三、操作系统, 对操作系统的学习, 能够让我们在了解JVM、以及一些底层知识的时候(比如CAS、volatile、synchronize等原理)能够更加的顺利, 他们都是依赖于操作系统相关的知识来的, 视频我推荐: 哈工大的计算机操作系统, B站能搜到, 书籍推荐计算机操作系统(考研408专用)

四、汇编语言, 如果有看过深入理解Java虚拟机这本书, 那么里面就有出现跟汇编相关的话术, 如果对汇编有所了解, 能够亲身的体验到寄存器操作、中断的原理等, 这些在学习操作系统等知识的时候必然会遇到的话术, 视频我推荐推荐: 小甲鱼, B站就能搜到, 书籍我推荐(汇编语言(第3版) 王爽)

五、设计模式, 刚开始写代码的时候, 会一个方法写很多逻辑, 就像流水账一样, 一直写下去, 没有考虑复用等情况, 通过学习设计模式, 我们可以写出更加优雅的代码, 模板方法、单例、工厂等模式的使用能够使得我们的代码阅读性更高、扩展性更强, 学会了设计模式的情况下, 再去看自己之前写的代码就会发现还能写的更好! 并且有了这个知识的基础上, 我们去看一些框架源码的时候会更加顺利, 框架源码用到设计模式的时候命名都是通俗易懂的, 看到名字就知道用了什么模式, 就像程序员之前互相沟通一样, 这个我没有看视频, 我看的是 HeadFirst设计模式 这本书籍, 通过一些生动形象的例子, 把设计模式讲活了...

3.3、创造核心竞争力-不停留在只会用的地步

java开发往往离不开spring的生态系统, 框架开发出来就是给人更加方便开发功能用的, 如果仅仅会用, 那么在遇到一些问题的时候会无从下手, 三年半的时候, 我阅读了spring、springmvc、mybatis、springboot、springcloud等框架的源码, 通过书籍加视频的方式深入的了解了这些框架的原理, 看这些框架源码的时候, 不纠结于一些边线知识, 只管主线流程, 了解主线流程后, 我发现后续遇到问题时, 我能非常自信的跟进源码去排查问题, 在第四章节中我会整理每一个框架我都是通过哪些书籍来深入学习的

3.4、学以致用-尝试输出(github / 博客 / 分享)

学习一个知识, 如果仅仅看了一遍书 / 看了一遍视频, 那么可能过几天就会忘记了, 一般我是通过看视频 -> 记笔记 -> 看书 -> 对书中的知识点进行整理笔记, 笔记采用类似于给他人讲解的方式来记录 -> 将笔记记录在github 或者 以博客的形式分享出来, 在这样的链路下, 我每一步都能更加深刻的学习到知识点, 有时候看书看懂了不代表真懂了, 真正用笔记来描述的时候会发现是磕磕碰碰的, 与此同时, 将这些磕磕碰碰的知识去再次学习, 那么对整个知识点就会有更加全新的认识, 大家也可以看到, 我的掘金的博客是从2020年就开始写了, 都是我个人的口头描述转为文字描述

3.5、有枪不用和无枪可用

在掌握了工作中需要的知识点的情况下, 我们需要去学习流行的技术, 防止自己落伍, 技术的迭代更新是非常快的, 学习这些技术, 往往会给自己带来意想不到的结果

一年前公司我深入的去研究了eureka、zuul等springcloud组件的原理, 后面幸运的是, 公司有一个私有化部署的项目, 主管的计划是用微服务来搭建, 这个项目需要考虑到客户的资源,
有些客户可能预算比较高, 我们就可以提供一套完整的微服务来运行, 有些客户预算比较低, 那么可能最多就跑3-4个java项目, 于是主管的要求是我们的微服务功能, 需要能够满足上述的情况,
能够非常方便的将一个或者多个服务合并成一个服务, 并且自由搭配

正是因为我有对这些组件的深入了解, 我从源码层次提供了一套实现方案, 并且是最简单的实现方案, 主要的原理就是控制bean的加载(打包的时候一起打包, 但是不加载到内存)以及内部
rpc调用时的扩展(利用回环地址来尽可能的忽略http请求的花销), 如果我没有对这一块有所掌握, 那么我可能就失去了这样一个非常好的锻炼机会了

四、从成长的曲线来看侧重点

作者：山猎

茶百道是四川成都的本土茶饮连锁品牌，创立于 2008 年 。经过 15 年的发展，茶百道已成为餐饮标杆品牌，全国门店超 7000 家，遍布全国 31 个省市，实现中国大陆所有省份及各线级城市的全覆盖。2021 年 3 月 31 日，在成渝餐·饮峰会中，茶百道斩获“2021 成渝餐·饮标杆品牌奖”。2021 年 8 月，入选艾媒金榜（iiMedia Ranking）最新发布《2021 年上半年中国新式茶饮品牌排行 Top15》。2023 年 6 月 9 日，新茶饮品牌“茶百道”获得新一轮融资，由兰馨亚洲领投，多家知名投资机构跟投，估值飙升至 180 亿元。

今年 4 月，茶百道在成都总部举行了品牌升级发布会，宣布门店数突破 7000 家。根据中国连锁经营协会的数据，截至 2020 年、2021 年以及 2022 年 12 月 31 日，茶百道门店数量分别为 2,240 间、5,070 间以及 6,532 间，疫情并没有拖慢其扩张步伐。

随着业务规模的急速扩展，茶百道全面加速推进数字化转型战略。 但由于茶百道部分早期业务系统由外部 SaaS 服务商提供，无法满足线上业务高速增长所带来的大规模、高并发、弹性扩展、敏捷性、可观测等要求。为了满足线上线下门店客户需求与业务增长需要，针对店务、POS、用户交易、平台对接、门店管理、餐饮制作等核心链路服务，茶百道选择全面自研与阿里云云原生能力相结合，推动容器化、微服务化、可观测能力全面升级。

云原生化的业务价值

茶饮行业面临着市场竞争的压力和内部运营效率的提升需求。为了应对这些挑战，阿里云与茶百道一起完成云原生上云的转型，开启数字化的新征程。

采用容器和微服务技术实现了应用的轻量化和高可移植性。让企业可以更灵活地部署、扩展应用，快速响应市场需求，使得企业能够实现应用的高可用性和弹性扩展能力，无论面对突发的高峰访问量还是系统故障，都能保持业务的稳定运行。

引入了持续交付和持续集成的开发方式，帮助企业实现了快速迭代和部署。通过自动化的流程，企业能够更快地推出新功能和产品，与市场保持同步，抢占先机。

云原生的上云转型不仅带来了更高的安全性、可用性和可伸缩性，也提升了企业的创新能力和竞争力。

云原生带来的可观测挑战

茶百道作为业务高速发展的新兴餐饮品牌，每天都有海量的在线订单，这背后是与互联网技术的紧密结合，借助极高的数字化建设支撑茶百道庞大的销售量。因此，对于业务系统的连续性与可用性有着非常严苛的要求，以确保交易链路核心服务的稳定运行。特别是在每日高峰订餐时段、营销活动、突发热点事件期间，为了让用户有顺畅的使用体验，整个微服务系统的每个环节都需要保证在高并发大流量下的服务质量。

完善的全链路可观测平台以及 APM  ( Application Performance Management )工具，是保障业务连续性与可用性的前提。在可观测技术体系建设上，茶百道技术团队经历过比较多探索。全面实现容器化之前，茶百道在部分微服务系统上接入了开源 APM 工具，并进行超过一年时间的验证，但最终没有能够推广到整个微服务架构中，主要有这几个方面的原因：

• 
  

  指标数据准确度与采样率之间的平衡难以取舍

  
  

  适当的采样策略是解决链路追踪工具成本与性能的重要手段，如果 APM 工具固定使用 100% 链路全采集，会带来大量重复链路信息被保存。在茶百道的庞大微服务系统规模下，100% 链路采集会造成可观测平台存储成本超出预期，而且在业务高峰期还会对微服务应用本身的性能带来一定影响。但开源工具在设定采样策略的情况下，又会影响指标数据准确度，使错误率、P99 响应时间等重要可观测指标失去观测与告警价值。

  
  


• 
  

  缺少高阶告警能力

  
  

  开源工具在告警方面实现比较简单，用户需要自行分别搭建告警处理及告警分派平台，才能实现告警信息发送到 IM 群等基本功能。由于茶百道微服务化后的服务模块众多、依赖复杂。经常因为某个组件的异常或不可用导致整条链路产生大量冗余告警，形成告警风暴。造成的结果就是运维团队疲于应付五花八门且数量庞大的告警信息，非常容易遗漏真正用于故障排查的重要消息。

  
  


• 
  

  故障排查手段单一

  
  

  开源 APM 工具主要基于 Trace 链路信息帮助用户实现故障定位，对于简单的微服务系统性能问题，用户能够快速找到性能瓶颈点或故障源。但实际生产环境中的很多疑难杂症，根本没有办法通过简单的链路分析去解决，比如 N+1 问题，内存 OOM，CPU 占用率过高，线程池打满等。这样就对技术团队提出了极高要求，团队需要深入了解底层技术细节，并具备丰富 SRE 经验的工程师，才能快速准确的定位故障根源。

  
  

接入阿里云应用实时监控服务 ARMS

在茶百道系统架构全面云原生化的过程中，茶百道技术团队与阿里云的工程师深入探讨了全链路可观测更好的落地方式。

ARMS 应用监控作为阿里云云原生可观测产品家族的重要成员，提供线程剖析、智能洞察、CPU & 内存诊断、告警集成等开源 APM 产品不具备的能力。在阿里云的建议下，茶百道技术团队尝试着将一个业务模块接入 ARMS 应用监控。

由于 ARMS 提供了容器服务 ACK 环境下的应用自动接入，只需要对每个应用的 YAML 文件增加 2 行代码就自动注入探针，完成整个接入流程。经过一段时间试用，ARMS 应用监控提供的实战价值被茶百道的工程师不断挖掘出来。茶百道同时使用了阿里云性能测试产品 PTS，来实现日常态和大促态的容量规划。因为ARMS和 PTS 的引入，茶百道日常运维与稳定性保障体系也发生了众多升级。

围绕 ARMS 告警平台构建应急响应体系

由于之前基于开源产品搭建告警平台时，经常遇到告警风暴的问题，茶百道对于告警规则的配置是非常谨慎的，尽可能将告警目标收敛到最严重的业务故障上，这样虽然可以避免告警风暴对 SRE 团队的频繁骚扰，但也会让很多有价值的信息被忽略，比如接口响应时间的突增等。

其实对于告警风暴问题，业界是有一整套标准解法的，其中涉及到去重、压缩、降噪、静默等关键技术，只是这些技术与可观测产品集成上存在一定复杂度，很多开源产品并没有在这个领域提供完善方案。

这些告警领域的关键技术，在 ARMS 告警平台上都有完整功能。以事件压缩举例，ARMS 提供基于标签压缩和基于时间压缩两种压缩方式。满足条件的多条事件会被自动压缩成为一条告警进行通知（如下图所示）。

图: 基于标签压缩

图：基于时间压缩

配合 ARMS 告警平台所提供的多种技术手段，可以非常有效的解决告警风暴的问题，因此茶百道技术团队开始重视告警的使用，逐步丰富更多的告警规则，覆盖应用接口、主机指标、JVM 参数、数据库访问等不同层面。

通过企业微信群进行对接，使告警通知实现 ISTM 流程的互动，当值班人员收到告警通知后，可以直接通过 IM 工具进行告警关闭、事件升级等能力，快速实现告警处理。（如下图所示）

图：监控告警事件的智能化收敛与通告

灵活开放的告警事件处置策略满足了不同时效、场景的需求。茶百道在此基础上参考阿里巴巴安全生产最佳实践，开始构建企业级应急响应体系。将业务视角的应急场景作为事件应急处置的核心模型，通过不同告警级别，识别与流转对应的故障处理过程。这些都是茶百道在全面云原生化后摸索出的经验，并显著提升生产环境服务质量。

引入采样策略

从链路信息中提取指标数据，是所有 APM 工具的必备功能。不同于开源产品简单粗暴的指标提取方式，ARMS 应用监控使用端侧预聚合能力，捕捉每一次真实请求，先聚合，后采样，再上报，提供精准的指标监控。确保在采样策略开启的情况下，指标数据依然与真实情况保持一致。

图：ARMS 端侧预聚合能力

为了降低 APM 工具带来的应用性能损耗，茶百道对大部分应用采取 10% 采样率，对于 TPS 非常高的应用则采取自适应采样策略，进一步降低高峰期应用性能损耗。通过实测，在业务高峰期，ARMS 应用监控造成的应用性能损耗比开源产品低 30% 以上且指标数据准确性可信赖， 比如接口级别的平均响应时间、错误数等指标都可以满足生产级业务需求。

图：接口级别指标数据

异步链路自动埋点*

在 Java 领域存在异步线程池技术，以及众多开源异步框架，比如 RxJava、Reactor Netty、Vert.x 等。相较于同步链路，异步链路的自动埋点与上下文透传的技术难度更大。开源产品对主流异步框架的覆盖度不全，在特定场景下存在埋点失败问题，一旦出现这样的问题，APM 工具最重要的链路分析能力就难以发挥作用。

在这种情况下，需要开发者自行通过 SDK 手工埋点，以保证异步链路的上下文透传。这就会造成巨大的工作量且难以在团队内部大面积、快速推广。

ARMS 对主流的异步框架都实现了支持，无需任何业务代码上的侵入就能够异步链路上下文透传，即使对一些异步框架的特定版本没有及时支持，只要用户侧提出需求，ARMS 团队就能在新版本的探针中补齐。使用 ARMS 应用监控之后，茶百道技术团队直接将此前异步框架手工埋点代码进行了清理，大幅度减少维护工作量。

图：异步调用的链路上下文

更高阶应用诊断技术的运用

在埋点覆盖度足够高的情况下，传统 APM 工具和链路跟踪工具能够帮助用户快速确定链路的哪一个环节（也就是Span）存在性能瓶颈，但需要更进一步排查问题根源时，就无法提供更有效的帮助了。

举一个例子，当系统 CPU 占用率显著提升时，是否因某个业务方法疯狂的消耗 CPU 资源所导致？这个问题对于大多数的 APM 产品而言，都是难以办法解决的。因为单从链路视图无法知晓每个环节的资源消耗情况。茶百道的工程师在使用开源工具时，曾多次遇到类似问题，当时只能凭借经验去猜测，再去测试环境反复对比来彻底解决，虽然也试过一些 Profiling 工具，但使用门槛比较高，效果不是很好。

ARMS 应用监控提供了 CPU & 内存诊断能力，可以有效发现 Java 程序中因为 CPU、内存和 I/O 导致的瓶颈问题，并按照方法名称、类名称、行号进行细分统计，最终协助开发者优化程序、降低延迟、增加吞吐、节约成本。CPU & 内存诊断可以在需要排查特定问题时临时开启，并通过火焰图帮助用户直接找到问题根源。在一次生产环境某应用 CPU 飙升场景中，茶百道的工程师通过 CPU & 内存诊断一步定位到问题是由一个特定业务算法所导致。

图：通过火焰图分析 CPU 时间

此外，对于线上的业务问题，还可以通过 ARMS 提供的 Arthas 诊断能力在线排查。Arthas 作为诊断 Java 领域线上问题诊断利器，利用字节码增强技术，可以在不重启 JVM 进程的情况下，查看程序运行情况。

虽然 Arthas 使用有一定门槛，需要投入比较多精力进行学习，但茶百道的工程师非常喜欢使用这个工具。针对“到底符合哪种特殊的数据导致某业务异常”此类问题，没有比 Arthas 更方便的排查工具了。

阶段性成果

经过 2 个月时间的调研与对比，茶百道决定全面从开源可观测平台转向 ARMS，从开源压测平台转向 PTS，并在团队内部进行推广。**随着使用的不断深入，ARMS 所提供的智能洞察、线程池分析等高阶可观测能力也逐步被茶百道的技术团队应用于日常运维中，线上问题排查效率相比之前也有了数倍提升。

在可观测产品本身的使用成本上，虽然表面上 ARMS 相比开源产品有所提高，但这是建立在开源方案数据单写，以及存在单点故障的情况下。其实茶百道的技术团队也非常清楚，之前的开源方案是存在高可用性隐患的，某个组件的故障会导致整个可观测方案不可用。只是大家对于开源方案提供的可观测能力并没有重度使用，所以才没有足够重视。所以综合来看，ARMS 整体成本并不会高于开源方案。

利用 ARMS 能力，茶百道实现了可观测指标采样率百分百覆盖，链路全采集，监控数据准确率大幅提供，能够快速实现业务故障的自动发现，有效的配合敏态业务发展。

故障发生后，监控系统需要第一时间通知相关人员，做初步定位，ARMS 告警告警能力实现了 ChatOps 能力，基于 IM 工具，快速触达相关人员，并且提供初步定位能力，是故障的响应能力大幅提升。

故障的快速恢复，对于控制业务影响至关重要，ARMS 利用全链路 Trace 能力，快速定位具体应用、接口、方法、慢sql等，是故障快速恢复的关键助手。茶百道技术团队负责人表示： “在与开源方案成本持平的前提下，ARMS 丰富且全面的全栈观测与告警能力，使茶百道快速建立运维观测与响应能力，故障恢复效率提升 50% 以上，故障恢复耗时****缩短 50%，真正做到用可观测为业务迅猛发展保驾护航。”

故障的预防收敛，在稳定性体系建设中是投入产出比极高的，PTS 利用全国流量施压的能力，和秒级监控能力，验证站点容量并定位性能瓶颈。茶百道在业务上线前，充分对单应用和全链路做压测，累计压测 800 余次，在上线前做到了性能问题的收敛，避免演进为线上故障。

下阶段目标

在可观测领域，Prometheus + Grafana 是指标数据存储、计算、查询、展示的事实标准，ARMS 产品家族提供托管加强的 Prometheus 和 Grafana 服务。ARMS 应用监控生成的指标数据也会自动保存到托管版 Prometheus 中，并预置数张 Grafana 大盘。茶百道的工程师们正在基于 Prometheus 和 Grafana，将应用层指标、关键业务指标、云服务指标进行结合，开发多维度可观测大盘。

在不久的将来，茶百道就会建立覆盖业务层、用户体验层、应用服务层、基础设置层、云服务层的统一可观测技术体系，为千万级用户同时在线的大规模微服务系统实现稳定性保障。

前言

作为一个人间观察员，同时我也是年轻人里面的一份子，我可以感觉到在生活的方方面面都能感觉到一些病态的现状。

1、首先跟我们日常相关的，结婚、买房买车，很多人的想法这是一笔很大的花销，另外工作在这几年经济比较差的环境下也比较难找，然后涨幅也没有那么高了；我发现基本大家的话题都离不开这些哈哈，可能是所谓的人生大事。

2、在讨论上面话题的时候，或者在朋友圈看到别人发的东西，我能感觉身边很多人蛮焦虑，有些甚至抑郁

3、不止是心情上出现问题，蛮多年轻人身体健康上也出现问题，像最近的脆皮大学生的梗。当然这里更多是打工人的身体健康问题，毕竟每天坐着看电脑，运动少，然后吃着各种外卖，再加上工作压力啥的。

总结：可以感受到这个社会充斥着金钱至上的味道，即使你在温饱的情况也会觉得很难受，为啥没有暴富。金钱就像那个萝卜悬在我们面前鞭笞我们前进，彷佛偷下懒就是不对的，像李某人：你要想下自身的原因？有没有努力赚钱？

很多人在这种社会环境下，或者氛围下，身心疲惫，然后你再上网刷一下，更焦虑了，哈哈。当我尝试分析各种各种原因，包括客观上、主观上的问题，发现没法解决现状问题。

什么原因导致？

这就引出以前两个名人的分歧，就是周树人、胡适，周树人是偏向人性的唤醒，就是他认为人太过冷漠了，一群人围观“坏人”的砍头，对于跟自己不相关的事情漠不关心；而胡适认为是环境导致人们出现这种情况，所以两人出现分歧。

目前我认为环境问题占大头，在很长一段的历史里面，压制人的天性，控制你的说话，人人自危，在这种环境下生存的人就会出现冷漠的心态，也就是说是对应的产物。我们现在看到的还是表面的问题，至于本质的问题是什么呢？这就得谈到《共产党宣言》。

我是在读《毛泽东笔记精讲》的时候，描述了早期对乌托邦的向往，在失败之后通过反复看了《共产党宣言》很多遍，然后系统学习共产主义，调整了方向。我那时就好奇究竟里面讲了什么，怎么从乌托邦主义转辩证唯物主义的，其实里面就很显露的暴露出资本主义带来的现状。

《共产党宣言》

里面首先提到一点，历史是一部阶级斗争的博弈，在封建时代，资本主义就是打压对象，后来随着先进的生产力出现，资本主义开始扩张，通过对外取代落后的生产力来达到资本递增的需求，所以资本主义占据了上风。

但是随着生产力的发展，机器的普及，人们的工作开始变得细分化，劳动量越大（按我理解是对重复劳动会更多，相当于人也变成一台机器，不断重复，以前搞一个东西时间是长了些，但是一天工作量就那么些，需要各个环节的切换，当你只剩下某个步骤的时候，就是一台重复的机器）。

资本也会让整个社会趋向盲目性，因为它本身就有复利的目的，比如说100w一年存银行拿到多少钱，第二年把所有钱再作为本金进行一个复利的操作。当生产力无法突破的时候，或者说市场过于饱和的时候，开始出现了危机，它不仅影响人们的日常生活，还有相处方式，当人与人的关系只剩下交易、利益的时候，再也没有其他关系，这就是当今的社会风气，就是大家都向钱看，而它恰恰描述在《共产党宣言》里面。

当一座大厦缺乏精神支柱、价值体系的时候，它建的越高倒得越快

待完善

是的，这个宣言极大鼓舞人们追随共产主义，也给出一定的理论指导，在我看来有些地方还需要完善，首先目前的生产力没有达到这么高的水平，记得刘强东在谈到ai的时候，如果机器人可以代替普通人干活，那么我们真正离共产主义的那个时代不远了；另外按需分配的规则也需要完善，是按照以前一个人多少粮票、多少住房来衡量呢？我们的思维是被现状局限了，是不是以后的物质跟现在的水一样，相对来说是非常充裕的，我们真正按照需求来要这个量，但是这里面也有人性的问题，当然如果物质已经丰富到这种情况，也没有人在意多少。

另外在那个时代，每个人都能满足基本的需求，工作都让机器去做，那人们在做什么？这就有点科幻了，是不是未来我们可以去探索外太空呢？这确实是一个有意思的目标哈哈

未来的方向

1、生产力的提升是一个很重要的基础

2、当然这个时候去制定完善的按需分配机制也不合理，需要达到上面前提条件

共产主义是解决当前资本主义带来一系列的问题的方法，但是当前的条件还达不到。

学习的东西

唯心主义、辩证唯物主义

当我在看《毛泽东笔记精讲》的时候，里面提到了早期有段时间推崇乌托邦思想，后来体系接触社会主义之后，追随辩证唯物主义。那么我就很好奇，唯心主义、辩证唯物主义 区别很大吗？

这里可以举个例子，比如说我要做一个大项目，按照我以往的经验，我会去参考业界的过往经验，然后去规划当前符合公司情况的架构。问题来了，当社会主义在初创的时候，哪有借鉴的例子，所以它出现了唯心主义，通过自己对社会主义的理解，进行蓝图，思想概念的构造，然后进行实施，这就是早期德国的社会主义乌托邦。

它的问题是会朝着预想的方向去进展，重心是你自己yy出来的，辩证唯物主义是需要借助历史，来反推未来的发展，它需要依靠现实的demo来总结规律，这像不像我们易经，这是唯物主义。

它忽略了什么，人的主观能动性，人的意志往往可以克服种种困难，所以是辩证唯物主义。

坚持实践是检验真理的唯一标准

物理上客观条件是主要的决定因素，而心理上、精神上是一大变量，是影响因素；我们可以看到在长征途中，做好了心理上的宣导，才能战胜困难，这是在《毛泽东自述》谈到的心理建设的重要性。

关于现状的想法

1、解决温饱问题，基本的物质经济

2、哪些事情对你有意义

当你满足温饱问题之后，我认为应该更多思考什么是你真正要创造的东西，还是一百年后，几百年后，人们对这个少年的印象就是这是个打工人，资本的复利的炮灰，不这不是我想要的，所以我一直在抽时间去思考历史上有哪些精神、哪些处事方式值得我们学习的，然后提出自己的方法论。

当你在获得收获然后分享那一刻是幸福，是骄傲的，历史就是一本厚厚的书籍，有些记载了每个朝代的精英集团，有些承载了那个时代的思想，它是现代人前行的路灯。

3、建设自己的精神世界

知识体系重建，价值体系重建，精神世界重建，这是重点方向。

题目

给定两个数组，判断两数组内容是否相等。

• 不使用排序


• 不考虑元素位置

例：

[1, 2, 3] 和 [1, 3, 2] // true

[1, 2, 3] 和 [1, 2, 4] // false

思考几秒：有了😀😀

1. 直接遍历✍

• 直接遍历第一个数组，并判断是否存在于在第二个数组中


• 求差集, 如果差集数组有长度，也说明两数组不等（个人感觉比上面的麻烦就不举例了）

const arr1 =  ["apple", "banana", 1]

const arr2 =  ["apple", 1, "banana"]



function fn(arr1, arr2) {

  // Arrary.some: 有一项不满足 返回false

  // Arrary.indexOf: 查到返回下标，查不到返回 -1

  if (arr1.length !== arr2.length) {

    return false;

  }

  return !arr1.some(item => arr2.indexOf(item)===-1)

}



fn(arr1,arr2) // true

• 细心的小伙伴就会发现：NaN 会有问题

const arr1 =  ["apple", "banana", NaN]

const arr2 =  ["apple", NaN, "banana"]



function fn(arr1, arr2) {

  if (arr1.length !== arr2.length) {

    return false;

  }

  return !arr1.some(item => arr2.indexOf(item)===-1)

}



fn(arr1,arr2) // false

Arrary.prototype.indexOf() 是使用的严格相等算法 => NaN值永远不相等

Array.prototype.includes() 是使用的零值相等算法 => NaN值视作相等

• 严格相等算法: 与 === 运算符使用的算法相同


• 零值相等不作为 JavaScript API 公开， -0和0 视作相等，NaN值视作相等，具体参考mdn文档:

• 使用includes

const arr1 =  ["apple", "banana", NaN]

const arr2 =  ["apple", NaN, "banana"]



function fn(arr1, arr2) {

  if (arr1.length !== arr2.length) {

    return false;

  }

  return !arr1.some(item => !arr2.includes(item))

}



fn(arr1,arr2) // true

使用includes 确实可以判断NaN了，如果数组元素有重复呢？

// 重复的元素都是banana

const array1 = ["apple", "banana", "cherry", "banana"];

const array2 = ["banana", "apple", "banana", "cherry"];

// 或者

// 一个重复的元素是banana， 一个是apple

const array1 = ["apple", "banana", "cherry", "banana"];

const array2 = ["banana", "apple", "apple", "cherry"];

由上可知：这种行不通，接下来看看是否能从给数组元素添加标识入手

2. 把重复元素标识编号✍

这个简单：数组 元素重复 转换成val1, val2

function areArraysContentEqual(arr1, arr2) {

  if (arr1.length !== arr2.length) {

    return false;

  }



  // 重复数组元素 加1、2、3

  const countArr1 = updateArray(arr1)

  const countArr2 = updateArray(arr2)



  /**

   * 

   * @param {*} arr 数组 元素重复 转换成val1, val2

   * @returns 

   */

  function updateArray(arr) {

    const countMap = new Map();

    const updatedArr = [];



    for (const item of arr) {

      if (!countMap.has(item)) {

        // 如果元素是第一次出现，直接添加到结果数组

        countMap.set(item, 0);

        updatedArr.push(item);

      } else {

        // 如果元素已经出现过，添加带有编号的新元素到结果数组

        const count = countMap.get(item) + 1;

        countMap.set(item, count);

        updatedArr.push(`${item}${count}`);

      }

    }

    return updatedArr;

  }

  const flag = countArr1.some(item => !countArr2.includes(item))

  return !flag

}



const array1 = ["apple", "banana", "cherry", "banana"];

const array2 = ["banana", "apple", "banana", "cherry"];



areArraysContentEqual(array1, array2) // true



// 其实这种存在漏洞的

const array3 = ["apple", "banana", "cherry", "banana", 1, '1', '1' ];

const array4 = ["banana", "apple", "banana", "cherry", '1', 1, 1];

// 应该是false

areArraysContentEqual(array3, array4) // true

因为把判断的 转为了字符串 updatedArr.push(${item}${count}) 所以出问题了

3. 统计元素次数(最终方案)✍

function areArraysContentEqual(arr1, arr2) {

  if (arr1.length !== arr2.length) {

    return false;

  }



  // 创建计数对象，用于记录每个元素在数组中的出现次数

  const countMap1 = count(arr1)

  const countMap2 = count(arr2)



  // 统计数组中的元素出现次数

  function count(arr = []) {

    const resMap = new Map();

    for (const item of arr) {

      resMap.set(item, (resMap.get(item) || 0) + 1);

    }

    return resMap

  }

  // 检查计数对象是否相等

  for (const [key, count] of countMap1) {

    if (countMap2.get(key) !== count) {

      return false;

    }

  }



  return true;

}



const array1 = ["apple", "banana", "cherry", "banana", 1, '1', '11', 11];

const array2 = ["banana", "apple", "banana", "cherry", '1', 1, '11', 11];



areArraysContentEqual(array1, array2) // true

注意事项

这个题需要注意：

• 先判断长度，长度不等 必然不等


• 元素可重复


• 边界情况考虑
  
  
  
  • '1' 和 1 (Object的key是字符串， Map的key没有限制)
  
  
  • NaN
  
  
  • null undefined
  
  
  
  

结语：

如果本文对你有收获，麻烦动动发财的小手，点点关注、点点赞！！！👻👻👻

因为收藏===会了

如果有不对、更好的方式实现、可以优化的地方欢迎在评论区指出，谢谢👾👾👾

大家好，我是冰河~~

最近，有很多小伙伴想跟我学渗透。平时时间确实太忙了，除了要研发公司项目外，写公号，写博客，录视频，写书稿，维护开源项目，几乎占据了我全部的业余时间。目前确实没有太多的时间教大家，今天，就暂时给大家分享一个小技巧吧，如何彻底隐藏电脑中的“小电影”，让你的女朋友再也不能发现你电脑中的小秘密！

实现效果：你女朋友打开文件是一张图片，你打开却是各种“小电影”~~

好了，我们开始吧！

首先，准备好一张图片，还有一个对你来说的很重要的“电影”文件夹，如图所示。

电影文件夹中的内容如下所示。

接下来，将电影文件夹压缩为1.rar文件，如下所示。

然后新建一个名称为copy_image.bat的脚本文件，文件内容如下所示。

copy 1.jpg/b+1.rar=2.jpg

双击运行copy_image.bat的脚本文件，会生成一张2.jpg文件，如下所示。

接下来，只保留2.jpg文件，其他文件和文件夹全部删除。

可以看到，就只剩下这个图片了，我们打开这张图片。

可以看到，它确实只是一张图片。那么问题来了：我们要看“小电影”怎么办？ 接下来，是重点。

如果你想看里面的“小电影”，那只需要把图片的后缀名从.jpg修改为.rar，如下所示。

双击打开2.rar文件，如下所示。

可以看到，里面都是你珍藏多年的“小电影”啦。为了保险起见，看完，还是把文件的后缀名改回.jpg吧 ~~

你学会了吗？欢迎在文末留言讨论~~

好了，今天的分享就到这里，我是冰河，我们下期见~~

在老东家工作 3 年了，公司的业务和技术栈相对熟练得差不多了。

领导觉得我能够委以重任，便把一个新项目交给我负责，另外指派一名同事协助我。

项目的重点在于数据的交互比较多，以及每天大量的数据同步和批量操作，不能出错。

队友建议以短、平、快为主，能够使用已有现成的技术就用现成的技术。直接面向过程开发是人们最为舒适，是人为本能的习惯。由于他有这一种能够处理好的决心，便把数据批量操作这块委托于他。

查看了以往公司现成一些写法，一部分是直接面向 SQL 写法批量插入，面对增量同步则先查出，存在的更新，不存在的插入。一部分是通过 Kafka 和后台任务原子操作。

理论上这么操作结果也能成，但是看到修改记录，我就知道面临的需求变了很多变化很快，导致大量的更改。私底下询问负责人也了解出了太多问题，原本一劳永逸赶紧写完结果反而投入了更多的精力和时间。

出于预防心理，也对那位同事进行了提醒并且加以思考再下手。

不到一个月，我们就把项目上线了，并且没有出现数据上的错误，得到了领导的表扬。

我们也提前收场，做一些小的优化，其余时间在摸鱼。

一段时间之后，麻烦便接踵而至，其一就是开始数据量暴增，那位同事在做增量同步时进行了锁表操作，批量操作需要一些时间，在前台读取时出现响应超时。

其二就是增量同步要调整，以主库或第三方来源库为主，出现数据更新和删除的需要同步操作。

同事目前的主力放在了新项目上，把一些零散的时间用来调整需求和 bug，结果越处理，bug 出现的越多，不是数量过多卡死就是变量不对导致数据处理不对。

于是到了某一时刻终于爆发，领导找到我俩，被痛批一顿，工作这么久就只会 CRUD 操作，来的实习生都会干的活，还养你们干什么。

当然，要复盘的话当然有迹可循。我想碰见这种情况还真不少，首次开发项目时一鼓作气，以“短、平、快” 战术面向过程开发，短时间内上线。

但是，一个软件的生命周期可不止步于上线，还要过程运维以及面对变化。

导致在二次开发的时候就脱节了，要么当时写法不符合现有业务，要么改动太多动不动就割到了大动脉大出血，要么人跑了...

所以我们会采用面向对象，抽象化编程，就是用来保稳定，预留一部分来应付变化，避免牵一发而动全身。

挨完骂，也要开始收拾烂摊子。

于是我打算重新组装一个通用的方法，打算一劳永逸。

首先我们定义一个接口通用思维 IDbAsyncBulk。由于源码已经发布到了github，所以一些注释写成了英文，大致也能看出蹩脚英文的注释。

public interface IDbAsyncBulk

    {

        /// <summary>

        /// default init.

        /// use reflect to auto init all type, to lower case database fileds,and  default basic type.

        /// if ignore some fileds,please use DbBulk,Ignore property to remarkable fileds.

        /// if other operating,need user-defined to init operate.

        /// </summary>

        /// <typeparam name="T">Corresponding type</typeparam>

        Task InitDefaultMappings<T>();



        /// <summary>

        /// batch operating

        /// </summary>

        /// <typeparam name="T">will operate object entity type.</typeparam>

        /// <param name="connection_string">database connecting string.</param>

        /// <param name="targetTable">target table name. </param>

        /// <param name="list">will operate data list.</param>

        Task CopyToServer<T>(string connection_string, string targetTable, List<T> list);



        /// <summary>

        /// batch operating

        /// </summary>

        /// <typeparam name="T">will operate object entity type.</typeparam>

        /// <param name="connection">database connecting string.need to check database connecting is openning.

        /// if nothing other follow-up operate, shouldn't cover this connecting.</param>

        /// <param name="targetTable">target table name.</param>

        /// <param name="list">will operate data list.</param>

        Task CopyToServer<T>(DbConnection connection, string targetTable, List<T> list);



        /// <summary>

        /// renew as it exists，insert as it not exists.

        /// follow up : 

        /// 1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection_string">connecting string</param>

        /// <param name="keys">mapping orignal table and target table fileds,need primary key and data only,if not will throw error.</param>

        /// <param name="targetTable">target table name.</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        /// <param name="insertmapping">need to insert column，if is null,just use Mapping fileds，in order to avoid auto-create column</param>

        /// <param name="updatemapping">need to modify column，if is null,just use Mapping fileds</param>

        Task MergeToServer<T>(string connection_string, List<string> keys, string targetTable, List<T> list, string tempTable = null, List<string> insertmapping = null, List<string> updatemapping = null);



        /// <summary>

        /// renew as it exists，insert as it not exists.

        /// follow up : 

        /// 1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection">database connecting string.need to check database connecting is openning.</param>

        /// <param name="keys">mapping orignal table and target table fileds,need primary key and data only,if not will throw error.</param>

        /// <param name="targetTable">target table name.</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        /// <param name="insertmapping">need to insert column，if is null,just use Mapping fileds，in order to avoid auto-create column</param>

        /// <param name="updatemapping">need to modify column，if is null,just use Mapping fileds</param>

        Task MergeToServer<T>(DbConnection connection, List<string> keys, string targetTable, List<T> list, string tempTable = null, List<string> insertmapping = null, List<string> updatemapping = null);



        /// <summary>

        ///  batch update operating。

        /// 1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection_string">connecting string</param>

        /// <param name="where_name">matching 'where' compare fileds.</param>

        /// <param name="update_name">need to update fileds.</param>

        /// <param name="targetTable">target table name</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        Task UpdateToServer<T>(string connection_string, List<string> where_name, List<string> update_name, string targetTable, List<T> list, string tempTable = null);



        /// <summary>

        ///  batch update operating。

        /// 1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection_string">connecting string</param>

        /// <param name="where_name">matching 'where' compare fileds.</param>

        /// <param name="update_name">need to update fileds.</param>

        /// <param name="targetTable">target table name</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        /// <param name="createtemp"> create temporary table or not </param>

        Task UpdateToServer<T>(DbConnection connection, List<string> where_name, List<string> update_name, string targetTable, List<T> list, string tempTable = null, bool createtemp = true);



        /// <summary>

        /// renew as it exists，insert as it not exists.original table not exist and  target table exist will remove.

        /// 1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// 4.will remove data that temporary data not exist and target table exist.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection_string">connecting string</param>

        /// <param name="keys">mapping orignal table and target table fileds,need primary key and data only,if not will throw error.</param>

        /// <param name="targetTable">target table name</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        /// <param name="insertmapping">need to insert column，if is null,just use Mapping fileds，in order to avoid auto-create column</param>

        /// <param name="updatemapping">need to modify column，if is null,just use Mapping fileds</param>

        Task MergeAndDeleteToServer<T>(string connection_string, List<string> keys, string targetTable, List<T> list, string tempTable = null, List<string> insertmapping = null, List<string> updatemapping = null);



        /// <summary>

        /// renew as it exists，insert as it not exists.original table not exist and  target table exist will remove.

        ///  1.create temporary table

        /// 2.put data into temporary table.

        /// 3.merge data to target table.

        /// 4.will remove data that temporary data not exist and target table exist.

        /// </summary>

        /// <typeparam name="T">data type</typeparam>

        /// <param name="connection">database connecting string.need to check database connecting is openning.</param>

        /// <param name="keys">mapping orignal table and target table fileds,need primary key and data only,if not will throw error.</param>

        /// <param name="targetTable">target table name</param>

        /// <param name="list">will operate data list.</param>

        /// <param name="tempTable">put data into temporary table,default name as 'target table name + # or _temp'</param>

        /// <param name="insertmapping">need to insert column，if is null,just use Mapping fileds，in order to avoid auto-create column</param>

        /// <param name="updatemapping">need to modify column，if is null,just use Mapping fileds</param>

        Task MergeAndDeleteToServer<T>(DbConnection connection, List<string> keys, string targetTable, List<T> list, string tempTable = null, List<string> insertmapping = null, List<string> updatemapping = null);



        /// <summary>

        /// create temporary table

        /// </summary>

        /// <param name="tempTable">create temporary table name</param>

        /// <param name="targetTable">rarget table name</param>

        /// <param name="connection">database connecting</param>

        Task CreateTempTable(string tempTable, string targetTable, DbConnection connection);

    }

解释几个方法的作用：

InitDefaultMappings：初始化映射，将目标表的字段映射到实体，在批量操作时候会根据反射进行一一匹配表字段；

CopyToServer：批量新增，在符合数据表结构时批量复制到目标表，采用官方 SqlBulkCopy 类结合实体简化操作。

MergeToServer：增量同步，需指定唯一键，存在即更新，不存在则插入。支持指定更新字段，指定插入字段。

UpdateToServer：批量更新，需指定 where 条件，以及更新的字段。

MergeAndDeleteToServer：增量同步，以数据源和目标表进行匹配，目标表存在的则更新，不存在的则插入，目标表存在，数据源不存在则目标表移除。

CreateTempTable：创建临时表。

增加实体属性标记，用来标记列名是否忽略同步数据，以及消除数据库别名，大小写的差异。

 /// <summary>

    /// 数据库批量操作标记，用于标记对象属性。

    /// </summary>

    public class DbBulkAttribute : Attribute

    {

        /// <summary>

        /// 是否忽略。忽略则其余属性不需要设置，不忽略则必须设置Type。

        /// </summary>

        public bool Ignore { get; set; }



        /// <summary>

        /// 列名，不设置则默认为实体字段名小写

        /// </summary>

        public string ColumnName { get; set; }



    }

实现类，目前仅支持 SqlServer 数据库，正在更新 MySql 和 PGSql 中。然后需要定义BatchSize(default 10000)、BulkCopyTimeout (default 300)、ColumnMappings，分别是每批次大小，允许超时时间和映射的字段。

/// <summary>

    /// sql server batch

    /// </summary>

    public class SqlServerAsyncBulk : IDbAsyncBulk

    {

        /// <summary>

        /// log recoding

        /// </summary>

        private ILogger _log;

        /// <summary>

        ///batch insert size（handle a batch every time ）。default 10000。

        /// </summary>

        public int BatchSize { get; set; }

        /// <summary>

        /// overtime,default 300

        /// </summary>

        public int BulkCopyTimeout { get; set; }

        /// <summary>

        /// columns mapping

        /// </summary>

        public Dictionary<string, string> ColumnMappings { get; set; }

        /// <summary>

        /// structure function

        /// </summary>

        /// <param name="log"></param>

        public SqlServerAsyncBulk(ILogger<SqlServerAsyncBulk> log)

        {

            _log = log;

            BatchSize = 10000;

            BulkCopyTimeout = 300;

        }

        

        //...to do

使用上也非常的简便，直接在服务里注册单例模式，使用的时候直接依赖注入。

 //if you use SqlServer database, config SqlServerAsyncBulk service.

services.AddSingleton<IDbAsyncBulk, SqlServerAsyncBulk>();

public class BatchOperate

{

  private readonly IDbAsyncBulk _bulk;

  public BatchOperate(IDbAsyncBulk bulk)

  {

    _bulk = bulk;

  }

}

以 user_base 表举两个实例,目前测试几十万数据也才零点几秒。

 public async Task CopyToServerTest()

        {

            var connectStr = @"Data Source=KF009\SQLEXPRESS;Initial Catalog=MockData;User ID=xxx;Password=xxx";

            await _bulk.InitDefaultMappings<UserBaseModel>();

            var mock_list = new List<UserBaseModel>();

            for (var i = 0; i < 1000; i++) {

                mock_list.Add(new UserBaseModel

                {

                    age = i,

                    birthday = DateTime.Now.AddMonths(-i).Date,

                    education = "本科",

                    email = "xiaoyu@163.com",

                    name = $"小榆{i}",

                    nation = "汉",

                    nationality="中国"

                });

            }

            await _bulk.CopyToServer(connectStr, "user_base", mock_list);

        }

public async Task MergeToServerTest()

        {

            var connectStr = @"Data Source=KF009\SQLEXPRESS;Initial Catalog=MockData;User ID=sa;Password=root";

            await _bulk.InitDefaultMappings<UserBaseModel>();

            var mock_list = new List<UserBaseModel>();

            for (var i = 0; i < 1000; i++)

            {

                mock_list.Add(new UserBaseModel

                {

                    age = i,

                    birthday = DateTime.Now.AddMonths(-i).Date,

                    education = "本科",

                    email = "mock@163.com",

                    name = $"小榆{i}",

                    nation = "汉",

                    nationality = "中国"

                });

            }

            var insertMapping = new List<string> { "birthday", "education", "age", "email", "name", "nation", "nationality" };

            var updateMapping = new List<string> { "birthday", "education", "age", "email"};

            await _bulk.MergeToServer(connectStr,new List<string> {"id"}, "user_base", mock_list,null, insertMapping, updateMapping);

        

到这里，也已经完成了批量数据操作啦，不用再面对大量的sql操作啦。面向 sql 开发一时确实爽，但是面临变化或者别人接手的时候，是很痛苦的。

具体实现细节内容过多，篇幅有限暂时不全部展示，有兴趣或者尝试的伙伴可以进 github 进行参考。

github👉：github.com/sangxiaoyu/… 💖

工作这件事，从根本上说，就是别人花钱请你实现 ta 的梦想。

既然是别人花钱实现 ta 的梦想，那你觉得是 ta 的意愿更重要一些还是你自己的意愿更重要一些（注意，这其实是一句反问句）？

你上班的路上去一个早餐摊买早餐，早餐摊既可以卖煎饼也可以卖鸡蛋灌饼。你给早餐摊老板十块钱说给我做个鸡蛋灌饼，他说对不起，我的梦想是成一个优秀的煎饼maker，所以我不能给你做鸡蛋灌饼，只能给你做煎饼。

你听了这句话肯定心里一万句草泥马崩腾而过：“你的梦想关我屁事啊！我就想吃鸡蛋灌饼！老子花了钱的！你想做煎饼maker你自己花钱去做啊，为啥花我的钱给你做煎饼！”

如果这个早餐摊老板说啥非要坚持只做煎饼不做鸡蛋灌饼会发生什么？你肯定会立刻离开他然后去别的地方买你想吃的东西。也就是说，交易会取消。

说回来，工作的本质就是别人花钱请你实现ta的梦想，所以ta扔给你的事情一定是围绕着ta的目标展开的，你对这些工作感受如何是次要的，毕竟人家花钱了。如果你觉得他扔给你的工作太多或者太憋屈，那就离开，交易取消。

当然大部分老板都不会彻底不顾及你的感受，因为要是彻底把你惹毛了，谁替他实现梦想呢？所以他也会在一定程度上顾虑你的感受，哪怕对 ta自己的目标有负面影响。比如老板希望你 7✖️24小时给公司工作，然而他也知道你这样工作三天就得累死，所以也会安排你休息。你们双方彼此互相退让，会达成最终的一致，然而这个“一致”的天平一定不是正好在你俩中间的，而是偏向你的老板的，因为人家花钱了。

再换句话说，只要你还拿着老板的钱，那你老板的目标就比你的目标更重要。

前几天有一个刚刚毕业的小朋友找我聊天，他去参与了一个销售岗位的面试，这家公司的HR问他为什么从上一家公司离职。他是这么跟HR说的：“我在上一家公司销售的产品是一个纪念币，纪念币印着阿根廷足球队，然而金币上印着两个星（代表阿根廷得过两次世界杯冠军）。然而我去推销这个金币的时候，阿根廷已经三星了，这种情况我怎么可能卖的出去？”然后他问我，他这么跟HR说，HR会怎么想。

我回答他说：“HR会想，他上一家公司的产品有缺点，所以他就完全卖不出去。我们家的产品也有很多缺点，所以这个人来了我们家肯定也卖不出去。这个候选人 fail。”

小朋友听了我的话，一瞬间蔫儿了。然后他想了想，问我如果是我会怎么说。

我跟他说，天底下一切商品都是有缺点的，连全世界最畅销的商品都不例外，即使天底下最成功的公司，走进公司内部看都是一地鸡毛的。产品有缺点就卖不出去，按照这个逻辑，那世界上就不该有销售这个岗位。

换一个角度去想，假设你是老板，你有一个完美无瑕的商品，谁见谁夸，所有人都抢着买，那我雇佣销售干什么？我买一堆自动售货机不就行了吗？因为我的产品不够完美，所以才需要销售人员推销，所以在老板的心里，销售人员需要解决我的产品“不完美”的问题。具体怎么解决，那是你的问题，而不是我的问题，我花钱雇佣你就是为了让你解决这个问题的。

然而在刚才那位小朋友的心里这个事情却是反过来的，老板应该把他的产品变“完美”，要不我卖的很辛苦。在他的逻辑里，老板仿佛应该为他”工作轻松“而服务。这就是一个以自我为中心的本末倒置的心态，抱着这样的心态在职场混，就难免混的很惨了。

拿人钱财替人消灾，既然拿了工资，就应该优先考虑组织遇到的难题是什么，组织需要我解决的难题是什么。组织有了好结果，组织才会把好结果回馈给我，我自己才能好。这才是这个世界运转的基本逻辑。

在我看来，职场人里90%以上的抱怨，都是因为没有想清楚这个最基本的逻辑。

前两天有人在我的帖子下面大吐苦水，说现在的团队晋升都是优先“老人”，“新人”要等很久，所以这个情况对“新人”太不公平啦。言下之意就是公司应该改革晋升制度，让新人更容易晋升一些。

兄弟，老板当初创办了这家公司，就是为了赚钱的。所以老板一切行为的根本目的就是赚钱，设计“晋升”制度就为了更好的赚钱。赚钱是目的，“晋升制度”只是手段。公司的运营情况一旦发生了变化，公司需要调整制度，老板是该优先考虑赚钱的难易度，还是该优先考虑你的晋升难易度？

我相信有的人看到这里就会说我是“精神资本家”，明明也是给人打工的，咋了老胳膊肘往外拐给资本家说话。（loser的智力全点在编名词上了）

我之所以这么想，是因为我明白一个很基本的道理：“这个世界不是围绕着我运转的。 ”

在这个芸芸众生的苍茫世界中，我只是一个微不足道的尘芥。我每天从拥挤的13号线地铁上下来，几千人从我的身边匆忙走过，根本没有人会在乎我。北京城2300万常驻人口，全中国14亿人口，乃至全世界70亿人口，没有人亏欠我什么。

我作为一个成年人，就应该自力更生养活自己。这几千万的陌生人里，有一个人跟我说一个月给我几万块钱，换我给他打工赚钱，在我点头答应的那一刻，这就是两个成年人之间平等的合约，他不欠我的，就像我也不欠他的一样。

如果有一天我觉得他给我的钱太少，配不上我的劳动，我就大大方方的结束这场交易。

有一天他雇佣了一个比我年轻好多岁的人，付的工资比给我的还多。我听说了以后一定会心里很不是滋味，但是我也说不上什么。因为钱是人家的，人家爱给谁给谁，爱给多少给多少，这是人家的自由，人家不欠我的。

老板跟我谈好，如果我能给他赚更多钱，他就给我付更多的工资，这是一场公平的交易。我绝不会觉得我什么都不需要做，只是干等着，老板就欠我一个“晋升”。

别人都是自私自利的，我特别理解他们，原因很简单，我自己也是自私自利的。别人就是应该先为他们自己考虑，有空闲才会考虑一下我，因为遇到利益分配的时候，我也会优先考虑我自己。人类就是这种生物，你是人，你的老板也是人。我如果想要别人优先考虑一下我，我就必须让我找他心里变得重要。而想让我在别人心里变得重要，就得优先满足别人的利益。

那些觉得其他人应该优先考虑他的人，全是心智未成年的“巨婴”。

大家有兴趣可以阅读一下《我有一个好主意》的文章

一入国企深似海，捆绑越多，你走得越难，有的人甚至终身被困于此，任人搓揉捏扁。离职就要走得干脆点，不要回头，通常更烦的事情可能还在后头，早走早解脱！

1.国企怎样的？

有人说进国企，基本等于金饭碗

emm，这是个很大的误区，事业编考进去国企的领导才是，我们这些签劳动合同的打工人，跟别的企业打工人没区别！

只不过，国企特别注重社会影响，相对于其他企业很少会裁员而已，这不代表不裁员。之前公司架构调整时就直接砍了一个事业部的人，不过n+1给到位，人家整个部门还开开心心聚餐去 。羡慕嫉妒恨，怎么不把我裁了？我也想要n+1。

国企福利待遇很不错

的确，之前挺不错，包三餐和夜宵（好多家餐馆任选，饭堂有汤有水果有酸奶有糖水，一顿可以选六道菜，麦当劳吃到厌），每月一次下午茶和一袋果蔬，季度生日会各种水果点心等，说实话，这么多好吃的，好多人入职不久就日渐圆润，然后公司员工戏称这里是养猪场。

之前有各种补贴，过节有过节费和活动，我还曾盲盒抽中过个很不错的键盘！

节日礼包直接顺丰快递邮寄回家，有人才政策的公司帮你还分期的免费手机电脑，还有公租房、暑假儿童托管班、挂靠公司的学位、免费每月150G的号码套餐等，各方面想得很周到，囊括你生活的众多方面，让你与公司各种福利紧密结合，以至于你想走也要思虑再三。

2.在国企的日子，我都干了什么？

我所在的团队主要搞医疗相关业务的，趁着疫情的机遇，公司发展得特别顺，所以日子很滋润。

比如21年广州荔湾区疫情突发时，我们也加班加点搞了个流动人群分析和网格热力的可视化大屏，22年初西藏疫情时，公司除了组织员工捐赠防疫物资，还派人支援，给他们弄了个公卫事件平台，以及分析大屏和传播链图谱，22年尾疫情大爆发，一堆人进方舱医院，我们团队负责了37个方舱医院的大屏和公卫平台……

然而，疫情开放后，这些业务没有了，人手过剩又没钱，然后又是架构调整，又是下放地市，又是捣鼓出各种开源节流的方案，很快，一堆福利都削减没了，骚操作越来越多。

3.我的裸辞为后面埋坑了

之前我写了《我裸辞了，但是没走成！》，引起了很多人的讨论，而我没有回复任何一个人，因为我觉得当初写那篇文的自己就是个傻逼！

留下来的第一个月月底！公司直接开会宣布要砍工资，绩效只发70%，呵呵！这触及大家的根本利益，我们团队真的太过乖了，不情不愿也都签名了！别的团队都抗议，集体不签，然后他们被拉去谈话，最终还是签名了！

这只是个开始，然后裁了一波员，把一些外包员工给砍了，包括我旁边那位很厉害的建模师，但是就是不动我们这些自有员工。因为自有员工工资很便宜，没必要动。

我们工资全靠福利补贴和年终奖拉平互联网工资水平线。现在来看，这就是隐形炸弹，给了公司很大的操作空间。福利现在砍了好多，我们的收入直线下降，加上绩效也砍了一截，日子更难过了！

而今年没什么大项目和好的业务，注定今年年终奖凉凉，所以补贴多和大头年终奖不一定是好事，劳动合同上没有明文规定的收入都是大陷阱，一旦公司要动，你去走法律途径也没理！

然后9月底，趁着国庆假期前，公司没人性地再砍一波，绩效只发60%！这下彻底炸了，我们组好几个人愤慨组队发邮件反馈不同意！

听说别的部门直接闹罢工抗议了，这次大家不再默默忍受，充分表达了不满！

然后周一早上，领导轮流约谈每人，意思很明确，你不同意也得同意，公司只是通知你一声，不论你是否同意，都会执行的！

4.没有未来还苟个鬼！

很多人说别那么功利，要看长远，国企稳定，不怎么加班，压力相对少，已经很不错了！

有些人追求安稳，牺牲点钱还能接受。道理我懂，但现在不是牺牲一点钱，是牺牲很多钱！傻逼才会被当水鱼一样宰！

之前我提辞职已经在领导那里留下案底，不出所料的，我第二季度拿了个B,加上我不愿参加党员事务，只想好好搞技术，然后积分倒数，根据党员规则，倒数不能拿B+和A，意味着我第三季度只能是B。这样恶性循环，那么我永远不能升职加薪，这日子已经没有盼头了！

最近我主导一个BI项目的重构，原本只是梳理成新架构，将功能和界面优化，现在直接变成产品推倒从零开始。

最可怕的是，产品不懂技术，还对原BI平台功能一问三不知，她们只看界面样式，然后她们很喜欢照搬照抄大厂优秀的产品，很喜欢想一套是一套，宗旨就是往复杂的方向一去不复返，恨不得每个功能组件都定制化一个个手动开发，还特别喜欢那种一层嵌一层没完没了的鸡肋操作，不考虑复用性，不考虑我们这边开发的实际情况，也没有想过逻辑通不通的问题，如果要按着这样开发就要耗费大量时间！

然而，领导要在短时间内看到成果，我作为主开发，要把控进度和规划任务，其他组员都比较佛系，然后我就成了那个去争取，去battle的出头鸟。

然后产品每次会说，这是基于用户角度设计的，XX大厂的产品就这么设计，为什么人家能这样搞，你搞不了？

呵呵！人家多少人，我们多少人，人家打磨这个产品多久，我们有多少时间？老想一口吃成个大胖子，就没点逼数吗？

最烦的是，每期评审都喜欢基于以前的功能修改新增，就不能一次性确认吗？导致好些原本写好的功能，还有可能要推翻重写！啊啊啊，想打人！

她们的不专业让我很烦躁，沟通也变得凶！然后我被批评注意点情绪管理，但我发现温和沟通也是没用的，因为人家根本不理。

下期个鬼！下期还不是我们来搞！

没想清楚就让你开搞，然后做完又不要，浪费大家时间！

我不否认我的工作方式也有问题，估计很多人都烦死我了！与其内耗自己不如一起内耗，相互伤害啊！

最近情绪很暴躁，加上我身体也发出了相应警告，严重爆痘，不停出红疹，每天都要吃抗过敏药压着，这样的情况持续了三四个月，感觉这样下去我迟早会崩溃！

公司现在明摆着就是不愿给裁员赔偿，耗着你，逼你走！

钱少事多，今年白干了，我累了，也不想耗下去了，然后果断选择撤离，提了离职，这次走得很坚决。

重构也完成了，现在只是修复bug继续优化，也对得起新组长的挽留！

我的亲戚说，打份工而已，不要太认真！

不愧是职场老鸟，真知灼见啊！

5.职场生存指南

1. 不要局限于现在的技术，保持学习。

你参与的项目可能只用到一部分的技术，而市场上要求的技术面往往更多，长久以往，你会被限死在这片技术领域，逐渐被养废，导致自己失去市场竞争力。

2. 领导的话听听就算了，别当真！

上司很喜欢PUA现在外面的情况不好混，他都没去外面混过，怎么知道外面不好混？只不过是因为他自己走不了，所以得拉多几个人一起落水，这样他心里就平衡多了！

3. 福利可以有，但不能过分依赖！

过分依赖会让自己失去主动权！尽量减少自己与公司的捆绑，避免被公司拿捏，要为自己的未来预留后路，即便走也能无后顾之忧。

4. 面向领导的开发，技术能力不是升职加薪的重点，给领导创造价值才是！

比如领导在大领导面前展示你做的这个产品给公司赚了多少钱，得到了赞许，那么你可能就能得到好的绩效考核，如果你做的东西，没什么业务，一直内部团队应用，自己玩自己的，那么就是没产出，没价值，别想升职加薪了！

注意！！！给别的部门团队创造价值不属于给领导创造价值，反而可能会给领导添堵，因为人家领导成果多了，自家领导压力就大了！分清敌我关系！除非是合作项目，成果共享那种！

5. 尝试与别的部门团队的人认识，人脉等于机会！

我通过给公司软考群整理资料，认识了别的团队的人，也因此在之前考虑转部门团队的时候能找人打听情况。有时候不是这个公司不好，而是团队里某些人讨厌，当你想要逃离时，可以考虑转部门团队，如果你对他们有利用价值，他们将是你要用到的贵人！

让我狂笑一下，啊哈哈哈哈~

啦啦啦！我解脱啦！啦啦啦！我好快乐！

变量

变量概述

数据类型

运算符

算数运算符

递增递减运算符

比较运算符

逻辑运算符

赋值运算符

运算符优先级

选择结构

流程控制（顺序，分支，循环）

小结

数组

函数

函数基本概念

arguments

函数声明方式

JavaScript作用域

预解析

sum(1)(2,3)(4,5,6) js的链式调用

function sum(){

let arr = Array.prototype.slice.call(arguments);

fn = function(){

    let arr1 = Array.prototype.slice.call(arguements)

    return sum.apply(null,arr.concat(arr1))

}

//`reduce()` 方法将数组缩减为单个值。

//`reduce()` 方法为数组的每个值（从左到右）执行提供的函数。

//函数的返回值存储在累加器中（结果/总计）。

//注释：对没有值的数组元素，不执行 `reduce()` 方法。

//注释：`reduce()` 方法不会改变原始数组。

   fn.toString = function(){

       return arr.reduce((value,n)=>{

           return value+n

       })

   }

   return fn

}

//柯里化的高级实现

function curry(func){

    return curried(...args){

        if(args.length >= func.length){

            return func.apply(this,args);

        }else{

            return function(...args2){

                return curried.apply(this,args.concat(args2))

            }

        }

    }

}

面试点

sum(1)(2)(3)怎么实现

面试的时候，面试官让我讲一个这个怎么实现
当时想到的是嵌套闭包，调用返回值，进行累加

//这个是我在其他文章上看到的代码

function sum(a){

    function add(b){

        a =a+b

        return add;

    }

    add.toString = function(){

    return a;

    }    

    return sum;

    

查询了一下，涉及到了一个知识点，函数柯里化

//正常的函数

function sum(a,b){

    var sum = 0;

    sum = a+ b;

    console.log(sum);

}



//柯里化函数

function curry(a){

    return function(b){

        console.log(a+b)

    }

}

const sum = curry(1);

// 这个过程分为三步

// step1：

// addCurry(1)

// 返回下面的函数

// ƒ (arg) {

// 	return judge(1, arg);

// }

// step2：

// addCurry(1)(2)

// 返回下面的函数

// ƒ (arg) {

// 	return judge(1,2, arg);

// }

// step3：

// addCurry(1)(2)(3)

// 返回并执行下面的函数

// return fn(1,2,3);

// 最终得到结果6

函数柯里化

把接收多个参数的函数变换成接受一个单一参数的函数，并且但会接收余下的采纳数并且返回结果的新函数的技术。eg:它是指将一个函数从可调用的 f(a, b, c) 转换为可调用的 f(a)(b)(c)

参数复用

用于正则表达式的检验

//记录思路

    柯里化检验函数curry 

    const check = curry(); 

    生成工具化函数，进行验证

    const checkphone = check(/'正则表达式'/)

    检验电话号码

    checkphone('122333232');

延迟计算

返回的函数都不会立即执行，而是等待调用（开发者调用）

动态生成函数

比如说，在dom结点中每每绑定一次事件，都需要对环境进行判断，再去绑定这个事件；将这个过程进行柯里化，在使用前进行一次判断

const addEvent = (function() {

	if (window.addEventListener) {

		return function(ele) {

			return function(type) {

				return function(fn) {

					return function(capture) {

						ele.addEventListener(type, (e) => fn.call(ele, e), capture);

					}

				}

			}

		}

	} else if (window.attachEvent) {

		return function(ele) {

			return function(type) {

				return function(fn) {

					return function(capture) {

						ele.addEventListener(type, (e) => fn.call(ele, e), capture);

					}

				}

			}

		}

	}

})();



// 调用

addEvent(document.getElementById('app'))('click')((e) => {console.log('click function has been call:', e);})(false);



// 分步骤调用会更加清晰

const ele = document.getElementById('app');

// get environment

const environment = addEvent(ele)

// bind event

environment('click')((e) => {console.log(e)})(false);

//来自于[一文搞懂Javascript中的函数柯里化（currying） - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/120735088)

柯里化函数后虽然代码比较冗长，但是它的适用性增加了

柯里化封装

eg : sum(1,2,3...)

    //函数柯里化封装（这个封装可以直接复制走使用）

    function curry(fn, args) {

            var length = fn.length;

            var args = args || [];

            return function () {

                newArgs = args.concat(Array.prototype.slice.call(arguments));

                if (newArgs.length < length) {

                    return curry.call(this, fn, newArgs);

                } else {

                    return fn.apply(this, newArgs);

                }

            }

        }

        

        //需要被柯里化的函数

        function multiFn(a, b, c) {

            return a * b * c;

        }

        

        //multi是柯里化之后的函数

        var multi = curry(multiFn);

        console.log(multi(2)(3)(4));

        console.log(multi(2, 3, 4));

        console.log(multi(2)(3, 4));

        console.log(multi(2, 3)(4));

        //转载自[Javascript高级篇之函数柯里化 - 掘金 (juejin.cn)](https://juejin.cn/post/7111902909796712455)

Function.prototype

四个方法：apply，bind，call，toString

Function.prototype.bind()

定义

bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。（MDN）

const module = {

  x: 42,

  getX: function () {

    return this.x;

  },

};



const unboundGetX = module.getX;

console.log(unboundGetX()); // The function gets invoked at the global scope

// Expected output: undefined



const boundGetX = unboundGetX.bind(module);

console.log(boundGetX());

// Expected output: 42

Function.prototype.apply()

function 的实例的apply（）方法会以给定的this值和作为数组（或类数组对象）提供arguments调用该函数

const numbers = [5, 6, 2, 3, 7];

const max = Math.max.apply(null, numbers);

console.log(max);

// Expected output: 7

const min = Math.min.apply(null, numbers);

console.log(min);

// Expected output: 2

语法

apply(thisArg) apply(thisArg, argsArray)

参数

//argsArray --- 用于指定调用func时的参数，或者如果不需要向函数提供参数，则为null或undefined



//thisArg --- 调用func 时提供的this值，如果函数不处于严格对象，则null 和undefined 会被替换成全局对象，原始值会被转换成对象

返回值

使用指定的this值和参数调用函数的结果

Function.prototype.call()

Function 实例的 call() 方法会以给定的 this 值和逐个提供的参数调用该函数

//示例

function Product(name, price) {

  this.name = name;

  this.price = price;

}



function Food(name, price) {

  Product.call(this, name, price);

  this.category = 'food';

}



console.log(new Food('cheese', 5).name);

// Expected output: "cheese"

//语法

call(thisArg)

call(thisArg, arg1)

call(thisArg, arg1, arg2)

call(thisArg, arg1, arg2, /* …, */ argN)

Function.prototype.toString()

Function 实例的 toString() 方法返回一个表示该函数源码的字符串。

function sum(a, b) {

  return a + b;

}



console.log(sum.toString());

// Expected output: "function sum(a, b) {

//                     return a + b;

//                   }"



console.log(Math.abs.toString());

// Expected output: "function abs() { [native code] }"

放一个JavaScript的链接

转载自：http://www.cnblogs.com/wangdan0915…

关于我

由于高中的游手好闲、不学无术，没有考上大学。去了一所专科学校，本以为自己能够浪子回头，在学校好好学习。可惜的是，来到一个陌生又充满诱惑的城市后，迅速的迷失了自己，天天埋头打游戏，学习的事情早已抛之脑后。

一晃眼，到了2020年，疫情的接踵而至，让我这个本来没有任何技术、学历的“闲散人士”更加雪上加霜。豪不夸张的说，当时去实习，就差跪着求人家要我，说自己不要薪资。经历过一个月后，也就是2020年5月底，我找到了一份前端开发工作，从此开启了我的前端开发工作之旅。

在专科学校里的时间，我并没有意识到社会市场的残酷，甚至天真的认为自己还是能够辛苦点的找到一份工作。可是，现实给了我当头一棒，没有技术、没有学历、疫情打击。那一段时间应该是真的认知自己的时间，家里也没什么闲钱供我去培训班，我也不知道我出去能干嘛。去看了一圈市场，与跟同学的了解，了解到了前端开发工作，所以就一股脑扎进这个行业当中。

求职之旅

跟大多数人一样，并不知道应该从何处下手，当时在我的认知当中就知道一个 JQuery，所谓的 MVVM 框架简直是一无所知。点开小破站，找到点击率最高的视频，开始自学起来。

了解到一点框架的皮毛、然后死记硬背一点基础，统统写进简历当中。

所以我的学习曲线是如图下所示

graph TD

框架 --> 框架基础 --> JS,CSS,HTML

跟大多数人一样，我是直接通过框架起手学习的前端。导致了我对于问题的处理能力几乎为零，遇到问题直接就双手离开键盘。看不懂，是真的看不懂（如果有相同感受的可以在评论抠一个 1）。

对着视频学了十天左右，写了一个 demo，屁颠颠的去求职。结果也是可想而知，人家也不是傻子一眼识破。四处碰壁，简历丢出去，根本没人看。兜兜转转持续了一个月左右，终于有一家小公司愿意给一个面试机会，马不停蹄的出发去面试，坐了一个小时左右的地铁抵达一个破旧不堪的写字楼，当时要不是看到周围还有一个高校，我还以为我去了一个搞传销的地方。。。推开一个破旧的们，一个很小的房间，两个人坐在里面给我面试。我也很直白的说自己只会一点点皮毛，他们也很直白的告诉我：我们条件有限，相当于是各取所需。其实老实说，我挺感动的，没有给我画大饼，也很直白的说我图他们要我，他们图我不要啥钱。

最终，我也算是如愿找到了这份实习工作，一个月 2000。也算是不错的结果了。

实习项目开发

去到公司以后，也马不停蹄的开始了开发工作。首先就是让我从一个简单的后台管理系统开始入手。但是问题也来了，我根本不知道什么叫管理系统，连项目搭建我都不会，然后就是两眼一抹黑。不停的去百度，查看如何搭建一个后台管理系统。

老实说，我当时连路由是什么我都不清楚，更别说加一堆乱七八糟的功能在里面了。哪个过程可想而知，多么的折磨人。经历了半个月，模板被我折腾起来了一个简单的样子，对着人家的管理系统样子进行拙劣的模仿。但是 bug 满天飞也是避免不了的问题。并且没有丝毫的设计可言，纯纯的依托答辩。

最后的最后，实在是看不下去了（包括我自己），去网上扒了一个模板开始自己去折腾。为什么一开始不考虑使用模板呢？因为我看不懂代码，下不去手。

虽然最后跌跌撞撞的项目启动起来了，但是也算是我第一次项目开发的经历吧。后续持续的添加一些功能，改动一些简单的样式，还好老板也很佛系，没有为难我，基本上没有魔改模板。所以也算是顺利的完成了后台管理系统的开发任务。

小插曲

在实习工作的期间，在技术群中认识了一个很牛的大佬。经常我在群里问一些傻逼问题（因为自己基础太差了），但是他都会很耐心的给我讲解，甚至是下班后抽出时间给我远程讲课。也算是我的半个引路人吧，让我知道了如何去玩儿前端。在这里手动抠一个感谢🙏🙏🙏。

步入正轨

在经历过第一个项目开发后，也算是知道了框架应该如何去玩儿（也就是知道了框架的 api 如何去调用）。也知道了如何去学好前端，所以慢慢的回头去了解基前端的三大基础知识 js css html。

其实我相信很多人跟我一样，开始都是赶鸭子上架的形式去开发项目，遇到问题束手无策；遇到 bug 不知道如何去排查；遇到不知道如何去实现。。。最后我也总结出了问题所在，那就是基础的不扎实，学习顺序的问题，导致了这些问题。

啰嗦一句

哪怕是现在，我有时候跟网友聊天的时候也能听到一些让人不能理解的观点：前端那么简单有什么难度？前端不就是写写页面？前端。。。。

从我的观点出发而言，前端这个岗位确实是属于，宽进严出。想入行确实很容易，毕竟像我这样啥也不懂的，通过十来天的学习都能去做前端开发的事情。

但是，但是，但是，重要的话说三遍，前端的简单是因为它的入行门槛低。但是入门和会还是有本质的区别，绝大多数前端开发工作都是写 后台管理系统，这种开发，都是直接套用现成模板与组件就能够写。如果是定制化开发，脱离了后台管理系统的开发，那还是有手就行吗？

继续步入正轨

在工作的时间中，也认识了很多互联网大厂的大牛：滴滴、网易、腾讯等，经常厚着脸皮去请教他们。但是他们回应最多的是：多看基础，看书！

大佬们都这么说，那还等什么！直接开始行动。

• 绿宝书：犀牛书


• 红宝书：javascript高级程序设计


• 黄宝书：你不知道的js

直接搞起来！虽然我很讨厌看书，但是看到自己实习的 2k 工资，我还不动起来，那可能真就废了。

所以每天下班后，回家翻开书籍，开始看。果不其然，一看就打瞌睡，生涩、枯燥的知识内容。没办法，继续去请教如何看书学习，得到的答案就是：好记性，不如烂笔头。

然后读书的时候，边看边写，跟做笔记一样。效果果然好多了，没那么容易打瞌睡。而且我也买了一些零食（口香糖、耐嚼的肉干之类的）边看边吃，让自己集中注意力。总之是为了能够学到真知识，想尽了各种办法。

半个月后，看了几章节基础，感觉确实潜移默化的改变了一些。写代码的时候不会那么的茫然；反复调试的次数少了一些；知道了更多好用的 api ，代码质量有一定的提高。

读书笔记分享

读书笔记

在这里分享一篇，自己从零开始写的一些笔记。不过自己已经停更很久了。

实习总结

经过两个月的实习后，时间也来到了 2020年7月，我毕业了。我也学到了很多东西，但是我觉得，这样子的工作状态并不是我喜欢的。

回学校简单收拾了一下，也决定了辞职。去找一份更加有前途的工作，当然这里肯定有很多人疑惑：你凭什么啊？确实是如此，包括我的父母，也是很疑惑并且还质疑的问道：你上几个月班，忘了自己的实际情况了？

我也开始反思，自己真的就那么的蠢、那么的不堪吗？

果断辞职

经过我的深思熟虑后，还是在毕业后辞职了。在出租屋沉淀了一个月，这一个月基本上每天只睡了五六个小时，其余时间都花在了基础的夯实上面，狠狠的补充前端基础知识。每天醒来就是：看书、写 demo、请教大佬，每天如此，孜孜不倦。

一个月后，整理自己的简历，然后又开始了自己的求职之旅。

二次求职

求职之路，也并没有自己想的那么顺利。别人也没有因为我简历写的东西多了那么一点可怜的东西而青睐你。

我也在开始反思，自己的辞职是否正确。因为我的本质问题并没有解决：没有学历、没有经验。期间也在自我怀疑、自我安慰，也在凌晨的时候，抓耳挠腮，头发也在开始一大把一大把的掉。

就这样持续了一个月左右，我终于又收到了一份面试邀请。马不停蹄的前去面试，结果却出乎我的意料，他们并没有问我八股文，反而是对我所说的经历感兴趣。我也是添油加醋的说了一顿我的实习经历、辞职后的这一个月的学习经历。

最后的最后，他们通过了我的初试。给我说需要老大亲自面试，我开始很忐忑。但是见到老大后，他是一个很和蔼的老师，并没有刁难我，也没有问我刁钻问题，只是跟我谈了一下基本情况、了解了我的基本情况，就通过了我的二次面试。

二次求职之旅结果

我很幸运，因为，让我去打工的地方是一个资源丰富的高校。我的老大也是院长，初次面试的两位也是两位老师。我也如愿以偿的又有了一份新的工作，接触到了极其丰富的资源。

老师们也很愿意教授知识，让我的技术再次的突飞猛进。

开发项目：

• 北京冬奥会水立方保电系统


• 基于负荷聚合的园区能量态势感知与交易系统


• 电压暂降仿真模拟系统

薪资变化

毕业后，我的薪资也算是以每年翻倍的涨幅进步。也算是我的学习换来的回报吧。还是挺不错的～

现在

截至目前，经过三年零两个月的工作时间，也算是勉强迈入了初级前端开发的门槛吧。不断的学习中，也在积极的参与开源的贡献。

• Ray Template


• Vue3 Next QRcode


• Vue Hooks Plus

这些都是本人参与开发、贡献的项目，有兴趣可以点开看看。如果觉得有用也可以点一个小星星🌟～～～

最后

学习确实是一个枯燥的过程，也是一个很痛苦的过程。包括自己，如果不是那些大佬对我的帮助，我也不会那么快的进步。最后还是很衷心的感谢他们对我的帮助～

:is()

你是否曾经写过下方这样冗余的CSS选择器:

.active a,

.active button,

.active label {

  color: steelblue;

}

其实上面这段代码可以这样写：

.active :is(a, button, label) {

  color: steelblue;

}

看~是不是简洁了很多！

是的，你可以使用 :is() 对选择器的任何部分进行分组，例如，你可以对如下代码：

.section h2,

.aside h2,

.nav h2 {

  color: steelblue;

}

进行转换：

:is(.section, .aside, .nav) h2 {

  color: steelblue;

}

但是 :is() 不仅对父选择器和子选择器有用，它也可以选择多个相邻的选择器，比如:

button:is(:focus, :hover, :active) {

  color: steelblue;

}



button:is(.active, .pressed) {

  color: lightsteelblue;

}

上述代码等价于：

button:focus, button:hover, button:active {

  color: steelblue;

}



button.active, button.pressed {

  color: lightsteelblue;

}

:where()

:where() 是一个与 :is() 非常相似的伪类，也值得注意。它们看起来非常相似:

:where(.section, .aside, .nav) h2 {

  color: steelblue;

}

但区别在于 :where 的权重为 0，而:is() 总是会采用列表中最特高的选择器的权重。例如，你知道下面的 CSS 代码中的按钮是什么颜色吗?

:is(html) button {

  color: red;

}



:where(html) button {

  color: blue;

}

在上面的例子中，虽然以 :where() 开头的块在以 :is() 开头的块下面，但 :is() 块具有更高的权重。

:has()

一个相关但非常不同的伪类是:has()。:has() 允许选择包含匹配选择器(或选择器集)的子元素的父元素。

:has() 的一个示例是不显示下划线的情况下包含图像或视频的链接:

a { text-decoration: underline }



/* 链接有下划线，除非它们包含图像或视频 */

a:has(img, video) {

  text-decoration: none;

}

现在，如果默认情况下我们的 a 标记有下划线文本，但其中有图像或视频，则任何匹配的锚元素的下划线将被删除。

你也可以结合 :is() 使用：

:is(a, button):has(img, video) {

  text-decoration: none;

}

我们还需要预处理器吗?

现在你可能会说“SCSS可以做到这一点!，你甚至可能更喜欢它的语法:

.active {

  button, label, a {

    color: steelblue;

  }

}

说的没错，这很优雅。但是，CSS 似乎现在已经都能获取到我们曾经需要SCSS(或其他预处理器)才能获得的特性。

CSS 变量也是 CSS 本身的另一个不可思议的补充，它回避了一个问题：就是什么时候或者多久你真的需要预处理程序:

.active :is(a, button, label) {

  --color: steelblue;

  color: var(--steelblue);

}

这并不是说预处理器没有它们的用例和优点。

但我认为在某个时间点上，它们确实是处理任何重要CSS的强制要求，而现在情况不再如此了。

惊喜

我想说的是，CSS的未来仍然是光明的。CSS 工作组正积极致力于直接向CSS中添加嵌套选择器。他们正在积极地在3种可能的语法之间进行选择:

/* 1 */

article {

  font-family: avenir;

  & aside {

    font-size: 1rem;

  }

}



/* 2 */

article {

  font-family: avenir;

} {

  aside {

    font-size: 1rem;

  }

}



/* 3 */

@nest article {

  & {

    font-family: avenir;

  }

  aside {

    font-size: 1rem;

  }

}

你最喜欢哪一个?

庆幸的是，第 1 种已经被官方采纳！所以我们可能很快就会看到一个非常像 scss 的嵌套语法。

浏览器支持

目前所有主流浏览器都支持 :is() 和 :where() 伪类:

但是，需要注意，我们在这里提到的 :has() 伪类没有相同级别的支持，所以使用 :has() 时要小心:

神奇的点击事件

你知道我们在 document 中，用鼠标点击一次页面会发生什么吗？

可能你会告诉我，会触发一个或多个的 click 事件监听器，然后运行这个监听器的回调函数。

但是，这个过程中还有一些奇怪事情的一起出现了...

固定的事件触发顺序

在可注册的 Document Event 中，click 事件自然是最常见的事件。
不过点击一次页面并不是只会触发 click 事件，而是会触发许多个不同但又十分接近事件。
比如也算是老朋友的 mousedown、mouseup 等等。

如果说我们在同一个元素上注册多个如: mousedown、pointdown 等与点击相关的事件监听器，这时候它们会按照什么顺序触发呢？
触发的时候会是固定顺序的吗？

做一个小小的实验就可以知道，它们的触发顺序是固定的，且与注册顺序无关：

后续所有的 el 与 events 皆为此项不再赘述，
且在做出不同的测试时保证其节点不会存在上一个测试所遗留的事件监听器。（懒得写注销事件代码啦～）

const el = document.getElementById('app');

// 组合事件集合

const events: (keyof HTMLElementEventMap)[] = [

  'click',

  'mousedown',

  'mouseup',

  'pointerdown',

  'pointerup',

  'touchstart',

  'touchend',

];

// 注册组合事件

for (const event of events) {

  el.addEventListener(event, e => {

    console.log('触发了 ->', event);

  });

}

PC 端触发顺序为

pointerdown -> mousedown -> pointerup -> mouseup -> click

移动端触发顺序为

pointerdown -> touchstart -> pointerup -> touchend -> mousedown -> mouseup -> click

如上可知，pointerdown 始终是第一触发的事件（比 touchstart 还快）！而在移动端，mousedown 与 mouseup 都是在 touchend 之后触发的。
也就是说，当我们在触摸的时候，mousedown 无法触发，而是在手指离开屏幕的时候才会被触发！

高贵的 click 事件

那如果在始终我们在第一个触发的 pointerdown 事件中阻止了事件的默认行为，会发生什么呢？

再来一次小实验看看：

for (const event of events) {

  el.addEventListener(event, e => {

    if (event === 'pointerdown') {

      e.preventDefault();

    }

    console.log('触发了 ->', event);

  });

}

这个时候神奇的事情发生了，紧随其后的touchstart、pointerup和touchend依旧触发了，
而mousedown 与 mouseup 事件被阻止了，
但是属于最后触发的 click 事件却依然成功的触发了！

这就是 click 的高贵血统吗？

阻塞与异步也无法阻止事件触发的固定顺序

我们知道，浏览器是单线程的，所以在执行一个任务的时候，其他任务都会被阻塞。

那我们触发一个调皮的事件的时候让线程阻塞了，后续事件的触发顺序发生变化吗？

for (const event of events) {

  el.addEventListener(event, e => {

    console.time(`执行事件 ${event} 1`);

    let n = 0;

    // 主线程阻塞130ms左右

    for (let i = 0; i < 1000000; i++) {

      // 浮点数运算

      n += i ** ((Math.PI ** Math.PI) ** Math.PI);

    }

    console.timeEnd(`执行事件 ${event} 1`);

  });

  el.addEventListener(event, e => {

    console.time(`执行事件 ${event} 2`);

    let n = 0;

    // 主线程阻塞130ms左右

    for (let i = 0; i < 1000000; i++) {

      // 浮点数运算

      n += i ** ((Math.PI ** Math.PI) ** Math.PI);

    }

    console.timeEnd(`执行事件 ${event} 2`);

  });

}

可以看到，事件的触发顺序依旧是固定的，并不会因为事件的阻塞这种小事而产生动摇，
后续的事件需要等待前面的事件执行完毕之后才会被触发。

这看起来显而易见，因为事件的触发也属于主线程的任务，所以当主线程被阻塞的时候，事件的触发也会被阻塞。

那如果我们把事件的执行变成异步函数呢？还是会这么如我们所愿吗？

for (const event of events) {

  el.addEventListener(event, async e => {

    console.time(`执行事件 ${event}`);

    let n = 0;

    // 多了一个 0 所以是 1300ms~

    for (let i = 0; i < 10000000; i++) {

      n += i ** ((Math.PI ** Math.PI) ** Math.PI);

    }

    console.timeEnd(`执行事件 ${event}`);

    console.log('触发了 ->', event);

    await new Promise(resolve => {

      setTimeout(() => {

        console.log('Promise触发了 ->', event);

        resolve(0);

      }, 100);

    });

  });

}

从 log 中可得出，
参与下一个主线程执行的 Promise 的 log 会在 click 事件之后触发直接一起触发
（也可中得出 setTimeout 的局限性），
但当前主线程应当触发的事件与其触发的顺序依旧无法被撼动。

事件执行与页面渲染不能不说的关系

我们知道，浏览器的渲染是由主线程来完成的，所以当主线程被阻塞的时候，页面的渲染也会被阻塞。
当在一条事件链中修改了多次的 DOM 时，有关页面实际的绘制也将会被推迟到最后一次修改之后。

// 加一个transition看看效果

el.style.transition = 'all 1s';

for (const event of events) {

  el.addEventListener(event, e => {

    console.time(`执行事件 ${event}`);

    let n = 0;

    // 少了一个 0 所以是 130ms 啦~

    for (let i = 0; i < 1000000; i++) {

      n += i ** ((Math.PI ** Math.PI) ** Math.PI);

    }

    const backgroundColor = el.style.backgroundColor;

    // 简单的切换一下背景色

    el.style.backgroundColor = backgroundColor === 'black' ? 'white' : 'black';

    console.log('触发了 ->', event, el.style.backgroundColor);

    console.timeEnd(`执行事件 ${event}`);

  });

}

当事件触发完毕之前，el.style.backgroundColor 虽然被修改了，但页面的实际绘制被推迟，
只有其事件所有的执行结束之后，才姗姗来迟的展示出实际切换后的效果。

如果点的快就会导致各种鬼畜的现象:

渲染因为下一次事件的触发而导致被迫推迟，从而让页面看起像是闪烁了一下，
这样的用户体验是十分糟糕的。

如果说 backgroundColor 的修改只是一个属于**重绘（Repaint）小事的话，
那么如果我们在事件中修改了属于回流（Reflow）**会咋样？

// 加一个transition看看效果

el.style.transition = 'all 1s';

// 加个bg

el.style.backgroundColor = '#eee';

for (const event of events) {

  el.addEventListener(event, e => {

    console.time(`执行事件 ${event}`);

    let n = 0;

    // 少了一个 0 所以是 130ms 啦~

    for (let i = 0; i < 1000000; i++) {

      n += i ** ((Math.PI ** Math.PI) ** Math.PI);

    }

    // 默认100vh

    const height = el.style.height || el.getBoundingClientRect().height;

    // 调整高度

    el.style.height = parseInt(height.toString()) - 300 + 'px';

    console.log('触发了 ->', event);

    // style对象上的

    console.log('style.height ->', el.style.height);

    // 实际渲染的（DOMRect）

    console.log('getBoundingClientRect().height ->', el.getBoundingClientRect().height);

    console.timeEnd(`执行事件 ${event}`);

  });

}