JavaScript : découper grande chaîne en segments de taille n

Question

Je voudrais découper une chaîne très grande (disons, 10 000 caractères) en morceaux de taille N.

Quel serait le meilleur moyen en termes de performances pour ce faire ?

Par exemple : « 1234567890 » diviser par 2 deviendrait {« 12 » « 34 », « 56 », « 78 », « 9 »}

Quelque chose comme cela serait possible à l’aide de la string.match et dans l’affirmative, qui serait la meilleure façon de le faire en termes de performances ?

Answer 1

Vous pouvez faire quelque chose comme ceci:

"1234567890".match(/.{1,2}/g);

Qui vous donne:

["12", "34", "56", "78", "90"]

Et:

"123456789".match(/.{1,2}/g);

vous donne:

["12", "34", "56", "78", "9"]

En général, pour toute chaîne dont vous voulez extraire la nde la taille des sous-chaînes, vous pouvez utiliser:

str.match(/.{1,n}/g); //replace n with the size of the substring

Comme la mesure de la performance, j'ai essayé avec environ 10k caractères et il a fallu un peu plus d'une seconde sur Chrome. YMMV.

Answer 2

• comparaison des match, slice, substr et substring
• comparaison des match et slice pour les différentes tailles de segment
• comparaison des match et slice avec la petite taille de bloc

Bas de ligne:

• match est très inefficace, slice est mieux, sur Firefox substr/substring est encore mieux
• match est encore plus inefficace pour de courtes chaînes de caractères (même avec le cache regex, probablement en raison de regex l'analyse du temps de configuration)
• match est encore plus inefficace pour le gros morceau de la taille (probablement due à l'incapacité de "sauter")
• pour les chaînes plus longues, avec une très petite partie de la taille, match surpasse slice sur les vieux IE, mais perd toujours sur tous les autres systèmes
• jsperf roches

Answer 3

C'est le plus rapide, le plus performant de la solution:

function chunkString(str, len) {
  var _size = Math.ceil(str.length/len),
      _ret  = new Array(_size),
      _offset
  ;

  for (var _i=0; _i<_size; _i++) {
    _offset = _i * len;
    _ret[_i] = str.substring(_offset, _offset + len);
  }

  return _ret;
}

Le comparer aux autres; je gagne :)

Answer 4

var str = "123456789";
var chunks = [];
var chunkSize = 2;

while (str) {
    if (str.length < chunkSize) {
        chunks.push(str);
        break;
    }
    else {
        chunks.push(str.substr(0, chunkSize));
        str = str.substr(chunkSize);
    }
}

alert(chunks); // chunks == 12,34,56,78,9

Answer 5

J'ai écrit une extension de la fonction, de sorte que le morceau longueur peut aussi être un tableau de nombres, comme [1,3]

String.prototype.chunkString = function(len) {
    var _ret;
    if (this.length < 1) {
        return [];
    }
    if (typeof len === 'number' && len > 0) {
        var _size = Math.ceil(this.length / len), _offset = 0;
        _ret = new Array(_size);
        for (var _i = 0; _i < _size; _i++) {
            _ret[_i] = this.substring(_offset, _offset = _offset + len);
        }
    }
    else if (typeof len === 'object' && len.length) {
        var n = 0, l = this.length, chunk, that = this;
        _ret = [];
        do {
            len.forEach(function(o) {
                chunk = that.substring(n, n + o);
                if (chunk !== '') {
                    _ret.push(chunk);
                    n += chunk.length;
                }
            });
            if (n === 0) {
                return undefined; // prevent an endless loop when len = [0]
            }
        } while (n < l);
    }
    return _ret;
};

Le code

"1234567890123".chunkString([1,3])

sera de retour:

[ '1', '234', '5', '678', '9', '012', '3' ]