Pagina nueva 1

Free Web Hosting Provider - Web Hosting - E-commerce - High Speed Internet - Free Web Page

"Tutorial de pascal"

Bloques o Sentencias Compuestas

Un bloque es un conjunto de sentencias designadas a realizar una tarea en común, las sentencias están separadas por un ";", y el bloque es delimitado por las palabras reservadas Begin y End, esto le permite al compilador reconocer todo lo que tiene que ejecutar en algún caso determinado. El ejemplo mas claro que podemos ver, es el cuerpo de un programa.

Program Bloque ;

BEGIN
WriteLn( ' Buenos dias' );
WriteLn( ' Buenas tardes ' );
END .

Cuantas veces en nuestra vida cotidiana realizamos la misma tarea varias veces, creo que casi todo el tiempo pasa esto, en la codificación de programas existe una forma de realizar la misma tarea sin tener que escribir N veces la misma sentencia.

Ciclo FOR

Casi todos los lenguajes de programación no brindan sentencias de ciclos, Turbo Pascal cuenta con el ciclo FOR, este nos permite realizar un numero exacto de veces una sentencia o bloque de sentencias. Su sintaxis es la siguiente :

FOR Variable := V_Inicial To V_Final DO
Sentencia ;

Para hacer esto, el ciclo FOR utiliza como base una variable índice, la cual parte de un valor inicial, sufriendo un incremento o decremento, hasta llegar al valor final. Esto se vera más claro con el ejemplo siguiente:

Diferencia entre no usar y usar un Ciclo

Program Sin_Ciclo ;
Begin
   WriteLn( ' Número = 1' ) ;
   WriteLn( ' Número = 2' ) ;
   WriteLn( ' Número = 3' ) ;
   WriteLn( ' Número = 4' ) ;
End.

Program Ciclo ;
Var
I : Integer ;
Begin
For I := 1 To 4 Do
WriteLn( ' Número = ', I ) ;
End.

La principal limitante con la sentencia FOR, es la incapacidad de salir sin completar el ciclo, obligando al compilador a ejecutar el proceso involucrado, el número de veces especificados.

Existe dos maneras de ejecutar la sentencia FOR, el incremento en uno "TO" y el decremento en uno "DOWNTO", cubriendo con esto todas las necesidades de un programador en la manipulación de sus datos.

Diferencia entre TO y DOWNTO

Program Ciclo_1_a_4 ;
Var
     I : Integer ;
Begin
For I := 1 To 4 Do
      WriteLn( ' Número = ', I ) ;
End.

Program Ciclo_4_a_1 ;
Var
     I : Integer ;
Begin
For I := 4 DownTo 1 Do
      WriteLn( ' Número = ', I ) ;
End.

Ciclo WHILE

Esta sentencia nos permite realizar un proceso cíclico más flexible, nos libra de la dependencia de un número preestablecido, el compilador ejecuta la sentencia WHILE, siempre y cuando la condición booleana sea valida (True), de ser falsa (Fasle) termina automáticamente la sentencia. Su sintaxis es la siguiente:

WHILE Condición DO
Sentencia ;

Si quisiéramos realizar un proceso diez veces, tendríamos que forzar la sentencia WHILE a trabajar como FOR. Esto se muestra en el siguiente ejemplo:

Program WHILE_a_FOR ;
Var
     I   : Integer ;
Begin
    I := 1 ;
WHILE I <= 4 Do
       Begin
           Writeln( ' Número ', I ) ;
            I := I + 1 ;
       End;
End.

Cuando la variable I llegue al valor de 5, la condición no se cumplirá, terminando la sentencia WHILE.

Ciclo REPEAT UNTIL

La sentencia REPEAT es la contra parte del WHILE, el compilador primero ejecuta el bloque de sentencias, al terminar verifica el resultadode la condicion UNTIL y de ser falsa lo seguirá ejecutándo, el ciclo terminará cuando sea verdadera. Su sintaxis es la siguiente:

REPEAT
   Sentencia ;
   ...
   Sentencia ;
UNTIL Condición;

Si quisiéramos realizar un proceso diez veces, tendríamos que forzar la sentencia REPEAT UNTIL a trabajar como FOR. Esto se muestra en el siguiente ejemplo:

Program REPEAT_a_FOR ;
Var
     I   : Integer ;
Begin
    I := 1 ;
REPEAT
         Writeln( ' Número ', I ) ;
          I := I + 1 ;
    UNTIL I = 5 ;
End.

Cuando la variable I llegue al valor de 5, la condición se cumplirá, terminando la sentencia REPEAT UNTIL.

Sentencia IF ... THEN ... ELSE ...

Esta sentencia nos brinda la posibilidad de bifurcar la ejecución de un programa, basandoce en procesos alternativos vinculados a una condición, permitiendo depurar los resultados finales. Su sintaxis es la siguiente:

IF Condición THEN
Sentencia
ELSE
Sentencia;

