我希望将一个非常大的字符串(比如说 10,000 个字符)分割成 N 大小的块。
从性能方面考虑,最好的方法是什么?
举个例子:
"1234567890"
拆分为 2 小块会变成 ["12", "34", "56", "78", "90"]
。
是否可以使用 String.prototype.match
来实现这样的功能?如果可以,从性能方面考虑,这是否是最佳方式?
我希望将一个非常大的字符串(比如说 10,000 个字符)分割成 N 大小的块。
从性能方面考虑,最好的方法是什么?
举个例子:
"1234567890"
拆分为 2 小块会变成 ["12", "34", "56", "78", "90"]
。
是否可以使用 String.prototype.match
来实现这样的功能?如果可以,从性能方面考虑,这是否是最佳方式?
var l = str.length, lc = 0, chunks = [], c = 0, chunkSize = 2;
for (; lc < l; c++) {
chunks[c] = str.slice(lc, lc += chunkSize);
}
it Split将大字符串拆分成给定单词的小字符串。
function chunkSubstr(str, words) {
var parts = str.split(" ") , values = [] , i = 0 , tmpVar = "";
$.each(parts, function(index, value) {
if(tmpVar.length < words){
tmpVar += " " + value;
}else{
values[i] = tmpVar.replace(/\s+/g, " ");
i++;
tmpVar = value;
}
});
if(values.length < 1 && parts.length > 0){
values[0] = tmpVar;
}
return values;
}
我会使用正则表达式...
var chunkStr = function(str, chunkLength) {
return str.match(new RegExp('[\\s\\S]{1,' + +chunkLength + '}', 'g'));
}
在进行一些尝试后,我为模板字符串想出了一种解决方案:
使用方法:
chunkString(5)`testing123`
function chunkString(nSize) {
return (strToChunk) => {
let result = [];
let chars = String(strToChunk).split('');
for(let i = 0; i < (String(strToChunk).length / nSize); i++) {
result = result.concat(chars.slice(i*nSize,(i+1)*nSize).join(''));
}
return result
}
}
document.write(chunkString(5)`testing123`);
// returns: testi,ng123
document.write(chunkString(3)`testing123`);
// returns: tes,tin,g12,3
这个小代码片段怎么样:
function splitME(str, size) {
let subStr = new RegExp('.{1,' + size + '}', 'g');
return str.match(subStr);
};
(str, n) => {
return str.split('').reduce(
(acc, rec, index) => {
return ((index % n) || !(index)) ? acc.concat(rec) : acc.concat(',', rec)
},
''
).split(',')
}
const phrase = "1110010111010011100101110100010000011100101110100111001011101001011101001110010111010001000001110010111010011100101110100"
const number = 7
chkchars.splitToChunks(phrase, number)
// result => ['1110010', '1110100','1110010', '1110100','0100000', '1110010','1110100', '1110010','1110100', '1011101','0011100', '1011101','0001000','0011100','1011101', '0011100','1011101']
// perf => 0.287ms
window.format = function(b, a) {
if (!b || isNaN(+a)) return a;
var a = b.charAt(0) == "-" ? -a : +a,
j = a < 0 ? a = -a : 0,
e = b.match(/[^\d\-\+#]/g),
h = e && e[e.length - 1] || ".",
e = e && e[1] && e[0] || ",",
b = b.split(h),
a = a.toFixed(b[1] && b[1].length),
a = +a + "",
d = b[1] && b[1].lastIndexOf("0"),
c = a.split(".");
if (!c[1] || c[1] && c[1].length <= d) a = (+a).toFixed(d + 1);
d = b[0].split(e);
b[0] = d.join("");
var f = b[0] && b[0].indexOf("0");
if (f > -1)
for (; c[0].length < b[0].length - f;) c[0] = "0" + c[0];
else +c[0] == 0 && (c[0] = "");
a = a.split(".");
a[0] = c[0];
if (c = d[1] && d[d.length -
1].length) {
for (var d = a[0], f = "", k = d.length % c, g = 0, i = d.length; g < i; g++) f += d.charAt(g), !((g - k + 1) % c) && g < i - c && (f += e);
a[0] = f
}
a[1] = b[1] && a[1] ? h + a[1] : "";
return (j ? "-" : "") + a[0] + a[1]
};
var str="1234567890";
var formatstr=format( "##,###.", str);
alert(formatstr);
This will split the string in reverse order with comma separated after 3 char's. If you want you can change the position.
String.prototype.lsplit = function(){
return this.match(new RegExp('.{1,'+ ((arguments.length==1)?(isFinite(String(arguments[0]).trim())?arguments[0]:false):1) +'}', 'g'));
}
这里是我正在使用的代码,它使用了String.prototype.slice。
是的,作为答案,它相当长,因为它尽可能地遵循当前标准,并且当然包含了相当数量的JSDOC注释。但是,一旦被压缩,该代码仅为828字节,一旦被gzip传输,它只有497字节。
这个添加到String.prototype
中的1个方法(在可用的情况下使用Object.defineProperty)是:
已经包括了许多测试来检查功能。
担心代码长度会影响性能吗?不用担心,http://jsperf.com/chunk-string/3
额外的大部分代码都是为了确保代码在多个JavaScript环境中响应相同。
/*jslint maxlen:80, browser:true, devel:true */
/*
* Properties used by toChunks.
*/
/*property
MAX_SAFE_INTEGER, abs, ceil, configurable, defineProperty, enumerable,
floor, length, max, min, pow, prototype, slice, toChunks, value,
writable
*/
/*
* Properties used in the testing of toChunks implimentation.
*/
/*property
appendChild, createTextNode, floor, fromCharCode, getElementById, length,
log, pow, push, random, toChunks
*/
(function () {
'use strict';
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
/**
* Defines a new property directly on an object, or modifies an existing
* property on an object, and returns the object.
*
* @private
* @function
* @param {Object} object
* @param {string} property
* @param {Object} descriptor
* @return {Object}
* @see https://goo.gl/CZnEqg
*/
function $defineProperty(object, property, descriptor) {
if (Object.defineProperty) {
Object.defineProperty(object, property, descriptor);
} else {
object[property] = descriptor.value;
}
return object;
}
/**
* Returns true if the operands are strictly equal with no type conversion.
*
* @private
* @function
* @param {*} a
* @param {*} b
* @return {boolean}
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.4
*/
function $strictEqual(a, b) {
return a === b;
}
/**
* Returns true if the operand inputArg is undefined.
*
* @private
* @function
* @param {*} inputArg
* @return {boolean}
*/
function $isUndefined(inputArg) {
return $strictEqual(typeof inputArg, 'undefined');
}
/**
* The abstract operation throws an error if its argument is a value that
* cannot be converted to an Object, otherwise returns the argument.
*
* @private
* @function
* @param {*} inputArg The object to be tested.
* @throws {TypeError} If inputArg is null or undefined.
* @return {*} The inputArg if coercible.
* @see https://goo.gl/5GcmVq
*/
function $requireObjectCoercible(inputArg) {
var errStr;
if (inputArg === null || $isUndefined(inputArg)) {
errStr = 'Cannot convert argument to object: ' + inputArg;
throw new TypeError(errStr);
}
return inputArg;
}
/**
* The abstract operation converts its argument to a value of type string
*
* @private
* @function
* @param {*} inputArg
* @return {string}
* @see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring
*/
function $toString(inputArg) {
var type,
val;
if (inputArg === null) {
val = 'null';
} else {
type = typeof inputArg;
if (type === 'string') {
val = inputArg;
} else if (type === 'undefined') {
val = type;
} else {
if (type === 'symbol') {
throw new TypeError('Cannot convert symbol to string');
}
val = String(inputArg);
}
}
return val;
}
/**
* Returns a string only if the arguments is coercible otherwise throws an
* error.
*
* @private
* @function
* @param {*} inputArg
* @throws {TypeError} If inputArg is null or undefined.
* @return {string}
*/
function $onlyCoercibleToString(inputArg) {
return $toString($requireObjectCoercible(inputArg));
}
/**
* The function evaluates the passed value and converts it to an integer.
*
* @private
* @function
* @param {*} inputArg The object to be converted to an integer.
* @return {number} If the target value is NaN, null or undefined, 0 is
* returned. If the target value is false, 0 is returned
* and if true, 1 is returned.
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-9.4
*/
function $toInteger(inputArg) {
var number = +inputArg,
val = 0;
if ($strictEqual(number, number)) {
if (!number || number === Infinity || number === -Infinity) {
val = number;
} else {
val = (number > 0 || -1) * Math.floor(Math.abs(number));
}
}
return val;
}
/**
* The abstract operation ToLength converts its argument to an integer
* suitable for use as the length of an array-like object.
*
* @private
* @function
* @param {*} inputArg The object to be converted to a length.
* @return {number} If len <= +0 then +0 else if len is +INFINITY then
* 2^53-1 else min(len, 2^53-1).
* @see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
*/
function $toLength(inputArg) {
return Math.min(Math.max($toInteger(inputArg), 0), MAX_SAFE_INTEGER);
}
if (!String.prototype.toChunks) {
/**
* This method chunks a string into an array of strings of a specified
* chunk size.
*
* @function
* @this {string} The string to be chunked.
* @param {Number} chunkSize The size of the chunks that the string will
* be chunked into.
* @returns {Array} Returns an array of the chunked string.
*/
$defineProperty(String.prototype, 'toChunks', {
enumerable: false,
configurable: true,
writable: true,
value: function (chunkSize) {
var str = $onlyCoercibleToString(this),
chunkLength = $toInteger(chunkSize),
chunked = [],
numChunks,
length,
index,
start,
end;
if (chunkLength < 1) {
return chunked;
}
length = $toLength(str.length);
numChunks = Math.ceil(length / chunkLength);
index = 0;
start = 0;
end = chunkLength;
chunked.length = numChunks;
while (index < numChunks) {
chunked[index] = str.slice(start, end);
start = end;
end += chunkLength;
index += 1;
}
return chunked;
}
});
}
}());
/*
* Some tests
*/
(function () {
'use strict';
var pre = document.getElementById('out'),
chunkSizes = [],
maxChunkSize = 512,
testString = '',
maxTestString = 100000,
chunkSize = 0,
index = 1;
while (chunkSize < maxChunkSize) {
chunkSize = Math.pow(2, index);
chunkSizes.push(chunkSize);
index += 1;
}
index = 0;
while (index < maxTestString) {
testString += String.fromCharCode(Math.floor(Math.random() * 95) + 32);
index += 1;
}
function log(result) {
pre.appendChild(document.createTextNode(result + '\n'));
}
function test() {
var strLength = testString.length,
czLength = chunkSizes.length,
czIndex = 0,
czValue,
result,
numChunks,
pass;
while (czIndex < czLength) {
czValue = chunkSizes[czIndex];
numChunks = Math.ceil(strLength / czValue);
result = testString.toChunks(czValue);
czIndex += 1;
log('chunksize: ' + czValue);
log(' Number of chunks:');
log(' Calculated: ' + numChunks);
log(' Actual:' + result.length);
pass = result.length === numChunks;
log(' First chunk size: ' + result[0].length);
pass = pass && result[0].length === czValue;
log(' Passed: ' + pass);
log('');
}
}
test();
log('');
log('Simple test result');
log('abcdefghijklmnopqrstuvwxyz'.toChunks(3));
}());
<pre id="out"></pre>
reduce
方法的示例,我认为这将非常有帮助。 - kiatng