আমি একটি খুব বড় স্ট্রিং (ধরা যাক, 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"]সাধারণভাবে, যে কোনও স্ট্রিংয়ের মধ্যে আপনি সর্বাধিক এন- সাইজড সাবস্ট্রিংগুলি নিষ্কাশন করতে চান , আপনি তা করতে পারেন:
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যতদূর পারফরম্যান্স, আমি প্রায় 10 ক অক্ষর দিয়ে এটি চেষ্টা করেছি এবং এটি Chrome এ এক সেকেন্ডের বেশি সময় নিয়েছে। 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 এর অংশে এটি করে I আপনি "কম বা বেশি" বলতে কী বোঝায় তা আমি নিশ্চিত নই। মনে রাখবেন এটি সাধারণভাবে কাজ করবে না, বিশেষত এমন স্ট্রিংগুলির সাথে যা সংযুক্তিযুক্ত অক্ষরগুলি ধারণ করে এবং ইউনিকোড স্ট্রিংগুলিও ভেঙে ফেলতে পারে।
[^]। এটির সাথে আপনার উদাহরণটির ফলস্বরূপstr.match(/[^]{1,n}/g)
আমি বেশ কয়েকটি দ্রুত বৈকল্পিক তৈরি করেছি যা আপনি jscreen এ দেখতে পারেন । আমার প্রিয়টি হ'ল:
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, slice, substrএবংsubstringmatchএবং sliceজন্যmatchএবং sliceছোট খণ্ড আকার সঙ্গেশেষের সারি:
matchsliceফায়ারফক্সে খুব অদক্ষ, এটি আরও ভালsubstr / এ আরও ভালsubstring আরও ভাল এখনও ভালmatch সংক্ষিপ্ত স্ট্রিংগুলির জন্য আরও বেশি অকার্যকর (এমনকি ক্যাশেড রেজেক্সের সাথেও - সম্ভবত রেজেক্স পার্সিং সেটআপ সময়ের কারণে)match বৃহত্তর অংশের আকারের জন্য আরও বেশি অদক্ষ (সম্ভবত "ঝাঁপ" দিতে অক্ষমতার কারণে)match আউটপোরফর্মগুলি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'));
}আমি যে কোডটি ব্যবহার করছি এটি এখানে স্ট্রিং.প্রোটোটাইপ.স্লাইস ব্যবহার করে ।
হ্যাঁ এটি একটি উত্তর হিসাবে দীর্ঘ হিসাবে এটি বর্তমানের মানগুলি যতটা সম্ভব কাছাকাছি অনুসরণ করার চেষ্টা করে এবং অবশ্যই JSDOC মন্তব্যগুলির যুক্তিসঙ্গত পরিমাণ ধারণ করে । যাইহোক, একবার সংশোধন করা হলে, কোডটি কেবলমাত্র 828 বাইট এবং একবার সংক্রমণের জন্য জিপিড হয় এটি কেবল 497 বাইট।
এটি যুক্ত করে এমন 1 টি পদ্ধতি String.prototype( যেখানে উপলব্ধ সেখানে অবজেক্ট.ডাইফাইনপ্রোটারি ব্যবহার করে ):
কার্যকারিতা পরীক্ষা করার জন্য বেশ কয়েকটি পরীক্ষা অন্তর্ভুক্ত করা হয়েছে।
কোডটির দৈর্ঘ্য কার্যকারিতাকে প্রভাবিত করবে তা ভেবে? কোনও উদ্বেগের দরকার নেই, 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 = 2;
let pieces = "1234567890 ".split(new RegExp("(.{"+n.toString()+"})")).filter(x => x.length == 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;
}