문자열을 n자 세그먼트로 분할하려면 어떻게 해야 합니까?

문자열을 n자 세그먼트로 분할하려면 어떻게 해야 합니까?

제목처럼 문자열이 있어서 n자씩 분할하고 싶습니다.

예를 들어 다음과 같습니다.

var str = 'abcdefghijkl';

으로 약간의 마법을 부린 후에n=3, 이 됩니다.

var arr = ['abc','def','ghi','jkl'];

방법이 있을까요?

var str = 'abcdefghijkl';
console.log(str.match(/.{1,3}/g));

주의: 사용{1,3}뿐만 아니라{3}3의 배수가 아닌 문자열 길이의 나머지를 포함하려면 다음과 같이 하십시오.

console.log("abcd".match(/.{1,3}/g)); // ["abc", "d"]

---

몇 가지 세부 사항:

1. 문자열에 줄바꿈이 포함될 수 있는 경우(문자열을 분할하지 않고 문자로 카운트하는 경우),.캡처가 안 돼요사용하다/[\s\S]{1,3}/대신.(@Mike 감사합니다).
2. 문자열이 비어 있으면match()돌아온다null빈 배열이 예상될 수 있습니다.추가함으로써 이 문제로부터 보호|| [].

따라서 다음과 같은 결과를 얻을 수 있습니다.

var str = 'abcdef \t\r\nghijkl';
var parts = str.match(/[\s\S]{1,3}/g) || [];
console.log(parts);

console.log(''.match(/[\s\S]{1,3}/g) || []);

정규 표현을 쓰고 싶지 않다면...

var chunks = [];

for (var i = 0, charsLength = str.length; i < charsLength; i += 3) {
    chunks.push(str.substring(i, i + 3));
}

jsFiddle.

...regex 솔루션이 매우 우수하다는 것을 알 수 있습니다:)

str.match(/.{3}/g); // => ['abc', 'def', 'ghi', 'jkl']

이 질문에 대한 이전 답변을 바탕으로 다음 함수가 문자열을 분할합니다.str) n-n-number (size)의 문자입니다.

function chunk(str, size) {
    return str.match(new RegExp('.{1,' + size + '}', 'g'));
}

데모

(function() {
  function chunk(str, size) {
    return str.match(new RegExp('.{1,' + size + '}', 'g'));
  }
  
  var str = 'HELLO WORLD';
  println('Simple binary representation:');
  println(chunk(textToBin(str), 8).join('\n'));
  println('\nNow for something crazy:');
  println(chunk(textToHex(str, 4), 8).map(function(h) { return '0x' + h }).join('  '));
  
  // Utiliy functions, you can ignore these.
  function textToBin(text) { return textToBase(text, 2, 8); }
  function textToHex(t, w) { return pad(textToBase(t,16,2), roundUp(t.length, w)*2, '00'); }
  function pad(val, len, chr) { return (repeat(chr, len) + val).slice(-len); }
  function print(text) { document.getElementById('out').innerHTML += (text || ''); }
  function println(text) { print((text || '') + '\n'); }
  function repeat(chr, n) { return new Array(n + 1).join(chr); }
  function textToBase(text, radix, n) {
    return text.split('').reduce(function(result, chr) {
      return result + pad(chr.charCodeAt(0).toString(radix), n, '0');
    }, '');
  }
  function roundUp(numToRound, multiple) { 
    if (multiple === 0) return numToRound;
    var remainder = numToRound % multiple;
    return remainder === 0 ? numToRound : numToRound + multiple - remainder;
  }
}());

#out {
  white-space: pre;
  font-size: 0.8em;
}

<div id="out"></div>

만약 당신이 정말로 계속 할 필요가 있다면.split및/또는.raplace, 그 후 를 사용합니다./(?<=^(?:.{3})+)(?!$)/g

위해서.split:

var arr = str.split( /(?<=^(?:.{3})+)(?!$)/ )
// [ 'abc', 'def', 'ghi', 'jkl' ]

위해서.replace:

var replaced = str.replace( /(?<=^(?:.{3})+)(?!$)/g, ' || ' )
// 'abc || def || ghi || jkl'

/(?!$)/스트링의 끝에서 멈추지 않는 것입니다.이 기능이 없으면:

