概述

通常要表示一个字符串，核心就是以下两个数据：
（1）字符串长度；
（2）指向存放字符串内存数据的指针；
在 lua 中，字符串实际上是被内化的一种数据。内化指的是每个存放lua字符串的变量，实际上存放的并不是一份字符串数据的副本，而是这份字符串数据的引用。在这个理念下，每当新创建一个字符串时，首先都会去检查当前系统中是否已经有一份相同的字符串数据了。如果有的话直接复用，将直接指向这个已经存在的字符串，否则就重新创建出一份新的字符串数据。

使用内化的优点在于，时间上。进行字符串的查找和比较操作时，性能可以会有很大的提高。传统的字符串的比较算法是根据字符串长度逐位来进行，这个时间复杂度和字符串长度线性相关；而内化之后，在已知字符串散列值的情况下，只需要一次整数的比较即可。空间上。由于是一个内化的方式，所有相同的字符串是共享一块内存。这极大的节省了相同字符串带来的内存耗费。缺点在于每次创建字符串之前，多了一次查找的过程，好在在lua中查找一次字符串的消耗不大。

为了实现内化，在lua虚拟机中必然要有一个全局的地方存放当前系统中的所有字符串，以便在新创建字符串时，先到这里来查找是否已经存在同样的字符串，lua虚拟机使用一个散列桶来管理字符串。

字符串数据结构

/*
** Header for string value; string bytes follow the end of this structure
** (aligned according to 'UTString'; see next).
*/
typedef struct TString {
  CommonHeader;
  lu_byte extra;  /* reserved words for short strings; "has hash" for longs */  // 对于短字符串，用来记录这个字符串是否为保留字，对于长字符串，可以用于惰性求Hash值
  lu_byte shrlen;  /* length for short strings */
  unsigned int hash; // 字符串的散列值
  union {
    size_t lnglen;  /* length for long strings */
    struct TString *hnext;  /* linked list for hash table */
  } u;
} TString;


/*
** Ensures that address after this type is always fully aligned.
*/
typedef union UTString {
  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
  TString tsv;
} UTString;

重新分配存放字符串的散列桶的数量

由于字符串的内化是使用散列桶来存放数据，当字符串数据非常多时，会重新分配散列桶的数量，降低每个桶上分配到的数据量。这个通过luaS_resize 实现：

/*
** resizes the string table
*/
void luaS_resize (lua_State *L, int newsize) {
  int i;
  stringtable *tb = &G(L)->strt;
  if (newsize > tb->size) {  /* grow table if needed */
    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
    for (i = tb->size; i < newsize; i++)
      tb->hash[i] = NULL;
  }
  for (i = 0; i < tb->size; i++) {  /* rehash */
    TString *p = tb->hash[i];
    tb->hash[i] = NULL;
    while (p) {  /* for each node in the list */
      TString *hnext = p->u.hnext;  /* save next */
      unsigned int h = lmod(p->hash, newsize);  /* new position */
      p->u.hnext = tb->hash[h];  /* chain it */
      tb->hash[h] = p;
      p = hnext;
    }
  }
  if (newsize < tb->size) {  /* shrink table if needed */
    /* vanishing slice should be empty */
    lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
  }
  tb->size = newsize;
}

触发luaS_resize的地方：
（1）lgc.c的checkSizes函数，会进行检查，如果此时桶的数量太大，比如是实际存放的字符串数量的4倍，会将散列桶数量减少到原来的一半。
（2）lstring.c的internshrstr函数，此时字符串的数量大于桶数量，且桶数量小于 MAX_INT/2，则进行翻倍。

创建一个新字符串的过程：

（1）计算需要新创建的字符串对应的散列值；
（2）根据散列值找到对应的散列桶，遍历该散列桶的所有元素，如果能够查找到同样的字符串，说明之前已经存在相同的字符串，此时不需要重新分配一份新的字符串数据，直接返回即可。
（3）如果第（2）步没有找到相同的字符串，调用luaS_newlstr函数创建一个新的字符串。具体代码：

/*
** checks whether short string exists and reuses it or creates a new one
*/
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
  TString *ts;
  global_State *g = G(L);
  unsigned int h = luaS_hash(str, l, g->seed);
  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
  lua_assert(str != NULL);  /* otherwise 'memcmp'/'memcpy' are undefined */
  for (ts = *list; ts != NULL; ts = ts->u.hnext) {
    if (l == ts->shrlen &&
        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
      /* found! */
      if (isdead(g, ts))  /* dead (but not collected yet)? */
        changewhite(ts);  /* resurrect it */
      return ts;
    }
  }
  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
    luaS_resize(L, g->strt.size * 2);
    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
  }
  ts = createstrobj(L, l, LUA_TSHRSTR, h);
  memcpy(getstr(ts), str, l * sizeof(char));
  ts->shrlen = cast_byte(l);
  ts->u.hnext = *list;
  *list = ts;
  g->strt.nuse++;
  return ts;
}

/*
** new string (with explicit length)
** 长度小于LUAI_MAXSHORTLEN的字符串，调用 internshrstr。对于长度大于LUAI_MAXSHORTLEN的则一定创建一个 TString对象
*/
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
    return internshrstr(L, str, l);
  else {
    TString *ts;
    if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
      luaM_toobig(L);
    ts = luaS_createlngstrobj(L, l);
    memcpy(getstr(ts), str, l * sizeof(char));
    return ts;
  }
}

/*
** Create or reuse a zero-terminated string, first checking in the
** cache (using the string address as a key). The cache can contain
** only zero-terminated strings, so it is safe to use 'strcmp' to
** check hits.
*/
TString *luaS_new (lua_State *L, const char *str) {
  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
  int j;
  TString **p = G(L)->strcache[i];
  for (j = 0; j < STRCACHE_M; j++) {
    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
      return p[j];  /* that is it */
  }
  /* normal route */
  for (j = STRCACHE_M - 1; j > 0; j--)
    p[j] = p[j - 1];  /* move out last element */
  /* new element is first in the list */
  p[0] = luaS_newlstr(L, str, strlen(str));
  return p[0];
}

字符串连接

字符串在lua中是一个不可变的数据，改变一个字符串变量的数据不会影响原来字符串的数据。所以尽量少使用字符串连接操作符，因为每次都会生成一个新的字符串。可以使用 table来模拟字符串缓冲区，避免了大量使用连接操作符，大大提升性能，table.concat()。