Si deseamos determinar si un numero es par o non, haríamos un ciclo determinado verificando el residuo de la variable índice, si es cero es par y sino es non. Esto se muestra en el siguiente ejemplo:

Program Pares_Nones ;
Var
     I   : Integer ;
Begin
FOR I := 1 TO 4 DO
        IF ( I MOD 2 ) = 0 THEN
           Writeln( ' Número ', I, ' Es PAR' )
        ELSE
           Writeln( ' Número ', I, ' Es NON' ) ;
End.

El IF puede omitir la sentencia ELSE, evitando realizar un proceso al ser falsa la condición.

Sentencia IF anidadas

Cuando una condición es muy compleja de platear, se pueden realizar bloques de IF anidados, facilitando con esto el desempeño del compilador, evitando la evaluación de condiciones de dudosa eficiencia. Su sintaxis es la siguiente:

IF Condición 1 THEN
      IF Condición 2 THEN
         Sentencia
      ELSE
         Sentencia
ELSE
   Sentencia;

En una lista de números del uno a diez, se desea encontrar los pares que estén entre el 3 y 7, una solución es aplicar dos sentencias IF anidadas verificando ambas condiciones. Esto se muestra en el ejemplo siguiente:

Program Pares_entre_3_y_7 ;
Var
     I   : Integer ;
Begin
FOR I := 1 TO 10 DO
     IF ( I MOD 2 ) = 0 THEN
         IF ( I >= 3 ) AND ( I <= 7 ) THEN
             Writeln( ' Núm ', I, ' PAR entre 3 y 7' ) ;
End.

Sentencia CASE

Una variable puede tomar una gran variedad de valores, si deseáramos tomar en cuenta cada uno de ellos, tejeríamos una gran telaraña de IF, en estos casos se puede utilizar la sentencia CASE, capaz de estructurar sus valores significativos asignándole el proceso a realizar. Su sintaxis es la siguiente:

CASE Variable OF
Valor 1 : Sentencia;
...
Valor N : Sentencia
ELSE
Sentencia
END ;

La sentencia CASE solo soporta variables Carácter y enteras, evitando así las complejas evaluaciones, esto se comprenderá mejor con el siguiente ejemplo:

Program Pares_Nones ;
Var
     I, Res   : Integer ;
Begin
FOR I := 1 TO 4 DO
       Begin
       Res := ( I MOD 2 ) ;
           CASE Res OF
          0 : Writeln( ' Número ', I, ' Es PAR' ) ;
          1 : Writeln( ' Número ', I, ' Es NON' ) ;
           End
         End
End.

Sentencia GOTO

Esta característica es del lenguaje BASIC, cambia el orden secuencial de ejecución de un programa, esto representa romper el modelo estructurado de programación de Turbo Pascal, corriendo el riesgo de perder el control del mismo.

Para Usar la sentencia GOTO, es necesario primero declarar todas las etiquetas con la palabra reservada LABEL, una etiqueta es un identificador como cualquier otro, el bloque a realizar se delimita usando ":" y END, esto nos representa el inicio y final del mismo. Su sintaxis es la siguiente:

GOTO Etiqueta;

Un ejemplo sencillo del uso del GOTO es el siguiente:

Program Pares_Nones ;
LABEL Salto ;
     I, Res   : Integer ;
Begin
   Writeln( ' Primera Línea ' ) ;
GOTO Salto ;
   Writeln( ' Segunda Línea' ) ;
   Salto : Writeln( ' Tercera Línea' ) ;
End.

En este ejemplo vemos como el compilador se brinca la sentencia WriteLn, evitando desplegar el letrero de "Segunda Línea".

Sentencia HALT

Se utiliza para romper la ejecución de un programa, el HALT se puede aplicar cuando se presenta algún error en las variables de alguna formula, fallas físicas, o por carecer de sentido el programa. Su sintaxis es la siguiente:

HALT;

Un ejemplo sencillo del uso del HALT es el siguiente:

Program Pares_Nones ;
Begin
   Writeln( ' Primera Línea ' ) ;
   HALT ;
   Writeln( ' Segunda Línea' ) ;
   Writeln( ' Tercera Línea' ) ;
End.

En este ejemplo vemos como el compilador ejecuta solo la primera sentencia WriteLn, y termina su ejecución.

Operaciones Básicas

Las Operaciones se realizan por medio de operadores y operandos, donde el operador es un símbolo que indica a el compilador la operación a realizar, los operandos son los datos a quienes aferctará el operador. Existen cuatro operadores basicos y son los siguientes:

Operadores	Operación
*	Multiplicación
/	División
+	Suma
-	Resta

Cuando se realiza cualquier operación, el resultado arrojado será del tipo capaz de soportarla. Por ejemplo la suma de números reales arroja un número real, no obstante la suma de un número real con uno entero, arrojará un real.

Operadores DIV y MOD

En el caso de la división, no importando los números que dividamos, el resultado será un número real, para obtener un resultado entero, debemos de utilizar el operador DIV, de la misma manera usaremos el operador MOD, para obtener el residuo entero. Su sintaxis es la siguiente :

