/*** ——————————————————————————————————————————————————————————————————————————————————————————————————————————— ***/
/*** ——————————————————————————————————————————————————————————————————————————————————————————————————————————— ***/
/*** ***/
/*** MISC TOOLS Version 1.3.1 ***/
/*** Dernière Mise à Jour : 10-06-15 ***/
/*** ***/
/*** ——————————————————————————————————————————————————————————————————————————————————————————————————————————— ***/
/*** ***/
/*** Général ***/
/*** Ce script contient les méthodes d'exploitation général permettant de gagner du temps sur des fonctions ***/
/*** des fonctions légères comme une sorte de boîte à outils. ***/
/*** ***/
/*** ——————————————————————————————————————————————————————————————————————————————————————————————————————————— ***/
/*** cybORg version 0.05 ***/
/*** MIND version 0.2 ***/
/*** ——————————————————————————————————————————————————————————————————————————————————————————————————————————— ***/
//
// © Ockam Razor — ockam.razor@gmail.com
// cybORg pakage — Since 21/11/2009
// MIND universe — Since 26/12/2009
///* —— LEGENDE —— */
//
// Tans qu'une méthode n'affirme pas être compatible pour un navigateur, c'est qu'elle n'a pas été testée sur ce dernier.
//
// Algo : Méthode de pure algorythme ne présentant aucun risque d'incompatibilité navigateur
// Perf : Méthodes compatible avec l'ensembles des navigateurs
//
// Comp. : Compatible avec le navigateur cité précédemment.
// no-Comp. : Incompatible avec le navigateur cité précédemment.
//
// FF : Firefox
// IE : Internet Explorer
// Ch : Chrome
// Sa : Safari
// Op : Opéra
// Ces légendes peuvent se trouver après le nom d'une méthode quand cela désigne cette méthode uniquement.
// Elles peuvent, également, se trouver sous la définition d'un ensemble de méthode. En ce cas cela concerne la totalité des méthodes de cet ensemble.
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* VARIABLES */
/* Variables de gestion générale de MiscTools */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// Objet de variables
var MiscTools = new Object();
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* GENERAL */
/* Méthodes de concernant les éléments généraux de la page */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— GET SCREEN SCALE
// Fonction permettant de récupérer les dimentions de la fenêtre.
//
// IE Comp.
function GetScreenScale(){
// L'objet de retour
var Sortie = { width:0 , height:0 };
// Pour un BON navigateur ————>
if( window.innerWidth ){
// Récupère les deux tailles de l'écran
Sortie.width = window.innerWidth;
Sortie.height = window.innerHeight;
// Pour IE... ————>
} else if( document.documentElement.clientWidth ) {
// Retourne la largeur de l'écran
Sortie.width = document.documentElement.clientWidth;
Sortie.height = document.documentElement.clientHeight;
}
// Retourne l'objet
return Sortie;
}
// —————— GET NAVIGATOR
// Donne avec ( Presque totalement ) certitude le navigateur.
function GetNavigator(){
// La sortie
var Sortie = "";
// Les bons navigateurs ————>
//
if( window.innerWidth ){
// Tente une détection par nomination ——>
var NomNavigateur = navigator.userAgent;
//
if( FindIn( NomNavigateur , "Chrome" ) ){
//
Sortie = "Chrome";
} else if( FindIn( NomNavigateur , "Opera" ) ){
//
Sortie = "Opera"
} else if( FindIn( NomNavigateur , "Safari" ) ){
//
Sortie = "Safari"
} else {
//
Sortie = "Firefox";
}
// Retourne le résultat
return Sortie;
// Les... autres navigateurs ————>
//
} else {
//
return( "IE" );
}
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* STRING */
/* Méthodes de modification ou génération de chaîne de caractère. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— VARIABLES
// Variables de traitment des string
// Objet de variables
var MiscToolsString = new Object();
// Liste de l'Alphabet
MiscToolsString.Alphabet = [ "a" , "b" , "c" , "d" , "e" , "f" , "g" , "h" , "i" , "j" , "k" , "l" , "m" ,
"n" , "o" , "p" , "q" , "r" , "s" , "t" , "u" , "v" , "w" , "x" , "y" , "z" ];
//
MiscToolsString.Consones = [ "b" , "c" , "d" , "f" , "g" , "h" , "j" , "k" , "l" , "m" ,
"n" , "p" , "q" , "r" , "s" , "t" , "v" , "w" , "x" , "z" ];
MiscToolsString.Voyelles = [ "a" , "e" , "i" , "o" , "u" , "y" ];
// Liste Hexadecimal
MiscToolsString.Hexadecimal = [ "0" , "1" , "2" , "3" , "4" , "5" , "6" , "7" , "8" , "9" , "A" , "B" , "C" , "D" , "E" , "F" ];
// Liste de conversion
MiscToolsString.ConversionList = { _A01_:"À" , _A02_:"Â" , _A03_:"Ä" ,
_a01_:"à" , _a02_:"â" , _a03_:"ä" ,
_E01_:"È" , _E02_:"É" , _E03_:"Ê" , _E04_:"Ë" ,
_e01_:"é" , _e02_:"è" , _e03_:"ê" , _e04_:"ë" ,
_I01_:"Î" , _I02_:"Ï" ,
_i01_:"î" , _i02_:"ï" ,
_O01_:"Ô" , _O02_:"Ö" ,
_o01_:"ô" , _o02_:"ö" ,
_U01_:"Û" , _U02_:"Ü" ,
_u01_:"ù" , _u02_:"û" , _u03_:"ü" ,
_SS01_:"œ" , _SS02_:"ç" , _SS03_:"'" , _SS04_:"\"" , _SS05_:" " ,
_Sp01_:"-" , _Sp02_:"—" , _Sp03_:"©" , _Sp04_:"®" , _Sp05_:"™" ,
_Sp06_:"«" , _Sp07_:"»" , _Sp08_:"&" , _Sp09_:"$" , _Sp10_:"?" ,
_Sp11_:"!" , _Sp12_:"." , _Sp13_:"," , _Sp14_:";"
}
// —————— POP
// Retire un caractère, une chaine ou plusieurs au sein d'une chaine plus grande
function Pop( Chaine , // ————> La chaine concernée
ARetirer // ————> Le ou les éléments à retirer
){
// Si les éléments à retirer ne sont pas un tableau ——>
if( !TypeOf( ARetirer , "Array" ) ){
//
// Retire et renvoie
return( Chaine.split( ARetirer ).join( "" ) );
// Sinon ——> S'il s'agit d'un tableau
} else {
// Pour chaque partie du tableau ——>
for( var iARetirer = 0 ; iARetirer < ARetirer.length ; iARetirer++ ){
//
// Provoque un Pop() pour lui
Chaine = Pop( Chaine , ARetirer[ iARetirer ] );
}
}
// Retourne la chaine
return Chaine;
}
// —————— FIND IN
// Vérifie le nombre d'occurence d'une chaine dans une autre
function FindIn( Chaine , // ————> La chaine concernée
Contenu // ————> Le contenu à trouver
){
// Sépare et calcul le texte
return( Chaine.split( Contenu ).length - 1 );
}
// —————— HIGH LOW CASE
// La chaine de caractère est retournée avec une majuscule à la première lettre et le reste en minuscule
function HighLowCase( Chaine ){
// Coupe la chaine
var Sortie = Chaine.split( "" );
//
var PremiereLettre = Sortie.shift();;
//
var AutresLettres = Sortie.join( "" );
// Convertie les deux partie de la chaine et renvoie
return( PremiereLettre.toUpperCase() + AutresLettres.toLowerCase() );
}
// —————— TRIM
// Convertie une chaine de caratère pour retirer les espaces.
function Trim( Chaine ){
// Renvoie la chaine convertie sans espace
return( Chaine.replace(/\s+/g,"") );
}
// —————— CHARACTER CONVERSION
// Convertie une chaine de caratère de façon à remplacer certains caractère par d'autres
function CharacterConversion( Chaine , // ————> La chaine de départ
CaractereDepart , // ————> Le ou les caractère de départ
CaractereFin // ————> Le ou les caractère de fin
){
// Si le Caractère de départ est unique ——>
if( !TypeOf( CaractereDepart , "Array" ) ){
// Convertie les caractères
return Chaine.split( CaractereDepart ).join( CaractereFin );
// S'ils sont multiples ——>
} else {
// Pour chaque caractéres ——>
for( var iCaractereDepart = 0 ; iCaractereDepart < CaractereDepart.length ; iCaractereDepart++ ){
// Convertie ces caractères
Chaine = CharacterConversion( Chaine , CaractereDepart[ iCaractereDepart ] , CaractereFin[ iCaractereDepart ] || "" );
}
}
// Retourne la chaine
return Chaine;
}
// —————— JUMP LINE CONVERSION
// Convertie une chaine de caractère possédant des retours chariot manuel en les remplaçant par des
ou inversement.
function JumpLineConversion( Chaine , // ————> La chaine à convertir
Balisage // ————> Si on convertie pour ajouter les balise
ou l'inverse
){
// Arguments par défaut
Balisage = ( Balisage == null ) ? true : Balisage;
// Convertion du texte si Balisage
Chaine = escape( Chaine );
// Convertie le contenu texte
CharacterConversion( Chaine ,
Balisage ? [ "%0A" ] : [ "
" , "
" , "" ] ,
Balisage ? [ "
" ] : [ "%0A" ] );
// Retourne le texte déconvertie
return unescape( Chaine );
}
// —————— SPECIAL CONVERSION
// Convertie une chaine de caractère possédant des signes particuliers afin de les compiler spécialement pour qu'ils puissent être transiter ou bien pour les
// déconvertir après ce genre de transition
function SpecialConversion( Chaine , // ————> La chaine à convertir
Conversion // ————> Si on convertie ou la déconvertie
){
// Argument par défaut
Conversion = ( Conversion == null ) ? true : Conversion;
// Compile les deux tableaux
var TableauSpecial = new Array();
var TableauNormal = new Array();
//
for( var iConversionList in MiscToolsString.ConversionList ){
//
TableauSpecial.push( MiscToolsString.ConversionList[ iConversionList ] );
TableauNormal.push( iConversionList );
}
// Lance et renvoie la conversion
if( Conversion ){
//
return( CharacterConversion( Chaine , TableauSpecial , TableauNormal ) );
//
} else {
//
return( CharacterConversion( Chaine , TableauNormal , TableauSpecial ) );
}
}
// —————— GET ENCRYPTION
// Génére une clée de cryptage aléatoire selon un nombre de clé et une échelle de valeur des clées choisit.
function GetEncryption( Clees , // ————> Nombre de Clé du Cryptage
Valeur , // ————> Valeur maximal d'une clé
Separateur // ————> Séparateur des clés
){
// Arguments par défaut
Clees = Clees || 10;
Valeur = Valeur || 99;
Separateur = Separateur || "_";
// Variable de cryptage initial
var Cryptage = "";
// Pour chaque clé à créer...
for( var iClee = 0 ; iClee < Clees ; iClee++ ){
// Ajoute une valeur aléatoire de clée
Cryptage += DecadeNumber( Random( 0 , Valeur , true ) );
// Ajoute le séparateur si ce n'est pas la dernière clée
if( iClee != ( Clees - 1 ) ){ Cryptage += Separateur; }
}
// Renvoie le cryptage ainsi fait
return Cryptage;
}
// —————— STOP SENTENCE
// Interrompt une chaine de caractère au bout d'un certains nombre de caractère et y
// laisse une chaine indiquant l'interruption.
function StopSentence( Chaine , // ————> Chaine
Nombre , // ————> Nombre de caractère avant interruption
Fin , // ————> Chaine indiquant l'interruption
Type // ————> Type d'arrêt ( "Tout", "Mot" ou "Phrase" )
){
// Arguments par défaut
Type = Type || "Tout"
// Définition du séparateur selon le Type
if( Type == "Tout" ){ Type = ""; }
else if( Type == "Mot" ){ Type = " "; }
else if( Type == "Phrase" ){ Type = "."; }
// Séparation de la chaine
var TabChaine = Chaine.split( Type );
// Chaine reconstituée
Chaine = "";
// Pour chaque Caractère/Mot/Phrase ————>
for( var i = 0 ; i < Nombre ; i++ ){
// Concaténe les caractères tans qu'il y en a suivis du Séparateur.
if( TabChaine[ i ] != null && TabChaine[ i ] != undefined ){
Chaine += TabChaine[ i ] + Type;
}
}
// Place l'indice de Fin s'il restait encore des éléments
if( TabChaine[ i + 1 ] != null && TabChaine[ i + 1 ] != undefined ){
Chaine += Fin;
}
// Renvoie la Chaine
return Chaine;
}
// —————— POP TAG
// Retire toutes les balises d'un string.
function PopTag( Chaine ){
// Conversion de la Chaine
// ( RAPPEL de Version Navigateur : Untel[x] ne fonctionne pas sur les String sous IE )
var Chaine = Chaine.split( "" );
// Création de la Sortie
var Sortie = "";
//
// Levier
var Levier = true;
// Pour chaque élément de la Chaine ————>
for( var i = 0 ; i < Chaine.length ; i++ ){
// S'il s'agit d'une ouverture de balise, désactive le levier
if( Chaine[ i ] == "<" ){ Levier = false; }
// Si le levier est activé, rajoute la chaine à la sortie
if( Levier ){ Sortie += Chaine[ i ]; }
// S'il s'agit d'une fermeture de balise, active le levier
if( Chaine[ i ] == ">" ){ Levier = true; }
}
// Renvoie la Sortie
return Sortie;
}
// —————— POP BETWEEN
// Retire une chaine de caractère entre deux séparateur différent dans une chaine.
function PopBetween( Texte , // ————> La chaine
ChaineDebut , // ————> La chaine de début
ChaineFin // ————> La chaine de fin
){
// Sépare le texte
var leTexte = Texte.split( ChaineDebut );
// Levier
var Levier = true;
// Pour chaque partie du texte
for( var i = 1 ; i < leTexte.length ; i++ ){
// S'il contient la seconde chaine
if( FindIn( leTexte[ i ] , ChaineFin ) && Levier ){
// Convertie cette partie
var laPartie = leTexte[ i ].split( ChaineFin );
laPartie[ 0 ] = null;
AllEmptyDown( laPartie );
leTexte[ i ] = "[*REMOVE*]" + laPartie.join( ChaineFin );
// Bloque le levier
Levier = false;
}
// Si le levier est débloqué et que c'est la fin
if( i == leTexte.length - 1 && Levier ){
// Retire cette partie
leTexte[ i ] = "[*REMOVE*]";
}
}
// Renvoie le tout
return leTexte.join( ChaineDebut ).split( ChaineDebut + "[*REMOVE*]" ).join( "" );
}
// —————— GOMMAGE
// Retourne une chaine d'autant de blanc (Ou autre caractère) que de caractère dans cette chaîne
function Gommage( Texte , // ————> La chaine
Remplacement // ————> Le ou les caractère de remplacement
){
// Arguments par défaut
Remplacemnt = Remplacemnt || " ";
// Sépare les chaines du texte
var leTexte = Texte.split( "" );
// Pour chaque caractère ——>
for( var iTexte = 0 ; iTexte < leTexte.length ; iTexte++ ){
// Remplace le caractère
leTexte[ iTexte ] = Remplacemnt;
}
// Recompile et renvoie le texte
return leTexte.join( "" );
}
// —————— PASTE STRING
// Retourne une chaine suivis d'un nombre ( 1 ) ou dont le nombre à la fin augmente de 1
function PasteString( Texte ){
// Valeurs
var Chiffre = "";
var TabTexte = Texte.split( "" );
// Récupère le chiffre de la fin ——>
while( !isNaN( Number( TabTexte[ TabTexte.length - 1 ] ) ) ){
// Intégre le chiffre
Chiffre = TabTexte[ TabTexte.length - 1 ] + Chiffre;
// Supprime le chiffre
TabTexte.pop();
}
// Si on a récupéré aucun chiffre ——> fixe à 0
Chiffre = ( Chiffre == "" ) ? "0" : Chiffre;
// Le chiffre deviens un nombre et augmente de 1
Chiffre = Number( Chiffre ) + 1;
// Retourne la chaine associé au chiffre
return( TabTexte.join( "" ) + String( Chiffre ) );
}
// —————— TRIM SPACE
// Remplace les Espaces par des underscores et retire les espaces avant et après la chaîne de caractère
function TrimSpace( Texte ){
// Compile le tableau du texte
Texte = Texte.split( "" );
// Tans qu'il a des espace avant ——> Les retire
while( Texte[ 0 ] == " " ){
//
Texte.shift();
}
// Tans qu'il a des espace après ——> Les retire
while( Texte[ Texte.length - 1 ] == " " ){
//
Texte.pop();
}
// Compile le texte
Texte = Texte.join( "" );
// Remplace les espaces par des underscores
Texte = CharacterConversion( Texte , " " , "_" );
// Retourne le texte
return Texte;
}
// —————— REVERSE STRING
// Retourne une chaine inversée
function ReverseString( Texte ){
// Retourne la compilation
return Texte.split( "" ).reverse().join( "" );
}
// —————— CHARACTER LOOP
// Place un certain caractère tout les X nombre de caractère dans une chaine
//
// ¤ VorteX Compatible ¤
function CharacterLoop( Texte , // ————> Le texte
Caractere , // ————> Le caractère à insérer
Valeur , // ————> ¤ Valeur des pas d'insertion
Depart // ————> D'où il part ( "Debut" ou "Fin" )
){
// Arguments par défaut
Depart = Depart || "Debut";
// Compile le tableau du texte
if( Depart == "Fin" ){ Texte = ReverseString( Texte ); }
//
Texte = Texte.split( "" );
// Valeur de sorte
var Sortie = "";
// Compile le pas
var Pas = Aspiration( Valeur );
// Pour chaque caractère du texte ——>
for( var iTexte = 0 ; iTexte < Texte.length ; iTexte++ ){
// Ajoute à la sortie
Sortie += Texte[ iTexte ];
// Décroit le pas
Pas--;
// Si le pas est à zéro ——>
if( Pas <= 0 ){
// Ajoute la valeur à la sortie
Sortie += ( Depart == "Debut" ) ? Caractere : ReverseString( Caractere );
// Remet le pas au max
Pas = Aspiration( Valeur );
}
}
// Renvoie la sortie
return ( Depart == "Debut" ) ? Sortie : ReverseString( Sortie );
}
// —————— MULTIPLE STRING
// Renvoie une chaine de caractère concaténé dans elle-même autant de fois qu'on le souhaite
function MultipleString( Texte , // ————> Le Texte
Nombre // ————> Le nombre de boucle
){
// Variable de sortie
var Sortie = "";
// Autant de fois que le nombre ——>
for( var iNombre = 0 ; iNombre < Nombre ; iNombre++ ){
// Ajoute le texte à la sortie
Sortie += Texte;
}
// Retourne la sortie
return Sortie;
}
// —————— RANDOM WORD
// Génére une chaine aléatoire de lettres simulant un mot à peut prés lisible ( En intercalant voyelle et consonne )
function RandomWord( Nombre ){
// Arguments par défaut
Nombre = Nombre || 5;
// Variable de sortie
var Sortie = "";
// Définit un bump sur le nombre
Nombre += Random( -1 , 1 , true );
// Définit la lettre de départ et l'état
var Voyelle = RandomBoolean();
// Pour autant que le nombre ——>
while( Nombre > 0 ){
// Place une voyelle ——>
if( Voyelle ){
//
Sortie += RandomArray( MiscToolsString.Voyelles );
// Ou une consone ——>
} else {
//
Sortie += RandomArray( MiscToolsString.Consones );
}
// Switch l'état de voyelle
Voyelle = !Voyelle;
// Le nombre réduit
Nombre--;
}
// Retourne la sortie
return Sortie;
}
// —————— RANDOM HEXADECIMAL
// Génére une chaine aléatoire de lettres simulant un mot à peut prés lisible ( En intercalant voyelle et consonne )
function RandomHexadecimal( Rouge , // ————> Valeur de rouge obligatoire
Vert , // ————> Valeur de vert obligatoire
Bleu // ————> Valeur de bleu obligatoire
){
// Tirage aléatoire des couleurs
Rouge = Rouge || RandomArray( MiscToolsString.Hexadecimal ) + RandomArray( MiscToolsString.Hexadecimal );
Vert = Vert || RandomArray( MiscToolsString.Hexadecimal ) + RandomArray( MiscToolsString.Hexadecimal );
Bleu = Bleu || RandomArray( MiscToolsString.Hexadecimal ) + RandomArray( MiscToolsString.Hexadecimal );
// Retour de la couleur
return( Rouge + Vert + Bleu );
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* NUMBER */
/* Méthodes de calculs et de traitement des nombres et chiffres. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— VARIABLES
// Variables de traitment des numbers
// Objet de variables
var MiscToolsNumber = new Object();
// Liste des opérateurs
MiscToolsNumber.Operateur = [ "+" , "-" , "*" , "/" , "=" ];
// —————— RANDOM
// Tire aléatoirement un chiffre entre deux numéros définit.
// Permet, également, de l'arrondire
function Random( Debut , // ————> Numero Minimal
Fin , // ————> Numero Maximal
Arrondie // ————> S'il est arrondie ou non
){
// Arguments par défaut
Arrondie = Arrondie || false;
//
if( Arrondie == true ){ Arrondie = "round"; }
// Numéro recevant le tirage
var Numero = 0;
// Calibrage Debut et Fin
Debut = Aspiration( Debut );
Fin = Aspiration( Fin );
// Tirage aléatoire du numéro
Numero = Math.random() * ( Fin - Debut ) + Debut;
// Arrondie le numéro s'il le faut
if( Arrondie ){ Numero = Math[ Arrondie ]( Numero ); }
// Retourne le Numéro
return Numero;
}
// —————— ROUND
// Retourne un nombre arrondie classique ou avec un choix de chiffre aprés la virgule.
function Round( Chiffre , // ————> Chiffre à convertir
Nombre , // ————> Nombre de chiffre après la virgule
Mode // ————> Mode de convertion ( "round" , "floor" ou "ceil" )
){
// Arguments par défaut
Mode = Mode || "round";
Nombre = Nombre || 0;
// Convertie le chiffre ——>
Chiffre = ( Nombre > 0 ) ? Chiffre * ( Nombre != 0 ? ( eval( "1e+" + Math.abs( Nombre ) ) ) : 1 )
: Chiffre / ( Nombre != 0 ? ( eval( "1e+" + Math.abs( Nombre ) ) ) : 1 );
// Arrondie
Chiffre = eval( "Math." + Mode.toLowerCase() + "(" + Chiffre + ")" );
// Reconvertie et renvoie le chiffre
return( ( Nombre > 0 ) ? Chiffre / ( Nombre != 0 ? ( eval( "1e+" + Math.abs( Nombre ) ) ) : 1 )
: Chiffre * ( Nombre != 0 ? ( eval( "1e+" + Math.abs( Nombre ) ) ) : 1 ) );
}
// —————— NEAR EGAL
// Vérifie si une valeur est quasiement égal à une autre
function NearEgal( Chiffre , // ————> Le chiffre référent
Valeur , // ————> Valeur vérifiée
Tolerance // ————> Tolérance dans la vérification
){
// Arguments par défaut
Tolerance = Tolerance || 1;
// Retourne la vérification
return( ( Valeur > Chiffre - Tolerance && Valeur < Chiffre + Tolerance ) );
}
// —————— EGAL NEAR
// Une valeur devient égale à l'une des deux valeurs suivants celle qui est la plus proche
function EgalNear( Valeur , // ————> La valeur référente
Valeur1 , // ————> La première valeur
Valeur2 // ————> La seconde valeur
){
// Sonde la distance
var DistanceValeur1 = Math.abs( Valeur1 - Valeur );
var DistanceValeur2 = Math.abs( Valeur2 - Valeur );
// Retourne la valeur la plus proche par la distance la plus faible
return( DistanceValeur1 <= DistanceValeur2 ? Valeur1 : Valeur2 );
}
// —————— IS BETWEEN
// Vérifie si une valeur est comprise entre deux autres
function IsBetween( Valeur , // ————> La valeur vérifiée
Min , // ————> Le chiffre référent minimal
Max // ————> Le chiffre référent maximal
){
// Arguments par défaut
Min = Min != null ? Min : 0;
Max = Max != null ? Max : 1;
// Retourne la vérification
return( ( Valeur >= Min && Valeur <= Max ) );
}
// —————— BUMP NUMBER
// Renvoie une valeur tans qu'elle ne dépasse une certaines limite en minimal ou maximal, sinon, renvoie la limite qu'elle dépasse
function BumpNumber( Valeur , // ————> La valeur vérifiée
Min , // ————> Le chiffre référent minimal
Max // ————> Le chiffre référent maximal
){
// Arguments par défaut
Min = Min != null ? Min : -10000000;
Max = Max != null ? Max : 10000000;
// Renvoie la valeur si elle est entre les deux
if( IsBetween( Valeur , Min , Max ) ){ return Valeur; }
// Sinon ——> Renvoie la valeur qu'elle dépasse
else if( Valeur > Max ){ return Max; }
//
else { return Min; }
}
// —————— DECADE NUMBER
// Renvoie un chiffre sous forme string suivis d'un nombre de zéro devant lui s'il possède un nombre de composant inférieur au minimum
function DecadeNumber( Chiffre , // ————> Le chiffre traité
Nombre // ————> Le nombre de composant du chiffre attendu
){
// Arguments par défaut
Nombre = Nombre || 2;
// Compile le nombre en string
var StringChiffre = String( Chiffre );
// Tans qu'il a moins de caractère que souhaité ——>
while( StringChiffre.length < Nombre ){
//
// Lui ajoute un zéro devant
StringChiffre = "0" + StringChiffre;
}
// Renvoie le chiffre
return StringChiffre;
}
// —————— MATH OPERATOR
// Effectue un calcul de valeur selon diférent type d'opérateur afin de faciliter les argumentaires. C'est une sorte de petit VorteX
function MathOperator( Chiffre , // ————> La valeur initial
Nombre , // ————> La valeur de modification
Operateur // ————> L'opérateur ( S'il n'est pas déjà compris dans le Nombre )
){
// Si le nombre est une boolean ——> Renvoie le nombre directement
if( TypeOf( Nombre , "Boolean" ) ){ return Nombre }
// Sauvegarde la valeur du nombre
var SauveNombre = Nombre;
// Vérifie la présence d'un opérateur dans le nombre ——>
//
// Si ce nombre est un string ——>
if( TypeOf( Nombre , "String" ) ){
// Coupe le nombre
var cetOperateur = Nombre.split( "" )[ 0 ];
var ceNombre = Nombre.split( "" );
ceNombre.shift();
ceNombre = ceNombre.join( "" );
// Si le premier élément est un opérateur et que le reste peut être convertie en nombre ——>
if( IndexOf( MiscToolsNumber.Operateur , cetOperateur , "Etat" )
&& !isNaN( Number( Aspiration( ceNombre ) ) ) ){
// Remplace l'opérateur et le nombre
Nombre = ceNombre;
Operateur = cetOperateur;
}
}
// Arguments par défaut
Nombre = ( Nombre == null ) ? Chiffre : Nombre;
Chiffre = ( Chiffre == null ) ? Nombre : Chiffre;
Operateur = Operateur || "=";
// Suivant l'opérateur ——>
//
// Egalité ——>
if( Operateur == "=" ){
// Effectue le calcul
Chiffre = Number( Aspiration( Nombre ) );
}
//
// Addition ——>
else if( Operateur == "+" ){
// Effectue le calcul
Chiffre += Number( Aspiration( Nombre ) );
}
//
// Soustraction ——>
else if( Operateur == "-" ){
// Effectue le calcul
Chiffre -= Number( Aspiration( Nombre ) );
}
//
// Multiplication ——>
else if( Operateur == "*" ){
// Effectue le calcul
Chiffre *= Number( Aspiration( Nombre ) );
}
//
// Division ——>
else if( Operateur == "/" ){
// Effectue le calcul
Chiffre /= Number( Aspiration( Nombre ) );
}
// Renvoie le nombre s'il est un chiffre, sinon, renvoie la sauvegarde du nombre
return !isNaN( Chiffre ) ? Chiffre : SauveNombre;
}
// —————— NUMBER GOTO
// Renvoie un chiffre duction de la distance entre deux éléments et divisé par un nombre
function NumberGoTo( Chiffre , // ————> La valeur initial
Resultat , // ————> La valeur à atteindre
Frein // ————> Le frein d'atteinte
){
// Retourne le calcul
return( ( Resultat - Chiffre ) / Frein );
}
// —————— NUMBER BETWEEN
// Renvoie une valeur entre deux points selon un pourcentage sans ordre entre le min et le max
function NumberBetween( Min , // ————> Valeur N°1
Max , // ————> Valeur N°2
Pourcentage , // ————> Le pourcentage de moyenne
Arrondie // ————> Si la valeur est arrondie ( rien, "round" , "floor" ou "ceil" )
){
// Arguments par défaut
Pourcentage = Pourcentage || 50;
// Calibrage des arguments
var Minimum = ( Min <= Max ) ? Min : Max;
var Maximum = ( Min <= Max ) ? Max : Min;
// Récupère la valeur
var Valeur = ( ( Maximum - Minimum ) * ( Pourcentage / 100 ) ) + Minimum;
// Retourne le calcul
return( ( Arrondie == null ) ? Valeur : Round( Valeur , 0 , Arrondie ) );
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* BOOLEAN */
/* Méthodes de modification et traitement des booleans. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— RANDOM BOOLEAN
// Sort un pure aléatoire entre vrai ou faux, ou par un pourcentage de réussite
function RandomBoolean( Pourcentage ){
// Argument par défaut
Pourcentage = Pourcentage || 50;
// Tire la valeur aléatoire
var Valeur = Random( 0 , 100 );
// Indique le résultat
return( Pourcentage > Valeur );
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* ARRAY */
/* Méthodes de modification et traitement des tableaux. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— ARRAY MAX
// Sonde les éléments d'un tableau et en retourne la valeur numérique la plus élevée ou la plus faible.
function NumberIsInArray( Tableau , // ————> Le tableau sondé
Recherche // ————> Si on cherche le min ou le max ( max par défaut )
){
// Arguments par défaut
Recherche = Recherche || "max";
// Initialisation du lancement
var lancement = "Math." + Recherche.toLowerCase() + "( ";
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est bel et bien un nombre ————>
if( !isNaN( Number( Tableau[ i ] ) ) ){
// On ajoute l'élément à la chaine de lancement
lancement += Tableau[ i ];
// Levier bloqué
var test = false;
// Pour chaque élément du tableau après celui-ci ————>
for( var j = i + 1 ; j < Tableau.length ; j++ ){
// Si cet élément est un nombre, on débloque le levier
if( !isNaN( Number( Tableau[ j ] ) ) ){ test = true; }
}
// Si le levier a été débloqué, on ajoute une virgule de séparation dans la fonction de lancement
if( test ){ lancement += " , "; }
// Si le levier est resté bloqué, on mes fin à la chaine de la fonction de lancement
else { lancement += " );"; }
}
}
// Si la taille de la chaine de la fonction démontre qu'on a ajouté aucun élément du tableau, on renvoie directement Faux
if( lancement.length < 14 ){ lancement = "false"; }
// Sinon, on renvoie la fonction lancée à savoir l'élément le plus élevé parmis les éléments numérique du tableau
return eval( lancement );
}
// —————— INDEX OF
// Vérifie la position d'un élément dans un tableau.
// Remplace la fonction indexOf sans majuscule qui ne fonctionne pas toujours
//
// Perf
function IndexOf( Tableau , // ————> Tableau
Element , // ————> Élément à trouver
Type // ————> Forme de retour ( "Index" ou "Etat" )
){
// Arguments par défaut
Type = Type || "Index";
// Récupère par indexOf si on est pas sur IE
if( GetNavigator() != "IE" ){
//
var Index = Tableau.indexOf( Element );
}
// Envoie par l'indexOf s'il le trouve ——>
if( Index != undefined
&& Index != null
&& Index != -1 ){
//
return ( Type == "Index" ) ? Tableau.indexOf( Element ) : true;
}
// S'il ne le trouve pas par indexOf ——>
else {
// Pour chaque élément du tableau ——>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est celui qu'on cherche ——> Renvoie son Index
if( Tableau[ i ] == Element ){
//
return ( Type == "Index" ) ? i : true;
}
}
}
// Sinon ——> Renvoie -1 ou false
return( ( Type == "Index" ) ? -1 : false );
}
// —————— RANDOM ARRAY
// Retourne un élément aléatoire d'un tableau.
function RandomArray( Tableau ){
// Numéro de tirage aléatoire entre 0 et le nombre d'élément dans le tableau
var NumeroTirage = Random( 0 , ( Tableau.length - 1 ) , true );
// Retourne l'élément de ce Numéro
return Tableau[ NumeroTirage ];
}
// —————— UNICITE ARRAY
// Retourne un tableau dénué de doublon.
function UniciteArray( Tableau ){
// Variable de Sortie
var Sortie = [];
// Pour chaque élément du Tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// Levier activé
var levier = true;
// Pour chaque élément déjà récupéré ——>
for( var j = 0 ; j < Sortie.length ; j++ ){
// S'il s'y trouve déjà, désactive le levier
if( Sortie[ j ] == Tableau[ i ] ){ levier = false; }
}
// Si le levier est resté activé, ajoute l'élément au tableau de Sortie
if( levier ){ Sortie.push( Tableau[ i ] ); }
}
// Retourne le tableau de sortie
return Sortie;
}
// —————— PUSH UNICITE
// Ajoute un élément à un tableau à condition qu'il ne s'y trouve pas déjà.
function PushUnicite( Tableau , // ————> Tableau concerné
Element // ————> Élément à ajouter
){
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est strictement égal à l'élément à y mettre, renvoie le tableau tel quel
if( Tableau[ i ] === Element ){ return Tableau; }
}
// Sinon, ajoute l'élément au Tableau
Tableau.push( Element )
// Puis Renvoie le Tableau
return Tableau;
}
// —————— FRESH ARRAY
// Retire toutes les parties d'un tableau étant null ou étant un String vide ou bien étant égale à une certaine valeur.
function FreshArray( Tableau , // ————> Le Tableau
ARetirer // ————> L'élément à retirer
){
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// Levier à retirer
var OnVire = false;
// Si on ne retire rien de précis ——>
if( !ARetirer ){
// S'il est null, indéfinie ou un string vide, il le vire
if( Tableau[ i ] == null
|| Tableau[ i ] == undefined
|| Tableau[ i ] == "" ){
//
OnVire = true;
}
// Si on retire quelque chose de précis ——>
} else {
// S'il est égal à l'élément à virer, il le vire
if( Tableau[ i ] == ARetirer ){ OnVire = true; }
}
// S'il le faut ——> On vire l'élément du tableau
if( OnVire ){
//
Tableau.splice( i , 1 );
//
i--;
}
}
// Le renvoie
return Tableau;
}
// —————— KEY WORD
// À partir d'un tableau de mots-clés, donne une notification au choix aux mots dans
// cette phrase.
function KeyWord( Phrase , // ————> La Phrase
Mots , // ————> Les mots concernés
Notification // ————> Les Notifications à mettre
){
// Phrase par défaut
Phrase = Phrase ||"";
// Pour chaque Mots concernés ————>
for( var i = 0 ; i < Mots.length ; i++ ){
// Récupére ces mots dans la phrase, les retire puis les replace entourée des notifications voulues
Phrase = Phrase.split( Mots[ i ] ).join( Notification[ 0 ] + Mots[ i ] + ( Notification[ 1 ] || "" ) );
}
// Renvoie la Phrase
return Phrase;
}
// —————— CAPSULE ARRAY
// Encapsule une valeur dans un tableau s'il n'est pas déjà un tableau
function CapsuleArray( Valeur ){
// Si la valeur n'est pas un tableau ——>
if( !TypeOf( Valeur , "Array" ) ){
//
// La renvoi sous forme de tableau
return [ Valeur ];
// Si la valeur est un tableau ——>
} else {
//
// La renvoie telle quelle
return Valeur;
}
}
// —————— FIND IN ARRAY
// Indique le nombre de fois qu'une valeur est trouvé au sein d'un tableau
function FindInArray( Tableau , // ————> Le Tableau
Valeur // ————> La valeur à vérifier
){
// Valeur de sortie
var Sortie = 0;
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
//
// S'il équivaux à la valeur recherché ——> Augmente la sortie
if( Tableau[ iTableau ] == Valeur ){ Sortie++; }
}
// Renvoie la sortie
return Sortie;
}
// —————— AVERAGE ARRAY
// À partir d'un tableau, retourne une moyenne équivalent à la somme des valeur numérique du tableau
function AverageArray( Tableau ){
// Variables de traitement
var Dividande = 0;
var Chiffre = 0;
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
//
// S'il équivaux à un chiffre ——>
if( !isNaN( Number( Tableau[ iTableau ] ) ) ){
//
// Récupère ses valeurs
Chiffre += Number( Tableau[ iTableau ] );
//
Dividande++;
}
}
// Renvoie la sortie
return( Dividande != 0 ? Chiffre / Dividande : 0 );
}
// —————— MOST ARRAY
// Renvoie l'élément le plus fréquent dans le tableau
function MostArray( Tableau ){
// Variables de traitement
var TableauSortie = new Array();
var MaxSortie = [ "" , 0 ];
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// levier de vérification
var Levier = false;
// Pour chaque élément du tableau de sortie ——>
for( var iTableauSortie = 0 ; iTableauSortie < TableauSortie.length ; iTableauSortie++ ){
// S'il s'y trouve ——> Augmente son chiffre
if( TableauSortie[ iTableauSortie ][ 0 ] == Tableau[ iTableau ] ){
//
TableauSortie[ iTableauSortie ][ 1 ]++;
Levier = true;
}
}
// S'il ne s'y trouvait pas ——>
if( !Levier ){
//
// Ajoute son tableau de sa valeur et son chiffre
TableauSortie.push( [ Tableau[ iTableau ] , 1 ] );
}
}
// Pour chaque élément du tableau ——>
for( var iTableauSortie = 0 ; iTableauSortie < TableauSortie.length ; iTableauSortie++ ){
// S'il est présent en plus grand nombre que précédemment sauvegardé ——> Le sauvegarde
if( MaxSortie[ 1 ] < TableauSortie[ iTableauSortie ][ 1 ] ){
//
MaxSortie[ 0 ] = TableauSortie[ iTableauSortie ][ 0 ];
MaxSortie[ 1 ] = TableauSortie[ iTableauSortie ][ 1 ];
}
}
// Retourne la dernière valeur sauvegardée
return MaxSortie[ 0 ];
}
// —————— ORDER ARRAY
// Classe et retourne un tableau suivant différents principes au choix
function OrdreArray( Tableau , // ————> Le Tableau
Type // ————> Le type de classement ( "StringSize" ou "NumberSize" pour le moment )
){
// Arguments par défaut
Type = Type || "NumberSize";
// Clone le tableau
Tableau = CloneObject( Tableau );
// Variables de traitement
var TableauSortie = new Array();
// Tans qu'il y a des élément dans le tableau ——>
while( Tableau.length > 0 ){
// Variable de vérification
var Valeurs = [ 0 , 0 ];
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// S'il n'est pas du bon type ——> Le supprime
if( Type == "NumberSize" && !TypeOf( Tableau[ iTableau ] , "Number" )
|| Type == "StringSize" && !TypeOf( Tableau[ iTableau ] , "String" ) ){
//
Tableau.splice( iTableau , 1 );
//
iTableau--;
// S'il est du bon type ——>
} else {
// Vérifie s'il est le plus grand ——> S'il l'est, le conserve
if( Type == "NumberSize" && Tableau[ iTableau ] > Valeurs[ 0 ]
|| Type == "StringSize" && Tableau[ iTableau ].length > Valeurs[ 0 ] ){
//
Valeurs[ 0 ] = ( Type == "NumberSize" ) ? Tableau[ iTableau ] : Tableau[ iTableau ].length;
Valeurs[ 1 ] = iTableau;
}
}
}
// Récupère l'élément conservé au final et le retire du tableau
TableauSortie.push( Tableau[ Valeurs[ 1 ] ] );
Tableau.splice( [ Valeurs[ 1 ] ] , 1 );
}
// Retourne le tableau de sortie
return TableauSortie;
}
// —————— UNI TYPE ARRAY
// Renvoie un tableau à partir d'un autre mais ne contenant que les éléments d'un type choisis.
function UniTypeArray( Tableau , // ————> Le Tableau
Type // ————> Le Type demandé ( "String" par défaut )
){
// Arguments par défaut
Type = Type || "String";
// Clone le tableau
Tableau = CloneObject( Tableau );
// Pour chaque valeur du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// S'il n'est pas du type demandé ——> Le supprime
if( !TypeOf( Tableau[ iTableau ] , Type ) ){
//
Tableau.splice( iTableau , 1 );
//
iTableau--;
}
}
// Retourne le tableau de sortie
return Tableau;
}
// —————— PUSH AT
// Ajoute un élément dans un tableau à l'endroit donné ( Sans écraser ce qui s'y trouve déjà )
function PushAt( Tableau , // ————> Le Tableau
Element , // ————> Élément à ajouter
Position // ————> la position de l'élément
){
// Arguments par défaut
Type = Type || "String";
// Valeurs de sortie
var TableauSortie = new Array();
// Pour chaque valeur du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// S'il s'agit de la position ——> Intégre l'élément
if( iTableau == Position ){
//
TableauSortie.push( Element );
}
// Intégre la valeur du tableau
TableauSortie.push( Tableau[ iTableau ] );
}
// Retourne le tableau de sortie
return TableauSortie;
}
// —————— LAST ARRAY
// Retourne le dernier élement d'un tableau
function LastArray( Tableau ){
//
return Tableau[ Tableau.length - 1 ];
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* OBJET */
/* Méthodes basé sur les objets. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— VARIABLES
// Variables de traitment des objets
// Objet de variables
var MiscToolsObject = new Object();
// Tableau de sauvegarde des objets pour le clonage
MiscToolsObject.CloneSauve = new Array();
// —————— TYPE OF
// Retourne le nom précis d'un élément ou variable ou la vérification par rapport à un élément
function TypeOf( Variable , // ————> Variable à vérifier
Type // ————> Type proposé à vérifier
){
// Valeur de sortie
var Sortie = "";
// Les types que l'on détecte directement ——>
if( typeof Variable == "string"
|| typeof Variable == "number"
|| typeof Variable == "function"
|| typeof Variable == "boolean" ){
//
Sortie = HighLowCase( typeof Variable );
// Array ——>
} else if( typeof Variable == "object" && Variable.length != null && Variable.push ){
//
Sortie = "Array";
// Object ——>
} else if( typeof Variable == "object" ){
//
Sortie = String( Variable.toString() );
Sortie = Sortie.split( "[object " ).join( "" );
Sortie = Sortie.split( "]" ).join( "" );
Sortie = Sortie.split( "HTML" ).join( "" );
Sortie = Sortie.split( "Element" ).join( "" );
//
Sortie = HighLowCase( Sortie );
// Autrement ——>
} else {
//
Sortie = ( typeof Variable );
}
// Vérifie la coexistance avec le type proposé ou bien renvoie tel quel ——>
if( Type ){
//
return Type == Sortie;
} else {
//
return Sortie;
}
}
// —————— TAKE ALL
// Donne un ensemble de valeur ou clé à un élément à partir d'un objet
function TakeAll( Element , // ————> L'élément recevant les valeurs
Valeurs, // ————> Les valeurs à donner
Ecrase // ————> Si les valeurs à donner écrase celles déjà présentes
){
// Arguments par défaut
Ecrase = ( Ecrase != null && Ecrase != undefined ) ? Ecrase : true;
// S'il y a des valeurs et un élément ——>
if( Valeurs && Element ){
// Pour chaque valeurs ——>
for( var iValeur in Valeurs ){
// Si on doit écrase ou bien si elle n'existe pas ——>
if( Ecrase || !Element[ iValeur ] ){
// Donne la valeur du nom de la clé à l'élément
Element[ iValeur ] = MathOperator( Element[ iValeur ] , Valeurs[ iValeur ] );
}
}
}
}
// —————— EXTRACT ALL
// Récupére les propriétées particulière d'un certains type d'objet pour les donner en tant que clés à un Objet simple
function FindInObject( Objet , // ————> L'objet vérifié
Valeurs // ————> Tableau désignant les valeurs à récupérer
){
// Valeur de sortie
var Sortie = new Object();
// Encapsule les valeurs
Valeurs = CapsuleArray( Valeurs );
// Pour chaque valeurs ——>
for( var iValeur = 0 ; iValeur < Valeurs.length ; iValeur++ ){
// L'intégre à la sortie
Sortie[ Valeurs[ iValeurs ] ] = Objet[ Valeurs[ iValeurs ] ];
}
// Retourne la sortie
return Sortie;
}
// —————— LENGTH OBJECT
// Donne le nombre de clé ou élément dans un objet
function LengthObject( Objet ){
// Valeur initial
var Nombre = 0;
// Pour chaque clé ——>
for( var iClee in Objet ){
// Si elle n'est pas nulle
if( Objet[ iClee ] != null ){
// Augmente le chiffre
Nombre++;
}
}
// Retourne le nombre
return Nombre;
}
// —————— DEFAULT NOT VOID
// Suivant les critères d'une valeur, si elle est vide, null ou undefined, renvoie une valeur par défaut
function DefaultNotVoid( Valeur , // ————> La valeur à tester
Defaut // ————> La valeur par défaut
){
// Si la valeur est un string vide, tableau vide, null ou indéfinie ——> renvoie la valeur par défaut
if( Valeur == null
|| Valeur == undefined
|| Valeur == ""
|| TypeOf( Valeur , "Array" ) && Valeur.length == 0 ){
//
// Retourne la valeur par défaut
return Defaut;
// Sinon ——> Retourne la valeur initiale
} else {
//
return Valeur;
}
}
// —————— CLONE OBJECT
// Retourne un objet ou un tableau étant un clone d'un premier sans lien entre eux
function CloneObject( Element , // ————> L'élément à cloner
Prevention , // ————> Si on établie une affectation préventive ( Rien, Un nom de variable à vérifier ou "Total" )
Niveau , // ————> Le nombre de niveau à cloner
Racine // ————> Si on est à la racine du clonage ( Ne rien mettre à cet argument )
){
// Arguments par défaut
Racine = Racine == null ? true : Racine;
// S'il s'agit de la racine ——> Nettoie la sauvegarde précédente
if( Racine ){
//
MiscToolsObject.CloneSauve = new Array();
}
// Si on effectue une prévention totale ——>
if( Prevention == "Total" ){
// Ajoute l'objet au tableau de sauvegarde
MiscToolsObject.CloneSauve.push( Element );
// Si on effectue une prévention partielle ——>
} else if( Prevention != null ){
// Si l'élément est un objet et possède la variable de prevention ——>
if( TypeOf( Element , "Object" ) ){
//
if( Element[ Prevention ] != null ){
//
// Ajoute la valeur de la variable au tableau
MiscToolsObject.CloneSauve.push( Element[ Prevention ] );
}
}
}
// Réduit le niveau
Niveau--;
//
// Si le niveau est à -1 ——> Renvoie l'élément tel quel
if( Niveau == -1 ){
//
return Element;
}
// S'il s'agit d'un tableau ——>
if( TypeOf( Element , "Array" ) ){
// Créait le nouveau tableau
var NouveauTableau = new Array();
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Element.length ; iTableau++ ){
// Levier d'autorisation ——>
var Levier = true
// Si on effectue une prévention totale ——>
if( Prevention == "Total" ){
// Si l'élément se trouve déjà dans le tableau de sauvegarde ——>
if( IndexOf( MiscToolsObject.CloneSauve , Element[ iTableau ] , "Etat" ) ){
// Bloque le levier
Levier = false;
}
// Si on effectue une prévention partielle ——>
} else if( Prevention != null ){
// Si l'élément possède la variable et si elle se trouve déjà dans le tableau de sauvegarde ——>
if( IndexOf( MiscToolsObject.CloneSauve , Element[ iTableau ][ Prevention ] , "Etat" ) ){
// Bloque le levier
Levier = false;
}
}
// Si on le peut ——>
if( Levier ){
// Ajoute cet élément convertie au tableau
NouveauTableau.push( CloneObject( Element[ iTableau ] , Prevention , Niveau , false ) );
}
}
// Retourne le tableau
return NouveauTableau;
// S'il s'agit d'un objet ——>
} else if( TypeOf( Element , "Object" ) ){
// Créait le nouvel objet
var NouvelObjet = new Object();
// Pour chaque élément de l'objet ——>
for( var iObjet in Element ){
// S'il n'est pas null ——>
if( Element[ iObjet ] != null ){
// Levier d'autorisation ——>
var Levier = true
// Si on effectue une prévention totale ——>
if( Prevention == "Total" ){
// Si l'élément se trouve déjà dans le tableau de sauvegarde ——>
if( IndexOf( MiscToolsObject.CloneSauve , Element[ iObjet ] , "Etat" ) ){
// Bloque le levier
Levier = false;
}
// Si on effectue une prévention partielle ——>
} else if( Prevention != null ){
// Si l'élément possède la variable et si elle se trouve déjà dans le tableau de sauvegarde ——>
if( IndexOf( MiscToolsObject.CloneSauve , Element[ iObjet ][ Prevention ] , "Etat" ) ){
// Bloque le levier
Levier = false;
}
}
// Si on le peut ——>
if( Levier ){
// Ajoute cet élément convertie à l'objet
NouvelObjet[ iObjet ] = CloneObject( Element[ iObjet ] , Prevention , Niveau , false );
}
}
}
// Retourne l'objet
return NouvelObjet;
// S'il ne s'agit ni d'un objet, ni d'un tableau ——> Le renvoie tel quel
} else {
//
return Element;
}
}
// —————— RANDOM KEY
// Retourne une clé d'un objet de façon aléatoire
function RandomKey( Objet ){
// Récupère une valeur aléatoire suivant son nombre de clé
var Nombre = Random( 0 , LengthObject( Objet ) , "floor" );
// Pour chaque clé de l'objet ——>
for( var iObjet in Objet ){
// Si on est sur le nombre choisit ——> Renvoie la valeur
if( Nombre == 0 ){
//
return Objet[ iObjet ];
}
// Réduit le nombre
Nombre--;
}
// Sinon ——> Renvoie l'objet tel quel
return Objet
}
// —————— FIND IN OBJECT
// Vérifie si la valeur en question se trouve dans l'une des clés de l'objet
function FindInObject( Objet , // ————> L'objet vérifié
Valeur // ————> La valeur recherchée
){
// Pour chaque clé de l'objet ——>
for( var iObjet in Objet ){
//
// S'il a la bonne valeur ——> Renvoie son nom
if( Objet[ iObjet ] == Valeur ){
//
return iObjet;
}
}
// Si on a rien trouvé ——> Renvoie faux
return false;
}
// —————— ABSOLUT MODIF
// Sonde un objet et modifie la valeur de chaque clé suivant sa valeur, son nom ou une partie de son nom
//
// ¤ VorteX Compatible ¤
function AbsolutModif( Objet , // ————> L'objet vérifié
Verification , // ————> La valeur de vérification
Valeur , // ————> ¤ La valeur a donner
Type // ————> Le type de vérification ( "Valeur", "Nom" ou "Portion" )
){
// Arguments par défaut
Type = Type || "Valeur";
Valeur = Valeur || null;
// Pour chaque clé de l'objet ——>
for( var iObjet in Objet ){
// Levier de vérification
var Levier = false;
// Si la vérification se fait par Valeur et que la clé équivaux à la vérification ——>
if( Type == "Valeur" && Objet[ iObjet ] == Verification ){
//
// Active le levier
Levier = true;
}
// Si la vérification se fait par Nom et que la clé se nomme comme la vérification ——>
else if( Type == "Nom" && iObjet == Verification ){
//
// Active le levier
Levier = true;
}
// Si la vérification se fait par Valeur et que le nom de la clé possède la vérification ——>
else if( Type == "Portion" && FindIn( iObjet , Verification ) ){
//
// Active le levier
Levier = true;
}
// Si le levier est active ——>
if( Levier ){
// Modifie la valeur de la clé
Objet[ iObjet ] = MathOperator( Objet[ iObjet ] , Valeur );
}
// Si la clé est un objet ——>
if( TypeOf( Objet[ iObjet ] , "Object" ) ){
// Relance l'AbsolutModif sur elle
AbsolutModif( Objet[ iObjet ] , Verification , Valeur , Type );
}
}
}
// —————— MASSIVE KEY
// Pour tout les éléments d'un objet, ajoute un nouvel élément du nom choisis et de la valeur choisie
//
// ¤ VorteX Compatible ¤
function MassiveKey( Objet , // ————> L'objet vérifié
Nom , // ————> Nom de la clé
Valeur // ————> ¤ La valeur a donner
){
// Ajoute la clé à l'objet ——>
Objet[ Nom ] = Aspiration( Valeur );
// Pour chaque clé de l'objet ——>
for( var iObjet in Objet ){
// S'il s'agit d'un objet ——> Poursuit le Massive Key dessus
if( TypeOf( Objet[ iObjet ] , "Object" ) ){
//
MassiveKey( Objet[ iObjet ] , Nom , Valeur );
}
}
}
// —————— PUSH OBJECT
// Ajoute une clé d'un nom suivis d'un chiffre suivant les clé précédent possèdant déjà ce nom.
// Retourne ensuite le nom de la clé
//
// ¤ VorteX Compatible ¤
function PushObject( Objet , // ————> L'objet vérifié
Nom , // ————> Nom de la clé
Valeur // ————> ¤ La valeur a donner à la clé
){
// Compile le nom de la clé
Nom += "1";
// Tans que la clé existe déjà ——>
while( Objet[ Nom ] ){
//
// Fait avancer le nom dans les chiffres
Nom = PasteString( Nom );
}
// Créait la clé
Objet[ Nom ] = Aspiration( Valeur );
// Retourne le nom de la clé
return Nom;
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* FUNCTION */
/* Méthodes basé sur les fonctions. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— LAUNCH
// Lance une méthode donnée à partir de son nom, un objet ou un ensemble de code
function Launch( Fonction , // ————> La fonction, code ou objet de fonction
ArgumentsSupplantes , // ————> Les argument supplantés ( Mis avant les autres )
ArgumentsAdditifs // ————> Les arguments additifs ( Mis après les autres )
){
// Encapsule les arguments supplantés et additifs
if( ArgumentsSupplantes && typeof ArgumentsSupplantes != "object" ){ ArgumentsSupplantes = [ ArgumentsSupplantes ]; }
if( ArgumentsAdditifs && typeof ArgumentsAdditifs != "object" ){ ArgumentsAdditifs = [ ArgumentsAdditifs ]; }
// Définit la fonction à lancer
var FonctionLaunch;
var ArgumentLaunch;
var ArgumentsLaunch;
// Si la fonction est directement une fonction ——> La récupère pour la lancer
if( typeof Fonction == "function" ){
//
FonctionLaunch = Fonction;
// S'il s'agit d'un objet ——> Récupère la fonction et les éléments
} else if( typeof Fonction == "object" ){
// Récupère les arguments
ArgumentLaunch = Fonction.Argument;
ArgumentsLaunch = Fonction.Arguments;
// Si elle contient une clé "fonction" ——>
if( Fonction.Fonction ){
// Si sa fonction est un string ——>
if( typeof Fonction.Fonction == "string" ){
// Si elle contient une cible ——>
if( Fonction.Cible ){
// Récupère la fonction
FonctionLaunch = Fonction.Cible[ Fonction.Fonction ];
// Sinon ——> depuis sa racine
} else {
//
FonctionLaunch = this[ Fonction.Fonction ];
}
// Si sa fonction est une fonction ——>
} else if( typeof Fonction.Fonction == "function" ){
// La récupère
FonctionLaunch = Fonction.Fonction;
// Si sa fonction est autre chose ——>
} else {
//
// Trace l'erreur
TraceErreur( "MiscTools" , "Launch" , [ "La clé \"Fonction\" ne peut pas être interprété correctement." , "Elle doit être un String ou bien un lien de fonction." ] );
}
// Si elle ne contient aucune clé "fonction" ——>
} else {
//
// Trace l'erreur
TraceErreur( "MiscTools" , "Launch" , "La clé \"Fonction\" ne se trouve pas dans l'objet Launch." );
}
// S'il s'agit d'un code ——> Lance le code et brise la fonction
} else if( typeof Fonction == "string" ){
// Vérifie qu'elle contient au moins un espace
if( Fonction.split( " " ).length >= 2 ){
//
eval( Fonction );
//
FonctionLaunch = "";
// Si elle ne contient aucun espace ——> La convertie en fonction
} else {
//
FonctionLaunch = this[ Fonction ];
}
}
// Si la fonction à lancée n'est pas vide ——>
if( FonctionLaunch != "" ){
// Convertie les arguments
var ArgumentsDeFonction = ( ArgumentLaunch != null ) ? [ ArgumentLaunch ] : ArgumentsLaunch;
// Ajoute les arguments supplantés et additifs
ArgumentsDeFonction = ( ArgumentsSupplantes != null || ArgumentsAdditifs != null ) ? ( ArgumentsDeFonction || new Array() ) : ArgumentsDeFonction;
//
// Supplantés ——>
if( ArgumentsSupplantes ){
//
for( var iSup = 0 ; iSup < ArgumentsSupplantes.length ; iSup++ ){
//
ArgumentsDeFonction.unshift( ArgumentsSupplantes[ iSup ] );
}
}
//
// Additifs ——>
if( ArgumentsAdditifs ){
//
for( var iAdd = 0 ; iAdd < ArgumentsAdditifs.length ; iAdd++ ){
//
ArgumentsDeFonction.push( ArgumentsAdditifs[ iAdd ] );
}
}
// Essaye de lancer la fonction suivant la demande d'arguments
try {
// S'il y a des arguments ——>
if( ArgumentsDeFonction ){
// Suivant leur nombre ——> Lance la fonction avec ce nombre ( 10 Max )
switch( ArgumentsDeFonction.length ){
//
case 1:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] );
break;
//
case 2:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] );
break;
//
case 3:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] );
break;
//
case 4:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] );
break;
//
case 5:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] );
break;
//
case 6:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] , ArgumentsDeFonction[ 5 ] );
break;
//
case 7:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] , ArgumentsDeFonction[ 5 ] ,
ArgumentsDeFonction[ 6 ] );
break;
//
case 8:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] , ArgumentsDeFonction[ 5 ] ,
ArgumentsDeFonction[ 6 ] , ArgumentsDeFonction[ 7 ] );
break;
//
case 9:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] , ArgumentsDeFonction[ 5 ] ,
ArgumentsDeFonction[ 6 ] , ArgumentsDeFonction[ 7 ] , ArgumentsDeFonction[ 8 ] );
break;
//
case 10:
//
FonctionLaunch( ArgumentsDeFonction[ 0 ] , ArgumentsDeFonction[ 1 ] , ArgumentsDeFonction[ 2 ] ,
ArgumentsDeFonction[ 3 ] , ArgumentsDeFonction[ 4 ] , ArgumentsDeFonction[ 5 ] ,
ArgumentsDeFonction[ 6 ] , ArgumentsDeFonction[ 7 ] , ArgumentsDeFonction[ 8 ] ,
ArgumentsDeFonction[ 9 ] );
break;
}
// S'il n'y a pas d'argument
} else { FonctionLaunch(); }
// Si échoue ——> Trace l'erreur
} catch( e ){
//
TraceErreur( "MiscTools" , "Launch" , "La fonction \"" + Fonction + "\" n'a pas pus être lancée." );
}
}
}
// —————— FULL LAUNCH
// Lance un ensemble de fonction simplement agencée à la suite dans un tableau
function FullLaunch( Tableau , // ————> Le tableau des fonctions
ArgumentsSupplantes , // ————> Les argument supplantés
ArgumentsAdditifs // ————> Les arguments additifs
){
// Pour chaque fonctions ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// Lance la fonction Launch
Launch( Tableau[ iTableau ] , ArgumentsSupplantes , ArgumentsAdditifs );
}
}
// —————— INSTANT
// Lance un compte à rebours en frame, une fonction est lancée en boucle jusqu'à ce que ce compte à rebours atteigne zéro
function Instant( Fonction , // ————> La fonction lancée
Duree // ————> La durée en "frame"
){
// Créait un objet support de cette fonction
var ObjetSupport = new Object();
// Lui donne sa fonction
ObjetSupport.Fonction = function( event ){
// Lance la fonction
Launch( Fonction );
// Décroit
Duree--;
// Si a atteint zéro ——> Retire la boucle
if( Duree <= 0 ){ RemoveEvents( ObjetSupport , "BoucleInstant" ); }
}
// Donne l'événement
AddEvents( ObjetSupport , [ "ENTER_FRAME" , "BoucleInstant" , ObjetSupport.Fonction ] );
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* ELEMENTS */
/* Méthodes basé sur les éléments spécifiques. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— $ DOLLAR
// Racourcie de getElementById pour récupérer le lien vers une balise Div.
function $( Element ){
//
return document.getElementById( Element );
}
// —————— GET STYLE
// Retourne la valeur d'un style d'une balise ayant un ID.
//
// Attention :
// Le retournement de valeur de style ne fonctionne que pour des style placés
// dynamiquement, autrement dit, il ne retournera pas les styles donné via CSS.
//
// IE Comp.
function GetStyle( Element , // ————> ID de l'élément
Style // ————> Nom du style à retourner
){
// Récupération de l'instance de l'élément
if( typeof( Element ) == "string" ){
//
var element = $( Element );
} else {
//
var element = Element;
}
// Si on est sous un bon Navigateur ————>
if ( window.getComputedStyle )
// On récupére la valeur du style par le procédé normal
var sortie = window.getComputedStyle( element , null ).getPropertyValue( Style );
// Si on est ( Malheureusement ) sous IE ————>
else if ( element.currentStyle )
// On récupére la valeur du style par le procédé d'IE
var sortie = eval( 'element.currentStyle.' + Style );
// Renvoie de la valeur
return sortie;
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* CONVERSION */
/* Méthodes de conversion d'un type de données vers un autre. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— VARIABLES
// Variables concernant la conversion
// Tableau de conversion Hexadecimal
MiscTools.Hexadecimal = [ "0" , "1" , "2" , "3" , "4" , "5" , "6" , "7" , "8" , "9" , "A" , "B" , "C" , "D" , "E" , "F" ];
// Tableaux de conversion HTML
MiscTools.HTMLCaractereSpeciaux = [ "‚" , "ƒ" , "„" , "…" , "†" , "‡" , "ˆ" , "‰" , "Š" , "‹" , "Œ" , "‘" , "’" ,
"“" , "”" , "•" , "–" , "—" , "˜" , "™" , "š" , "›" , "œ" , "Ÿ" , " " , "¡" ,
"¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , "" , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" ,
"¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Æ" , "Ç" , "È" ,
"É" , "Ê" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" ,
"Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" , "Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" ,
"ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" ,
"ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" ,
"ý" , "þ" , "ÿ" ,
" " , "¡" , "¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" ,
"" , "®" , "&masr;" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" ,
"º" , "»" , "¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" ,
"Å" , "&Aelig" , "Ç" , "È" , "É" , "&Ecric;" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" ,
"Ñ" , "Ò" , "Ó" , "Ô" , "Õ" , "Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" ,
"Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" , "ã" , "ä" , "å" , "æ" , "ç" ,
"è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" , "ð" , "ñ" , "ò" , "ó" ,
"ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" , "ý" , "þ" , "ÿ"
];
//
MiscTools.HTMLCaractereSpeciauxCode = [ "‚" , "ƒ" , "„" , "…" , "†" , "‡" , "ˆ" , "‰" , "Š" , "‹" , "Œ" , "‘" , "’" ,
"“" , "”" , "•" , "–" , "—" , "˜" , "™" , "š" , "›" , "œ" , "Ÿ" , " " , "¡" ,
"¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , " " , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" ,
"¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Å" , "Ç" , "È" ,
"É" , "Ê" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" ,
"Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" , "Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" ,
"ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" ,
"ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" ,
"ý" , "þ" , "ÿ" ,
" " , "¡" , "¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , " " , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" , "¼" , "½" ,
"¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Å" , "Ç" , "È" , "É" , "Ê" , "Ë" , "Ì" ,
"Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" , "Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" ,
"Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" , "ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" ,
"ë" , "ì" , "í" , "î" , "ï" , "ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" ,
"ú" , "û" , "ü" , "ý" , "þ" , "ÿ"
];
// Tableaux de conversion Name
MiscTools.Name = { __POINT__ :"." ,
__GUILL__ :"'" ,
__GUILL2__ :"\"" ,
__MOINS__ :"-" ,
__PLUS__ :"+" ,
__SLASH__ :"/" ,
__MULTI__ :"*" ,
__ASLASH__ :"\\" ,
__POVIR__ :";" ,
__DEUPO__ :":" ,
__SPACE__ :" " ,
__EXCLA__ :"!" ,
__ET__ :"&" ,
__INTER__ :"?" ,
__OUPAR__ :"(" ,
__FEPAR__ :")" ,
__OUCRO__ :"[" ,
__FECRO__ :"]" ,
__OUACC__ :"{" ,
__FEACC__ :"}" };
// Tableaux de conversion Special
MiscTools.SpecialSimple = [ "a" , "b" , "c" , "d" , "e" , "f" , "g" , "h" , "i" , "j" , "k" ,
"l" , "m" , "n" , "o" , "p" , "q" , "r" , "s" , "t" , "u" , "v" ,
"w" , "x" , "y" , "z" ,
"A" , "B" , "C" , "D" , "E" , "F" , "G" , "H" , "I" , "J" , "K" ,
"L" , "M" , "N" , "O" , "P" , "Q" , "R" , "S" , "T" , "U" , "V" ,
"W" , "X" , "Y" , "Z" ,
"1" , "2" , "3" , "4" , "5" , "6" , "7" , "8" , "9" , "0" , "°" , "+" ,
"&" , "é" , "\"" , "'" , "(" , "-" , "è" , "_" , "ç" , "à" , ")" , "=" ,
"#" , "{" , "[" , "|" , "\\" , "^" , "@" , "]" , "}" ,
"$" , "ù" , "*" , "," , ";" , ":" , "!" ,
"¨" , "£" , "%" , "µ" , "?" , "." , "/" , "§" ,
"¤" , " " ,
"â" , "ê" , "î" , "ô" , "û" ,
"ä" , "ë" , "ï" , "ö" , "ü" ,
"Â" , "Ê" , "Î" , "Ô" , "Û" ,
"Ä" , "Ë" , "Ï" , "Ö" , "Ü" ,
"É" , "È" , "À" , "Ç" , "œ"
];
MiscTools.Special = [ "○☺☺☺" , "○☻☻☻" , "○♥♥♥" , "○♦♦♦" , "○♣♣♣" , "○♠♠♠" , "○•••" , "○◘◘◘" , "○•◘•" , "◙" , "○♂♂♂" ,
"○♀♀♀" , "○♪♪♪" , "○♫♫♫" , "☼" , "○►►►" , "○◄◄◄" , "↕" , "‼" , "¶" , "▬" , "↨" ,
"○↑↑↑" , "○↓↓↓" , "→" , "←" ,
"∟" , "↔" , "▲" , "▼" , "╚" , "╔" , "╩" , "╦" , "╠" , "═" , "╬" ,
"ð" , "Ð" , "╝" , "╗" , "║" , "╣" , "©" , "®" , "ƒ" , "¢" , "¥" ,
"┐" , "└" , "┴" , "┬" ,
"├" , "┼" , "ã" , "Ã" , "░" , "▒" , "▓" , "»" , "«" , "┤" , "™" , "Ö" ,
"▄" , "█" , "¦" , "▀" , "ß" , "õ" , "Õ" , "þ" , "Þ" , "¯" , "´" , "±" ,
"‗" , "¾" , "÷" , "¸" , "○☺☺☻" , "·" , "¹" , "²" , "■" ,
"○↑↓↓" , "○↑↑↓" , "○↑↓↑" , "○↓↑↑" , "○↓↓↑" , "○↓↑↓" , "○◄►◄" ,
"○☻☺☺" , "○☻☻☺" , "○☺☻☻" , "○☻☺☻" , "○••◘" , "○•◘◘" , "○◘••" , "○◘◘•" ,
"○◘•◘" , "♦♥♦" ,
"○♥♥♦" , "○♥♦♦" , "○♥♦♥" , "○♦♥♥" , "○♦♦♥" ,
"○♣♣♠" , "○♣♠♠" , "○♣♣♠" , "○♠♣♣" , "○♠♠♣" ,
"○♂♂♀" , "○♂♀♀" , "○♂♀♂" , "○♀♂♂" , "○♀♀♂" ,
"○♪♪♫" , "○♪♫♫" , "○♪♫♪" , "○♫♪♪" , "○♫♫♪" ,
"○►►◄" , "○►◄◄" , "○►◄►" , "○◄►►" , "○◄◄►"
];
// —————— FUSION
// Fusionne plusieurs variables pour en obtenir une nouvelle, mélange des autres.
// Si les variables sont des Nombres, elle les fait s'additionner.
// Si les variables sont des string, elle les fait se concaténer.
// Si les variables sont des boolean, elle retourne true quand elles sont toutes vraies ou false si l'une d'entre elles est fausse.
// Si les variables sont des tableaux, elle créait un nouveau tableau contenant chaque élément de chaque tableau dans l'ordre.
function Fusion(){
// Variable de résultat
var resultat;
// Mise du i (Oui... arguments n'est pas un tableau!...)
var i = 0;
// Tans qu'on trouve des arguments ———>
while( arguments[ i ] != null ){
// Si le premier des arguments est un Object (Array est un Objet) ————>
if( typeof arguments[ 0 ] == "object" ){
// Si on est sur le premier le résultat devient égal au premier tableau mis en chaine de caractère séparé par l'élément de séparation
if( i == 0 ){
resultat = arguments[ i ].join( "!!!getPowerOfFusion!!!" );
// Si on est sur un autre suivant le premier, le résultat rajoute a sa valeur ce tableau mis en chaine de caractère séparé par l'élément de séparation
} else {
resultat += arguments[ i ].join( "!!!getPowerOfFusion!!!" );
}
// Si le suivant éxiste, on ajoute un élément de séparation
if( arguments[ i + 1 ] != null ){
resultat += "!!!getPowerOfFusion!!!";
// Si le suivant n'éxiste pas, on transforme le résultat en tableau suivant ses éléments de séparation
} else { resultat = resultat.split( "!!!getPowerOfFusion!!!" ); }
// Si le premier des arguments est une boolean
} else if( typeof arguments[ 0 ] == "boolean" ){
// Si on est pas tombé sur un false, le résultat se calque sur la variable suivante si elle est une boolean
if( typeof arguments[ i ] == "boolean" && resultat != false ){ resultat = arguments[ i ]; }
// Si le premier des arguments est un String ou un Nombre ————>
} else {
// Si c'est le premier, le résultat est égal à cet argument
if( i == 0 ){ resultat = arguments[ i ]
// Si ce n'est pas le premier, le résultat s'additionne ou se concaténe avec cet élément
} else { resultat += arguments[ i ] }
}
// Augmentation i
i++;
}
// Renvoie le résultat obtenu
return resultat;
}
// —————— HTML TO STRING
// Convertie une chaine Html contenant les caractères spéciaux html en une chaine standard.
function HtmlToString( Chaine ){
// Renvoie la chaine convertie
return( CharacterConversion( Chaine , HTMLCaractereSpeciaux , HTMLCaractereSpeciauxCode ) );
}
// —————— ARRAY TO ELEMENT
// Retourne un élément à partir d'un tableau contenant les noms des occurences jusq'à lui
function ArrayToElement( Tableau , // ————> Tableau du chemin
Racine // ————> Racine de départ
){
// Définit la sortie
var Sortie = Racine || window;
// Pour chaque élément du tableau ——>
for( var iTableau = 0 ; iTableau < Tableau.length ; iTableau++ ){
// S'il existe sur l'élément ——>
if( Sortie[ Tableau[ iTableau ] ] ){
// Le récupère
Sortie = Sortie[ Tableau[ iTableau ] ];
// S'il n'existe pas ——> Trace l'erreur et retourne null
} else {
//
TraceErreur( "MiscTools" , "ArrayToElement" , [ "Le chemin " + Tableau.join( "." ) + " est introuvable." ,
"Il est impossible de détecter \"" + Tableau[ iTableau ] + "\" sur \"" +
( iTableau != 0 ? Tableau[ iTableau - 1 ] : Racine ) + "\"" ] );
//
return null;
}
}
// Retourne le résultat
return Sortie;
}
// —————— STRING TO ELEMENT
// Retourne un élément à partir d'une chaine de caractère
function StringToElement( Chaine , // ————> La chaine de caractère
Racine , // ————> Racine de départ
Separateur // ————> Séparateur s'il ne s'agit pas de points
){
// Arguments par défaut
Separateur = Separateur || ".";
// Retourne la chaine calculer après être compilée en tableau
return ArrayToElement( Chaine.split( Separateur ) , Racine );
}
// —————— ELEMENT TO ARRAY
// Retourne un tableau de nom d'occurence à partir d'un élément
function ElementToArray( Element ){
// Si l'élément a un nom ——>
if( Element.name ){
// Variable de sortie
var Sortie = [ Element.name ];
//
var CurrentElement = Element;
// Tans que l"on trouve un parent ——>
while( Element.parent != null && Element.parent != undefined ){
// Ajoute le nom du parent
Sortie.unshift( Element.parent.name || null );
// Modifie l'élément en cours
CurrentElement = Element.parent;
}
// Renvoie le tout nettoyé
return FreshArray( Sortie );
// Si l'élément n'a aucun parent ——> Trace l'erreur et renvoie un tableau vide
} else {
//
TraceErreur( "MiscTools" , "ElementToArray" , [ "L'élément sondé doit avoir une valeur \"name\"." ,
"Il n'a pas été créé par NewElement()." ,
"Seul les éléments créés par NewElement() peuvent être sondé par ElementToArray()." ] );
//
return [];
}
}
// —————— ELEMENT TO STRING
// Retourne une chaine de caractère de nom d'occurence à partir d'un élément
function ElementToString( Element , // ————> Element concerné
Separateur // ————> Le séparateur s'il n'est pas un point
){
// Arguments par défaut
Separateur = Separateur || ".";
// Retourne la recherche par tableau compilé
return ElementToArray( Element ).join( Separateur );
}
// —————— NUMBER TO HEXA
// Convertie un chiffre de 1 à 15 end hexadecimal
function NumberToHexa( Chaine ){
// Renvoie la valeur
return( MiscTools.Hexadecimal[ Chaine ] );
}
// —————— HEXA TO NUMBER
// Convertie un chiffre hexacimal de 1 à F en nombre
function HexaToNumber( Valeur ){
// Renvoie la valeur
return( IndexOf( MiscTools.Hexadecimal , Valeur ) );
}
// —————— STRING OR NUMBER
// Retourne un string ou un nombre convertie dans le bon typage suivant qu'il peut être interprété comme un nombre ou non
function StringOrNumber( Valeur ){
// Renvoie la valeur suivant sa capacité à être un chiffre
return( isNaN( Number( Valeur ) ) ?
String( Valeur ) :
Number( Valeur ) );
}
// —————— FULL STRING OR NUMBER
// Sonde un objet et applique une conversion en chiffre de toutes les chaine de caractères chiffrées
function FullStringOrNumber( Objet ){
// Pour chaque clé de l'objet ——>
for( var iObjet in Objet ){
// S'il s'agit d'un objet ou tableau ——>
if( TypeOf( Objet[ iObjet ] , "Object" ) || TypeOf( Objet[ iObjet ] , "Array" ) ){
// Poursuit dessus
FullStringOrNumber( Objet[ iObjet ] );
// Sinon, S'il s'agit d'un string ou chiffre ——> Effectue le StringOrNumber
} else if( TypeOf( Objet[ iObjet ] , "String" ) || TypeOf( Objet[ iObjet ] , "Number" ) ){
//
Objet[ iObjet ] = StringOrNumber( Objet[ iObjet ] );
}
}
// Renvoie l'objet
return Objet;
}
// —————— STRING TO NAME
// Convertie une chaine de caractère pour qu'elle soit exploitable en tans qu'élèment nominatif ( Objet, Clip, clé, etc. )
function StringToName( Valeur ){
// Tableaux de compilations
var Remplacement = new Array();
var Speciaux = new Array();
//
// Convertie les tableaux de compilations ——>
for( var iName in MiscTools.Name ){
//
Remplacement.push( iName ) ;
Speciaux.push( MiscTools.Name[ iName ] );
}
// Retourne la valeur convertie
return( CharacterConversion( Valeur , Speciaux , Remplacement ) );
}
// —————— NAME TO STRING
// Convertie une chaine de caractère pré-convertie pour être un élément nominatif en chaine standard
function NameToString( Valeur ){
// Tableaux de compilations
var Remplacement = new Array();
var Speciaux = new Array();
//
// Convertie les tableaux de compilations ——>
for( var iName in MiscTools.Name ){
//
Remplacement.push( iName ) ;
Speciaux.push( MiscTools.Name[ iName ] );
}
// Retourne la valeur convertie
return( CharacterConversion( Valeur , Remplacement , Speciaux ) );
}
// —————— STRING TO SPECIAL
// Convertie une chaine de caractère en remplaçant tout les composants par des caractères spéciaux la rendant indétectable
function StringToSpecial( Valeur ){
// Tableaux de compilations
var Remplacement = new Array();
var Speciaux = new Array();
//
// Convertie les tableaux de compilations ——>
for( var iSpe = 0 ; iSpe < MiscTools.SpecialSimple.length ; iSpe++ ){
//
Remplacement.push( MiscTools.SpecialSimple[ iSpe ] ) ;
Speciaux.push( MiscTools.Special[ iSpe ] );
}
// Retourne la valeur convertie
return( CharacterConversion( Valeur , Remplacement , Speciaux ) );
}
// —————— SPECIAL TO STRING
// Convertie une chaine de caractère issue d'une conversion String2Special afin de retrouver la valeur originelle
function SpecialToString( Valeur ){
// Tableaux de compilations
var Remplacement = new Array();
var Speciaux = new Array();
//
// Convertie les tableaux de compilations ——>
for( var iSpe = 0 ; iSpe < MiscTools.SpecialSimple.length ; iSpe++ ){
//
Remplacement.push( MiscTools.SpecialSimple[ iSpe ] ) ;
Speciaux.push( MiscTools.Special[ iSpe ] );
}
// Retourne la valeur convertie
return( CharacterConversion( Valeur , Speciaux , Remplacement ) );
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* URL */
/* Méthodes basées sur la manipulation de l'adresse URL. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— GET GET
// Récupére un GET de l'addresse URL.
function GetGet(){
// Variables initiales
var Sortie = Object();
// Extraction du lien
var param = window.location.search.slice( 1 , window.location.search.length );
// Sépration des paramètres
var first = param.split( "&" );
// Pour chaque paramètre ————>
for( var i = 0 ; i < first.length ; i++ ){
// Donne la séparation de la chaine du paramètre
second = first[ i ].split( "=" );
// Récupère les valeurs
Sortie[ second[ 0 ] ] = second[ 1 ];
}
// Sortie
return Sortie;
}
// —————— GET LESS
// Retire des gets d'une chaine issue d'un URL.
function GetLess( URL , // ———> L'Url conscerné
ARetirer // ———> tableau des éléments à retirer
){
// Convertie l'URL en string
URL = String( URL );
// Convertie l'élément à retirer s'il est un string
if( typeof ARetirer == "string" ){ ARetirer = [ ARetirer ]; }
// Pour chaque éléments à retirer
for( var i = 0 ; i < ARetirer.length ; i++ ){
// Le retire de l'Url
URL = PopBetween( URL , ARetirer[ i ] , "&" );
}
// S'il reste un "&" à la fin, le retire
if( URL[ URL.length - 1 ] == "&" ){ URL = URL.substr( 0 , URL.length - 1 ); }
// Renvoie l'URL
return URL;
}
// —————— GET ADD
// Ajoute un Get à une chaine URL
function GetAdd( URL , // ———> L'Url conscerné
AAjouter ,// ———> Tableau des éléments à ajouter
Valeurs // ———> Tableau des valeurs des éléments à ajouter
){
// Convertie l'URL en string
URL = String( URL );
// Convertie l'élément à ajouter s'il est un string
if( typeof AAjouter == "string" ){ AAjouter = [ AAjouter ]; }
if( typeof Valeurs == "string" ){ Valeurs = [ Valeurs ]; }
// S'il n'y a pas de point d'interrogation dans l'URL, en ajoute un
var InterrogationInitial = false;
//
if( !FindIn( URL , "?" ) ){
//
URL += "?";
InterrogationInitial = true;
}
// Pour chaque éléments à ajouter
for( var i = 0 ; i < AAjouter.length ; i++ ){
// Si ce n'est pas le tout premier
if( !InterrogationInitial || i != 0 ){ URL += "&"; }
// L'ajoute à l'Url
URL += AAjouter[ i ] + "=" + Valeurs[ i ];
}
// Renvoie l'URL
return URL;
}
// —————— OBJECT GET
// Convertie un objet en chaine de caractère Get
function ObjectGet( Objet , // ———> L'objet concerné
Conversion , // ———> S'il y a une conversion des valeurs
Egale , // ———> L'indice "Egale"
Et // ———> L'indice "Et"
){
// Arguments par défaut
Egale = Egale || "=";
Et = Et || "&";
//
Conversion = ( Conversion == null ) ? true : Conversion;
// Valeur de sortie
var Sortie = "";
// Levier de continuité
var Levier = false;
// Pour chaque élément de l'objet ——>
for( var iObjet in Objet ){
// Ajoute le "Et" si ce n'est pas le premier
Sortie += Levier ? Et : "";
// La compile à la chaine
Sortie += iObjet + Egale + ( Conversion ? StringToName( String( Objet[ iObjet ] ) ) : String( Objet[ iObjet ] ) );
// Active le levier
Levier = true;
}
// Renvoie la chaine
return Sortie;
}
// —————— GET OBJECT
// Convertie un objet en chaine de caractère Get
function GetObject( Chaine , // ———> La chaine Get
Conversion , // ———> S'il y a une déconversion des valeurs
Egale , // ———> L'indice "Egale"
Et // ———> L'indice "Et"
){
// Arguments par défaut
Egale = Egale || "=";
Et = Et || "&";
//
Conversion = ( Conversion == null ) ? true : Conversion;
// Compile la chaine en tableau
Chaine = Chaine.split( Et );
// Valeur de sortie
var Sortie = new Object;
// Pour chaque élément du tableau de chaine ——>
for( var iChaine = 0 ; iChaine < Chaine.length ; iChaine++ ){
// Sépare le nom et la valeur
var Nom = Chaine[ iChaine ].split( Egale )[ 0 ];
var Valeur = Chaine[ iChaine ].split( Egale )[ 1 ];
// Intégre la clé
Sortie[ Nom ] = ( Conversion ) ? NameToString( Valeur ) : Valeur;
}
// Renvoie l'objet
return Sortie;
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* TEXTE */
/* Méthodes basées sur les champs de textes. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— GET SELECTION
// Récupére le contenu d'un texte surligné à la souris par l'utilisateur.
//
// IE Comp.
function GetSelection(){
// Pour FireFox
if( document.selection ){ return( document.selection.createRange().text ); }
// Pour IE...
else{ return( document.getSelection() ); };
}
/* ———————————————————————————————————————————————————————————————————————————————————————— */
/* */
/* TRACE */
/* Méthodes basé sur l'alert. */
/* */
/* ———————————————————————————————————————————————————————————————————————————————————————— */
// —————— VARIABLES
// Variables relative à l'application des traces
//
// Effet du trace
var TraceEffect = "Alert";
// Compteur de Tn
var TraceCompteur = 0;
// Si le silence se fait ou non
var TraceSilence = false;
// —————— CHUT
// Modifie l'état de silence des traces
function Chut( Etat ){
//
TraceSilence = ( Etat == null ) ? true : Etat;
}
// —————— TRACE
// Autre façon de lancer une alert.
// Pour les programmeurs qui jonglent.
function trace( Texte , Type ){
// Si on n'est pas dans le silence ——>
if( !TraceSilence ){
// Argumnts par défaut
Type = Type || "";
// Changement de type si demande
if( Type != "" ){
//
var MemoireTraceEffect = TraceEffect;
//
TraceEffect = Type
}
// Trace en alert ——>
if( TraceEffect == "Alert" ){
//
alert( Texte );
// Trace en titre ——>
} else if( TraceEffect == "Title" ) {
//
document.title = Texte;
// Trace en fonction ——>
} else if( typeof TraceEffect == "function" ) {
//
TraceEffect( Texte );
// Trace en Console ——>
} else if( TraceEffect.JeSuisConsole ) {
//
TraceEffect.Traitement( Texte );
// Trace en innerHTML ——>
} else {
//
TraceEffect.innerHTML += Texte + "
";
}
// Si le type a été changé, le remet par défaut
if( MemoireTraceEffect ){ TraceEffect = MemoireTraceEffect };
}
}
//
function Trace( Texte , Type ){
trace( Texte , Type );
}
// —————— AUTO TRACE
// Suite de méthode simple pour procéder à des traces rapides
//
function T(){ trace( "!" ); }
//
function Tn( Numero ){
//
TraceCompteur = Numero || TraceCompteur;
//
TraceCompteur++;
//
Trace( TraceCompteur );
}
//
function Tr(){ trace( "—————————————————————————————————————————————————————————————————————————" ); }
//
function Td(){ trace( Math.round( Math.random() * 9999999999 ) ); }
// —————— TRACE ENSEMBLE
// Trace un ensemble contenu dans un tableau
function TraceEnsemble( Contenu ){
// Si le mode de trace est en Alert ou Title ——>
if( TraceEffect == "Alert" || TraceEffect == "Title" ){
// Trace le tout fusionné
trace( Contenu.join( " " ) );
// Sinon ——> Trace les uns après les autres
} else {
//
for( var iContenu = 0 ; iContenu < Contenu.length ; iContenu++ ){
//
trace( Contenu[ iContenu ] );
}
}
}
// —————— TRACE OBJECT
// Trace tout le contenue d'un objet en mettant sa structure, ses clés et ses types pour chaque partie
function TraceObject( Objet , // ————> L'objet concerné
Niveau // ————> Le niveau de l'objet ( Ne rien mettre )
){
// Arugments par défaut
Niveau = Niveau || 0;
// Valeur de sortie
var TableauSortie = new Array();
// Pour chaque élément de l'objet ——>
for( var iObjet in Objet ){
// S'il s'agit d'un objet ——>
if( TypeOf( Objet[ iObjet ] , "Object" ) ){
// Ajoute son nom
TableauSortie.push( MultipleString( "———" , Niveau + 1 ) + "( " + iObjet + " ) : " );
// Récupère et fusionne la suite
TableauSortie = Fusion( TableauSortie , TraceObject( Objet[ iObjet ] , Niveau + 1 ) );
// S'il ne s'agit pas d'un objet ——>
} else {
// Récupère sa valeur, type et position
TableauSortie.push( MultipleString( "———" , Niveau ) + "( " + iObjet + " ) : " + "[ " + TypeOf( Objet[ iObjet ] ) + " ] " + Objet[ iObjet ] );
}
}
// Si on est au niveau 1 ou plus ——> Retourne le tableau
if( Niveau >= 1 ){ return TableauSortie; }
//
// Si on est au niveau 0 ——> Trace l'ensemble
else { TraceEnsemble( TableauSortie ); }
}
// —————— TRACE ERREUR
// Affiche un message d'erreur spécifique
function TraceErreur( Classe , // ————> Classe concernée
Fonction , // ————> Fonction concernée
ContenuErreur // ————> Rapport de l'erreur
){
// Encapsule le rapport si ce n'est pas un tableau
if( typeof ContenuErreur != "object" ){ ContenuErreur = [ ContenuErreur ]; }
// Créait la version initial de la sortie
var Sortie = [
"——————————————————————————————————————————————————————" ,
"Erreur dans la fonction " + Fonction + "() de " + Classe
];
// Ajoute le rapport d'erreur
Sortie = Fusion( Sortie , ContenuErreur );
Sortie = Fusion( Sortie , [ "——————————————————————————————————————————————————————" ] );
// Envoie le tout
TraceEnsemble( Sortie );
}
// —————— TRACE IF NOT BE
// Sonde un élément et sort une erreur s'il n'est pas du type voulu, sinon, renvoie true
function TraceIfNotBe( Element , // ————> L'élément sondé
Types , // ————> Le ou les types recherchés
Classe , // ————> Classe concernée
Fonction , // ————> Fonction concernée
NomElement // ————> Nom de l'élément sondé
){
// Encapsule les types
Types = CapsuleArray( Types );
// Levier de vérification
var Levier = false;
// Pour chaque types à vérifier ——>
for( var iTypes = 0 ; iTypes < Types.length ; iTypes++ ){
// S'il est du type voulu ——> Active le levier
if( TypeOf( Element , Types[ iTypes ] ) ){
//
Levier = true;
}
}
// Si le levier n'a pas été activé ——> Trace l'erreur
TraceErreur( Classe , Fonction , "L'élément " + NomElement + " doit être de type " + Types + "." );
// Retourne l'activation
return Levier;
}
// —————— TRACE IF NOT KEY
// Sonde un objet et en retourne une erreur si une clé est manquante, sinon, renvoie true
function TraceIfNotKey( Objet , // ————> L'objet sondé
Clees , // ————> Le ou les clées recherchées
Classe , // ————> Classe concernée
Fonction , // ————> Fonction concernée
NomObjet // ————> Nom de l'objet sondé
){
// Encapsule les clées
Clees = CapsuleArray( Clees );
// Clées fausses
var FausseClees = new Array();
// Tans qu'il reste des clées ——>
while( Clees.length > 0 ){
// Si la clée en cours n'existe pas sur l'objet ——> L'enregistre comme fausse
if( Objet[ Clees[ 0 ] ] == null || Objet[ Clees[ 0 ] ] == undefined ){ FausseClees.push( Clees[ 0 ] ); }
// Retire la clée
Clees.splice( 0 , 1 );
}
// S'il y a des clées fausse ——>
if( FausseClees.length > 0 ){
// Trace l'erreur
TraceErreur( Classe , Fonction , "L'objet " + NomObjet + " ne possède pas " + ( FausseClees.length > 1 ? "les clées" : "la clée" ) + " " + FausseClees + "." );
// Retourne l'echec
return false;
}
// Retourne la réussite
return true;
}
// —————— TRACE OBSOLETE
// Affiche un message spécifique montrant les fonctions archaïques ( Cross-Link ) utilisés à mauvais escient
function TraceObsolete(){
// Tableau de sortie
var Sortie = [ "Vous avez utilisé " + LengthObject( MiscTools.CrossLink ) + " Fonctions Obsolétes :" ];
// Pour chaque fonction Cross-Link utilisées
for( var iCrossLink in MiscTools.CrossLink ){
// L'ajoute au tableau avec son nombre d'utilisation
Sortie.push( MiscTools.CrossLink[ iCrossLink ] + " : " + iCrossLink + " → Utilisez plutôt \"" + MiscTools.CrossLinkList[ iCrossLink ] + "\"" );
}
// Envoie le tout
TraceEnsemble( Sortie );
}
// —————— CRASH
// Fonction pour faire crasher automatiquement le code en cours
// Attention toutefois, cette méthode ne fonctionne pas si elle est éxécutée dans un milieu entre code try{}
function Crash(){
//
Erreur_Volontaire_par_Crash;
}
/* ———————————————————————————————————————————————————— MiscTools - cybORg ———————————————————————————————————————————————————————————— */