diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md index b5b1da7a6..e6c9397f9 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/solution.md @@ -1,5 +1,5 @@ -Using `setInterval`: +Usando `setInterval`: ```js run function printNumbers(from, to) { @@ -14,12 +14,11 @@ function printNumbers(from, to) { }, 1000); } -// usage: +// uso: printNumbers(5, 10); ``` -Using nested `setTimeout`: - +Usando `setTimeout` anidado: ```js run function printNumbers(from, to) { @@ -34,13 +33,13 @@ function printNumbers(from, to) { }, 1000); } -// usage: +// uso: printNumbers(5, 10); ``` -Note that in both solutions, there is an initial delay before the first output. The function is called after `1000ms` the first time. +Tenga en cuenta que en ambas soluciones, hay un retraso inicial antes de la primera salida. La función se llama después de `1000ms` la primera vez. -If we also want the function to run immediately, then we can add an additional call on a separate line, like this: +Si también queremos que la función se ejecute inmediatamente, entonces podemos agregar una llamada adicional en una línea separada, como esta: ```js run function printNumbers(from, to) { diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md index 84bb0c39c..a15994ade 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/1-output-numbers-100ms/task.md @@ -2,11 +2,11 @@ importance: 5 --- -# Output every second +# Salida cada segundo -Write a function `printNumbers(from, to)` that outputs a number every second, starting from `from` and ending with `to`. +Escriba una función `printNumbers(from, to)` que genere un número cada segundo, comenzando desde `from` y terminando con `to`. -Make two variants of the solution. +Haz dos variantes de la solución. -1. Using `setInterval`. -2. Using nested `setTimeout`. +1. Usando `setInterval`. +2. Usando `setTimeout` anidado. diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md index e652a3b36..80834441b 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/solution.md @@ -1,14 +1,14 @@ -Any `setTimeout` will run only after the current code has finished. +Cualquier `setTimeout` se ejecutará solo después de que el código actual haya finalizado. -The `i` will be the last one: `100000000`. +La `i` será la última:` 100000000`. ```js run let i = 0; setTimeout(() => alert(i), 100); // 100000000 -// assume that the time to execute this function is >100ms +// supongamos que el tiempo para ejecutar esta función es> 100 ms for(let j = 0; j < 100000000; j++) { i++; } diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md index 667c8ffa6..2dbd1316a 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/4-settimeout-result/task.md @@ -2,25 +2,25 @@ importance: 5 --- -# What will setTimeout show? +# ¿Qué mostrará setTimeout? -In the code below there's a `setTimeout` call scheduled, then a heavy calculation is run, that takes more than 100ms to finish. +En el siguiente código hay una llamada programada `setTimeout`, luego se ejecuta un cálculo pesado, que demora más de 100 ms en finalizar. -When will the scheduled function run? +¿Cuándo se ejecutará la función programada? -1. After the loop. -2. Before the loop. -3. In the beginning of the loop. +1. Después del bucle. +2. Antes del bucle. +3. Al comienzo del bucle. -What is `alert` going to show? +¿Qué va a mostrar "alerta"? ```js let i = 0; setTimeout(() => alert(i), 100); // ? -// assume that the time to execute this function is >100ms +// supongamos que el tiempo para ejecutar esta función es> 100 ms for(let j = 0; j < 100000000; j++) { i++; } diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md index 95fddea65..4e52b0769 100644 --- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md +++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md @@ -1,39 +1,39 @@ -# Scheduling: setTimeout and setInterval +# Planificación: setTimeout y setInterval -We may decide to execute a function not right now, but at a certain time later. That's called "scheduling a call". +Podemos decidir ejecutar una función no ahora, sino en un momento posterior. Eso se llama "planificar una llamada". -There are two methods for it: +Hay dos métodos para ello: -- `setTimeout` allows us to run a function once after the interval of time. -- `setInterval` allows us to run a function repeatedly, starting after the interval of time, then repeating continuously at that interval. +- `setTimeout` nos permite ejecutar una función una vez después del intervalo de tiempo. +- `setInterval` nos permite ejecutar una función repetidamente, comenzando después del intervalo de tiempo, luego repitiéndose continuamente en ese intervalo. -These methods are not a part of JavaScript specification. But most environments have the internal scheduler and provide these methods. In particular, they are supported in all browsers and Node.js. +Estos métodos no son parte de la especificación de JavaScript. Pero la mayoría de los entornos tienen el planificador interno y proporcionan estos métodos. En particular, son compatibles con todos los navegadores y Node.js. ## setTimeout -The syntax: +La sintaxis: ```js -let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...) +let timerId = setTimeout(func|código, [retraso], [arg1], [arg2], ...) ``` -Parameters: +Parámetros: -`func|code` -: Function or a string of code to execute. -Usually, that's a function. For historical reasons, a string of code can be passed, but that's not recommended. +`func|código` +: Función o una cadena de código para ejecutar. +Por lo general, es una función. Por razones históricas, se puede pasar una cadena de código, pero eso no es recomendable. -`delay` -: The delay before run, in milliseconds (1000 ms = 1 second), by default 0. +`retraso` +: El retraso o *delay* antes de la ejecución, en milisegundos (1000 ms = 1 segundo), por defecto 0. `arg1`, `arg2`... -: Arguments for the function (not supported in IE9-) +: Argumentos para la función (no compatible con IE9-) -For instance, this code calls `sayHi()` after one second: +Por ejemplo, este código llama a `sayHi()` después de un segundo: ```js run function sayHi() { - alert('Hello'); + alert('Hola'); } *!* @@ -41,7 +41,7 @@ setTimeout(sayHi, 1000); */!* ``` -With arguments: +Con argumentos: ```js run function sayHi(phrase, who) { @@ -49,97 +49,97 @@ function sayHi(phrase, who) { } *!* -setTimeout(sayHi, 1000, "Hello", "John"); // Hello, John +setTimeout(sayHi, 1000, "Hola", "John"); // Hello, John */!* ``` -If the first argument is a string, then JavaScript creates a function from it. +Si el primer argumento es un string, entonces JavaScript crea una función a partir de ella. -So, this will also work: +Entonces, esto también funcionará: ```js run no-beautify -setTimeout("alert('Hello')", 1000); +setTimeout("alert('Hola')", 1000); ``` -But using strings is not recommended, use arrow functions instead of them, like this: +Pero no se recomienda usar strings, use funciones de flecha en lugar de ellas, como esta: ```js run no-beautify -setTimeout(() => alert('Hello'), 1000); +setTimeout(() => alert('Hola'), 1000); ``` -````smart header="Pass a function, but don't run it" -Novice developers sometimes make a mistake by adding brackets `()` after the function: +````smart header="Pasa una función, pero no la ejecuta" +Los desarrolladores novatos a veces cometen un error al agregar paréntesis `()` después de la función: ```js -// wrong! +// mal! setTimeout(sayHi(), 1000); ``` -That doesn't work, because `setTimeout` expects a reference to a function. And here `sayHi()` runs the function, and the *result of its execution* is passed to `setTimeout`. In our case the result of `sayHi()` is `undefined` (the function returns nothing), so nothing is scheduled. + +Eso no funciona, porque `setTimeout` espera una referencia a una función. Y aquí `sayHi()` ejecuta la función, y el *resultado de su ejecución* se pasa a `setTimeout`. En nuestro caso, el resultado de `sayHi()` es `undefined` (la función no devuelve nada), por lo que no hay nada planificado. ```` -### Canceling with clearTimeout +### Cancelando con clearTimeout -A call to `setTimeout` returns a "timer identifier" `timerId` that we can use to cancel the execution. +Una llamada a `setTimeout` devuelve un "identificador de temporizador" `timerId` que podemos usar para cancelar la ejecución. -The syntax to cancel: +La sintaxis para cancelar: ```js let timerId = setTimeout(...); clearTimeout(timerId); ``` -In the code below, we schedule the function and then cancel it (changed our mind). As a result, nothing happens: +En el siguiente código, planificamos la función y luego la cancelamos (cambiamos de opinión). Como resultado, no pasa nada: ```js run no-beautify -let timerId = setTimeout(() => alert("never happens"), 1000); -alert(timerId); // timer identifier +let timerId = setTimeout(() => alert("no pasa nada"), 1000); +alert(timerId); // identificador del temporizador clearTimeout(timerId); -alert(timerId); // same identifier (doesn't become null after canceling) +alert(timerId); // mismo identificador (No se vuelve nulo después de cancelar) ``` -As we can see from `alert` output, in a browser the timer identifier is a number. In other environments, this can be something else. For instance, Node.js returns a timer object with additional methods. +Como podemos ver en la salida `alert`, en un navegador el identificador del temporizador es un número. En otros entornos, esto puede ser otra cosa. Por ejemplo, Node.js devuelve un objeto de temporizador con métodos adicionales. -Again, there is no universal specification for these methods, so that's fine. +Nuevamente, no hay una especificación universal para estos métodos. -For browsers, timers are described in the [timers section](https://www.w3.org/TR/html5/webappapis.html#timers) of HTML5 standard. +Para los navegadores, los temporizadores se describen en el [timers section](https://www.w3.org/TR/html5/webappapis.html#timers) de el estándar HTML5. ## setInterval -The `setInterval` method has the same syntax as `setTimeout`: +El método `setInterval` tiene la misma sintaxis que `setTimeout`: ```js -let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...) +let timerId = setInterval(func|código, [retraso], [arg1], [arg2], ...) ``` +Todos los argumentos tienen el mismo significado. Pero a diferencia de `setTimeout`, ejecuta la función no solo una vez, sino regularmente después del intervalo de tiempo dado. -All arguments have the same meaning. But unlike `setTimeout` it runs the function not only once, but regularly after the given interval of time. - -To stop further calls, we should call `clearInterval(timerId)`. +Para detener las llamadas, debemos llamar a 'clearInterval (timerId)'. -The following example will show the message every 2 seconds. After 5 seconds, the output is stopped: +El siguiente ejemplo mostrará el mensaje cada 2 segundos. Después de 5 segundos, la salida se detiene: ```js run -// repeat with the interval of 2 seconds +// repetir con el intervalo de 2 segundos let timerId = setInterval(() => alert('tick'), 2000); -// after 5 seconds stop +// después de 5 segundos parar setTimeout(() => { clearInterval(timerId); alert('stop'); }, 5000); ``` -```smart header="Time goes on while `alert` is shown" -In most browsers, including Chrome and Firefox the internal timer continues "ticking" while showing `alert/confirm/prompt`. +```smart header="El tiempo pasa mientras se muestra 'alerta'" +En la mayoría de los navegadores, incluidos Chrome y Firefox, el temporizador interno continúa "marcando" mientras muestra "alert / confirm / prompt". -So if you run the code above and don't dismiss the `alert` window for some time, then in the next `alert` will be shown immediately as you do it. The actual interval between alerts will be shorter than 2 seconds. +Entonces, si ejecuta el código anterior y no descarta la ventana de 'alerta' por un tiempo, en la próxima 'alerta' se mostrará de inmediato. El intervalo real entre alertas será más corto que 2 segundos. ``` -## Nested setTimeout +## setTimeout anidado -There are two ways of running something regularly. +Hay dos formas de ejecutar algo regularmente. -One is `setInterval`. The other one is a nested `setTimeout`, like this: +Uno es `setInterval`. El otro es un `setTimeout` anidado, como este: ```js -/** instead of: +/** en vez de: let timerId = setInterval(() => alert('tick'), 2000); */ @@ -151,21 +151,21 @@ let timerId = setTimeout(function tick() { }, 2000); ``` -The `setTimeout` above schedules the next call right at the end of the current one `(*)`. +El `setTimeout` anterior planifica la siguiente llamada justo al final de la actual `(*)`. -The nested `setTimeout` is a more flexible method than `setInterval`. This way the next call may be scheduled differently, depending on the results of the current one. +El `setTimeout` anidado es un método más flexible que `setInterval`. De esta manera, la próxima llamada se puede planificar de manera diferente, dependiendo de los resultados de la actual. -For instance, we need to write a service that sends a request to the server every 5 seconds asking for data, but in case the server is overloaded, it should increase the interval to 10, 20, 40 seconds... +Por ejemplo, necesitamos escribir un servicio que envíe una solicitud al servidor cada 5 segundos solicitando datos, pero, en caso de que el servidor esté sobrecargado, debería aumentar el intervalo a 10, 20, 40 segundos ... -Here's the pseudocode: +Aquí está el pseudocódigo: ```js let delay = 5000; let timerId = setTimeout(function request() { - ...send request... + ...enviar solicitud... - if (request failed due to server overload) { - // increase the interval to the next run + if (solicitud fallida debido a sobrecarga del servidor) { + //aumentar el intervalo en la próxima ejecución delay *= 2; } @@ -174,12 +174,11 @@ let timerId = setTimeout(function request() { }, delay); ``` +Y si las funciones que estamos planificando requieren mucha CPU, entonces podemos medir el tiempo que tarda la ejecución y planificar la próxima llamada, tarde o temprano. -And if the functions that we're scheduling are CPU-hungry, then we can measure the time taken by the execution and plan the next call sooner or later. - -**Nested `setTimeout` allows to set the delay between the executions more precisely than `setInterval`.** +**`setTimeout` anidado permite establecer el retraso entre las ejecuciones con mayor precisión que `setInterval`.** -Let's compare two code fragments. The first one uses `setInterval`: +Comparemos dos fragmentos de código. El primero usa `setInterval`: ```js let i = 1; @@ -188,7 +187,7 @@ setInterval(function() { }, 100); ``` -The second one uses nested `setTimeout`: +El segundo usa `setTimeout` anidado: ```js let i = 1; @@ -198,105 +197,105 @@ setTimeout(function run() { }, 100); ``` -For `setInterval` the internal scheduler will run `func(i++)` every 100ms: +Para `setInterval` el planificador interno se ejecutará `func(i++)` cada 100ms: ![](setinterval-interval.svg) -Did you notice? +¿Te diste cuenta? -**The real delay between `func` calls for `setInterval` is less than in the code!** +**¡El retraso real entre las llamadas de `func` para `setInterval` es menor que en el código!** -That's normal, because the time taken by `func`'s execution "consumes" a part of the interval. +Eso es normal, porque el tiempo que tarda la ejecución de `func` "consume" una parte del intervalo. -It is possible that `func`'s execution turns out to be longer than we expected and takes more than 100ms. +Es posible que la ejecución de `func` sea más larga de lo esperado y demore más de 100 ms. -In this case the engine waits for `func` to complete, then checks the scheduler and if the time is up, runs it again *immediately*. +En este caso, el motor espera a que se complete `func`, luego verifica el planificador y, si se acabó el tiempo, lo ejecuta de nuevo *inmediatamente*. -In the edge case, if the function always executes longer than `delay` ms, then the calls will happen without a pause at all. +En el caso límite, si la función siempre se ejecuta más que el `retraso` ms, entonces las llamadas se realizarán sin pausa alguna. -And here is the picture for the nested `setTimeout`: +Y aquí está la imagen para el `setTimeout` anidado: ![](settimeout-interval.svg) -**The nested `setTimeout` guarantees the fixed delay (here 100ms).** +**El `setTimeout` anidado garantiza el retraso fijo (aquí 100ms).** -That's because a new call is planned at the end of the previous one. +Esto se debe a que se planea una nueva llamada al final de la anterior. -````smart header="Garbage collection and setInterval/setTimeout callback" -When a function is passed in `setInterval/setTimeout`, an internal reference is created to it and saved in the scheduler. It prevents the function from being garbage collected, even if there are no other references to it. +````smart header="Recolección de basura y setInterval/setTimeout callback" +Cuando se pasa una función en `setInterval / setTimeout`, se crea una referencia interna y se guarda en el planificador. Evita que la función se recolecte, incluso si no hay otras referencias a ella.. ```js -// the function stays in memory until the scheduler calls it +// la función permanece en la memoria hasta que el planificador la llame setTimeout(function() {...}, 100); ``` -For `setInterval` the function stays in memory until `clearInterval` is called. +Para `setInterval`, la función permanece en la memoria hasta que se invoca `clearInterval`. -There's a side-effect. A function references the outer lexical environment, so, while it lives, outer variables live too. They may take much more memory than the function itself. So when we don't need the scheduled function anymore, it's better to cancel it, even if it's very small. -```` +Hay un efecto secundario. Una función hace referencia al entorno léxico externo, por lo tanto, mientras vive, las variables externas también viven. Pueden tomar mucha más memoria que la función misma. Entonces, cuando ya no necesitamos la función planificada, es mejor cancelarla, incluso si es muy pequeña. -## Zero delay setTimeout +## Retraso cero en setTimeout -There's a special use case: `setTimeout(func, 0)`, or just `setTimeout(func)`. +Hay un caso de uso especial: `setTimeout (func, 0)`, o simplemente `setTimeout (func)`. -This schedules the execution of `func` as soon as possible. But the scheduler will invoke it only after the currently executing script is complete. +Esto planifica la ejecución de `func` lo antes posible. Pero el planificador lo invocará solo después de que se complete el script que se está ejecutando actualmente. -So the function is scheduled to run "right after" the current script. +Por lo tanto, la función está planificada para ejecutarse "justo después" del script actual. -For instance, this outputs "Hello", then immediately "World": +Por ejemplo, esto genera "Hola", e inmediatamente después "Mundo": ```js run -setTimeout(() => alert("World")); +setTimeout(() => alert("Mundo")); -alert("Hello"); +alert("Hola"); ``` -The first line "puts the call into calendar after 0ms". But the scheduler will only "check the calendar" after the current script is complete, so `"Hello"` is first, and `"World"` -- after it. +La primera línea "pone la llamada en el calendario después de 0 ms". Pero el planificador solo "verificará el calendario" una vez que se haya completado el script actual, por lo que "Hola" es primero y "Mundo"` -- después. -There are also advanced browser-related use cases of zero-delay timeout, that we'll discuss in the chapter . +También hay casos de uso avanzados relacionados con el navegador y el tiempo de espera cero (zero-delay), que discutiremos en el capítulo . -````smart header="Zero delay is in fact not zero (in a browser)" -In the browser, there's a limitation of how often nested timers can run. The [HTML5 standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) says: "after five nested timers, the interval is forced to be at least 4 milliseconds.". +````smart header="De hecho, el retraso cero no es cero (en un navegador)" +En el navegador, hay una limitación de la frecuencia con la que se pueden ejecutar los temporizadores anidados. EL [HTML5 standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers) dice: "después de cinco temporizadores anidados, el intervalo debe ser de al menos 4 milisegundos". -Let's demonstrate what it means with the example below. The `setTimeout` call in it re-schedules itself with zero delay. Each call remembers the real time from the previous one in the `times` array. What do the real delays look like? Let's see: +Demostremos lo que significa con el siguiente ejemplo. La llamada `setTimeout` se planifica a sí misma con cero retraso. Cada llamada recuerda el tiempo real de la anterior en el array `times`. ¿Cómo son los retrasos reales? Veamos: ```js run let start = Date.now(); let times = []; setTimeout(function run() { - times.push(Date.now() - start); // remember delay from the previous call + times.push(Date.now() - start); // recuerda el retraso de la llamada anterior - if (start + 100 < Date.now()) alert(times); // show the delays after 100ms - else setTimeout(run); // else re-schedule + if (start + 100 < Date.now()) alert(times); // smostrar los retrasos después de 100 ms + else setTimeout(run); // de lo contrario replanificar }); -// an example of the output: +// Un ejemplo de la salida: // 1,1,1,1,9,15,20,24,30,35,40,45,50,55,59,64,70,75,80,85,90,95,100 ``` -First timers run immediately (just as written in the spec), and then we see `9, 15, 20, 24...`. The 4+ ms obligatory delay between invocations comes into play. +Los primeros temporizadores se ejecutan inmediatamente (tal como está escrito en la especificación), y luego vemos `9, 15, 20, 24 ...`. Entra en juego el retraso obligatorio de más de 4 ms entre invocaciones. -The similar thing happens if we use `setInterval` instead of `setTimeout`: `setInterval(f)` runs `f` few times with zero-delay, and afterwards with 4+ ms delay. +Lo mismo sucede si usamos `setInterval` en lugar de `setTimeout`: `setInterval(f)` ejecuta `f` algunas veces con cero retardo, y luego con 4+ ms de retraso. -That limitation comes from ancient times and many scripts rely on it, so it exists for historical reasons. +Esa limitación proviene de la antigüedad y muchos guiones dependen de ella, por lo que existe por razones históricas. -For server-side JavaScript, that limitation does not exist, and there exist other ways to schedule an immediate asynchronous job, like [setImmediate](https://nodejs.org/api/timers.html) for Node.js. So this note is browser-specific. +Para JavaScript del lado del servidor, esa limitación no existe, y existen otras formas de planificar un trabajo asincrónico inmediato, como [setImmediate](https://nodejs.org/api/timers.html) para Node.js. Entonces esta nota es específica del navegador. ```` -## Summary +## Resumen + +- Los métodos `setTimeout(func, delay, ... args)` y `setInterval(func, delay, ... args)` nos permiten ejecutar el `func` una vez / regularmente después de un retardo (delay) en milisegundos. +- Para cancelar la ejecución, debemos llamar a `clearTimeout / clearInterval` con el valor devuelto por `setTimeout / setInterval`. +- Las llamadas anidadas `setTimeout` son una alternativa más flexible a `setInterval`, lo que nos permite establecer el tiempo *entre* ejecuciones con mayor precisión. +- La programación de retardo cero con `setTimeout(func, 0) `(lo mismo que `setTimeout(func)`) se usa para programar la llamada "lo antes posible, pero después de que se complete el script actual". +- El navegador limita la demora mínima para cinco o más llamadas anidadas de `setTimeout` o para `setInterval` (después de la quinta llamada) a 4 ms. Eso es por razones históricas. -- Methods `setTimeout(func, delay, ...args)` and `setInterval(func, delay, ...args)` allow us to run the `func` once/regularly after `delay` milliseconds. -- To cancel the execution, we should call `clearTimeout/clearInterval` with the value returned by `setTimeout/setInterval`. -- Nested `setTimeout` calls are a more flexible alternative to `setInterval`, allowing us to set the time *between* executions more precisely. -- Zero delay scheduling with `setTimeout(func, 0)` (the same as `setTimeout(func)`) is used to schedule the call "as soon as possible, but after the current script is complete". -- The browser limits the minimal delay for five or more nested call of `setTimeout` or for `setInterval` (after 5th call) to 4ms. That's for historical reasons. +Tenga en cuenta que todos los métodos de planifiación no *garantizan* el retraso exacto. -Please note that all scheduling methods do not *guarantee* the exact delay. +Por ejemplo, el temporizador en el navegador puede ralentizarse por muchas razones: +- La CPU está sobrecargada. +- La pestaña del navegador está en modo de fondo. +- El portátil está con batería. -For example, the in-browser timer may slow down for a lot of reasons: -- The CPU is overloaded. -- The browser tab is in the background mode. -- The laptop is on battery. +Todo eso puede aumentar la resolución mínima del temporizador (el retraso mínimo) a 300 ms o incluso 1000 ms dependiendo de la configuración de rendimiento del navegador y del nivel del sistema operativo. -All that may increase the minimal timer resolution (the minimal delay) to 300ms or even 1000ms depending on the browser and OS-level performance settings. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy