Lo que quiero es algo así como una cadena que tenga alrededor de 2000 a 3000 caracteres con más de cien \n ubicados de manera no uniforme en ellos, y quiero dividirlos por cada 1000 caracteres, y luego en las cadenas devueltas en una matriz, para cada uno de los valores en la matriz devuelta, quiero terminar la cadena en el último \n (dejarlo como está si la cadena no contiene \n ) y el resto de la cadena después del último \n debe agregarse al comienzo del siguiente valor en la matriz, y luego esto debe llevarse a cabo DESPUÉS de que la cadena anterior se haya fijado en el último \n
Espero que entiendas lo que quiero decir, y este es mi código.
module.exports={ async split(text,length,max){ if (text.length > max){ return; } let regex = new RegExp(`.{1,${length}}`, "g"); let splitted = text.match(regex); return splitted; } }El lugar donde se busca y ejecuta es aquí:
let splitted = await split(lyrics,1000,6000)Me las arreglé para hacer la división por cada 1000 palabras, pero lo que expliqué en la parte superior es lo que quiero hacer y no puedo manejarlo, ¿alguien puede ayudarme?
EDITAR: supongamos que quisiera dividir la cadena para un máximo de 20 caracteres con una longitud máxima de cadena de 1000, y si pasa por alto ese límite, significa que no se devolverá nada. Puede hacer esa segunda etapa de división (como mencioné en la pregunta como \n ) con un espacio en blanco ( ). Imagina que la cadena es: Hello, I love Stack Overflow, and it is super cool En mi código actual, si lo hiciéramos
let string = `Hello, I love Stack Overflow, and it is super cool` let splitted = await split(string, 10, 1000)volvería
["Hello, I l", "ove Stack ", "Overflow, ", "and it is ", "super cool"]
¿Qué pasa si se agrega otro argumento en split() , haciéndolo:
async split(text, length, max, splitAt)
splitAt puede significar \n o dependiendo de la elección
El resultado que quiero devolver es: ["Hello, I", "love Stack", "Overflow,", "and it is", "super cool"]
El caso es que no entiendo como hacerlo
Si lo entiendo correctamente, desea dividir el texto en fragmentos que tengan un tamaño máximo de 1000, y deben terminar con un carácter de nueva línea.
function split(str, chunkSize){ const chunks = []; let current_chunk = "" str.split("\n").forEach(part => { if(current_chunk.length + part.length > chunkSize){ // Adds the chunk to chunks and resets current chunk. chunks.push(current_chunk); current_chunk = ""; } // adds \n to the start of the part, if the current chunk isn't empty. current_chunk.length ? current_chunk += `\n${part}` : current_chunk += part }) // Used to get the last one, if it isn't empty. if(current_chunk.length) chunks.push(current_chunk); return chunks; }Debería verse algo como esto. Sin embargo, no lo he probado, ya que lo he escrito en mi teléfono.
Ciertamente, no necesita que este método sea async y debería ser solo un caso de recorrer la cadena, dividir por len y encontrar el último splitAt lastIndexOf y luego tomar ese fragmento en una matriz usando substring
Algo como esto:
function split(text, len, max, splitAt) { if (text.length > max) { return; } let pos = 0; const chunks = [] while (pos < text.length) { if (pos + len >= text.length) { chunks.push(text.substring(pos)); pos = text.length } else { const s = text.substring(pos, pos + len + 1).lastIndexOf(splitAt); chunks.push(text.substring(pos, pos + s)); pos += s + 1; } } return chunks; } let string = `Hello, I love Stack Overflow, and it is super cool` let splitted = split(string, 10, 1000, " ") console.log(splitted);