oigan no les parece buena idea estudiar juntos, osea formar un grupo para estudiar bgt y algunas cosas ponerlas acá y ayudar a los otros.

ea sí, yo creo grupo si quieren.

pero en donde? xd

Donde quieran, telegram, whatsapp.

solo tengo watsap. el teledram no me está funcionando .

creen por wsp pero no metan a personas que van a estar con la tontería de me gusta o no si estas en ese grupo es porque deseas aprender y ayudar a aclarar las dudas de los demás, no para andar diciendo si esta bueno o malo el sistema o lo que sea que sea bgt, hasta ahora no me queda claro que es xd

ea dale, los que quieran entrar al grupo permanentes, los tengo abiertos.

es un lenguaje de programación. algo parecido en la sintacssis a python solo que es algo un poco diferente y algunas cosas se escriben de forma mas larga al contrario que en python, una de las razones por las que dicen que no es muy bueno pero yo opino que está bien este lenguaje, python tambien me gusta.

totalmente deacuerdo con el grupo, alguien créelo o pasenme sus números por privado y yo lo hago

al final quien lo va a crear? para darle mi número.

Ya lo creo yo, solo me falta un número más aunque sea, porque solo somos 3.

vvale amigo, yo espero.

Ya está creado! el que quiera unirse páseme su número por favor.

añadí mike xD

hola chicos. les traigo en esta ocasión el capítulo 8 de este manual (las condicionales) aquí se toca: condicionales if y condicionales case. ahora, sin mas dilación, les dejo con el manual:
Hasta ahora, sólo hemos explorado las variables en el sentido de que les hemos dado valores conocidos. Aunque muy a menudo en un programa necesitarás poder hacer cosas sin tener que conocer el valor exacto de una variable. Por ejemplo, puedes querer hacer que el corazón del jugador empiece a latir rápido cuando su salud esté por debajo del 20%. Para ello hay que utilizar algo llamado sentencias condicionales.
7.1. Sentencias If
Las sentencias If funcionan exactamente igual que en el lenguaje cotidiano. Puedes decirle a tu madre: "Si me encuentro mal, por favor, informa a mi padre". Aunque los programas de ordenador no pueden realizar tareas tan complicadas como ésta, sí pueden realizar tareas informáticas basadas en la misma lógica.
Las sentencias if son útiles si tiene una condición simple o un conjunto de condiciones sobre las que hay que actuar dependiendo de la situación.
Una sentencia if en BGT podría tener este aspecto:
if(health < 21)
{
// Play the heart beating sound.
}
Lo que ocurre aquí es que cuando el intérprete llega a la sentencia if comprobará si es verdadera, es decir, si la variable salud tiene un valor inferior a 21. Si lo es, ejecutará el código que está entre la sentencia if y el corchete derecho de cierre que ves a continuación. También se puede hacer:
if(health < 21)
{
// Play the heart beating sound.
}
else
{
// Do something else if the health is not below 21.
}
En este caso, pueden ocurrir dos cosas. Si el valor de la salud es inferior a 21, entonces se ejecuta la primera sección de código. Sin embargo, si la condición no es verdadera, se ejecutará la otra sección de código, es decir, la que está entre la palabra else y la sentencia }. En resumen, esto permite hacer que una cosa suceda si una condición es verdadera y otra si no lo es.
Otro punto de interés: si sólo hay una cosa que hacer cuando tu condición if es verdadera, no tienes que usar las llaves. Aquí hay un ejemplo:

//condición de una sola acción con llaves
if(health<21)
{
//Play heart beating sound
}

//single action condition without braces

if(health<21)
//Play heart beating sound

//multiple action condition with braces

if(health<21)
{
//Play heart beating sound
alert("Alert!", "You are about to die..."); //show a message
}
Es importante recordar que las acciones múltiples deben contener las llaves. De hecho, se recomienda utilizar llaves en todas las situaciones para facilitar la gestión del código, para que no haya errores. Así será más fácil si desea añadir más acciones dentro de esa sentencia if en el futuro.

En la sección anterior, le dije que cualquier variable declarada dentro de una función era local sólo para esa función. Lo mismo ocurre con las sentencias if. Cualquier variable declarada dentro de la sentencia if es local a esa sentencia, y no puede ser usada fuera de ella. No es habitual que se declare una variable dentro de una sentencia if, pero puede resultar útil en algún momento. Lo mismo ocurre con cualquier bloque de código, incluidos los bucles.
Por supuesto, hay muchas otras comprobaciones que puede realizar. A continuación, una lista completa:

• if(x == y) - Esto es verdadero si x es igual a y. Puede realizar esta comprobación en cualquier tipo de variable.
• if (x != y) - Esto es verdadero si x no es igual a y. Puede realizar esta comprobación en cualquier tipo de variable.
• if(x < y) - Es verdadero si x es menor que y. Puede realizar esta comprobación sólo en variables numéricas.
• if(x <= y) - Es verdadero si x es menor o igual que y. Sólo se puede realizar esta comprobación en variables numéricas.
• if(x > y) - Es verdadero si x es mayor que y. Sólo se puede realizar esta comprobación en variables numéricas.
• if(x >= y) - Esto es verdadero si x es mayor o igual que y. Puedes realizar esta comprobación sólo en variables numéricas.
• if(!x) - Es verdadero si x es falso. Sólo se puede utilizar en variables booleanas.

Quizá te preguntes por qué utilizamos dos signos de igualdad cuando comprobamos si x es igual a y. Esto se debe a que con un solo signo igual estaríamos asignando el valor de y a x, que no es exactamente lo que queremos. Por lo tanto, decir:

Es importante recordar que las acciones múltiples deben contener las llaves. De hecho, se recomienda utilizar llaves en todas las situaciones para facilitar la gestión del código, para que no haya errores. Así será más fácil si desea añadir más acciones dentro de esa sentencia if en el futuro.
if(x=y)
es, por tanto, ilógica e incorrecta.

Ilustremos todo esto con un ejemplo más práctico. Volveremos una vez más a Juan Pérez y a sus problemas para decidir su propia edad, sin embargo esta vez imprimiremos si es o no menor de edad basándonos en el número aleatorio que se genera. Volviendo a un ejemplo anterior, mira el siguiente fragmento de código una vez más.
string my_name="John Doe";
int age=random(5, 50);
string message_string="My name is " + my_name + ", I'm " + age + " years old and don't you ever forget it!";
alert("Important information", message_string);
¿Te resulta familiar? Bien, porque no será por mucho tiempo... Ahora trata de adivinar qué pasará cuando hagamos lo siguiente.

string my_name="John Doe";
int age=random(5, 50);
string message_string="My name is " + my_name + ", I'm " + age + " years old which means that I am ";
if(age<18)
{
message_string+="a minor!";
}
else
{
message_string+="of full age!";
}
alert("Important information", message_string);

El código anterior es realmente muy simple, pero lo revisaremos paso a paso para asegurarnos de que está 100% claro. Primero, creamos la variable llamada mi_nombre, que en este caso es totalmente innecesaria, pero formaba parte del ejemplo original, así que permitimos que se quede. Luego, generamos un número aleatorio entre 5 y 50 y lo asignamos a la variable llamada edad. Después de esto, hacemos la cadena que contendrá nuestro mensaje final. Notarás que la sentencia no está completa, y no es de extrañar ya que estamos a punto de completarla dentro de una sentencia if. Si la edad es inferior a 18 años añadimos un texto a la cadena que dice que John Doe es menor de edad. Si no lo es, entonces se ejecuta la otra sección de código que en cambio hace que la cadena diga que Juan es mayor de edad. Finalmente, por supuesto, lo imprimimos en nuestro viejo cuadro de mensajes. Pruebe a ejecutar este código, y vea si entiende la lógica que hay detrás del resultado impreso.

Es, como probablemente ya te hayas dado cuenta, perfectamente posible tener una sentencia if dentro de otra sentencia if. Esto le permite hacer que algo suceda sólo si se cumplen varias condiciones. También puede realizar múltiples comparaciones dentro de las sentencias if. Exploraremos esto un poco más adelante en este capítulo.

Ahora que hemos visto cómo se usan las sentencias if, es hora de que te presente un nuevo tipo de variable... El booleano. Un booleano sólo puede contener dos valores, verdadero o falso. Estos valores se utilizan a menudo en las sentencias if, como esta por ejemplo:
bool has_weapon=true;
if(has_weapon==true)
{
// Do something.
}
Las palabras true y false no son nombres de variables o constantes predefinidas, sino que son palabras clave reales del lenguaje. Por esta razón, no se puede decir

false=5;

puesto que false ya se utiliza como palabra clave. Por otro lado, cuando se trabaja con variables booleanas se podría hacer algo como
bool has_weapon=true;
if(has_weapon)
{
// Do something.
}

Esto puede parecer extraño a primera vista, ya que no especificamos ninguna condición que deba cumplirse, pero como has_armas es una variable booleana y tiene el valor true el código dentro de la sentencia if se ejecutará porque toda la expresión saldrá como true. Del mismo modo, si has_weapon hubiera sido falsa, el código dentro de la sentencia if no se habría ejecutado, ya que toda la expresión sería falsa.

Para demostrar los diferentes usos de las variables booleanas junto con otros tipos de variables, veremos un ejemplo de uso simple para las funciones llamadas key_down y key_pressed. Estas funciones se utilizan para comprobar el estado de ciertas teclas. Observa el siguiente fragmento de código:
if(key_pressed(KEY_F4))
{
if(key_down(KEY_LMENU))
{
alert("Fine!", "If you want to be boring and exit this program then by all means do so. Bye.");
exit();
}
else
{
alert("Um...", "Are you, by any chance, trying to close the program down?");
}
}
Aquí comprobamos si dos condiciones diferentes son verdaderas y actuamos en base a lo que encontramos. En primer lugar, comprobamos si la tecla f4 está pulsada. Si esto es cierto, comprobamos si se mantiene pulsada la tecla alt. Si esto también es cierto, asumimos que el usuario está cerrando el programa. Si no es cierto, mostramos un mensaje de burla porque se olvidaron de mantener presionada la tecla alt.

Finalmente, tenemos dos llaves de cierre para que todas las sentencias if se cierren correctamente. Puedes anidar tantas sentencias if y else como quieras y de la forma que quieras, siempre que las equilibres con las llaves adecuadas en los lugares correctos.

¿Hay alguna forma de comprobar que más de una condición es verdadera? Sí, la hay. Los operadores lógicos le permiten comprobar múltiples condiciones en una sentencia if.
Tome el siguiente ejemplo. Comprobaremos de nuevo la condición Alt+F4, pero esta vez no se mostrará ningún mensaje. Simplemente saldremos.

if((key_down(KEY_LMENU))&&(key_pressed(KEY_F4)))
{
exit();
}
Dos cosas principales que puede notar aquí. Para empezar, nuestra sentencia if contiene tres conjuntos de paréntesis. Uno que encierra toda la sentencia if, y otros dos conjuntos que encierran cada condición. Esto es puramente por razones de legibilidad. Podríamos haber dicho fácilmente
if(key_down(KEY_LMENU)&&key_pressed(KEY_F4))

y recibió el mismo resultado.
La otra cosa que habrás notado es el símbolo && (doble ampersand). Esto representa la palabra y. En otras palabras, le dice al motor que si se mantiene pulsada la tecla Alt y se pulsa la tecla F4, salga.
Aquí hay otro ejemplo:
if((key_down(KEY_LMENU))||(key_pressed(KEY_F4)))
{
exit();
}
Esto no tiene ningún propósito real en este ejemplo. Le dice al motor que salga si se pulsa la tecla alt o la tecla f4. Sin embargo, podría ser útil si ha asignado dos teclas a una función, por ejemplo, las flechas hacia abajo y hacia la derecha que le mueven una opción hacia abajo en un menú.
El último operador, que hemos mencionado brevemente, es el operador de negación. Se escribe con un ! (signo de exclamación). Invierte el resultado de una condición. Por ejemplo:
if(!key_down(KEY_LMENU))

