Contador de segundos en Actionscript

elSuricatoRojo

Si lo que quieres es obtener el tiempo transcurrido entre 2 eventos que a priori no sabes de cuanto va a ser, en este caso, te puedes ahorrar el setInterval y solo utilizar Date ya que solo necesitas 1) Fijar el momento inicial y 2) Pedir en cualquier momento los segundos transcurridos. Entre medias no va a haber llamadas a funciones como lo haría el setInterval.

En este caso utilizas lo que has explicado antes para calcular el tiempo que ha transcurrido entre 2 eventos.

Pero, por ejemplo para lanzar una acción en un determinado tiempo o durante un determinado tiempo, necesitas de un setInterval o EnterFrame, eso es a lo que me refería antes.

Ahora, me parece buena idea controlar el tiempo por Date, es más efectivo.

Psycho, ahora soy yo quien no te sigue. El intervalo no hay que borrarlo ya que no existe... es un dato que devuelve una función. La frecuencia con que llames a get_tiempoTranscurrido() dependerá de la aplicación.

Si necesitas un cronometro que muestre los segundos vas a tener que llamar a get_tiempoTranscurrido() cada segundo e incluso puede ser aconsejable combinar la utilización de la solución que propongo basada en Date con un setInterval que la llame cada segundo (aunque yo me tiraría mas por utilizar un onEnterFrame).

Si lo que quieres es obtener el tiempo transcurrido entre 2 eventos que a priori no sabes de cuanto va a ser, en este caso, te puedes ahorrar el setInterval y solo utilizar Date ya que solo necesitas 1) Fijar el momento inicial y 2) Pedir en cualquier momento los segundos transcurridos. Entre medias no va a haber llamadas a funciones como lo haría el setInterval.

Pero entonces tienes que borrar el intervalo igualmente, porque aun con menos frequencia lo seguirá repitiendo...

Vaaaale, creo que ya lo entiendo. Tu lo que propones es hacer un intervalo del tiempo exacto que necesitas, en vez de estar contando hasta llegar a él.

Vas a necesitar guardar el dato de cuando queires empezar a contabilizar los segundos. En código sería mas o menos:

<code>
var miFecha:Date = new Date();
var tiempoInicio:Number;
function set_tiempoInicio():Void {
tiempoInicio = miFecha.getTime();
}
function get_tiempoTranscurrido():Number {
var tiempoActual:Number = miFecha.getTime();
var tiempoTranscurrido:Number = tiempoActual-tiempoInicio;
return (tiempoTranscurrido);
}
</code>

Con set_tiempoInicio() marcas el inicio para contabilizar, y con get_tiempoTranscurrido() pides el tiempo transcurrido desde que hicistes el set_tiempoInicio().

Ya, pero entonces tienes que utilizar algo para contabilizarlo, es decir:

+ obtengo una fechaInicio
+ calculo una fechaFinal

Qué metodología utilizaría para contar de fechaInicio a fechaFinal?

Cada vez que haces un getTime() te devuelve el tiempo en milisegundos desde 1/1/1970. Si haces un getTime ahora y otro dentro de 100 segundos los valores que recibas estarán desfasados 100000 milisegundos (cosas del espacio tiempo :-))

Y como contabilizas el tiempo transcurrido? Es decir, esos 108.266 segundos.

Eso es pero la fecha va en milisegundos desde el 1/1/1970, es decir que te devuelve un Number como: 1184579337265
El dato va en milisegundos por lo que en segundos serían: 1184579337.265

Si guardas el dato de cuando quieres empezar a contar (como "tiempoInicio" por ejemplo) y luego en un momento dado haces otro getTime() y te devuelve al como: 1184579445531 y lo guadas como "tiempoFin" (por ejemplo), tan solo tienes que hacer un calculo parecido a este:

var tiempoTranscurrido:Number=tiempoFin-tiempoInicio

...que con los datos de ejemplo que he puesto daría:
1184579445531-1184579337265=108266

o lo que es lo mismo 108.266 segundos.

que son 108.266 segundos

No lo acabo de entender... lo que haces en vez de guardar un contador es una variable de fecha?

Tambien puedes utilizar la clase Date y su método getTime() que te pasa los milisegundos transcurridos desde el 1/1/1970 (no se que paso ese día :-) ). Guardando el dato de cuando quieres empezar a contar segundos puedes calcular cuantos han pasado con un sencillo cálculo.

Las ventajas, en mi opinión, son en orden de importancia:
1) poder acceder cuando quieras al dato y que éste esté actualizado al milisegundo (con el setInterval el dato estará cuantificado en saltos de tantos milisegundos como hayas definido el setInterval).
2) no tener una función repitiendose cada n milisegundos
3) no estar pendiente de borrar el setInterval

elCronoSuricato

Acuérdate de borrar el intervalo cuando hayas contado pa no perder rendimiento:

<code>_root.segundos = 0
_root.totales = 50;
//----
_root.interContador = setInterval(function(){
_root.segundos++
if (_root.segundos == _root.totales) {
clearInterval(_root.interContador)
}
},1000);</code>

Lo puedes hacer con un setInterval

<code>
_root.segundos=0

_root.interContador = setInterval(function(){
_root.segundos++
},1000)
</code>

Lo he escrito directamente aqui... que no te extrañe que le falte algun parentesis ;)

ciaoo