Convertir le tableau de valeurs d'octets en base64 de la chaîne et de briser les longues lignes, Javascript (code de golf)

Cette fonction JavaScript prend un tableau de nombres (dans la plage de 0 à 255) et la convertit en une chaîne base64, puis les pauses longues lignes si nécessaire:

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();
}

Pouvez-vous faire la même chose en moins de code? Pouvez-vous faire en sorte qu'elle s'exécute plus rapidement? La portabilité de la pas un objet, l'utilisation de la marque de nouvelles fonctionnalités de la langue si vous voulez, mais s 'dois être en JavaScript.

  • S'exécute plus rapidement dans ce navigateur(s)? btoa est uniquement pris en charge par les navigateurs Gecko et WebKit pour autant que je sais.
  • Il se trouve que c'est un très petit morceau de une extension de Firefox, mais si vous avez un moyen astucieux de le faire en utilisant un autre navigateur JS, je serais heureux de voir que, trop.
  • ahem... codegolf.stackexchange.com
  • codegolf.SE est juste pour le divertissement; c'est un réel, légitime problème de programmation.
InformationsquelleAutor zwol | 2011-03-20
  1. 13

    J'ai une autre entrée:

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

    Minifiés, 88 caractères:

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

    Ou si vous voulez de nouvelles lignes de fuite, 85 caractères:

    function e(d){return btoa(String.fromCharCode.apply(d,d)).replace(/.{1,76}/g,'$&\n')}
    • Oh, très bien! Bien que je ne suis pas sûr à 100% sur l'utilisation de apply. Il y a une limite matérielle de quelque chose comme 2**19 arguments d'une fonction (dans Firefox, de toute façon) et je pense qu'il pourrait avoir à faire plus d'un peu de travail supplémentaire déballage de la matrice dans l'argument de la zone. Je n'attends pas de mes tableaux à que depuis longtemps, cependant, et la brièveté est agréable.
    • Je l'ai testé tout à l'heure (dans Firebug), il a travaillé jusqu'à environ 12*2**20 les numéros ici. Et qui n'était même pas une dure limite, il a juste signalé que le script de l'espace de pile quota est épuisé.
    • Combien de temps faut-il prendre? Pouvez-vous le temps de nos différentes méthodes avec de grands tableaux d'octets?
    • Ah, je viens de terminer de faire ça avec un tableau de 2**23 entrées. J'ai chronométré chaque 5 fois dans Firebug, a jeté le plus bas et le plus élevé, et a pris la moyenne des 3 autres. Ma première dure environ 6 secondes. Votre premier prend environ 5.8, votre seconde environ 5.3, votre troisième prend environ 2,7, et celui-ci d'environ 0,9 secondes.
    • Nice! J'ai pensé que map ou apply serait le meilleur, c'est pourquoi je upvoted cette réponse, mais pas votre autre.
    • Très cool, mais vous êtes à l'aide de deux variables dans le non-compacte - données et d, alors qu'ils devraient l'être.
    • Bon point.

    InformationsquelleAutor Anomie
  2. 3

    Fonctionne dans 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');
}
    • Avez-vous besoin que trim là?
    • Je l'ai mis pour éviter que la chaîne renvoyée avoir une fuite saut de ligne lorsque la chaîne base64 est un multiple exact de la longueur de la ligne tout en manquant de la linebreak autrement. Mais lors de l'écriture que de vous répondre, j'ai pensé: "est-ce que Firefox javascript regex prise en charge du moteur de largeur zéro positif "look-ahead"?". Et il le fait! Édité.
    • Oh, est l'objet ici minimum de caractères? Ceci peut être minimisé à 116 caractères, ou 113 si vous voulez que chaque sortie d'avoir une fuite de saut de ligne (modifier la regex pour /.{1,76}/g).
    • Minimum caractères ne sont pas vraiment le but, je vais être en cours d'exécution de l'ensemble de la chose par le biais d'un auto-minifier dans tous les cas, un minimum de activités est souhaitable. J'aime l'utilisation de reduce bien que j'imagine que c'est pas plus vite que la boucle for, depuis le big coût va être de plus en plus la chaîne.
    InformationsquelleAutor Anomie
  3. 1

    Je n'ai pas Firefox à portée de main, donc je ne peux pas l'essayer, mais à partir d'un général de la chaîne de manutention de point de vue, il semble que vous avez un peu de place à l'amélioration. Ce que vous faites est, pour chaque octet, la création d'une nouvelle chaîne d'un caractère de plus que votre précédente. C'est un O(N^2) opération. Il ya quelques façons de couper vers le bas N de sorte que votre algorithme s'exécute en temps quasi-linéaire dans le temps:

    1. Construire des chaînes de longueur 57 (cela donnera une 76-char Base64 résultat), puis d'effectuer une btoa sur elle et d'ajouter la chaîne résultante à votre sortie

    2. Tout comme #1, seulement de construire un tableau de lignes et d'appels join pour créer le résultat final de la chaîne.

    3. Utilisation map pour créer un tableau de 1-les chaînes de caractères, puis d'appeler join sur elle.

    Voici une partie du code non testé pour chaque méthode:

    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');
}

    Et voici la dernière, minimisé (116 caractères):

    function e(b){return btoa(b.map(function(d){return
String.fromCharCode(d)}).join("")).replace(/.{76}(?=.)/g,'$&\n')}
    • Une fermeture est nécessaire, parce que la carte invoque sa fonction avec 3 args (élément de tableau, l'index et l'objet array) et de la Chaîne.fromCharCode peuvent prendre de multiples points de code comme arguments pour retourner un multiple de chaîne de caractères. Par coïncidence, je me suis souvenu de ce juste avant que vous avez posté et réalisé que je pouvais tirer parti de ce fait.
    • J'aime l'idée de chunking 57 octets à la fois pour nourrir btoa.
    InformationsquelleAutor Gabe