/*
Librairie String.

Version : 1.0.2
Date : 20.07.2005
Description : Extension des fonctions relatives aux chaînes de caractères.

Copyright © 2005, QuentinC
Cette librairie est libre d'utilisation, vous pouvez le modifier à volonté, à condition de laisser les commentaires du fichier intacts.
Pour télécharger d'autres librairies, rendez-vous sur http://www.quentinc.fr.st.

Historique des versions :
1.0 > Première version de la librairie String.
*/


// Prototype de String

String.HTML_ENTITIES = "&àáäâèéëêìíïîòóöôùúüû ©"&ccedil";
String.TEXT_ENTITIES = "&àáäâèéëêìíïîòóöôùúüû ©\"ç";

/*
Met la première lettre de chaque mot en majuscule.
@return String La même chaîne est retournée, avec la première de chaque mot en majuscules.
*/
String.prototype.ucWords = function () {
var tab = this.split(" ");
for (var i=0; i < tab.length; i++) {
tab[i] = tab[i].charAt(0).toUpperCase() + tab[i].substring(1);
}
return tab.join(" ");
}

/*
Retourne le nombre de mots que contient la chaîne.

@return Integer Le nombre de mots que contient la chaîne est retourné.
*/
String.prototype.getWordCount = function () {
return this.split(" ").length;
}

/*
Équivalent à substr_count en php, cette fonction retourne le nombre de fois que la chaîne passée en paramètre est contenue dans la chaîne actuelle.
@param String s La chaîne à utiliser pour la recherche.

@return Integer Le nombre d'occurences de <var>s</var> trouvées dans la chaîne. La casse est prise en considération.

*/
String.prototype.getSubstrCount = function (s) {
return this.split(s).length-1;
}

/*
Retourne la chaîne répétée n fois.

@param Integer n Le nombre de fois que la chaîne d'origine doit être répétée.

@return String La même chaîne est retournée, mais répétée <var>n</var> fois.
*/
String.prototype.repeatStr = function (n) {
var str = "";
for (var i=0; i < n; i++) { str += this; }
return str;
}

/*
Efface les éventuels blancs au début et à la fin de la chaîne. Est considéré comme blanc les espaces, les tabulations, et les retours de ligne \r et \n.

@return String La même chaîne est retournée après traitement.
*/
String.prototype.trim = function () {
var reg = new RegExp("^\\s*");
var reg2 = new RegExp("\\s*$");
return this.replace(reg, "").replace(reg2, "");
}

/*
Équivalent à htmlspecialchars en php (étonnant!) : remplace &gt; et &lt; par &amp;gt; et &amp;lt;

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.htmlspecialchars = function () {
return this.split("<").join("&lt;").split(">").join("&gt;");
}

/*
Fonction équivalente à add_slashes en php : ajoute un caractère \ devant les caractères \, ", '.

@return String La même chaine est retournée, après traitement.
*/
String.prototype.addSlashes = function () {
var reg = new RegExp("([\"\\\\'])", "g");
return this.replace(reg, "\\$1");
}

/*
Identique à strip_slashes du php : efface les caractères \ devant \, ", '.

@return String La même chaine est retournée, après traitement.
*/
String.prototype.stripSlashes = function () {

var reg = new RegExp("\\\\([\\\\\"'])", "g");
return this.replace(reg, "$1");
}

/*
Identique à nl2br du php : remplace les sauts de ligne \r\n, \r ou \n en <br />

@return String La même chaine est retournée, après traitement.
*/
String.prototype.nl2br = function () {
var reg = new RegExp("(\r\n|\r|\n)", "g");
return this.replace(reg, "<br />");
}

/*
Remplace <br> et <br /> en \n.

@return String La même chaine est retournée, après traitement.
*/
String.prototype.br2nl = function () {
var reg = new RegExp("<br( /)?>", "g");
return this.replace(reg, "\n");
}

/*
Ajoute un \ devant tous les caractères suceptibles d'êtres interprétés à l'intérieur d'une expression régulière : \, +, *, [, ], (, ), {, } et -.

@return String La même chaine est retournée, après traitement.
*/
String.prototype.escapeRegexp = function () {

var reg = new RegExp("([\\.\\\\\\+\\-\\*\\[\\]\\{\\}\\(\\)\\?\\$\\^])", "g");
return this.replace(reg, "\\$1");
}

/*
Effectue le contraire de la fonction escapeRegex, c'est-à-dire qu'elle efface les \ avant les caractères suceptibles d'être interprétés par une expression régulière.

@return String La même chaine est retournée, après traitement.
*/
String.prototype.unescapeRegexp = function () {
var reg = new RegExp("\\\\([\\.\\\\\\+\\-\\*\\[\\]\\{\\}\\(\\)\\?\\$\\^])", "g");
return this.replace(reg, "$1");
}

/*
Raccourci pour la séquence de code suivante, souvent utilisée :
<code>
var reg = new RegExp("blablabla");
return reg.test("blablabla");
</code>
@param String s Une expression régulière sous forme de chaîne.

@return Boolean Le même résultat que la fonction RegExp.test sur l'expression régulière passée en paramètre.
*/
String.prototype.matches = function (s) {
var reg = new RegExp(s);
return reg.test(this);
}

