redis中sdssplitargs（字符串分割函数）你知多少

路过的阿烨

已于 2023-07-18 22:14:27 修改

阅读量159

点赞数 1

文章标签： redis 数据库后端算法

于 2023-07-18 22:06:01 首次发布

本文链接：https://blog.csdn.net/qq_62176884/article/details/131796201

版权

最新本人学习了一下redis中的字符串分割函数，并且自己写了一个go语言的demo发现网上较为详细的讲解比较少，而且该函数与普通的分割函数还是有不同之处的。故写该博客记录一下。

注意sds是redis特有的数据结构相当于string 不过更加精巧

首先源码奉上

sds *sdssplitargs(const char *line, int *argc) {
    const char *p = line;
    char *current = NULL;
    char **vector = NULL;

    *argc = 0;
    while(1) {
        /* skip blanks */
        while(*p && isspace(*p)) p++;
        if (*p) {
            /* get a token */
            int inq=0;  /* set to 1 if we are in "quotes" */
            int insq=0; /* set to 1 if we are in 'single quotes' */
            int done=0;

            if (current == NULL) current = sdsempty();
            while(!done) {
                if (inq) {
                    if (*p == '\\' && *(p+1) == 'x' &&
                                             is_hex_digit(*(p+2)) &&
                                             is_hex_digit(*(p+3)))
                    {
                        unsigned char byte;

                        byte = (hex_digit_to_int(*(p+2))*16)+
                                hex_digit_to_int(*(p+3));
                        current = sdscatlen(current,(char*)&byte,1);
                        p += 3;
                    } else if (*p == '\\' && *(p+1)) {
                        char c;

                        p++;
                        switch(*p) {
                        case 'n': c = '\n'; break;
                        case 'r': c = '\r'; break;
                        case 't': c = '\t'; break;
                        case 'b': c = '\b'; break;
                        case 'a': c = '\a'; break;
                        default: c = *p; break;
                        }
                        current = sdscatlen(current,&c,1);
                    } else if (*p == '"') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
                        goto err;
                    } else {
                        current = sdscatlen(current,p,1);
                    }
                } else if (insq) {
                    if (*p == '\\' && *(p+1) == '\'') {
                        p++;
                        current = sdscatlen(current,"'",1);
                    } else if (*p == '\'') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
                        goto err;
                    } else {
                        current = sdscatlen(current,p,1);
                    }
                } else {
                    switch(*p) {
                    case ' ':
                    case '\n':
                    case '\r':
                    case '\t':
                    case '\0':
                        done=1;
                        break;
                    case '"':
                        inq=1;
                        break;
                    case '\'':
                        insq=1;
                        break;
                    default:
                        current = sdscatlen(current,p,1);
                        break;
                    }
                }
                if (*p) p++;
            }
            /* add the token to the vector */
            vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
            vector[*argc] = current;
            (*argc)++;
            current = NULL;
        } else {
            /* Even on empty input string return something not NULL. */
            if (vector == NULL) vector = s_malloc(sizeof(void*));
            return vector;
        }
    }

err:
    while((*argc)--)
        sdsfree(vector[*argc]);
    s_free(vector);
    if (current) sdsfree(current);
    *argc = 0;
    return NULL;
}

一.初始化

const char *p = line;
char *current = NULL;
char **vector = NULL;

