RAPPEL : avec un simple clic-droit, le source JS des instructions cliquables peut être récupéré dans la mémoire à instructions.

Tiroir du brouillon (effacer ("le brouillon"))

Tiroir du docapp interne

On voit la flèche déplaçable On voit la mémoire à instructions On a calé le brouillon On a calé le docapp interne Mode strict pour les scripts éditables
On voit le surligneur Filtre du tableau :

le surligneur

On peut surligner (tout ('td') .du ("tableau des instructions") .vérifiant ("x .contient (le .texte)")) suivant : ; le surlignement a une durée = 15 secondes, le temps pour le lecteur de trouver ce qu'il cherche (à la fin remet en état les éventuelles instructions cliquables malmenées).

Étudier l'ILO française d'AlgoDok

Terrain d'expérimentation et exemple de mise à jour d'un IFRAME

mettre .à .jour ("le docapp interne") .avec (le .contenu .du ("code à modifier"))

Objectifs

Ce document applicatif est a priori destiné aux développeurs de modules en Javascript (avec ou sans ILO), ayant une certaine habitude des instructions linguistiques. Il est donc à la fois exhaustif et synthétique.

Néanmoins, comme il comporte de nombreux exemples, il peut aussi servir au débutant voulant rapidement avoir une idée de l'ensemble des possibilités d'AlgoDok, afin de créer rapidement les instructions cliquables (exemple : déplacer ("la console") .à ("24cm" , "200px")), les actionneurs (exemple : ), et les boutons (exemple : la console) qui lui permettront d'apporter une dynamique à ses documents, sans pour autant connaître le langage Javascript. Le lecteur peut aussi directement aller .au ("tableau des instructions") et s'exercer directement dans un environnement adapté.

Variables Globales

Pour des raisons philosophiques expliquées dans la documentation générale, avec l'usage de l'élément var, AlgoDok fait un usage raisonné des variables globales, simples propriétés de l'objet global window : un peu moins de 100 pour la partie extra-linguistique d'AlgoDok et un peu moins de 100 pour l'interface linguistique opérationnelle, sachant que l'objet window contient initialement de l'ordre de 600 à 700 propriétés/variables globales (selon les navigateurs). D'autre part AlgoDok utilise deux objets espaces de noms : AlgoDok pour le paramétrage linguistique, c'est à dire une adaptation au vocabulaire et à la grammaire de la langue de travail, et $AD pour un éventuel complément de mémorisation d'états internes, réservé a priori au développeur d'AlgoDok.

On peut étudier l'ensemble de ces variables globales, énumérables (en vert ou rouge pour les VG extra-linguistique) ou non (en noir), juste après le chargement d'AlgoDok.

Par principe, Javascript fait en sorte qu'au chargement du document tout identifiant d'élément soit pris comme nom d'une une variable globale, devenant ainsi une propriété de l'objet window, mais non énumérable comme on peut le constater avec l'élément identifié par "i1" : alerter("<tt>i1</tt> propriété de window et référence d'élément ? " + (i1 == élément("i1"))) alerter("mais <tt>i1</tt> propriété énumérable de window ? " + (Object.keys(window).indexOf("i1") >= 0)) .

Variables globales à caractère Mathématique

En Javascript, les fonctions mathématiques sont acessibles via l'objet Math, ce qui alourdit l'écriture des expressions usuelles dès qu'on les utilise abondamment. Pour cette raison, AlgoDok définit aussi la plupart d'entre elles comme variables globales. On a fait de même pour les nombres π et e : afficher(PI, "2s"), afficher(E, "2s").

Ainsi on peut directement utiliser les fonctions suivantes : sin, cos, tan, asin, acos, atan, sqrt, round, exp, floor, ceil, abs, random, min, max, cbrt et sign ; par exemple : afficher ( tan(3*PI/4) , "2s"). On a ajouté cubrt comme synonyme de cbrt, gcd(a,b) (greatest common divisor) pour le plus grand diviseur commun de deux entiers, et NOT = not comme fonction de négation d'un booléen.

Pour la cohérence de l'ensemble, on a renommé certaines fonctions plus conformément aux usages anglo-saxons en Mathématiques : ln pour le logarithme népérien, Arg = arg pour l'argument principal d'un nombre complexe vu comme un couple (x,y), par exemple afficher( 180/PI * arg(-1,1) , "2s"), et norm pour la norme euclidienne d'un vecteur vu comme un n-uplet, par exemple : afficher( norm(-1, 2, -3, 4, 5, 3) , "2s").

Enfin on a ajouté la fonction de deux variables gcd(a,b) (greatest common divisor) pour le plus grand diviseur commun de deux entiers, et aussi NOT = not comme fonction de négation d'un booléen. Elles ne sont pas dans l'objet Math standard.