N_Entero:= DividendoDIV Divisor ;
N_Entero:= DividendoMOD Divisor ;

Este programa es un ejemplo sencillo de operaciones :
Programa

Program Operaciones ;
   Var
     Sum, Res, Mul, Div_ : Real ;
     C_Ent, R_Ent           : Integer ;

Begin
    Sum := 5 + 2 ;
    Res := 5 - 2 ;
    Mul := 5 * 2 ;
    Div_   := 5 / 2 ;
    C_Ent := 5 DIV 2 ;
    R_Ent := 5 MOD 2 ;
    WriteLn( ' La suma de 5 + 2 = ', Sum ) ;
    WriteLn( ' La Resta de 5 - 2 = ', Res ) ;
    WriteLn( ' La Multiplicación de 5 * 2 = ', Mul ) ;
    WriteLn( ' La División de 5 / 2 = ', Div_ ) ;
    WriteLn( ' La división Entera 5 / 2 = ', C_Ent ) ;
    WriteLn( ' El Residuo Entera 5 / 2 = ', R_Ent ) ;
End.

Prioridad de Operadores

Cuando realizamos alguna expresión muy compleja, nos encontraremos con mas de un operador, esto no representa ningún problema, debido a que los operadores tienen una jerarquía de ejecución, es decir se realizan de izquierda a derecha los operadores de mayor a menor jerarquía. El orden de jerarquía es el siguiente:

( )	Cunetan con la mayor jerarquía.
* / DIV MOD	Cunetan con la mediana jerarquía.
+ -	Cunetan con la menor jerarquía.

Este programa es un ejemplo sencillo de la jeraquía de operadores:
Programa

Program Operaciones ;
Var
Op1, Op2 : Real ;

Begin
    Op1 := 3 + 5 * 2 ;
    Op2 := ( 3 + 5 ) * 2 ;
    WriteLn( ' El Resultado de 3 + 5 * 2 = ', Op1 ) ;
    WriteLn( ' El Resultado de ( 3 + 5 ) * 2 = ', Op2 ) ;
End.

Constantes Variables

Este termino suena medio absurdo, debido a que las constantes no pueden cambiar su valor, al comprenderlo desde otro punto de vista nos daremos cuenta que es una variable, con la única diferencia de tener un valor inicial asignado.

Estas se usan para evitar la tarea de inicializar nuestras variables en el programa, esto se debe a que una variable al ser declarada, trae consigo el valor ocupado en la memoria antes de su asignación. Un ejemplo similar es cuando adquirimos una caja nueva, esta puede venir vacía o con objetos, para poderla usar limpiaríamos primero su interior y posteriormente guardaríamos nuestros objetos. Su sintaxis es la siguiente :

Const
Var_Con_I : Real = 3.1415926 ;
Var_Con_S : String = ' Hola ' ;
Programa

Program Constantes_Variables ;
   Const
     Num1 : Integer = 10 ;
   Nom1 : String = 'Carlos' ;
   Var
     Num2 : Integer ;
     Nom2 : String ;

Begin
    WriteLn( ' Constante Variable con 10 = ', Num1 ) ;
    WriteLn( ' Copstante Variable con Carlos = ', Nom1 ) ;
    WriteLn( ' Variable númerica = ', Num2 ) ;
    WriteLn( ' Variable Cadena = ', Nom2 ) ;
End.

Operadores Lógicos

Son todas las operaciones comparativas que podemos realizar con nuestros datos, obteniendo como unico resultado un True o False. La siguiente tabla muestra estos operadores:

Operadores	Descripción
=	Igual a
<>	Distinto a
<	Menor que
>	Mayor que
<=	Menor igual que
>=	Mayor igual que
Not	Negación de condición

Procedimiento

Es un identificador ligado a un bloque de sentencias, esto nos permite usarlo varias veces, sin necesidad de repetir todo el código, llamando el bloque por medio de su identificador.

Un ejemplo sencillo, es el asignar valores nulos a variables utilizadas en varios cálculos, para no repetir el código utilizaremos un procedimiento de nombre Inicio, el cual llamaríamos en las diversas partes donde sea necesario.

Creación de Procedimientos

No se puede crear un procedimiento sin tener un objetivo especifico, tomando en cuenta posibles los valores de entrada, sus identificadores propios, y el bloque de sentencias capaz de cumplir con el objetivo. Su sintaxis es la siguiente:

PROCEDURE Identificador ( Parámetros ) ;
Sección declarativa ;
BEGIN
END;

Cuando declaramos un procedimiento, automáticamente se incorpora como un identificador durante su compilación y ejecución.

Este es un ejemplo sencillo de la declaración y uso de un procedimiento:

Program Procedimiento ;

Var
X, Y, Z : Integer ;

PROCEDURE Inicio( X1, Y1, Z1 : Integer ) ;
     Begin
        X :=X1; Y := Y1;   Z := Z1 ;
     End;

