SDS （Simple Dynamic Strings） 是redis 用于存储字符串的数据结构，有以下几个特性：
- 二进制安全
- 兼容C语言标准字符串处理函数
- 节省空间
二进制安全
C语言中用'\0'表示字符串结尾，如果字符串内容含有'\0'，就会提前截断（非二进制安全），redis 使用一个变量存放字符串长度，另一个字符柔性数组存放字符串实际内容，读取时根据len变量确定长度，不会出现截断：
兼容C语言标准
SDS 对外暴露buf的指针，而不是结构体的起始地址，上层可以类似处理C语言字符串一样处理SDS字符串。
结构体使用了柔性数组，这种数组是可伸缩的，之所以使用柔性数组是因为数组地址和结构体地址是连续的，如图：
这样就可以通过数组的地址定位到结构体地址，从而获取到其他变量的值（参考用于获取字符串长度的sdslen 函数）
节省空间
不是所有长度的字符串都用相同的结构存放，redis中SDS 根据长度分为5种类型：
- sdshdr5：长度 < 2^5 - 1
- sdshdr8：长度 < 2^8 - 1
- sdshdr16：长度 < 2^16 - 1
- sdshdr32：长度 < 2^32 - 1
- sdshdr64 ： 长度 < 2^64 - 1
实际结构如下：
struct __attribute__ ((__packed__)) sdshdr5 {
unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {
uint8_t len; /* used */
uint8_t alloc; /* excluding the header and null terminator */
unsigned char flags; /* 3 lsb of type, 5 unused bits */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
uint16_t len; /* used */
uint16_t alloc; /* excluding the header and null terminator */
unsigned char flags; /* 3 lsb of type, 5 unused bits */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {
uint32_t len; /* used */
uint32_t alloc; /* excluding the header and null terminator */
unsigned char flags; /* 3 lsb of type, 5 unused bits */
char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
uint64_t len; /* used */
uint64_t alloc; /* excluding the header and null terminator */
unsigned char flags; /* 3 lsb of type, 5 unused bits */
char buf[];
};len表示buf中已占字节数，alloc表示buf中分配字节数，flags 表示字符串类型，buf存放实际字符串内容，当字符串长度小于32字节时，甚至用一个int变量flags同时表示了字符串类型和长度，存储空间节省到了极致。
flags中只有低3位存放类型，高5位对于sdshdr5 用作存放长度，其余类型作为预留字段。
当获取一个sds变量长度时，需要先找到flags变量，然后判断sds是5中类型中哪一种，再进一步获取len变量的值：
#define SDS_TYPE_5 0
#define SDS_TYPE_8 1
#define SDS_TYPE_16 2
#define SDS_TYPE_32 3
#define SDS_TYPE_64 4
#define SDS_TYPE_MASK 7
#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
static inline size_t sdslen(const sds s) {
unsigned char flags = s[-1];
switch(flags&SDS_TYPE_MASK) {
case SDS_TYPE_5:
return SDS_TYPE_5_LEN(flags);
case SDS_TYPE_8:
return SDS_HDR(8,s)->len;
case SDS_TYPE_16:
return SDS_HDR(16,s)->len;
case SDS_TYPE_32:
return SDS_HDR(32,s)->len;
case SDS_TYPE_64:
return SDS_HDR(64,s)->len;
}
return 0;
}sdslen的入参s指向柔性数组buf的地址，因为buf和结构体地址连续，所以可以通过s[-1] 获得flags变量，判断类型时，只取flags的低3位，进而获取到sds头部结构的大小，然后用buf - 头部大小获取到sds的起始地址，再读取len变量。
每个字符串结构都用 __attribute__ ((__packed__)) 修改对齐方式，加上修饰后，结构体会按1字节对齐，这样才能通过buf变量的地址 -1 获取到flags地址，效果如图：
字符串基本操作
sds字符串基本操作有创建、释放、拼接等
字符串创建
代码位于sds.c 文件 _sdsnewlen 函数
sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
void *sh;
sds s;
char type = sdsReqType(initlen); // 根据长度判断用哪种类型
if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8; // 如果是空串，为了应对可能的扩容，直接用sdshdr8类型
int hdrlen = sdsHdrSize(type); // 头部长度
unsigned char *fp; /* flags pointer. */
size_t usable;
assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
sh = trymalloc?
s_trymalloc_usable(hdrlen+initlen+1, &usable) :
s_malloc_usable(hdrlen+initlen+1, &usable);
if (sh == NULL) return NULL;
if (init==SDS_NOINIT)
init = NULL;
else if (!init)
memset(sh, 0, hdrlen+initlen+1);
s = (char*)sh+hdrlen; // buf 数组地址
fp = ((unsigned char*)s)-1; // flags变量地址
usable = usable-hdrlen-1;
if (usable > sdsTypeMaxSize(type))
usable = sdsTypeMaxSize(type);
switch(type) { // 根据不同类型初始化结构体
case SDS_TYPE_5: {
*fp = type | (initlen << SDS_TYPE_BITS);
break;
}
case SDS_TYPE_8: {
SDS_HDR_VAR(8,s);
sh->len = initlen;
sh->alloc = usable;
*fp = type;
break;
}
}
case SDS_TYPE_16: {
SDS_HDR_VAR(16,s);
sh->len = initlen;
sh->alloc = usable;
*fp = type;
break;
}
case SDS_TYPE_32: {
SDS_HDR_VAR(32,s);
sh->len = initlen;
sh->alloc = usable;
*fp = type;
break;
}
case SDS_TYPE_64: {
SDS_HDR_VAR(64,s);
sh->len = initlen;
sh->alloc = usable;
*fp = type;
break;
}
}
if (initlen && init)
memcpy(s, init, initlen); // 将字符串写入buf
s[initlen] = '\0'; // 末尾添加\0
return s; // 对外返回buf地址
}主要操作是根据长度判断用那种类型sds结构，然后初始化结构体，最后对外返回buf数组的地址。
字符串释放
void sdsfree(sds s) {
if (s == NULL) return;
s_free((char*)s-sdsHdrSize(s[-1]));
}sds 还提供字符串置空函数，仅将字符串内容清空，避免重复内存释放/申请的操作
void sdsclear(sds s) {
sdssetlen(s, 0);
s[0] = '\0';
}字符串拼接
sds sdscatlen(sds s, const void *t, size_t len) {
size_t curlen = sdslen(s);
s = sdsMakeRoomFor(s,len);
if (s == NULL) return NULL;
memcpy(s+curlen, t, len);
sdssetlen(s, curlen+len);
s[curlen+len] = '\0';
return s;
}主要通过sdsMakeRoomFor 函数为buf数据分配好足以放下len个字节的空间，如果已有空间不够则需要重新申请内存并迁移原sds内容到新的空间，然后再做拼接。
sds sdsMakeRoomFor(sds s, size_t addlen) {
void *sh, *newsh;
size_t avail = sdsavail(s); // 当前字符串可用空间，一般是alloc - len
size_t len, newlen, reqlen;
char type, oldtype = s[-1] & SDS_TYPE_MASK;
int hdrlen;
size_t usable;
/* Return ASAP if there is enough space left. */
if (avail >= addlen) return s;
len = sdslen(s);
sh = (char*)s-sdsHdrSize(oldtype); // 原sds结构体起始地址
reqlen = newlen = (len+addlen);
assert(newlen > len); /* Catch size_t overflow */
if (newlen < SDS_MAX_PREALLOC) // 小于1M时翻倍扩容，大于1M时每次新增1M
newlen *= 2;
else
newlen += SDS_MAX_PREALLOC;
newlen += SDS_MAX_PREALLOC;
type = sdsReqType(newlen);
/* Don't use type 5: the user is appending to the string and type 5 is
* not able to remember empty space, so sdsMakeRoomFor() must be called
* at every appending operation. */
if (type == SDS_TYPE_5) type = SDS_TYPE_8; // 为避免频繁扩容，直接用type8
hdrlen = sdsHdrSize(type);
assert(hdrlen + newlen + 1 > reqlen); /* Catch size_t overflow */
if (oldtype==type) { // 新的字符串类型没变，直接在原地址空间上分配空间
newsh = s_realloc_usable(sh, hdrlen+newlen+1, &usable);
if (newsh == NULL) return NULL;
s = (char*)newsh+hdrlen;
} else { // 新的字符串需要用不同类型，则重新分配空间并拷贝
/* Since the header size changes, need to move the string forward,
* and can't use realloc */
newsh = s_malloc_usable(hdrlen+newlen+1, &usable);
if (newsh == NULL) return NULL;
memcpy((char*)newsh+hdrlen, s, len+1);
s_free(sh);
s = (char*)newsh+hdrlen;
s[-1] = type;
sdssetlen(s, len);
}
usable = usable-hdrlen-1;
if (usable > sdsTypeMaxSize(type))
usable = sdsTypeMaxSize(type);
sdssetalloc(s, usable);
return s;
}这里扩容规则是，如果字符串长度还小于1M，则翻倍扩容，否则每次扩容1M。
参考：
《redis5设计与源码分析》