Présentation d'ECMAScript for XML (E4X) avec Rhino

js> print("Hello World");

function citationAlea()
{
    var citAlea=new Array(); // creation d'un tableau
    var indiceCitAlea;
    citAlea[0]= "La peur d\'un nom ne fait qu\'accroitre la peur de la chose elle-même. [ J. K. Rowling ]";
    citAlea[1]= "Pour un esprit equilibre, la mort n\'est qu\'une grande aventure de plus. [ J. K. Rowling ]";
    citAlea[2]= "Les humains ont un don pour desirer ce qui leur fait le plus de mal. [ J. K. Rowling ]";

    indiceCitAlea = parseInt(Math.round(Math.random() * (citAlea.length-1)));
    print(citAlea[indiceCitAlea]);
}

js> load("citationAleatoire.js");
js> citationAlea(); //Appel de la fonction définie dans citationAleatoire.js

js> load("../citationAleatoire.js");
js> citationAlea(); //Appel de la fonction définie dans citationAleatoire.js

function generateurVolontaires()
{
    /* Création et initialisation de nos variables
        liste_personnes est le tableau contenant notre liste de volontaires potentiels
        indice_liste est l'indice de l'élément que nous allons "tirer" aléatoirement dans la liste */
    var liste_personnes=new Array();
    var indice_liste = 0;
    liste_personnes[0]= "Terieur Alain";
    liste_personnes[1]= "Terieur Alex";
    liste_personnes[2]= "Fonsec Sophie";
    liste_personnes[3]= "Zeblouse Agathe";
    liste_personnes[4]= "Zepower Agathe";
    liste_personnes[5]= "Naimarre Jean";
    liste_personnes[6]= "Naigrossurlapatate Jean";    
 
    /* Choix au hasard  d'un élément de la liste, en générant une valeur d'indice entre 0 et la taille du tableau de personnes
        Rappel : en JavaScript comme en C, C++, PHP et Java, les indices d'un tableau de 
        taille n vont de 0 à n-1 Math.random() génère un nombre réel entre 0 et 1 (non compris)
        On génère ensuite un nombre entre 0 et la taille du tableau-1 (non compris)
        La fonction round nous permet d'avoir un nombre réel entre 0 et la taille du tableau-1 (inclus cette fois)
        le parseInt permet de convertir notre nombre réel en entier.*/
    
    indice_liste = parseInt(Math.round(Math.random() * (liste_personnes.length-1)));
    /* Affichage de l'élément sélectionné */
    print(liste_personnes[indice_liste]);
}

js> load("generateurVolontaires.js");
js> generateurVolontaires();

/* Tout d'abord il nous faut importer les packages Java adéquats :
    java.awt
    java.awt.event
    avec la commande importPackage()
*/
importPackage(java.awt);
importPackage(java.awt.event);
        
/* Juste une fonction JavaScript qui réalise un affichage de la date courante */
function displayDate () {
    print(new Date());
}
        
/* La fonction "JavaScript" qui créée et affiche la frame */
function createAndDisplayFrame() {

    /* Création d'un objet Frame (java.awt.Frame)
        On passe en paramètre du constructeur le titre de la Frame */
    var frame = new Frame("A Java Frame in JavaScript");

    /* On manipule notre objet Java Frame : on fixe sa taille
        L'objet Dimension est également un objet Java */
    frame.setSize(new Dimension(200,100));

    /* Création de 2 boutons (java.awtButton) */
    var button_date = new Button("Date");
    var button_quit = new Button("Quit");
    
    /* On ajoute un gestionnaire de disposition à la Frame */
    frame.setLayout(new FlowLayout());
    
    /* On ajoute les deux boutons à la Frame */
    frame.add(button_date);
    frame.add(button_quit);
    
    /* On crée deux objets (JavaScript) qui seront appelés lors de l'appui sur les boutons 
        On notera le nom de la propriété des objets : actionPerformed qui correspond
        au nom de la méthode correspondante que doit implémenter un écouteur d'événements
        ActionEvent (click sur bouton).
        La propriété actionPerformed est associé aux méthodes JavaScript displayDate et quit */ 
    var handler_date = {actionPerformed: displayDate};
    var handler_quit  = {actionPerformed: quit};
    
    /* On crée nos écouteurs d'événements à partir des objets avec la propriété actionPerformed
        et à partir de l'interface Java ActionListener (java.awt.event.ActionListener) */
    var buttonDateListener = ActionListener(handler_date);
    var buttonQuitListener = ActionListener(handler_quit);
                        
    /* On associe ces écouteurs aux boutons correspondants */
    button_date.addActionListener(buttonDateListener);
    button_quit.addActionListener(buttonQuitListener);
    
    /* Très important : ne pas oublier de rendre la fenêtre "visible" ! Par défaut elle ne l'est pas !*/
    frame.setVisible(true);
}//Fin de la fonction createAndDisplayFrame()

<?xml version='1.0' encoding='iso-8859-1'?>
<note>
    <date>29 mai 2005</date>
    <to>Agathe Zeblouse</to>
    <from>Agathe Zepoheure</from>
    <heading>Message important</heading>
    <body>King Kong contre Sauron vient de sortir au cinema</body>
</note>

