1. Accueil
  2. Javascript
  3. Sources Javascript
  4. Sources Date & Heure
  5. Sleep() sans boucle d'attente consommatrice

Sleep() sans boucle d'attente consommatrice

Soyez le premier à donner votre avis sur cette source.

Vue 7 606 fois - Téléchargée 332 fois

Télécharger le projet
Commenter

Description

J'ai créé cette fonction sleep([temps de pause]) pour mes propres besoins (effets visuels principalement, ou diaporama), elle qui peut être utilisée partout, même dans des objets, sans recours à une boucle d'attente consommatrice.
Elle est un peu contraignante au niveau de son implémentation, mais mais beaucoup plus facile que l'utilisation d'un time out.
Il suffit de copier-coller le code proposé pour l'utiliser.

Source / Exemple : 


/*----------------------------------------------------------------------

	POUR UN PETIT SOMME
	
Auteur : Phil Perret (philippe.perret@yahoo.fr)
Date : Janvier 2010

	Un exemple est proposé en bas de page, qu'il suffit d'appeler avec :
	
	AppelTestSleep()
	
	cf. l'explication de l'utilisation dans le fichier "sleep.dat"
	
----------------------------------------------------------------------*/

/*----------------------------------------------------------------------

	POUR UTILISER LES PAUSES DANS VOS SCRIPTS, COPIER-COLLER LE CODE CI-DESSOUS
	
	Le code ci-dessous permet de faire des pauses (sleep, wait) dans une fonction.
	
	Dans le code ci-dessous :
		– Tous les `maFonction` doivent être remplacés par le nom de votre fonction (de vos fonctions).
		– Les temps doivent bien sûr être adaptés suivant votre convenance
	
	
	Note : pour récupérer un argument envoyé à la fonction/méthode, il suffit d'utiliser :
	
		var <maValeur> = my.<nomFonction>.args[<indice argument>];
		
		où
			<nomFonction>	Nom de la fonction/méthode
			<indice arg>	Indice de l'argument quand il a été envoyé
							en appelant <nomFonction> (0-start)
	
	

	// *************** CODE À COPIER *********************
	
	function maFonction(arg1 [, arg2&#8230; argN]){
	
		// Initialisation
		if ( "undefined" != typeof this.maFonction ){
			my = this ;
			this.maFonction.my = this ;
			my.maFonction.etape = 0 ;
			// Conserver les arguments
			my.maFonction.args= my.maFonction.arguments ;
		} else {
			my = arg1 ;
		}

		if (my.maFonction.etape<(step=1)){
		
			//*****************************************
			//
			// Définir ici ce qu'il faut faire avant
			// le premier arrêt
			//
			//*****************************************
			
		// Premier break (2 secondes)
		sleep(2000);}else if(my.maFonction.etape<(++step) ){
		
			//*****************************************
			//
			// Définir ici ce qu'il faut faire avant
			// le deuxième arrêt
			//
			//*****************************************
			
		// Deuxième break
		sleep(1500);}else if(my.maFonction.etape<(++step) ){
		
			//*****************************************
			//
			// Définir ici ce qu'il faut faire avant
			// le troisième arrêt
			//
			//*****************************************

		//*****************************************
		//
		// Ajouter autant d'arrêts que voulu simplement en 
		// copiant-collant la ligne commençant par 'sleep('
		// ci-dessus.
		//
		//	Penser à :
		//		1/ Remplacer "maFonction" par le nom de votre
		//		   fonction
		//		2/ Indiquer correctement le temps d'arrêt
		//
		//*****************************************

		// Dernier break, de 10 secondes
		sleep(10000);} else {

			//*****************************************
			//
			// Définir ici ce qu'il faut faire pour
			// terminer
			//
			//*****************************************
		
		}
	}
	// *************** FIN CODE À COPIER *********************
	
----------------------------------------------------------------------*/

