csharp复制代码npx react-native init AwesomeProject

复制代码sudo gem install cocoapods

复制代码npm install -g rnvm

复制代码rnvm list

复制代码rnvm install 0.66.4

perl复制代码rnvm use 0.66.4

复制代码0.66.4

bash复制代码npm install qs

javascript复制代码const qs = require('qs');

javascript复制代码// 解析简单的查询字符串
const queryObj = qs.parse('key1=value1&key2=value2');
console.log(queryObj); // 输出: { key1: 'value1', key2: 'value2' }

// 解析包含数组的查询字符串
const queryArray = qs.parse('a[]=b&a[]=c');
console.log(queryArray); // 输出: { a: ['b', 'c'] }

// 解析包含嵌套对象的查询字符串
const queryNestedObj = qs.parse('user[name]=Tom&user[age]=25');
console.log(queryNestedObj); // 输出: { user: { name: 'Tom', age: '25' } }

javascript复制代码// 构建简单对象的查询字符串
const queryString1 = qs.stringify({ page: 1, limit: 10 });
console.log(queryString1); // 输出: 'page=1&limit=10'

// 构建包含数组的查询字符串
const queryString2 = qs.stringify({ tags: ['nodejs', 'qs'] });
console.log(queryString2); // 输出: 'tags[0]=nodejs&tags[1]=qs'

// 通过设置 arrayFormat 选项，改变数组在查询字符串中的格式
const queryStringWithBrackets = qs.stringify({ tags: ['nodejs', 'qs'] }, { arrayFormat: 'brackets' });
console.log(queryStringWithBrackets); // 输出: 'tags[]=nodejs&tags[]=qs'

javascript复制代码// 解析获取忽略 URL 前缀 '?'
const queryWithPrefix = qs.parse('?a=1&b=2', { ignoreQueryPrefix: true });
console.log(queryWithPrefix); // 输出: { a: '1', b: '2' }

// 支持指定分隔符
const queryWithSemicolon = qs.parse('a=1;b=2', { delimiter: ';' });
console.log(queryWithSemicolon); // 输出: { a: '1', b: '2' }

// 支持复杂嵌套对象的深度自定义
const deepNested = qs.parse('a[b][c]=true', { depth: 0 });
console.log(deepNested); // 输出: { a: { '[b][c]': 'true' } }

// 支持ISO-8859-1字符集解析
const isoEncoded = qs.parse('a=%A7', { charset: 'iso-8859-1' });
console.log(isoEncoded); // 输出: { a: '§' }

javascript复制代码// 以不编码的形式构建查询字符串
const unencodedStr = qs.stringify({ a: { b: 'c' } }, { encode: false });
console.log(unencodedStr); // 输出: 'a[b]=c'

// 支持自定义序列化日期对象
const dateObj = new Date('2020-01-01');
const customDate = qs.stringify({ date: dateObj }, {
    serializeDate: function (d) { return d.toISOString().split('T')[0]; }
});
console.log(customDate); // 输出: 'date=2020-01-01'

java复制代码SqlSession sqlSession = sqlSessionFactory.openSession();
List<Student> studentList = sqlSession.selectList("com.sjdwz.dao.StudentMapper.findAll");

java复制代码SqlSession sqlSession = sqlSessionFactory.openSession();
StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
List<Student> studentList = studentMapper.findAll();

java复制代码 configuration.<T>getMapper(type, this);

java复制代码return mapperProxyFactory.newInstance(sqlSession);

java复制代码 mapperProxyFactory.newInstance(sqlSession);

java复制代码MapperProxy#invoke()//代理对象执行的方法，代理后所有Mapper的方法调用时，都会调用这个invoke方法
	MapperProxy#cachedInvoker()//代理对象里的Method也是对象，为了避免频繁new对象，在这里给Method对象加缓存
		methodCache#computeIfAbsent()//从缓存中取Method对象，取不到创建之后加入缓存
        //PainMethodInvoker是MapperProxy的内部类
        PlainMethodInvoker#invoke()//执行方法，所有代理对象的方法都会执行同一个。代理对象本质是方法的拦截器！
			MapperMethod#execute()//执行方法，最终还是在调用SqlSession接口
                SqlSession#insert()
                SqlSession#update()
                SqlSession#delete()
                SqlSession#selectOne()
                SqlSession#selectList()

java复制代码DefaultSqlSession#selectOne()//执行单记录
DefaultSqlSession#selectList()//查询列表
    CachingExecutor#query()
		MappedStatement#getBoundSql()//获取SQL语句
	CachingExecutor#query()//二级缓存查询
		CachingExecutor.delegate = SimplyExecutor//装饰设计模式：Caching的对SimpleExecutor查询加二级缓存装饰
	SimplyExecutor#query()
    	BaseExecutor#query()//子类执行查询直接调用父类方法，一级缓存
        BaseExecutor#queryFromDatabase()//缓存没有则去查询数据库，一级缓存
	SimplyExecutor#doQuery()//simple执行查询
		SimplyExecutor#prepareStatement()//准备查询语句
			RoutingStatementHandler#parameterize()//路由delegate=PreparedStatementHandler
				PreparedStatementHandler#parameterize()//设置查询参数
				DefaultParameterHandler#setParameters()//设置查询参数
			RoutingStatementHandler#query()//路由delegate=PreparedStatementHandler
				PreparedStatementHandler#query()//执行SQL，封装结果集
    				PreparedStatement#execute()//执行SQL查询操作
					DefaultResultSetHandler#handleResultSets()//封装返回值，将查询结果封装成Object对象

java复制代码//DefaultSqlSession
@Override
public int insert(...) {
return update(statement, parameter);
}
@Override
public int update(String statement) {
return update(statement, null);
}
@Override
public int delete(...) {
return update(....);
}

java复制代码DefaultSqlSession#update()
	CachingExecutor#update()//执行更新
		flushCacheIfRequired()//执行增删改前，清除对应二级缓存
		CachingExecutor.delegate = SimplyExecutor//装饰模式
	SimplyExecutor#update()//调用父类模板方法
		BaseExecutor#update()//执行更新
			BaseExecutor#clearLocalCache()//清除一级缓存，LocalCache
		    BaseExecutor#doUpdate()//调用子类方法
	SimplyExecutor#doUpdate()//simple执行更新
		SimplyExecutor#prepareStatement()//准备查询语句
			RoutingStatementHandler#parameterize()//delegate=PreparedStatementHandler
				PreparedStatementHandler#parameterize()//设置查询参数
				DefaultParameterHandler#setParameters()//设置查询参数
            RoutingStatementHandler#update()//delegate=PreparedStatementHandler
                PreparedStatementHandler#update()
                    PreparedStatement#execute()//执行SQL，完成增删改查操作
                    reparedStatement#getUpdateCount()//获取影响行数

shell复制代码#!/bin/sh
basepath=$(cd `dirname $0`;pwd)
echo ${basepath}

cd ${basepath}/ffmpeg-5.1.2-src
pwd

export PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:/d/repos/ffmpeg/x264_install/lib/pkgconfig
echo ${PKG_CONFIG_PATH}

./configure --prefix=${basepath}/ffmpeg_5.2.1_install \
--enable-debug  --disable-asm --disable-stripping --disable-optimizations \
--enable-gpl --enable-libx264 --disable-static --enable-shared \
--extra-cflags=-l${basepath}/x264_install/include --extra-ldflags=-L${basepath}/x264_install/lib

make -j8
make install

shell复制代码#!/bin/sh
basepath=$(cd `dirname $0`;pwd)
echo ${basepath}

cd ${basepath}/ffmpeg-5.1.2-src
pwd

export PKG_CONFIG_PATH=${PKG_CONFIG_PATH}:/d/repos/ffmpeg/x264_install/lib/pkgconfig
echo ${PKG_CONFIG_PATH}

./configure  \
--enable-debug  --disable-asm --disable-stripping --disable-optimizations \
--enable-gpl --enable-libx264 --disable-static --enable-shared \
--extra-cflags=-l${basepath}/x264_install/include --extra-ldflags=-L${basepath}/x264_install/lib