Begin
Inicio( 1, 2, 3 ) ;
WriteLn( 'X=', X, ' Y=', Y, ' Z=', Z ) ;
Inicio( 4, 5, 6 ) ;
WriteLn( 'X=', X, ' Y=', Y, ' Z=', Z ) ;
End.

Función

Al igual que un procedimiento, es un identificador ligado a un bloque de sentencias, permitiendo su uso indefinidamente, sin necesidad de repetir todo el código, pero nos ofrece la ventaja de devolver un valor al final de su ejecución.

Un ejemplo sencillo, es realizar una suma con dos valores de entrada, devolviendo el resultado obtenido a la función.

Creación de Funciones

No se puede crear una Función sin tener un objetivo especifico, tomando en cuenta los posibles valores de entrada, sus identificadores propios, el bloque de sentencias, y el tipo de valor que devolverá la función. Su sintaxis es la siguiente:

FUNCTION Identificador ( Parámetros ) : Tipo ;
Sección declarativa;
BEGIN
END;

Este es un ejemplo sencillo de la declaración y uso de una Función:

Program Procedimiento ;

Var
Z : Integer ;

FUNCTION Suma( X1, X2 : Integer ): Integer ;
     Begin
        Suma := X1 + X2 ;
     End;

Begin
     Z := Suma( 1, 1 ) ;
     WriteLn( ' 1 + 1 =', Z ) ;
     Z := Suma( 2, 2 ) ;
     WriteLn( ' 2 + 2 =', Z ) ;
End.

Parámetros

Las funciones y procedimientos normalmente las trabajamos con variables globales, limitando su campo de acción, con el uso de parámetros logramos indicar los valores y variables iniciales de los procesos, logrando una mayor flexibilidad y portabilidad.

Contamos con dos tipos de parámetros:

Parámetros por valor

Cuando se pasa un parámetros por valor, se obtiene una copia temporal de la variable usada, dentro de la función o procedimiento se trabaja con la copia obtenida, no importando las operaciones que se realicen con la copia, la variable introducida como parámetro, no será afectada en su valor inicial al terminar el proceso. Su sintaxis es la siguiente:

PROCEDURE Identificador ( Ide1, Ide2: Tipo; Ide3: Tipo ) ;
Parámetro por referencia

Cuando se pasa un parámetros por referencia, los cambios que se realicen a la variable introducida como parámetro, se mantendrán vigentes al terminar el proceso, en este caso especifico solo se admiten variables. Su sintaxis es la siguiente:

PROCEDURE Identificador ( VAR Ide1: Tipo ) ;
Variables Globales

Estas variables se declaradas después de la sección de unidades, permitiendo su utilización tanto en los procedimientos y funciones, como en el cuerpo del programa.

Este es un ejemplo sencillo de Variables Globales:

Program Procedimiento ;

VAR
Z : Integer ;

Begin
...
End.

Variables Locales

Estas variables se declaradas dentro de un procedimiento o función, quedando limitadas para ser usadas en cualquier sección del programa.

Este es un ejemplo sencillo de Variables Locales:

Program Procedimiento ;

PROCEDURE Local ;
     VAR
        Z   : Integer ;
      Begin
         ...     { Sección valida de Z }
      End;

Begin
...
End.

Truncamiento y Redondeo

El Truncamiento nos permite eliminar la parte decimal de un número real, la función es TRUNC(), nos devuelve un numero de tipo entero. Su sintaxis es la siguiente :

Variable_Entera := TRUNC( Número_Real ) ;

El Redondeo nos permite aproximarnos a un número entero más cercano, esto se define con sus decimales, mayor o igual a 0.5 sube al numero entero consecutivo, menor a 0.5 se trunca la parte decimal, la función es ROUND( ), nos devuelve un numero de tipo entero. Su sintaxis es la siguiente :

Variable_Entera := ROUND( Número_Real ) ;

Este sencillo ejemplo, aplicará las funciones anteriores:

Program Tru_Red ;

Begin
   WriteLn( ' Truncar   3.89 = ', TRUNC( 3.89 ) ) ;
   WriteLn( ' Redondea   4.6 = ', ROUND( 4.6 ) ) ;
   WriteLn( ' Redondea   5.1 = ', ROUND( 5.1 ) ) ;
End.

Funciones Exponenciales y Logarítmicas

La función SQR( ), nos brinda el cuadrado de un número, el tipo de esta función es real o entera, según se requiera en la sentencia. Su sintaxis es la siguiente:
Variable := SQR( Número ) ;

La función SQRT( ), nos brinda la raíz cuadrado de un número, el tipo de valor que devuelve esta función es real. Su sintaxis es la siguiente:

Variable_Real := SQR( Número ) ;

La función EXP( ), nos brinda el valor de e elevado a la X, el tipo de valor que devuelve esta función es real. Su sintaxis es la siguiente:

Variable_Real := EXP( Número ) ;

