Tambien podriamos agregar un setError(false), cuando se da click en el botón comprobar...
<button
onClick={() => {
setLoading(true);
setError(false);
}} >
Check
</button>
Cuando trabajas con componentes funcionales en React, cada estado vive en su propia línea de código, con su propia variable y su propio actualizador. Esto les da independencia total, pero también plantea retos importantes cuando una sola acción del usuario necesita modificar varios estados a la vez. Entender cómo y dónde actualizar cada estado es fundamental para evitar errores sutiles que pueden romper la experiencia de tu aplicación.
¿Cómo funcionan los estados independientes con useState?
A diferencia de los componentes de clase, donde todo el estado vive dentro de this.state como un único objeto, los estados independientes se declaran por separado con useState. Cada uno tiene su variable y su función actualizadora [0:42]:
value y setValue: almacena lo que el usuario escribe en el input.error y setError: indica si el código de seguridad es incorrecto.loading y setLoading: controla si la aplicación está en estado de carga.Esto significa que no existe un setState general. Cada estado se actualiza de forma completamente aislada, lo cual es limpio y predecible en escenarios simples, pero requiere coordinación cuidadosa cuando varios estados deben cambiar al mismo tiempo.
¿Cómo capturar el valor dinámico de un input?
Para conectar un input con el estado, se necesitan dos cosas [1:23]:
value como el valor del input, vinculándolo al estado declarado en useState.onChange y llamar a setValue(event.target.value) para actualizar el estado con lo que el usuario escribe.Cada pulsación de tecla dispara una actualización del estado. Un console.log(value) permite comprobar que el estado se sincroniza correctamente con cada cambio en el input [2:24].
¿Cómo validar el código de seguridad contra un valor esperado?
Se define una constante fuera del componente, siguiendo la convención de mayúsculas con guiones bajos para variables que nunca cambian [2:50]:
javascript const SECURITY_CODE = "paradigma";
Dentro del useEffect, cuando el estado loading es true, se simula una llamada al backend con setTimeout. Al terminar la espera, se compara value con SECURITY_CODE [3:30]:
javascript if (value === SECURITY_CODE) { setLoading(false); setError(false); } else { setLoading(false); setError(true); }
Si el código coincide, se quita la carga sin mostrar error. Si no coincide, se quita la carga y se activa el estado de error.
¿Qué problema surge al actualizar varios estados independientes?
Aquí aparece el dilema central de los estados independientes [5:50]. Cuando el usuario escribe un código incorrecto y luego intenta con el correcto sin recargar la página, ocurre lo siguiente:
setError(true) en el primer intento.setLoading(true) se ejecuta, pero nadie limpia el error antes de la nueva validación.setError(false) en el flujo adecuado [6:40].Este comportamiento incorrecto ocurre porque cada actualizador es independiente. No hay un mecanismo automático que resetee los demás estados cuando uno cambia. Cuando una interacción del usuario implica cambiar varios estados en una misma acción, hay que llamar a múltiples actualizadores en bloque, literalmente uno tras otro [7:10].
¿Dónde es correcto actualizar cada estado?
La pregunta más importante no es solo cómo corregir el bug, sino dónde colocar cada actualización de estado. Existen varias formas de resolverlo:
error a false justo cuando el usuario hace clic en comprobar, antes de entrar al efecto.useEffect, al inicio de la validación.setError(false) explícitamente en ambas ramas del condicional.Cada enfoque tiene implicaciones distintas en legibilidad y en el momento exacto en que el usuario deja de ver el mensaje de error. No existe una única solución correcta; lo relevante es entender que los estados independientes te obligan a ser explícito y deliberado con cada actualización.
Este tipo de retos crecen a medida que la aplicación escala. ¿Cuántas formas distintas se te ocurren para resolver este problema? Comparte tu solución y compárala con las alternativas.
Cuando trabajas con componentes funcionales en React, cada estado vive en su propia línea de código, con su propia variable y su propio actualizador. Esto les da independencia total, pero también plantea retos importantes cuando una sola acción del usuario necesita modificar varios estados a la vez. Entender cómo y dónde actualizar cada estado es fundamental para evitar errores sutiles que pueden romper la experiencia de tu aplicación.
A diferencia de los componentes de clase, donde todo el estado vive dentro de this.state como un único objeto, los estados independientes se declaran por separado con useState. Cada uno tiene su variable y su función actualizadora [0:42]:
value y setValue: almacena lo que el usuario escribe en el input.error y setError: indica si el código de seguridad es incorrecto.loading y setLoading: controla si la aplicación está en estado de carga.Esto significa que no existe un setState general. Cada estado se actualiza de forma completamente aislada, lo cual es limpio y predecible en escenarios simples, pero requiere coordinación cuidadosa cuando varios estados deben cambiar al mismo tiempo.
Para conectar un input con el estado, se necesitan dos cosas [1:23]:
value como el valor del input, vinculándolo al estado declarado en useState.onChange y llamar a setValue(event.target.value) para actualizar el estado con lo que el usuario escribe.Cada pulsación de tecla dispara una actualización del estado. Un console.log(value) permite comprobar que el estado se sincroniza correctamente con cada cambio en el input [2:24].
Se define una constante fuera del componente, siguiendo la convención de mayúsculas con guiones bajos para variables que nunca cambian [2:50]:
javascript const SECURITY_CODE = "paradigma";
Dentro del useEffect, cuando el estado loading es true, se simula una llamada al backend con setTimeout. Al terminar la espera, se compara value con SECURITY_CODE [3:30]:
javascript if (value === SECURITY_CODE) { setLoading(false); setError(false); } else { setLoading(false); setError(true); }
Si el código coincide, se quita la carga sin mostrar error. Si no coincide, se quita la carga y se activa el estado de error.
Aquí aparece el dilema central de los estados independientes [5:50]. Cuando el usuario escribe un código incorrecto y luego intenta con el correcto sin recargar la página, ocurre lo siguiente:
setError(true) en el primer intento.setLoading(true) se ejecuta, pero nadie limpia el error antes de la nueva validación.setError(false) en el flujo adecuado [6:40].Este comportamiento incorrecto ocurre porque cada actualizador es independiente. No hay un mecanismo automático que resetee los demás estados cuando uno cambia. Cuando una interacción del usuario implica cambiar varios estados en una misma acción, hay que llamar a múltiples actualizadores en bloque, literalmente uno tras otro [7:10].
La pregunta más importante no es solo cómo corregir el bug, sino dónde colocar cada actualización de estado. Existen varias formas de resolverlo:
error a false justo cuando el usuario hace clic en comprobar, antes de entrar al efecto.useEffect, al inicio de la validación.setError(false) explícitamente en ambas ramas del condicional.Cada enfoque tiene implicaciones distintas en legibilidad y en el momento exacto en que el usuario deja de ver el mensaje de error. No existe una única solución correcta; lo relevante es entender que los estados independientes te obligan a ser explícito y deliberado con cada actualización.
Este tipo de retos crecen a medida que la aplicación escala. ¿Cuántas formas distintas se te ocurren para resolver este problema? Comparte tu solución y compárala con las alternativas.
Tambien podriamos agregar un setError(false), cuando se da click en el botón comprobar...
<button
onClick={() => {
setLoading(true);
setError(false);
}} >
Check
</button>
Yo simplemente agregaria un setError(false) al inicio del efecto
if (loading) {
setError(false);
setTimeout(() => {
console.log("Haciendo la validación");
if (value === SEGURITY_CODE) {
setLoading(false);
} else {
setError(true);
setLoading(false);
}
console.log("terminando la validación");
}, 1000)
}
++Reto de la clase++ manteniendo el mismo código, solo agregando un else con setError(false)
useEffect(
() => {
if (loading) {
setTimeout(() => {
if (value !== SECURITY_CODE) {
setError(true)
}else{
setError(false)
}
setLoading(false)
}, 1000)
}
}, [ loading ] )
También se le pudiera poner un setTimeout al setError para quitarlo. La otra forma que se me ocurre es que en el evento onChange al ejecutarse, poner setError(false), así escribes en el input y nunca tendrás un error mostrándose :)
Mi manera de solucionarlo es que cuado loading es true, llamamos a setError(false) para que desaparezca el mensaje y solo se vea el de “Cargando…” desués si el valor es igual al codgo de seguridad tambien ponemos setError(false) para que no nos estorbe.
React.useEffect(() => {
console.log("Empezando...")
if (!!loading) {
setError(false);
setTimeout(() => {
console.log("Haciendo la validacion...")
if(value === SECURITY_CODE) {
setLoading(false);
setError(false);
} else {
setLoading(false);
setError(true);
}
console.log("Terminando la validacion...")
}, 2000)
}
console.log("Acabando...")
}, [loading])
Hice una función llamada handleChange() en donde el estado de error lo cambio a falso, de esta forma en cuanto el usuario modifique el texto del input, el mensaje de error desaparece :)
const handleChange = (event) => {
setValue(event.target.value);
setError(false);
}
<input
type="text"
placeholder="Código de seguridad"
value={value}
onChange={(event) => handleChange(event)}
/>
Los estados independientes o simples con estados que no dependen uno del otro para funcionar. Solo dependen de una variable con un actualizador del estado:
// Sintaxis
const [estado, actualizadorEstado] = React.useState(valorInicial);
// Ejemplo
const [puntuacion, setPuntuacion] = React.useState(0);
Para entender que son los estados simples o independientes vamos a hacer un pequeño código de ejemplo:
Vamos a crear un nuevo estado que será la validación de nuestro input, por lo que será dinámico, su valor inicial es un string vacío.
function UseState({ name }) {
const [value, setValue] = React.useState('');
...
}
Ahora en nuestro input vamos a hacer que el valor del estado sea lo que haya dentro del input.
function UseState(...) {
...
<input
placeholder="Código de seguridad"
value={value}
onChange={(event) => {
setValue(event.target.value)
}}
/>
}
Ya estamos recibiendo el valor del input en nuestra variable del estado.
Lo que debemos hacer es crear una forma de validar nuestro código de seguridad, ósea que el valor que pase el usuario sea el valor esperado que necesitamos para validar el código y dejar al usuario hacer lo que necesite.
Para esto vamos a crear una variable por fuera de nuestro componente:
const SECURITY_CODE = 'paradigma';
Ahora queremos que en caso de que el código que escribió el usuario es incorrecto nosotros se lo podamos indicar, y en caso de que sí, el flujo de la aplicación continúa:
function UseState({ name }) {
...
React.useEffect(() => {
if(loading) {
setError(false);
setTimeout(() => {
if(value === SECURITY_CODE) {
setLoading(false);
} else {
setLoading(false);
setError(true);
}
},3000);
}
}, [loading]);
...
}
Y listo, ya tenemos un entendimiento de como funcionan los estados simples y si uso práctico.

// This function is called when the form is submitted
const onValidation = (e) => {
e.preventDefault();
setMessage('');
setLoading(true);
};
{message && (
<p className={error ? 'text-red-400' : 'text-green-400'}>{message}</p>
)}
Según yo la forma un poco mas eficiente y con mejor experiencia de usuario es quitar el error al momento que el usuario cambia el input nuevamente de la siguiente manera
comprobando primero si el error es true, de esta forma evitamos cambiar el estado a false cada que el usuario presione una tecla
<input placeholder="Codigo de seguridad" value={value}
onChange={ev => {
if (error) {
setError(false)
}
setValue(ev.target.value)
}}/>
Lo colocaría después de la validación de la variable loading:
useEffect(() => {
if(!!loading){
setError(false)
setTimeout(()=> {
console.log("Haciendo la validación")
if(value!==SECURITY_CODE){
setError(true)
}
setLoading(false)
console.log("Terminando la validación")
}, 3000)
}
}, [loading])

este es mi solución al problema que cuando le den click al boton el setError pase a false