Bonsoir à tous,

Le titre de ce topic est sans doute bien impertinent; mais c'est l'impression que me donne le fonctionnement de mon code !

J'ai progressé dans la conversion d'un programme Flash en JS, et me voilà bien avancé dans ce que (dans un autre topic) TabouretBleu avait baptisé "la méthode moche".

La partie JS en cause effectue, après une initialisation de l'affichage, une boucle "do" jusqu'à ce que l'on ait obtenu "imax" grilles.
Cette boucle comporte elle-même:

• une boucle où l'on teste des grilles tirées au hasard jusqu'à en obtenir une résolue dans au moins un des résolveurs resoudre()
• puis un appel ajax au script TPgenTSf-ecrGr.php à qui on transmet quelques variables et qui doit créer un enregistrement dans une base et renvoyer le numéro de l'enregistrement créé.

Le JS:

function generer() {
    $("#zGrTest").empty().show();
    $("#zGrReso").empty().show();
    $("#zGrRete").empty().show();
    $("#lL5").show();
    $("#lL6").show();
    $("#lL7").show();
    $("#lL8").show();
    $("#lL9").show();
    $("#lL10").show();
    $("#zDerGrill").show();
    $("#zTpsCalc").show();
    $("#passages1").empty().show();
    $("#reste1").empty().show();
    $("#passages2").empty().show();
    $("#reste2").empty().show();
    $("#passages3").empty().show();
    $("#reste3").empty().show();
    $("#passages4").empty().show();
    $("#reste4").empty().show();
    grid = $("#detailGrilles");
    grid.empty();
    do {
        do {
            grillesTestees++;
            document.getElementById("zGrTest").textContent = grillesTestees;
            creer_iconeT();
            for (i=1;i<5;i++) {
                reste[i] = 0;
                document.getElementById("reste"+i).textContent = '';
                passages[i] = 0;
                document.getElementById("passages"+i).textContent = '';
            }
            resoudre(1);
            resoudre(2);
            resoudre(3);
            resoudre(4);
        } while (reste[1]&&reste[2]&&reste[3]&&reste[4]);
        func_fin();
        $.ajax({
            url: 'TPgenTSf_ecrGr.php',
            type: 'POST',
            data: {
                contenu: contenu,
                R1: passages[1],
                R2: passages[2],
                R3: passages[3],
                R4: passages[4]
            },
            dataType: 'json',
            success: function (json, statut) {
                var retErreur = json.erreur;
                if (retErreur != '') {
                    $("#zComment").append(json.erreur);
                    $(".errorContainerPage").show();
                } else {
                    //
                }
                console.log("passé par 'success'");
                var sol = json.sol;
                var Rm = json.Rm;
                numGrille = json.num_grille;
                console.log('grille='+numGrille+ '\nsol='+sol+'\nRm='+Rm);
                //var grid = $("#detailGrilles");
            
            },
            error: function (resultat, statut, erreur) {
                console.log("passé par 'error'");
            },
            complete: function (resultat, statut) {
                console.log("passé par 'complete'");
            }
        })
        if(numGrille<=0) {
            zComment.textContent = "" + numGrille + "*";// ??? et après ?
        }
        if(nbPassMini>1) {
            grillesRetenues++;
            document.getElementById("zGrRete").textContent = grillesRetenues;
            let xxx = grillesRetenues+' : grille N°'+numGrille+ ' = '+nbPassMini + ' / ' + passages[1]+ passages[2]+ passages[3]+ passages[4];
            document.getElementById("zDerGrill").textContent = xxx;
            grid.append(xxx);
            if (grillesRetenues<imax) {grid.append("<br>");}
            grilleAEnregistrer = grillesACreer[grillesRetenues];
        }
    } while (grillesRetenues<imax)
}

Le php:

