Convertir matriz de valores de bytes a cadena codificada en base64 y romper líneas largas, Javascript (código de golf)

Question

Esta función de JavaScript toma una matriz de números (en el rango 0-255) y convierte a una cadena codificada en base64, luego se rompe líneas si es necesario:

function encode(data) 
{ 
    var str = ""; 
    for (var i = 0; i < data.length; i++) 
    str += String.fromCharCode(data[i]); 

    return btoa(str).split(/(.{75})/).join("\n").replace(/\n+/g, "\n").trim(); 
} 

¿Se puede hacer lo mismo con menos código? ¿Puedes hacerlo para que funcione más rápido? La portabilidad no tiene objeto, utilice nuevas funciones de idioma si lo desea, pero debe estar en JavaScript.

Answer 1

tengo otra entrada:

function encode(data) 
{ 
    var str = String.fromCharCode.apply(null,data); 
    return btoa(str).replace(/.{76}(?=.)/g,'$&\n'); 
} 

Minificado, 88 caracteres:

function e(d){return btoa(String.fromCharCode.apply(d,d)).replace(/.{76}(?=.)/g,'$&\n')} 

O si quieres saltos de línea finales, 85 caracteres:

function e(d){return btoa(String.fromCharCode.apply(d,d)).replace(/.{1,76}/g,'$&\n')} 

Answer 2

funciona en Firefox 3.6.13:

function encode(data) 
{ 
    var str = data.reduce(function(a,b){ return a+String.fromCharCode(b) },''); 
    return btoa(str).replace(/.{76}(?=.)/g,'$&\n'); 
} 

Answer 3

no tengo Firefox a mano, así que no puedo probarlo, pero desde una perspectiva general de manejo de series que parece que tiene algo de espacio mejorar. Lo que estás haciendo es, por cada byte, crear una nueva cadena de un carácter más larga que la anterior. Esta es una operación O (N^2). Hay algunas maneras de reducir N para que su algoritmo se ejecuta en casi lineal tiempo:

1. Build hasta cadenas a la longitud 57 (esto va a dar un resultado 76-char base 64), a continuación, realizar una btoa en y añada la cadena resultante a su resultado

2. Al igual que en el n. ° 1, solo cree un conjunto de líneas y llame al join para crear la cadena final de salida.

3. Utilice map para crear una matriz de cadenas de 1 carácter, luego llame al join en él.

Aquí hay un código no probado para cada método:

function encode(data) 
{ 
    var output = ""; 
    var str = ""; 
    for (var i = 0; i < data.length; i++) 
    { 
    str += String.fromCharCode(data[i]); 
    // the "&& i != data.length - 1" clause 
    // keeps the extra \n off the end of the output 
    // when the last line is exactly 76 characters 
    if (str.length == 57 && i != data.length - 1) 
    { 
     output += btoa(str) + "\n"; 
     str = ""; 
    } 
    } 
    return output + btoa(str); 
} 

function encode(data) 
{ 
    var output = []; 
    var str = ""; 
    for (var i = 0; i < data.length; i++) 
    { 
    str += String.fromCharCode(data[i]); 
    if (str.length == 57) 
    { 
     output[output.length] = btoa(str); 
     str = ""; 
    } 
    } 
    if (str != "") 
    output[output.length] = btoa(str); 
    return output.join("\n"); 
} 

function encode(data) 
{ 
    var str = data.map(function (d) { return String.fromCharCode(d) }).join(""); 
    return btoa(str).replace(/.{76}(?=.)/g,'$&\n'); 
} 

Y aquí es la última, minified (116 caracteres):

function e(b){return btoa(b.map(function(d){return 
String.fromCharCode(d)}).join("")).replace(/.{76}(?=.)/g,'$&\n')}