La función LN( ), nos brinda el logaritmo natural de un número, el tipo de valor que devuelve esta función es real. Su sintaxis es la siguiente:

Variable_Real := LN( Número ) ;

Este sencillo ejemplo, aplicará las funciones anteriores:

Program Exp_Log ;

Begin
   WriteLn( ' Cuadrado 3.5 = ', SQR( 3.5 ):3:2 ) ;
   WriteLn( ' Raíz   6 = ', SQRT( 6 ):3:2 ) ;
   WriteLn( ' e ^ 3 = ', EXP( 3 ):3:2 ) ;
   WriteLn( ' Logaritmo 3 = ', LN( 3 ):3:2 ) ;
   WriteLn( ' 2 ^ 3 = ', Exp( 3 * Ln( 2 ) ):3:2 ) ;
End.

Funciones Aritméticas

La función ABS( ), nos permite obtener el valor absoluto de un número o variable, esto se requiere en algunos procesos matemáticos. Su sintaxis es la siguiente:

Variable := ABS( Valor ) ;

El procedimiento DEC( ), nos permite decrementar el valor de una variable un numero de unidades especificados. Su sintaxis es la siguiente:

DEC( Variable, Valor ) ;

El procedimiento INC( ), nos permite incrementar el valor de una variable un numero de unidades especificados. Su sintaxis es la siguiente:

INC( Variable, Valor ) ;

La función INT( ), nos permite obtener la parte entera de un número real, el valor que devuelve es de tipo real. Su sintaxis es la siguiente:

Variable := INT( Valor ) ;

La función FRAC( ), nos permite obtener la parte decimal de un número real, el valor que devuelve es de tipo real. Su sintaxis es la siguiente:

Variable := FRAC( Valor ) ;

Funciones Trigonométricas

El seno, coseno y arcotangente, son las unicas funciones trigonométricas que existen en Turbo Pascal, el resto se pueden calcular a partir de estas.

El seno SIN(), coseno COS() y arcotangente ARCTAN(), la siguiente tabla nos muetra como calcular las demas:

Función	Operación
Tangente( X )	Sin(x) / Cos(x)
Cotangente( X )	Cos(x) / Sin(x)
Secante( X )	1 / Cos(x)
Cosecante( X )	1 / Sin(x)

Números Aleatorios

La función RANDOM, genera un número decimal comprendido entre 0 y 1, si utilizamos un parámetro X, obtiene un numero entero entre 0 y X-1.

La procedimiento RANDOMIZE, evita generar el mismo grupo de números aleatorios, renovándolo en cada ejecución.

Este sencillo ejemplo, aplicará las funciones de números Aleatorios:

Program Random_Randomize ;
Var
I : Integer ;

Begin
   RANDOMIZE ;
   FOR I := 1 TO 15 DO
       WriteLn( ' Numero : ', RANDOM( 50 ) ) ;
End.

Cadena de Caracteres

Una cadena consta de 1 a 255 caracteres, el tipo de variable que la soporta es el string, si deseamos delimitar el tamaño de las cadena, se especifica entre corchetes su longitud, teniendo como limite 255 caracteres. Su sintaxis es la siguiente :

Var_Cadena : STRING;
Var_Cadena : STRING[ Número ] ;
Comparación de Cadenas

Cuando comparamos dos cadenas, se toman en cuenta el valor ASCII de sus caracteres, un ejemplo sencillo puede ser las cadenas ‘Alas’ y ‘alas’, a simple vista pensaríamos que son iguales, pero en realidad la cadena ‘Alas’ es menor que ‘alas’, debido a los valores de sus letras son diferentes, ‘A’ = 65 y ‘a’ = 97.

La longitud es una característica importante en las cadenas, la cual se determina por su número de caracteres, por ejemplo, la longitud de ‘Hola’ es de 4 caracteres, si una cadena no contiene caracteres, la llamaremos vacía o nula.

Manejo de los caracteres de una cadena

Si deseamos manipular algún carácter de una cadena, tendremos que especificar la casilla de su ubicación, para obtener o cambiar su valor actual.

Aplicando esta característica de las cadenas, podríamos seleccionar y desplegar en pantalla el carácter deseado, para ello desarrollaremos el siguiente ejemplo:

Program Mod_Cadena ;
    Var
       Cad : String[ 10 ] ;
Begin
    Cad := 'UNO' ;
    WriteLn( Cad[ 1 ] ) ;
    WriteLn( Cad[ 2 ] ) ;
    WriteLn( Cad[ 3 ] ) ;
End.

Longitud de las Cadenas

La función LENGTH( ), permite saber el número de caracteres de una cadena, devuelve un número entero entre 0 a 255. Su sintaxis es la siguiente :

Variable := LENGTH( Cadena ) ;
Operador +

Este operador nos permite unir varias cadenas de caracteres, esto se realiza como una simple suma, de igual manera podemos agregar caracteres a una cadena.

Función CONCAT( )