make -j8
make install

cpp复制代码#include <cstdio>
#include "common.h"
#include "iostream"
// 因为ffmpeg中的库都是C编写的，使用cpp开发，引用C库需要extern "C"配置，适配C/cpp函数名编译的不同规则
extern "C"{
    #include "libavformat/avformat.h"
    #include "libavformat/avio.h"
    #include "libavcodec/avcodec.h"
    #include "libswscale/swscale.h"
    #include "libavutil//imgutils.h"

}
using  namespace std;

AVFormatContext *av_fmt_ctx_input = nullptr;

int video_stm_index = -1;
int audio_stm_index = -1;
int ret = 0;

// 提前定义好结构体，便于解码音频和视频时的变量的统一管理
typedef struct StreamContext{
    //解码音频的解码器上下文
    AVCodecContext *audioAVCodecCtx = nullptr;
    //解码视频的解码器上下文
    AVCodecContext *videoAVCodecCtx= nullptr;
    //表示视频的数据流
    AVStream *videoStream= nullptr;
    //表示音频的数据流
    AVStream *audioStream= nullptr;
    //色彩空间转换后的AVFrame
    AVFrame *rgbFrame = nullptr;
};
// 根据定义好的结构体声明一个变量
struct StreamContext streamContext;
// 色彩空间转换模块的上下文
SwsContext *swsContext = nullptr;

/********其他函数***********/
//.....
// 后文补充
//......
/********其他函数***********/


// 入口函数
int main(int argc,char *args[]) {
    // 同目录下存放任意一个MP4文件，便于直接读取
    const char *input_file = "bunny.mp4";
    // avformat_open_input，解封装，并读取文件头信息，创建av_fmt_ctx_input结构体对象
    if ((ret = avformat_open_input(&av_fmt_ctx_input,input_file, nullptr, nullptr))<0){
        print_log("avformat_open_input", ret); // 错误处理，print_log是自定义的一个函数，用于打印一些错误信息
        return -1;
    }
    // 主要针对某些没有文件头的视频文件情况，会尝试从文件主体中去读取一些文件的信息
    ret = avformat_find_stream_info(av_fmt_ctx_input, nullptr);
    if(ret<0){
        print_log("avformat_find_stream_info", ret);
        return ret;
    }
    // 打印一下av_fmt_ctx_input目前持有的信息，（如果不想要也可以去掉）
    av_dump_format(av_fmt_ctx_input,-1,input_file,0);
    // 1，分别对视频和音频的解码进行初始化的准备
    // 就是获取对应的流，以及初始化对应的解码器
    if (initVideo() < 0 || initAudio() < 0){
        return -1;
    }
    // 初始化这个用来转换的AVFrame,
    // 需要手动设置frame->data,frame->linesize这两个空间 在前一篇文章中说到过
    ret = initRGBFrame();
    if (ret<0){
        print_log("initRGBFrame",-1);
        return ret;
    }
    // 创建AVPakcet结构体的对象，前一篇文章说过它是存放编码数据的结构体
    AVPacket  *av_packet = av_packet_alloc();
    
    // av_read_frame 读取视频文件的中的数据流 到av_packet中，
    // 此时av_packet中就存放了一块编码过的数据
    while (av_read_frame(av_fmt_ctx_input,av_packet)>=0){
        // av_packet->stream_index表示这个packet数据来自AVFormatContext中的streams数组的哪个下标
        // 通过判断来区分packet里面装的是音频数据还是视频数据，需要分开解码
        if (av_packet->stream_index == video_stm_index){ // video_stm_index就是我们找到的视频流所在的数组下标
            ret = decodeData(av_packet,streamContext.videoAVCodecCtx,1);

        }else if (av_packet->stream_index == audio_stm_index){
            // decode audio

        }

        if (ret<0){

            break;
        }

    }
    // 集中释放AVCodecContext，AVPacket,AVFormatContext等资源
    avcodec_free_context(&(streamContext.audioAVCodecCtx));
    avcodec_free_context(&(streamContext.videoAVCodecCtx));
    av_packet_free(&av_packet);
    avformat_close_input(&av_fmt_ctx_input);

    return 0;
}

