Renvoyer Le Texte En JavaScript

Ce doit insérer un saut de ligne à la plus proche des espaces de maxChar:

str = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It w as popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";

str = wordWrap(str, 40);

function wordWrap(str, maxWidth) {
    var newLineStr = "\n"; done = false; res = '';
    do {                    
        found = false;
        //Inserts new line at first whitespace of the line
        for (i = maxWidth - 1; i >= 0; i--) {
            if (testWhite(str.charAt(i))) {
                res = res + [str.slice(0, i), newLineStr].join('');
                str = str.slice(i + 1);
                found = true;
                break;
            }
        }
        //Inserts new line at maxWidth position, the word is too long to wrap
        if (!found) {
            res += [str.slice(0, maxWidth), newLineStr].join('');
            str = str.slice(maxWidth);
        }

        if (str.length < maxWidth)
            done = true;
    } while (!done);

    return res + str;
}

function testWhite(x) {
    var white = new RegExp(/^\s$/);
    return white.test(x.charAt(0));
};

OriginalL'auteur ieeehh

Bien que cette question est assez vieux, de nombreuses solutions proposées jusqu'à présent sont de plus compliqué et plus cher que nécessaire, comme user2257198 souligné - C'est complètement soluble avec une courte ligne de l'expression régulière.

Cependant j'ai trouvé quelques problèmes avec sa solution, y compris: l'emballage après la largeur plutôt que de avant de, en rupture sur des caractères n'est pas explicitement inclus dans la classe de caractère et ne pas considérer existant caractères de saut de ligne provoquant le début de paragraphes à être coupée à mi-ligne.

Qui m'a conduit à écrire mon propre solution:

//Static Width (Plain Regex)
const wrap = (s, w) => s.replace(
    /(?![^\n]{1,32}$)([^\n]{1,32})\s/g, '$1\n'
);

//Dynamic Width (Build Regex)
const wrap = (s, w) => s.replace(
    new RegExp(`(?![^\\n]{1,${w}}$)([^\\n]{1,${w}})\\s`, 'g'), '$1\n'
);

Bonus

• Poignées tout char qui n'est pas un saut de ligne (e.code g).
• Poignées existantes retours à la ligne correctement (e.g paragraphes).
• Empêche de pousser des espaces sur le début de retours à la ligne.
• Empêche d'ajouter inutile de saut de ligne à la fin de la chaîne.

Explication

Le concept principal est simplement de trouver des séquences contiguës de caractères qui ne pas contiennent de nouvelles lignes de [^\n], jusqu'à la longueur désirée, de l'e.g 32 {1,32}. En utilisant la négation ^ dans la classe de caractères, il est beaucoup plus permissif, en évitant les choses qui manquent, comme la ponctuation qui, autrement, auraient à être explicitement ajouté:

str.replace(/([^\n]{1,32})/g, '[$1]\n');
//Matches wrapped in [] to help visualise

"[Lorem ipsum dolor sit amet, cons]
[ectetur adipiscing elit, sed do ]
[eiusmod tempor incididunt ut lab]
[ore et dolore magna aliqua.]
"

Jusqu'à présent seuls les tranches de la chaîne exactement à 32 caractères. Il fonctionne parce qu'il est propre saut de ligne insertions de marquer le début de chaque séquence après le premier.

Briser sur les mots, une qualification est nécessaire après le gourmand quantificateur {1,32} pour l'empêcher de choisir les séquences se terminant au milieu d'un mot. Un mot de saut de char \b peut causer des espaces à la mise en place de nouvelles lignes, de sorte qu'un espace blanc char \s doit être utilisé à la place. Il doit également être placé à l'extérieur du groupe afin de les manger, pour éviter l'augmentation de la largeur maximale de 1 char:

str.replace(/([^\n]{1,32})\s/g, '[$1]\n');
//Matches wrapped in [] to help visualise

"[Lorem ipsum dolor sit amet,]
[consectetur adipiscing elit, sed]
[do eiusmod tempor incididunt ut]
[labore et dolore magna]
aliqua."

Maintenant, il se brise sur les mots, avant la limite, mais le dernier mot et la période n'a pas été suivie dans la dernière séquence, car il n'est pas appelé à disparaître de l'espace.