<?php
$R1 = $_POST['R1'];
$R2 = $_POST['R2'];
$R3 = $_POST['R3'];
$R4 = $_POST['R4'];
$contenu = $_POST['contenu'];
if ($R1>0) {
	$Rm = $R1;
	if ($R2>0 and $R2<$Rm) {$Rm=$R2;}
	if ($R3>0 and $R3<$Rm) {$Rm=$R3;}
	if ($R4>0 and $R4<$Rm) {$Rm=$R4;}
} else if ($R2>0) {
	$Rm = $R2;
	if ($R3>0 and $R3<$Rm) {$Rm=$R3;}
	if ($R4>0 and $R4<$Rm) {$Rm=$R4;}
} else if ($R3>0) {
	$Rm = $R3;
	if ($R4>0 and $R4<$Rm) {$Rm=$R4;}
} else {
	$Rm = $R4;
}

$sol = 0;
if ($R1>0) {$sol++;}
if ($R2>0) {$sol++;}
if ($R3>0) {$sol++;}
if ($R4>0) {$sol++;}
include("../acces_Chedev.php");
$requete = "INSERT INTO GrillesSf  
		VALUES ('', '".$sol."', '".$Rm."', '".$R1."', '".$R2."', '".$R3."', '".$R4."', '".$contenu."')";
if (mysql_query($requete)) {//si la création est faite, on récupère le numéro de grille
	$numero_de_grille = mysql_insert_id();//
	$retourEcrGr['num_grille']=$numero_de_grille;
} else {
	$retourEcrGr['num_grille']="erreur";
}
mysql_close();

$retourEcrGr['num_grille']=$numero_de_grille;
$retourEcrGr['sol']=$sol;
$retourEcrGr['Rm']=$Rm;
$retourEcrGr['R1']=$R1;
$retourEcrGr['R2']=$R2;
$retourEcrGr['R3']=$R3;
$retourEcrGr['R4']=$R4;
echo json_encode($retourEcrGr);
?>

Le php est celui qui est en exploitation dans ma version Flash (qui fonctionne), sauf que je l'ai aménagé pour avoir un retour en jason.
En particulier, l'instruction $numero_de_grille = mysql_insert_id(); revoie bien à mon programme Flash le numéro de l'enregistrement créé.

Dans la version JS, la table est bien mise à jour avec les variables transmises, mais le numéro de grille n'est pas renvoyé.

Pouvez-vous m'aider à comprendre pourquoi (sans doute un truc que j'ai mal écrit!), et m'indiquer comment m'y prendre pour traiter ce problème?

Merci d'avance.

PS 1
Dans le prog Flash j'avais mis des instructions delai = setInterval(this, "func4", retard); dont je ne me souviens plus à quoi elles servaient! Est-ce un début de piste?

PS 2
Toute critique sur ma façon d'écrire duJS sera la bienvenue.
Je pense entre autres à l'instruction:
passages[i] = 0;
document.getElementById("passages"+i).textContent = '';
qui a surement une formulation plus compacte et plus élégante ...

Salut chedev !