Les noms des fonctions mathématiques usuelles étant pratiquement internationaux, ils n'ont pas été traduits, d'autant plus qu'en Javascript on peut définir des synonymes via de simples affectations ; par exemple : pgcd = gcd ; afficher( pgcd (2016,2018) ).

Comme π est nettement plus souvent utilisé que e dans la pratique, on a aussi le synonyme pi = PI. De plus la variable locale e étant presque toujours utilisée ici comme désignant un élément, il est préférable de ne pas avoir de variable globale éponyme.

Paramètres à géométrie variables

L'interface linguistique opérationnelle (ILO) ayant principalement pour objectif de définir une passerelle linguistique entre des développeurs chevronnés (qui manipulent facilement les fonctions de plusieurs variables et donc parlent un langage spécifique et hermétique pour le commun des mortels, voire même pour leurs pairs) et des concepteurs de documents (qui peuvent ne rien connaître à la programmation mais a priori connaissent bien leur langue maternelle) le paramètre privilégié des fonctions d'AlgoDok est e, pour désigner un des éléments composant le document, objet d'une instruction linguistique vue comme une injonction à l'impératif.

Ainsi, en général, le paramètre e peut être indifféremment un objet du DOM (classe Element) ou son identifiant s'il en a un. Le passage par identifiant prend en théorie un plus de temps à l'exécution que par objet, mais dans la pratique il n'y a pas de différence sensible, comme on peut le constater avec le script ci-dessous (le script du préliminaire) où la première boucle effectue 1 million de recherches d'un élément, dans un algorithme conçu pour déjouer toute éventuelle optimisation de compilation du source JS. On note que d'autres processus sont actifs, y compris lors de l'exécution de ce script.

On peut reprendre le test avec i1 car en Javascript tout identifiant d'élément est initialement pris comme une variable globale : i1 = élément("i1") ; la différence de vitesse d'exécution est imperceptible.

La notation (···) indique qu'un paramètre peut être un élément, une liste d'éléments ou un tableau d'éléments, donc en particulier le résultat d'une requête avec éléments ou tout/toute. Par exemple on peut cacher ( les.éléments ('h3') .du ("préliminaire") ), montrer ( les.éléments ('h3') .du ("préliminaire") ) ou encore afficher (le .nombre .de (toutes .les ('instructions cliquables') .du (document))).

Une propriété de contenance circonstanciée

Pour faciliter les requêtes internes et les exemples, AlgoDok définit un test de contenance textuelle (text content), via la propriété contient, que l'on peut surcharger, comme sur l'exemple suivant :
Lecteur averti peut donc, pour ce docapp, la redéfinir ci-dessus à tout instant, en notant que this.textContent est le contenu textuel dépouillé de toute balise, contrairement à contenu(this).

Espacements particuliers

Rappelons qu'en Javascript . et ( ) sont des opérateurs, le premier étant appliquable à tout objet, le second uniquement aux fonctions. On peut donc les entourer d'espaces séparateurs, mais pour différencier la syntaxe usuelle de celle des instructions linguistiques on colle de préférence le point à la gauche des mots qui suivent le verbe d'action.

Pour gagner de la place, il vaut mieux cacher ("le préliminaire").

On note qu'afin de pouvoir avoir des phrases lisibles en français, toute instruction linguistique de l'ILO étant une variable globale, elle peut être précédée de un, une, le, la, les et l car AlgoDok définit des variables globales éponymes, synonymes de l'objet global window.

On note aussi que pour les fonctions/instructions suivantes, on peut utiliser une variante plus linguistique avec .de, .du ou .des : arrondi, arrondi.entier, classe, clone, cloner.au.début, conteneur, contenu, contenu.JS, contenu.numérique, contraire, créer.au.début, dimensions, écrire.au.début, élément.prédécesseur, élément.successeur, éléments.de, insérer.au.début, mettre.au.début, partie.décimale, partie.entière, position, prédécesseur, sémantique, successeur, tout(···), toute(···), tous.les(···), toutes.les(···), valeur, et valeur.numérique.

Exemple : commuter (toutes .les ('fondamentales') .du ("tableau des instructions")) .sur ('invisible'), ce qui est équivalent à commuter (toutes .les ('fondamentales') .de ("le tableau des instructions")) .sur ('invisible'). D'où l'importance de mettre des identifiants conçus grammaticalement avec un article défini, car ce sont les seuls qui permettent une syntaxe des instructions en langage naturel, en ajoutant bien sûr les délimiteurs syntaxiques indispensables au Javascript.