Надежно сжимайте строку из единиц и нулей в строку меньшего размера и преобразуйте ее обратно в точно такую ​​же строку. Каждый раз

Простым решением может быть использование BigInt (который может безопасно представлять 256-битное число), а затем преобразовать его в шестнадцатеричную строку.

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

Обновлять

я расширил решение @Nikk и решил использовать шестнадцатеричный формат

Цель состоит в том, чтобы получить максимально короткую строку из строки, которая будет содержать только диапазон цифр (первоначально 0-1, но в этом примере мы сделаем 1-8).

Я определил карту символов, содержащую все возможные двухзначные комбинации от 11 до 88 (11..18,21..28,31.......88), которая сопоставляет ее с одним символом, в ней 64 возможных комбинации. этот диапазон (8^2=64)

поэтому со всеми возможными комбинациями наш окончательный набор символов стал [a-zA-Z!-_] без каких-либо цифр.

наша длина меняется с 256 на 128

мне было бы интересно попробовать сопоставить большие наборы цифр с юникодом символы, чтобы получить более короткие результаты, но нам нужно гораздо больше карта персонажей.

поскольку в нашем наборе символов нет чисел, мы можем переключать повторяющиеся символы с помощью одного символа и цифры, чтобы указать, сколько раз этот символ повторяется.

поскольку наша цифра всегда будет равна 1 и выше, мы можем сказать, что 0 означает 10, а затем помещать еще одну цифру, пока они в сумме не дадут точное повторение.

это означает, что наши цифры 0.... и 1.... станут a4 и b4 40 повторений 1 превращаются в a0000 ('0' * 10 в 4-й степени) 100 повторений 1 превращаются в a0000000000 ('0' * 10 в 10-й степени) 256 0s будут a00000000000000000000000006, что представляет собой строку длиной 27 бит.

поэтому при таком подходе наша результирующая строка из 256 бит будет варьироваться от 27 до 128 бит.

мы могли бы стать короче, заменив повторяющиеся 0 на набор значений Юникода, поскольку это более крупный набор символов, в результате чего самая короткая строка будет выглядеть примерно так: «a0|6»

«a0|6» означает 256 нулей подряд, однако мы могли бы просто сохранить одну цифру и повторить ее 256 раз при возврате в случае, если все цифры совпадают.

Таким образом, самая короткая строка варьируется от 1,4 до 128 бит от 256 цифр, причем более короткие строки возможны только в том случае, если в строке более 4 повторяющихся цифр. (что я делаю очень часто)

вот код для сжатия строк base8 (1-8)

function allCharactersSame(s){
  let n = s.length;
  for (let i = 1; i < n; i++) {
    if (s[i] != s[0]) {
      return false;
    }
    return true;
  }
}
const characterMap = { // {{{
'11':'a','12':'b','13':'c','14':'d','15':'e','16':'f','17':'g','18':'h','21':'i','22':'j','23':'k','24':'l','25':'m','26':'n','27':'o','28':'p','31':'q','32':'r','33':'s','34':'t','35':'u','36':'v','37':'w','38':'x','41':'y','42':'z','43':'A','44':'B','45':'C','46':'D','47':'E','48':'F','51':'G','52':'H','53':'I','54':'J','55':'K','56':'L','57':'M','58':'N','61':'O','62':'P','63':'Q','64':'R','65':'S','66':'T','67':'U','68':'V','71':'W','72':'X','73':'Y','74':'Z','75':'!','76':'@','77':'#','78':'$','81':'%','82':'^','83':'&','84':'*','85':'(','86':')','87':'-','88':'_'
} // }}}
async function convertHash(string) { // {{{
    if (allCharactersSame(string)){
        return string[0]
    }
    if (string.length % 2 === 1){throw 'Input MUST be fully divisable by 2'}
    var n = ''
    // map characters
    string.match(/.{1,2}/g).forEach((num) => {n += characterMap[num]})
    // shrink repeats
    string = n.replace(/(.)\1+/g, (s) => {
        var nn = ''
        var x = Math.floor(s.length / 10)
        var y = s.length % 10
        nn += '0'.repeat(x)
        if (y !== 0){nn += y}
        return `${s[0]}${nn}`
    })
    return string
} // }}}
async function revertHash(string) { // {{{
    if (string.length === 1){
        return string.repeat(256)
    }

    // unshrink
    var nn = string.replaceAll(/([a-zA-Z])([0-9]+)/g,function(s1){
        var ny = ''
        var v = '';
        var ar = s1.split('')
        var ch = ar.shift()
        for(v of ar) {
            if (v === '0'){
                ny += ch.repeat(10)
            } else {
                ny += ch.repeat(v)
            }
        }
        return ny
    })

    // unpack
    var n = ''
    nn.split('').forEach(bit => {
        Object.keys(characterMap).forEach(key => {
            if (bit === characterMap[key]) {
                n += key
            }
        })
    })
    return n
} // }}}

Используя это, я сжал ~7 тыс. 256-битных числовых строк в кодировке Base2 в среднем до 86 бит, причем ~30 из них стали однобитными с точностью 100% при распаковке.