前言

最近测试反馈一个问题，某个查询全量信息的接口，有时候返回全量数据，符合预期，但是偶尔又只返回1条数据，简直就是“见鬼”了，究竟是为什么出现这样的“幽灵数据”呢？

大胆猜测

首先我们看了下这对代码的业务逻辑，非常的简单，总共没有几行代码，也没有分页逻辑，代码如下：

public  List<SdSubscription> findAll() {

    return sdSubscriptionMapper.selectAll();

}

那么究竟是咋回事呢？讲道理不可能出现这种情况的啊，不要慌，我们加点日志，将日志级别调整为DEBUG，让日志飞一段时间。

public  List<SdSubscription> findAll() {

    log.info("find the sub start .....");

    List<SdSubscription> subs = sdSubscriptionMapper.selectAll();

     log.info("find the sub end .....");

    return subs;

}

果不其然，日志中出现了奇奇怪怪的分页参数，如下图所示:

果然是PageHelper这个开源框架搞的鬼，我想大家都用过吧，分页非常方便，那么究竟为什么别人都没问题，单单就我会出现问题呢?

PageHelper工作原理

为了回答上面的疑问，我们先看看PageHelper框架的工作原理吧。

PageHelper 是一个开源的 MyBatis 分页插件，它可以帮助开发者在查询数据时，快速的实现分页功能。

PageHelper 的工作原理可以简单概括为以下几个步骤：

PageHelper 的实现原理主要依赖于拦截器技术和反射机制，通过拦截查询语句并动态生成分页语句，实现了简单、高效、通用的分页功能。具体源码在下图的类中，非常容易看懂。

明白了PageHelper的工作原理后，反复检查代码，都没有调用过startPage，debug查看ThreadLocal中也没有分页信息啊，懵逼中。那我看看别人写的添加分页参数的代码吧，不看不知道，一看吓一跳。

原来有位“可爱”的同事竟然在查询后，加了一个分页，就是把分页信息放到线程的ThreadLocal中。

那大家是不是有疑问，丁是丁，矛是矛，你的线程关我何事？这就要说到我们的tomcat了。

Tomcat请求流程

其实这就涉及到我们的tomcat相关知识了，我们一个浏览器发一个接口请求，经过我们的tomcat的，究竟是一个什么样的流程呢？

关于tomcat中使用线程池提交浏览器的连接请求的源码如下：

从而得知，你的连接请求是从线程池从拿的，而拿到的这个线程恰好是一个“脏线程”，在ThreadLocal中放了分页信息，导致你这边出现问题。

总结

后来追问了同事具体原因，才发现是粗心导致的。有些bug总是出现的莫名其妙，就像生活一样。所以关键的是我们在使用一些开源框架的时候一定要掌握底层实现的原理、核心的机制，这样才能够在解决一些问题的时候有据可循。

欢迎关注个人公众号【JAVA旭阳】交流学习！

在这篇博客中，我们将分享 10+ 个实用的一行 JavaScript 代码，这些代码可以帮助你提高编码效率和代码简洁度。这些代码片段将涵盖各种用途，从操作数组和字符串，到更高级的概念，如异步编程和面向对象编程。

获取数组中的随机元素

使用 Math.random() 函数和数组长度可以轻松获取数组中的随机元素：

const arr = [1, 2, 3, 4, 5];

const randomElement = arr[Math.floor(Math.random() * arr.length)];

console.log(randomElement);

数组扁平化

使用 reduce() 函数和 concat() 函数可以轻松实现数组扁平化：

const arr = [[1, 2], [3, 4], [5, 6]];

const flattenedArr = arr.reduce((acc, cur) => acc.concat(cur), []);

console.log(flattenedArr); // [1, 2, 3, 4, 5, 6]

对象数组根据某个属性值进行排序

const sortedArray = array.sort((a, b) => (a.property > b.property ? 1 : -1));

从数组中删除特定元素

const removedArray = array.filter((item) => item !== elementToRemove);

检查数组中是否存在重复项

const hasDuplicates = (array) => new Set(array).size !== array.length;

判断数组是否包含某个值

const hasValue = arr.includes(value);

首字母大写

const capitalized = str.charAt(0).toUpperCase() + str.slice(1);

获取随机整数

const randomInt = Math.floor(Math.random() * (max - min + 1)) + min;

获取随机字符串

const randomStr = Math.random().toString(36).substring(2, length);

使用解构和 rest 运算符交换变量的值：

let a = 1, b = 2

[b, a] = [a, b]

console.log(a, b) // 2, 1

将字符串转换为小驼峰式命名：

const str = 'hello world'

const camelCase = str.replace(/\s(.)/g, ($1) => $1.toUpperCase()).replace(/\s/g, '').replace(/^(.)/, ($1) => $1.toLowerCase())

console.log(camelCase) // "helloWorld"

计算两个日期之间的间隔

const diffInDays = (dateA, dateB) => Math.floor((dateB - dateA) / (1000 * 60 * 60 * 24));

查找日期位于一年中的第几天

const dayOfYear = (date) => Math.floor((date - new Date(date.getFullYear(), 0, 0)) / 1000 / 60 / 60 / 24);

复制内容到剪切板

const copyToClipboard = (text) => navigator.clipboard.writeText(text);



copyToClipboard("Hello World");

获取变量的类型

const getType = (variable) => Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();



getType('');     // string

getType(0);      // number

getType();       // undefined

getType(null);   // null

getType({});     // object

getType([]);     // array

getType(0);      // number

getType(() => {});  // function

检测对象是否为空

const isEmptyObject = (obj) => Object.keys(obj).length === 0 && obj.constructor === Object;

系列文章

• 10个超级实用的reduce使用技巧


• 10个超级实用的Set、Map使用技巧


• 10个超级好用的Javascript技巧

我的更多前端资讯

欢迎大家技术交流 资料分享 摸鱼 求助皆可 —链接

大家好，我是老三，今天和大家聊一个话题：项目中用到的力扣算法。

不知道从什么时候起，算法已经成为了互联网面试的标配，在十年前，哪怕如日中天的百度，面试也最多考个冒泡排序。后来，互联网越来越热，涌进来的人越来越多，整个行业越来越内卷的，算法也慢慢成了大小互联网公司面试的标配，力扣现在已经超过3000题了，那么这些题目有多少进入了面试的考察呢？

以最爱考算法的字节跳动为例，看看力扣的企业题库，发现考过的题目已经有1850道——按照平均每道题花20分钟来算，刷完字节题库的算法题需要37000分钟，616.66小时，按每天刷满8小时算，需要77.08天，一周刷五天，需要15.41周，按一个月四周，需要3.85个月。也就是说，在脱产，最理想的状态下，刷完力扣的字节题库，需要差不多4个月时间。

那么，我在项目里用过，包括在项目中见过哪些力扣上的算法呢？我目前刷了400多道题，翻来覆去盘点了一下，发现，也就这么几道。

1.版本比较：比较客户端版本

场景

在日常的开发中，我们很多时候可能面临这样的情况，兼容客户端的版本，尤其是Android和iPhone，有些功能是低版本不支持的，或者说有些功能到了高版本就废弃掉。

这时候就需要进行客户端的版本比较，客户端版本号通常是这种格式6.3.40，这是一个字符串，那就肯定不能用数字类型的比较方法，需要自己定义一个比较的工具方法。

题目

165. 比较版本号

这个场景对应LeetCode： 165. 比较版本号。

• 题目：165. 比较版本号 (leetcode.cn/problems/co…)


• 难度：中等


• 标签：双指针 字符串


• 描述：
  
  

  给你两个版本号 version1 和 version2 ，请你比较它们。

  
  

  版本号由一个或多个修订号组成，各修订号由一个 '.' 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。

  
  

  比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。例如，版本 1.0 小于版本 1.1 ，因为它们下标为 0 的修订号相同，而下标为 1 的修订号分别为 0 和 1 ，0 < 1 。

  
  

  返回规则如下：

  
  
  
  
  • 如果 *version1* > *version2* 返回 1，
  
  
  • 如果 *version1* < *version2* 返回 -1，
  
  
  • 除此之外返回 0。
  
  
  
  

  示例 1：

  
  

  输入：version1 = "1.01", version2 = "1.001"
  
  输出：0
  
  解释：忽略前导零，"01" 和 "001" 都表示相同的整数 "1"
  
  

  
  

  示例 2：

  
  

  输入：version1 = "1.0", version2 = "1.0.0"
  
  输出：0
  
  解释：version1 没有指定下标为 2 的修订号，即视为 "0"
  
  

  
  

  示例 3：

  
  

  输入：version1 = "0.1", version2 = "1.1"
  
  输出：-1
  
  解释：version1 中下标为 0 的修订号是 "0"，version2 中下标为 0 的修订号是 "1" 。0 < 1，所以 version1 < version2
  
  

  
  

  提示：

  
  
  
  
  • 1 <= version1.length, version2.length <= 500
  
  
  • version1 和 version2 仅包含数字和 '.'
  
  
  • version1 和 version2 都是 有效版本号
  
  
  • version1 和 version2 的所有修订号都可以存储在 32 位整数 中
  
  
  
  

解法

那么这道题怎么解呢？这道题其实是一道字符串模拟题，就像标签里给出了了双指针，这道题我们可以用双指针+累加来解决。

• 两个指针遍历version1和version2


• 将. 作为分隔符，通过累加获取每个区间代表的数字


• 比较数字的大小，这种方式正好可以忽略前导0

来看看代码:

class Solution {

    public int compareVersion(String version1, String version2) {

        int m = version1.length();

        int n = version2.length();

​

        //两个指针

        int p = 0, q = 0;

​

        while (p < m || q < n) {

            //累加version1区间的数字

            int x = 0;

            while (p < m && version1.charAt(p) != '.') {

                x += x * 10 + (version1.charAt(p) - '0');

                p++;

            }

​

            //累加version2区间的数字

            int y = 0;

            while (q < n && version2.charAt(q) != '.') {

                y += y * 10 + (version2.charAt(q) - '0');

                q++;

            }

​

            //判断

            if (x > y) {

                return 1;

            }

            if (x < y) {

                return -1;

            }

​

            //跳过.

            p++;

            q++;

        }

        //version1等于version2

        return 0;

    }

}

​

应用

这段代码，直接CV过来，就可以直接当做一个工具类的工具方法来使用：

public class VersionUtil {

​

    public static Integer compareVersion(String version1, String version2) {

        int m = version1.length();

        int n = version2.length();

​

        //两个指针

        int p = 0, q = 0;

​

        while (p < m || q < n) {

            //累加version1区间的数字

            int x = 0;

            while (p < m && version1.charAt(p) != '.') {

                x += x * 10 + (version1.charAt(p) - '0');

                p++;

            }

​

            //累加version2区间的数字

            int y = 0;

            while (q < n && version2.charAt(q) != '.') {

                y += y * 10 + (version2.charAt(q) - '0');

                q++;

            }

​

            //判断

            if (x > y) {

                return 1;

            }

            if (x < y) {

                return -1;

            }

​

            //跳过.

            p++;

            q++;

        }

        //version1等于version2

        return 0;

    }

}

​

前面老三分享过一个规则引擎：这款轻量级规则引擎，真香！

比较版本号的方法，还可以结合规则引擎来使用：

• 自定义函数：利用AviatorScript的自定义函数特性，自定义一个版本比较函数
  
  

      /**
  
       * 自定义版本比较函数
  
       */
  
      class VersionFunction extends AbstractFunction {
  
          @Override
  
          public String getName() {
  
              return "compareVersion";
  
          }
  
  ​
  
          @Override
  
          public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
  
              // 获取版本
  
              String version1 = FunctionUtils.getStringValue(arg1, env);
  
              String version2 = FunctionUtils.getStringValue(arg2, env);
  
              return new AviatorBigInt(VersionUtil.compareVersion(version1, version2));
  
          }
  
      }
  
  

  
  


• 注册函数：将自定义的函数注册到AviatorEvaluatorInstance中
  
  

      /**
  
       * 注册自定义函数
  
       */
  
      @Bean
  
      public AviatorEvaluatorInstance aviatorEvaluatorInstance() {
  
          AviatorEvaluatorInstance instance = AviatorEvaluator.getInstance();
  
          // 默认开启缓存
  
          instance.setCachedExpressionByDefault(true);
  
          // 使用LRU缓存，最大值为100个。
  
          instance.useLRUExpressionCache(100);
  
          // 注册内置函数，版本比较函数。
  
          instance.addFunction(new VersionFunction());
  
          return instance;
  
      }
  
  

  
  


• 代码传递上下文：在业务代码里传入客户端、客户端版本的上下文
  
  

      /**
  
       * @param device  设备
  
       * @param version 版本
  
       * @param rule    规则脚本
  
       * @return 是否过滤
  
       */
  
      public boolean filter(String device, String version, String rule) {
  
          // 执行参数
  
          Map<String, Object> env = new HashMap<>();
  
          env.put("device", device);
  
          env.put("version", version);
  
          //编译脚本
  
          Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
  
          //执行脚本
  
          boolean isMatch = (boolean) expression.execute(env);
  
          return isMatch;
  
      }
  
  

  
  


• 编写脚本：接下来我们就可以编写规则脚本，规则脚本可以放在数据库，也可以放在配置中心，这样就可以灵活改动客户端的版本控制规则
  
  

  if(device==bil){
  
      return false;
  
  }
  
  
  
  ## 控制Android的版本
  
  if (device=="Android" && compareVersion(version,"1.38.1")<0){
  
      return false;
  
  }
  
  
  
  return true;
  
  

  
  

2.N叉数层序遍历：翻译商品类型

场景

一个跨境电商网站，现在有这么一个需求：把商品的类型进行国际化翻译。

商品的类型是什么结构呢？一级类型下面还有子类型，字类型下面还有子类型，我们把结构一画，发现这就是一个N叉树的结构嘛。

翻译商品类型，要做的事情，就是遍历这棵树，翻译节点上的类型，这不妥妥的BFS或者DFS！

题目

429. N 叉树的层序遍历

这个场景对应LeetCode：429. N 叉树的层序遍历。

• 题目：429. N 叉树的层序遍历(leetcode.cn/problems/n-…)


• 难度：中等


• 标签：树 广度优先搜索


• 描述：
  
  

  给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

  
  

  树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

  
  

  示例 1：

  
  

  

  
  

  输入：root = [1,null,3,2,4,null,5,6]
  
  输出：[[1],[3,2,4],[5,6]]
  
  

  
  

  示例 2：

  
  

  

  
  

  输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
  
  输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
  
  

  
  

  提示：

  
  
  
  
  • 树的高度不会超过 1000
  
  
  • 树的节点总数在 [0, 10^4] 之间
  
  
  
  

解法

BFS想必很多同学都很熟悉了，DFS的秘诀是栈，BFS的秘诀是队列。

层序遍历的思路是什么呢？

使用队列，把每一层的节点存储进去，一层存储结束之后，我们把队列中的节点再取出来，孩子节点不为空，就把孩子节点放进去队列里，循环往复。

代码如下：

class Solution {

   public List<List<Integer>> levelOrder(Node root) {

        List<List<Integer>> result = new ArrayList<>();

        if (root == null) {

            return result;

        }



        //创建队列并存储根节点

        Deque<Node> queue = new LinkedList<>();

        queue.offer(root);



        while (!queue.isEmpty()) {

            //存储每层结果

            List<Integer> level = new ArrayList<>();

            int size = queue.size();

            for (int i = 0; i < size; i++) {

                Node current = queue.poll();

                level.add(current.val);

                //添加孩子

                if (current.children != null) {

                    for (Node child : current.children) {

                        queue.offer(child);

                    }

                }

            }

            //每层遍历结束，添加结果

            result.add(level);

        }

        return result;

    }

}

应用

商品类型翻译这个场景下，基本上和这道题目大差不差，不过是两点小区别：

• 商品类型是一个属性多一些的树节点


• 翻译过程直接替换类型名称即可，不需要返回值

来看下代码：

• ProductCategory：商品分类实体
  
  

  public class ProductCategory {
  
      /**
  
       * 分类id
  
       */
  
      private String id;
  
      /**
  
       * 分类名称
  
       */
  
      private String name;
  
      /**
  
       * 分类描述
  
       */
  
      private String description;
  
      /**
  
       * 子分类
  
       */
  
      private List<ProductCategory> children;
  
    
  
      //省略getter、setter
  
    
  
  }  
  
  

  
  

• translateProductCategory：翻译商品类型方法
  
  

     public void translateProductCategory(ProductCategory root) {
  
          if (root == null) {
  
              return;
  
          }
  
  
  
          Deque<ProductCategory> queue = new LinkedList<>();
  
          queue.offer(root);
  
  
  
          //遍历商品类型，翻译
  
          while (!queue.isEmpty()) {
  
              int size = queue.size();
  
              //遍历当前层
  
              for (int i = 0; i < size; i++) {
  
                  ProductCategory current = queue.poll();
  
                  //翻译
  
                  String translation = translate(current.getName());
  
                  current.setName(translation);
  
                  //添加孩子
  
                  if (current.getChildren() != null && !current.getChildren().isEmpty()) {
  
                      for (ProductCategory child : current.getChildren()) {
  
                          queue.offer(child);
  
                      }
  
                  }
  
              }
  
          }
  
      }
  
  

  
  

3.前缀和+二分查找：渠道选择

场景

在电商的交易支付中，我们可以选择一些支付方式，来进行支付，当然，这只是交易的表象。

在支付的背后，一种支付方式，可能会有很多种支付渠道，比如Stripe、Adyen、Alipay，涉及到多个渠道，那么就涉及到决策，用户的这笔交易，到底交给哪个渠道呢？

这其实是个路由问题，答案是加权随机，每个渠道有一定的权重，随机落到某个渠道，加权随机有很多种实现方式，其中一种就是前缀和+二分查找。简单说，就是先累积所有元素权重，再使用二分查找来快速查找。

题目

先来看看对应的LeetCode的题目，这里用到了两个算法：前缀和和二分查找。

704. 二分查找

• 题目：704. 二分查找(leetcode.cn/problems/bi…)


• 难度：简单


• 标签：数组 二分查找


• 描述：
  
  

  给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

  
  

  示例 1:

  
  

  输入: nums = [-1,0,3,5,9,12], target = 9
  
  输出: 4
  
  解释: 9 出现在 nums 中并且下标为 4
  
  

  
  

  示例 2:

  
  

  输入: nums = [-1,0,3,5,9,12], target = 2
  
  输出: -1
  
  解释: 2 不存在 nums 中因此返回 -1
  
  

  
  

  提示：

  
  
  
  
  1. 你可以假设 nums 中的所有元素是不重复的。
  
  
  2. n 将在 [1, 10000]之间。
  
  
  3. nums 的每个元素都将在 [-9999, 9999]之间。
  
  
  
  

解法

二分查找可以说我们都很熟了。

数组是有序的，定义三个指针，left、right、mid，其中mid是left、right的中间指针，每次中间指针指向的元素nums[mid]比较和target比较:

• 如果nums[mid]等于target，找到目标


• 如果nums[mid]小于target，目标元素在(mid,right]区间；


• 如果nums[mid]大于target，目标元素在[left,mid)区间

代码：

class Solution {

    public int search(int[] nums, int target) {

        int left=0;

        int right=nums.length-1;



        while(left<=right){

            int mid=left+((right-left)>>1);

            if(nums[mid]==target){

                return mid;

            }else if(nums[mid]<target){

                //target在(mid,right]区间，右移

                left=mid+1;

            }else{

                //target在[left,mid)区间，左移

                right=mid-1;

            }

        }

        return -1;

    }

}

二分查找，有一个需要注意的细节，计算mid的时候：int mid = left + ((right - left) >> 1);，为什么要这么写呢？

因为这种写法int mid = (left + right) / 2;，可能会因为left和right数值太大导致内存溢出。同时，使用位运算，也是除以2最高效的写法。

——这里有个彩蛋，后面再说。

303. 区域和检索 - 数组不可变

不像二分查找，在LeetCode上，前缀和没有直接的题目，因为本身前缀和更多是一种思路，一种工具，其中303. 区域和检索 - 数组不可变 是一道典型的前缀和题目。

• 题目：303. 区域和检索 - 数组不可变(leetcode.cn/problems/ra…)


• 难度：简单


• 标签：设计 数组 前缀和


• 描述：
  
  

  给定一个整数数组 nums，处理以下类型的多个查询:

  
  
  
  
  1. 计算索引 left 和 right （包含 left 和 right）之间的 nums 元素的 和 ，其中 left <= right
  
  
  
  

  实现 NumArray 类：

  
  
  
  
  • NumArray(int[] nums) 使用数组 nums 初始化对象
  
  
  • int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ，包含 left 和 right 两点（也就是 nums[left] + nums[left + 1] + ... + nums[right] )
  
  
  
  

  示例 1：

  
  

  输入：
  
  ["NumArray", "sumRange", "sumRange", "sumRange"]
  
  [[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
  
  输出：
  
  [null, 1, -1, -3]
  
  
  
  解释：
  
  NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
  
  numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
  
  numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1)) 
  
  numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
  
  

  
  

  提示：

  
  
  
  
  • 1 <= nums.length <= 104
  
  
  • -105 <= nums[i] <= 105
  
  
  • 0 <= i <= j < nums.length
  
  
  • 最多调用 104 次 sumRange 方法
  
  
  
  