/*
Fonction équivalente à String.startsWith du Java : teste si la chaîne commence pour une séquence de caractères indiquée.

@param String s La chaîne à tester.
@return Boolean true si la chaîne commence par <var>s</var>, false dans le cas contraire.
*/
String.prototype.startsWith = function (s) {
return this.indexOf(s)==0;
}

/*
Teste si deux chaînes sont égales, en ignorant la casse.
@param String s La chaîne à tester.

@return Boolean true si la chaîne et <var>s</var> sont identiques en ignorant la casse.
*/
String.prototype.equalsIgnoreCase = function (s) {
return this.toLowerCase()==s.toLowerCase();
}

/*
Fonction identique à String.endsWith du Java : permet de tester si la chaîne se termine par une séquence de caractères indiquée.

@param String s La chaîne à tester.

@return Boolean true si la chaîne se termine par les mêmes caractères que ceux de <var>s</var>, false dans le cas contraire.
*/
String.prototype.endsWith = function (s) {
return this.lastIndexOf(s) == this.length-s.length;
}

/*
Retourne la chaîne, le dernier caractère devient le premier et le premier devient le dernier.

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.reverse = function () { return this.split("").reverse().join(""); }

/*
Remplace la plupart des caractères spéciaux par leur entité html &xxx; correspondante.

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.escapeEntities = function () {
var tab = String.HTML_ENTITIES.split(";");
var str = ""+this+"";
for (var i=0; i < tab.length; i++) {
var a = String.TEXT_ENTITIES.charAt(i);
var b = tab[i]+";";
str = str.split(a).join(b);
}
return str;
}

/*
Remplace la plupart des entités HTML &xxx; par leur caractère ASCII correspondant.

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.unescapeEntities = function () {
var tab = String.HTML_ENTITIES.split(";");
var str = ""+this+"";
for (var i=0; i < tab.length; i++) {
var b = String.TEXT_ENTITIES.charAt(i);
var a = tab[i]+";";
str = str.split(a).join(b);
}
return str;
}

/*
Désaccentue les caractères accentués.

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.removeAccents = function () {

var str = ""+this+"";
var a = "àâäáÀÁÄÂëèéêÊÉÈËïîíìÌÍÎÏüùûúÚÙÛÜãõñÃÕÑç";
var b = "aaaaAAAAeeeeEEEEiiiiIIIIooooOOOOuuuuUUUUaonAONc";

for (var i=0; i < a.length; i++) {
str = str.split(a.charAt(i)).join(b.charAt(i));
}
return str;
}

/*
Efface les tags HTML d'une chaîne.
@Exemple
&lt;h1&gt;Test&lt;/h1&gt;&lt;p&gt;Bonjour&lt;/p&gt;&lt;p&gt;Voilà &lt;b&gt;test&lt;/b&gt;&lt;/p&gt; devient Test Bonjour Voilà test 

@return String La même chaîne est retournée, après traitement.
*/
String.prototype.stripTags = function () {

var reg = new RegExp(
"<[/]?[a-zA-Z0-9]+( [a-zA-Z0-9_]+=((\"[^\"]+\")|([^ ]+)))*>", "g");
return this.replace(reg, " ");
}

/*
Teste si la chaîne pourrait être une adresse e-mail valide.

@return Boolean true dans le cas où la chaîne pourrait être une adresse e-mail valide, false dans le cas contraire.

@Attention !
Cette fonction ne vérifie pas si telle ou telle adresse e-mail existe réellement, elle ne fait qu'un test au niveau syntaxique (présence d'un signe "@", etc, etc.)
*/
String.prototype.isEmail = function () {
return this.matches("^[-a-zA-Z0-9\\._]{3,}@[-a-zA-Z0-9_]{2,}\\.[a-z]{2,4}$");
}

/*
Teste si la chaîne pourrait être une adresse URL valide commençant par http://

@return Boolean true si la chaîne pourrait être une adresse URL valide commençant par http://, false dans le cas contraire.

@Attention !
Cette fonction ne vérifie pas l'existance de l'URL, elle effectue simplement un test au niveau syntaxique.

*/
String.prototype.isURL = function () {
return this.matches("^http://[^ ]+$");
}


/*
Ajoute des caractères à gauche ou à droite de la chaîne pour qu'elle atteigne une longueur donnée. Si la longueur de la chaîne est supérieure à la taille spécifiée, elle restera inchangée.

@param Integer n La longueur que doit atteindre la chaîne retournée
@param String ch Optionnel : Définit le ou les caractères de remplissage. Par défaut, ce sera un espace.
@param Boolean right Optionnel : Définit si le remplissage doit être fait à droite ou à gauche de la chaîne. Spécifiez true pour la droite, et false pour la gauche. Par défaut, ce paramètre est à false et donc le remplissage se fait à gauche.

@return String La chaîne modifiée est retournée, la chaîne d'origine ne change pas.
*/
String.prototype.fill = function (n, ch, right) {
var str = this + "";
if (!ch) ch = " ";

while (str.length < n) {
if (right) str += ch;
else str = ch + str;
}
return str;
}