北漂的女孩

go携程算法：1-120万数里面的素数

Thu, 06 Jun 2024 11:43:14 +0800

没有面试就在家学习学习吧，万一遇见合适的，一次就面试成功

思路图：

程序算法：

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func main() {
    //存入12万数据 测试的可以少些
    ichan := make(chan int, 1000)
    //12数据的素数
    pchan := make(chan int, 1000)
    //判断chan是否可以关闭
    exitchan := make(chan bool, 16) //标识chan 结束

    wg.Add(1)
    n := 100
    go putNumber(ichan, n)

    //判断12万数据店里面的素数
    for i := 0; i < 16; i++ {
       wg.Add(1)
       go pNumber(ichan, pchan, exitchan)
    }
    //打印素数
    wg.Add(1)
    go fmtNumber(pchan)

    //因为判断素数开启了16个协程，不能直接在方法里面关闭，需要判断是否可以关闭
    wg.Add(1)
    //关闭协程
    go func() {
       for i := 0; i < 16; i++ {
          <-exitchan
       }
       //关闭pchan
       close(pchan)
       wg.Done()
    }()

    wg.Wait()
    fmt.Println("结束数据")
}

// 2-n的所有数据  写入ichan
func putNumber(ichan chan int, n int) {
    for i := 2; i <= n; i++ {
       ichan <- i
    }
    close(ichan)
    wg.Done()
}

// ichan里面取值，判断是不是素数
func pNumber(ichan chan int, pchan chan int, exitchan chan bool) {
    for val := range ichan {
       var flag = true
       for i := 2; i < val; i++ {
          if val%i == 0 {
             flag = false
             break
          }
       }
       if flag {
          pchan <- val
       }
    }

    wg.Done()
    //多个协程什么时候关闭chan，不能直接关闭，因为开16个协程，所以需要判断在去关闭
    //close(pchan)
    //新加一个管道，用来记录协程挂你
    exitchan <- true
}

// 输出素数
func fmtNumber(pchan chan int) {
    for num := range pchan {
       fmt.Println(num)
    }
    wg.Done()
}

linux 搭建docker

Wed, 29 May 2024 16:28:19 +0800

公司开始尝试用php转换成golang，由于投资的原因，我们又被迫离职了，现在出来找工作，都在问熟练使用docker等，反正不好找工作那就自己在家学习一下docker吧。

docker是什么？
其实docker是linux容器的一种封装方式，提供了简单易用的使用接口。Docker将应用程序与该程序的依赖，打包在一个文件里面，运行这个文件，就会生成一个虚拟容器，程序在这个虚拟容器里面运行，就好像在真是的物理机上运行一样，有了docker，就不用担心环境问题啊。
总体来讲，docker的接口相当简单，用户可以方便的创建和使用容器，把自己的应用放如容器，容器可以进行版本控制、复制、分享、修改，就像管理普通的代码一样。
docker的用途

提供了一次性的环境。本地测试他人软件、持续集成的时候提供单元测试和构建环境。
提供了弹性的云服务。docker容器可以随开随关，很适合动态扩容和缩容。
组建微服务架构。通过多个容器，一台服务器上可以跑多个服务，因此本机就可以虚拟出微服务架构

docker的安装
学习安装的地址：https://docs.docker.com/engine/install/centos/

注意：linux安装docker,内核版本要求在3.10及以上，可以用命令查看内核版本，uname -r

安装docker

yum -y installed docker

可能遇见的报错：

以前可能安装过docker，有版本的冲突，查找安装的docker包，并删除：查找命令 yum list installed | grep docker

移除命令：yum -y remove containerd.io.x86_64

安装docker

yum -y install docker

启动docker:

docker启动失败：

docker的版本太低了，安装docker-ce

移除所有docker相关的信息

安装docker-ce

安装完毕，启动docker

docker-ce 安装方法地址：https://developer.aliyun.com/mirror/docker-ce

docker 镜像的地址： https://developer.aliyun.com/mirror/

镜像的命令学习和方法

获取镜像：本地构建 docker build 拉去镜像 docker pull 镜像名称

查看镜像：docker images
删除镜像：docker rmi 镜像名称、镜像id
推送镜像：docker push 镜像名称
导出镜像：docker save -o 文件名.tar 镜像名称
加载镜像：docker load -i 文件名.tar
加载镜像：docker load -i -q 文件名.tar（不输出日志）

查看镜像：

拉去镜像：例如mysql5.7

将mysql5.7镜像进行压包

删除镜像

加载本地镜像

容器的命令学习

雪花算法id生成器

Fri, 10 Jun 2022 15:09:59 +0800

<?php
/**
 * Created by PhpStorm.
 * User: lhj
 * Date: 2020/11/18
 * Time: 9:39
 */
/**
 * 雪花算法id生成器
 * Class SnowFlake
 * @package app\base\utils
 * @author lhj
 */
class IdGenerator
{
    const EPOCH = 1479533469598;    //开始时间,固定一个小于当前时间的毫秒数
    const max12bit = 4095;
    const max41bit = 1099511627775;

    const MACHINEID = "machineId";  //配置里的机器id的key

    static $machineId = null;      // 机器id
    static $orderNumber = 0;
    //设置机器id
    public static function setMachineId($mId = 0)
    {
        self::$machineId = $mId;
    }
    //获取机器id
    public static function getMachineId()
    {
        return self::$machineId;
    }
    //生成id

    public static function createOnlyId($needOrder = true, $mId = 0)
    {
        // 时间戳 42字节
        $time = floor(microtime(true) * 1000);
        // 当前时间 与 开始时间 差值
        $time -= self::EPOCH;
        // 二进制的 毫秒级时间戳
        $base = decbin(self::max41bit + $time);
        // 机器id  10 字节

        if(!self::$machineId)
        {
            self::$machineId = config(self::MACHINEID);
        }

        if($mId)
            $machineNumberId = $mId;
        else
            $machineNumberId = self::$machineId;


        $machineid = str_pad(decbin($machineNumberId), 10, "0", STR_PAD_LEFT);

        $randNumber = 0;
        if($needOrder) {
            self::$orderNumber = self::$orderNumber < self::max12bit? self::$orderNumber + 1 : 0;
            $randNumber = self::$orderNumber;
        }else{
            self::$orderNumber = 0;
            $randNumber = mt_rand(0, self::max12bit);
        }

        // 序列数 12字节
        $random = str_pad(decbin($randNumber), 12, "0", STR_PAD_LEFT);
        // 拼接
        $base = $base.$machineid.$random;
        // 转化为 十进制 返回
        return bindec($base);
    }
}

无线递归获取标签

Wed, 16 Feb 2022 16:55:19 +0800

<?php

$tags = '[{"TagId":"5297739878417567745","TagName":"器械","Icon":"","TagPid":"0","TagPath":"\/","Selected":0,"Child":[{"TagId":"5297739991856713729",
"TagName":"瑜伽球","Icon":"","TagPid":"5297739878417567745","TagPath":"\/5297739878417567745","Selected":1,"Child":[]},{"TagId":"5297739939595685889",
"TagName":"哑铃","Icon":"","TagPid":"5297739878417567745","TagPath":"\/5297739878417567745","Selected":1,"Child":[]}]},
{"TagId":"5285677198231998465","TagName":"课件类型标签","Icon":"","TagPid":"0","TagPath":"\/","Selected":0,
"Child":[{"TagId":"5285678117011066881","TagName":"训练目的","Icon":"","TagPid":"5285677198231998465","TagPath":"\/5285677198231998465",
"Selected":0,"Child":[{"TagId":"5304964691385126913","TagName":"强化躯干力量和核心力量","Icon":"","TagPid":"5285678117011066881",
"TagPath":"\/5285677198231998465\/5285678117011066881","Selected":1,"Child":[]}]}]}]';