function sleep(temps){
	this.awake.appelante= this.sleep.caller ;
	this.awake.contexte = this.sleep.caller.my ;
	this.awake.timer = setTimeout(awake, temps);
}
function awake(){
	this.awake.appelante.etape ++ ;
	this.awake.appelante(this.awake.contexte) ;
}
/*
	
	LE CODE CI-DESSOUS (JUSQU'AU BOUT) EST DONNÉ POUR EXEMPLE. IL PEUT ÊTRE DÉTRUIT.
	
	Pour l'essayer, jouer : 
	
		AppelTestSleep();


  • /


function AppelTestSleep(){
	monObjetTest.TestSleep("Le premier pour dire bonjour", "le second pour dire au revoir");
}

var monObjetTest= {
	
	mon_age: 46,
	mon_age_mental: 4,
	
	TestSleep: function(message1, message2) {
		
		// Initialisation
		if ( "undefined" != typeof this.TestSleep ){
			my = this ;
			this.TestSleep.my = this ;
			my.TestSleep.etape = 0 ;
			// Conserver les arguments
			my.TestSleep.args= my.TestSleep.arguments ;
		} else {
			my = message1 ;
		}
	
		if ( my.TestSleep.etape<(step=1)) {
		
			alert("Je vais délivrer le premier message dans 5 secondes.");
			
			sleep(5000);
		}
		else if (  my.TestSleep.etape < (++step) ) {
		
			alert("Le premier message est : " + my.TestSleep.args[0] 
				+ "\n\nJe donnerai le suivant dans 3 secondes.") ;
			
			sleep(3000);
		}
		else if (  my.TestSleep.etape < (++step) ) {
		
			alert("Le deuxième message est : " + my.TestSleep.args[1] 
				+ "\n\nEt j'ai " + my.mon_age + " ans."
				+ "\n\nJe terminerai dans 6 secondes, si Dieu le veut.") ;
		
			sleep(6000);
		} else {
			alert("j'ai fini !");
		}
	}
}
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Signaler
Messages postés
647
Date d'inscription
samedi 30 décembre 2000
Statut
Membre
Dernière intervention
20 juillet 2012
 6
Merci, je connais déjà cette fonction et ce n'est pas ce que je recherche ;)

En fait je souhaite retourner un résultat à la fonction appelante

Cela ne marchera pas si je fais un setInterval() car dans ce cas la fonction retournera automatiquement undefined

Laissez faire, je pense à utiliser une autre méthode ;) Mais merci tout de même ;)
Signaler
Messages postés
3
Date d'inscription
jeudi 19 février 2009
Statut
Membre
Dernière intervention
13 janvier 2010
Merci JDMCreator,

Pour ton problème, utiliser mon script, ce serait utiliser un bazooka pour écraser une mouche.

Ce que tu décris, c'est la fonctionnalité principale de setInterval, donc je te conseillerais de voir par là. setInterval permet d'appeler à intervalle régulier une fonction/du code (donc pour toi la fonction de condition de test).

Schématiquement :

function MaFonctionQuiTraiteLaCondition(){
//…
//… ici on traite la condition
//…
}

//= Lancement de la boucle temporisée
// Le code signifie : "tous les 1000 millièmes de secondes
// (toute les secondes), appeler la fonction
// `MaFonctionQuiTraiteLaCondition`"var maBoucleDeCondsetInterval(MaFonctionQuiTraiteLaCondition, 1000 /* 1000 millième de secondes */);

(à vérifier : le premier argument de setInterval doit peut-être être un string, pas une référence : "MaFonctionQuiTraiteLaCondition")

Hope it helps
Signaler
Messages postés
647
Date d'inscription
samedi 30 décembre 2000
Statut
Membre
Dernière intervention
20 juillet 2012
 6
Bonjour,

Félicitation ! Votre code est exactement ce qu'il me faut ! Malheureusement, j'ai du mal à l'adapté à ma situation.

Je souhaiterais l'utiliser en boucle, je m'explique

À chaque seconde, on vérifie une condition, sinon, on fait une pause puis on regarde de nouveau la condition après ce lap de temps

Pourriez-vous m'aider s'il vous plaît ?
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (phildepantin)