解法

这道题，我们如果不用前缀和的话，写起来也很简单：

class NumArray {

    private int[] nums;



    public NumArray(int[] nums) {

        this.nums=nums;

    }

    

    public int sumRange(int left, int right) {

        int res=0;

        for(int i=left;i<=right;i++){

            res+=nums[i];

        }

        return res;

    }

}

当然时间复杂度偏高，O(n)，那么怎么使用前缀和呢？

• 构建一个前缀和数组，用来累积 (0……i-1)的和，这样一来，我们就可以直接计算[left,right]之间的累加和

代码如下：

class NumArray {

    private int[] preSum;



    public NumArray(int[] nums) {

        int n=nums.length;

        preSum=new int[n+1];

        //计算nums的前缀和

        for(int i=0;i<n;i++){

            preSum[i+1]=preSum[i]+nums[i];

        }

    }

    

    //直接算出区间[left,right]的累加和

    public int sumRange(int left, int right) {

        return preSum[right+1]-preSum[left];

    }

}

可以看到，通过前缀和数组，可以直接算出区间[left,right]的累加和，时间复杂度O(1)，可以说非常高效了。

应用

了解了前缀和和二分查找之后，回归我们之前的场景，使用前缀和+二分查找来实现加权随机，从而实现对渠道的分流选择。

• 需要根据渠道和权重的配置，生成一个前缀和数组，来累积权重的值，渠道也通过一个数组进行分配映射


• 用户的支付请求进来的时候，生成一个随机数，二分查找找到随机数载前缀和数组的位置，映射到渠道数组


• 最后通过渠道数组的映射，找到选中的渠道

代码如下：

/**

 * 支付渠道分配器

 */

public class PaymentChannelAllocator {

    //渠道数组

    private String[] channels;

    //前缀和数组

    private int[] preSum;

    private ThreadLocalRandom random;



    /**

     * 构造方法

     *

     * @param channelWeights 渠道分流权重

     */

    public PaymentChannelAllocator(HashMap<String, Integer> channelWeights) {

        this.random = ThreadLocalRandom.current();

        // 初始化channels和preSum数组

        channels = new String[channelWeights.size()];

        preSum = new int[channelWeights.size()];



        // 计算前缀和

        int index = 0;

        int sum = 0;

        for (String channel : channelWeights.keySet()) {

            sum += channelWeights.get(channel);

            channels[index] = channel;

            preSum[index++] = sum;

        }

    }



    /**

     * 渠道选择

     */

    public String allocate() {

        // 生成一个随机数

        int rand = random.nextInt(preSum[preSum.length - 1]) + 1;



        // 通过二分查找在前缀和数组查找随机数所在的区间

        int channelIndex = binarySearch(preSum, rand);

        return channels[channelIndex];

    }



    /**

     * 二分查找

     */

    private int binarySearch(int[] nums, int target) {

        int left = 0;

        int right = nums.length - 1;



        while (left <= right) {

            int mid = left + ((right - left) >> 2);

            if (nums[mid] == target) {

                return mid;

            } else if (nums[mid] < target) {

                left = mid + 1;

            } else {

                right = mid - 1;

            }

        }

        // 当找不到确切匹配时返回大于随机数的最小前缀和的索引

        return left;

    }

}

测试一下：

    @Test

    void allocate() {

        HashMap<String, Integer> channels = new HashMap<>();

        channels.put("Adyen", 50);

        channels.put("Stripe", 30);

        channels.put("Alipay", 20);



        PaymentChannelAllocator allocator = new PaymentChannelAllocator(channels);



        // 模拟100次交易分配

        for (int i = 0; i < 100; i++) {

            String allocatedChannel = allocator.allocate();

            System.out.println("Transaction " + (i + 1) + " allocated to: " + allocatedChannel);

        }

    }

彩蛋

在这个渠道选择的场景里，还有两个小彩蛋。

二分查找翻车

我前面提到了一个二分查找求mid的写法：

int mid=left+((right-left)>>1);

这个写法机能防止内存溢出，用了位移运算也很高效，但是，这个简单的二分查找写出过问题，直接导致线上cpu飙升，差点给老三吓尿了。

int mid = (right - left) >> 2 + left;

就是这行代码，看出什么问题来了吗？

——它会导致循环结束不了！

为什么呢？因为>>运算的优先级是要低于+的，所以这个运算实际上等于：

int mid = (right - left) >> (2 + left);

在只有两个渠道的时候没有问题，三个的时候就寄了。

当然，最主要原因还是没有充分测试，所以大家知道我在上面为什么特意写了单测吧。

加权随机其它写法

这里用了前缀和+二分查找来实现加权随机，其实加权随机还有一些其它的实现方法，包括别名方法、树状数组、线段树 、 随机列表扩展 、 权重累积等等方法，大家感兴趣可以了解一下。

印象比较深刻的是，有场面试被问到了怎么实现加权随机，我回答了权重累积、前缀和+二分查找，面试官还是不太满意，最后面试官给出了他的答案——随机列表扩展。

什么是随机列表扩展呢？简单说，就是创建一个足够大的列表，根据权重，在相应的区间，放入对应的渠道，生成随机数的时候，就可以直接获取对应位置的渠道。

public class WeightedRandomList {

    private final List<String> expandedList = new ArrayList<>();

    private final Random random = new Random();



    public WeightedRandomList(HashMap<String, Integer> weightMap) {

        // 填充 expandedList，根据权重重复元素

        for (String item : weightMap.keySet()) {

            int weight = weightMap.get(item);

            for (int i = 0; i < weight; i++) {

                expandedList.add(item);

            }

        }

    }



    public String getRandomItem() {

        // 生成随机索引并返回对应元素

        int index = random.nextInt(expandedList.size());

        return expandedList.get(index);

    }



    public static void main(String[] args) {

        HashMap<String, Integer> items = new HashMap<>();

        items.put("Alipay", 60);

        items.put("Adyen", 20);

        items.put("Stripe", 10);



        WeightedRandomList wrl = new WeightedRandomList(items);



        // 演示随机选择

        for (int i = 0; i < 10; i++) {

            System.out.println(wrl.getRandomItem());

        }

    }

}

这种实现方式就是典型的空间换时间，空间复杂度O(n)，时间复杂度O(1)。优点是时间复杂度低，缺点是空间复杂度高，如果权重总和特别大的时候，就需要一个特别大的列表来存储元素。

当然这种写法还是很巧妙的，适合元素少、权重总和小的场景。

刷题随想

上面就是我在项目里用到过或者见到过的LeetCode算法应用，416:4，不足1%的使用率，还搞出过严重的线上问题。

……

在力扣社区里关于算法有什么的贴子里，有这样的回复：

“最好的结构是数组，最好的算法是遍历”。

“最好的算法思路是暴力。”

……

坦白说，如果不是为了面试，我是绝对不会去刷算法的，上百个小时，用在其他地方，绝对收益会高很多。

从实际应用去找刷LeetCode算法的意义，本身没有太大意义，算法题的最大意义就是面试。

刷了能过，不刷就挂，仅此而已。

这些年互联网行业红利消失，越来越多的算法题，只是内卷的产物而已。

当然，从另外一个角度来看，考察算法，对于普通的打工人，可能是个更公平的方式——学历、背景都很难卷出来，但是算法可以。

我去年面试的真实感受，“没机会”比“面试难”更令人绝望。

写到这，有点难受，刷几道题缓一下！

​

​

参考：

[1].leetcode.cn/circle/disc…

[2].36kr.com/p/121243626…

[3].leetcode.cn/circle/disc…

[4].leetcode.cn/circle/disc…

​

​

备注：涉及敏感信息，文中的代码都不是真实的投产代码，作者进行了一定的脱敏和演绎。

2023年我的经历可以说是和大A一样，用今年的经历给大家几个忠告，希望我的经历让各位乐呵一下，学习到一些职场的小知识。

本人现任职某产业互联网独角兽公司交易部门后端开发，会点前端已经在这里躺了2年多。

春节前

第一次大跌从1月20号开始，也就是春节放假前一天按照以往的经历是20号会发年终然而公司一波顶级操作一纸公告下来只有ABC绩效有年终而且与之前相比还打折，打开手机一看1000块过节费。后来才知道只给了部门几个可以拿年终的绩效名额，其他80%都是D。就这样拿着过节费过了一个年。

春节后

过完年回来后3月底要给我降薪，从组长那里得知原因是绩效评估是E，开完会后连忙去OA查询发现绩效评估为D，后来组长知道后开始和HR沟通。20号左右HR开始找我谈话开头先是道歉又说降薪不是以绩效为标准而是22年的几次线上事故影响过大原因。

一会是绩效组长沟通后又不是绩效，让我感觉是恶意降薪，就这样一直扯皮到快4月份。由于那段时间需要处理的事情太多不想和她扯皮所以选择同意降薪。

后来的小道消息得知系统录入的绩效和HR那里是两份，而系统里面高是因为有项目的加分，真不懂他们的绩效评估是怎么做的，那段时间真是可以说掉到了谷底身心俱疲。到今天想起来如果没有和别人说我系统中D绩效 HR没准也不会有其他理由降薪。

给打工人的第一个忠告：在公司里面谁也不要相信，定期收集考勤、加班证据，把证据握在自己手里，至于代码事故问题就写单元测试，留好评审会议记录，测试记录证据至少这样可以不被认定为主要责任。

9月、10月、11月裁员

之前一直听组长说23年业绩一直不好公司想要裁员到9月还是等到了，好像定了10个人将近部门人数的三分之一。因为公司砍掉了年终而且加班严重有几个小伙伴也有走的意愿，定了5个开发，还有几个转岗。10月又裁了几个开发，和被裁的小伙伴交流公司裁掉的全是年轻人30往上的一个没动，11月测试部门述职定不下名额直接两个测试全部裁掉

谈补偿HR又是神级操作先是套路员工灌输是自己想走，不是公司裁员不想给补偿金，后来又想按照实习期工资补偿，被部门几个人骂了后妥协了，年假还是不想给最后按照一倍补偿。到了发薪日又是一波操作最后几天的工资不给，听说要起诉公司又拖了一个月才发。都把人家裁了最后一天还在让别人加班太顶了。

给大家的第二个忠告：裁员的话不要慌也不要怕，一定要强硬，不要随便签字属于自己的赔偿一定要争取：赔偿金、代通知金、加班费、年假都算上，确定好最后的上班时间、社保、发薪时间。

给大家的第三个忠告：在公司不要和招惹或者和那些老员工、领导身边的红人翻脸，他们这些人就是能决定领导的想法，一边添油加醋一边对你笑嘻嘻

