No me gustaba iniciarlas así, me parecía complicar en vano, hasta que recientemente me enteré de que iniciadas así en una función, se borran cuando termina. Es mejor que crearlas normal y luego borrarlas en una línea extra.
Así que me tomé la molestia de modificar un código para que funcione así. Pero falla en ciertos casos. Cuando cambio colores usando botones (el programa que estoy haciendo tiene esa opción), en este para incrementar un color (rojo, verde o azul):
// Usada en botones up de posibles colores de cuadraditos:
function IncrementarColor (nroDeColorPosible, incremento, parte) {
// nroDeColorPosible es qué elemento del array de...
// colores posibles será modificado.
// parte es qué parte del color: Rojo, verde o azul.
var ShoweraModificar = "ShowerDePosibleColor"+nroDeColorPosible;
trace ("ShoweraModificar: "+ShoweraModificar);
var EvaluedShower = eval(ShoweraModificar);
trace ("EvaluedShower: "+EvaluedShower);
if (EvaluedShower != "Ninguno") {
// Para modificar la parte indicada,
// dividir el color en 3 partes:
var Rojo = EvaluedShower.substr(0, 2);
var Verde = EvaluedShower.substr(2, 2);
var Azul = EvaluedShower.substr(4, 2);
trace("Colores captados: "+Rojo+", "+Verde+", "+Azul);
// Obtener la parte a incrementar:
var EvaluedParte = eval(parte);
trace ("EvaluedParte: "+EvaluedParte);
// Convertirla en decimal:
EvaluedParte = ConvertirHexEnDec(EvaluedParte);
trace("Convertirla en decimal: "+EvaluedParte);
// Incrementarla:
EvaluedParte = Math.min(EvaluedParte+incremento, 255);
trace("Incrementarla: "+EvaluedParte);
// Convertirlo en hexadecimal:
EvaluedParte = ConvertirDecEnHex(EvaluedParte);
trace("Convertirla en hexadecimal: "+EvaluedParte);
// Transferirla a la variable origen:
set (parte, EvaluedParte);
trace ("parte: "+parte+": "+EvaluedParte);
// Para que la variable nroDeColorPosible pueda usarse...
// en otras funciones:
_level0.NroDeColorPosible = nroDeColorPosible;
trace ("Variable copiada a lv0: NroDeColorPosible: "+nroDeColorPosible);
trace("Rojo: "+Rojo);
trace("Verde: "+Verde);
trace("Azul: "+Azul);
// Cambiar el color:
ChangePosibleColor();
}
}
function ChangePosibleColor () {
trace("Ejecutando ChangePosibleColor");
trace("Rojo: "+Rojo);
trace("Verde: "+Verde);
trace("Azul: "+Azul);
// etc
}
Ejemplo de salida siendo azul (si mal no recuerdo:
nroDeColorPosible es 0, podría ser otra cosa, no importa aquí mientras el valor se conserve
incremento es 1, idem
parte es "Azul" o 2, no me acuerdo, pero funcionaba):
ShoweraModificar: ShowerDePosibleColor0
EvaluedShower: 000000
Colores captados: 00, 00, 00
EvaluedParte: 00
Convertirla en decimal: 0
Incrementarla: 1
Convertirla en hexadecimal: 01
parte: Azul: 01
Variable copiada a lv0: NroDeColorPosible: 0
Rojo: 00
Verde: 00
Azul: 01
Ejecutando ChangePosibleColor
Rojo:
Verde:
Azul:
Vean que las variables Rojo, Verde y Azul ¡se pierden! Pero la función IncrementarColor aún no terminó ¿por ejecutar otra función dentro de ella, sus variables se pierden?
Ejemplo más sencillo:
function GenerarTipo1ySumar () {
var a = random(10);
var b = random(10);
Sumar();
trace("Generados: "+a+", "+b);
}
// Supongamos que tengo generar tipo 2, 3, etc, distintas fomas de generar.
function Sumar () {
Resultado = a+b;
trace("Suma: "+Resultado);
}
Iba a preguntar si al hacer Sumar las variables se pierden, pero se me ocurrió una posible explicación: Las variables aún no se borraron, pero están dentro de la función así que para usarlas fuera no se las puede nombrar como si estuvieran en el lv0, no sé cómo habría que llamarlas pero... quizá GenerarTipo1ySumar.a y .b
¿Es así?
¿Entonces me conviene usar var si conviene que la variable se borre luego de la función, pero sólo si no es usada por otra dentro de ella?
Porque hacer referencias como esa que puse GenerarTipo1ySumar.a está un poco raro ¡y no serviría! ahora que me doy cuenta, porque si hay más funciones que usan Sumar entonces a Sumar habría que indicarle desde dónde está siendo llamada para que sepa el nombre que debe usar ¡un lío!
¿Es así?
Respuesta de GPT:
En ActionScript 1/2 (como en Flash 5), el uso de var define variables con alcance local a la función. Eso significa:
- Las variables declaradas con var existen solo mientras se ejecuta esa función y solo son visibles dentro de esa función.
- Al salir de la función, las variables locales quedan fuera de alcance (son recolectadas más adelante).
- Llamar otra función desde dentro no “borra” las variables locales; simplemente no están en el ámbito de la otra función.
Qué está pasando en tus ejemplos:
1) Caso IncrementarColor / ChangePosibleColor
- Rojo, Verde y Azul se declaran con var dentro de IncrementarColor.
- ChangePosibleColor es otra función, con su propio ámbito. Dentro de ChangePosibleColor, las variables locales de IncrementarColor no son visibles, por eso aparecen vacías en los traces.
- Antes de llamar ChangePosibleColor, sigues viendo los valores correctos porque aún estás dentro de IncrementarColor.
Cómo pasar esos valores correctamente:
- Pásalos como parámetros:
function ChangePosibleColor(rojo, verde, azul) { trace(rojo, verde, azul); ... }
y llamas ChangePosibleColor(Rojo, Verde, Azul);
- O almacénalos en un objeto/propiedad accesible (por ejemplo en this o en _level0, aunque usar niveles globales es frágil):
this.Rojo = Rojo; this.Verde = Verde; this.Azul = Azul;
y en ChangePosibleColor leer this.Rojo, etc. Asegúrate de qué es this en ese contexto.
- O usa un objeto ColorState para agruparlos y pasarlo completo:
var color = { r: Rojo, v: Verde, a: Azul };
ChangePosibleColor(color);
2) Caso GenerarTipo1ySumar / Sumar
- a y b están declaradas con var dentro de GenerarTipo1ySumar, por lo que Sumar no puede verlas. En Sumar, a y b son indefinidas, y Resultado = a + b dará NaN.
- La forma correcta es pasar los operandos como argumentos:
function Sumar(a, b) {
var Resultado = a + b;
trace("Suma: " + Resultado);
return Resultado;
}
function GenerarTipo1ySumar() {
var a = random(10);
var b = random(10);
var res = Sumar(a, b);
trace("Generados: " + a + ", " + b);
}
Respondiendo a tus preguntas directas:
- “¿Se pierden las variables locales al llamar otra función?” No. Siguen existiendo en su propio ámbito, pero la otra función no las ve a menos que se las pases (parámetros) o las pongas en un ámbito compartido (propiedad de objeto/global).
- “¿Puedo referirme como GenerarTipo1ySumar.a?” No en AS1/2. Las variables locales no son propiedades del objeto función. No puedes acceder a ellas desde fuera; no existe esa sintaxis para cerrar sobre el stack de la función.
- “¿Conviene usar var?” Sí. Úsalo siempre para variables locales temporales. Para compartir datos entre funciones:
- Pasa parámetros y devuelve resultados (mejor práctica).
- O usa propiedades de un objeto contenedor (this, un MovieClip, o un objeto “modelo”).
- Evita depender de _level0 salvo que sea intencional y controlado.
Notas específicas de Flash 5/AS1:
- eval() y set() funcionan, pero son frágiles. Mejor usa objetos y arrays en lugar de construir nombres de variables como strings.
- Si estás armando nombres como "ShowerDePosibleColor0", considera guardar esos valores en un array: var ShowerDePosibleColor = ["000000", "ffcc00", ...]; y acceder por índice.
- Evita variables globales implícitas (asignar sin var). Pueden chocar nombres y dificultan el mantenimiento.
Refactor breve del primer caso sin eval/set:
- Supón un array de colores hex string:
var coloresPosibles = ["000000","000000",...];
- Incremento:
function IncrementarColor(idx, inc, parte) {
var hex = coloresPosibles[idx]; // "rrggbb"
var r = hex.substr(0,2);
var g = hex.substr(2,2);
var b = hex.substr(4,2);
var map = { Rojo:"r", Verde:"g", Azul:"b" };
var key = map[parte]; // "r"/"g"/"b"
var val = ConvertirHexEnDec((key=="r")?r:(key=="g")?g:b);
val = Math.min(val + inc, 255);
var hexVal = ConvertirDecEnHex(val);
if (key=="r") r = hexVal;
else if (key=="g") g = hexVal;
else b = hexVal;
coloresPosibles[idx] = r+g+b;
ChangePosibleColor(r, g, b, idx);
}
function ChangePosibleColor(r, g, b, idx) {
trace("Rojo: " + r);
trace("Verde: " + g);
trace("Azul: " + b);
// actualizar UI del índice idx...
}
Conclusión:
- var no borra variables “antes de tiempo” por llamar otra función; simplemente respeta el alcance local.
- Para que otra función use esos valores, pásalos como parámetros o guárdalos en un lugar compartido conocido. Evita eval/set y variables globales implícitas.
No le veo sentido a pasar parámetros que voy a borrar, prefiero que las variables estén en el lv0 y las borro, así no tengo que andar pasando cosas, que supongo es un gasto extra.
Bue... duda resuelta supongo.
