可靠地将一串 1 和 0 压缩为较小的字符串，并将其转换回完全相同的字符串。每次

Question

我想知道是否有更好的方法在 NodeJS 或纯 javascript 中做到这一点。

我写了一些函数，可以通过计算它们重复的次数来做到这一点，但我想知道是否有更好的方法，或者是否有任何改进。

输入始终是仅由 1 和 0 组成的 256 位数字字符串（'00001110100101.....'）

function toSmallString(x) { // {{{
  return new Promise((resolve, reject) => {
    // always start with a 0 or a 1 to show bigstring where to start
    var nn = `${x[0]}`;
    var ar = x.split('')
    var n = 0;
    var lv = ar[0];

    // a blank item to iterate, catches the last set of numbers
    ar.push('')

    // 0 means ten and continue since we will always be above 1
    for (const v of ar) {
      // if flipping bits, store number and start over
      if (lv !== v) { nn += n ;lv = v; n = 1 }

      // increment if last value is same as this value, if value becomes 10, add a 0 to nn and start over
      else { n = n + 1;if(n === 10){nn += '0';n = 0} }
    }
    resolve(nn)
  })
}

function toBigString(x) {
  return new Promise((resolve, reject) => {
    var ar = x.split('')
    var sn = parseInt(ar.shift())
    var nn = ''

        // 0 means 10 zeros and continue without bitflipping
        // any other number will expand and then flip bits

    for (const v of ar) {
      var n = parseInt(v)
      var i = 1
      if(n === 0){
        nn += sn.toString().repeat(10)
      } else {
        while(i <= n){
          nn += sn
          i = i + 1
        }
        // bit flip
        sn = (sn === 0) ? 1 : 0;
      }
    }
    resolve(nn)
  })
}

我尝试了一些事情，我非常缺乏经验（十六进制，科学记数法），但是当尝试将其转换回原始的 256 位 1 和 0 时，值会改变形式。

每个 1 和 0 都重要，它们的放置和顺序对于保存至关重要。

我的计划是存储数十万个这样的 256 位字符串，因此某种形式的字符串压缩将是可行的方法。

Answer 1

一个简单的解决方案可能是使用BigInt（它可以安全地表示 256 位数字），然后将其转换为十六进制字符串。

function toSmallString(x) {
  return BigInt('0b' + x).toString(16); // bin => hex
}
function toBigString(x) {
  return BigInt('0x' + x).toString(2); // hex => bin
}