function afficherMessage()
{
    /* Chargement du fichier XML : readFile retourne une chaine de caractères 
        correspondant au contenu du fichier qui lui est passé en paramètre.
        Cette chaine de caractère est stockée dans la variable note */
    var note = readFile("note.xml");
    /* new XML(note) créer un objet XML en JavaScript à partir de la chaine de caractères
        qui lui est passé en paramètre. */
    var xmlDoc=new XML(note);
    /* typeof retourne le type son paramètre : ici xml */
    print("type de la variable xmlDoc : " + typeof(xmlDoc) + "\n");
    print("Affichage grace a E4X\n");
    /* A partir d'une syntaxe simple, on a accès à tous les éléments du 
        document XML à partir de la racine du document
        xmlDoc.date permet ainsi d'accéder à la valeur contenue dans l'élément 
        date de la racine note */
    print("xmlDoc.date : \n" + xmlDoc.date + "\n");
    print("xmlDoc.to : \n" + xmlDoc.to + "\n");
    print("xmlDoc.from : \n" + xmlDoc.from + "\n");
    print("xmlDoc.heading : \n" + xmlDoc.heading + "\n");
    print("xmlDoc.body : \n" + xmlDoc.body + "\n");
    print("\nFin du programme\n");
}

js> load("note.js");
js> afficherMessage();

var xmlDoc=new XML(note);

<?xml version='1.0' encoding='iso-8859-1'?>
<note>
    <date>29 mai 2005</date>
    <to>
        <prenom>Agathe</prenom>
        <nom>Zeblouse</nom>
    </to>
    <from>
        <prenom>Agathe</prenom>
        <nom>Zepoheure</nom>
    </from>
    <heading>Message important</heading>
    <body>Les XMen 3 viennent de sortir au cinema</body>
</note>

function afficherMessage_2()
{
    var note = readFile("note.xml");
    var xmlDoc=new XML(note);
    print("type de la variable xmlDoc : " + typeof(xmlDoc) + "\n");
    print("Affichage grace a E4X\n");
    print("xmlDoc.date : \n" + xmlDoc.date + "\n");
    print("xmlDoc.to : \n");
    /* xmldoc.to.prenom permet d'accéder au contenu de l'élément <prenom>  qui est défini
        dans l'élément <to> lui-même défini dans l'élément racine <note> */
    print(">>>> prenom : " + xmlDoc.to.prenom + "\n");
    print(">>>> nom : " + xmlDoc.to.nom + "\n");
    print("xmlDoc.from : \n" + xmlDoc.from + "\n");
    print(">>>> prenom : " + xmlDoc.from.prenom + "\n");
    print(">>>> nom : " + xmlDoc.from.nom + "\n");
    print("xmlDoc.heading : \n" + xmlDoc.heading + "\n");
    print("xmlDoc.body : \n" + xmlDoc.body + "\n");
    print("\nFin du programme\n");
}

<?xml version="1.0" encoding="ISO-8859-1"?>
<personnes>
    <personne>
        <nom>Terieur</nom>
        <prenom>Alex</prenom>
    </personne>
    <personne>
        <nom>Terieur</nom>
        <prenom>Alain</prenom>
    </personne>
    <personne>
        <nom>Zeblouse</nom>
        <prenom>Agathe</prenom>
    </personne>
    <personne>
        <nom>Fonsec</nom>
        <prenom>Sophie</prenom>
    </personne>
    <personne>
        <nom>Naigrosurlapatate</nom>
        <prenom>Jean</prenom>
    </personne>
</personnes>

function afficher_personnes()
{
    var personnes = readFile("personnes.xml");
    var xmlDoc=new XML(personnes);
    var count = 0;
    for each (var i in xmlDoc.personne)
    {
        count ++;
        print(" - Personne numero " + count + " est : \n");
        print("   >>> Prenom : " + i.prenom + "\n");
        print("   >>> Nom : " + i.nom + "\n");
    }
    print("\n --- nombre d'elements dans l'objet personnes : " + count + " --- \n");
    print("\nFin du programme\n");
}

<?xml version="1.0" encoding="ISO-8859-1"?>
<citations>
    <citation>
        <texte>La peur d'un nom ne fait qu'accroitre la peur de la chose elle-même</texte>
        <auteur>J. K. Rowling</auteur>
    </citation>
    <citation>
        <texte>Pour un esprit équilibre, la mort n'est qu'une grande aventure de plus.</texte>
        <auteur>J. K. Rowling</auteur>
    </citation>
    <citation>
        <texte>Les humains ont un don pour désirer ce qui leur fait le plus de mal.</texte>
        <auteur>J. K. Rowling</auteur>
    </citation>
    <citation>
        <texte>Ce sont nos choix qui montrent ce que nous sommes vraiment, beaucoup plus que nos aptitudes.</texte>
        <auteur>J. K. Rowling</auteur>
    </citation>
    <citation>
        <texte>Je ne suis pas d'une beauté suprême. Mais faut pas s'fier a ce qu'on voit.</texte>
        <auteur>J. K. Rowling</auteur>
    </citation>
</citations>

function citationAleaXML()
{
    var chaine = readFile("citations.xml");
    var citAlea=new XML(chaine);
    var indiceCitAlea = 1;
 
    var count = 0;
    for each (var i in citAlea.citation)
    {
        /* On "parcourt" l'objet pour comptabiliser le nombre de citations
            Afin d'avoir la borne haute pour la génération de notre nombre aléatoire */ 
        count ++;
    }
 
    /* Même principe que dans la première version du premier "générateur" de citation aléatoire */
    indiceCitAlea = parseInt(Math.round(Math.random() * (count -1)));
 
    /* il y a plusieurs balises <citation> dans le document XML (5 dans notre exemple)
        donc au lieu d'avoir une propriété, nous avons un tableau de propriétés
        Pour accéder à l'une des citations en particulier, on précise un indice à ce tableau */
    print(citAlea.citation[indiceCitAlea].texte + " - " + citAlea.citation[indiceCitAlea].auteur);
}