ini复制代码
int initVideo(){
    //av_find_best_stream 用于从av_fmt_ctx_input中找到类型为AVMEDIA_TYPE_VIDEO的流的数组下标
    // 当然由于我们此时已经直到AVFormatContext->nb_streams 流数组的长度，所以可以手动遍历。
    // av_find_best_stream函数就是手动遍历查找的。
    video_stm_index = av_find_best_stream(av_fmt_ctx_input,AVMEDIA_TYPE_VIDEO,-1,-1, nullptr,0);
    if (video_stm_index == -1 ){ // 如果-1,表示没有找到我们想要的数组下标，返回错误
        print_log("video_index_error",video_stm_index); 
        return -1;
    }
    cout<< "video stream index:  "<<video_stm_index<<endl; //打印信息
    //拿到了视频流
    streamContext.videoStream = av_fmt_ctx_input->streams[video_stm_index];
    
    // 接着开始准备进行解码器的初始化
    // 上一篇文章我们说过，视频流中有解码该流的数据的解码器id
    // 此时我们通过解码器id，找到对应的解码器的详细信息（AVCodec），或者也可以直接把它理解为解码器
    // avcodec_find_decoder是找对应的解码器，avcodec_find_encoder是找对应的编码器，别弄错了
    auto codec = avcodec_find_decoder(streamContext.videoStream->codecpar->codec_id);
    // 然后通过这个codec，创建该解码器的上下文，
    // 但是此时上下文里还没有视频流的有效信息
    auto av_codec_ctx = avcodec_alloc_context3(codec);
    // 于是我们把视频流的有效信息赋值到解码器上下文中
    ret = avcodec_parameters_to_context(av_codec_ctx,streamContext.videoStream->codecpar);
    if (ret<0){
        print_log("video avcodec_parameters_to_context",ret);
        return ret;
    }
    // 对解码器进行初始化，准备开始解码
    ret = avcodec_open2(av_codec_ctx,codec, nullptr);
    if (ret<0){
        print_log("video avcodec_open2",ret);
        return ret;
    }
    streamContext.videoAVCodecCtx = av_codec_ctx;
    return 0;
}


int initAudio(){
    audio_stm_index = av_find_best_stream(av_fmt_ctx_input,AVMEDIA_TYPE_AUDIO,-1,-1, nullptr,0);
    if (audio_stm_index == -1){
        print_log("audio_index_error",audio_stm_index);
        return -1;
    }
    cout<< "audio stream index "<<audio_stm_index<<endl;
    streamContext.audioStream = av_fmt_ctx_input->streams[audio_stm_index];

    auto codec = avcodec_find_decoder(streamContext.audioStream->codecpar->codec_id);
    auto av_codec_ctx = avcodec_alloc_context3(codec);
    ret = avcodec_parameters_to_context(av_codec_ctx,streamContext.audioStream->codecpar);
    if (ret<0){
        print_log("audio avcodec_parameters_to_context",ret);
        return ret;
    }
    ret = avcodec_open2(av_codec_ctx,codec, nullptr);
    if (ret<0){
        print_log("audio avcodec_open2",ret);
        return ret;
    }
    streamContext.audioAVCodecCtx = av_codec_ctx;

    return 0;
}

arduino复制代码int initRGBFrame(){
    //先创建一个AVFrame结构体
    streamContext.rgbFrame = av_frame_alloc();
    
    auto width = streamContext.videoAVCodecCtx->width;
    auto height = streamContext.videoAVCodecCtx->height;
    
    // 通过像素格式，图片宽高，来计算当前所需的缓冲空间大小，最后一个字段是对齐字数
    auto bufferSize = av_image_get_buffer_size(AV_PIX_FMT_RGB24,width,height,1);
    uint8_t *  buffer = (uint8_t *)av_malloc(bufferSize);
    // AV_PIX_FMT_RGB24  packed RGB 8:8:8, 24bpp, BGRBGR...
    // 在data[8]数组中保存在data[0]中
    //根据缓冲大小，像素格式，宽高来填充 rgbFrame->data和rgbFrame->linesize
    av_image_fill_arrays(streamContext.rgbFrame->data,streamContext.rgbFrame->linesize,buffer,
                         AV_PIX_FMT_RGB24,width,height,1);
    // 创建视频帧转换的上下文，libswscale可以提供颜色转换，图片尺寸放缩等能力
    swsContext = sws_getContext(width,height,streamContext.videoAVCodecCtx->pix_fmt,width,height,
                                AV_PIX_FMT_RGB24,0, nullptr, nullptr, nullptr);
    if (swsContext == nullptr){
        return -1;
    }
    return 0;
}