var arr = str.split( /(?<=^(?:.{3})+)/ )
// [ 'abc', 'def', 'ghi', 'jkl' ] // is fine
var replaced = str.replace( /(?<=^(.{3})+)/g, ' || ')
// 'abc || def || ghi || jkl || ' // not fine

그룹 무시/(?:...)/는 배열 내의 엔트리가 중복되지 않도록 하기 위한 것입니다.이 기능이 없으면:

var arr = str.split( /(?<=^(.{3})+)(?!$)/ )
// [ 'abc', 'abc', 'def', 'abc', 'ghi', 'abc', 'jkl' ] // not fine
var replaced = str.replace( /(?<=^(.{3})+)(?!$)/g, ' || ' )
// 'abc || def || ghi || jkl' // is fine

마이솔루션(ES6 구문):

const source = "8d7f66a9273fc766cd66d1d";
const target = [];
for (
    const array = Array.from(source);
    array.length;
    target.push(array.splice(0,2).join(''), 2));

이 기능을 사용하여 함수를 만들 수도 있습니다.

function splitStringBySegmentLength(source, segmentLength) {
    if (!segmentLength || segmentLength < 1) throw Error('Segment length must be defined and greater than/equal to 1');
    const target = [];
    for (
        const array = Array.from(source);
        array.length;
        target.push(array.splice(0,segmentLength).join('')));
    return target;
}

그러면 함수를 재사용 가능한 방법으로 쉽게 호출할 수 있습니다.

const source = "8d7f66a9273fc766cd66d1d";
const target = splitStringBySegmentLength(source, 2);

건배.

const chunkStr = (str, n, acc) => {     
    if (str.length === 0) {
        return acc
    } else {
        acc.push(str.substring(0, n));
        return chunkStr(str.substring(n), n, acc);
    }
}
const str = 'abcdefghijkl';
const splittedString = chunkStr(str, 3, []);

REGEX를 사용하지 않는 깨끗한 솔루션

이 간단한 코드를 시도하면 마법처럼 작동할 것입니다!

let letters = "abcabcabcabcabc";
// we defined our variable or the name whatever
let a = -3;
let finalArray = [];
for (let i = 0; i <= letters.length; i += 3) {
    finalArray.push(letters.slice(a, i));
  a += 3;
}
// we did the shift method cause the first element in the array will be just a string "" so we removed it
finalArray.shift();
// here the final result
console.log(finalArray);

내가 가장 좋아하는 대답은 Gouder Hicham의 대답이다.하지만 저는 좀 더 이해하기 위해 그것을 수정했습니다.

let myString = "Able was I ere I saw elba";

let splitString = [];
for (let i = 0; i < myString.length; i = i + 3) {
    splitString.push(myString.slice(i, i + 3));
}

console.log(splitString);

다음은 코드의 기능화된 버전입니다.

function stringSplitter(myString, chunkSize) {
    let splitString = [];
    for (let i = 0; i < myString.length; i = i + chunkSize) {
        splitString.push(myString.slice(i, i + chunkSize));
    }
    return splitString;
}

그리고 이 기능은 다음과 같이 사용됩니다.

let myString = "Able was I ere I saw elba";
let mySplitString = stringSplitter(myString, 3);
console.log(mySplitString);

그 결과:

>(9) ['Abl', 'e w', 'as ', 'I e', 're ', 'I s', 'aw ', 'elb', 'a']

function chunk(er){
return er.match(/.{1,75}/g).join('\n');
}

위의 기능은 Base64 청킹에 사용하는 기능입니다.줄 바꿈이 75자로 생성됩니다.

여기에서는 n자마다 문자열을 다른 문자열과 삽입합니다.

export const intersperseString = (n: number, intersperseWith: string, str: string): string => {

  let ret = str.slice(0,n), remaining = str;

  while (remaining) {
    let v = remaining.slice(0, n);
    remaining = remaining.slice(v.length);
    ret += intersperseWith + v;
  }

  return ret;

};

위와 같이 사용할 경우:

console.log(splitString(3,'|', 'aagaegeage'));

다음과 같은 것을 얻을 수 있습니다.

aag|aag|aeg|aeg|e