En lugar de comprobar que key_down(KEY_LMENU)==true, se comprobará si es false.
Tenga en cuenta que este operador no se utiliza para comparar valores. Simplemente invierte los efectos de una condición dada. Para usar nuestro ejemplo anterior:
if(!key_down(KEY_LMENU))
Observe que sólo hay una condición y una comprobación. Esto invierte literalmente el estado de un valor, en lugar de comparar la falsedad de dos valores. Por ejemplo, si el usuario está presionando la tecla Alt, la función devuelve verdadero. Por lo tanto, el operador de negación lo convierte en falso. Para comprobar que un valor dado es igual (verdadero) o diferente (falso) a otro valor, se escribiría
if(mi_var1!=mi_var2)

Esto tendría más sentido, tanto lógica como gramaticalmente. Dado que el signo de exclamación representa la negación, es decir, no, e igual es autoexplicativo, esto se traduce literalmente en inglés como: if my_var1 is not equal to my_var2. En lugar de invertir directamente el resultado como el operador de negación, esto devolverá verdadero si la condición es falsa, es decir, si las dos variables no son iguales.
7.2. Switch y Case
Las sentencias switch...case son muy similares a las sentencias if, excepto que se utilizan para establecer comprobaciones numerosas o más complicadas.
He aquí un ejemplo:
Int health;
double energy;

switch(health)
{
case 100:
energy=100;
break;
case 90:
energy=89;
break;
case 80:
energy=78;
break;
case 70:
energy=67;
break;
case 60:
energy=56;
break;
//additional values go here
}

La palabra clave switch se utiliza para iniciar una sentencia case y va seguida de la variable a comprobar dentro de paréntesis. Cada condición se introduce con la palabra clave case. El cuerpo de la sentencia switch se encierra entre llaves.
Al final de cada caso en una sentencia switch, generalmente se utiliza la sentencia break para terminar ese caso.
Si omite la sentencia break al final de un caso, la ejecución continuará en el siguiente caso. Aunque esto a veces puede ser útil, es algo que hay que tener en cuenta.
Otra palabra clave que se puede utilizar es default. Esta realiza una tarea para cualquier otra condición no cumplida por la sentencia case. Tomando nuestro ejemplo anterior, podríamos hacer que la disminución de energía de nuestro jugador sea más realista haciendo lo siguiente:
switch(health)
{
case 100:
energy=100;
break;
case 90:
energy=89;
break;
case 80:
energy=78;
break;
//additional values go here
default:
energy-=0.5;
}

Esto significa ahora que cada vez que se ejecuta esta sentencia case, establecerá nuestra energía a un valor predeterminado cada vez que nuestra salud alcance un número divisible por 10, y simplemente restará 0.5 en todas las demás circunstancias.
Observe que incluso un caso predeterminado todavía tiene un descanso. Puedes poner los casos en el orden que desees.

La expresión dentro de la condición del interruptor puede ser cualquier expresión que resulte en un valor, siempre y cuando el resultado sea numérico. Por ejemplo, podría tener:
switch(number % 100)
Sin embargo, cada caso dentro del switch, debe ser una constante: no puedes poner expresiones como:
case n < 5:
o
case number:
Si lo hace, el compilador señalará un error.

Además, no puede tener más de un caso con el mismo valor, o más de un caso por defecto.

Como siempre, las sentencias switch...case pueden ser anidadas si es necesario.

Posteo para que se me quede en partisipaciones

@dhegwork-adakly Solo vengo a aclarar. No he visto que se diga que BGT es malo porque algunas cosas se escriban de una manera más larga. Se lo critica porque ya perdió su soporte. Perder su suporte significa que BGT ya no se va a actualizar más, siempre va a estar como tal, en un futuro puede tener avugeros de seguridad y nunca va a corregir la forma que tiene para conectarse a las redes y la firma de las apps, que esas son las razones por lals que los audiojuegos en BGT sean detectados hasta por Windows Defender. De hecho, seamos claros. Windows Defender a software en BGT lo clasifica como Trojan, y eso significa que no tiene que tener necesariamente una amenaza, si no que con BGT hay puntos déviles, y que tengas cuidado, que alguien te puede meter algo.

nooo acá no lo han dicho pero si conoc'i alguien que una ves se quejaba de que en bgt debíaescribir alert("mensaje", "Hola, mundo!"); mientras que en python print(Hola, mundo!) y por eso criticó al lenguaje.Yo me acordé de ello por eso lo puse aquí.