scss复制代码int decodeData(AVPacket  *av_packet,AVCodecContext *av_codec_ctx,int is_video) {
    // 发送数据到解码器
    ret = avcodec_send_packet(av_codec_ctx,av_packet);
    if (ret<0){
        print_log("video avcodec_send_packet",ret);
        return ret;
    }
    // 创建一个AVFrame用来承接解码后的数据（此时不用在手动填充data等字段了）
    AVFrame  *av_frame = av_frame_alloc();
    while (true){
        // 从解码器中读取解码后的数据到AVFrame中
        ret = avcodec_receive_frame(av_codec_ctx,av_frame);
        if (ret == AVERROR_EOF){ // 到文件结束
            ret = 0;
            break;
        } else if (ret == AVERROR(EAGAIN)){ // avpacket的数据不够形成一帧数据，需要继续往解码器发送avpacket
            ret = 0;
            break;
        }else if(ret<0){ // 其他错误
            print_log("video decode error",ret);

            break;
        }else{
            // ret>=0 表示正常,此时会得到的av_frame基本上都是YUV420P的色彩格式，
            if(is_video>0){ //  处理视频数据
                // sws_scale函数可以对AVFrame进行转换（颜色空间转换，图片宽高放缩等）
                // (YUV420P) to (packed RGB 8:8:8)
                ret = sws_scale(swsContext, ( uint8_t const* const*)av_frame->data, av_frame->linesize, 0, av_frame->height,
                                streamContext.rgbFrame->data, streamContext.rgbFrame->linesize);
                if (ret<0){
                    print_log("sws_scale_frame",ret);
                    break;
                }
                // 此时rgbFrame内就保存了RGB格式的数据，接下来我们只要把数据写入到文件即可
                saveRGBImage(0);
                ret = -1;
                break; // 只解码一帧就退出
            }else{

            }


        }
    }
    av_frame_free(&av_frame);

    return ret;
}

arduino复制代码void saveRGBImage(int index){
    char fileName[32];

    sprintf(fileName,"frame_%d.ppm",index); // 定义一下文件名frame_0.ppm
    FILE  *file = fopen(fileName,"wb"); // 打开文件
    if (file == nullptr){
        return;
    }
    int width = streamContext.videoAVCodecCtx->width;
    int height = streamContext.videoAVCodecCtx->height;
    int line_size = streamContext.rgbFrame->linesize[0];
    // 写入ppm文件的文件头，P6
    fprintf(file, "P6\n%d %d\n255\n", width, height);
    for (int i = 0; i < height; ++i) { 
        //相当于一行一行的写入数据，（也可以计算数据总数，一次性写入）
        // line_size是一行的长度，从第0行开始，每次写入一行长度的数据
        fwrite(streamContext.rgbFrame->data[0]+i*line_size,1,line_size,file);
    }
   fclose(file);
}

c复制代码char* print_log(const char *tag,int ret){
    const int max_buf = 1024;
    char buf_log[2048] = "";
    // av_strerror函数能够根据当前错误码给我们返回一些错误信息
    // 虽然非常粗糙，但是聊胜于无。
    av_strerror(ret,buf_log,max_buf);
    cout<< tag << " error:   %d  %s" << ret << buf_log << endl;
    return "";
}

ini复制代码from openai import OpenAI
from dotenv import load_dotenv, find_dotenv