Je pense qu y a pas de problème avec tes requtes (tu peux le vérifier dans l'onglet réseau de la console de développement de ton navigateur - F12)

Par contre, tu fais l'erreur suivante :

$.ajax({
  //...
  success: function(json) {
    numGrille = json.num_grille;
  }
  // ...
});
if (numGrille) {
 // 
}

Ce code va d'abord lancée la requete ajax, puis, sans attendre la réponse du serveur, va continuer l'exécution du code. Donc au moment ou tu teste ta variable numGrille, la fonction success n'a pas encore été exécutée. Elle le sera plus tard, quand la réponse du serveur arrivera. C'est ce qu'on appelle l'exécution aysnchrone.

Donc, tout ce qui se doit produire après la réponse du serveur doit être dans la fonction success. Bien sur, pour améliorer la clarté du code, tu peux déclarer une fonction qui sera appelé dans la fonction success :

$.ajax({
  //...
  success: function (json) {
    if (json.num_grille === 'erreur') {
       // ici tu peux gérer le cas ou y a une erreur 
    } else {
      aprèsRéception(json);
    }
  }
  // ...
});

function aprèsRéception(json) {
  if (numGrille) {
   // 
  }
}

Ah, la synchro! On m'avait toujours dit que je ne chantais pas juste

Trêve de plaisanteries, encore une fois merci LCaba: je vais de ce pas tester ce que tu viens de m'expliquer et je mettrai ici le résultat obtenu.

Petite question complémentaire:
Mes appels Ajax sont dans une boucle et ils s'opèrent donc entre une et plusieurs dizaines de fois à chaque lancement de ce programme.
Tu pourras sans doute me confirmer que chacun de ces appels est géré de façon qu'il reçoive finalement les réponses qui le concernent.
Mais cela risque de générer une file d'attente plus ou moins longue. Y a-t-il un risque de carambolage, et si oui y a-t-il un remède ou des précautions à prendre?

Par ailleurs, pas de critique majeure sur mon code?

Salut, 

Pas de souci pour tes requetes ajax, chaque success sera appelé avec la réponse qui la concerne

Y a aucun risque de carambolage, les requetes sont placés en fle d'attente, et en général le navigateur en envoie simultanément 6 au maximum. 

Par contre tu peux optimiser l'exécution en envoyant tout dans une seule requete (cela t'oblige par contre à modifier la façon dont php gère ta requete, et la façon dont tu gère le résultat). S'ily a 5-10 requetes, je dirais que c'est pas la peine de s'embeter, si par contre t'en a une centaine, ça peut faire gagner un temps de chargement significatif

Et bien là, ça a quasiment tourné à la cata!

Ma dernière version

function generer() {
    grillesTestees = 0;
    ...
    grid.empty();
    do {
        do {
            grillesTestees++;
            document.getElementById("zGrTest").textContent = grillesTestees;
            creer_iconeT();
            for (i=1;i<5;i++) {
                reste[i] = 0;
                document.getElementById("reste"+i).textContent = '';
                passages[i] = 0;
                document.getElementById("passages"+i).textContent = '';
            }
            resoudre(1);
            resoudre(2);
            resoudre(3);
            resoudre(4);
        } while (reste[1]&&reste[2]&&reste[3]&&reste[4]);
        func_fin();
        $.ajax({
            url: 'TPgenTSf_ecrGr.php',
            type: 'POST',
            data: {
                contenu: contenu,
                R1: passages[1],
                R2: passages[2],
                R3: passages[3],
                R4: passages[4]
            },
            dataType: 'json',
            success: function (json, statut) {
                console.log("passé par 'success' Générer");
                if (json.erreur) {
                    $("#zComment").append(json.erreur);
                    $(".errorContainerPage").show();
                } else if (json.num_grille <= 0){
                    //
                } else {
                    var sol = json.sol;
                    var Rm = json.Rm;
                    numGrille = json.num_grille;
                    console.log('grille='+numGrille+ '\nsol='+sol+'\nRm='+Rm);
                    if(nbPassMini>1) {
                        grillesRetenues++;
                        document.getElementById("zGrRete").textContent = grillesRetenues;
                        let xxx = grillesRetenues+' : grille N°'+numGrille+ ' = '+nbPassMini + ' / ' + passages[1]+ passages[2]+ passages[3]+ passages[4];
                        document.getElementById("zDerGrill").textContent = xxx;
                        grid.append(xxx);
                        if (grillesRetenues<imax) {grid.append("<br>");}
                        grilleAEnregistrer = grillesACreer[grillesRetenues];
                    }
                }    
            },
            error: function (resultat, statut, erreur) {
                console.log("passé par 'error' Générer");
            },
            complete: function (resultat, statut) {
                console.log("passé par 'complete' Générer");
            }
        })
    } while (grillesRetenues<imax)
}

met très vite mon navigateur dans le rouge: il me demande gentiment d’arrêter "ce script qui a l'air de boucler".
Et en effet alors que j'ai 8 grilles à créer, il en est à près de 500 quand je stoppe!

J'avoue que je tâtonne sans trop comprendre ce que je fais ...