/**
 * 根据config算法匹配标签
 * depth : 匹配节点所在深度。
 * matchMethod : 匹配方式。
 * name : 匹配字符
 * show : 是否展示全路径，check :只显示选中一个节点，checkAll：显示所有路径上的节点（从depth 深度 节点开始）
 */
 * 'app_tags'=>[
    'queue' => [['depth'=>1,'matchMethod' => 'part','name'=>'队列','show'=>'checkAll']],
    'target' => [['depth'=>1,'matchMethod' => 'part','name'=>'训练目的','show'=>'check']],
    'instrument' => [['depth'=>0,'matchMethod' => 'part','name'=>'器械','show'=>'checkAll']],
    'showTag' => [
            ['depth'=>1,'matchMethod' => 'part','name'=>'心率','show'=>'checkAll'],
            ['depth'=>1,'matchMethod' => 'part','name'=>'消耗','show'=>'checkAll'],
            ['depth'=>1,'matchMethod' => 'part','name'=>'适用水平','show'=>'checkAll'],
            ['depth'=>1,'matchMethod' => 'part','name'=>'强度','show'=>'checkAll'],
            ['depth'=>1,'matchMethod' => 'part','name'=>'类别','show'=>'checkAll'],
        ],
],
 * @param [type] $tags
 * @return void
 * @Author lianghuiju@aocyun.com
 * @DateTime 2022-01-12
 */
public static function matchTags($tags,$matchKey = 'app_tags', $join = true, $joinStr = '、')
{   
    $result = [];
    $algorithm = config($matchKey) ?? [];
    if($algorithm){
        foreach($algorithm as $key => $al){
            $result[$key] = [];
            $ret = [];
            $match = false;
            $depth = 0;
            $ret = self::recursion_tags($tags,$al,$depth,$ret,$match);
            if($join && is_array($ret)){
                foreach($ret as $a=>$r){
                    $ret[$a] = implode($joinStr,$r); 
                }
            }
            if(is_array($ret)) $ret = array_values($ret);
            $result[$key] = $ret;
        }
    }
    return $result;
}
/**
 * 递归调用
 *
 * @param [type] $tags
 * @param [type] $algorithm
 * @param [type] $depth
 * @param [type] $result
 * @param boolean $match
 * @return void
 * @Author  lianghuiju@aocyun.com
 * @DateTime 2022-01-12
 */
public static function recursion_tags($tags, $algorithm, $depth, $result, $match = false, $matchName = false)
{
    foreach($tags as $k => $tag){
        $ret = false;
        $matchMethod = '';
        $name = '';
        $show = '';
        $dep = '';
        $mName = $matchName;
        $algo = $algorithm;

        foreach($algorithm as $k=>$al){
            $matchMethod = $al['matchMethod'];
            $name = $al['name'];
            $show = $al['show'];
            $dep = $al['depth'];
            if( $depth == $dep){
                if($matchMethod == 'part'){
                    $ret = strstr($tag['TagName'],$name) === false ? false : true;
                }else if($matchMethod == 'all'){
                    $ret = strcmp($tag['TagName'],$name) === 0 ? true : false;
                }
            }
            if($ret) {
                $match = true;
                $algo = [$al];
                $mName = $k;
                break;
            }
        }

        if(  $match && $mName !== false && ( ($show == 'check' && $tag['Selected']) 
            || ($show == 'checkAll') ) )
            $result[$mName][] = $tag['TagName'];
        
        
        if( !empty($tag['Child']) ){
            $result = self::recursion_tags($tag['Child'], $algo, $depth + 1, $result, $match, $mName);
        }
    }
    return $result;
}

ffmpeg脚本学习

Thu, 09 Dec 2021 15:23:57 +0800

一、简单的操作

对于 MPEG 格式的视频，可以直接连接：视频尺寸要一致

ffmpeg -i concat:"1.mpg|2.mpg|3.mpg" -c copy output.mp4

对于非 MPEG 格式容器，但是是 MPEG 编码器（H.264、DivX、XviD、MPEG4、MPEG2、AAC、MP2、MP3 等），

可以包装进 TS 格式的容器再合并。在新浪视频，有很多视频使用 H.264 编码器，可以采用这个方法(视频尺寸可以不一致)

视频合并素材.mp4 逐个转化为素材.ts

ffmpeg -i 1.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts 1.ts
ffmpeg -i 2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts 2.ts
ffmpeg -i 3.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts 3.ts

将1.ts，2.ts，3.ts 合成mp4。

ffmpeg -i "concat:1.ts|2.ts|3.ts" -c copy -bsf:a aac_adtstoasc -movflags +faststart ts.mp4

截取从第02:53开始后的10分02秒的长度的视频（CPU计算较慢，尝试使用GPU CUDA加速报错，待尝试）

ffmpeg -ss 00:02:53 -vsync 0 -t 00:10:01 -i ts.mp4   out.mp4

用audio音频替换video中的音频

ffmpeg -i 1.mp4 -i 1.mp3-c:v copy -c:a aac -strict experimental -map 0:v:0 -map 1:a:0 output.mp4

用audio音频和video中的音频混声

ffmpeg -i text.mp4 -stream_loop -1 -i 4.mp3 -filter_complex [0:a][1:a]amix -t 60 -y hun.mp4

二、FFmpeg concat 分离器

这种方法成功率很高，也是最好的，但是需要 FFmpeg 1.1 以上版本。先创建一个文本文件filelist.txt：

file 'input1.mkv'

file 'input2.mkv'

file 'input3.mkv'

然后：

ffmpeg -f concat -i filelist.txt -c copy output.mkv

注意：使用 FFmpeg concat 分离器时，如果文件名有奇怪的字符，要在 filelist.txt 中转义

测试了一下，不同尺寸的视频可以正常合成，但是不同格式的合成有问题

三、使用concat滤镜（filter）进行视频文件的合并：

 ffmpeg -i 1.mp4 -i 2.mp4 -i 3.mp4 -filter_complex '[0:0] [0:1] [1:0] [1:1] [2:0] [2:1] concat=n=3:v=1:a=1 [v] [a]' -map '[v]' -map '[a]’  output.mp4

上面的命令合并了三种不同格式的文件，FFmpeg concat 过滤器会重新编码它们。注意这是有损压缩。

[0:0] [0:1] [1:0] [1:1] [2:0] [2:1] 分别表示第一个输入文件的视频、音频、第二个输入文件的视频、音频、第三个输入文件的视频、音频。

concat=n=3:v=1:a=1 表示有三个输入文件，输出一条视频流和一条音频流。

[v] [a] 就是得到的视频流和音频流的名字，注意在 bash 等 shell 中需要用引号，防止通配符扩展。

音频拼接

ffmpeg -i "concat:3.mp3|4.mp3" -acodec copy third.mp3 (3格式和4保持一致)

音频拼接

ffmpeg -i "concat:first.mp3|second.mp3" -i second.mp3 -acodec copy test.mp3 -map_metadata 0:1  (third格式和second保持一致)

音视频混合，不调整音量

ffmpeg -i 1.mp4 -i 3.mp3 -c:v copy -map 0:v:0 -filter_complex "[0:a][1:a]amerge=inputs=2[aout]" -map "[aout]" -ac 2  mix_amerge.mp4

音频混合，调整第1个音频的音量和第2个音频的音量

ffmpeg -i 3.mp3 -i 4.mp3 -filter_complex "[0:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=0.5[a0]; 
[1:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=0.9[a1]; [a0][a1]amerge=inputs=2[aout]" 
-map "[aout]" -ac 2 mix_v0.5.mp3

音频混合，调整第1个音频的音量和第2个音频的音量

ffmpeg -i 3.mp3 -i new2.mp3 -filter_complex "[0:a]aformat=sample_fmts=fltp:channel_layouts=stereo,volume=0.5[a0]; 
[1:a]aformat=sample_fmts=fltp:channel_layouts=stereo,volume=0.9,adelay=5000|5000|5000,apad[a1]; [a0][a1]amerge=inputs=2[aout]" 
-shortest -map "[aout]" -ac 2 mix_new1.mp3

// apad -shortest 是使音频长度为最长

// adelay 延时播放时间

音视频混合，调整第1个音频的音量和第2个音频的音量

ffmpeg -i 1.mp4 -i 2.mp3 -filter_complex "[0:a]aformat=sample_fmts=fltp:channel_layouts=stereo,volume=0.4[a0]; 
[1:a]aformat=sample_fmts=fltp:channel_layouts=stereo,volume=0.9,adelay=5000|5000|5000[a1]; 
[a0][a1]amix=inputs=2:duration=first[aout]" -map [aout] -ac 2 -c:v copy -map 0:v:0 new3.mp4

视频合并

第一步将output1.mp4文件转成output1.ts

ffmpeg -i output1.mp4 -vcodec copy -acodec copy -vbsf h264_mp4toannexb output1.ts

第二步将output1.ts和output2.ts合并为Cam01.mp4

ffmpeg -y -f concat -safe 0 -i list.txt -c copy Cam01.mp4

list.text内容如下：

file 'output1.ts'

file 'output2.ts'

1.视频编辑比如从第5秒的地方开始，往后截取10秒钟

ffmpeg -ss 5 -t 10 -i output1.mp4 output2.mp4

2.视频加背景音乐

ffmpeg -y -i Cam01.mp4 -i jj01.mp3 -filter_complex 
[0:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=0.5[a0];
[1:a]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo,volume=0.5[a1];
[a0][a1]amix=inputs=2:duration=first[aout] -map [aout] -ac 2 -c:v copy -map 0:v:0 -preset superfast result.mp4

3.视频加速

ffmpeg -i result.mp4 -vf setpts=PTS/2 -af atempo=2 result01.mp4

4.音频剪辑

ffmpeg -y -i 124.mp3 -vn -acodec copy -ss 00:00:00 -t 00:01:32 output.mp3

5.调整视频宽高

ffmpeg -i result.mp4 -vf scale=320*240result02.mp4

6.分辨率 -vf scale=1920:1080

ffmpeg -i tsAll.mp4 -stream_loop -1 -i BGM.mp3 -vf scale=1920:1080 -filter_complex [0:a][1:a]amix -t 540 -y gao.mp4

7.比特率 -b

ffmpeg -i tsAll.mp4 -stream_loop -1 -i BGM.mp3 -vf scale=1920:1080 -b 1.5M -filter_complex [0:a][1:a]amix -t 540 -y su.mp4

8.帧率 -r

ffmpeg -i input.avi -r 30 output.mp4

9.将input.mp3的音量放大四倍

ffmpeg  -i   input.mp3   -vol   400    output.mp3

10.分离视频音频流

ffmpeg -i input_file -vcodec copy -an output_file_video　　//分离视频流
eg：ffmpeg -i 1.mp4 -vcodec copy -an 2.mp4
ffmpeg -i input_file -acodec copy -vn output_file_audio　　//分离音频流

11.-r 提取图像的频率，-ss 开始时间，-t 持续时间

ffmpeg -ss 0:1:30 -t 0:0:20 -i input.avi -vcodec copy -acodec copy output.avi    //剪切视频

12.ffmpeg从视频中生成gif图片：

ffmpeg -i capx.mp4 -t 10 -s 320x240 -pix_fmt rgb24 jidu1.gif

// -t参数表示提取前10秒视频

// -s 表示按照 320x240的像素提取

13.ffmpeg将视频导出成多张图片

ffmpeg -i output.mp4 -r 30 -f image2 foo-%05d.jpeg

// -r参数表示按照30帧的速度提取。

14.ffmpeg视频加水印

ffmpeg -hide_banner -i zui.mp4 -i 12.png -filter_complex "overlay=x=0:y=0" out111.mp4 -y

ffmpeg安装学习

Thu, 09 Dec 2021 15:19:01 +0800

下载两个压缩包，并解压

https://ffmpeg.org/releases/ffmpeg-snapshot.tar.bz2

http://www.tortall.net/projects/yasm/releases/yasm-1.3.0.tar.gz

上传linux的指定目录下，加压

tar -xjvf ffmpeg-snapshot.tar.bz2

tar -zxvf yasm-1.3.0.tar.gz

2、进入yasm-1.3.0目录，安装

./configure

make

make install

3、进入ffmpeg目录，开始安装

./configure –enable-shared –prefix= /opt/ffmpeg

make

make install

4、最后一步，lib包加载

耐心等待完成之后执行 cd /opt/ffmpeg/ 进入安装目录，查看一下发现有bin,include,lib,share这4个目录

bin是：ffmpeg主程序二进制目录

include是：C/C++头文件目录

lib是：编译好的库文件目录

share是：文档目录

然后进入bin目录，执行 ./ffmpeg -version 查看当前版本的详细信息

问题：一般会报libavdevice.so.57: cannot open shared object file: No such file or directory，原因是lib目录未加载到链接到系统库中，

解决方案：

系统ld目录列表在/etc/ld.so.conf中，打开文件会发现，里面引用了/etc/ld.so.conf.d/下面所有的.conf文件，比如mariadb-x86_64.conf我们只需要创建一个文件并写入lib路径即可，执行命令：vim /etc/ld.so.conf.d/ffmpeg.conf 然后添加一行内容： /opt/ffmpeg/lib 之后保存并退出，然后执行 Idconfig 使配置生效，

现在再次执行 ./ffmpeg -version 显示就正常了　

对数组分组、排序等操作

Wed, 16 Jun 2021 17:50:31 +0800

从yii2框架中看见一个关于数组的操作，感觉还可以，有需要的拿走不谢

<?php
/**
 * Class ArrayHelper
 * @see https://github.com/yiichina/yii2/blob/api/framework/helpers/BaseArrayHelper.php
 */
class ArrayHelper
{
    /**
     * 将对象或者对象数组转换成数组。
     * @param object|array|string $object 要转成数组的对象
     * @param array $properties 从对象类的名称到需要将生成的数组结果集放入到属性中的映射。
     * 每个类的属性集合指定一个以下格式的数组：
     *
     * ```php
     * [
     *     'app\models\Post' => [
     *         'id',
     *         'title',
     *         // the key name in array result => property name
     *         'createTime' => 'created_at',
     *         // the key name in array result => anonymous function
     *         'length' => function ($post) {
     *             return strlen($post->content);
     *         },
     *     ],
     * ]
     * ```
     *
     * `ArrayHelper::toArray($post, $properties)` 调用此方法生成的数组集合可能如下：
     *
     * ```php
     * [
     *     'id' => 123,
     *     'title' => 'test',
     *     'createTime' => '2013-01-01 12:00AM',
     *     'length' => 301,
     * ]
     * ```
     *
     * @param bool $recursive 是否使用递归的方式将对象的属性转换为数组。
     * @return array 这种对象的数组表示
     */
    public static function toArray($object, $properties = [], $recursive = true)
    {
        if (is_array($object)) {
            if ($recursive) {
                foreach ($object as $key => $value) {
                    if (is_array($value) || is_object($value)) {
                        $object[$key] = static::toArray($value, $properties, true);
                    }
                }
            }

            return $object;
        } elseif (is_object($object)) {
            if (!empty($properties)) {
                $className = get_class($object);
                if (!empty($properties[$className])) {
                    $result = [];
                    foreach ($properties[$className] as $key => $name) {
                        if (is_int($key)) {
                            $result[$name] = $object->$name;
                        } else {
                            $result[$key] = static::getValue($object, $name);
                        }
                    }

                    return $recursive ? static::toArray($result, $properties) : $result;
                }
            }
            if ($object instanceof Arrayable) {
                $result = $object->toArray([], [], $recursive);
            } else {
                $result = [];
                foreach ($object as $key => $value) {
                    $result[$key] = $value;
                }
            }

            return $recursive ? static::toArray($result, $properties) : $result;
        }

        return [$object];
    }

    /**
     * 递归合并 2 个及以上的数组。
     * 如果每个数组元素有相同的字符串键值对，
     * 后者将会覆盖前者（不同于 array_merge_recursive）。
     * 如果两个数组都有数组类型的元素并且具有相同的键，
     * 那么将进行递归合并。
     * 对于整型键类型元素，后面数组中的元素将
     * 会被追加到前面的数组中去。
     * 你能够使用 [[UnsetArrayValue]] 对象从之前的数组中设置值或者
     * [[ReplaceArrayValue]] 强制替换原先的值来替代递归数组合并。
     * @param array $a 需要合并的数组
     * @param array $b 需要合并的数组。你能够指定额外的
     * 数组中的第三个参数，第四个参数等。
     * @return array 合并之后的数组（不改变原始数组。）
     */
    public static function merge($a, $b)
    {
        $args = func_get_args();
        $res = array_shift($args);
        while (!empty($args)) {
            foreach (array_shift($args) as $k => $v) {
                if ($v instanceof UnsetArrayValue) {
                    unset($res[$k]);
                } elseif ($v instanceof ReplaceArrayValue) {
                    $res[$k] = $v->value;
                } elseif (is_int($k)) {
                    if (array_key_exists($k, $res)) {
                        $res[] = $v;
                    } else {
                        $res[$k] = $v;
                    }
                } elseif (is_array($v) && isset($res[$k]) && is_array($res[$k])) {
                    $res[$k] = static::merge($res[$k], $v);
                } else {
                    $res[$k] = $v;
                }
            }
        }

        return $res;
    }

    /**
     * 检索具有给定键或属性名的数组元素或对象属性的值。
     * 如果这个数组中不存在键，将返回默认值。
     * 从对象中获取值时不使用。
     *
     * 数组中的键可以指定圆点来检索子数组中的值或者对象中包含的属性。
     * 特别是，如果键是 `x.y.z`，
     * 然后返回的值中像这样 `$array['x']['y']['z']` 或者 `$array->x->y->z`（如果 `$array` 是一个对象）。
     * 如果 `$array['x']` 或者 `$array->x` 既不是数组也不是对象，将返回默认值。
     * 注意如果数组已经有元素 `x.y.z`，然后它的值将被返回来替代遍历子数组。
     * 因此最好要做指定键值对的数组
     * 像这样 `['x', 'y', 'z']`。
     *
     * 以下是一些用法示例,
     *
     * ```php
     * // working with array
     * $username = \yii\helpers\ArrayHelper::getValue($_POST, 'username');
     * // working with object
     * $username = \yii\helpers\ArrayHelper::getValue($user, 'username');
     * // working with anonymous function
     * $fullName = \yii\helpers\ArrayHelper::getValue($user, function ($user, $defaultValue) {
     *     return $user->firstName . ' ' . $user->lastName;
     * });
     * // using dot format to retrieve the property of embedded object
     * $street = \yii\helpers\ArrayHelper::getValue($users, 'address.street');
     * // using an array of keys to retrieve the value
     * $value = \yii\helpers\ArrayHelper::getValue($versions, ['1.0', 'date']);
     * ```
     *
     * @param array|object $array 从对象或数组中进行提取
     * @param string|\Closure|array $key 数组元素的键名，数组当中的键或者对象当中的属性名称，或者一个返回值的匿名函数。
     * 匿名函数应该像这样签名：
     * `function($array, $defaultValue)`。
     * 在 2.0.4 版本中可以通过数组当中可用的键来传递。
     * @param mixed $default 如果指定的数组当中的键不存在则返回默认值。
     * 从对象当中获取值时不使用。
     * @return mixed 找到该元素当中的值并返回，否则直接返回默认的值。
     */
    public static function getValue($array, $key, $default = null)
    {
        if ($key instanceof \Closure) {
            return $key($array, $default);
        }

        if (is_array($key)) {
            $lastKey = array_pop($key);
            foreach ($key as $keyPart) {
                $array = static::getValue($array, $keyPart);
            }
            $key = $lastKey;
        }

        if (is_array($array) && (isset($array[$key]) || array_key_exists($key, $array))) {
            return $array[$key];
        }

        if (($pos = strrpos($key, '.')) !== false) {
            $array = static::getValue($array, substr($key, 0, $pos), $default);
            $key = substr($key, $pos + 1);
        }

        if (is_object($array)) {
            // this is expected to fail if the property does not exist, or __get() is not implemented
            // it is not reliably possible to check whether a property is accessible beforehand
            return $array->$key;
        } elseif (is_array($array)) {
            return (isset($array[$key]) || array_key_exists($key, $array)) ? $array[$key] : $default;
        }

        return $default;
    }

    /**
     * 在指定键的路径上将值写入关联数组。
     * 如果没有这样的关键路径，它将通过递归创建。
     * 如果键存在，就会被覆盖。
     *
     * ```php
     *  $array = [
     *      'key' => [
     *          'in' => [
     *              'val1',
     *              'key' => 'val'
     *          ]
     *      ]
     *  ];
     * ```
     *
     * `ArrayHelper::setValue($array, 'key.in.0', ['arr' => 'val']);` 的结果如下：
     *
     * ```php
     *  [
     *      'key' => [
     *          'in' => [
     *              ['arr' => 'val'],
     *              'key' => 'val'
     *          ]
     *      ]
     *  ]
     *
     * ```
     *
     * 这个
     * `ArrayHelper::setValue($array, 'key.in', ['arr' => 'val']);` 或者
     * `ArrayHelper::setValue($array, ['key', 'in'], ['arr' => 'val']);`
     * 生成的结果集如下：
     *
     * ```php
     *  [
     *      'key' => [
     *          'in' => [
     *              'arr' => 'val'
     *          ]
     *      ]
     *  ]
     * ```
     *
     * @param array $array 将值写入到数组中
     * @param string|array|null $path 你想将值写入到 `$array` 中的路径
     * 它的组成可以是将每个路径的描述用圆点连起来
     * 也可以用数组中的键来描述路径
     * 如果路径为空 `$array` 则被分配给 `$value`
     * @param mixed $value 被写入的值
     * @since 2.0.13
     */
    public static function setValue(&$array, $path, $value)
    {
        if ($path === null) {
            $array = $value;
            return;
        }

        $keys = is_array($path) ? $path : explode('.', $path);

        while (count($keys) > 1) {
            $key = array_shift($keys);
            if (!isset($array[$key])) {
                $array[$key] = [];
            }
            if (!is_array($array[$key])) {
                $array[$key] = [$array[$key]];
            }
            $array = &$array[$key];
        }

        $array[array_shift($keys)] = $value;
    }

    /**
     * 从数组中移除元素并返回值。
     * 如果数组中不存在键，则默认值将被返回。
     *
     * 用法示例，
     *
     * ```php
     * // $array = ['type' => 'A', 'options' => [1, 2]];
     * // working with array
     * $type = \yii\helpers\ArrayHelper::remove($array, 'type');
     * // $array content
     * // $array = ['options' => [1, 2]];
     * ```
     *
     * @param array $array 要从中提取值得数组
     * @param string $key 数组元素的键名
     * @param mixed $default 如果指定的键不存在则返回默认值
     * @return mixed|null 如果找到该元素的值，否则为默认值
     */
    public static function remove(&$array, $key, $default = null)
    {
        if (is_array($array) && (isset($array[$key]) || array_key_exists($key, $array))) {
            $value = $array[$key];
            unset($array[$key]);

            return $value;
        }

        return $default;
    }

    /**
     * 从数组中移除对应的值并返回移除的项。
     *
     * 比如，
     *
     * ```php
     * $array = ['Bob' => 'Dylan', 'Michael' => 'Jackson', 'Mick' => 'Jagger', 'Janet' => 'Jackson'];
     * $removed = \yii\helpers\ArrayHelper::removeValue($array, 'Jackson');
     * // result:
     * // $array = ['Bob' => 'Dylan', 'Mick' => 'Jagger'];
     * // $removed = ['Michael' => 'Jackson', 'Janet' => 'Jackson'];
     * ```
     *
     * @param array $array 查找值得数组
     * @param string $value 从这个数组中移除的值
     * @return array 返回从数组中移除的项
     * @since 2.0.11
     */
    public static function removeValue(&$array, $value)
    {
        $result = [];
        if (is_array($array)) {
            foreach ($array as $key => $val) {
                if ($val === $value) {
                    $result[$key] = $val;
                    unset($array[$key]);
                }
            }
        }

        return $result;
    }

    /**
     * 根据指定的键对数组进行索引和/或分组。
     * 输入的应该是多维数组或对象数组。
     *
     * 这个 $key 可以是子数组的键名，对象的属性名，
     * 或匿名函数返回的值将被用作键。
     *
     * $groups 是数组中的键，
     * 用于根据指定的键将输入数组分组为一个或多个子数组。
     *
     * 如果 `$key` 被指定为 `null` 或者与该键对应的元素的值除未指定的 `$groups`
     * 外为 `null` 那么该元素将被丢弃。
     *
     * 比如：
     *
     * ```php
     * $array = [
     *     ['id' => '123', 'data' => 'abc', 'device' => 'laptop'],
     *     ['id' => '345', 'data' => 'def', 'device' => 'tablet'],
     *     ['id' => '345', 'data' => 'hgi', 'device' => 'smartphone'],
     * ];
     * $result = ArrayHelper::index($array, 'id');
     * ```
     *
     * 结果会生成一个关联数组，这个键就是 `id` 属性的值
     *
     * ```php
     * [
     *     '123' => ['id' => '123', 'data' => 'abc', 'device' => 'laptop'],
     *     '345' => ['id' => '345', 'data' => 'hgi', 'device' => 'smartphone']
     *     // The second element of an original array is overwritten by the last element because of the same id
     * ]
     * ```
     *
     * 匿名函数也可以用作于分组数组当中。
     *
     * ```php
     * $result = ArrayHelper::index($array, function ($element) {
     *     return $element['id'];
     * });
     * ```
     *
     * `id` 将作为第三个参数传入到 `$array` 并按 `id` 进行分组：
     *
     * ```php
     * $result = ArrayHelper::index($array, null, 'id');
     * ```
     *
     * 结果将生成多维数组并按 `id` 进行一维分组，
     * 二维按索引 `device` 进行分组并生成 `data` 索引三维数组：
     *
     * ```php
     * [
     *     '123' => [
     *         ['id' => '123', 'data' => 'abc', 'device' => 'laptop']
     *     ],
     *     '345' => [ // all elements with this index are present in the result array
     *         ['id' => '345', 'data' => 'def', 'device' => 'tablet'],
     *         ['id' => '345', 'data' => 'hgi', 'device' => 'smartphone'],
     *     ]
     * ]
     * ```
     *
     * 通过键进行分组的数组中也可以使用匿名函数：
     *
     * ```php
     * $result = ArrayHelper::index($array, 'data', [function ($element) {
     *     return $element['id'];
     * }, 'device']);
     * ```
     *
     * 结果将返回一个多维数组一维按 `id` 分组，
     * 二维按索引 `device` 分组并且三维按索引 `data` 进行分组：
     *
     * ```php
     * [
     *     '123' => [
     *         'laptop' => [
     *             'abc' => ['id' => '123', 'data' => 'abc', 'device' => 'laptop']
     *         ]
     *     ],
     *     '345' => [
     *         'tablet' => [
     *             'def' => ['id' => '345', 'data' => 'def', 'device' => 'tablet']
     *         ],
     *         'smartphone' => [
     *             'hgi' => ['id' => '345', 'data' => 'hgi', 'device' => 'smartphone']
     *         ]
     *     ]
     * ]
     * ```
     *
     * @param array $array 需要索引或者分组的数组
     * @param string|\Closure|null $key 列名或者匿名函数的结果将用于对数组进行分组
     * @param string|string[]|\Closure[]|null $groups 数组当中的键，将用一个或多个键来对传入的数组进行分组。
     * 如果 $key 属性或者它的值的特定元素为空和 $groups 没有定义，数组的元素将被丢弃。
     * 因此，如果变量 $groups 是指定的，数组元素将被添加到没有任何键的数组当中。
     * 此参数自版本 2.0.8 起可用。
     * @param array $delKeys 要删除的键 custom code
     * @return array 索引数组和/或分组数组
     */
    public static function index($array, $key, $groups = [], $delKeys = [])
    {
        $result = [];
        $groups = (array) $groups;

        foreach ($array as $element) {
            $lastArray = &$result;

            foreach ($groups as $group) {
                $value = static::getValue($element, $group);
                if (!array_key_exists($value, $lastArray)) {
                    $lastArray[$value] = [];
                }
                $lastArray = &$lastArray[$value];
            }

            if ($key === null) {
                if (!empty($groups)) {
                    //custom code
                    foreach ($delKeys as $delKey) {
                        static::remove($element, $delKey);
                    }
                    $lastArray[] = $element;
                }
            } else {
                $value = static::getValue($element, $key);
                if ($value !== null) {
                    if (is_float($value)) {
                        $value = StringHelper::floatToString($value);
                    }
                    //custom code
                    foreach ($delKeys as $delKey) {
                        static::remove($element, $delKey);
                    }
                    $lastArray[$value] = $element;
                }
            }
            unset($lastArray);
        }

        return $result;
    }

    /**
     * 返回数组中指定列的值。
     * 传入的数组类型可以是多维数组或者对象数组。
     *
     * 比如，
     *
     * ```php
     * $array = [
     *     ['id' => '123', 'data' => 'abc'],
     *     ['id' => '345', 'data' => 'def'],
     * ];
     * $result = ArrayHelper::getColumn($array, 'id');
     * // the result is: ['123', '345']
     *
     * // using anonymous function
     * $result = ArrayHelper::getColumn($array, function ($element) {
     *     return $element['id'];
     * });
     * ```
     *
     * @param array $array
     * @param int|string|\Closure $name
     * @param bool $keepKeys 是否保留数组的键。如果不保留，
     * 数组的结果的索引将被重新定义为整数。
     * @return array 返回列表的列值
     */
    public static function getColumn($array, $name, $keepKeys = true)
    {
        $result = [];
        if ($keepKeys) {
            foreach ($array as $k => $element) {
                $result[$k] = static::getValue($element, $name);
            }
        } else {
            foreach ($array as $element) {
                $result[] = static::getValue($element, $name);
            }
        }

        return $result;
    }

    /**
     * 从多维数组当中或者对象数组（key-value pairs）构建一个映射。
     * 那个 `$from` 和 `$to` 参数指定的键名或者属性名来设置映射。
     * 可选，可以根据 `$group` 变量对映射键值对进一步分组。
     *
     * 比如，
     *
     * ```php
     * $array = [
     *     ['id' => '123', 'name' => 'aaa', 'class' => 'x'],
     *     ['id' => '124', 'name' => 'bbb', 'class' => 'x'],
     *     ['id' => '345', 'name' => 'ccc', 'class' => 'y'],
     * ];
     *
     * $result = ArrayHelper::map($array, 'id', 'name');
     * // the result is:
     * // [
     * //     '123' => 'aaa',
     * //     '124' => 'bbb',
     * //     '345' => 'ccc',
     * // ]
     *
     * $result = ArrayHelper::map($array, 'id', 'name', 'class');
     * // the result is:
     * // [
     * //     'x' => [
     * //         '123' => 'aaa',
     * //         '124' => 'bbb',
     * //     ],
     * //     'y' => [
     * //         '345' => 'ccc',
     * //     ],
     * // ]
     * ```
     *
     * @param array $array
     * @param string|\Closure $from
     * @param string|\Closure $to
     * @param string|\Closure $group
     * @return array
     */
    public static function map($array, $from, $to, $group = null)
    {
        $result = [];
        foreach ($array as $element) {
            $key = static::getValue($element, $from);
            $value = static::getValue($element, $to);
            if ($group !== null) {
                $result[static::getValue($element, $group)][$key] = $value;
            } else {
                $result[$key] = $value;
            }
        }

        return $result;
    }

    /**
     * 检查给定数组是否包含指定键。
     * 此方法通过支持不区分大小写键的比较增强了 `array_key_exists()`
     * 函数。
     * @param string $key 检测的键名
     * @param array $array 需要检查键的数组
     * @param bool $caseSensitive 键的比较是否支持区分大小写
     * @return bool 数组是否包含指定的键
     */
    public static function keyExists($key, $array, $caseSensitive = true)
    {
        if ($caseSensitive) {
            // Function `isset` checks key faster but skips `null`, `array_key_exists` handles this case
            // http://php.net/manual/en/function.array-key-exists.php#107786
            return isset($array[$key]) || array_key_exists($key, $array);
        }

        foreach (array_keys($array) as $k) {
            if (strcasecmp($key, $k) === 0) {
                return true;
            }
        }

        return false;
    }

    /**
     * 按一个或多个键对对象数组或者数组（具有相同结构）进行排序。
     * @param array $array 要排序的数组。调用此方法后数组将被修改。
     * @param string|\Closure|array $key 按 key(s) 进行排序。
     * 引用子数组的键名元素，对象的属性名，或一个匿名函数返回用于比较的值。
     * 匿名函数的签名应该是这样的：`function($item)`。
     * 要按多维键排序，需提供数组中的键。
     * @param int|array $direction 排序方向。它可以按照 `SORT_ASC` 或者 `SORT_DESC` 来排序。
     * 当按照不同排序方向的多个键排序时，使用数组进行排序。
     * @param int|array $sortFlag PHP 排序标记。包括有效的值
     * `SORT_REGULAR`，`SORT_NUMERIC`，`SORT_STRING`，`SORT_LOCALE_STRING`，`SORT_NATURAL` 和 `SORT_FLAG_CASE`。
     * 请参考 [PHP manual](http://php.net/manual/en/function.sort.php)
     * 获取更多详细信息。按具有不同排序标志的多个键排序时，使用数组中的标记排序。
     * @throws InvalidArgumentException 如果 $direction 或者 $sortFlag 参数的个数
     * 与 $key 参数的个数不一致。
     */
    public static function multisort(&$array, $key, $direction = SORT_ASC, $sortFlag = SORT_REGULAR)
    {
        $keys = is_array($key) ? $key : [$key];
        if (empty($keys) || empty($array)) {
            return;
        }
        $n = count($keys);
        if (is_scalar($direction)) {
            $direction = array_fill(0, $n, $direction);
        } elseif (count($direction) !== $n) {
            throw new InvalidArgumentException('The length of $direction parameter must be the same as that of $keys.');
        }
        if (is_scalar($sortFlag)) {
            $sortFlag = array_fill(0, $n, $sortFlag);
        } elseif (count($sortFlag) !== $n) {
            throw new InvalidArgumentException('The length of $sortFlag parameter must be the same as that of $keys.');
        }
        $args = [];
        foreach ($keys as $i => $key) {
            $flag = $sortFlag[$i];
            $args[] = static::getColumn($array, $key);
            $args[] = $direction[$i];
            $args[] = $flag;
        }

        // This fix is used for cases when main sorting specified by columns has equal values
        // Without it it will lead to Fatal Error: Nesting level too deep - recursive dependency?
        $args[] = range(1, count($array));
        $args[] = SORT_ASC;
        $args[] = SORT_NUMERIC;

        $args[] = &$array;
        call_user_func_array('array_multisort', $args);
    }

    /**
     * 将字符串数组中的特殊字符编码为 HTML 实体。
     * 默认情况下只对数组值进行编码。
     * 如果数组是一个值，此方法还将递归的进行编码。
     * 只有字符串值才会被编码。
     * @param array $data 将要被编码的数据
     * @param bool $valuesOnly 是否只对数组值进行编码。
     * 如果不是，数组的键和值将同时被编码。
     * @param string $charset 数据使用的字符集。如果没有设置，
     * [[\yii\base\Application::charset]] 将被使用。
     * @return array 返回编码的数据
     * @see http://www.php.net/manual/en/function.htmlspecialchars.php
     */
    public static function htmlEncode($data, $valuesOnly = true, $charset = null)
    {
        if ($charset === null) {
            $charset = 'UTF-8';
        }
        $d = [];
        foreach ($data as $key => $value) {
            if (!$valuesOnly && is_string($key)) {
                $key = htmlspecialchars($key, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
            }
            if (is_string($value)) {
                $d[$key] = htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
            } elseif (is_array($value)) {
                $d[$key] = static::htmlEncode($value, $valuesOnly, $charset);
            } else {
                $d[$key] = $value;
            }
        }

        return $d;
    }

    /**
     * 将 HTML 实体解码为字符串数组中的相应字符。
     * 只有数组值将被默认解码。
     * 如果数组是一个值，此方法还将递归的进行解码。
     * 只有字符串值才会被解码。
     * @param array $data 将要被解码的数据
     * @param bool $valuesOnly 是否只对数组值进行解码。
     * 如果不是，数组的键和值都将被解码。
     * @return array 返回解码的数据
     * @see http://www.php.net/manual/en/function.htmlspecialchars-decode.php
     */
    public static function htmlDecode($data, $valuesOnly = true)
    {
        $d = [];
        foreach ($data as $key => $value) {
            if (!$valuesOnly && is_string($key)) {
                $key = htmlspecialchars_decode($key, ENT_QUOTES);
            }
            if (is_string($value)) {
                $d[$key] = htmlspecialchars_decode($value, ENT_QUOTES);
            } elseif (is_array($value)) {
                $d[$key] = static::htmlDecode($value);
            } else {
                $d[$key] = $value;
            }
        }

        return $d;
    }

    /**
     * 返回一个值，该值指示给定数组是否是关联数组。
     *
     * 如果数组的键都是字符串，那么数组就是关联的。如果 `$allStrings` 设置为假，
     * 如果数组的键中至少有一个是字符串，那么该数组将被视为关联数组。
     *
     * 注意，空数组不会被认为是关联的。
     *
     * @param array $array 将被检测的数组
     * @param bool $allStrings 数组键是否必须为所有字符串
     * 以便数组被视为关联的。
     * @return bool 返回数组是否是关联数组
     */
    public static function isAssociative($array, $allStrings = true)
    {
        if (!is_array($array) || empty($array)) {
            return false;
        }

        if ($allStrings) {
            foreach ($array as $key => $value) {
                if (!is_string($key)) {
                    return false;
                }
            }

            return true;
        }

        foreach ($array as $key => $value) {
            if (is_string($key)) {
                return true;
            }
        }

        return false;
    }

    /**
     * 返回一个值，该值指示给定数组是否是索引数组。
     *
     * 如果一个数组的所有键都是整数，那么该数组是索引数组。如果变量 `$consecutive` 设置为真，
     * 那么数组键必须是从 0 开始的连续序列。
     *
     * 注意，空数组将被认为是索引的。
     *
     * @param array $array 将被检测的数组
     * @param bool $consecutive 数组键是否必须是连续序列
     * 以便数组是不是索引数组。
     * @return bool 是否为索引数组
     */
    public static function isIndexed($array, $consecutive = false)
    {
        if (!is_array($array)) {
            return false;
        }

        if (empty($array)) {
            return true;
        }

        if ($consecutive) {
            return array_keys($array) === range(0, count($array) - 1);
        }

        foreach ($array as $key => $value) {
            if (!is_int($key)) {
                return false;
            }
        }

        return true;
    }

    /**
     * 检查是否为数组或 [[\Traversable]] 包含一个元素。
     *
     * 这个方法与 PHP 函数 [in_array()](http://php.net/manual/en/function.in-array.php) 相同
     * 但它还适用于实现 [[\Traversable]] 接口。
     * @param mixed $needle 寻找的值。
     * @param array|\Traversable $haystack 要寻找的值。
     * @param bool $strict 是否启用 (`===`) 比较。
     * @return bool 如果 `$needle` 存在于 `$haystack` 中返回 `true`，否则将返回 `false`。
     * @throws InvalidArgumentException 如果 `$haystack` 不能遍历也不是数组则返回异常。
     * @see http://php.net/manual/en/function.in-array.php
     * @since 2.0.7
     */
    public static function isIn($needle, $haystack, $strict = false)
    {
        if ($haystack instanceof \Traversable) {
            foreach ($haystack as $value) {
                if ($needle == $value && (!$strict || $needle === $value)) {
                    return true;
                }
            }
        } elseif (is_array($haystack)) {
            return in_array($needle, $haystack, $strict);
        } else {
            throw new InvalidArgumentException('Argument $haystack must be an array or implement Traversable');
        }

        return false;
    }

    /**
     * 检查变量是数组还是 [[\Traversable]]。
     *
     * 该方法与 PHP 函数 [is_array()](http://php.net/manual/en/function.is-array.php) 相同，
     * 但是，它还可以用于实现 [[\Traversable]] 接口。
     * @param mixed $var 被评估的变量。
     * @return bool 变量 $var 是否是一个数组
     * @see http://php.net/manual/en/function.is-array.php
     * @since 2.0.8
     */
    public static function isTraversable($var)
    {
        return is_array($var) || $var instanceof \Traversable;
    }

    /**
     * 检测是否为一个数组或者 [[\Traversable]] 是另一个数组的子集还是 [[\Traversable]]。
     *
     * 这个方法将返回 `true`，如果 `$needles` 所有的元素都包含在 `$haystack`。
     * 如果至少缺少一个元素的话，将被返回 `false`。
     * @param array|\Traversable $needles 这个值必须 **all** 在 `$haystack` 存在。
     * @param array|\Traversable $haystack 要搜索的值。
     * @param bool $strict 是否启用 (`===`) 比较。
     * @throws InvalidArgumentException 如果 `$haystack` 或者 `$needles` 既不能遍历也不是数组。
     * @return bool 如果 `$needles` 存在于 `$haystack` 返回 `true`，否则返回 `false`。
     * @since 2.0.7
     */
    public static function isSubset($needles, $haystack, $strict = false)
    {
        if (is_array($needles) || $needles instanceof \Traversable) {
            foreach ($needles as $needle) {
                if (!static::isIn($needle, $haystack, $strict)) {
                    return false;
                }
            }

            return true;
        }

        throw new InvalidArgumentException('Argument $needles must be an array or implement Traversable');
    }

    /**
     * 根据指定的规则筛选数组。
     *
     * 比如：
     *
     * ```php
     * $array = [
     *     'A' => [1, 2],
     *     'B' => [
     *         'C' => 1,
     *         'D' => 2,
     *     ],
     *     'E' => 1,
     * ];
     *
     * $result = \yii\helpers\ArrayHelper::filter($array, ['A']);
     * // $result will be:
     * // [
     * //     'A' => [1, 2],
     * // ]
     *
     * $result = \yii\helpers\ArrayHelper::filter($array, ['A', 'B.C']);
     * // $result will be:
     * // [
     * //     'A' => [1, 2],
     * //     'B' => ['C' => 1],
     * // ]
     *
     * $result = \yii\helpers\ArrayHelper::filter($array, ['B', '!B.C']);
     * // $result will be:
     * // [
     * //     'B' => ['D' => 2],
     * // ]
     * ```
     *
     * @param array $array 源数组
     * @param array $filters 定义应该从结果中保留或删除的数组键的规则。
     * 具体规则如下：
     * - `var` - `$array['var']` 将被留在数组中。
     * - 只有 `var.key` = `$array['var']['key'] 将留在数组中。
     * - `!var.key` = `$array['var']['key'] 将从结果集中移除。
     * @return array 过滤后的数组
     * @since 2.0.9
     */
    public static function filter($array, $filters)
    {
        $result = [];
        $forbiddenVars = [];

        foreach ($filters as $var) {
            $keys = explode('.', $var);
            $globalKey = $keys[0];
            $localKey = isset($keys[1]) ? $keys[1] : null;

            if ($globalKey[0] === '!') {
                $forbiddenVars[] = [
                    substr($globalKey, 1),
                    $localKey,
                ];
                continue;
            }

            if (!array_key_exists($globalKey, $array)) {
                continue;
            }
            if ($localKey === null) {
                $result[$globalKey] = $array[$globalKey];
                continue;
            }
            if (!isset($array[$globalKey][$localKey])) {
                continue;
            }
            if (!array_key_exists($globalKey, $result)) {
                $result[$globalKey] = [];
            }
            $result[$globalKey][$localKey] = $array[$globalKey][$localKey];
        }

        foreach ($forbiddenVars as $var) {
            list($globalKey, $localKey) = $var;
            if (array_key_exists($globalKey, $result)) {
                unset($result[$globalKey][$localKey]);
            }
        }

        return $result;
    }
}

php+Spreadsheet导出多个sheet

Thu, 10 Jun 2021 18:19:27 +0800

产品需求让一键导出多个sheet，脑子里面立马想到了PhpOffer

<?php
namespace app\count\logic;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

/**
 * 按照不同的条件导出
 * @param $data
 * auth:lianghuiju@aocyun.com
 * time:2021/6/3 17:39
 */
public function getExportCountExcel(){
    $exportRes = array(
        'campusList'=>array(
            "0"=>array(
                'CampusName'=>'学校',
                'PreviewTimes'=>'500',
                'DateTime'=>'20210610'
            ),
            "1"=>array(
                'CampusName'=>'学校1',
                'PreviewTimes'=>'500',
                'DateTime'=>'20210610'
            ),
        ),
        'classList'=>array(
            "0"=>array(
                'CampusName'=>'校区1',
                'ClassName'=>'班级1',
                'LookBackTotal'=>'34'
            ),
            "1"=>array(
                'CampusName'=>'校区2',
                'ClassName'=>'班级2',
                'LookBackTotal'=>'8'
            ),
        )
    );   
    $this->dataAll($exportRes);
}

/**
 * 格式化标准数据并导出
 * @param $data
 * @throws \PhpOffice\PhpSpreadsheet\Writer\Exception
 * auth:lianghuiju
 * time:2021/6/7 18:32
 */
public function dataAll($data){
    $lastArr = [];
    $num = count($lastArr);
    if(isset($data['campusList'])){
        $lastArr[$num]['title'] = "机构数据";
        $lastArr[$num]['rows'][0] = ['学校名称','预习平均使用时长','学习日期'];
        $i = 1;
        foreach ($data['campusList'] as $key =>$value){
          $lastArr[$num]['rows'][$i++]=[$value['CampusName'],$value['PreviewTimes'],$value['DateTime']];
        }
    }
    $num = count($lastArr);
    if(isset($data['classList'])){
        $lastArr[$num]['title'] = "校区数据";
        $lastArr[$num]['rows'][0] = ['学校名称','班级名称','预习平均使用时长'];
        $i = 1;
        foreach ($data['classList'] as $value){
          $lastArr[$num]['rows'][$i++]=[$value['CampusName'],$value['ClassName'],$value['LookBackTotal']];
        }
    }
    $this->xtexport($lastArr);
}

/**
 * 数据导出
 * @param $data_array
 * @throws \PhpOffice\PhpSpreadsheet\Writer\Exception
 * auth:lianghuiju
 * time:2021/6/7 18:15
 */
public  function xtexport($data_array)
{
    $name = '学习统计' . date("Y-m-d", time());
    $spreadsheet = new Spreadsheet();
    foreach ($data_array as $key => $data) {
        $this->opSheet($spreadsheet,$key,$data);
    }
    header('Content-Type: application/vnd.ms-excel');
    header('Content-Disposition: attachment;filename="' . $name . '.xlsx"');
    header('Cache-Control: max-age=0');
    $writer = new Xlsx($spreadsheet);
    $writer->save('php://output');
    $spreadsheet->disconnectWorksheets();//删除清空：
    unset($spreadsheet);
    exit;
}

/**
 * 数据填充到excel
 * @param $spreadsheet
 * @param $n
 * @param $data
 * auth:lianghuiju
 * time:2021/6/7 18:30
 */
private function opSheet($spreadsheet,$n, $data){
    $spreadsheet->createSheet();//创建sheet
    $spreadsheet->setActiveSheetIndex($n);//设置当前的活动sheet
    $keys = $data['rows'][0];//这是你的数据键名
    $count = count($keys);//计算你所占的列数
    $infoStart =  1 ;//下面的详细信息的开始行数
    $sheet = $spreadsheet->getActiveSheet($n)->setTitle($data['title']);//设置sheet的名称
    foreach ($data['rows'] as $key => $item) {
        for ($i = 65; $i < $count + 65; $i++) {
            $sheet->setCellValue(strtoupper(chr($i)) . ($key+"$infoStart"), $item[$i - 65]);
        }
    }
}

Filebeat + elasticsearch+kibana日志收集

Thu, 13 May 2021 10:50:29 +0800

Filebeat + elasticsearch+kibana

注意：版本一致7.12.1，linux环境下安装,路径：/usr/local/soft

1.filebeat

官方文档：https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-installation-configuration.html

下载地址：https://www.elastic.co/cn/downloads/beats/filebeat

安装步骤：linux 安装

curl -L -O https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-7.12.1-linux-x86_64.tar.gz

tar xzvf filebeat-7.12.1-linux-x86_64.tar.gz

进入目录 cd /usr/local/soft/filebeat/filebeat-7.12.1-linux-x86_64/modules.d

执行 ./filebeat modules list （启动和编辑收集）

执行 ./filebeat modules enable system nginx mysql （启用一个/多个模块，nginx和mysql）

进入目录：cd /usr/local/soft/filebeat/filebeat-7.12.1-linux-x86_64/modules.d

修改nginx.yml

修改完文件保存：执行这个文本 ./filebeat test config -e 检测你的配置是不是对

继续执行： ./filebeat setup -e （确保你又权限执行）

最后启动： ./filebeat -e

需要注意的是：

setup.ilm.enabled: auto

setup.ilm.rollover_alias: "filebeat"

setup.ilm.pattern: "{now/d}-000001"

Filebeats从版本7.0起，生命周期需要自己管理es的索引了，

收集多个项目并按照不用的索引展示信息：配置文件

# ============================== Filebeat inputs ===============================
filebeat.inputs:
- type: log
  # Change to true to enable this input configuration.
  enabled: true
  # Paths that should be crawled and fetched. Glob based paths.
  paths:
    #- /var/log/*.log
    - /www/tp5/runtime/log/*/*.log
    #- c:\programdata\elasticsearch\logs\*
  fields:
     indexprefix: "tplog_5"
  json.add_error_key: true
- type: log
  enabled: true
  paths:
    - /www/csy-vclass-osc-console/runtime/log/*/*.log
  fields:
    indexprefix: "tplog_osc"
# ---------------------------- Elasticsearch Output ----------------------------
setup.ilm.enabled: false
setup.template.name: "thinkphp_log"
setup.template.pattern: "thinkphp_log-*"

output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["127.0.0.1:9200"]
  index: "%{[fields][indexprefix]}-%{+yyyy.MM.dd}"

2.elasticsearch

官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/current/targz.html

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.12.1-linux-x86_64.tar.gz

安装：tar -xzf elasticsearch-7.12.1-linux-x86_64.tar.gz

目录：cd elasticsearch-7.12.1/

需要注意的是：

新版的elasticsearch，不让用root用户启动，所以你需要新建一个新的用户再去执行

我这边把整合elasticsearch设置新的权限

useradd lianghuiju 新增用户

passwd lianghuiju 设置密码

chown lianghuiju:lianghuiju elasticsearch 整个文件用lianghuiju用户执行

chown 777 elasticsearch lianghuiju用户有最高的权限

执行：./bin/elasticsearch

在需要注意点：

elasticsearch 外网不能访问，

修改 vim /usr/local/soft/elasticsearch/elasticsearch-7.12.1/config/elasticsearch.yml

但是我不可以，需要代理转发出去 Nginx 配置TCP代理转发出去：

vim /usr/local/soft/openresty/nginx/conf/nginx.conf

stream {

log_format proxy '$remote_addr [$time_local] '

'$protocol $status $bytes_sent $bytes_received '

'$session_time "$upstream_addr" '

'"$upstream_bytes_sent" "$upstream_bytes_received" "$upstream_connect_time"';

access_log /mydata/logs/tcp-access.log proxy ;#日志地址需要你

open_log_file_cache off;

include tcpConf/*.conf; # 统一放置，方便管理

}

在/usr/local/soft/openresty/nginx/conf目录里面需要常见一个文件夹tcpConf

在/usr/local/soft/openresty/nginx/conf/tcpConf里面创建一个tcp9004.conf

内容：

upstream tcp9004 {

server 127.0.0.1:9200;//把9200代理出去，端口用9004

}

server {

listen 9004;

proxy_connect_timeout 8s;

proxy_timeout 24h;

proxy_pass tcp9004;

}

记得服务器重启：service nginx restart

3.kibana

文档地址：https://www.elastic.co/cn/start

下载 curl -O https://artifacts.elastic.co/downloads/kibana/kibana-7.12.1-linux-x86_64.tar.gz

解压 tar -xzf kibana-7.12.1-linux-x86_64.tar.gz

进入目录cd kibana-7.12.1-linux-x86_64/

执行 ./bin/kibana

注意：

Kibana和es是一样的，也不让root用户启动

配置文件：

i18n.locale: "zh-CN" #kibana展示为中文

elasticsearch.hosts: ["http://192.168.56.101:9004"] #配置好es

kibana.index: ".kibana"

server.port: 5601 #启动端口

server.host: "192.168.56.101" #kibana配置ip便于外网访问

进入虚拟机需要看你自己的ip

流量并发控制常用的方法

Sun, 25 Apr 2021 17:10:14 +0800

在最近几天的面试中，老被面试问到，对于大流量高并发的情况下，怎么做到并发流量控制

1.计数器

<?php
/**
 * 计数器来限流
 * @param $uid  用户的uid
 * @param $actionKey  任务名的key
 * @param int $limitTime 多长时间
 * @param int $maxCount 访问的最大次数
 */
function countingFlow($uid,$actionKey,$limitTime=60,$maxCount=100){
    if(empty($uid) || empty($actionKey)){
        return false;
    }
    $redis = new Redis();
    $redis->connect("127.0.0.1",6379);
    $redis->auth("foobared");
    $redisKey = sprintf("hist:%s:%s",$uid,$actionKey);
    $count = $redis->incr($redisKey);
    if($count == 1){
        $redis->expire($redisKey,$limitTime);
    }
    if($count > $maxCount){
        return false;
    }
    return true;
}

注意：

临界问题：
在第一次0-58秒之内有1个请求，在59秒内突然来了15个请求，这个时候已经到了1分钟计数器会重置。
第二次的1秒内（1分0秒）又有了15个请求，这个时候是不是就在2秒内有30个请求被放行了呢？（59秒，1分0秒），如果某个服务器的访问只能是20次请求，那么这种限流方式已经导致服务器挂掉了。

2.滑动窗口计数器

<?php
/**
 * 滑动窗口计数器来限流
 * @param $uid  用户的uid
 * @param $actionKey  任务名的key
 * @param int $period 时间 毫秒
 * @param int $maxCount 最大次数
 */
function isActionAllowed($uid,$actionKey,$period,$maxCount=100){
    if(empty($uid) || empty($actionKey)){
        return false;
    }
    $redis = new Redis();
    $redis->connect("127.0.0.1",6379);
    $redis->auth('foobared'); //密码验证

    $now = msectime();//毫秒时间戳
    $maxCount = 1;
    //拼接key
    $redisKey = sprintf('miaosha:%s:%s',$uid,$actionKey);
    //事务开始客户端请求 客户端缓存
    $pipe = $redis->multi(Redis::PIPELINE);
    //value 和 score 都用毫秒时间戳
    $pipe->zAdd($redisKey,$now,$now);
    //移除时间窗口之前的行为记录，剩下的都是时间窗口
    $pipe->zRemRangeByScore($redisKey,0,$now - $period);
    $pipe->zCard($redisKey);
    //获取窗口内的行为数量
    //多加1秒的过期时间
    $pipe->expire($redisKey,$period+1);
    $res = $pipe->exec();

    return $res[2] < $maxCount;

}

3.令牌桶限流

所有的请求之前都需要那个令牌
根据限流的大小按照一定的速率往桶中放令牌
桶需要限制一个最大的令牌数，当桶满的的时候，新增的令牌就得被丢弃或者拒绝
请求先拿着令牌才能进行自己的业务逻辑然后处理完删除
令牌有最低限额，当桶中的限额达到最低令牌时，请求处理完也不会删除令牌，以达到最终限流

<?php
<?php

class Token
{
    private $_max;//最大的令牌
    private $_queue;
    private $_redis;

    public function __construct()
    {
        try {
            $this->_redis = new Redis();
            $this->_redis->connect("127.0.0.1", 6379);
            $this->_redis->auth("foobared");

            $this->_queue = "token";
            $this->_max = 10;

        } catch (RedisException $exception) {
            throw  new Exception($exception->__toString());
            return false;
        }
    }

    /**
     * 令牌初始化
     */
    public function resertKey()
    {
        $this->_redis->del($this->_queue);
        $this->_add($this->_max);
    }

    /**
     * 添加令牌
     * @param int $number
     */
    public function add($number = 1)
    {
        $maxNum = $this->_max;
        $currentNumber = $this->_redis->lLen($this->_queue);
        if ($maxNum > $currentNumber + $number) {
            $number = $number;
        } else {
            $number = $maxNum - $currentNumber;
        }
        if ($number > 0) {
            $tokens = array_fill(0, $number, 1);

            foreach ($tokens as $token) {
                $this->_redis->lPush($this->_queue, $token);
            }
        }
    }

    /**
     * 获取令牌
     * @return bool
     */
    public function get()
    {
        return $this->_redis->rPop($this->_queue) ? true : false;
    }
}

消费类：模拟用户请求

<?php
require 'token.php';
$token = new Token();
var_dump($token->get());

投递类：后端向令牌桶投递

<?php
require 'token.php';
$token = new Token();
$token->add(1);