hola bro @mc dabo. Quería reportarte lo que creo que fue un error en la parte 2 del manual xd. mirá como quedaron estas líneas, no sé como explicar lo que me hace verlo como error pero a ver que dicen...
Cuando escribimos la siguiente línea:

x++;

usted como escritor, y acelera el programa. Si está incrementando una variable una vez, puede que no note el cambio. Si, por otro lado, está cambiando constantemente un contador, notará la diferencia. Aunque una variable integral es de un tipo, puede especificar el rango potencial permitido de la variable. Los dos que suelen interesarle son short, un entero de 16 bits (2 bytes) que va de -32768 a 32767, y long, un entero de 32 bits (4 bytes) que va de -2147483648 a 2147483647.

usted como escritor... y acelera

hola. No noto el error que decís. Puede, puede que a lo mejor el inicio del texto sea algo como: si usted, como escritor, acelera el programa, pero es un detalle muuy pequeño y el resto del párrafo se entiende perfectamente, o por lo menos así lo veo yo.
Un saludo.
pd: a lo mejor acelera es el error? no lo se. Hay que ver cuál es la palabra en inglés en cuestión. Igual insisto, la explicación se comprende.

si, pero. usted como escritor y acelera el programa, y además está en minúscula. algo me dice que había texto antes de eso y que tal vez por accidente el compa se lo saltó. ya me fijo bien en el manual en inglés igual para comprobar...

no es nada grave pero no está de mas comentarlo, realmente todo se entiende perfectamente aunque esté esa línea incompleta o con una palabra incorrecta.

a, eso puede ser. Yo no tengo bgt instalado en esta pc por lo que no tengo el manual a mano, pero si, en todo caso hay que ir al orígen del texto.

efectivamente. cito la parte original en inglés. y nope xd, genial por ti que lo comprendiste amigo. yo no lo comprendí jaja, por eso lo reportaba... la verdad si es entendible por lo menos yo no lo huviera reportado. pero acá va el texto original.
x++;

We are telling BGT to increment the counter by 1. This does two things. It saves time for you as the writer, and speeds up the program.

claro. Básicamente, traducción rápida.
Le estamos ordenando a BGT que incremente el contador en 1. Esto hace 2 cosas. Le ahorra tiempo a usted como escritor, y acelera el programa (acelera se lo puede cambiar como agiliza que creo quedaría mejor) ya lo último igual son cuestiones meramente de traducción, que no hacen ni cambian en nada al sentido del párrafo.
Un saludo.

no, lo demás está totalmente bien jaja. el error nomás iba ahí.

si, cierto. no me di cuenta. tengan en cuenta que son textos muy largos, y aveces se me escapan algunos errores como esos jaja. pido disculpas y paso por aquí para avisarles que voy a empezar a traducir los bucles o loops. en breves los tendrán. saludos.

Posteo así @mc dabo puede postear.

chicos! aquí les traigo la 4 o 5 entregade este tutorial!. la verdad esta vez me esforcé mucho para traerles 2 de una, así que les pegaré esta y cuando alguno postee, la otra. oy veremos los loops que englova los whiles, los fors y los dos. así que sin mas dilación, allá vamos:
Después de haber experimentado un poco con las sentencias if, es lógico que se introduzca el concepto de bucle, ya que son bastante similares. Un bucle es una sección de código que se ejecuta una y otra vez hasta que una determinada condición es verdadera. Se utilizan mucho en los juegos, por ejemplo, querrás un bucle que compruebe continuamente ciertas pulsaciones de teclas y si se han producido algunos eventos particulares, etc.
Hay tres maneras de realizar un bucle, cada una de las cuales discutiremos en este capítulo.
8.1. Bucles while
Observa el siguiente ejemplo de código.
while(key_pressed(KEY_ESCAPE)==false)
{
wait(5);
}
¿Se ha confundido? No hay problema, vamos a repasarlo poco a poco. La primera línea es realmente la más complicada. Primero tienes la palabra "while", que significa que un bucle debe comenzar aquí. Después tienes la condición que debe cumplirse para que el bucle se ejecute. En este caso, usamos la función llamada key_pressed para comprobar si la tecla de escape ha sido presionada, y hacer que el bucle se ejecute mientras esa función informa que la tecla no está siendo presionada. En definitiva, el bucle seguirá ejecutándose hasta que el usuario pulse escape. El código entre la sentencia while y la llave de cierre se ejecuta una y otra vez, y después de cada ejecución la condición se comprueba una vez más para ver si es verdadera. Si lo es, el código después de la llave de cierre comenzará a ejecutarse en su lugar. En nuestro bucle sólo hacemos que el programa espere durante 5 milisegundos, lo que básicamente pausa la ejecución durante un tiempo muy corto entre cada comprobación de nuestra condición. Si no incluyéramos esta línea, la CPU del procesador comenzaría a ejecutarse al 100%, que no es realmente lo que queremos. Así que en cualquier bucle que se ejecute durante un período de tiempo más largo siempre debe tener una breve pausa, y 5 milisegundos suele ser un buen compromiso entre la velocidad y el uso de la CPU.

