Konvertieren HTML-Zeichen-Entities zurück in regulären Text mit Javascript

Question

die Fragen sagt alles :)

eg. wir haben >, müssen wir > mit JavaScript nur

aktualisieren: Es scheint, jquery der einfache Weg ist aus. Aber es wäre schön, eine leichte Lösung zu haben. Mehr wie eine Funktion, die dazu in der Lage ist.

Answer 1

Man könnte so etwas tun:

String.prototype.decodeHTML = function() { 
    var map = {"gt":">" /* , … */}; 
    return this.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z]+);?/gi, function($0, $1) { 
     if ($1[0] === "#") { 
      return String.fromCharCode($1[1].toLowerCase() === "x" ? parseInt($1.substr(2), 16) : parseInt($1.substr(1), 10)); 
     } else { 
      return map.hasOwnProperty($1) ? map[$1] : $0; 
     } 
    }); 
}; 

Answer 2

Es ist nichts eingebaut, aber es gibt viele Bibliotheken, die dafür geschrieben wurden.

Here ist eins.

Und here eines, das ein jQuery-Plugin ist.

Answer 3

function decodeEntities(s){ 
    var str, temp= document.createElement('p'); 
    temp.innerHTML= s; 
    str= temp.textContent || temp.innerText; 
    temp=null; 
    return str; 
} 

alert(decodeEntities('<')) 

/* returned value: (String) 
< 
*/ 

Answer 4

Ich weiß, es gibt Bibliotheken gibt, aber hier sind ein paar Lösungen für Browser. Diese funktionieren gut, wenn Sie html-Entity-Datenstrings in editierbare Bereiche einfügen, in denen die Zeichen angezeigt werden sollen, z. B. Textarea oder Eingabe [type = text].

Ich füge diese Antwort hinzu, wie ich ältere Versionen von IE unterstützen muss, und ich fühle, dass es ein paar Tage im Wert von Forschung und Prüfung schließt. Ich hoffe, dass jemand das nützlich findet.

Zuerst ist dies für modernere Browser mit jQuery, Bitte beachten Sie, dass dies nicht verwendet werden sollte, wenn Sie Versionen von IE vor 10 (7, 8, oder 9) unterstützen müssen, da es die Zeilenenden streichen wird nur eine lange Textzeile.

if (!String.prototype.HTMLDecode) { 
    String.prototype.HTMLDecode = function() { 
      var str = this.toString(), 
      $decoderEl = $('<textarea />'); 

     str = $decoderEl.html(str) 
      .text() 
      .replace(/<br((\/)|(\/))?>/gi, "\r\n"); 

     $decoderEl.remove(); 

     return str; 
    }; 
} 

Das nächste ist oben auf kennebec Arbeit basiert, mit einigen Unterschieden, die meist aus Gründen der älteren IE-Versionen sind. Dies erfordert keine jQuery, erfordert aber immer noch einen Browser.

if (!String.prototype.HTMLDecode) { 
    String.prototype.HTMLDecode = function() { 
     var str = this.toString(), 
      //Create an element for decoding    
      decoderEl = document.createElement('p'); 

     //Bail if empty, otherwise IE7 will return undefined when 
     //OR-ing the 2 empty strings from innerText and textContent 
     if (str.length == 0) { 
      return str; 
     } 

     //convert newlines to <br's> to save them 
     str = str.replace(/((\r\n)|(\r)|(\n))/gi, " <br/>");    

     decoderEl.innerHTML = str; 
     /* 
     We use innerText first as IE strips newlines out with textContent. 
     There is said to be a performance hit for this, but sometimes 
     correctness of data (keeping newlines) must take precedence. 
     */ 
     str = decoderEl.innerText || decoderEl.textContent; 

     //clean up the decoding element 
     decoderEl = null; 

     //replace back in the newlines 
     return str.replace(/<br((\/)|(\/))?>/gi, "\r\n"); 
    }; 
} 

/* 
Usage: 
    var str = "&gt;"; 
    return str.HTMLDecode(); 

returned value: 
    (String) >  
*/ 

Answer 5

Hier ist eine "Klasse" für die Decodierung von ganzen HTML-Dokument.

HTMLDecoder = { 
    tempElement: document.createElement('span'), 
    decode: function(html) { 
     var _self = this; 
     html.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z]+);/gi, 
      function(str) { 
       _self.tempElement.innerHTML= str; 
       str = _self.tempElement.textContent || _self.tempElement.innerText; 
       return str; 
      } 
     ); 
    } 
} 

Bitte beachte, dass ich Gumbos regexp für den Fang von Einheiten verwendet, sondern für vollwertig HTML-Dokumente (oder XHTML) Sie simpy /&[^;]+;/g nutzen könnten.