En la programación de computadoras, una declaración determina el nombre y el tipo de datos de una variable u otro elemento. Los programadores declaran variables escribiendo el nombre de la variable en el código, junto con cualquier indicador de tipo de datos y otra sintaxis requerida.

Una declaración en la programación de computadoras se puede confundir con otros tipos de designaciones para variables. Uno de esos términos es la definición de una variable, que se refiere a la asignación de una ubicación de almacenamiento para esa variable. Otro término similar es dimensionar variables, que se refiere a reservar memoria para las variables determinando la longitud o el tamaño de las variables. Los programadores comúnmente dimensionan variables y matrices para ayudar al programa a manejar elementos de un tamaño específico.

Declaraciones de bloque de inicio/finalización

La declaración begin/ end es una declaración de bloque que no realiza ninguna lógica o funcionalidad en sí misma, pero se usa para agrupar dos o más declaraciones juntas para que puedan tratarse como una sola declaración, generalmente en un contexto donde se espera una sola declaración.

Por ejemplo, la instrucción if/then espera una única sub instrucción después de la palabra clave  then, que se ejecutará si la condición que la precede se evalúa como verdadera. Usando un par begin/ end, se puede vincular un bloque completo de declaraciones a la condición. Técnicamente hablando, el begin/ end no es parte de la sintaxis de la declaración if/ :then

if x ≥ 0 then 

  Hazalgo;             

if x ≥ 0 then begin       

        Hazalgo;             

  Else;

        Hazalgo;

end;

A continuación, se enumeran todos los tipos de declaraciones y expresiones que se pueden usar en combinación con un bloque begin/ end

• if
• bucles for/do 
• bucles while/do 
• Bucles infinitos loop 
• Cláusulas individuales en una declaración case
• Declaraciones with/do 

Declaraciones independientes begin/ end en bloque

Dado que los bloques begin/ endno presentan un comportamiento o lógica propia, por supuesto, también se pueden usar para agrupar una o más (técnicamente, cero o más) declaraciones en cualquier lugar del código donde se permite una declaración, incluso cuando no se usa en el contexto. donde la agrupación es necesaria para juntar las declaraciones.

El siguiente fragmento de código muestra tres declaraciones, la segunda de las cuales es un bloque begin/ que en sí mismo contiene dos declaraciones. endEsto es válido, aunque el par begin/ endno tiene ningún efecto y el código realizaría exactamente la misma acción sin él.

Console.Write('hello');

begin

  Console.Write(' to');

  Console.Write(' the');

end;

Console.WriteLine(' world')

Declaraciones si/entonces/si no (de lo contrario) - if/then/else

La declaración si/entonces es una declaración condicional que ejecuta su subdeclaración, que sigue a la palabra clave entonces, solo si la condición proporcionada se evalúa como verdadera:

if x < 10 then
 x := x+1;

En el ejemplo anterior, la condición es x < 10 y la instrucción a ejecutar es x := x+1. Como tal, el código incrementará x en uno solo si su valor actual sigue siendo inferior a 10.

Otra cláusula

Opcionalmente, se puede proporcionar una cláusula else con una segunda subdeclaración. Esta segunda instrucción se ejecutará en lugar de la primera si la condición fuera falsa. Siempre se garantiza que una de las dos sentencias se ejecutará:

if x < 10 then 

     x := x+1 

else 

     x := x+10;

En el ejemplo anterior, el código incrementará x en uno si su valor actual sigue siendo inferior a 10, como antes. Sin embargo, si x ya es 10 o mayor, se incrementará en 10.

Observe cómo el segundo ejemplo anterior no tiene punto y coma (;) después de la primera declaración, la que se ejecutará si la condición es verdadera. eso se debe a que, en Oxygene, los puntos y comas se usan para separar declaraciones, no para terminarlas.

Técnicamente hablando, el punto y coma en el primer fragmento de código no pertenece a la declaración interna x := x+1. En su lugar, separa toda la declaración si/entonces de lo que pueda venir después. En el segundo ejemplo, toda la declaración if/then/else no finaliza hasta después de la cuarta línea, por lo que ese es el primer lugar donde un punto y coma es válido.

Se podría argumentar que no debería estar presente en el código de ejemplo; sin embargo, la convención de Oxygene es escribir el punto y coma final después de cada declaración, incluso las individuales, y es por eso que el fragmento lo incluyó.

Declaraciones if/then y bloques de inicio/fin.

Por sí sola, la declaración if/then, así como su cláusula else opcional, solo requiere que se ejecute una sola declaración para cada uno de los dos casos. Para ejecutar más de una declaración, se pueden agrupar varias declaraciones usando una declaración de bloque de inicio/finalización:

if x < 10 then begin 

       x := x+1; 

       writeLn('increased by 1.'); 

end 

else begin 

       x := x+10; 

       writeLn('increased by 10.'); 

end;