Pourtant le but à atteindre n'est pas très loin: une fois les grilles crées (mais pas plus qu'il n'en faut), je n'ai plus qu'un fichier de tournoi à créer (comprenant les numéros des grilles en question).

Encore un coup d'ajax, mais là encore qui ne doit intervenir qu'après que les précédents aient terminé leur tâche.

Bref il me faut encore un petit peu d'aide pour me remettre en selle.

Merci d'avance.

Dernière minute:
Le rajout de l'instruction async: false, dans l’appel Ajax semble avoir tout remis en ordre.
Intellectuellement, ça me convient, mais cette apparente simplicité ne cache-t-elle pas un autre piège?

-
Edité par chedev 1 décembre 2017 à 12:41:14

async: false ne devrait convenir intellectuellement à personne 

Le problème que tu rencontres, c'est toujours une question d'exécution asynchrone. Et le régler à coup d'éxcution synchrone n'est pas une solution. Pendant que les requetes s'exécutent, ta page est bloquée.

On a vu ci-dessus que tu peux pas tester la variable numGrille parce que l'instruction if() est exécutée avant que la réponse n'arrive. C'est la même chose avec la boucle while : tu peux pas évaluer une expression qui dépend du résultat de la requête.

Voici ce qu'il se passe dans l'ordre : ta boucle do/while commence à tourner. Avant même que la première réponse arrive, en quelques millisecondes, elle a probablement déjà fait des milliers de tour, donc des milliers de requêtes sont en file d'attente. Mais ça ne s'arrête pas là.Ton script voudrait bien exécuter le success de la première réponse du serveur, mais il doit attendre que l'instruction en cours se termine. Or l'instruction en cours c'est une boucle while qui peut s'arrêter que si grillesRetenues atteind une certaine valeur. Mais grilleRetenues peut pas être modifiée par les 'success' puisqu'on attend que la boucle while se termine pour les exécuter...

Comment faire alors ?

2 solutions :

• Dans ton cas précis, je pense qu'il est préférable de générer et de tester les grilles valides côté serveur.
• Sinon, tu peux prévoir dans ta fonction success, de relancer une nouvelle requete tant que t'as pas le bon nombre de grilles. Exemple basique qui exécute une requete tant que la réponse du serveur - qui dans mon exemple renvoie un nombre aléatoire - n'est pas >= à 0.9 : 

<?php
// fichier fetch.php

echo mt_rand(0, 1);

var essais = 0;
function getRandomFromServer() {
  $.ajax({
    url: 'fetch.php',
    success: function(response) {
      essais++;
      if (n < 0.9) {
        getRandomFromServer();
      } else {
        alert('Le serveur a renvoyé un nombre supérieur ou égal '
            + 'à 0.9 après ' + essais + ' essai' + (essai > 1 ? 's' : '') +'\n'
            + 'Ce nombre est : ' + n );
      }
    }
  });
}

Merci pour ta réponse. Comme souvent elle débouche sur de nouvelles questions

1) async: false ne devrait convenir intellectuellement à personne
J'ai bien vu quelques réticences là où j'ai pêché cette solution, mais je voudrai être convaincu plutôt que de me contenter d'admettre que "c'est comme ça".
En effet j'ai bien compris qu'il s'agit d'une question d'exécution asynchrone (en clair: ne pas pouvoir exploiter une info avant qu'elle ne soit disponible). Donc dans ma petite tête je me dis que puisqu'on ne peut échapper à cette évidence, il est nécessaire et suffisant d'attendre qu'elle le soit; en conséquence le fait que la page soit bloquée pendant cette attente est inévitable. Accessoirement, dans mon cas, ce n'est pas franchement gênant puisque cette page n'a rien d'autre à faire.
Les réticences que j'évoquais semblaient plus liées au fait que le premier A d'Ajax voulait dire Asynchrone et que le faire travailler en synchrone  était un peu contre nature. Du coup cette pratique risquait d'être dépréciée à plus ou moins long terme. Bref, cela résultait plus d'une profession de foi que d'une démonstration.