Esta función nos permite unir varias cadenas de caracteres, devolviendo como resultado una cadena, funciona de igual manera que el operador +. Su sintaxis es la siguiente:

Variable:= CONCAT( Cadena_1, Cadena_2, ... Cadena_N ) ;

En este ejemplo aplicaremos los conceptos anteriores :

Program Con_Len ;
    Var
       Cad : String[ 10 ] ;
       K     : Integer ;
Begin
    Cad := 'U' + 'N' ;
    Cad := CONCAT( Cad, 'O' ) ;
    FOR K := 1 TO LENGTH( Cad ) DO
        WriteLn( Cad[ K ] ) ;
End.

Función POS( )

Esta función nos permite buscar una subcadena dentro de una cadena, nos devuelve un valor entero, el cual indique la posición en donde se encuentra la subcadena. Su sintaxis es la siguiente :

Variable := POS( SubCadena, Cadena ) ;

Si no se logra encontrar la subcadena, la funcion nos devolverá un cero.

Función COPY( )

Esta función nos devuelve una subcadena, tomando como base una posición de la cadena origen, y el número de caracteres a copiar. Su sintaxis es la siguiente:

Variable := COPY( Cadena, Posición, Num_Caracteres ) ;

Si se rebasa la capacidad de la variable receptora, solo se copiaran los caracteres que pueda soportar.

Procedimiento INSERT( )

Este procedimiento inserta una subcadena, indicando la cadena destino, y la posición de la inserción. Su sintaxis es la siguiente:

INSERT( Sub_Cadena, Cadena, Posición ) ;

En una inserción de subcadenas, se puede saturar la capacidad de la cadena receptora, impidiendo la inserción completa, obligando a omitir la parte restante.

Procedimiento DELETE( )

Este procedimiento borra una cantidad de caracteres de una cadena, indicando su posición inicial y el número de caracteres a eliminar. Su sintaxis es la siguiente:

DELETE( Cadena, Posición, Num_Caracter ) ;

En muchos casos el número de caracteres a borrar, rebasa por completo la longitud de la cadena, se ignora los caracteres excedidos.

Función UPCASE( )

Esta función convierte a mayúsculas un carácter alfabético, el cual se proporciona como parámetro. Su sintaxis es la siguiente:

Variable:= UPCASE( Caracter ) ;

Si el carácter utilizado como parámetro, no es una letra del abecedario, no sufrirá ningún cambio, conservando su valor original.

Procedimiento STR( )

Este procedimiento convierte un valor numérico a cadena de caracteres, no importando el tipo de número, puede ser entero o con decimales. Su sintaxis es la siguiente:

STR( Var_Numérica, Cadena ) ;

En la variable cadena se deposita la conversión satisfactoria de la variable numérica, utilizando el número de caracteres que sea necesario.

Procedimiento VAL( )

Este procedimiento convierte una cadena de caracteres a un valor numérico, siempre y cuando los caracteres de la cadena sean números. Su sintaxis es la siguiente:

VAL( Cadena, Var_Numérica, Var_Entera ) ;

En la variable numérica se deposita la conversión satisfactoria de la cadena, en caso de contener caracteres especiales o letras, la variable numérica almacenara un cero, y se asignara un valor de error en la variable entera.

Unidades

Son un conjunto de identificadores compilados, los cuales podemos llamar en cualquier programa de Turbo Pascal, sin necesidad de escribirlos de nuevo.

Una unidad no se puede ejecutar por si sola, estas requieren ser llamadas por un programa, donde podrán desempeñar sus tareas.

Palabra reservada USES

Esta sentencia se utiliza para declarar una unidad, indicando la integración al programa, la unidades se declaran después de la sentencia PROGRAM.

Las unidades estándar con que cuenta Turbo Pascal son la siguientes:

Crt

Dos

Graph

Overlay

Printer

System

Estructura de las Unidades

La unidades se componen de cuatro partes, declaración, interfaz, implementacion e inicializacion.

Declaración

Esta sección es la que se encarga de asignar un nombre a la unidad, por consiguiente no se puede omitir. Su sintaxis es la siguiente:

UNIT Nombre ;
Interfaz

Esta sección se encarga de la declaración de todos los identificadores que pueden ser usados el programa, como son variables, constantes, procedimientos y funciones. En esta sección no se incluyen los códigos de los procedimientos ni funciones, solo se encuentra su declaración. Su sintaxis es la siguiente:

INTERFACE
Uses Unidades ;
Var
Let : String ;
Procedure Nom ;
Implementación

Esta sección es exclusiva para la unidad, contiene la declaraciones de etiquetas, variables, constantes, así como el contenido de los procedimientos y funciones declarados en la sección de interfaz. Su sintaxis es la siguiente:

IMPLEMENTATION
Procedure Nom ;
   Begin
    ...
   End;
Inicialización

Esta sección se utiliza para inicializar los valores de las variables, no es indispensable de las unidades. Su sintaxis es la siguiente;

Begin
Let := ‘’ ;
End.
Creación de una Unidad

