मैं एन-साइज़ चंक्स में एक बहुत बड़े स्ट्रिंग (चलो कहना है, 10,000 अक्षर) को विभाजित करना चाहूंगा।
ऐसा करने के लिए प्रदर्शन के मामले में सबसे अच्छा तरीका क्या होगा?
उदाहरण के लिए:
"1234567890"2 से विभाजित हो जाएगा ["12", "34", "56", "78", "90"]।
क्या ऐसा करना संभव होगा String.prototype.matchऔर यदि ऐसा है तो क्या यह प्रदर्शन के लिहाज से सबसे अच्छा तरीका होगा?
जवाबों:
आप ऐसा कुछ कर सकते हैं:
"1234567890".match(/.{1,2}/g);
// Results in:
["12", "34", "56", "78", "90"]विधि अभी भी स्ट्रिंग्स के साथ काम करेगी जिसका आकार चंक-आकार का एक सटीक गुणक नहीं है:
"123456789".match(/.{1,2}/g);
// Results in:
["12", "34", "56", "78", "9"]सामान्य तौर पर, किसी भी स्ट्रिंग के लिए, जिसमें से आप कम-से-अधिक n- सब्सट्रेटिंग निकालना चाहते हैं , आप ऐसा करेंगे:
str.match(/.{1,n}/g); // Replace n with the size of the substringयदि आपकी स्ट्रिंग में नई लाइनें या गाड़ी के रिटर्न हो सकते हैं, तो आप ऐसा करेंगे:
str.match(/(.|[\r\n]){1,n}/g); // Replace n with the size of the substringजहां तक प्रदर्शन की बात है, मैंने लगभग 10k पात्रों के साथ इसे आजमाया और क्रोम पर एक सेकंड से अधिक समय लगा। YMMV।
यह भी एक पुन: प्रयोज्य समारोह में इस्तेमाल किया जा सकता है:
function chunkString(str, length) {
return str.match(new RegExp('.{1,' + length + '}', 'g'));
}.न्यूलाइन से बिल्कुल भी मेल नहीं खाता। इतना है कि यह लेता है मैं इस सवाल का जवाब अपडेट करेगा \nऔर \rखाते में।
var chunks = str.split("").reverse().join().match(/.{1, 4}/).map(function(s) { return s.split("").reverse().join(); });। यह 4 की मात्रा में है। मुझे यकीन नहीं है कि आप "कम या अधिक" से क्या मतलब है। ध्यान रखें कि यह सामान्य रूप से काम नहीं करेगा, विशेष रूप से स्ट्रिंग्स के साथ जिसमें संयोजन वर्ण होते हैं और यूनिकोड के तार भी तोड़ सकते हैं।
[^]। इसके साथ आपके उदाहरण का परिणाम होगाstr.match(/[^]{1,n}/g)
मैंने कई तेज़ वेरिएंट बनाए जो आप jsPerf पर देख सकते हैं । मेरा पसंदीदा यह है:
function chunkSubstr(str, size) {
const numChunks = Math.ceil(str.length / size)
const chunks = new Array(numChunks)
for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
chunks[i] = str.substr(o, size)
}
return chunks
}Math.ceil()सही संख्या में हिस्सा निर्धारित करने के लिए करना चाहिए था ।
match, की तुलनाslicesubstrsubstringmatchऔर sliceअलग हिस्सा आकार के लिएmatchऔर sliceछोटे हिस्सा आकार के साथजमीनी स्तर:
matchबहुत अक्षम है, sliceफ़ायरफ़ॉक्स पर बेहतर है substr/ substringअभी भी बेहतर हैmatch शॉर्ट स्ट्रिंग्स के लिए और भी अक्षम है (कैश्ड रेगेक्स के साथ भी - शायद रेगेक्स पार्सिंग सेटअप समय के कारण)match बड़े चंक आकार के लिए और भी अधिक अक्षम है (शायद "कूद" में असमर्थता के कारण)matchoutperforms sliceलेकिन फिर भी सभी अन्य प्रणालियों पर खो देता हैयह एक तेज़ और सीधा उपाय है -
function chunkString (str, len) {
const size = Math.ceil(str.length/len)
const r = Array(size)
let offset = 0
for (let i = 0; i < size; i++) {
r[i] = str.substr(offset, len)
offset += len
}
return r
}
console.log(chunkString("helloworld", 3))
// => [ "hel", "low", "orl", "d" ]
// 10,000 char string
const bigString = "helloworld".repeat(1000)
console.time("perf")
const result = chunkString(bigString, 3)
console.timeEnd("perf")
console.log(result)
// => perf: 0.385 ms
// => [ "hel", "low", "orl", "dhe", "llo", "wor", ... ]substr()इसके बजाय उपयोग करना होगा substring()।
आश्चर्य! आप विभाजन को विभाजित करने के लिए उपयोग कर सकते हैं ।
var parts = "1234567890 ".split(/(.{2})/).filter(O=>O)का परिणाम [ '12', '34', '56', '78', '90', ' ' ]
filter (o=>o)लिए है?
filter(x=>x)उन खाली तत्वों को छानने के लिए उपयोग किया जाता है
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मैंने एक विस्तारित कार्य लिखा है, इसलिए चंक की लंबाई भी संख्या हो सकती है, जैसे कि [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;
};कोड
"1234567890123".chunkString([1,3])वापस होगा:
[ '1', '234', '5', '678', '9', '012', '3' ]यह दिए गए शब्दों के छोटे तारों को विभाजित करता है ।
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;
}यहाँ एक समाधान है जिसे मैं थोड़ा प्रयोग करने के बाद टेम्पलेट स्ट्रिंग्स के लिए आया था:
उपयोग:
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आप reduce()किसी भी रेगेक्स के बिना उपयोग कर सकते हैं :
(str, n) => {
return str.split('').reduce(
(acc, rec, index) => {
return ((index % n) || !(index)) ? acc.concat(rec) : acc.concat(',', rec)
},
''
).split(',')
}reduceतरीके का उपयोग करने के बारे में उदाहरण प्रदान करेंगे ।
एक प्रोटोटाइप फ़ंक्शन के रूप में:
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 का उपयोग करता है ।
हां यह एक उत्तर के रूप में काफी लंबा है क्योंकि यह वर्तमान मानकों का यथासंभव अनुसरण करने की कोशिश करता है और निश्चित रूप से इसमें उचित मात्रा में जेएसडीओसी की टिप्पणियां शामिल हैं। हालांकि, एक बार खनन करने के बाद, कोड केवल 828 बाइट्स है और एक बार ट्रांसमिशन के लिए gzipped केवल 497 बाइट्स है।
1 विधि जो इसे जोड़ता है String.prototype( Object.defineProperty का उपयोग करके जहां उपलब्ध है):
कार्यक्षमता की जांच के लिए कई परीक्षणों को शामिल किया गया है।
चिंता है कि कोड की लंबाई प्रदर्शन को प्रभावित करेगी? चिंता करने की कोई जरूरत नहीं है, http://jsperf.com/chunk-string/3
अतिरिक्त कोड में से अधिकांश यह सुनिश्चित करने के लिए है कि कोड कई जावास्क्रिप्ट वातावरणों में समान प्रतिक्रिया देगा।
/*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>स्लाइस () विधि का उपयोग करना:
function returnChunksArray(str, chunkSize) {
var arr = [];
while(str !== '') {
arr.push(str.slice(0, chunkSize));
str = str.slice(chunkSize);
}
return arr;
}वही सबस्ट्रिंग () विधि का उपयोग करके किया जा सकता है।
function returnChunksArray(str, chunkSize) {
var arr = [];
while(str !== '') {
arr.push(str.substring(0, chunkSize));
str = str.substring(chunkSize);
}
return arr;
}उपरोक्त समाधान के साथ मेरा मुद्दा यह है कि यह वाक्यों में स्थिति की परवाह किए बिना स्ट्रिंग को औपचारिक आकार के टुकड़े में रखता है।
मुझे लगता है कि निम्नलिखित एक बेहतर दृष्टिकोण है; हालाँकि इसके लिए कुछ प्रदर्शन की जरूरत है:
static chunkString(str, length, size,delimiter='\n' ) {
const result = [];
for (let i = 0; i < str.length; i++) {
const lastIndex = _.lastIndexOf(str, delimiter,size + i);
result.push(str.substr(i, lastIndex - i));
i = lastIndex;
}
return result;
}आप निश्चित रूप से कुछ ऐसा कर सकते हैं
let pieces = "1234567890 ".split(/(.{2})/).filter(x => x.length == 2);इसे पाने के लिए:
[ '12', '34', '56', '78', '90' ]यदि आप गतिशील रूप से इनपुट / चंक आकार को समायोजित करना चाहते हैं, ताकि विखंडू आकार n के हों, तो आप यह कर सकते हैं:
n = 2;
let pieces = "1234567890 ".split(new RegExp("(.{"+n.toString()+"})")).filter(x => x.length == n);मूल स्ट्रिंग में सभी संभव आकार n चंक्स खोजने के लिए, यह आज़माएँ:
let subs = new Set();
let n = 2;
let str = "1234567890 ";
let regex = new RegExp("(.{"+n.toString()+"})"); //set up regex expression dynamically encoded with n
for (let i = 0; i < n; i++){ //starting from all possible offsets from position 0 in the string
let pieces = str.split(regex).filter(x => x.length == n); //divide the string into chunks of size n...
for (let p of pieces) //...and add the chunks to the set
subs.add(p);
str = str.substr(1); //shift the string reading frame
}आपको इसके साथ समाप्त होना चाहिए:
[ '12', '23', '34', '45', '56', '67', '78', '89', '90', '0 ' ] 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.function chunkString(str, length = 10) {
let result = [],
offset = 0;
if (str.length <= length) return result.push(str) && result;
while (offset < str.length) {
result.push(str.substr(offset, length));
offset += length;
}
return result;
}