小插曲

8月底的一天HR突然找我说工时不够要扣工资，正常应该出勤23天184个小时，我其中一天请了假22天出勤了188个小时。按照之前公司要求加班的工时可以抵请假时长我用22天出勤了23天应出勤的时间是没问题的。HR的顶级算法是即使请假也要够应出勤工时然后多出来的才可以使用抵扣。真是这公司HR就是个大聪明数学不会算，最后还是没扣。

年底

今年公司严格控制了部门支出，打车报销严查、加班也不管饭了。裁员后能干活的走了一半，现在的项目开发流程真是一言难尽，产品不设计原型、不写需求文档、不在OA提需求还说没有时间，需求没确定、没宣讲已经开始让开发这边开始了，开发按照做完初稿原型做完推倒重来。
三季度公司偷偷把社保调整到了80%，年底大言不惭的说在国家允许的情况下公积金调整到了5%，每次开会就是PUA让我们看看别的企业都在裁员应该把公司当成自己家一样。小道消息今年也没有年终。又沉闷的过了一年

出京

年终没了、也降薪了，放假后不想待在北京了端午直接去了杭州，由于接近亚运会的时间所以杭州氛围非常好，这个时候有点小梅雨，西湖边上拍的环境和氛围真的好。

周末和朋友们还去了承德,这个阳光和草原真绝了

11月去了南京，去南京是也为了自己的执念吧她还是没同意，这么久了也是时候放下了，第一次为了一个人跨越千里去了一个陌生的城市，鸡鸣寺的小猫都是两只。

年底和朋友几个去了威海，认识了一个辽宁的大哥开车带我们玩了一整天

给大家的第四个忠告：工作不是你的全部，甚至不是你的生活，你要按照自己想过的方式去活着，有些事和东西得到了当然很好，你要知道得不到也不是你的问题尽人事听天命，降低期待。

2024计划

今年的计划是：

iframe被用于将一个网页嵌套在另一个网页中，有的时候这会带来一些安全问题，这时我们就需要一些防嵌套操作了。

本文分为俩部分，一部分讲解如何检测或者禁止嵌套操作，另一部分讲解如何从嵌套中跳出。

末尾放了正在使用的完整代码，想直接用的可以拉到最后。

效果

当存在嵌套时会出现一个蒙版和窗口，提示用户点击。

点击后会在新窗口打开网站页面。

嵌套检测

设置响应头

响应头中有一个名为X-Frame-Options的键，可以针对嵌套操作做限制。

它有3个可选值：

DENY：拒绝所有

SAMEORIGIN：只允许同源

ALLOW-FROM origin：指定可用的嵌套域名，新浏览器已弃用

后端检测（以PHP为例）

通过获取$_SERVER中的HTTP_REFERER和HTTP_SEC_FETCH_DEST值，可以判断是否正在被iframe嵌套

// 如果不是iframe，就为空的字符串

$REFERER_URL = $_SERVER['HTTP_REFERER'];



// 资源类型，如果是iframe引用的，会是iframe

$SEC_FETCH_DEST = $_SERVER['HTTP_SEC_FETCH_DEST'];



// 默认没有被嵌套

$isInIframe = false;



if (isset($_SERVER['HTTP_REFERER'])) {

  $refererUrl = parse_url($_SERVER['HTTP_REFERER']);

  $refererHost = isset($refererUrl['host']) ? $refererUrl['host'] : '';



  if (!empty($refererHost) && $refererHost !== $_SERVER['HTTP_HOST']) {

    $isInIframe = true;

  }

}



// 这里通过判断$isInIframe是否为真，来处理嵌套和未嵌套执行的动作。

if($isInIframe){

  ....

}

前端检测（使用JavaScript）

通过比较window.self（当前窗口对象）和window.top（顶层窗口对象）可以判断是否正在被iframe嵌套

if (window.self !== window.top) {

  // 检测到嵌套时该干的事

}

从嵌套中跳出

跳出只能是前端处理，如果使用了PHP等后端检测，可以直接返回前端JavaScript代码，或者HTML的A标签设置转跳。

JavaScript直接转跳（不推荐）

不推荐是因为现在大多浏览器为了防止滥用，会阻止自动弹出新窗口。

window.open(window.location.href, '_blank');

A标签点击转跳（较为推荐）

当发生了用户交互事件，浏览器就不会阻止转跳了，所以这是个不错的方法。

href="https://www.9kr.cc" target="_blank">点击进入博客

JavaScript+A标签（最佳方法）

原理是先使用JavaScript检测是否存在嵌套，

如果存在嵌套，再使用JavaScript加载蒙版和A标签，引导用户点击。

这个方法直接查看最后一节。

正在使用的方法

也就是上一节说的JavaScript+A标签。

先给待会要显示的蒙版和A标签窗口设置样式

/* 蒙版样式 */

.overlay1 {

        position: fixed;

        top: 0;

        left: 0;

        width: 100%;

        height: 100%;

        background-color: rgba(0,0,0,0.5); /* 半透明背景颜色 */

        z-index: 9999; /* 确保蒙版位于其他元素之上 */

        display: flex;

        align-items: center;

        justify-content: center;

    }

        

    /* 窗口样式 */

    .modal1 {

        background-color: #fff;

        padding: 20px;

        border-radius: 5px;

    }

然后是检测和加载蒙版+A标签的JavaScript代码

if (window.self !== window.top) {

	// 创建蒙版元素

	var overlay = document.createElement('div');

	overlay.className = 'overlay1';



	// 创建窗口元素

	var modal = document.createElement('div');

	modal.className = 'modal1';



	// 创建A标签元素

	var link = document.createElement('a');

	link.href = 'https://www.9kr.cc';

	link.target = '_blank'; // 在新窗口中打开链接

	link.innerText = '点击进入博客';

	//link.addEventListener('click', function(event) {

	//    event.preventDefault(); // 阻止默认链接行为

	//    alert('Test');

	//});



	// 将A标签添加到窗口元素中

	modal.appendChild(link);



	// 将窗口元素添加到蒙版元素中

	overlay.appendChild(modal);



	// 将蒙版元素添加到body中

	document.body.appendChild(overlay);

}

博客的话，只需要在主题上设置自定义CSS和自定义JavaScript即可

前言

说来也讽刺，我刚刚在23年12月写了一篇走出迷茫，还给自己定了个目标，新的一年刚开始就遇到危机了。

因为我负责一个项目迁移了两次都失败了，领导说虽然去年没扣你绩效，但你连续失败可能会被领导扣绩效。原因是上面只看结果，过程他们看不到。如果严重的话，你可能会被列入 优化名单。

刚刚7天内通宵两个晚上的我，听到这个消息后脑子真的嗡嗡的。因为我本能的认为失败的原因不在我，网络问题结合使用的nextJS插件，导致我们无法线下测试，所以有问题只会在生产上暴露。

就这样通宵后的我三天没有睡好，有一天晚上我梦见我在和领导解释为什么会出现这些问题，但是他们不听。我不是失落，而是害怕。有房贷和孩子没有坚强的家庭支援的人，大概会懂我这几天的无助。

起因

事情是这样的，我负责的一个项目要从公有云迁移到私有云，而私有云中有部分中间要求使用国产化，这些问题都已经解决了之前也简单记录了一下。

但是这个项目最复杂的是网络，有十几二十个防火墙要申请，还有一些白名单要配置，而且我们没有域名，使用的是别人的域名http://www.aaa.cn/path进行转发到我们web代理服务器上。就因为这个/path的原因，我们的前端后端都在代码中做了修改。关键他还不止一个域名，还有一个aaa.cn/path这个地址也可以访问。但该死的http://www.aaa.cn/path一开始只有外网可访问内网访问不了，aaa.cn/path一开始内网都可以访问。然而，今天测试的时候发现这两个https地址都可以访问了，但是我事先没有收到任何通知。这里说一下为什么要https，因为微信必须要求https域名，当然还有一些其他场景。

第一次割接

因为迁移后的环境没有割接前没有域名，更没有https的域名供我们使用测试。我们申请了公网负载IP进行测试一切顺利，于是我开始第一次割接。然后失败了，因为迁移前的obs是自带公网可访问域名的（我们的资源公网客户端可以直接访问），但是迁移后我们的obs是私有云，他们虽然提供了域名但只能内网访问，于是我们使用了nginx做了反向代理。反向代理后使用公网负载IP到访问这个私有云的obs资源是没有问题的，但上了服务器使用域名访问这些资源，就不能访问。因为当晚除了这个域名问题，还有一个程序问题，所以我在凌晨5点放弃了割接，发邮件说明失败原因。

第二次割接

第一次的使用域名无法方私有云obs问题，我领导去修改了nginx代理配置，增加了header头，将host改成了可以正常访问的公网负载IP，然后使用浏览器测试直接打开了私有云obs的图片。另外程序问题是开发忘记刷脚本了，我没有骂他，因为我觉得我骂了影响后面的工作。外包是一个团队，因为他工作的原因导致其他人无效通宵，其他人会给他压力的。当然，提还是要提的。

解决上述两个问题后，我准备了第二次割接，然后还是失败了。原因nextJS打包是需要访问后端服务器，同时nextJS中有个图片模糊加载的插件访问图片的域名和打包需要访问后端服务器域名是同一个，共用同一个参数配置。而不巧的是我们部署打包的服务器无法访问http://www.aaa.cn这个域名，而aaa.cn虽然可以访问，但是他的证书不安全nextJS的模糊加载插件直接提示安全问题，不予与加载展示。

我们蹭着线上域名割接后，做了几轮测试得出一下结论。

方案一：http://www.aaa.cn需要打包服务器能访问，运维说配置hosts就可以，但这个要提工单，无法直接协调；

方案二：aaa.cn配置上SSL安全证书，使其https合法；

方案三：如果方案一和方案二尝试后都不行，在http://www.aaa.cn打包服务器可访问的情况下或aaa.cn配置安全证书的情况，去掉nextJS的模糊图片加载问题；

再次放弃割接计划，发邮件说明原因。

然后6点睡，10点起，和领导沟通问题的时候，领导说了上面的话。我给领导回复是，主要还是网络太复杂了，但是我会尽全力的，结果怎么样我也没得选，听天命吧。

过程

领导和我聊完后，我的心情是不能平复的。

我想的最多的是，如果我失业了，我那每月1.3w的房贷怎么办？

每月的家庭支出怎么办？

我老婆一个人能不能扛得住？

现在这个环境我能快速找到工作吗？

就算找到了，我能找到心仪的工作吗？

找到新工作后，我能不能待多久？

我现在是不是该去复习一些技术了？

我应该先学哪些东西呢？