Esta unida fue desarrolloda para facilitar el manejo de información en la pantalla, cuenta con sus procedimientos.

UNIT Prueba;
INTERFACE
PROCEDURE Centra( Cad : String; ren : Integer );
IMPLEMENTATION
USES Crt;

PROCEDURE Centra( Cad : String; ren : Integer ) ;
    VAR
      C : Integer ;
BEGIN
      C := ( 80 - Length( Cad ) ) DIV 2
      GotoXY ( C, ren );
      Write( Cad );
END;

BEGIN
END.

Compilación de una Unidad

Las unidades se compilan con destino a disco, de esta manera el compilador generara un archivo con extensión TPU, después de verificar el código fuente.

La compilación se puede ejecutar con las teclas ALT + F9, y la creación de la unidad con la tecla F9.

Archivos de Acceso secuencial

Estos archivos son llamados también archivos de texto, están formados por cadenas de caracteres separadas por un enter, su valor ASCII es de 13, su final esta delimitado por el caracter 26.

Declaración de un Archivo secuencial

Un archivo de texto para ser manipulado, se requiere declara una variable de tipo TEXT, esto nos permitirá asignar la variable al archivo físico de texto. Su sintaxis es la siguiente :

VAR
Archivo : TEXT;

Una vez declarada la variable del archivo, se procede a la asignación el nombre del archivo a manipular.

Asignación de archivos

La sentencia ASSIGN( ), nos asignar el nombre de algún archivo a nuestra variable de tipo archivo. Su sintaxis es la siguiente:

ASSIGN ( VarArchivo, NombreArchivo ) ;

Donde NombreArchivo es una cadena de caracteres que contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio.

Abrir un Archivo de Texto

Los archivos de texto se pueden abrir de tres formas diferentes, cuando son creados se usa el REWRITE( ), cuando se abren de lectura RESET( ) y cuando se abren para agregar mas información APPEND( ).

Escribir datos en el Archivo de Texto

Para poder escribir datos en un archivo de texto, se requiere primero que el archivo se encuentre abierto en modo de escritura, usando la sentencia APPEND( ) o REWRITE( ), posteriormente se utilizan la instrucción WriteLn( ), para escribir los datos. Su sintaxis es la siguiente:

WRITELN( Var_Archivo, Datos ) ;

En este ejemplo crearemos un archivo de texto, y grabanremos tres cadenas:

Program Graba_Texto ;
    Var
       Arch : Text ;
Begin
    Assign( Arch, 'demo.txt' ) ;
    Rewrite( Arch ) ;
    WriteLn( Arch, 'Primera cadena' ) ;
    WriteLn( Arch, 'Segunda cadena' ) ;
    WriteLn( Arch, 'Tercera cadena' ) ;
    Close( Arch ) ;
End.

Leer datos de un Archivo de Texto

Para poder leer datos de un archivo de texto, se requiere primero que el archivo se encuentre abierto en modo de lectura, usando la sentencia RESET( ), posteriormente se utilizan la instrucción ReadLn( ), para leer los datos. Su sintaxis es la siguiente:

READLN( Var_Archivo, Datos ) ;

En este ejemplo abriremos un archivo de texto, y leeremos su contenido:

Program Leer_Texto ;
    Var
       Arch       : Text ;
       Cadena : String ;
Begin
    Assign( Arch, 'demo.txt' ) ;
    Reset( Arch ) ;
    While NOT ( EOF ( Arch ) ) Do
        ReadLn( Arch, Cadena ) ;
    Close( Arch ) ;
End.

Archivos de acceso directo

Estos archivos son tambien llamados archivos con tipo, estos poseen una secuencia de componentes accesibles individualmente, a los cuasles llamaremos registros, un registro es un agrupamiento de datos. Su sintaxis es la siguiente:

Archivo : FILE OF Tipo_Registro;
Abrir un Archivo con Tipo

Los archivos de tipo se pueden abrir de dos formas diferentes, cuando son creados se usa el REWRITE( ), y cuando se abren de lectura y escritura RESET( ).

Escribir datos en el Archivo con Tipo

Para poder escribir datos en un archivo de texto, se requiere primero que el archivo se encuentre abierto en modo de escritura, usando la sentencia RESET( ), después se utilizan la instrucción Write( ), para escribir los datos. Su sintaxis es la siguiente:

WRITE( Var_Archivo, Var_Registro ) ;

En este ejemplo crearemos un archivo de tipo, y grabanremos tres registros:

Program Graba_Registro ;
    Var
       Arch : File of Integer ;
       K      : Integer ;
Begin
    Assign( Arch, 'demo.dat' ) ;
    Rewrite( Arch ) ;
    For K := 1 To 3 Do
       Write( Arch, K ) ;
    Close( Arch ) ;
End.

Leer datos de un Archivo con Tipo

Para poder leer datos de un archivo de tipo, se requiere primero que el archivo se encuentre abierto en modo de lectura, usando la sentencia RESET( ), después se utilizan la instrucción Read( ), para leer los datos. Su sintaxis es la siguiente:

READ( Var_Archivo, Var_Registro ) ;

En este ejemplo abriremos un archivo de tipo, y leeremos su contenido:

Program Leer_Registro ;
    Var
       Arch   : File Of Integer ;
       K        : Integer ;
Begin
    Assign( Arch, 'demo.dat' ) ;
    Reset( Arch ) ;
    While NOT ( EOF ( Arch ) ) Do
        Read( Arch, K ) ;
    Close( Arch ) ;
End.

Ubicación física en un registro específico

El procedimiento SEEK(), nos permite colocarnos en un registro especifico, mediante un parámetro numérico, pero debemos tener cuidado de que exista el número del registro. Su sintaxis es la siguiente:

SEEK( Var_Archivo, Valor_Pos ) ;

Fin de un Archivo

La función booleana EOF( ), nos indica cuando se llega al final de un archivo, no importando su tipo. Su sintaxis es la siguiente:

Variable := EOF( Var_Archivo ) ;

Fin de Linea

La función booleana EOLN( ), nos indica cuando se llega al final de una línea de un archivo de texto, comúnmente se utiliza las lecturas por caracteres . Su sintaxis es la siguiente:

Variable := EOLN( Var_Archivo ) ;

En este ejemplo abriremos un archivo de texto, y leeremos por caracter:

Program Leer_car ;
    Var
       Arch   : Text ;
       Cad    : String ;
       Car     : Char ;
Begin
    Assign( Arch, 'demo.txt' ) ;
    Reset( Arch ) ;
    While NOT ( EOF ( Arch ) ) Do
       Begin
          Cad := '' ;
           While NOT ( EOLN( Arch ) ) Do
               Begin
                  Read( Arch, Car ) ;
                  Cad := Cad + Car ;
                End ;
       End ;
    Close( Arch ) ;
End.

Cerrar un archivo

Después de utilizar un archivo, es importante cerrarlo, evitando con esto que se dañe físicamente, el procedimiento que realiza esta operación es CLOSE(). Su sintaxis es la siguiente:

CLOSE( Var_Archivo ) ;

Archivos de Acceso secuencial

Estos archivos son llamados también archivos de texto, están formados por cadenas de caracteres separadas por un enter, su valor ASCII es de 13, su final esta delimitado por el caracter 26.

Declaración de un Archivo secuencial

Un archivo de texto para ser manipulado, se requiere declara una variable de tipo TEXT, esto nos permitirá asignar la variable al archivo físico de texto. Su sintaxis es la siguiente :

VAR
Archivo : TEXT;

Una vez declarada la variable del archivo, se procede a la asignación el nombre del archivo a manipular.

Asignación de archivos

La sentencia ASSIGN( ), nos asignar el nombre de algún archivo a nuestra variable de tipo archivo. Su sintaxis es la siguiente:

ASSIGN ( VarArchivo, NombreArchivo ) ;

Donde NombreArchivo es una cadena de caracteres que contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio.

Abrir un Archivo de Texto

Escribir datos en el Archivo de Texto

WRITELN( Var_Archivo, Datos ) ;

En este ejemplo crearemos un archivo de texto, y grabanremos tres cadenas:

Leer datos de un Archivo de Texto

READLN( Var_Archivo, Datos ) ;

En este ejemplo abriremos un archivo de texto, y leeremos su contenido:

Archivos de acceso directo

Archivo : FILE OF Tipo_Registro;
Abrir un Archivo con Tipo

Los archivos de tipo se pueden abrir de dos formas diferentes, cuando son creados se usa el REWRITE( ), y cuando se abren de lectura y escritura RESET( ).

Escribir datos en el Archivo con Tipo

WRITE( Var_Archivo, Var_Registro ) ;

En este ejemplo crearemos un archivo de tipo, y grabanremos tres registros:

Leer datos de un Archivo con Tipo

READ( Var_Archivo, Var_Registro ) ;

En este ejemplo abriremos un archivo de tipo, y leeremos su contenido:

Ubicación física en un registro específico

SEEK( Var_Archivo, Valor_Pos ) ;

Fin de un Archivo

La función booleana EOF( ), nos indica cuando se llega al final de un archivo, no importando su tipo. Su sintaxis es la siguiente:

Variable := EOF( Var_Archivo ) ;

Fin de Linea

La función booleana EOLN( ), nos indica cuando se llega al final de una línea de un archivo de texto, comúnmente se utiliza las lecturas por caracteres . Su sintaxis es la siguiente:

Variable := EOLN( Var_Archivo ) ;

En este ejemplo abriremos un archivo de texto, y leeremos por caracter:

Cerrar un archivo

Después de utilizar un archivo, es importante cerrarlo, evitando con esto que se dañe físicamente, el procedimiento que realiza esta operación es CLOSE(). Su sintaxis es la siguiente:

CLOSE( Var_Archivo ) ;