Opcionalmente, se puede usar un bloque de declaración de inicio/fin, incluso si solo se proporciona una declaración. Esta es una práctica común para mantener el código limpio y legible, y para evitar el error común de olvidarse de agregar begin/end cuando luego se expande una declaración if/then de una sola declaración.

También es una práctica común y muy recomendable usar consistentemente o no usar un par de inicio/fin tanto para la instrucción entonces como para la instrucción else, incluso si no es necesario. Ayuda a mantener el código equilibrado.

if x < 10 then begin

  x := x+1;

  y := y+1;

end

else

  x := x+10; // feels unsymmetrical with the 'then' block above

if x < 10 then begin

  x := x+1;

  y := y+1;

end

else begin

  x := x+10; // balances nicely, even if the 'begin/end' is unnecessary here.

end;

Condiciones anulables

La expresión de condición para las sentencias if/then debe ser de tipo booleano o booleano anulable.

Si la condición es un booleano simple, la instrucción si/entonces ejecutará la cláusula entonces si la condición es verdadera y la cláusula else (opcional) si la condición es falsa.

Si la condición es de tipo booleano anulable, entonces se debe considerar el caso adicional de la condición que se evalúa como cero. Si bien un booleano anulable nulo estrictamente hablando no es equivalente a falso, la instrucción si/entonces los trata de la misma manera y ejecutará la cláusula else, si se proporciona, en este caso.

Este comportamiento se extiende simétricamente a los bucles while/do, que también tratan una condición nula como falsa y saldrán del bucle, mientras que los bucles repeat/until tratarán una condición nula como falsa y seguirán ejecutando el bucle.

Decisiones en cascada o anidadas.

Ejemplos:

Decisiones en secuencia

Ciclos

Un ciclo es una estructura que permite repetir o iterar un conjunto de acciones la cantidad de veces que determine una condición. Siempre debe de tener un inicio y un final.

for i := 0 to 10 do 
  DoSomething;

for i: Integer := 0 to 10 do 
  DoSomething;

for i := 0 to 10 step 2 do 
  DoSomething();

for i := 0 to 10 step 3 do 
  DoSomething();

for i := 10 downto 0 do 
  DoSomething();

for each i in list do 
  DoSomething();

for each i: String in list do {...}

for each s in list index i do 
  DoSomething(s);

Los ciclos while  nos permite ejecutar una o varias líneas de código de manera repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera conocer cuando se va a dar el valor final que esperamos, los ciclos while, no dependen directamente de valores numéricos, sino de valores booleanos, es decir su ejecución depende del valor de verdad de una condición dada, verdadera o falso, nada más. De este modo los ciclos while, son mucho más efectivos para condiciones indeterminadas, que no conocemos cuando se van a dar a diferencia de los ciclos for, con los cuales se debe tener claro un principio, un final y un tamaño de paso.

   Si la condición es falsa la primera vez nunca se  ejecuta  el (los) estatuto(s).

Do while.

Estructura Do-While o Hacer-Repetir

Es una estructura repetitiva en donde el número de repeticiones es desconocido y se hará mientras se cumpla cierta condición, dependiendo de ella puede que se realice más de una o ninguna vez.

Se diferencia con el ciclo while ya que en este la condición se realiza al finalizar el ciclo, mientras que en el do-while se ejecutan las instrucciones y luego se evalúa la condición.

Sintáxis

do

{

Bloque de instrucciones;

}

while(condición de finalización);

Ciclos while/do

El ciclo while/ do es un ciclo que ejecuta una declaración o un bloque de declaraciones repetidamente, siempre que una condición determinada se evalúe como true. La condición se volverá a evaluar al comienzo de cada iteración del ciclo, lo que permitirá que el código dentro del ciclo afecte la condición para terminarla.

Dado que la condición se evalúa antes de que se ingrese el bucle, es posible que un bucle while/ do nunca se ejecute ni una sola vez, si la condición ya está false cuando la ejecución llega al bucle.

Como alternativa al ciclo while/do , evaluará una condición al final de cada iteración, proporcionando así un ciclo que se garantiza que se ingresará al menos una vez.

Sintaxis

La sintaxis básica para un bucle while/ do se ve así:

while x < 10 do 
  DoSomething();

donde se especifica una expresión condicional entre las palabras clave while y do, y la palabra clave do va seguida de la declaración que se ejecutará repetidamente.

Por sí solo, el bucle while/ do solo requiere que se ejecute una sola declaración para cada iteración. Para ejecutar más de una sentencia, se pueden agrupar varias sentencias usando una sentencia begin/end:

while x > 10 do begin
  DoSomething();
  DoSomethingElse();
end;

 

Bucles infinitos

Un bucle infinito es un bucle que ejecuta una sentencia o un bloque de sentencias repetidamente, sin una condición de protección para determinar su final (como los bucles while/do y repeat/until o un conjunto predefinido de elementos para recorrer, como el bucle for).