여기서도 같은 작업을 수행하지만 어레이로 이동합니다.

export const sperseString = (n: number, str: string): Array<string> => {

  let ret = [], remaining = str;

  while (remaining) {
    let v = remaining.slice(0, n);
    remaining = remaining.slice(v.length);
    ret.push(v);
  }

  return ret;

};

다음으로 실행합니다.

console.log(sperseString(5, 'foobarbaztruck'));

다음과 같은 것을 얻을 수 있습니다.

['fooba', 'fuckazt', 'ruck']

만약 누군가가 위의 코드를 단순화하는 방법을 알고 있다면, lmk, 하지만 문자열에 대해서는 잘 작동할 것입니다.

정규 표현이나 명시적인 루프 없이 이 작업을 수행할 수 있는 방법은 다음과 같습니다. 단, 하나의 라이너에 대한 정의를 약간 확장합니다.

const input = 'abcdefghijlkm';

// Change `3` to the desired split length.
const output = input.split('').reduce((s, c) => {let l = s.length-1; (s[l] && s[l].length < 3) ? s[l] += c : s.push(c); return s;}, []);

console.log(output);  // output: [ 'abc', 'def', 'ghi', 'jlk', 'm' ]

기능은 한 후 를 사용하여 합니다.Array.reduce한 글자 한 글자 반복할 수 있습니다.통상은 「」입니다.reduce는 단일 값을 반환하지만 이 경우 단일 값은 배열이 됩니다.각 문자를 넘길 때 해당 배열의 마지막 항목에 추가합니다.어레이의 마지막 항목이 목표 길이에 도달하면 새 어레이 항목을 추가합니다.

조금 늦게 설명하겠습니다만, 여기에서는 서브스트링+어레이 푸시1보다 조금 빠른 바리에이션이 있습니다.

// substring + array push + end precalc
var chunks = [];

for (var i = 0, e = 3, charsLength = str.length; i < charsLength; i += 3, e += 3) {
    chunks.push(str.substring(i, e));
}

for 루프의 일부로 끝 값을 미리 계산하는 것은 서브스트링 내부의 인라인 계산을 수행하는 것보다 빠릅니다.Firefox와 Chrome에서 모두 테스트해 봤는데 둘 다 속도가 빨라졌어요.

여기서 드셔보실 수 있습니다

정규 표현을 사용하지 않는 클린 솔루션:

/**
* Create array with maximum chunk length = maxPartSize
* It work safe also for shorter strings than part size
**/
function convertStringToArray(str, maxPartSize){

  const chunkArr = [];
  let leftStr = str;
  do {

    chunkArr.push(leftStr.substring(0, maxPartSize));
    leftStr = leftStr.substring(maxPartSize, leftStr.length);

  } while (leftStr.length > 0);

  return chunkArr;
};

사용 예: https://jsfiddle.net/maciejsikora/b6xppj4q/

또한 정답으로 선택된 regexp 솔루션과 비교해보았습니다.일부 테스트는 jsfiddle - https://jsfiddle.net/maciejsikora/2envahrk/에서 확인할 수 있습니다.테스트 결과, 두 방법 모두 성능이 비슷합니다. 언뜻 보면 regexp 솔루션이 조금 더 빠를 수 있지만, 직접 판단해 보십시오.

    var b1 = ""; 
    function myFunction(n) { 
    if(str.length>=3){
     var a = str.substring(0,n);
     b1 += a+ "\n"
     str = str.substring(n,str.length)
     myFunction(n) 
    } 
    else{ 
    if(str.length>0){
    b1 += str 
    } 
    console.log(b1)
     } 
    }
  myFunction(4)

function str_split(string, length = 1) {
    if (0 >= length)
        length = 1;
    
    if (length == 1)
        return string.split('');

    var string_size = string.length;
    var result = [];

    for (let i = 0; i < string_size / length; i++)
        result[i] = string.substr(i * length, length);

    return result;
}

str_split(str, 3)

• 벤치마크: http://jsben.ch/HkjlU (브라우저마다 다릅니다)

결과(크롬 104)

언급URL : https://stackoverflow.com/questions/6259515/how-can-i-split-a-string-into-segments-of-n-characters