Tiroir du brouillon (
Tiroir du docapp interne
le surligneur
On peut
←
→
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 :
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" :
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 :
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 :
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
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 :
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.
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
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).
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
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 :
activer(···) ; actionner = activer ; | pour cliquer virtuellement(i.e en JS) sur des éléments cliquables (comme un lien ou tout élément ayant un attribut onclick). |
actualiser (···) ; | pour modifier tout élément dont l'identifiant est aussi le nom d'une variable globale ;
par exemple en utilisant la variable globale suivante :
|
afficher = alerter | fonction basique (synonyme d'alerter)
d'affichage destinée à être redéfinie ; par exemple on peut d'abord
|
alerter(t) ; alerter(t,d) ; | t : texte HTML ou objet quelconque ; d (optionel) : durée d'affichage (nombre en secondes ou nombre avec unité, comme "0.3min" ou "4s" ) ; par défaut d vaut AlgoDok.legtempo. |
aller .à (e) ; aller .au (e) | e : élément quelconque ; permet de placer le texte en lecture à l'endroit indiqué ;
par exemple : |
appliquer (f) .à (t) ; | f : fonction (Function) ou nom d'une fonction, ou encore
expression définissant une fonction de la variable x ; t : tableau (Array) ;
utilisé souvent en même temps qu'une requête avec éléments
ou tout (tous.les, toutes.les) comme
|
appliquer (f) .aux (t) ; | variante de ce qui précède ; on peut aussi enchaîner avec
appliquer (f) .aux (...) .et .à (...) ;
par exemple : |
arrêter (p) ; | pour arrêter un processus de numéro p retourné par la fonction exécution. |
arrondi.entier(x) ; | retourne un Number : synonyme de la fonction round ;
exemple : |
arrondi(x).avec(n).chiffres ; | retourne une String représentant x avec n chiffres significatifs ; lorsque n = 1 on peut mettre chiffre au lieu de chiffres. |
arrondi(x).avec(n).décimales ; | retourne une String représentant x avec n décimales ; on peut mettre décimale lorsque n ∈ { 0 ; 1 }. |
attendre (d) .avant .de (a) ;
attendre (d) .avant .d (a) ; attendre (d) .avant.de.faire (a) |
pour attendre un certain temps avant de faire une action : a est une fonction ou un source JS.
Par exemple |
attendre (x) .pour (a) ; attendre.que (x) .pour (a) ; |
pour attendre un certain événement prédicatif x avant de faire une action :
a est une fonction ou un source JS, x aussi mais pour définir un prédicat.
L'action n'est donc exécutée qu'au plus une fois. Par exemple |
attendre (x) .pendant (d) .pour (a) ; | comme ci-dessus mais en fixant un maximum de temps d'attente : par exemple
après avoir défini |
base() ; base(url) ; base(m,true) ; | permet, dans l'ordre, de retrouver la base des URL relatives, de changer dynamiquement
la base des URL relatives (très utile pour les importations de CSS et de modules) ou de
récupérer la base de chargement d'un module ; exemples :
|
bloquer(···) ; débloquer(···) ; | n'a de sens que pour un input type="text" ou un textarea : empêche la saisie, mais pas la copie. |
boîte(b,c) ; boîte(b,c,id) ; | Ici : c, le contenu de la boîte, est un source HTML ; cette fonction retourne un code HTML ;
par exemple :
|
booléen (id) .contenant (h) ; | h : du source HTML ; fonction qui retourne un Element BOOL
qui n'est pas initialement dans le document et qu'il
convient donc ensuite de mettre à la bonne place ; par exemple : |
bouton (c) .exécutant (js) ; | c : contenu HTML ; js : du source Javascript.
On retourne un élément BUTTON du DOM qu'il
convient ensuite de mettre à la bonne place ; par exemple : |
cacher (···) ; montrer (···) ; | ATTENTION : on peut déplacer, classer, effacer et modifier un élément caché ;
être caché correspond seulement à être classé comme invisible (dont
le contraire est visible) ; par exemple |
chaque (s) .de (e) ; |
|
charger (url) .dans (c) ; | c : cadre (balise iframe) ; valable aussi avec une image (img) et un lien (a). |
chrono() ; chrono(u) | u : unité éventuelle ("s", "ms" ou "µs") ; l'unité est "s" par défaut ;
retourne un nombre exprimant le temps écoulé depuis l'initialisation de l'horloge interne d'AlgoDok ;
exemple : |
classe(e) ; | retourne la classe de l'élément e ; exemple : |
On peut tester la sémantique d'un élément quelconque avec la propriété
estas interlinguistique (en espéranto), ou est en français ; on lui fournit
une chaîne de caractères qui représente une suite de signifiants séparés par des espaces.
On peut préfixer la sémantique par un , une , du , de l' ou
de la .
Par exemple Si le tagName d'un élément exprime une sémantique primitive,
il ne fait pas partie de la classe ; il en va de même pour le premier signifiant
d'un identifiant. Exemple :
| |
classer (···) .comme (c) ; déclasser (···) .comme (c) ; |
c : classe, formée d'un ou plusieurs signifiants (au singulier)
séparés par des espaces ; par exemple :
|
classer (···) .selon (b) .comme (c) ; | b : booléen ou expression booléenne (classe Boolean) ; exemple : |
clone(e) ; | permet d'obtenir un clone d'un élément pour le manipuler
avant usage ; par exemple
|
cloner (e) .avant (f) ; cloner (e) .dans (f) ; cloner (e) .après (f) ; |
Ici on clone directement dans le document, sans manipulation préalable particulière.
REMARQUE : si e admet Toto comme id alors, par exemple, le troisième clone
de e admet Toto.3 comme id ; on peut l'expérimenter ici : for(k = 0 ; k < 3 ; k++) cloner (ceci) .dans ('le brouillon'). |
cocher (···) ; décocher (···) ; | pour (dé-)cocher un booléen, action à ne pas confondre avec activerqui peut aussi bien cocher que décocher un booléen, comme on peut le constater sur l'exemple suivant : |
On peut savoir si un élément booléen est coché ou non, par exemple :
| |
commenter (···) ; décommenter (···) ; | valable pour tout TEXTAREA, donc pour tout script éditable ; par exemple : commenter ("le script du préliminaire") ; attendre("3s") .avant.de ('décommenter ("le script du préliminaire")'). |
commuter (···) .sur (c,nc) ; commuter (···) .comme (c,nc) ; |
Alternance du classement ; nc est une forme négative qu'on peut éventuelement
ajouter (exemple : éteintet allumé) ; exemples : |
conteneur(e) ; | e : élément quelconque ; on retourne un Element, parentde e au sens du DOM, boîte contenant e au sens des CSS. |
contenu(e) ; | retourne une String (sérialisation en HTML lorsque c'est possible) ; c'est une synthèse et un choix adapté des propriétés de constitiuants du DOM : innerHTML, value et data. |
contenu.JS (e) ; | retourne un source JS : dans AlgoDok seul, c'est intéressant uniquement pour un script language="Algo" ; en revanche c'est valable pour n'importe quel langage référencé dans l'objet AlgoDok.toJS, par exemple on peut imaginer travailler avec une syntaxe Python du moment qu'un traducteur de Python en JS existe via AlgoDok.toJS.Python = function(p) { ··· }. |
contenu.numérique (e) ; | retourne un nombre (Number) ; exemple :
|
contraire .de (a) .est (b) ; | permet d'affiner le classement des éléments ; par exemple en affirmant que
|
créer .un .élément (b,c) .dans (e) ; créer .un .élément (b,c) .contenant (h) .dans (e) ; créer (id) .un .élément (b,c) .dans (e) ; créer (id) .un .élément (b,c) .contenant (h) .dans (e) ; |
permet de créer des élément nouveaux dans le document ou dans un élément ;
on peut l'expérimenter ici avec
créer .un .élément ('h1','surligné')
.contenant ("Ceci est un petit exemple !") .dans ('le brouillon')
et créer ("Gertrude") .un .élément ('b','surligné') .contenant (" Voici un tout petit exemple ! ") .dans (le .conteneur .de (ceci)) REMARQUE : on peut mettre avant, après, au.début.de (ou au.début.du) à la place de dans. |
dans(c) ; | permet de manipuler les éléments d'un docapp en IFRAME
exploitant AlgoDok. Par exemple, après avoir pris le soin
d' |
déplacer (e) .à (x,y) ; | déplacement d'un seul élément à la fois en position absolue (unité sous-entendue pour un nombre : 1px) ;
exemples : |
dimensions (e) ; | retourne un objet comme { dx : 406 , dy : 150 } ; où ces dimensions d'affichage sont calculées par le navigateur ; c'est parfois utile pour déplacer un élément par rapport à la droite d'un autre (voir aussi position). |
écrire (t) .après (···) ; écrire (t) .avant (···) ; écrire (t) .au .début .de (···) ; |
il s'agit d'écrire juste après, juste avant ou
en tout début de ;
comme sur cet exemple : |
écrire (t) .dans (···) ; écrire (t) .sur (···) ; |
en fin de l'élément (ou des éléments) concerné(s) ; par exemple : écrire (' [ILO]') .au.début.des ( éléments .sélectionnés.par ("tr > td:first-child")). |
écrire.ici (t) ; | t : source HTML ; pour construire « à la volée » une partie du document, dans un script classique. Permet de partir d'un corps de page réellement vide (hors le script d'écriture). Rarement utilisé en pratique. |
effacer(···) ; | effacer vide le contenu des éléments indiqués (à ne pas confondre avec supprimer) ; on peut effacer un élément caché ; on utilise souvent un effacement pour écrire ultérieurement dans e, par exemple avec un contenu téléversé : voir aussi mettre.à.jour et le module TelVerSer. |
effectuer(···) ; exécuter(···) ; | exécute du code Javascript ou appelle une fonction (on peut en fournir plusieurs),
avec émission d'un message d'alerte en cas d'erreur ;
les alertes émises ne sont pas forcément bloquantes comme avec l'instruction classique alert,
comme on peut le constater avec cet exemple :
|
élément(e) ; élément(e,sma) ; | si e est une String, la fonction retourne l'élément d'identifiant e, sinon elle retourne e ;
pour un identifiant non utilisé la fonction retourne null ou undefined
et émet une alerte sauf si sma = true (sma : sans message d'alerte),
ce qui permet de tester silencieusement la présence d'un élément d'identifiant connu ;
par exemple |
élément.prédécesseur(e) ; élément.successeur(e) ; |
On retourne l'élément correspondant dans la structure du document ; la sémantique ne correspond donc pas forcément à une position visuelle relative (voir aussi prédécesseur et successeur). |
éléments(tn) .de (e) ; | On retourne un tableau (Array) de tous les éléments ayant un tagName tn et composants de e
(au sens de la structure documentaire) ; la casse de tn n'a pas d'importance ;
par exemple :
|
ATTENTION : un tagName est forcément stocké en majuscules en HTML4, mais pas forcément en XML/HTML5 !! De plus la mise en majuscule via toUpperCase ne correspond pas au tagName HTML 5 pourtant en… majuscules. Donc, pour la comparaison, les tagNames sont systématiquement comparés en minuscules. |
|
éléments .vérifiant (p) ; | retourne un tableau (Array) de tous les éléments du document vérifiant le prédicat
p, prédicat soit sous forme d'une fonction à un paramètre, x,
et retournant un booléen,
soit une chaîne de caractères définissant un prédicat à une place. Exemple : |
éléments .de (e) .vérifiant (p) ; | idem que ci-dessus mais on n'effectue la recherche que dans l'élément e. |
éléments (tn) .de (e) .vérifiant (p) ; | idem que ci-dessus, mais on ne cherche que les éléments ayant un certain tagName tn (div, h2, p, tr, …). |
éléments.classés (s) ; éléments.de (e) .classés (s) ; |
retourne tous les éléments du document (ou de e) ayant une sémantique s uniquement dans sa classe ; par exemple : requêtes = les .éléments .classés ('requête fondamentale') ; alerter ("Le tableau requêtes contient " + nombre .de (requêtes) + " éléments."). |
éléments.sélectionnés.par (s) ; éléments.de (e) .sélectionnés.par (s) ; |
retourne tous les éléments du document (ou de e) vérifiant s, un sélecteur de CSS ; par exemple : requêtes = les .éléments .sélectionnés .par ('tr.requête') ; alerter ("Le tableau requêtes contient " + nombre .de (requêtes) + " éléments."). |
exécution (t,js,d) ; | t : type d'exécution, Number (1 ou 2) ou String (resp. : "périodique", "différé") ; js : source Javascript ou Function ; d : durée avec unité (String ; par exemple "2013 ms", "0.8 min" ou "14 s") qui représente une période (cas périodique) ou un délai (cas différé) ; cette fonction retourne un numéro de processus qui permet de l'arrêter, voire de le relancer. |
HMS(t) ; | Heure Minutes Secondes ; à partir d'un temps t en seconde, cette fonction retourne une String
donnant ce même temps arrondi à la seconde la plus proche ;
par exemple : |
identifier (e) .par (id) ; | permet de donner un identifiant à un élément ; par exemple
Cette instruction est intéressante pour éventuellement ré-identifierun élément cloné si le mécanisme d'identification automatique d'AlgoDok ne convient pas (voir clone et cloner). |
importer (···) | uniquement valable pour les feuilles de style (extension .css)
et les modules en Javascript (extension .js) ;
on fournit des URLs, relatives ou absolues ; l'imporation crée des éléments et les active.
Par exemple on peut
importer ("../Styles/AlgoDok-plus.css",
"http://www.algodok.com/" + "MiniMod/Notes éditables.js?2") ;
on peut ensuite, par exemple,
|
imprimer (···) ; | on peut spécifier un ou plusieurs éléments à imprimer, par une liste ou une requête ;
on peut par exemple |
insérer (···) .dans (···) ; etc… | alternative à écrire : voir la note 11. |
instruction (js) ; instruction.francisée (js) ; |
retourne une instruction cliquable (Element) correspondant au code Javascript fourni ; la seconde forme permet d'obtenir une apparence plus linguistique, comme avec <js class="fr"> ··· </js> en HTML. |
lorsque (p) .devient.vrai (a) ; lorsque (p) .devient.vraie (a) ; |
permet d'effectuer une action a (fonction ou source JS)
à chaque fois que le prédicat p (fonction ou source JS) devient vrai (alors qu'il est faux).
Exemple avec toto = 0 :
|
mettre (e) .avant (f) ; mettre (e) .dans (f) ; mettre (e) .après (f) ; mettre (e) .au .début .de (f) ; |
déplace un élément dans la structure du document ; comme pour l'instruction écrire,
danssignifie juste à la fin de, avantsignifie juste avant, aprèssignifie juste après et au début designifie au tout début de. |
mettre.à.jour (e) .avec (c) ; | permet de mettre à jour le contenu (en écrasant l'ancien) d'un élément e, avec c (String) ;
dans le cas particulier d'un iframe, c doit être l'équivalent d'un source HTML complet
( |
module (nom) ; | retourne soit l'objet caractéristique du module, ou bien undefined ; par
exemple : |
nombre.de (t) ; nombre.des (t) ; | retourne la taille d'un tableau ; par exemple, pour obtenir le nombre de lignes de ce tableau : voir (le. nombre .des (éléments ('tr') .du ('tableau des instructions'))). |
nombre.aléatoire(n,M) ; nombre.entier.aléatoire(m,M) ; |
retourne un nombre (Number) y ∈ [n, M] , entier dans le second cas, différent de M dans le premier. Variantes linguistiques : nombre.aléatoire.dans et nombre.entier.aléatoire.dans. |
nouvel.élément(b,c) ; nouveau(b,c) ; nouvelle(b,c) ; |
fonctions primitives retournant un Element de balise (tagName) b
et de classe (facultative) c ;
on peut à loisir compléter les deux dernières fonctions, en exploitant nouvel.élément ;
par exemple : nouvelle.ligne = function(x,c) { var tr = nouvel.élément('tr',c) ;
écrire (boîte('td',x) + boîte('td',x)) .dans(tr) ; return tr }
d'où ensuite
|
nouvelle.action (n) .définie.par (f) ; | f est une fonction ou une expression de variable x ;
on définit une nouvelle action qui peut porter
sur un élément ou plusieurs (liste ou tableau) ; par exemple,
avec |
objet (n) ; | si n est une String : retourne l'objet défini comme une variable globale de nom n (donc on peut obtenir undefined) ; retourne n si n n'est pas une String. |
paramètre (n) ; | retourne le paramètre passé au module de nom n ; par exemple :
|
partie.entière = floor ; partie.décimale(x) ; |
fonctions mathématiques de base pour étendre ou franciser celles du JS standard ; chacune retourne un nombre ; on note que la partie décimale de x c'est x - floor(x). |
permuter (x) .avec (y) ; permuter (x) .et (y) ; |
exemple : |
pluriel (s,p) ; pluriel .de (s) .est (p) ; |
exemple : |
position (e) ; | valable pour un élément en position absolue (absolute) ou fixe (fixed) ;
retourne un objet { x : …, y : … } ; exemple : |
prédécesseur(e) ; successeur(e) ; | peut retourner un Text, qu'AlgoDok considère comme étant une STRING
(en majuscules), ou un Element ;
par exemple en considérant les deux boîtes B-1et celle qui la suit
on peut le voir facilement avec
|
présenter (v) .selon (f) ; | f est une fonction ou bien une String contenant +v+,
désignant alors l'emplacement de la variable dans la chaîne à afficher ;
pour modifier l'apparence d'une variable (globale) définie par une balise var ;
exemple : toto = pi^3
|
recharger() ; | il s'agit du document ; pour une lecture plus naturelle on peut utiliser recharger ("le document"). |
relancer (p) ; | pour relancer un processus |
remplacer (er) .par (s) .dans (e) ; |
er : une expression régulière, ou une chaîne qui sera convertie en
expression régulière ;
exemple : |
rendre. ··· ; | rendre est un objet à compléter par exemple dans d'autres modules pour apporter une sémantique d'action aux éléments, comme ci-dessous. |
rendre.éditable(···) ; rendre.non.éditable(···) ; |
permet (resp. interdit) de saisir de l'information dans un élément non initialement prévu à cet effet.
Par exemple : |
rendre.déplaçable (e) .par (p) ; rendre.non.déplaçable (e) .par (p) ; |
permet (resp. interdit) de déplacer à la souris l'élément e par p
(qui est un élément ou le résultat d'une requête) ; on peut utiliser aussi
via et avec à la place de par; e est alors classé comme
déplaçable et p comme poignée ; exemple :
|
sémantique (e) ; | e : Element ;
plus complet que la classede e, sous forme d'un Array, en ajoutant une sémantique primitive (non intentionnelle) : ["élément", tagName en minuscules, premier signifiant d'un id éventuel, classe] ; exemple : |
source.HTML (e) ; source.JSON (e,nl) ; | e : Element ;
nl = true avec saut de ligne et indentation ; exemple :
|
supprimer(···) ; | Les éléments indiqués sont retirés du document (à ne pas confondre avec effacer) ;
par exemple on peut |
tout (s) .de (e) ; toute = tout ; chaque = tout ; |
s : sémantique de sélection, au singulier,
qui peut aussi contenir des noms de balise, en tant que sémantique primitive (en HTML) ;
exemple : |
tous .les (p) .de (e) ; toutes = tous ; | p : sémantique de sélection, au pluriel, qui peut aussi contenir des noms de balise, en tant que sémantique primitive (en HTML) ; exemple : imprimer (toutes .les ('fondamentales') .du (document) .vérifiant ("x.contient ('dans')")). |
Pour une simple raison de commodité de lecture des instructions
linguistiques, on peut utiliser tout.élément ou tous.les.éléments comme
synonyme de éléments ; de même on peut utiliser le signifiant primitif élément
dans les requêtes, par exemple avec :
| |
valeur (e) ; valeur.numérique (e) ; | retourne l'attribut value de e s'il existe (ou e sinon) ; valeur.numérique équivaut à contenu.numérique. |
variable (n,r) ; (variable.globale = variable) |
retourne un Element correspondant à une variable au sens d'AlgoDok ; le booléen r facultatif
indique si on veut un Element non modifiable sur clic (false par défaut) ;
on peut mettre directement une affectation ; par exemple :
mettre (variable ("toto = 22/7")) .après (ceci) ;
mettre (variable ("toto")) .dans ("la fonction variable") ;
alors on peut exécuter |
voir (n) ; | si n est une String alors on cherche à montrer le contenu de la variable globale
de nom n ; sinon on affiche simplement l'objet fourni ; par exemple :
|
En Javascript lorsqu'on exécute une expression algébrique qui mêle nombres (Number) et chaînes de caractères (String), le calcul est tenté en extrayant l'information chiffrée des chaînes de caractères. Par exemple : var ce_nombre = 2000 * arrondi(pi).avec(5).chiffres ; alerter(ce_nombre.constructor == Number). | |
L'instruction tous (ou toutes) d'AlgoDok
gère la plupart des pluriels, mais pas certains cas particuliers. D'où la fonction singulier
permettant de voir si le mécanisme de | |
Pour gérer les cas particuliers des pluriels
irréguliers, en particulier les invariables
(comme albinos, abus, accès, acquis, alias, amas, angélus, anis, anticorps, …)
on dispose de la fonction pluriel. Avec l'exemple suivant,
| |
Tout écrit dans un élément e est encapsulé dans une balise skribo sauf si e est vide (on considère alors que l'on initialise un élément) ; par exemple écrire (' [JS]') .dans ( le. conteneur .de (ceci)) ; alerter (le. nombre .des (éléments ('skribo') .du (document))). D'où la nécessité parfois d'utiliser insérer (avec la même syntaxe) ; mais alors on ne peut plus savoir a posteriori ce qu'on a inséré, ce qui est facile avec écrire. | |
Pour connaître le contenu d'un objet en format JSON c'est
très simple. Par exemple :
| |
La forme francisée des instructions cliquables peut être complétée par un module
via quelconque via la fonction AlgoDok.vernaculaire,
comme c'est le cas pour ce document applicatif :
| |
Pour que la base soit le document lui-même on utilise base(''), mais on utilise base('./') pour que ce soit le dossier qui le contient. L'usage de la balise base ou d'instructions base(···) rendent indispensable la première forme pour permettre ensuite une navigation dans le document sans un rechargement intempestif. | |
Pour ranger des éléments déplaçables,
on peut facilement définir une fonction qui fait le travail :
Ce qui permet ensuite de | |
La manipulation de dans est subtile car il faut savoir quelles
instructions sont réellement exploitées et à qui elles s'adressent : | |
Dans l'instruction présenter
on peut aussi passer une fonction à la place d'une chaîne de caractères,
par exemple avec V_sphère = 1000*pi :
| |
On peut parfois obtenir la même chose avec des requêtes différentes, par exemple :
La différence vient des algorithmes internes, et donc les temps d'exécution peuvent être notablement différents selon la méthode de requête employée, avec une incidence réelle que pour les traitements périodiques puisque même la plus lente d'entre elles est déjà très rapide (à l'échelle humaine) : Si les requêtes doivent être visibles par l'utilisateur/lecteur, le développeur choisira bien sûr les formes les plus linguistiques, pas forcément les plus rapides. Ces dernières ne sont utiles en pratique que pour le développement de modules ; on peut aussi utiliser toutes les ressources du Javascript, sans limite puisque seule l'interface linguistique a un intérêt pour d'autres utilisateurs, concepteurs de documents applicatifs ou développeurs (voir le document spécifique). |