PROCEDURE
 Declara un nombre de procedimiento y sus parámetros formales
------------------------------------------------------------------------------
 Sintaxis

     [STATIC] PROCEDURE <idProcedimiento> [(<lista idParám>)]
        [FIELD <lista idCampos> [IN <idAlias>]
        [LOCAL <identificador> [[:= <inicializador>], ... ]]
        [MEMVAR <lista identificadores>]
        [STATIC <identificador> [[:= <inicializador>], ... ]]
        .
        . <sentencias ejecutables>
        .
        [RETURN]

 Argumentos

     <idProcedimiento> es el nombre del procedimiento que se declara.
     Los nombres de procedimiento pueden tener cualquier longitud, pero
     sólo son significativos los 10 primeros caracteres. Pueden contener
     cualquier combinación de letras, números o caracteres de subrayado,
     pero los subrayados iniciales están reservados.

     <lista idParám> es la declaración de una o más variables de
     parámetro. Las variables especificadas en esta lista se declaran como
     locales.

     STATIC PROCEDURE declara un procedimiento que sólo puede invocarse
     por otros procedimientos o funciones declarados en el mismo fichero de
     programa (.prg).

     FIELD declara una lista de identificadores, <lista idCampos>, que
     se van a utilizar como nombres de campo cuando se encuentren. Una
     cláusula IN que preceda al <idAlias> declarado, crea una referencia al
     área de trabajo correspondiente de la base de datos especificada.

     LOCAL declara y, opcionalmente, inicializa una lista de variables o
     matrices de visibilidad y duración limitadas al procedimiento actual.

     <identificador>, <lista identificadores> es una etiqueta o
     etiquetas utilizadas como nombres de variable o matriz. Si
     <identificador> va seguido de corchetes ([ ]), se crea una matriz y se
     asigna a <identificador>. Si <identificador> se especifica como una
     matriz, la sintaxis para indicar el número de elementos de cada
     dimensión puede ser matriz[<nElementos>, <nElementos2>,...] o
     matriz[<nElementos>][<nElementos2>]... El número máximo de elementos
     por dimensión es 4096. El número máximo de dimensiones sólo depende de
     la cantidad de memoria disponible.

     <inicializador> es el valor que se asigna opcionalmente a la nueva
     variable privada. No es posible asignar valores a una matriz con
     <inicializador>. El <inicializador> para una variable privada está
     formado por el operador de asignación en línea (:=) seguido de
     cualquier expresión válida de CA-Clipper, incluyendo matrices
     literales. Si no se especifica un <inicializador>, la variable se
     inicializa con el valor NIL. Con una matriz, todos sus elementos se
     inicializan con el valor NIL.

     MEMVAR declara una lista de identificadores, <lista
     identificadores>, que se utilizan como matrices o variables de memoria
     privadas o públicas cuando se encuentran.

     STATIC declara y, opcionalmente, inicializa una lista de variables
     o matrices cuyo ámbito de visibilidad es el procedimiento actual y cuyo
     tiempo de vida es toda la aplicación.

     RETURN devuelve el control al procedimiento o función invocante
     definida por el usuario. Si no se especifica RETURN, el control se
     devuelve a la rutina invocante al terminar la definición del
     procedimiento. En cualquier caso, el compilador finaliza la definición
     del procedimiento si encuentra otra sentencia PROCEDURE, FUNCTION o un
     carácter de fin de fichero.

 Descripción

     La sentencia PROCEDURE declara un procedimiento y una lista opcional de
     variables locales para recibir los parámetros pasados por la rutina
     invocante. Un procedimiento es un subprograma compuesto por un grupo de
     declaraciones y sentencias que se ejecutan cuando se escribe
     <idProcedimiento> seguido de un paréntesis inicial y final o mediante
     una sentencia DO. Una definición de procedimiento comienza con la
     sentencia PROCEDURE y finaliza en la siguiente sentencia PROCEDURE,
     sentencia FUNCTION o carácter de fin de fichero.

     Los procedimientos permiten encapsular bloques de código de cálculo
     para mejorar la legibilidad y modularidad, aislar los cambios y ayudar
     a manejar programas complejos.

     En CA-Clipper, un procedimiento es idéntico a una función definida por
     el usuario, excepto en que siempre devuelve NIL. Cada procedimiento
     debe comenzar con una sentencia PROCEDURE y puede contener una
     sentencia RETURN para devolver el control al procedimiento o función
     invocante. Sin embargo, la sentencia RETURN no es imprescindible. Las
     declaraciones de procedimiento no pueden anidarse dentro de otras
     definiciones de procedimiento.

     Hay dos clases de visibilidad de nombres de procedimiento. Los
     procedimientos visibles desde cualquier parte de un programa se
     denominan procedimientos públicos y se declaran mediante una sentencia
     PROCEDURE. Los procedimientos sólo visibles en el fichero de programa
     (.prg) actual se denominan procedimientos estáticos y se declaran con
     una sentencia STATIC PROCEDURE. El ámbito de los procedimientos
     estáticos es todo el fichero.

     Los procedimientos estáticos son bastante útiles por varias razones. En
     primer lugar, limitan la visibilidad de un procedimiento, restringiendo
     así el acceso a ese procedimiento. Debido a esto, los subsistemas
     definidos en un mismo fichero de programa (.prg) pueden ofrecer un
     protocolo de acceso mediante una serie de procedimientos públicos y
     ocultar los detalles internos del subsistema mediante funciones y
     procedimientos estáticos. En segundo lugar, como las referencias a los
     procedimientos estáticos se resuelven durante la compilación, tienen
     preferencia sobre las referencias a funciones y procedimientos públicos
     que se resuelven en tiempo de enlace. Esto garantiza que, si existe en
     un fichero de programa un conflicto de nombres entre un procedimiento
     estático y un procedimiento o función público, se ejecute la referencia
     al procedimiento estático.

     Si desea más información sobre los procedimientos, declaraciones de
     variables y paso de parámetros, consulte el capítulo "Conceptos
     Básicos" de la Guía de Programación y Utilidades.

 Notas

     ■ Llamada a un procedimiento: En CA-Clipper, un procedimiento
        puede llamarse de dos formas. La primera, y preferible, es la
        convención de llamada de funciones. Este método para invocar un
        procedimiento es idéntico al que se utiliza para invocar una
        función, en una línea individual:

        <idProcedimiento>([<lista argumentos>])

        El segundo método, que es obsoleto, es la convención de llamada
        mediante el mandato DO...WITH. Los dos métodos difieren sólo en la
        forma de paso de parámetros por defecto. Por defecto, la convención
        de llamada de funciones pasa las variables por valor, mientras que
        la convención de llamada por mandato los pasa por referencia.

        Un procedimiento también puede invocarse con una expresión de alias,
        si va precedido de un alias y se invoca mediante la convención de
        llamada de funciones, tal como se indica a continuación:

        <idAlias> ->(<idProcedimiento>(<lista argumentos>))

        Al invocarse con una expresión de alias, se selecciona el área de
        trabajo correspondiente a <idAlias>, se ejecuta el procedimiento y
        se vuelve a seleccionar el área de trabajo original. Al igual que
        una expresión o función, un procedimiento de alias puede indicarse
        en una línea individual.

        En CA-Clipper, un procedimiento puede invocarse recursivamente. Esto
        significa que se puede llamar al procedimiento dentro de la misma
        definición de procedimiento.

     ■ Parámetros: Los procedimientos, al igual que las funciones
        definidas por el usuario, pueden recibir parámetros pasados por el
        procedimiento que los llamó, por una función definida por el usuario
        o por la línea de mandato del DOS. Un parámetro es un lugar para un
        valor o una referencia. En CA-Clipper, existen dos formas de recibir
        parámetros: puede declararse una lista de nombres de variables
        locales como parte de la declaración PROCEDURE (parámetros formales)
        o puede especificarse una lista de variables privadas en una
        sentencia PARAMETERS independiente. Recuerde que no puede mezclarse
        una declaración de parámetros formales con una sentencia PARAMETERS.
        Si se intenta hacerlo, se produce un error de compilación grave.

        Los procedimientos reciben los parámetros en el mismo orden en el
        que se pasan. En CA-Clipper, el número de parámetros no tiene que
        ser igual al número de argumentos pasados. Los argumentos pueden
        omitirse o dejarse sin especificar al final de la lista de
        argumentos. Un parámetro que no reciba un valor o referencia se
        inicializa con el valor NIL. Si se especifican argumentos, PCOUNT()
        devuelve la posición del último argumento pasado.

        Los parámetros especificados en un procedimiento pueden recibir
        argumentos pasados por valor o por referencia. El método por defecto
        para las expresiones y variables depende de la convención de
        llamada. En la convención de llamada de funciones, el método por
        defecto para pasar expresiones y variables es por valor, incluyendo
        variables que contienen referencias a matrices y objetos. En la
        convención de llamada de mandatos, el método por defecto para pasar
        variables es por referencia, excepto para las variables de campo,
        que siempre se pasan por valor. Cuando se pasa una variable de
        campo, debe encerrarse entre paréntesis, a menos que se declare con
        la sentencia FIELD. En caso contrario, se produce un error de
        ejecución.

 Ejemplos

      Este ejemplo muestra el esquema de un procedimiento de
        CA-Clipper que utiliza variables de ámbito resoluble en
        compilación:

        PROCEDURE Esqueleto( cNombre, cClase, nHuesos, ;
                             nArticulaciones )
           LOCAL nHuesosTrans, aEnMano := {"cráneo", ;
                                           "metacarpianos"}
           STATIC nContador := 0
           .
           . <sentencias ejecutables>
           .
           RETURN

      Este ejemplo determina si se ha omitido algún argumento
        comparándolo con NIL:

        PROCEDURE MiProc( param1, param2, param3 )
           IF param2 != NIL
              param2 := "valor por defecto"
           ENDIF
           .
           . <sentencias>
           .
           RETURN

      Este ejemplo invoca al procedimiento, ActualizarCantidad(),
        con una expresión de alias:

        USE Facturas NEW
        USE Cliente NEW
        Facturas->(ActualizarCantidad(Importe + Importe * nInteres))

 To download this example - click here.

See Also: FUNCTION LOCAL PARAMETERS PCOUNT() RETURN STATIC