我是不是应该找个副业？

搞短视频？写小说？滴滴？外卖？

自己做几个益智的微信小程序游戏，然后靠广告赚点饭钱？

回老家问问我爷爷或者我父辈的那些山和地是否能给我种果树或者粮食？

...

第二天是个周六，我开始冷静了一点。我开始拿起手机看着一串延期的计划表发呆，我完全提不起一点兴趣，也许自己不行去做的一种借口吧。但结果是我真的没有去做，因为我不想做。

看着计划，我越看越不对劲。

第三天是个周日，快到晚上的时候，我老婆问我吃完饭不。我说不吃了，刚好适应一下失业后饿肚子的感觉，以后说不准要经常饿肚子。

第四天早上，起来把掘金、华住、学习强国签到完，学了一节多领国，然后就去完成运动计划1000跳绳+10组其他健身运动。运动完后去洗澡，然后就萌生了鼓励自己的念头。

“想想这两次失败是否完全不可测试的？”

“还有哪些我能做的？”

“领导只是说我有危险，那何不在努力试试留下来，毕竟你自己希望能在这里呆满3年+的！”

“第二次割接的问题是不是可以通过自己购买域名模拟？”

“做自己该做的，船到桥头自然直，况且你一直觉得自己能力还可以，至少是中等水品？”

反思

反思第一次失败

1、虽然自己整理了checklist清单，让项目确认了他们也确认了，但自己并没有让他们把每个环节需要执行细节落入书面；

2、自己在整个上线过程中，确实没有针对具体问题做深度的剖析，只是站在方向的引导上，过度依赖团队中的开发；

3、网络知识和nginx虽然一直在用，但自己不熟悉却没有放到学习项中，自己一直在学习其他玩意，重要紧急没有分清楚；

4、出现问题，具体的问题没有自己剖析过，觉得是网络问题自己肯定不会；

反思第二次失败

1、和第一次一样，没有亲自分析问题日志和原因，基本都是团队反馈，然后自己总结的归纳；

2、没有深思熟虑，既然上次有域名访问图片的问题，但却没有考虑https的问题和nextJS打包需要访问后端的问题；

反思个人计划

1、强化工作的部分有，但太少需要针对性增加学习工作中遇到的薄弱的技术问题；

2、整个计划中，基本除了健康就是学习，没有增加实施后可以增加收入或者增加收入机会的内容，即使列了也没有执行到位；

3、计划中应该有侧重，计划中内容太多时间太分散，应该每个阶段增加一个侧重；

调整

关于本次迁移的工作的总结：

1、上线前整理checklist，并且核对每个人负责的内容，包括细节操作和操作所需材料，并收集材料；

2、以前是团队负责人，现在是技术经理，需要下沉，表现在现场分析解决问题和增加技术知识面；

3、增对工作汇总遇到的薄弱技术知识点，针对性的寻找资料学习；

4、遇到问题，冲在一线，现在是技术经理需要关系技术细节，并且需要从细节上帮助团队解决问题；

5、没有解决不了的问题，没有复现不了的环境，无法是成本问题，不要一分不掏，因为没了工作损失的不止这点钱；

关于自身工作状态的总结：

1、这家公司自从自己将责任划分清楚后，开始有点安逸，但所有需求自己要过一遍，每个技术方案自己要把持；

2、还是要以工作为主，有一半的学习要和当下的工作相关；

3、不要过分信任团队，特别是外包团队，要将核心掌握在自己手里；

4、防御性上班，关键核心的要素信息要记笔记，但点到为止自己明白就行，不然对你下黑手时，你无力反抗和无法维护自己的权益；

结合上述总结调整2024年执行计划：

原计划

一、工作：

1）2024年保住当前工作，做好项目技术管理，保持向上汇报，平级保持责任分明适当帮忙，识别风险提前向干系人预警；

​

二、学习：

1）每天保持至少3天的coding或技术学习，将自己花了万元的VIP培训视频一点点消化，每天就算看10分钟也行；

2）每周一篇技术博客，将解决技术问题和技术学习的内容，分享到微信公众号或掘金等博客上；

3）学习英语，多领国每天只是少一节，时间多可以多练习几个，拓宽后续就业面，避免被需要英语的外企或国际公司限制；

4）通过五月份的软考高项，去年上半年没有过，下半年放弃了，每天背知识点、练习和看教学视频；

​

三、健康：

1）每天保持运动，常规每天1000个跳绳+10组其他运动，如俯卧撑，最次每天200个跳绳，争取将结石排除提完；

2）控制饮食，多吃粗纤维果蔬少油少盐，争取大多时候半碗饭和两素一荤，至少每周一个晚上不吃晚饭，晚上19点后不食；

3）体重减到170以下，除了坚持以上两项，多出去走走；

4）排出肾结石，中度脂肪肝转轻度或无，降血液中的胆固醇，治好咽喉炎和鼻窦炎，以上四样至少完成两项；

5）平均睡眠提升到6小时+；

6）作为兴趣学学中医，看看倪海厦的中医视频，聊胜于无；

四、创作：

1）持续创作短视频或者小说，小说24年争取实现100w字，短视频每周一篇，不做硬性要求业余时间够就走；

​

以上所有目标，均坚持非强制原则，如果昨天没有完成，把今天的完成即可，有时间再补昨天的。

分解原计划

一、工作：

1）2024年保住当前工作,做好项目技术管理，保持向上汇报，平级保持责任分明适当帮忙，识别风险提前向干系人预警；

1.运行并阅读分析当前项目代码、分析数据库设计和分析中间件的使用，发现问题提出改进计划 -- 提高领导力的影响，专家权利；

2.对所有新增需求进行阅读，参与并制定需求所使用的技术方案 -- 掌握项目技术栈和架构变化，增加项目经验和能力；

3.对nginx、http协议、kafka、mysql等进行系统的学习，并将学习的内容用自己的语言总结描文章供后续自己翻阅；

4.不定期向领导汇报工作进展，包括工作中的问题、好消息等，特别是风险要提前预警；

​

二、学习：

1）每周保持至少3天的coding或技术学习，将自己花了万元的VIP培训视频一点点消化，每天就算看10分钟也行；

2）每周一篇技术博客，将解决技术问题和技术学习的内容，分享到微信公众号或掘金等博客上；

3）多领国学习英语每天只是少一节，尽可能多读多听重点练习听读，拓宽后续就业面，避免被需要英语的外企或国际公司限制；

4）按照提供的学习方看回放、复习讲义、做练习、对照题找书本原话，争取通过五月份的软考高项；

​

三、健康：

1）每天保持运动，每天200个跳绳，最佳常规每周三次 1000个跳绳+10组其他运动，争取体重减到170以下；

2）控制饮食，多吃粗纤维果蔬少油少盐，至少每周一个晚上不吃晚饭，晚上19点后不食；

3）每天200跳争取排出肾结石；少吃油腻增加运动争取中度脂肪肝转轻度或无和降血液中的胆固醇；少吃辛辣争取治好咽喉炎和鼻窦炎；

4）平均睡眠提升到6小时+；

5）每天拍胆经肝经心经；

​

四、创作：

1）每周至少发布一个短视频，主要发布自学中医相关内容或者郑强、罗翔、温铁军、艾跃进等爱国思想的演讲相关的内容，主打传播正能量和价值；

2）每天500字小说，争取24年完成30w字的小说；

​

五、拓展：

1）每周至少看书2小时；

2）每周学习中医至少1小时；

以上所有目标，均坚持非强制原则，如果昨天没有完成，把今天的完成即可，有时间再补昨天的。

新计划

因为之前的计划使用iphone自带的提醒事项做的，但是这东西在统计上手机和电脑不同步，而且手机电脑一起用还会重复计数。因此准备自己搞个计划清单列表小程序，至于app后续再研究，使用微信消息推送。

一、工作：

1）运行并阅读分析当前项目代码、分析数据库设计和分析中间件的使用，发现问题提出改进计划；

  -- 本月每天2小时，将程序打包编译先搞定，独立完成UAT环境的部署和安装（侧重）；

2）对所有新增需求进行阅读，参与并制定需求所使用的技术方案；

  -- 有就阅读，并分析需求中是否需要使用新的技术方案；

3）对nginx、http协议、kafka、mysql等进行系统的学习，并将学习的内容用自己的语言总结描文章供后续自己翻阅；

  -- 每2周学习nginx一个功能点，整理成技术文章；

4）不定期向领导汇报工作进展，包括工作中的问题、好消息等，特别是风险要提前预警；

  -- 一句项目情况汇报；

​

二、学习：

1）每周保持至少3天的coding或技术学习，将自己花了万元的VIP培训视频一点点消化，每天就算看10分钟也行；

2）每周一篇技术博客，将解决技术问题和技术学习的内容，分享到微信公众号或掘金等博客上；

3）多领国学习英语每天只是少一节，尽可能多读多听重点练习听读，拓宽后续就业面，避免被需要英语的外企或国际公司限制；

4）按照提供的学习方看回放、复习讲义、做练习、对照题找书本原话，争取通过五月份的软考高项（侧重）；

​

三、健康：

1）每天保持运动，每天200个跳绳，最佳常规每周三次 1000个跳绳+10组其他运动，争取体重减到170以下（侧重）；

2）控制饮食，多吃粗纤维果蔬少油少盐，至少每周一个晚上不吃晚饭，晚上19点后不食；

3）每天200跳争取排出肾结石；少吃油腻增加运动争取中度脂肪肝转轻度或无和降血液中的胆固醇；少吃辛辣争取治好咽喉炎和鼻窦炎；

4）平均睡眠提升到6小时+；

5）每天拍胆经肝经心经；

​

四、创作：

1）每周至少发布一个短视频，主要发布自学中医相关内容或者郑强、罗翔、温铁军、艾跃进等爱国思想的演讲相关的内容，主打传播正能量和价值；

2）每天500字小说，争取24年完成30w字的小说；

3）3月底前，开发一个小程序用于记录计划清单，并使用微信提醒，后续看情况加上短信提醒（侧重）；

4）模仿一个微信小游戏，

​

五、拓展：

1）每周至少看书2小时；

2）每周学习中医至少1小时；

以上所有目标，均坚持非强制原则，如果昨天没有完成，把今天的完成即可，有时间再补昨天的。

总结回顾

这些年我做了很多选择，但是我并没有因为我的选择变得更好。早先时候我一路走上坡的时候，我确实觉得是因为自己能力变强了我才有这样的成就，我也很自信我确实有这样的能力。但最近这4年一路下坡，让我重新认识了自己。早期我的能力可能确实在中上游，加上环境好很容易上去，而最终无论什么原因自己下来了说明自己总归有些问题的。

什么问题？自己认为比较严重的问题有如下：

1、过早且长期脱离一线，虽然有心想要重回一线，但是内心是抗拒那种艰苦的日子，虽然我不会把所有功绩揽给自己，但确实沾沾自喜；这就导致很多技术上的问题，我虽然了解但浮于表面，带着团队能解决，自己不一定能解决，最多只有思路。

2、没有认清打工人的本质，我曾在几家高端职位的公司任职，因为觉得高层领导或者直属领导太煞笔、不听劝、独断专行，而愤然离职；说到底还是太年轻，打工人就和上钟的技师一样，你要让领导爽，然后才能谈条件；他的煞笔不应该由你自己来买单，当然也和个人性格有关，城府和隐忍在职场上相当重要。

3、方向问题，我虽然做了11年，我之前的求职一直是以工资和职位头衔为目标，我基本没有规划过我的职业领域方向；等到要进入高端职位的圈子时，发现自己竟然什么都会一些，但别人要的是某个领域至少5年以上的工作经验，而我其中一个领域最多只有3.5年。

4、重心和当前迫切的问题自己没有刻意的把我，就比如很多计划看着挺好，但做起来也挺好，但是没有沉淀或者和当前的工作没有关系，就这样失去了很多巩固和提升能力的机会。

5、心里一直想要给自己留条后路，却发现前路没有走好，后路也没有留上，终日惶惶不安日。

有时候我在想，每一次的成功是不是老天给我的机会或者上辈子积德所致，每一次的失败或者落魄是不是老天觉得我朽木不可雕也。

但实际上自己也知道问题在哪？

不想做一线工作 -- 懒；

没有城府和隐忍 -- 蠢；

没有规划和防线 -- 笨；

没有重心和侧重 -- 懒；

前路没好后路成 -- 贪；

虽然明知道自己有这么多缺点，但是我还是想扛着氧气罐自救一下，说不定哪天让我踩上了风口飞起来了呢？放下氧气罐，也许我再也起不来了，但扛着虽然累，好歹我还活着。

-- 来自于35岁的自白！

什么是纯函数？

纯函数是数学上的一种理想状态，即相同的输入永远会得到相同的输出，而且没有任何可观察的副作用

在数学上函数的定义为

• It must work for every possible input value


• And it has only one relationship for each input value

即每个在值域内的输入都能得到唯一的输出，它只可能是多对一而不是一对多的关系：

副作用

Wikipedia Side Effect: In computer science, an operation, function or expression is said to have a side effect if it modifies some state variable value(s) outside its local environment, which is to say if it has any observable effect other than its primary effect of returning a value to the invoker of the operation. Example side effects include modifying a non-local variable, modifying a static local variable, modifying a mutable argument passed by reference, performing I/O or calling other functions with side-effects. In the presence of side effects, a program's behaviour may depend on history; that is, the order of evaluation matters. Understanding and debugging a function with side effects requires knowledge about the context and its possible histories.

副作用的形式很多样，一切影响到外部状态、或依赖于外部状态的行为都可以称为副作用。副作用是必须的，因为程序总是不可避免的要与外界交互，如：

更改外部文件、数据库读写、用户 UI 交互、访问其他具有副作用的函数、修改外部变量

这些都可以被视为副作用，而在函数式编程中我们往往希望使副作用最小化，尽量避免副作用，对应的纯函数则是希望彻底消除副作用，因为副作用让纯函数变得不“纯”，只要一个函数还需要依赖外部状态，那么这个函数就无法始终保持同样的输入得到同样的输出。

好处是什么？

You wanted a banana but what you got was a gorilla holding the banana and the entire jungle. — Joe Armstrong, creator of Erlang progamming

• 可缓存性，由于唯一的输入代表唯一的输出，那么这意味着我们可以在输入不变的情况下直接返回运算过的结果。


• 高度并行，由于纯函数不依赖外部状态，因此即便在多线程情况下外部怎么变动，纯函数始终能够返回预期的值，纯函数能够达到真正的无锁编程，高度并发。


• 高度可测性，不需要依赖外部状态，传统的 OOP 测试我们都需要模拟一个真实的环境，比如在 Android 中将 Application 模拟出来，在执行完之后断言状态的改变。而纯函数只需要模拟输入，断言输入，这是如此的简单优雅。


• 依赖清晰，面相对象编程总需要你将整个环境初始化出来，然后函数再依赖这些状态修改状态，函数往往伴随着大量外部的隐式依赖，而纯函数只依赖输入参数，仅此而已，也仅提供返回值。

更进一步

传统大学老师教的都是 OOP，所以大多数人最开始也不会去学习纯函数的思路，但纯函数是完全不一样的一套编程思路，下面是一个纯函数中实现循环的例子，传统的循环往往是这样的：

int sum(int[] array) {

    int sum = 0;

    for (int i = 0; i < array.length; i++) {

        sum += array[i];

    }

    return sum;

}

尽管大多数语言也会提供 for...in 之类的语法，如 kotlin：

fun sum(array: IntArray): Int {

    var sum = 0

    for (i in array) {

        sum += i

    }

    return sum

}

但我们注意到，在上面的例子中均引入了两个可变的变量，sum 和 i，站在 sum += i 的视角，它的外部依赖：i 是一个外部的可变状态，因此这个函数并不“纯”。

但另一方面来说，从整体函数对外的视角来看，其还是很“纯”的，因为对于传入的外部 array，始终有唯一的 int 返回值，那么我们追求完全的“纯”，完全不使用可变量的目的是什么呢？

在纯函数下要实现完全消灭不可变变量，我们可以这么做：

tailrec fun sum(array: IntArray, current: Int = 0, index: Int = 0): Int {

    if (index < 0 || index >= array.size) return current

    return sum(array, current + array[index], index + 1)

}

我们编写了退出条件，当 index 在不正常的情况下会，意味着没有东西可以加，直接返回 current，即当前已经算好的值；其余情况则直接返回 current 与当前 index 的值的和，再加上 index + 1 之后所有值的 sum。这个例子已经很简单了，但函数式，递归思维不免会让学传统 OOP 的人需要多加思考一下。

当然作为一个 kotlin 开发，我也毫不犹豫的使用了 tailrec 这个 kotlin 语言特性来帮助优化尾递归，否则在遇到相当长的列表的时候，这个函数会抛出 StackOverFlowError。

函数一等公民

许多面向对象语言通常会用 this 显式访问对象的属性或方法，也有一些语言会省掉编写 this，事实上在许多语言编译器的背后实现中，通常也会将“对象成员的调用”变成“额外给成员函数添加一个 this 变量”。

可见发挥重要作用的其实是函数，不如更进一步，函数是一等公民，对象只不过是个结构体；如此，在纯函数中你完全用不到 this，甚至很多情况下都用不到对象。

所谓的一等公民，就是希望函数包含对象，而不是对象包含函数，甚至可以不需要对象（暴论），下面就是一个例子，是一个常见的业务诉求：

• UserService 接收用户 id，并提供两个函数来获取用户 token 和用户的本地储存


• ServerService 需要服务器 ip 和 port，提供通过 secret 获取 token 和通过用户 token 获取用户数据两个能力


• UserData 是一个用户数据类，它能够接收父布局参数来构建 UI 数据用于显示

class UserService(private  val id: Int) {

    fun userToken(password: String): UserToken = TODO()

    fun localDb(dbPassword: String): LocalDb = TODO()

}



class ServerService(private  val ip: String, private  val port: Int) {

    fun serverToken(serverSecret: String): ServerToken = TODO()

    fun getUser(userToken: UserToken): UserData = TODO()

}



class UserData(

    val name: String, val avatarUrl: String, val description: String,

) {

    fun uiData(parentLayoutParameters: LayoutParameters): UIData = TODO()

}

那么这些变成函数式会怎么样呢？会像下面这样！

typealias UserTokenService = (password: String) -> UserToken

typealias LocalDbService = (dbPassword: String) -> LocalDb



typealias UserService = (id: Int) -> Pair<UserTokenService, LocalDbService>



typealias ServerTokenService = (serverSecret: String) -> ServerToken

typealias ServerUserService = (userToken: UserToken) -> UserDataAbilities

typealias ServerService = (ip: String, port: Int) -> Pair<ServerTokenService, ServerUserService>



typealias UserUIData = (parentLayoutParameters: LayoutParameters) -> UIData

typealias UserDataAbilities = UserUIData



val userService: UserService = { userId: Int ->

    val tokenService: UserTokenService = { password: String -> TODO() }

    val localDbService: LocalDbService = { dbPassword: String -> TODO() }

    tokenService to localDbService

}



val serverService: ServerService = { ip: String, port: Int ->

    val tokenService: ServerTokenService = { serverSecret: String -> TODO() }

    val userService: ServerUserService = { userToken: String -> TODO() }

    tokenService to userService

}

是不是看起来这些东西变得相当的复杂？但实际上真正的代码并没有写多少行，大量的代码都用来定义类型了！这也就是为什么你能看到的大多数展示函数式的例子都是用 js 去实现的，因为 js 的类型系统很弱，这样函数式写起来会很方便。

我这里用 kt 的范例则是写了大量的类型标记代码，因为我本人对显式声明类型有极高的要求，如果愿意，也可以完全将类型隐藏全靠编译器推理，就像下面这样，一切都变得简洁了，写起来和常规的 OOP 并没有太大区别。

val userService = { userId: Int ->

    val tokenService = { password: String -> TODO() }

    val localDbService = { dbPassword: String -> TODO() }

    tokenService to localDbService

}



val serverService = { ip: String, port: Int ->

    val tokenService = { serverSecret: String -> TODO() }

    val userService = { userToken: String -> TODO() }

    tokenService to userService

}

但不同的是，你看上面的代码，完全没有类/结构体的存在，因为变量的存储全部在函数体内储存了！

对于使用处，两种方式的用法事实上也大同小异，但可以看到我们彻底抛弃了类的存在！甚至在 kotlin 的未来版本中，如果这种代码始终在字节码中编译成 invokeDynamic，那么通过这种方式，字节码中甚至都可以避免类的存在！（当然，在 Android DEX 中会被脱糖成静态内部类）

// OOP

val userService = UserService(id = 0)

val serverService = ServerService(ip = "0.0.0.0", port = 114514)

val userToken = userService.userToken(password = "undefined")

val userData = serverService.getUser(userToken)

val uiData = userData.uiData(parentLayoutParameters)



// functional

val (userTokenService, _) = userService(0)

val (_, userDataService) = serverService("0.0.0.0", 114514)

val userToken = userTokenService("undefined")

val userData = userDataService(userToken)

val uiData = userData(parentLayoutParameters)

BTW，这里函数式 argument 没加 name 主要 kt 现在不支持。。。

柯里化