Pero digamos que quieres realizar una tarea en particular x número de veces, ¿sería un bucle la opción correcta? Ciertamente. Aquí hay un ejemplo rápido que muestra cómo puedes hacer que algo ocurra 1000 veces.
int x=0;
while(x<1000)
{
// Put your code here.
x++;
}
Comenzamos creando una variable llamada x y dándole un valor de 0. Luego comenzamos nuestro bucle, y le decimos que se ejecute mientras x sea menor que 1000. Después de esto insertamos cualquier código que queramos ejecutar, y finalmente incrementamos x en 1. De esta manera, x se incrementará en 1 en cada ciclo del bucle para que finalmente tenga el valor 1000. Cuando lo tenga, la siguiente comprobación de nuestra condición será obviamente falsa ya que x ya no es menor que 1000. Efectivamente, hemos ejecutado entonces nuestro código 1000 veces con x pasando de 0 a 999. Por supuesto, podríamos haber dado a x un valor inicial de 1 y dejar que el bucle se ejecutara mientras fuera menor que 1001, o por supuesto mientras fuera menor o igual que 1000 (ver el capítulo sobre sentencias if para más detalles), pero hay una razón particular por la que elegimos empezar en 0 que se explicará más adelante en el próximo capítulo.
He aquí otro ejemplo. Vamos a mostrar los números del 0 al 10 en una caja de mensajes.
int x=0;
string numbers="";
while(x<=10)
{
numbers+=x;
if(x<10)
{
numbers+=" ";
}
x++;
}
alert("Printing numbers 0 to 10", numbers);
El bucle se ejecuta mientras x sea menor o igual a 10, es decir, hasta que x sea 11.

Podríamos acortar ligeramente este código, de la siguiente manera:
int x=0;
string numbers="";
while(x<=10)
{
numbers+=x++;
if(x<=10)
{
numbers+=" ";
}
}
alert("Printing numbers 0 to 10", numbers);

Aquí, hemos cambiado x exactamente en el mismo lugar en el que lo comprobamos. X cambiará después de comprobar su valor (observe el operador ++ en x).
También hemos cambiado ligeramente nuestra condición if para comprobar si x es menor o igual que 10. Esto se debe a que, de lo contrario, los espacios se detendrían a partir de 9, ya que x se está incrementando antes de que se compruebe la condición if.
8.2. Bucles do while
Hemos visto los bucles while, ahora es el momento de mostrar algo muy parecido. Empecemos por esperar a que el usuario vuelva a pulsar escape:
do
{
wait(5);
}
while(!key_pressed(KEY_ESCAPE));
Hay dos puntos de interés aquí. Primero, la línea que dice do le dice a BGT dónde empieza el bucle. El bloque de código, de nuevo encerrado entre llaves, es la sección de código que debe repetirse mientras la condición sea verdadera. Finalmente, hay una línea adicional después de la llave de cierre que le dice al intérprete qué condiciones deben cumplirse para que el bucle continúe.
Puede notar que en esta sentencia while, hay un signo de exclamación antes de la condición. Esto le dice que repita el bucle mientras la condición sea falsa. En resumen, las dos líneas siguientes significan exactamente lo mismo:
while(key_pressed(KEY_ESCAPE)==false)