2) Dans ton cas précis, je pense qu'il est préférable de générer et de tester les grilles valides côté serveur
Au niveau du principe, je ne vois que du bon dans ta proposition: tant mieux si je fais travailler la machine de mon hébergeur plutôt que la mienne, même si mon micro n'est pas surchargé. Mais comment est-ce possible?
J'ai bien quelques scripts php qui se lancent automatiquement tous les jours ou tous les mois (en fonction d'un calendrier que j'ai horodaté) pour effectuer des travaux batch de bascule, de statistiques ou de classement.
Ca pourrait être un truc du même genre (sauf l'aspect cron)?
Et en quoi cela changerait ce que j'ai à programmer?
Bref, si tu peux m'en dire plus, je suis curieux de voir où ça peut conduire.

Pour le reste (qui est le fond du problème), je vais bien entendu exploiter au mieux les lignes de code que tu as eu l'amabilité d'écrire à mon attention. Plus serein tout de même puisque je dispose maintenant d'une solution synchrone opérationnelle.

Effectivement l'exécution asynchrone est maintenant déprécié est conduit à un message d'avertissement dans la console. L'appi fetch, plus récente, n'autorise pas ce genre de comportement. Bloqué la page, cela veut dire que l'utilisateur peut même pas suivre un lien s'il en a marre d'attendre, tout est bloqué.

Pour le truc du script PHP, je pensais simplement à faire une unique requete AJAX (donc pas besoin de batch ou autre), et le scirpt PHP qui est appelé génère est teste les grilles jusqu'à avoir un nombre suffisant de grilles à renvoyer.

Et bien, ce qui est bloqué, ce n'est pas ma page: c'est moi

Ma version synchrone fonctionne sans problème apparent (avec bien sûr le warning infamant "L’utilisation d’XMLHttpRequest de façon synchrone sur le fil d’exécution principal est obsolète à cause de son impact négatif sur la navigation de l’utilisateur final.").
Pour ne pas être mis au ban des néo-javascripteurs, j'essaye en vain de rentrer dans le rang, mais je ne vois toujours pas comment mettre en oeuvre une de tes deux solutions:

1) Dans ton cas précis, je pense qu'il est préférable de générer et de tester les grilles valides côté serveur.
C'est quoi "faire quelque chose" coté serveur? C'est tout faire en PHP ?
Et quand j'aurai toutes les données dont j'ai besoin, mettre à jour les bases de données concernées? (il y a la base des grilles et celle des tournois).
Mais même si je fonctionne comme ça, je dois mettre des grilles dans les tournois, et si pour une raison ou une autre une grille n'a pas été créée, je ne connais pas son numéro ... dont j'ai besoin pour l'affecter à un tournoi.

2) Tu peux prévoir dans ta fonction success, de relancer une nouvelle requête.
En asynchrone, je croule déjà sous le nombre de requêtes exécutées avec succès mais qui ne sont pas traitées (numéro de grille non récupéré). Ca en fait rapidement une pile énorme. Alors si j'en relance une autre, elle ne va pas s'ajouter à la pile?

Bien sûr, je pourrai générer les grilles par paquet de 1000, piocher dans ce tas pour alimenter des tournois puis éliminer celles qui n'auraient servi à rien. Mais ce serait refuser le combat. 
Alors, en attendant l'inspiration ou le tuyau sauveur, je pioche ...

-
Edité par chedev 2 décembre 2017 à 18:32:57

J'ai peut etre mal compris la façon dont tu génères grilles.

Quand tu dis tirer une grille au hasard ? qui génère la grille : php ou js ?

Voici le processus (actuel) complet.
Le fait de le décrire ici me permet de mettre à plat tout le processus amont de mes tournois

1) Cadre général:

• Il y a 4 sortes de tournois de base: Quotidien ou Hebdo x Sprint ou Finish (les tournois parallèles ont une organisation spécifique).
  Chacun est stocké dans une table (par exemple QS171204 pour le Quotidien Sprint du 4 décembre 2017) comportant ses numéros de grille (8 pour les Quotidiens et 20 pour les Hebdos), où seront enregistrés les scores des joueurs.
  
  