_ = load_dotenv(find_dotenv())
client = OpenAI()

response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Who won the world series in 2020?"},
    {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
    {"role": "user", "content": "Where was it played?"}
  ]
)
print(response)  # 打印的是一个对象
print(response.choices[0].message.content)  # 打印的是一个具体的回复的内容

json复制代码{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The World Series in 2020 was played at Globe Life Field in Arlington, Texas."
      }
    }
  ],
  "created": 1714051759,
  "id": "chatcmpl-6p9XYPYSTTRi0xEviKjjilqrWU2Ve",
  "model": "gpt-3.5-turbo-0125",
  "object": "chat.completion",
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 54,
    "total_tokens": 72
  }
}

ini复制代码from openai import OpenAI
from dotenv import load_dotenv, find_dotenv

_ = load_dotenv(find_dotenv())
client = OpenAI()

response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "你是一个ChatGPT助手，你帮助用户回答问题"},
    {"role": "user", "content": "说10遍王子请睡觉"},
    {"role": "assistant", "content": "王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。王子请睡觉。"},
    {"role": "user", "content": "你上面回答了几次王子请睡觉"}
  ]
)
print(response.choices[0].message.content)  # 我回答了10次“王子请睡觉”。

css复制代码openai.BadRequestError: Error code: 400 - {'error': {'message': "This model's maximum context length is 16385 tokens. However, your messages resulted in 17184 tokens. Please reduce the length of the messages.", 'type': 'invalid_request_error', 'param': 'messages', 'code': 'context_length_exceeded'}}

ini复制代码from openai import OpenAI
from dotenv import load_dotenv, find_dotenv
import requests,json


_ = load_dotenv(find_dotenv())
client = OpenAI()

def get_coin_prince(coin):
    # Execute query here
    url = 'https://data-api.binance.vision/api/v3/ticker/24hr?symbol='+coin.upper()+"USDT"  # binance直接请求获得结果数据
    response = requests.get(url)
    response = response.json()
    try:
      return response['lastPrice']+'USDT'
    except:
      return "The coin is not exist"

# 函数描述
tools = [
    {
        "type": "function",
        "function":{
          "name": "get_coin_prince",
          "description": "Get a coin Price from Binance, The price unit is in US dollars",
          "parameters": {
              "type": "object",
              "properties": {
                  "coin": {
                      "coin": "string",
                      "description": "Abbreviations for Virtual Currency",
                  }
              },
              "required": ["coin"],
          },
        }
    }
]

messages=[
         {"role": "user", "content": "BTC的价格是多少?"},
  ],
messages = []
messages.append({"role": "system", "content": "你是一个虚拟币查询机器人"})
messages.append({"role": "user", "content": "btc的价格是多少?"})
response = client.chat.completions.create(
  model="gpt-3.5-turbo-0613",
  messages=messages,
  tools=tools,
  tool_choice="auto", 
)

print(response)  # 打印的是一个对象

response_message = response.choices[0].message  # 消息对象

tool_calls = response_message.tool_calls  # 识别是否触发函数调用
if tool_calls: # 判断是否为函数调用
    available_functions = {
            "get_coin_prince": get_coin_prince,
        }  # 本例中只有一个函数，但可以有多个
    messages.append(response_message)
    for tool_call in tool_calls: # 遍历函数调用
      function_name = tool_call.function.name
      function_to_call = available_functions[function_name] # 找到本地目标函数
      function_args = json.loads(tool_call.function.arguments) # 获取函数参数的具体值
      function_response = function_to_call(
          coin=function_args.get("coin"),
      ) # 真实调用本地函数
      messages.append(
          {
              "tool_call_id": tool_call.id,
              "role": "tool",
              "name": function_name,
              "content": function_response, #本地调用函数内容返回值放进对话 ，接下来给ChatGPT组装内容
          }
      )  # 新一轮的对话的函数调用细节（函数ID，规则，名称，参数）

# 开始第二次对话
second_response = client.chat.completions.create(
    model="gpt-3.5-turbo-0125",
    messages=messages,
)  # 从模型中获取一个新的响应
print(messages) # 调试组装过的对话内容
print(second_response)
res =  second_response.choices[0].message.content