"Ou de fin de chaîne" option (\s|$) pourrait être ajouté à la white-space pour étendre le match, mais il serait encore mieux de prévenir correspondant à la dernière ligne à tous les parce qu'il provoque une inutile de nouvelle ligne doit être insérée à la fin. Pour ce faire, un négatif "look-ahead" exactement de la même séquence peut être ajouté avant, mais à l'aide d'une fin de chaîne de char au lieu d'un blanc-espace de char:

str.replace(/(?![^\n]{1,32}$)([^\n]{1,32})\s/g, '[$1]\n');
//Matches wrapped in [] to help visualise

"[Lorem ipsum dolor sit amet,]
[consectetur adipiscing elit, sed]
[do eiusmod tempor incididunt ut]
labore et dolore magna aliqua."

OriginalL'auteur Thomas Brierley

De nombreux comportements comme cela peut être réalisé comme un seul-liner à l'aide d'expressions régulières (à l'aide de non-greedy quantificateurs avec un nombre minimum de caractères, ou avide de quantificateurs avec un nombre maximum de caractères, en fonction de ce comportement dont vous avez besoin).

Ci-dessous, un non-greedy remplacement global est illustré de travail dans le Nœud V8 REPL, de sorte que vous pouvez voir la commande et le résultat. Cependant, le même doit travailler dans un navigateur.

Ce modèle de recherche pendant au moins 10 caractères correspondant à un groupe défini ( \w signifie la parole des personnages, \s sens les espaces), et ancre le modèle sur un \b frontière de mot. Il utilise ensuite une référence arrière à remplacer l'original de match avec un avoir un retour à la ligne ajoutée (dans ce cas, éventuellement le remplacement d'un caractère espace qui n'est pas saisie dans le texte placé entre crochets la référence arrière).

> s = "This is a paragraph with several words in it."
'This is a paragraph with several words in it.'
> s.replace(/([\w\s]{10,}?)\s?\b/g, "$1\n")
'This is a \nparagraph \nwith several\nwords in it\n.'

Dans l'affiche originale du format demandé ce qui pourrait ressembler à...

var str = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It w as popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.";

function wordWrap(text,width){
    var re = new RegExp("([\\w\\s]{" + (width - 2) + ",}?\\w)\\s?\\b", "g")
    return text.replace(re,"$1\n")
}

> wordWrap(str,40)
'Lorem Ipsum is simply dummy text of the\nprinting and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s\n, when an unknown printer took a galley of\ntype and scrambled it to make a type specimen\nbook. It has survived not only five centuries\n, but also the leap into electronic typesetting\n, remaining essentially unchanged. It w as popularised in the 1960s with the\nrelease of Letraset sheets containing Lorem\nIpsum passages, and more recently with desktop publishing\nsoftware like Aldus PageMaker including\nversions of Lorem Ipsum.'

OriginalL'auteur cefn

Voici une longue réponse repose sur javabeangrinder la solution adapte le texte pour le multi-point d'entrée:

  function wordWrap(str, width, delimiter) {
    //use this on single lines of text only

    if (str.length>width) {
      var p=width
      for (; p > 0 && str[p] != ' '; p--) {
      }
      if (p > 0) {
        var left = str.substring(0, p);
        var right = str.substring(p + 1);
        return left + delimiter + wordWrap(right, width, delimiter);
      }
    }
    return str;
  }

  function multiParagraphWordWrap(str, width, delimiter) {
    //use this on multi-paragraph lines of text

    var arr = str.split(delimiter);

    for (var i = 0; i < arr.length; i++) {
        if (arr[i].length > width)
          arr[i] = wordWrap(arr[i], width, delimiter);
    }

    return arr.join(delimiter);
  }

OriginalL'auteur Joshua Olson

Fatigué de regexes et difficile à lire? Vous pouvez envelopper les textes à l'aide intégrée dans Array méthodes. Voici une manière de le faire (il suffit de remplacer le 100 limite en fonction de la longueur souhaitée:

let string = 'Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.';

string.split(' ').map((value, index, array) => {
    if (!array.currentLineLength) {array.currentLineLength = 0}
    array.currentLineLength += value.length+1;
    if (array.currentLineLength > 100) {
        array.currentLineLength = value.length;
        return "\n" + value;
    }
    return value;
}).join(' ');

Peut-être que vous aimeriez pour le retrait de ce texte sur chaque ligne? Pas de problème, vous pouvez simplement ajouter après la dernière join:

.split("\n").map(value => ''.padEnd(20) + value).join("\n");

OriginalL'auteur Nicolas Bouvrette