• Les grilles sont stockées dans une table unique (qui grossit donc au fil du temps).
  Elles sont générées en même temps que les nouveaux tournois, en général 2 à 3 mois à l'avance.

C'est ce programme de génération de tournois et des grilles qui les composent (écrit à l'origine essentiellement en Flash) que je suis entrain d'essayer de reprogrammer en JS.
Si j'y arrive, j'aurai en principe assez d'expérience pour m'attaquer à mon véritable objectif: reprogrammer le jeu lui-même sans Flash afin de me libérer de ce langage devenu un paria du Web et enfin ouvrir mes tournois au monde des téléphones et des tablettes.

2) Principe du générateur (pour les grilles):
Une grille de tournoi doit (pour que ce soit intéressant) pouvoir être résolue, ce qui n'est pas le cas de n'importe quelle grille tirée au hasard. Faute d’avoir imaginé un dispositif de construction de grilles avec solution, je me suis rabattu sur un dispositif plus pragmatique: je tire une grille au hasard puis j'essaye de la résoudre au moyen de résolveurs que j'ai programmés.
Si un ou plusieurs résolveurs ont trouvé ... la grille a au moins une solution et elle est sauvegardée, sinon elle a peut-être des solutions que des résolveurs plus malins auraient trouvée, mais elle est rejetée.
Ensuite, toutes les grilles sauvegardées ne sont pas systématiquement affectées à un tournoi. Cela dépendra de leur degré de difficulté (nombre de résolveurs ayant trouvé la solution et nombre de "boucles" nécessaires pour chacun).
Par exemple les grilles résolues par tous les résolveurs en une seule boucle ne seront jamais dans un tournoi!

3) Fonctionnement du générateur

• Sélection d'un type de tournoi et d'une date ==> Contrôle du tournoi
  Si le tournoi n'existe pas (ou s'il existe mais ne contient pas toutes ses grilles), on le crée et on rend actif le choix "Générer".
  Sinon on renvoie les numéros de grilles qui lui sont affectées.
  Ce contrôle est un premier cas d'utilisation d'ajax ... qui fonctionne (correctement) en ajax.
  
  
• Génération des grilles
  - Une première boucle do portant sur les grilles retenues va traiter les 8 ou 20 grilles du tournoi. (Oublions les cas particuliers où il y en a moins à créer suite à un incident antérieur)
  - Dans cette première boucle, une seconde tire une grille au hasard et la soumet aux différents résolveurs. Cela incrémente le compteur des grilles testées. Si aucun résolveur n'a se solution, on teste une nouvelle grille.
  - Si une grille a au moins une solution, on incrémente les grilles résolues et on crée la grille (appel ajax de TPgenTSf_ecrGr.php).
  C'est là qu'ajax renvoie le numéro de la grille fraichement créée ... trop tard pour qu'on puisse d'en servir si on est en asychrone
  - Si cette grille est jugée assez difficile, elle devient une grille retenue et va être enregistrée dans le tournoi. C'est ce qui termine une itération de la première boucle do.
  
  
• Enregistrement des grilles dans le tournoi
  Il se faisait en Flash après l'enregistrement de chaque grille dans la première boucle do. En JS je pourrai procéder de la même façon ou attendre d'avoir toutes les grilles pour ne faire qu'une seule écriture. L'un comme l'autre (a priori en ajax) ne devrait pas être bien compliqué.

Tout ce long discours répond-t-il à ta question?

En fait tout était en Flash à l'exception des lanceurs (un par type de tournoi pour indiquer ses quelques paramètres (type, nombre de grilles, ...) et des programmes de lecture et écriture des tables qui étaient de courts scripts PHP.

Je pensais faire de même avec le JS et donc le tirage de grille au hasard est en JS, comme les résolveurs et les appels ajax.

