Javascript 将纯文本呈现为HTML，保留空白–；没有<；预处理>；

给定任何充满可打印字符的任意文本文件，如何将其转换为呈现完全相同的HTML（符合以下要求）

• 不依赖默认的HTML空白规则以外的任何规则
  • 否<代码> 浏览器应该呈现完全相同的输出，保持第二行的缩进以及“缩进”和“空格”之间的间隙。当然，我实际上并不是在寻找单间距输出，字体与算法/标记正交
    将这两行作为完整的输入文件，正确的输出示例如下：

    text = html_escape(text); // dummy function
    text = text.replace(/\t/g, '    ')
               .replace(/  /g, '  ')
               .replace(/  /g, '  ') // second pass
                                          // handles odd number of spaces, where we 
                                          // end up with " " + " " + " "
               .replace(/\r\n|\n|\r/g, '<br />');
    

    第一行
    第二行，
    缩进四个空格
    

  • 浏览器中的软包装是可取的。也就是说，生成的HTML不应强制用户滚动，即使输入行比其视口宽（假设单个单词仍比所述视口窄）

  我正在寻找完全定义的算法。在python或javascript中实现的额外点数

  ---

  （请不要只是回答我应该使用
  标签或CSS

  空白

  规则，因为我的要求使这些选项无法成立。也请不要发布未经测试和/或天真的建议，如“将所有空格替换为
  ”毕竟，我敢肯定一个解决方案在技术上是可行的-这是一个有趣的问题，你不认为吗？
  在允许浏览器包装长线的同时，解决方案是用一个空格和一个不间断空格替换两个空格的序列

  //+ Jonas Raoni Soares Silva
  //@ http://jsfromhell.com/string/wordwrap [rev. #2]
  
  // String.wordWrap(maxLength: Integer,
  //                 [breakWith: String = "\n"],
  //                 [cutType: Integer = 0]): String
  //
  //   Returns an string with the extra characters/words "broken".
  //
  //     maxLength  maximum amount of characters per line
  //     breakWith  string that will be added whenever one is needed to
  //                break the line
  //     cutType    0 = words longer than "maxLength" will not be broken
  //                1 = words will be broken when needed
  //                2 = any word that trespasses the limit will be broken
  
  String.prototype.wordWrap = function(m, b, c){
      var i, j, l, s, r;
      if(m < 1)
          return this;
      for(i = -1, l = (r = this.split("\n")).length; ++i < l; r[i] += s)
          for(s = r[i], r[i] = ""; s.length > m; r[i] += s.slice(0, j) + ((s = s.slice(j)).length ? b : ""))
              j = c == 2 || (j = s.slice(0, m + 1).match(/\S*(\s)?$/))[1] ? m : j.input.length - j[0].length
              || c == 1 && m || j.input.length + (j = s.slice(m).match(/^\S*/)).input.length;
      return r.join("\n");
  };
  

  浏览器将正确渲染所有空间（正常空间和非打断空间），同时仍将环绕长线（由于正常空间）
  Javascript:

  String.prototype.wordWrap = function(m, b, c) {
      var i, j, l, s, r;
      if (m < 1)
          return this;
      for (i = -1, l = (r = this.split("\n")).length; ++i < l; r[i] += s)
          for (s = r[i], r[i] = ""; s.length > m; r[i] += s.slice(0, j) + ((s =
                  s.slice(j)).length ? b : ""))
              j = c == 2 || (j = s.slice(0, m + 1).match(/\S*(\s)?$/))[1] ? m :
              j.input.length - j[0].length || c == 1 && m || j.input.length +
              (j = s.slice(m).match(/^\S*/)).input.length;
      return r.join("\n");
  };
  

  text=html_转义（text）；//虚拟函数
  text=text.replace（/\t/g''）
  .replace（//g'，）
  .replace（//g'，）//第二遍
  //处理奇数个空格，其中
  //以“+”结尾
  .替换（/\r\n |\n |\r/g，
  ）；
  

  虽然这并不能完全满足您的所有要求，但首先它不能处理选项卡，我使用了下面的gem，它为Javascript

  字符串添加了
  wordWrap（）
  方法，在一些情况下，你可以做一些与你描述的相似的事情——因此，这可能是一个很好的起点，可以想出一些能做你想要的其他事情的东西
  
  function textToHTML(text)
  {
      return ((text || "") + "")  // make sure it is a string;
          .replace(/&/g, "&")
          .replace(/</g, "&lt;")
          .replace(/>/g, "&gt;")
          .replace(/\t/g, "    ")
          .replace(/ /g, "&#8203;&nbsp;&#8203;")
          .replace(/\r\n|\r|\n/g, "<br />");
  }
  
  /+Jonas Raoni Soares Silva
  //@ http://jsfromhell.com/string/wordwrap [第2次修订]
  //wordWrap（maxLength:Integer，
  //[breakWith:String=“\n”]，
  //[cutType:Integer=0]）：字符串
  //
  //返回一个包含额外字符/单词“breaked”的字符串。
  //
  //maxLength每行的最大字符数
  //breakWith字符串，该字符串将在需要时添加
  //打破界限
  //cutType 0=长度超过“maxLength”的单词不会被打断
  //1=需要时将断开单词
  //2=任何超出限制的单词都将被打破
  String.prototype.wordWrap=函数（m、b、c）{
  变量i，j，l，s，r；
  if（m<1）
  归还这个；
  对于（i=-1，l=（r=this.split（“\n”））.length；++im；r[i]+=s.slice（0，j）+（（s=s.slice（j））。长度？b:”）
  j=c==2 | |（j=s.slice（0，m+1）。匹配（/\s*（\s）？$/）[1]？m:j.input.length-j[0]。长度
  ||c==1&&m | | j.input.length+（j=s.slice（m）.match（/^\s*/）.input.length；
  返回r.join（“\n”）；
  };
  
  我还想评论一下，在我看来，如果涉及制表符，一般情况下，你会希望使用单间距字体，因为单词的宽度会随所使用的比例字体而变化（使制表符停止的使用结果非常依赖于字体）
  
  更新：这是一个稍微易读的版本，由一个在线网站提供：
  
  String.prototype.wordWrap=函数（m、b、c）{
  变量i，j，l，s，r；
  if（m<1）
  归还这个；
  对于（i=-1，l=（r=this.split（“\n”））.length；++im；r[i]+=s.slice（0，j）+（s=
  s、 切片（j））。长度？b:“”）
  j=c==2 | |（j=s.slice（0，m+1）。匹配（/\s*（\s）？$/）[1]？m:
  j、 input.length-j[0]。length | c==1&&m | j.input.length+
  （j=s.slice（m）.match（/^\s*/）.input.length；
  返回r.join（“\n”）；
  };
  使用（
  &8203；
  ）保留空白并允许文本换行。基本思想是将每个空间或空间序列与零宽度空间配对。然后用一个不间断的空格替换每个空格。您还需要对html进行编码并添加换行符
  
  如果你不关心unicode字符，那就很简单了。只需使用
  string.replace（）
  ：
  
  要编码unicode字符，它稍微复杂一些。您需要迭代字符串：
  
  var plain='&lt;a&gt; i am text plain &lt;/a&gt;'
  plain.asHtml();
  /* '<a> i am text plain </a>' */
  
  如果没有等距字体，您将丢失以下列：
  
  偶数空间
  
  elevenfour空间
  
  解决这个问题的算法似乎非常复杂。
  如果在项目中使用jQuery库，那么它非常简单
  
  只需一行，将
  asHTml
  extension添加到String类，然后：
  
  var plain='a我是纯文本/a'
  plain.asHtml（）；
  /*"
  
  注意：您不必访问DoM。只需使用jQuery的生成器设计模式
  $（“”）
  
  “用替换所有空格”有什么不对？只是问一下，这是我想到的第一件事——当然，你还需要用
  
  替换换行符，并以某种方式展开制表符
  function textToHTML(text)
  {
      return ((text || "") + "")  // make sure it is a string;
          .replace(/&/g, "&amp;")
          .replace(/</g, "&lt;")
          .replace(/>/g, "&gt;")
          .replace(/\t/g, "    ")
          .replace(/ /g, "&#8203;&nbsp;&#8203;")
          .replace(/\r\n|\r|\n/g, "<br />");
  }
  
      .replace(/ /g, "&nbsp;")
      .replace(/((&nbsp;)+)/g, "&#8203;$1&#8203;")
  
  var charEncodings = {
      "\t": "&nbsp;&nbsp;&nbsp;&nbsp;",
      " ": "&nbsp;",
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      "\n": "<br />",
      "\r": "<br />"
  };
  var space = /[\t ]/;
  var noWidthSpace = "&#8203;";
  function textToHTML(text)
  {
      text = (text || "") + "";  // make sure it is a string;
      text = text.replace(/\r\n/g, "\n");  // avoid adding two <br /> tags
      var html = "";
      var lastChar = "";
      for (var i in text)
      {
          var char = text[i];
          var charCode = text.charCodeAt(i);
          if (space.test(char) && !space.test(lastChar) && space.test(text[i + 1] || ""))
          {
              html += noWidthSpace;
          }
          html += char in charEncodings ? charEncodings[char] :
          charCode > 127 ? "&#" + charCode + ";" : char;
          lastChar = char;
      }
      return html;
  }  
  
  ten       seven spaces
  eleven    four spaces
  
  var plain='&lt;a&gt; i am text plain &lt;/a&gt;'
  plain.asHtml();
  /* '<a> i am text plain </a>' */