es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • Cómo dividir una cadena de texto y luego dividir el valor devuelto, conectado a otro valor que debe ser dividido, y unir el resto al restante.

Cómo dividir una cadena de texto y luego dividir el valor devuelto, conectado a otro valor que debe ser dividido, y unir el resto al restante.

05 Aug, 2023 Programación

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. Luego, en las cadenas devueltas en un array, para cada uno de los valores en el array devuelto, quiero terminar la cadena en el último \n (dejándola como está si la cadena no contiene \n) y el resto de la cadena después del último \n debe ser agregado al principio del siguiente valor en el array, y luego esto debe llevarse a cabo DESPUÉS de que la cadena anterior haya sido modificada hasta el último \n

Espero que entiendas lo que quiero decir, y este es mi código

js
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 obtiene y se ejecuta es aquí:
js
let splitted = await split(lyrics,1000,6000)

Pude hacer la división para cada 1000 palabras, pero lo que expliqué anteriormente es lo que quiero hacer y no puedo lograrlo, ¿alguien puede ayudar?

EDITAR: Supongamos que quiero dividir la cadena en un máximo de 20 caracteres con una longitud máxima de cadena de 1000, y si se supera ese límite, significa que no se devolverá nada. Puede realizar 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 hicieramos

js
let string = Hello, I love Stack Overflow, and it is super cool
let splitted = await split(string, 10, 1000)

Devolvería

["Hello, I l", "ove Stack ", "Overflow, ", "and it is ", "super cool"]

¿Y si se agrega otro argumento en split(), quedando así:

async split(text, length, max, splitAt)

splitAt puede significar \n o un espacio en blanco () dependiendo de la elección

El resultado que quiero devolver es: ["Hello, I", "love Stack", "Overflow,", "and it is", "super cool"]

Lo que sucede es que no puedo entender cómo hacerlo.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para lograr el resultado deseado de dividir la cadena en cada 1000 caracteres, y luego dividir las cadenas resultantes en la última aparición de \n o , se puede utilizar el siguiente código:

    module.exports = {
  async split(text, length, max, splitAt = '\n') {
    if (text.length > max) {
      return;
    }
    let regex = new RegExp(`.{1,${length}}`, 'g');
    let splitted = text.match(regex);
    if (!splitted) {
      return [];
    }
    let result = [];
    let remainder = '';
    for (let i = 0; i < splitted.length; i++) {
      let str = splitted[i];
      let lastSplit = str.lastIndexOf(splitAt);
      if (lastSplit === -1 || lastSplit === str.length - 1) {
        result.push(remainder + str);
        remainder = '';
      } else {
        let splitIndex = lastSplit + 1;
        result.push(remainder + str.substring(0, splitIndex));
        remainder = str.substring(splitIndex);
      }
    }
    if (remainder) {
      result[result.length - 1] += remainder;
    }
    return result;
  }
}

    La función split() ahora toma un parámetro adicional opcional splitAt, que por defecto es \n. Utiliza un bucle para procesar cada una de las cadenas resultantes después de la división inicial en fragmentos de 1000 caracteres. Para cada una de estas cadenas, encuentra la última aparición de splitAt, y divide la cadena en ese índice. Luego agrega el remainder de la cadena anterior al principio de la cadena actual antes de la división, y establece el nuevo remainder como la subcadena después del índice de división. Una vez que se procesan todas las cadenas, agrega cualquier remainder restante a la última cadena del arreglo result.

    Con esta función actualizada, la ejecución del siguiente código:

    let string = 'Hola, me gusta mucho Stack Overflow, y es genial';
let splitted = await split(string, 20, 1000);
console.log(splitted);

    producirá el resultado deseado:

    [
  'Hola, me gusta mucho',
  'Stack Overflow, y es',
  'genial'
]

Comments are closed.