Me lo recomendó la IA hace unos días.

Intentando programar otra cosa usando eso, tengo

	NroDePasoaVariar = Pasos+1;
	while (NroDePasoaVariar > 1) {
		NroDePasoaVariar--;
		// Resumen:
		TipoDePaso_ = "TipoDePaso"+NroDePasoaVariar;
		while (this[TipoDePaso_] < TiposDePaso) {
			this[TipoDePaso_] = this[TipoDePaso_]+1;

Me genera dudas esa última línea y no entiendo la explicación de la IA.
https://share.google/aimode/cuudJrnjDdLWT9p75

Yo antes hacía
set(TipoDePaso_, eval(TipoDePaso_)+1)
o tal vez
set(TipoDePaso_, eval(eval(TipoDePaso_))+1)
La cosa es que estoy creando una variable...
cuyo nombre depende del valor de TipoDePaso_
y cuyo valor depende del valor del valor de eso.
¿No?
Si TipoDePaso_ es "TipoDePaso1" entonces el set lo que hace es
TipoDePaso1 = eval("TipoDePaso1")+1
O sea, me confunde que es como si el resultado del mismo código
this[TipoDePaso_]
dependiera de si está a la izquierda o derecha del =
Si está a la izquierda, se mira el contenido y se le quitan las comillas
Si está a la derecha, se mira el contenido y se busca el valor
Voy a intentar probar el código pero aún no estaba como para eso.

Hasta ahí entendí.

Te explico lo que quiero hacer.

Imagina que tienes unos datos, por ejemplo:
Input  ResultadoDeseado
1        2
2        3
3        4
Quieres que el programa averigue qué debe hacerse a cada Input para que el resultado sea su correspondiente ResultadoDeseado.
La respuesta es Input+1, pero queremos que la averigue el programa.

Contaremos con funciones como estas supongo, aún no confirmé que sirvan:

funtion TipoDePaso1 () {
   Resultado = Input+Valor;
}
funtion TipoDePaso2 () {
   Resultado = Input*Valor;
}
 

etc.

Definimos valor.
Al 1er Input le aplicaremos la 1er función.
Si el resultado sirve, al 2ndo Input le aplicaremos la misma función.
Si el resultado sirve, al 3er Input le aplicaremos la misma función.
Si el resultado sirve, hemos terminado.
Si falla en algún caso, al 1er Input le aplicamos la 2nda función.
Y así sucesivamente, vamos probando las funciones.
Si todas fallan modificamos el valor y volvemos al inicio.

Pero imagina que los datos fuesen:
Input  ResultadoDeseado
1        3
2        5
3        7
Ahora la respuesta es Input*2+1, podría servir una sola función pero lo que intento hacer es que el programa aumente el número de funciones que prueba como solución.

En fin, no sé explicarlo mejor, tengo que variar cosas:
- La cantidad de pasos u operaciones de la fórmula que se prueba.
- El nro del paso a variar de dicha fórmula.
- En qué consiste ese paso, es decir a qué función se llamará.
- El valor que usará ese paso.
- El input que se prueba.
- El paso a ejecutar.
- El resultado que debe chequearse.
En fin, acá está lo que logré, faltan las funciones y no termina, tiene algún error quizá:

Datos = 3;
Dato1 = 1;
BuenResultado1 = 2;
Dato2 = 2;
BuenResultado2 = 3;
Dato3 = 3;
BuenResultado3 = 4;
TiposDePaso = 2;
Pasos = 0;
while (Pasos < 2) {
	// Se prueba un método con un paso más, para probar métodos que sólo tienen 1 paso, luego métodos que tienen 2, etc:
	Pasos++;
	// Crea nuevo paso:
	this["PasoaProbar"+Pasos] = 0;
	trace("Creado el PasoaProbar"+Pasos);
	trace("su valor es "+this["PasoaProbar"+Pasos]);
	NroDePasoaVariar = Pasos+1;
	// Se indica que el paso a variar sea otro, para que varíe el último hasta que no se pueda, se reseteé, luego el penúltimo, y así, para lograr todas las variaciones posibles:
	while (NroDePasoaVariar > 1) {
		NroDePasoaVariar--;
		// Resumen:
		PasoaProbar_ = "PasoaProbar"+NroDePasoaVariar;
		// Se modifica el paso indicado:
		while (this[PasoaProbar_] < TiposDePaso) {
			this[PasoaProbar_] = this[PasoaProbar_]+1;
			trace(PasoaProbar1+" y "+PasoaProbar2);
			ValoraProbar = -1;
			// Se modifica el valor que usará el paso, para que por ejemplo se pruebe +1, +2, etc:
			while (ValoraProbar < 1) {
				ValoraProbar++;
				BuenResultadoHallado = true;
				DatoaProbar = 0;
				// Se modifica qué "Input" se chequea:
				while (DatoaProbar < Datos && BuenResultadoHallado == true) {
					DatoaProbar++;
					PasoaEjecutar = 0;
					// Se modifica el paso a ejecutar, para ver si el método (fórmula) sirve para lograr el resultado deseado con ese dato de input:
					while (PasoaEjecutar < Pasos) {
						PasoaEjecutar++;
						this["TipoDePaso"+this["PasoaProbar"+PasoaEjecutar]]();
					}
					if (this["Resultado"+Pasos] != this["BuenResultado"+DatoaProbar]) {
						BuenResultadoHallado = false;
					}
				}
			}
			this[PasoaProbar_] = 1;
		}
	}
}

¿Qué tiene que ver con la duda inicial? No sé explicarlo, pero debo variar qué hace el paso, guardo su nombre para evitar concatenar varias veces, y a ese paso que tiene un valor que indica a qué función se llamará, le debo ir variando dicho valor.
Ese valor no es el mismo que usan las funciones.

Aj, también me falta que se grabe el valor usado, además estoy usando el mismo en cada paso al ejecutar, bueh.... sí, muchas cosas para hacer.

Mira, voy a poner cómo debería ser el resultado si hubiera traces:
Se probarán métodos de 1 paso.
El tipo del paso fue variado, ahora el tipo (valor, a qué función se llamará) del paso 1 es 1
El valor a probar fue variado, es -1
Se probará el método con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 1
El resultado no coincide
El valor a probar fue variado, es 0
Se probará el método con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 1
El resultado no coincide
El valor a probar fue variado, es 1
Se probará el método con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 1
El resultado no coincide
En el paso 1 ya se probaron todos los valores especificados, se variará el tipo de paso
El tipo del paso fue variado, ahora el tipo (valor, a qué función se llamará) del paso 1 es 2
El valor a probar fue variado, es -1
Se probará el método con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 2
El resultado no coincide
(...)
En el paso 1 ya se probaron todos los valores especificados, se variará el tipo de paso
En el paso 1 ya se probaron todos los tipos de paso, se probará modificar otro paso
El método actual no tiene pasos anteriores
Se probarán métodos de 2 pasos.
El método consiste en llamar a las funciones 1 y luego a la 0 (esos son los valores de los pasos, 1 y 0).
Ahora el tipo (valor, a qué función se llamará) del paso 2 es 1
Ahora el método es 1, 1
El valor a probar fue variado, es -1
Se probará el método 1, 1 con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 1
Ejecutando paso 2 cuyo tipo (valor) es 1
El resultado no coincide
(...)
Se varió el tipo del paso 2, ahora el método es 1, 2
El valor a probar fue variado, es -1
Se probará el método 1, 2 con el input 1
Ejecutando paso 1 cuyo tipo (valor) es 1
Ejecutando paso 2 cuyo tipo (valor) es 2
El resultado no coincide

Más o menos eso es lo que quiero lograr. Como dije, en la ejecución de los métodos falta que se use el valor, no está guardado.

Lamento si no se entiende, no sé explicarlo mejor.