print(res)  # BTC的价格为64477.51 USDT。

js复制代码const {
    SyncHook,
    SyncBailHook,
    SyncWaterfallHook,
    SyncLoopHook,
    AsyncParallelHook,
    AsyncParallelBailHook,
    AsyncSeriesHook,
    AsyncSeriesBailHook,
    AsyncSeriesLoopHook,
    AsyncSeriesWaterfallHook
 } = require("tapable");

markdown复制代码tapable
├─ .babelrc
├─ .editorconfig
├─ .eslintrc
├─ .gitattributes
├─ .gitignore
├─ .prettierrc.js
├─ .travis.yml
├─ README.md
├─ lib 
│  ├─ AsyncParallelBailHook.js
│  ├─ AsyncParallelHook.js
│  ├─ AsyncSeriesBailHook.js
│  ├─ AsyncSeriesHook.js
│  ├─ AsyncSeriesLoopHook.js
│  ├─ AsyncSeriesWaterfallHook.js
│  ├─ Hook.js
│  ├─ HookCodeFactory.js
│  ├─ HookMap.js
│  ├─ index.js
│  ├─ MultiHook.js
│  ├─ SyncBailHook.js
│  ├─ SyncHook.js
│  ├─ SyncLoopHook.js
│  ├─ SyncWaterfallHook.js
│  ├─ util-browser.js
│  └─ __tests__
│     ├─ AsyncParallelHooks.js
│     ├─ AsyncSeriesHooks.js
│     ├─ Hook.js
│     ├─ HookCodeFactory.js
│     ├─ HookStackOverflow.js
│     ├─ HookTester.js
│     ├─ MultiHook.js
│     ├─ SyncBailHook.js
│     ├─ SyncHook.js
│     ├─ SyncHooks.js
│     ├─ SyncWaterfallHook.js
│     └─ __snapshots__
│        ├─ AsyncParallelHooks.js.snap
│        ├─ AsyncSeriesHooks.js.snap
│        ├─ HookCodeFactory.js.snap
│        └─ SyncHooks.js.snap
├─ LICENSE
├─ package.json
├─ tapable.d.ts
└─ yarn.lock

js复制代码初始化配置部分
constructor(args = [], name = undefined) {
    this._args = args; // 参数配置数组
    this.name = name; // Hook的名称
    this.taps = []; // 用于存储注册到 Hook 实例上的 tap 对象。
    this.interceptors = []; // 用于存储注册到 Hook 实例上的拦截器对象
    // 将全局常量 CALL_DELEGATE 赋值给实例属性 _call、call。表示某个调用的委托函数或逻辑。
    this._call = CALL_DELEGATE;
    this.call = CALL_DELEGATE;
    // 将全局常量 CALL_ASYNC_DELEGATE 赋值给实例属性_callAsync、callAsync。表示某个【异步】调用的委托函数或逻辑。
    this._callAsync = CALL_ASYNC_DELEGATE;
    this.callAsync = CALL_ASYNC_DELEGATE;
    // 将全局常量 PROMISE_DELEGATE 赋值给实例属性_promise、promise。表示某个【Promise】调用的委托函数或逻辑。
    this._promise = PROMISE_DELEGATE;
    this.promise = PROMISE_DELEGATE;
    // 暂时没看到具体用途，可能在后续的方法中确定。
    this._x = undefined;
    // compile抽象方法的实现，强制派生类/子类必须被重写以提供具体的实现。
    this.compile = this.compile;
    
    this.tap = this.tap;
    this.tapAsync = this.tapAsync;
    this.tapPromise = this.tapPromise;
}

js复制代码_tap(type, options, fn) {
    if (typeof options === "string") {
        options = {
            name: options.trim()
        };
    } else if (typeof options !== "object" || options === null) {
        throw new Error("Invalid tap options");
    }
    if (typeof options.name !== "string" || options.name === "") {
        throw new Error("Missing name for tap");
    }
    if (typeof options.context !== "undefined") {
        deprecateContext();
    }
    options = Object.assign({ type, fn }, options);
    options = this._runRegisterInterceptors(options);
    this._insert(options);
}
​
tap(options, fn) {
    this._tap("sync", options, fn);
}
​
tapAsync(options, fn) {
    this._tap("async", options, fn);
}
​
tapPromise(options, fn) {
    this._tap("promise", options, fn);
}

