Convertir les entités de caractères HTML en texte ordinaire en utilisant javascript

Question

les questions disent tout :)

par ex. nous avons >, nous avons besoin > en utilisant uniquement javascript

Mise à jour: Il semble jquery est la voie facile. Mais, ce serait bien d'avoir une solution légère. Plus comme une fonction qui est capable de le faire par elle-même.

Answer 1

Vous pouvez faire quelque chose comme ceci:

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

Il n'y a rien de intégré, mais il y a beaucoup de bibliothèques qui ont été écrites pour cela.

Here est un.

Et here celui qui est un plugin jQuery.

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

Je sais qu'il ya des bibliothèques là-bas, mais voici quelques solutions pour les navigateurs. Ils fonctionnent bien lorsque vous placez des chaînes de données d'entité html dans des zones modifiables humaines dans lesquelles vous souhaitez afficher les caractères, telles que textarea ou input [type = text].

J'ajoute cette réponse car je dois prendre en charge les anciennes versions d'Internet Explorer et je pense que cela résume quelques jours de recherche et de tests. J'espère que quelqu'un trouve cela utile. Tout d'abord, ceci est pour les navigateurs plus modernes utilisant jQuery, notez que ceci NE devrait PAS être utilisé si vous devez supporter des versions d'IE avant 10 (7, 8, ou 9) car il enlèvera les nouvelles lignes en vous laissant avec juste une longue ligne de texte.

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; 
    }; 
} 

Ce prochain est basé sur le travail de Kennebec ci-dessus, avec quelques différences qui sont la plupart du temps à cause des anciennes versions IE. Cela ne nécessite pas jQuery, mais nécessite toujours un navigateur.

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

Voici une "classe" pour décoder du document HTML entier.

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; 
      } 
     ); 
    } 
} 

Notez que j'ai utilisé regexp Gumbo pour la capture des entités, mais pour les documents HTML entièrement valides (ou XHTML), vous pouvez utiliser simpy /&[^;]+;/g.