在上面的例子中，其实我们也能看到，类的存在是不必须的，类的本质其实只是预设好了一部分参数的函数，柯里化要解决的问题就是如何更轻松的实现“预设一部分参数”这样的能力。将一个函数柯里化后，允许多参数函数通过多次来进行传入，如 foo(a, b, c, d, e) 能够变成 foo(a, b)(c)(d, e) 这样的连续函数调用

在下面的例子中，我将举一个计算重量的范例：

fun weight(t: Int, kg: Int, g: Int): Int {

    return t * 1000_000 + kg * 1000 + g

}

将其柯里化之后：

val weight = { t: Int ->

    { kg: Int ->

        { g: Int ->

            t * 1000_000 + kg * 1000 + g

        }

    }

}

使用处：

// origin

weight(2, 3, 4)

// currying

weight(2)(3)(4)

在这里我们能发现，柯里化其实让实现处变复杂了，不过在 js 中通常会通过 bind 来实现，kt 也有民间大神 github 开源的柯里化库，使用这些能够从一定程度上降低编写柯里化代码的复杂度。

让我们看看 skiplang 语言吧

skiplang.com/

Skiplang 的宗旨就在其网站主页，A programming language to skip the things you have already computed，在纯函数的情况下，意味着得知输入状态，那么输出状态就是唯一确定的，这种情况就非常适合做缓存，如果输入值已经计算过，那么直接可以返回缓存的输出值。

在纯函数的情况下，意味着运算可以做到高度并行，在 skiplang 中，多个异步线程之间不允许共享可变变量，自然也不会出现异步锁等东西，从而保证了异步的绝对安全。

个人思考

纯函数的收益非常诱人，但开发者往往不喜欢使用纯函数，一些常见的原因可能是：

尽管我对纯函数也非常的心动，但是我不是激进的纯函数派，我在日常工作中对其部分认同，具体到 kotlin 编程中，我通常坚持的理念是：

参考

• http://www.mathsisfun.com/sets/functi…


• en.wikipedia.org/


• mostly-adequate.gitbook.io/mostly-adeq…

个人主页原文：一个 Kotlin 开发，对于纯函数的思考

前言

没有理论，只有实操，用最直接的方式来了解和使用小程序分包。

文章偏向使用taro来模拟小程序分包配置，在原生小程序中也是几乎差不多的配置方式。

为什么要有小程序分包？

因为上传小程序打包以后的代码包不可以超过2M。但我们在开发小程序的时候需要加载某些依赖或者一下静态图片，代码包难免超过2M。所以需要小程序分包功能将小程序中所有的代码分别打到不同的代码包里去，避免小程序只能上传2M的限制。

目前小程序分包大小有以下限制：

• 整个小程序所有分包大小不超过 20M（开通虚拟支付后的小游戏不超过30M）


• 单个分包/主包大小不能超过 2M

如何对小程序进行分包？

本质上就是，配置一下app.json（小程序）或app.config.ts(Taro)中的subpackages字段。注意，分包的这个root路径和原本的pages是同级的。

如下图

这样配置好了，最基本的分包就完成了。

如何配置多个子包？

subpackages是个数组，在下面加上一样的结构就好了。

如何判断分包是否已经生效？

打开微信开发者工具，点击右上角详情 => 基本信息 => 本地代码，展开它。出现 主包，/xxxx/就是分包生效了。

如下图

所有页面都可以打到分包里面吗？

也不是，小程序规定，Tabbar页面不可以，一定需要在主包里。否则他直接报错。

分包中的依赖资源如何分配？