Un de mes soucis était qu'en Flash j'avais une petite impression de confidentialité (puisque l'exécutable swf est compilé) alors qu'en JS le code est en clair, visible par tous. Mais mes secrets de fabrication ne sont que des secrets de polichinelle et les royalties que je tire de mes brevets ne comptent que pour du beurre

Heu ... tu as laissé tomber LCaba ?

ha ha non mais je l'ai pas lu tout de suite à cause de la taille du pavé 

si je résume la partie qui concerne ce topic, l'algorithme est le suivant : ton script JS génère un tas de grille, et n'enregistre que celles qui respecte certains critère. Le shéma doit donc être le suivant :

var nbGrillesRetenues = 0;
var nbGrilleNécessaires = 8;

function generatriceDeGrille() {
  // renvoie une grille
}

function trouveEtTesteDesGrilles() {
  var grilleTestée;
  do {
    grilleTestée = generatriceDeGrille();
  } while (
    /* ici tu testes ta grille avec tes résolveurs*/
  );
  // si on sort de la boucle
  // c est que la grille respecte bien les critères
  // on peut la sauvegardée
  sauvegardeGrille(grilleTestée);
}

function sauvegardeGrille(grilleTestée) {
  $.ajax({
    // paramètres ajax
    success: function(data) {
      // la grille a été sauvegardée
      // sur le serveur, on reçoit un
      // id.
      // puis :
      nbGrilleRetenues++;
      if (nbGrilleRentenues < nbGrilleNécessaires) {
        trouveEtTesteDesGrilles();
      }
    };
  });
}

trouveEtTesteDesGrilles(); // on appelle une 1ère fois cette fonction qui s autoappellera ensuite tant que le nb de grille est insuffisant

-
Edité par LCaba 5 décembre 2017 à 11:27:05

Merci LCaba, ça a l'air de se présenter plutôt bien
Encore quelques ajustements ce soir ou demain et je pourrai (peut-être) valider cette étape.

Une question tout de même: pourquoi ta fonction "trouveEtTesteDesGrilles()" s'autoappelle ?






Ca génère une pile d'exécution considérable (il y a des tournois de 20 grilles et j'envisageais de générer plusieurs semaines en série ...).

Si on met cet appel dans une boucle do, ça ne revient pas au même, mais sans cette pile ?

-
Edité par chedev 6 décembre 2017 à 19:27:06

C'est justemeent à cause de l'asynchronisme qu'on peut pas utiliser une boucle do ou while !

Et du coup, y pas de pile d'appel, trouveEtTesteDesGrilles() termine sont exécution, puis quand la réponse du serveur arrive, trouveEtTesteDesGrilles() est appelé de nouveau.

Ah alors il faut que je revoie ma copie: je pensais m'être organisé comme tu avais construit ton exemple de code et le débogueur de FireFox m'affiche une pile d'exécution substantielle.

Copie ce script, et dis moi si tu as une pile de 10 appels :

n = 0;

function call() {
  $.ajax({
    url: '',
    success() {
      if (++n < 10)
        call();
    }
  });
}

Merci LCaba, je n'ai pas eu à recopier ce dernier petit script car j'ai maintenant obtenu (simplement après avoir bien relu ton script précédent) le bon résultat

Ca a été laborieux, mais il ne me reste plus que des bricoles à ajuster puis quelques ultimes contrôles et mon générateur "méthode moche" sera opérationnel !

Je serai alors prêt à attaquer ma cible finale: reprogrammer mon jeu proprement dit sans Flash.

Peux-tu me dire franchement compte tenu du mal que j'ai eu à arriver jusque là s'il est raisonnable que j'attaque ce chantier tout de suite ou s'il est préférable que je passe d'abord à la "bonne méthode" ?

Et si d'autres qui ont vu mes errement pour en arriver là veulent me donner leur point de vue, ils seront les bienvenus.

Je sais pas quoi te conseiller. Peut-être de lire ce tuto si c'est pas déjà fait : https://openclassrooms.com/courses/creez-des-pages-web-interactives-avec-javascript/decouvrez-le-dom 

Sans doute ça éclaircira certains points Mais le codage du jeu peut etre un bon exercice aussi.