break: Un ciclo infinito se ejecutará indefinidamente , hasta que se rompa explícitamente usando una declaración break, exit o raise.

La sintaxis de un bucle infinito es simplemente la palabra clave loop, seguida de la declaración que se repetirá:

loop DoSomething();

 

Bucles infinitos y bloques begin/ end.

Por sí solo, el ciclo infinito solo requiere que se ejecute una sola declaración para cada iteración.

Dada la necesidad de eventualmente salir del ciclo con una declaración break o exit, el ciclo infinito casi siempre se usa en combinación con una declaración begin/end bloque para permitir la ejecución de múltiples declaraciones para cada iteración:

loop begin
  DoSomething();
  DoSomethingElse();
  if DoneSomethingThird then
    break;
end;

Salir prematuramente del bucle o de una iteración de bucle

Como todos los bucles, los bucles infinitos se pueden salir prematuramente usando las declaraciones break y exit, y una iteración de un solo ciclo se puede acortar usando la declaración continue, que salta a la siguiente iteración del ciclo.

Arreglos

Estructura de datos que sirve para almacenar grandes secuencias de números.

Matrices

Es una estructura de datos, o más técicamente, un espacio de memoria que permite almacenar una colección de elementos, todos del mismo tipo.

Sentencias

Switch

*CASE

*BREAK

*DEFEAULT

Aunque la sentencia if es muy importante, en ocasiones puede ser muy tediosa, sobre todo en los casos en el que  programa presenta varias elecciones.

En situaciones donde el valor de una expresión determina  que sentencias serán ejecutadas será mejor utilizar una      sentencia switch en lugar de una if.

El condicional switch permite elegir entre varias opciones posibles. En realidad, este condicional puede ser expresado también usando condicionales if, por lo que podríamos decir que no es estrictamente necesario. Sin embargo, en algunos casos resulta más claro usar el condicional switch y resulta útil.

Una sentencia switch contiene un selector.  Cuando una sentencia switch se ejecuta, el valor del selector se compara con las etiquetas case. Si alguna de ellas concuerda con ese valor se ejecutara la correspondiente secuencia de sentencias. Si queremos que varias alternativas tengan el mismo conjunto de sentencias a ejecutar.

Expresiones

Las expresiones son construcciones de código que representan un valor. Son similares a las declaraciones , pero con una diferencia crucial: mientras que las declaraciones regulares siempre deben valerse por sí mismas, las expresiones representan un valor que puede (a veces debe) usarse en el contexto más amplio de una expresión o declaración circundante.

Por ejemplo, " 5 + 3" es una expresión, con un valor resultante de 8. No tiene mucho sentido escribir " 5 + 3" como una declaración en sí misma, pero la expresión se puede incrustar en una fórmula más compleja como " (5 + 3) * 2", o en una declaración como " ".var   x := 5 + 3;

Algunas expresiones se pueden usar como declaraciones, ignorando su valor final. Por ejemplo, una expresión de llamada a método puede producir un resultado que puede ser parte de una expresión más grande, pero también se puede llamar al mismo método como una declaración.

Ejemplos de expresiones

Las expresiones pueden ser tan simples como un valor literal , como el número 5o la cadena 'Hello', pueden ser identificadores simples, que se refieren a una variable o llaman a un método que devuelve un valor, o pueden ser expresiones complejas que combinan varias expresiones. para representar una nueva expresión.

Por ejemplo, la condición dentro de if/then es una expresión (de tipo booleano ). Si declara una variable con la Declaración var y le asigna un valor inicial, ese valor es una expresión.

var five := 5; // una expresión literal simple, '5', se usa para inicializar una variable

var ten := 2 * five; // un '2' literal y una expresión de referencia variable ('cinco') 
                     // se usan como operandos de una expresión mayor que los multiplica

if ten > 5 then DoThis(); // una expresión de referencia variable se compara con una expresión
                          // literal y la expresión booleana resultante se utiliza para
                          // ejecutar condicionalmente la expresión de llamada al método `DoThis()`

En los ejemplos anteriores, ha visto tres tipos de expresiones:

• Literales : un valor real codificado de forma rígida.
• Expresiones binarias : combinación de dos operandos con un operador como *o <.
• Referencias de identificador : se refiere a una variable o método que está dentro del alcance, simplemente por su nombre. (Técnicamente hablando, la llamada a DoThis()es tanto una referencia de identificador como una llamada de método ).

Los paréntesis le permiten encerrar visualmente sub expresiones para indicar el orden de precedencia en el que se ejecutarán dentro de una expresión más grande. Esto es especialmente útil cuando se usan operadores binarios , pero también puede ayudar a aclarar otras expresiones más complejas.

var x := 3 + 2 * 5 // evaluates to 3 + 10 = 13, as * has precedence over + by default.
var x := (3 + 2) * 5 // evaluates to 5 * 5 = 25, as the parenthesis cause the addition to be performed first.