*argc = 0;
while(1) {
    /* skip blanks */
    while(*p && isspace(*p)) p++;
    if (*p) {
        /* get a token */
        int inq=0;  /* set to 1 if we are in "quotes" */
        int insq=0; /* set to 1 if we are in 'single quotes' */
        int done=0;

        if (current == NULL) current = sdsempty();

在这里定义了指针*P（位置）

current存储当前token的字符串

vector保存返回的所有字符串

argc对字符串计数（因为是指针，等下函数调用返回后，可以直接用）

 while(*p && isspace(*p)) p++;

这里用循环跳过前面没用的的space

            int inq=0;  /* set to 1 if we are in "quotes" */
            int insq=0; /* set to 1 if we are in 'single quotes' */
            int done=0;

三个标志变量分别标记是否在双引号内是否在在单引号内以及是否完成一个token的解析

二.while（！done）内

循环没结束就标志 token没读完

二.1inq（双引号内）

  while(!done) {
                if (inq) {
                    if (*p == '\\' && *(p+1) == 'x' &&
                                             is_hex_digit(*(p+2)) &&
                                             is_hex_digit(*(p+3)))
                    {
                        unsigned char byte;

                        byte = (hex_digit_to_int(*(p+2))*16)+
                                hex_digit_to_int(*(p+3));
                        current = sdscatlen(current,(char*)&byte,1);
                        p += 3;
                    } else if (*p == '\\' && *(p+1)) {
                        char c;

                        p++;
                        switch(*p) {
                        case 'n': c = '\n'; break;
                        case 'r': c = '\r'; break;
                        case 't': c = '\t'; break;
                        case 'b': c = '\b'; break;
                        case 'a': c = '\a'; break;
                        default: c = *p; break;
                        }
                        current = sdscatlen(current,&c,1);
                    } else if (*p == '"') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
                        goto err;
                    } else {
                        current = sdscatlen(current,p,1);
                    }
                }

inq为真就说明当前处于双引号内并检查

if (*p == '\\' && *(p+1) == 'x' && is_hex_digit(*(p+2)) &&is_hex_digit(*(p+3)))

检查当前字符是否是反斜杠接下来是不是x 而且后面两个字符可以是合法的十六进制数字。

满足条件就会把16进制转换成int 追加到current字符串

然后p+=3 处理了三个字符

                        unsigned char byte;

                        byte = (hex_digit_to_int(*(p+2))*16)+
                                hex_digit_to_int(*(p+3));
                        current = sdscatlen(current,(char*)&byte,1);
                        p += 3;

这里sdscatlen相当于current+=string(byte) 追加到字符串末尾

这里的16进制转换函数也很简单而且第一个数字要×16说明它是第二位应该不用多说

int hex_digit_to_int(char c) {
switch(c) {
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'a': case 'A': return 10;
case 'b': case 'B': return 11;
case 'c': case 'C': return 12;
case 'd': case 'D': return 13;
case 'e': case 'E': return 14;
case 'f': case 'F': return 15;
default: return 0;
}

如果当前字符为反斜杠并且后面还有字符，则继续执行

                        else if (*p == '\\' && *(p+1)) {
                        char c;

                        p++;
                        switch(*p) {
                        case 'n': c = '\n'; break;
                        case 'r': c = '\r'; break;
                        case 't': c = '\t'; break;
                        case 'b': c = '\b'; break;
                        case 'a': c = '\a'; break;
                        default: c = *p; break;
                        }
                        current = sdscatlen(current,&c,1);

p++指针跳过反斜杠根据情况调整c的值最后将它追加到current的末尾

处理了字符串里的转义字符，将转义字符转换为实际的字符表示。

else if (*p == '"') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
                        goto err;
                    } else {
                        current = sdscatlen(current,p,1);
                    }

最后一些是终止条件就不多说了双引号结束 err是返回NULL

二.2单引号内

else if (insq) {
                    if (*p == '\\' && *(p+1) == '\'') {
                        p++;
                        current = sdscatlen(current,"'",1);
                    } else if (*p == '\'') {
                        /* closing quote must be followed by a space or
                         * nothing at all. */
                        if (*(p+1) && !isspace(*(p+1))) goto err;
                        done=1;
                    } else if (!*p) {
                        /* unterminated quotes */
                        goto err;
                    } else {
                        current = sdscatlen(current,p,1);
                    }
                }

insq真表示正在单引号内

检查当前字符是否为反斜杠并且下一个是单引号

满足条件则说明有转义字符\'将它解析为'最后加到current

不然就判断是否为单引号结束结束后看下一个字符是否为空格不是空格就返回err

done=1表示完成

如果所有条件都不满足单仍然在单引号中就把它加到current中

二.3不是双引号和单引号

 else {
                    switch(*p) {
                    case ' ':
                    case '\n':
                    case '\r':
                    case '\t':
                    case '\0':
                        done=1;
                        break;
                    case '"':
                        inq=1;
                        break;
                    case '\'':
                        insq=1;
                        break;
                    default:
                        current = sdscatlen(current,p,1);
                        break;
                    }
                }

如果是空格、换行符、回车符、制表符或\0将结束标志设置为0（\0在c++中是字符串末尾标识符，go里面你不能用S[LAST]==0来判断会触发panic，越界

如果是双引号就表示inq设置会1 标志进入双引号

如果是单引号 insq设置为1 表示进入单引号

其他字符就追加到current的末尾

三.末尾和err

      if (*p) p++;
            }
            /* add the token to the vector */
            vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
            vector[*argc] = current;
            (*argc)++;
            current = NULL;
        } else {
            /* Even on empty input string return something not NULL. */
            if (vector == NULL) vector = s_malloc(sizeof(void*));
            return vector;
        }
    }

err:
    while((*argc)--)
        sdsfree(vector[*argc]);
    s_free(vector);
    if (current) sdsfree(current);
    *argc = 0;
    return NULL;
}

在while（！done）结束后重新分配vector的内存空间以存当前解析的字符串

argc++ 表示解析的字符串数量++

current为NULL表示准备下一个字符串

最后返回vector数组

err就是清理内存返回NULL

所以相对于普通的分割函数

redis的分割函数支持处理16进制数字转义字符双单引号

路过的阿烨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
redis中sdssplitargs（字符串分割函数）你知多少

最新本人学习了一下redis中的字符串分割函数，并且自己写了一个go语言的demo发现网上较为详细的讲解比较少，而且该函数与普通的分割函数还是有不同之处的。故写该博客记录一下。注意sds是redis特有的数据结构相当于string 不过更加精巧首先源码奉上。
复制链接

扫一扫