while(!key_pressed(KEY_ESCAPE))
Es importante recordar que después de la sentencia while de un bucle do while, hay un punto y coma, ya que esto equivale a dar una instrucción Haz lo anterior, mientras se cumpla esta condición.
Hay una diferencia notable entre un bucle while y un bucle do while. Un bucle while comprueba primero la condición, lo que significa que el código puede ser omitido totalmente si la condición no se cumple. Sin embargo, con un bucle do while, la condición no se especifica hasta el final del bucle, lo que significa que el código siempre se ejecuta al menos una vez.
8.3. Bucle for
El bucle for es el más potente de los bucles, y se utiliza principalmente para contar. Esencialmente, combina las distintas partes del control del bucle en una sola sentencia.
Considere el bucle while de los ejemplos anteriores. Antes de comenzar el bucle, la variable se inicializó a un valor inicial (en nuestros ejemplos, era 0). Luego, tenemos la condición while en la parte superior del bucle while. Finalmente, justo antes de la llave de cierre del while, reinicializamos x para la próxima vez.
En un bucle for, estas tres etapas se empaquetan en una línea:
for(int x=0; x<=10; x++)
{
//loop code goes here.
}
Primero, inicializamos una variable con un valor inicial. Aquí, elegimos 0. Aunque creamos la variable desde dentro del bucle, es perfectamente legal utilizar una variable existente, como si modificáramos su valor en cualquier parte del script.
En segundo lugar, le decimos bajo qué condiciones nuestro bucle continuará ejecutándose. En nuestro caso, si x es menor que 10.
Por último, le decimos cómo reasignar la variable lista para el siguiente ciclo del bucle. Aunque hemos incrementado x en 1, como sería el caso en la mayoría de otros lenguajes, la expresión de reasignación puede ser la que quieras. Echa un vistazo al siguiente código.
for(x=1; x<1000; x*=2)
{
//code goes here
}

8.4. Romper y continuar
Hay dos últimos escenarios posibles que necesitamos cubrir. A veces querrás que muchas cosas ocurran continuamente, pero puede que no sepas exactamente cuándo quieres que el bucle se detenga o puede que quieras detenerlo por varias razones diferentes que no pueden ser usadas todas como condición. En este caso, podrías hacer algo como lo siguiente:

while(true)
{
if(something==true)
{
break;
}
if(something_else==true)
{
break;
}
if(yet_another_variable==true)
{
continue;
}
// more code here...
wait(5);
}
Hay tres cosas nuevas aquí. La primera está en la línea 1, donde no tenemos exactamente una condición para nuestro bucle. Todo lo que decimos es "while(true)", lo cual no tiene mucho sentido a primera vista. Sin embargo, no es tan extraño porque true, por supuesto, es siempre verdadero, lo que significa que el bucle nunca terminará simplemente porque la condición nunca puede ser falsa. En resumen, hemos creado un bucle sin fin. Naturalmente, no queremos que el bucle sea eterno; queremos detenerlo en algún momento, pero lo hacemos desde dentro del propio bucle. Las tres sentencias if anteriores comprueban condiciones que en realidad no existen, por lo que si ejecutaras este script te daría un error. Lo que estoy tratando de mostrar es que usted puede, a su propia discreción, salirse del bucle por cualquier razón y en cualquier momento usando la sentencia break que ve dentro de los dos primeros if's. Vimos brevemente la sentencia break en acción cuando vimos las sentencias switch...case. La sentencia break básicamente fuerza la terminación del bucle y comienza a ejecutar el código que viene después. Como se mencionó antes, esto es muy útil cuando se quiere salir del bucle por una serie de razones, o cuando no se sabe exactamente cuándo debe detenerse.
Hay que tener en cuenta que, si los bucles están anidados, la sentencia break sólo saldrá del bucle en el que está declarada.

La otra palabra clave que vio en la tercera sentencia if es continue. De nuevo, esta palabra clave puede ser usada en cualquier lugar dentro de un bucle. La palabra clave continue le dice al intérprete que se salte el resto de ese ciclo y pase al siguiente. Esto es útil, por ejemplo, cuando está leyendo de un archivo y hay ciertas cosas, como líneas en blanco que necesitan ser saltadas.