js复制代码_runRegisterInterceptors(options) {
    for (const interceptor of this.interceptors) {
        if (interceptor.register) {
            const newOptions = interceptor.register(options);
            if (newOptions !== undefined) {
                options = newOptions;
            }
        }
    }
    return options;
}

js复制代码withOptions(options) {
    // 用于将给定的选项与原始选项进行合并
    const mergeOptions = opt =>
    Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
​
    return {
        name: this.name,
        tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
        tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
        tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
        intercept: interceptor => this.intercept(interceptor),
        isUsed: () => this.isUsed(),
        withOptions: opt => this.withOptions(mergeOptions(opt))
    };
}

js复制代码isUsed() {
    return this.taps.length > 0 || this.interceptors.length > 0;
}

js复制代码intercept(interceptor) {
    // 重置钩子对象的编译状态
    this._resetCompilation();
    // 对interceptor进行复制，并推到interceptors数组里
    this.interceptors.push(Object.assign({}, interceptor));
    if (interceptor.register) {
        for (let i = 0; i < this.taps.length; i++) {
            this.taps[i] = interceptor.register(this.taps[i]);
        }
    }
}

js复制代码_resetCompilation() {
    this.call = this._call;
    this.callAsync = this._callAsync;
    this.promise = this._promise;
}

js复制代码_insert(item) {
    this._resetCompilation();
    let before;
    if (typeof item.before === "string") {
        before = new Set([item.before]);
    } else if (Array.isArray(item.before)) {
        before = new Set(item.before);
    }
    let stage = 0;
    if (typeof item.stage === "number") {
        stage = item.stage;
    }
    let i = this.taps.length;
    while (i > 0) {
        i--;
        const x = this.taps[i];
        this.taps[i + 1] = x;
        const xStage = x.stage || 0;
        if (before) {
            if (before.has(x.name)) {
                before.delete(x.name);
                continue;
            }
            if (before.size > 0) {
                continue;
            }
        }
        if (xStage > stage) {
            continue;
        }
        i++;
        break;
    }
    this.taps[i] = item;
}

cmake复制代码# 路径必须用左斜杠分隔
include_directories(D:/libxl-4.3.0.14/include_cpp)
target_link_libraries(libxl_read_xlsx_demo D:/libxl-4.3.0.14/lib64/libxl.lib)
target_link_libraries(libxl_write_xlsx_demo D:/libxl-4.3.0.14/lib64/libxl.lib)

cpp复制代码#include <bits/stdc++.h>
#include <direct.h>
// 省略其他头文件
using namespace std::filesystem;

string get_inp_xlsx_path() {
  char* cwd_buffer = getcwd(NULL, 0);
  path p = canonical(path(cwd_buffer) / ".." / "inp" / "example.xlsx");
  return p.string();
}

cmake复制代码add_executable(libxl_write_xlsx_demo libxl_write_xlsx_demo.cpp utils.cpp utils.h)

cmake复制代码add_executable(opxl_read_xlsx_demo opxl_read_xlsx_demo.cpp)
add_executable(opxl_write_xlsx_demo opxl_write_xlsx_demo.cpp utils.cpp utils.h)

add_subdirectory(OpenXLSX)

target_link_libraries(opxl_read_xlsx_demo OpenXLSX::OpenXLSX)
target_link_libraries(opxl_write_xlsx_demo OpenXLSX::OpenXLSX)

cpp复制代码#include <OpenXLSX.hpp>
using namespace OpenXLSX;

cpp复制代码void read_example_xlsx() {
  string xlsx_path = get_inp_xlsx_path();
  XLDocument doc;
  doc.open(xlsx_path);
  auto wks = doc.workbook().worksheet("Sheet1");
  read_data(wks);
}