我们先来了解一下小程序分包资源

 引用原则

  `packageA` 无法 require `packageB` JS 文件，但可以 require 主包、`packageA` 内的 JS 文件；使用 [分包异步化](https://developers.weixin.qq.com/miniprogram/dev/framework/subpackages/async.html) 时不受此条限制

  `packageA` 无法 import `packageB` 的 template，但可以 require 主包、`packageA` 内的 template

  `packageA` 无法使用 `packageB` 的资源，但可以使用主包、`packageA` 内的资源

原因: 分包是依赖主包运行的，所以主包是必然会被加载的，所以当分包引用主包的时候，主包的相关数据已经存在了，所以可以被引用。而分包不能引用其他分包的数据，也是因为加载顺序的问题。如果分包A引用分包B的数据，但分包B尚未被加载，则会出现引用不到数据的问题。

如果主包和分包同时使用了一个依赖，那么这个依赖会被打到哪里去？

会被打到主包

因为主包不能引用分包的资源，但是子包可以引用主包的资源，所以为了两个包都能引用到资源，只能打到主包中

比如以下情况

分包和主包同时使用了dayjs，那么这个依赖会被打入到主包中。

如果某一个依赖只在分包中使用呢？

如果某一个资源只在某一个分包中使用，那就会被打入到当前分包。

如果两个子包同时使用同一个资源呢？那资源会被打进哪里。

主包，因为两个子包的资源不能互相引用，所以与其给每一个子包都打入一个独立资源。小程序则会直接把资源打到主包中，这样，两个子包就都可以使用了。

分包需要担心低版本的兼容问题吗

不用

由微信后台编译来处理旧版本客户端的兼容，后台会编译两份代码包，一份是分包后代码，另外一份是整包的兼容代码。 新客户端用分包，老客户端还是用的整包，完整包会把各个 subpackage 里面的路径放到 pages 中。

独立分包

什么是独立分包

顾名思义，独立分包就是可以独立运行的分包。

举个例子，如果你的小程序启动页面是分包（普通分包）中的一个页面，那么小程序需要优先下载主包，然后再加载普通分包，因为普通分包依赖主包运行。但是如果小程序从独立分包进入进入小程序，则不需要下载主包，独立分包自己就可以运行。

普通分包所有的限制对独立分包都有效。

为什么要有独立分包，普通分包不够吗

因为独立分包不需要依赖主包，如果有作为打开小程序的的入口的必要，加载速度会比普通分包快，给客户的体验感更好。毕竟谁也不想打开一个页面等半天。

举个例子，如果小程序启动的时候是打开一个普通分包页面。则加载顺序是：加载主包 => 再加载当前分包

但如果小程序启动的时候是打开一个独立分包页面，则加载顺序是：直接加载独立分包，无需加载主包。

独立分包相对于普通分包，就是省去了加载主包的时间和消耗。

独立分包如何配置

配置和普通分包一样，加一个independent属性设为true即可。

独立分包的缺点

既然独立分包可以不依赖主包，那我把每个分包都打成独立分包可以吗。

最好别那么干

理由有四点

1.独立分包因为不依赖主包，所以他不一定能获取到小程序层面的全局状态，比如getApp().也不是完全获取不到，主包被加载的时候还是可以获取到的。概率性出问题，最好别用。

2.独立分包不支持使用插件

3.小程序的公共文件不适用独立分包。比如Taro的app.less或小程序的app.wxss

上述三个，我觉的都挺麻烦的。所以不是作为入口包这种必要的情况下，确实没有使用独立分包的需求。

PS:一个小程序里可以有多个独立分包

独立分包有版本兼容问题吗

有滴，但你不用这个兼容问题直接让你报错，
在低于 6.7.2 版本的微信中运行时，独立分包视为普通分包处理，不具备独立运行的特性。

所以，即使在低版本的微信中，也只是会编译成普通分包而已。

注意！！！ 这里有一个可能会遇到的坑，就是如果你在独立分包中使用了app.wxss或者app.less这些小程序层面的公共css文件，那么在低版本（<6.7.2）进行兼容的时候，你就会发现，独立分包的页面会被这些全局的CSS影响。因为那时候独立分包被编译成了普通分包。而普通分包是适用全局公共文件的。

分包预下载

首先我们需要了解，分包是基本功能是，在下程序打包的时候不去加载分包，然后在进入当前分包页面的时候才开始下载分包。一方面目的是为了加快小程序的响应速度。另一方面的原因是避开微信小程序本身只能上传2M的限制。

这里有一个问题，就是我在首次跳转某个分包的某个页面的时候，出现短暂的白屏怎么办？（下载分包的时间+运行接口的时间+渲染视图的时间）。

后两者没法彻底避免，只能优化代码，第一个下载分包的时间可以使用分包预下载功能解决。

我们可以通过分包预下载在进入分包页面之前就开始下载分包，来减少进入分包页面的时间。

如何配置分包预下载

当前的分包预下载只能在app.config(Taro)或者app.json（原生小程序）通过preloadRule字段去配置。

preloadRule字段是一个对象，key是页面的路径，value是进行预加载的分包name或者key，__APP__代表主包

上案例

通过preloadRule字段去配置

”packageB/pages/user/index“是key

packages:["packageA"]是value

案例上的意思是当进入packageA分包的时候，开始下载分包packageB

如果要某一个分包在加载主包的就开始下载,那么就设置packages:["APP"]即可。

总结

分包官方文档

分包官方分包demo-小程序版

如果您认为对您有用的话，留个赞或收藏一下吧~

<p> CSS Relative Color p>

p {

    color: rgb(255, 0, 0);

}

p {

    --color: rgb(255, 0, 0);

    color: rgb(from var(--color) calc(r - 255) calc(g + 255) b);  /* result = rgb(0, 255, 0) */

}

第二个关键点，from 后面通常会接一个颜色值，这个颜色值可以是任意颜色表示法，或者是一个 CSS 变量，下面的写法都是合法的：

p {

    color: rgba(from #ff0000) r g b);

    color: rgb(from rgb(255, 0, 0) r g b);

    color: rgb(from hsl(0deg, 100%, 50%) r g b);

    color: rgb(from var(--hotpink) r g b);

}

3. 对转换后的变量使用 calc() 或其他 CSS 函数

另外一个非常重要的基础概念就是，我们可以对 (from color r g b) 后的转换变量 r g b 使用 calc() 或其他 CSS 函数。

就是我们上面的例子：

p {

    --color: rgb(255, 0, 0);

    color: rgb(from var(--color) calc(r - 255) calc(g + 255) b);  /* result = rgb(0, 255, 0) */

}

4. 相对颜色语法支持，各种颜色表示函数：

相对颜色的基础的使用规则就是这样，它不仅支持 rgb 颜色表示法，它支持所有的颜色表示法：

• sRGB 颜色空间：hsl()、hwb()、rgb()；
• CIELAB 颜色空间：lab()、lch()；
• Oklab 颜色空间：oklab()、oklch()；

使用 CSS 相对颜色，实现统一按钮点击背景切换

通常页面上的按钮，都会有 hover/active 的颜色变化，以增强与用户的交互。

像是这样：

最常见的写法，就是我们需要在 Normal 状态、Hover 状态、Active 状态下写 3 种颜色：

p {

    color: #ffcc00;

    transition: .3s all;

}

/* Hover 伪类下为 B 颜色 */

p:hover {

    color: #ffd21f;

}

/** Active 伪类下为 C 颜色 **/

p:active {

    color: #ab8a05;

}

在之前，我们介绍过一种利用滤镜 filter: contrast() 或者 filter: brightness() 的统一解决方案，无需写多个颜色值，可以根据 Normal 状态下的色值，通过滤镜统一实现更亮、或者更暗的伪类颜色。

在今天，我们也可以利用 CSS 相对颜色来做这个事情：

div {

    --bg: #fc0;

    background: var(--bg);

    transition: .3s all;

}



div:hover {

    background: hsl(from var(--bg) h s calc(l * 1.2));

}

div:active {

    background: hsl(from var(--bg) h s calc(l * 0.8));

}

我们通过 hsl 色相、饱和度、亮度颜色表示法表示颜色。实现：

在实际业务中，这是一个非常有用的用法。

完整的 DEMO，你可以戳这里：CodePen Demo -- https://codepen.io/Chokcoco/pen/KKEdOeb

使用 CSS 相对颜色，实现文字颜色自适应背景

相对颜色，还有一个非常有意思的场景 -- 让文字颜色能够自适应背景颜色进行展示。

有这么一种场景，有的时候，无法确定文案的背景颜色的最终表现值（因为背景颜色的值可能是后台配置，通过接口传给前端），但是，我们又需要能够让文字在任何背景颜色下都正常展现（譬如当底色为黑色时文字应该是白色，当背景为白色时，文字应该为黑色）。

像是这样：

在不确定背景颜色的情况下，无论什么情况，文字颜色都能够适配背景的颜色。

在之前，纯 CSS 没有特别好的方案，可以利用 mix-blend-mode: difference 进行一定程度的适配：

div {

    // 不确定的背景色

}

p {

    color: #fff;

    mix-blend-mode: difference;

}

实操过这个方案的同学都会知道，在一定情况下，前景文字颜色还是会有一点瑕疵。并且，混合模式这个方案最大的问题是会影响清晰度。

有了 CSS 相对颜色后，我们有了更多的纯 CSS 方案。

利用 CSS 相对颜色，反转颜色

我们可以利用相对颜色的能力，基于背景色颜色进行反转，赋值给 color。

一种方法是将颜色转换为 RGB，然后从 1 中减去每个通道的值。

代码非常简单：

p {

    /** 任意背景色 **/

    --bg: #ffcc00;

    background: var(--bg);



    color: rgb(from var(--bg) calc(1 - r) calc(1 - g) calc(1 - b));  /** 基于背景反转颜色 **/

}

用 1 去减，而不是用 255 去，是因为此刻，会将 rgb() 表示法中的 0~255 映射到 0~1。

效果如下：

配个动图，我们利用背景色的反色当 Color 颜色，适配所有背景情况：

完整的 DEMO 和代码，你可以戳这里：CodePen Demo -- CSS Relatvie Color Adapt BG

当然，这个方案还有两个问题：

为了解决这两个问题，CSS 颜色规范在 CSS Color Module Level 6 又推出了一个新的规范 -- color-contrast()。

利用 color-contrast()，选择高对比度颜色

color-contrast() 函数标记接收一个 color 值，并将其与其他的 color 值比较，从列表中选择最高对比度的颜色。

利用这个 CSS 颜色函数，可以完美的解决上述的问题。

我们只需要提供 #fff 白色和 #000 黑色两种可选颜色，将这两种颜色和提供的背景色进行比较，系统会自动选取对比度更高的颜色。

改造一下，上面的代码，它就变成了：

p {

    /** 任意背景色 **/

    --bg: #ffcc00;

    background: var(--bg);



    color: color-contrast(var(--bg) vs #fff, #000);  /** 基于背景色，自动选择对比度更高的颜色 **/

}

这样，上面的 DEMO 最终效果就变成了：

完整的 DEMO 和代码，你可以戳这里：CodePen Demo -- CSS Relatvie Color Adapt BG

此方案的优势在于：

当然，唯一限制这个方案的最大问题在于，当前，color-contrast 还只是一个实验室功能，未大规模被兼容。

总结一下

到今天，我们可以利用 CSS 提供的各类颜色函数，对颜色有了更为强大的掌控力。

很多交互效果，不借助 JavaScript 的运算，也能计算出我们想要的最终颜色值。本文简单的借助：

两个案例，介绍了 CSS 相对颜色的功能。但它其实还有更为广阔的应用场景，完整的教程，你可以看这里 -- Chrome for Developers- CSS 相对颜色语法。

最后

好了，本文到此结束，希望本文对你有所帮助 :)

想 Get 到最有意思的 CSS 资讯，千万不要错过我的公众号 -- iCSS前端趣闻 😄

更多精彩 CSS 技术文章汇总在我的 Github -- iCSS ，持续更新，欢迎点个 star 订阅收藏。

如果还有什么疑问或者建议，可以多多交流，原创文章，文笔有限，才疏学浅，文中若有不正之处，万望告知。

昨天（1月7日），公历年初，农历临近过年。这本应大家辛苦了一年，进行年会、团聚、收款，盼望着领取薪资，与远在千里的家人团聚的日子。

然而现实是，被井某指着鼻子威胁骂到：

• 我等劳动局的！


• 我现在就违法解除！


• 我告诉你了，我现在就违法解除！


• 你试试看，你他妈两年半找不着工作！你试试看！


• 劳动仲裁一审二审，我有的是人！我慢慢等你，你试试看。


• 你敢上传一个试试，我现在就打110！

事件和视频

原视频很大媒体平台都有，包括百度、抖音等。

本来想知道到底是什么原因，视频里的女高管如此有恃无恐，一时不知道到底是谁违法了。难道是因为孙某有什么错误，导致她认为就算是自己根据没有违法，所以法律拿她无可奈何，或者是她认为违法了又如何？

但是随着视频的播放，她放话：劳动仲裁一审二审，我有的是人！我慢慢等你，你试试看……，从这里看来意思是说假设真的是官司打起来了，我有是办法（让你时间耗不起、工作找不起）。虽然孙某有在拍视频，她也知道有在拍，但依然如此出言不逊，甚至你敢上传一个试试！

当晚，此视频在和微信群被转发，各在文章平台、短视频平台迅速跟进，次日，名为北京尼欧XX科技有限公司发表了声明。

公司声明

如果只有视频，确实也不知事情原委（万一高管只是在视频里说说玩，其实是孙某违法了呢？），所以就没继续想些什么。但次日看到这个声明之后，从声明上看：高管以停职反省处理、孙某以足额支付补偿金处理，并强调章程均合法合规。

假设此声明没有问题，我有以下疑问：

• 员工是否真是不能通过试用期

据我了解，假设试用期为6个月，一般公司会在第二三个月就会有相关的述职会议，以评估你是否能胜任工作。也就是说，能不能胜任工作，能不能通过试用期，通常2-3个月就能知晓了。但是为什么要在最后一个月才因某能力不足裁员呢？半年的时候，普通项目都做得差不多了。

• 视频中的日期是什么时候

视频是在1月7号流传的。如果是热点事件，通常在一天内基本大家都能知道了。

但声明上说是根据12月8日足额支付补偿，依法合规，也就是说一个月之前就已经合规处理完此事了？

个人想法

大家有知道马云说了离职不是钱不够，就是心受委屈了。虽然有比较多的人补充说还有其他自己想走之类的原因云云。

但细究的话，各有各的原因，这就不便分析问题了。

总的说来，不管是自己离职，还是公司裁员，应该都能归纳于：愿意的、不愿意的。

这东西，就像是谈恋爱一样，如果双方不喜欢，不愿意，或开始愿意，后面不愿意了，终究就会产生破窗效应，最终摆烂或分道扬镳。

如果发现员工能力不足，或公司运营困难了，需要裁员时，应早日给出处理方案，例如培训、转岗、或直言等，从双方平等的角度获得对方的理解。

如果员工认为公司有哪些地方不合理，也早点提出相关方案，为什么不喜欢？有没有建议方案？尝试过哪些努力？比如公司人员结构、工作强度、代码可维护性……提出来看看，假设表达合理，公司也重视你，自然能给你相应的说法。

如果公司的解决问题的方案是，解决提出问题的人，那早点离开又何尝不对呢？说小一点，这是为了自己洒脱一点，说大一点，这是人择良友而交，禽择良木而栖，让环境越来越好。

当然，很多时候作为人确实也是身不由己，太多羁绊。但是有没有认真考虑过，有的东西是值得的吗？当发现不值得的时候，自己还有退路吗？是健康快乐更重要还是别人的看法更重要？

如何维护自身利益

那么，作为一个员工，我们应如何保护自己？不一定解决问题，但可能解决问题。

作为员工如何维护自己的利益

搞清楚劳动法和公司规定，知道自己有什么权利和责任。了解工资、工时、福利、休假等方面的规定，确保公司别违法。留着跟工作有关的文件，合同、工资单、绩效评估之类的记录。这些东西能当证据，帮你维护自己的权益。

如果有问题或烦恼，及时跟相关人员沟通，提供明确的事实和证据。参与公司的反馈机制，提建议和意见。继续学习，提升自己的技能，增加竞争力。参加培训课程、专业发展计划，提高职业能力和知识水平。

关注职业发展机会和市场趋势，找适合自己的发展方向。积极参与职业培训、跨部门项目之类的，提高竞争力。
平衡工作和个人生活的需求，保持身心健康。合理安排工作时间和休息时间，别太累和压力太大

被违法裁员时应如何处理

搞明白劳动法和规定，尤其是关于裁员的规定。这样你就知道自己有什么权利，雇主有什么责任。收集跟裁员有关的所有证据，比如裁员通知、合同、工资单、绩效评估、公司规定之类的文件。这些东西在后面的法律行动中可能很重要。

找专业的劳动法律顾问或律师咨询，让他们给你解释权益和法律选项。他们能帮你评估情况，提供适当的建议和法律支持。跟雇主沟通，表达你对裁员决定的担忧和不满。写份申诉信或要求重新考虑决定。有时候，通过沟通和谈判，可能会找到解决问题的办法。

根据当地的法律程序，你还有机会通过调解或仲裁来解决争议。律师会给你专业的法律建议，并在法庭上代表你维护权益。

最后，为勇敢维护自身利益的人们点赞！

相关信息

• 高管嚣张解雇员工引众怒 baijiahao.baidu.com/s?id=178748…


• 女高管违法开除男员工，员工不服反遭辱骂威胁 haokan.baidu.com/v?pd=wisena…


• 网传“女高管违法开除员工态度嚣张”，涉事公司凌晨回应 baijiahao.baidu.com/s?id=178745…