*** empty log message ***
This commit is contained in:
Alejandro de Garate
@@ -6,12 +6,13 @@
|
||||
* Las siguientes partes son derechos adquiridos de sus autores individuales.
|
||||
* www - http://www.harbour-project.org
|
||||
*
|
||||
* Copyright 2000 Alejandro de Gárate <alex_degarate@hotmail.com>
|
||||
* Documentación en Español de: ARRAY(), AADD(), ASIZE(), ATAIL(), ASIZE(),
|
||||
* AINS(), ADEL(), ADEL(), AFILL(), ASCAN()
|
||||
* AEVAL(), ACOPY(), ACLONE(), ASORT()
|
||||
* Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
|
||||
* Documentaci¢n en Espa¤ol de:
|
||||
* ARRAY(), AADD(), ASIZE(), ATAIL(), ASIZE(),
|
||||
* AINS(), ADEL(), ADEL(), AFILL(), ASCAN()
|
||||
* AEVAL(), ACOPY(), ACLONE(), ASORT()
|
||||
*
|
||||
* Vea doc/license.txt por los términos de la licencia.
|
||||
* Vea doc/license.txt por los t‚rminos de la licencia.
|
||||
*
|
||||
*/
|
||||
|
||||
@@ -25,12 +26,12 @@
|
||||
* $SYNTAX$
|
||||
* ARRAY( <nElementos> [, <nElementos>...] ) --> aArray
|
||||
* $ARGUMENTS$
|
||||
* <nElementos> es el número de elementos de la dimensión especificada.
|
||||
* <nElementos> es el n£mero de elementos de la dimensi¢n especificada.
|
||||
* $RETURNS$
|
||||
* Un array con las dimensiones especificadas.
|
||||
* $DESCRIPTION$
|
||||
* Esta función retorna un array sin inicializar de longitud <nElementos>.
|
||||
* Si parámetros <nElementos> adicionales son especificados se crea
|
||||
* Esta funci¢n retorna un array sin inicializar de tama¤o <nElementos>
|
||||
* Si par metros <nElementos> adicionales son especificados se crea
|
||||
* un array anidado multidimensional sin inicializar dentro de la misma
|
||||
* referencia del array.
|
||||
* Crear una variable de memoria con el mismo nombre que el array puede
|
||||
@@ -40,8 +41,9 @@
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array de diez elementos iniciales,
|
||||
* luego en cada elemento de ese array, va creando submatrices
|
||||
* lineales con la función ARRAY(). Cada una con la misma cantidad
|
||||
* de items que la posición que ocupa en aArray. Finalmente lo muestra.
|
||||
* lineales con la funci¢n ARRAY(). Cada una con la misma cantidad
|
||||
* de items que la posici¢n que ocupa en aArray. Finalmente lo
|
||||
* muestra.
|
||||
*
|
||||
* LOCAL aArray := Array(10)
|
||||
* LOCAL i := 1, j
|
||||
@@ -60,13 +62,13 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es CA-CLIPPER Compatible en todos los casos, excepto que
|
||||
* los arrays en Harbour pueden tener un número ilimitado de elementos
|
||||
* mientras que Clipper tiene un límite de 4096 elementos por dimensión.
|
||||
* Los arrays en Harbour pueden tener un número ilimitado de dimensiones.
|
||||
* Esta funci¢n es CA-CLIPPER Compatible en todos los casos, excepto que
|
||||
* los arrays en Harbour pueden tener un n£mero ilimitado de elementos
|
||||
* mientras que Clipper tiene un l¡mite de 4096 elementos por dimensi¢n.
|
||||
* Los arrays en Harbour pueden tener un n£mero ilimitado de dimensiones
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AADD(),ADEL(),AFILL(),AINS()
|
||||
* $END$
|
||||
@@ -75,56 +77,56 @@
|
||||
|
||||
* $DOC$
|
||||
* $FUNCNAME$
|
||||
* AADD()
|
||||
* AADD()
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Agrega dinámicamente un nuevo elemento al final de un array
|
||||
* Agrega din micamente un nuevo elemento al final de un array
|
||||
* $SYNTAX$
|
||||
* AADD(<aDestino>, <xValor>) --> Valor
|
||||
* AADD(<aDestino>, <xValor>) --> Valor
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el array al cual se agrega un nuevo elemento.
|
||||
* <aDestino> es el array al cual se agrega un nuevo elemento.
|
||||
*
|
||||
* <xValor> es el valor asignado al nuevo elemento.
|
||||
* <xValor> es el valor asignado al nuevo elemento.
|
||||
* $RETURNS$
|
||||
* AADD() evalúa <xValor> y retorna su valor. Si <xValor> no esta
|
||||
* especificado, AADD() retorna NIL.
|
||||
* AADD() eval£a <xValor> y retorna su valor. Si <xValor> no esta
|
||||
* especificado, AADD() retorna NIL.
|
||||
* $DESCRIPTION$
|
||||
* AADD() es una función que dinámicamente incrementa la longitud actual del
|
||||
* array destino en un elemento y asigna el valor <xValor> al recién creado
|
||||
* elemento del array.
|
||||
* <xValor> puede ser un puntero de referencia a otro array, el cual puede
|
||||
* ser asignado a la posicion subindice.
|
||||
* AADD() es una funci¢n que din micamente incrementa la longitud actual
|
||||
* del array destino en un elemento y asigna el valor <xValor> al reci‚n
|
||||
* creado elemento del array.
|
||||
* <xValor> puede ser un puntero de referencia a otro array, el cual
|
||||
* puede ser asignado a la posici¢n sub¡ndice.
|
||||
*
|
||||
* Es útil para construir listas dinámicas o colas (queues).
|
||||
* Cada vez que se ejecuta un comando @...GET, el sistema usa AADD() para
|
||||
* agregar un nuevo elemento al final del array GetList, y entonces asignar
|
||||
* un nuevo objeto Get al nuevo elemento.
|
||||
* Es £til para construir listas din micas o colas (queues).
|
||||
* Cada vez que se ejecuta un comando @...GET, el sistema usa AADD()
|
||||
* para agregar un nuevo elemento al final del array GetList, y entonces
|
||||
* asignar un nuevo objeto Get al nuevo elemento.
|
||||
* $EXAMPLES$
|
||||
* * Este ejemplo muestra el efecto de múltiples llamadas de la función
|
||||
* AADD() a un array, donde va agrgando un nuevo elemento cada vez.
|
||||
* * Este ejemplo muestra el efecto de m£ltiples llamadas de la funci¢n
|
||||
* AADD() a un array, donde va agrgando un nuevo elemento cada vez.
|
||||
*
|
||||
* LOCAL aArray := {}
|
||||
* FOR x:= 1 to 10
|
||||
* AADD( aArray, x)
|
||||
* NEXT
|
||||
*
|
||||
* * Este ejemplo crea un array multidemensional
|
||||
* LOCAL aArray := {} // Resultado: aArray es un array vacío
|
||||
* AADD( aArray, {10, 10122734 }) // Resultado: aArray es {10, 10122734}
|
||||
* AADD( aArray, {11, 13173645 }) // Resultado: aArray es
|
||||
* * Este ejemplo crea un array multidemensional
|
||||
* LOCAL aArray := {} // Resultado: aArray es un array vac¡o
|
||||
* AADD( aArray, {10, 10122734 }) // Resultado: aArray es {10, 10122734}
|
||||
* AADD( aArray, {11, 13173645 }) // Resultado: aArray es
|
||||
* { { 10, 10122734 }, { 11, 13173645 } }
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $PLATFORMS$
|
||||
* Todas las plataformas
|
||||
* Todas las plataformas
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AINS(), ASIZE()
|
||||
* AINS(), ASIZE()
|
||||
* $END$
|
||||
|
||||
|
||||
@@ -134,25 +136,26 @@
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Ajusta (aumenta ó decrementa) el tamaño de un array
|
||||
* Ajusta (aumenta ¢ decrementa) el tama¤o de un array
|
||||
* $SYNTAX$
|
||||
* ASIZE(<aDestino>, <nLongitud>) --> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el nombre del array a ser dinámicamente alterado
|
||||
* <aDestino> es el nombre del array a ser din micamente alterado
|
||||
*
|
||||
* <nLongitud> es el valor Numérico del nuevo tamaño de <aDestino>
|
||||
* <nLongitud> es el valor Num‚rico del nuevo tama¤o de <aDestino>
|
||||
* $RETURNS$
|
||||
* ASIZE() retorna una referencia al array <aDestino>.
|
||||
* $DESCRIPTION$
|
||||
* Esta función dinámicamente incrementa ó decrementa el tamaño del array
|
||||
* <aDestino> ajustando la longitud del array a <nLongitud> posiciones.
|
||||
* Esta funci¢n din micamente incrementa ¢ decrementa el tama¤o del
|
||||
* array <aDestino> ajustando la longitud del array a <nLongitud>
|
||||
* posiciones.
|
||||
*
|
||||
* Si la longitud del array <aDestino> is acortada, aquellos elementos
|
||||
* al final se pierden. Si la longitud del array es alargada un valor NIL
|
||||
* es asignado a los elementos en las nuevas posiciones.
|
||||
* al final se pierden. Si la longitud del array es alargada un valor
|
||||
* NIL es asignado a los elementos en las nuevas posiciones.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array con un sólo elemento, luego lo
|
||||
* agranda y luego lo vuelve al tamaño original.
|
||||
* * El siguiente ejemplo crea un array con un s¢lo elemento, luego lo
|
||||
* agranda y luego lo vuelve al tama¤o original.
|
||||
*
|
||||
* aArray := { 1 } // Resultado: aArray es { 1 }
|
||||
* ASIZE( aArray, 3) // Resultado: aArray es { 1, NIL, NIL }
|
||||
@@ -160,11 +163,11 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Si HB_COMPAT_C53 es definido, la función genera un Error, de otro
|
||||
* modo retornará el mismo array.
|
||||
* Si HB_COMPAT_C53 es definido, la funci¢n genera un Error, de otro
|
||||
* modo retornar el mismo array.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AADD(), ADEL(), AFILL(), AINS()
|
||||
* $END$
|
||||
@@ -177,30 +180,30 @@
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Retorna el último elemento de un array
|
||||
* Retorna el £ltimo elemento de un array
|
||||
* $SYNTAX$
|
||||
* ATAIL( <aArray> ) --> Elemento
|
||||
* $ARGUMENTS$
|
||||
* <aArray> es el nombre del array a usar
|
||||
* $RETURNS$
|
||||
* ATAIL() retorna <Elemento> que puede ser un valor ó una referencia
|
||||
* contenida en el último elemento en el array.
|
||||
* ATAIL() retorna <Elemento> que puede ser un valor ¢ una referencia
|
||||
* contenida en el £ltimo elemento en el array.
|
||||
* $DESCRIPTION$
|
||||
* Esta función devuelve el último elemento en el array llamado <aArray>.
|
||||
* No modifica el tamaño del array ni el valor de ningún subíndice.
|
||||
* Esta funci¢n devuelve el £ltimo elemento en el array llamado <aArray>
|
||||
* No modifica el tama¤o del array ni el valor de ning£n sub¡ndice.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array unidimensional y devuelve el
|
||||
* último elemento.
|
||||
* £ltimo elemento.
|
||||
*
|
||||
* aArray := { "Cuál", "es el", "futuro", "de xBase ?", "Harbour!" }
|
||||
* aArray := { "Cu l", "es el", "futuro", "de xBase ?", "Harbour!" }
|
||||
* ? ATAIL( aArray )
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* LEN(),ARRAY(),ASIZE(),AADD()
|
||||
* $END$
|
||||
@@ -213,30 +216,30 @@
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Inserta un elemento NIL en una posición del array
|
||||
* Inserta un elemento NIL en una posici¢n del array
|
||||
* $SYNTAX$
|
||||
* AINS( <aArray>, <nPos> ) --> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aArray> es el nombre del array al que se va a insertar un item
|
||||
*
|
||||
* <nPos> es la posición en el <aArray>
|
||||
* <nPos> es la posici¢n en el <aArray>
|
||||
* $RETURNS$
|
||||
* AINS() retorna una referencia al array destino, <aDestino>
|
||||
* $DESCRIPTION$
|
||||
* Esta función inserta un valor NIL en el array llamado <aArray>
|
||||
* Esta funci¢n inserta un valor NIL en el array llamado <aArray>
|
||||
* en la posicion <nPos>.
|
||||
*
|
||||
* Todos los elementos del array comenzando con la <nPos> serán
|
||||
* desplazados hacia arriba una posición y el último item en el array
|
||||
* será removido completamente. En otras palabras, si se va a insertar un
|
||||
* item en la quinta posición de un array de diez elementos, el elemento
|
||||
* que previamente estaba en la quinta posición ahora será reubicado a
|
||||
* la sexta posición. El elemento recién agregado será de tipo NIL y el
|
||||
* último elemento es descartado. La longitud del array <aArray>
|
||||
* permanece sin cambios.
|
||||
* Todos los elementos del array comenzando con la <nPos> ser n
|
||||
* desplazados hacia arriba una posici¢n y el £ltimo item en el array
|
||||
* ser removido completamente. En otras palabras, si se va a insertar
|
||||
* un item en la quinta posici¢n de un array de diez elementos, el
|
||||
* elemento que previamente estaba en la quinta posici¢n ahora ser
|
||||
* reubicado a la sexta posici¢n. El elemento reci‚n agregado ser de
|
||||
* tipo NIL y el £ltimo elemento es descartado. La longitud del array
|
||||
* <aArray> permanece sin cambios.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array lineal, al cual se inserta un
|
||||
* elemento en la quinta posición, perdiéndose el último.
|
||||
* elemento en la quinta posici¢n, perdi‚ndose el £ltimo.
|
||||
*
|
||||
* LOCAL aArray:= { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
|
||||
* AINS( aArray, 5)
|
||||
@@ -245,10 +248,10 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AADD(), ACOPY(), ADEL(), AEVAL(), AFILL(), ASIZE()
|
||||
* $END$
|
||||
@@ -265,24 +268,24 @@
|
||||
* $SYNTAX$
|
||||
* ADEL(<aDestino>, <nPos>) --> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el nombre del array cuyo elemento será removido.
|
||||
* <aDestino> es el nombre del array cuyo elemento ser removido.
|
||||
*
|
||||
* <nPos> es la posición del elemento a borrar
|
||||
* <nPos> es la posici¢n del elemento a borrar
|
||||
* $RETURNS$
|
||||
* ADEL() retorna una referencia al array destino, <aDestino>
|
||||
* $DESCRIPTION$
|
||||
* Esta función borra el elemento que se encuentra en la posición <nPos>
|
||||
* Esta funci¢n borra el elemento que se encuentra en la posici¢n <nPos>
|
||||
* en el array <aDestino>. Todos los elementos en el array <aDestino>
|
||||
* más allá de la posición dada <nPos> serán movidos hacia abajo una
|
||||
* posición en el array.
|
||||
* En otras palabras, si se borra un item de la quinta posición de un
|
||||
* array de diez elementos, el elemento que estaba en la sexta posición
|
||||
* ahora será reubicado a la quinta posición.
|
||||
* La longitud del array <aDestino> permanece sin cambios y el último
|
||||
* m s all de la posici¢n dada <nPos> ser n movidos hacia abajo una
|
||||
* posici¢n en el array.
|
||||
* En otras palabras, si se borra un item de la quinta posici¢n de un
|
||||
* array de diez elementos, el elemento que estaba en la sexta posici¢n
|
||||
* ahora ser reubicado a la quinta posici¢n.
|
||||
* La longitud del array <aDestino> permanece sin cambios y el £ltimo
|
||||
* elemento en el array toma el valor NIL.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array lineal, del cual se borra el
|
||||
* elemento en la quinta posición.
|
||||
* elemento en la quinta posici¢n.
|
||||
*
|
||||
* LOCAL aArray:= { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
|
||||
* ADEL( aArray, 5)
|
||||
@@ -291,10 +294,10 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* ACOPY(), AINS(), AFILL()
|
||||
* $END$
|
||||
@@ -309,43 +312,43 @@
|
||||
* $ONELINER$
|
||||
* Rellena un array con un valor especificado
|
||||
* $SYNTAX$
|
||||
* AFILL( <aDestino>, <xValor>, [<nInicio>], [<nContador>] ) --> aDestino
|
||||
* AFILL( <aDestino>, <xValor>, [<nInicio>], [<nContador>]) --> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el nombre del array a rellenar
|
||||
* <aDestino> es el nombre del array a rellenar
|
||||
*
|
||||
* <xValor> es la expresión con la que será rellenado <aDestino>
|
||||
* <xValor> es la expresi¢n con la que ser rellenado <aDestino>
|
||||
*
|
||||
* <nInicio> es la posición de comienzo, subíndice del array
|
||||
* <nInicio> es la posici¢n de comienzo, sub¡ndice del array
|
||||
*
|
||||
* <nContador> es el número de elementos que se van a rellenar
|
||||
* <nContador> es el n£mero de elementos que se van a rellenar
|
||||
* $RETURNS$
|
||||
* AFILL() retorna una referencia al array destino, <aDestino>
|
||||
* $DESCRIPTION$
|
||||
* Esta función rellena cada elemento del array llamado <aDestino> con
|
||||
* Esta funci¢n rellena cada elemento del array llamado <aDestino> con
|
||||
* el valor <xValor>. Si es especificado, <nInicio> marca el elemento
|
||||
* de inicio para continuar rellenando por <nContador> posiciones.
|
||||
* Si no es especificado, el valor de <nInicio> será 1, y el valor de
|
||||
* <nContador> será el valor de LEN(<aDestino>); y todos las posiciones
|
||||
* del array <aDestino> serán llenadas con la expresión de <xValor>.
|
||||
* Si no es especificado, el valor de <nInicio> ser 1, y el valor de
|
||||
* <nContador> ser el valor de LEN(<aDestino>); y todos las posiciones
|
||||
* del array <aDestino> ser n llenadas con la expresi¢n de <xValor>.
|
||||
*
|
||||
* Advertencia !:
|
||||
* Esta función sólo trabaja en una sola dimensión de <aDestino>.
|
||||
* Si hay punteros de referencia a otros arrays dentro de un subíndice
|
||||
* de <aDestino> estos valores se perderán, porque esta función los
|
||||
* Esta funci¢n s¢lo trabaja en una sola dimensi¢n de <aDestino>.
|
||||
* Si hay punteros de referencia a otros arrays dentro de un sub¡ndice
|
||||
* de <aDestino> estos valores se perder n, porque esta funci¢n los
|
||||
* sobreescribe con los nuevos valores.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo crea un array con valores asignados, luego
|
||||
* lo rellena con el valor cinco.
|
||||
*
|
||||
* LOCAL aTest := { NIL, 0, 1, 2 }
|
||||
* Afill( aTest, 5) // Resultado aTest es { 5, 5, 5, 5 }
|
||||
* Afill( aTest, 5) // Resultado aTest es { 5, 5, 5, 5 }
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AADD(), AEVAL(), DBSTRUCT(), DIRECTORY()
|
||||
* $END$
|
||||
@@ -363,51 +366,51 @@
|
||||
* ASCAN( <aDestino>, <xBuscar>,
|
||||
* [<nInicio>], [<nContador>] ) --> nParadoEn
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el nombre del array a examinar
|
||||
* <aDestino> es el nombre del array a examinar
|
||||
*
|
||||
* <xBuscar> es la expresión a encontrar en <aDestino>
|
||||
* <xBuscar > es la expresi¢n a encontrar en <aDestino>
|
||||
*
|
||||
* <nInicio> es la posición a la cual comenzar la búsqueda
|
||||
* <nInicio> es la posici¢n a la cual comenzar la b£squeda
|
||||
*
|
||||
* <nContador> es el número de elementos a examinar
|
||||
* <nContador> es el n£mero de elementos a examinar
|
||||
* $RETURNS$
|
||||
* ASCAN() retorna un valor numérico <nParadoEn>, de la posición donde
|
||||
* <xBuscar> fué encontrada.
|
||||
* ASCAN() retorna un valor num‚rico <nParadoEn>, de la posici¢n donde
|
||||
* <xBuscar> fu‚ encontrada.
|
||||
* $DESCRIPTION$
|
||||
* Esta función examina el contenido de un array llamado <aDestino> en
|
||||
* busca del valor de <xBuscar>. El valor devuelto es la posición en el
|
||||
* Esta funci¢n examina el contenido de un array llamado <aDestino> en
|
||||
* busca del valor de <xBuscar>. El valor devuelto es la posici¢n en el
|
||||
* array <aDestino> en el cual <xBuscar> fue encontrada.
|
||||
* Si esta expresión no es encontrada el valor retornado es cero.
|
||||
* Si esta expresi¢n no es encontrada el valor retornado es cero.
|
||||
*
|
||||
* Si es especificada, la posición de inicio al cual comenzar la búsqueda
|
||||
* puede ser establecida con el valor pasado en <nInicio>. Por defecto
|
||||
* es uno.
|
||||
* Si es especificada, la posici¢n de inicio al cual comenzar la
|
||||
* b£squeda puede ser establecida con el valor pasado en <nInicio>.
|
||||
* Por defecto es uno.
|
||||
*
|
||||
* Si es especificado, el número de elementos del array a examinar puede
|
||||
* ser establecido con el valor pasado en <nContador>. Por defecto es el
|
||||
* número total de elementos en el array <aDestino>.
|
||||
* Si es especificado, el n£mero de elementos del array a examinar puede
|
||||
* ser establecido con el valor pasado en <nContador>. Por defecto es
|
||||
* el n£mero total de elementos en el array <aDestino>.
|
||||
*
|
||||
* Si <xBuscar> es un bloque de código, la operación de la función es
|
||||
* Si <xBuscar> es un bloque de c¢digo, la operaci¢n de la funci¢n es
|
||||
* ligeramente diferente. Cada referencia del subindice del array es
|
||||
* pasada al bloque de código para ser evaluada. La rutina de búsqueda
|
||||
* continuará hasta que el valor obtenido del bloque de código sea
|
||||
* verdadero (.T.) ó hasta que el final del array haya sido alcanzado.
|
||||
* pasada al bloque de c¢digo para ser evaluada. La rutina de b£squeda
|
||||
* continuar hasta que el valor obtenido del bloque de c¢digo sea
|
||||
* verdadero (.T.) ¢ hasta que el final del array haya sido alcanzado.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo utiliza una función de biblioteca para llenar
|
||||
* * El siguiente ejemplo utiliza una funci¢n de biblioteca para llenar
|
||||
* el array aDir con los nombres de archivos en el directorio actual.
|
||||
* Posteriormente, busca si entre ellos esta presente el archivo
|
||||
* test.prg, devuelve cero si no esta, ó mayor de cero si está.
|
||||
* test.prg, devuelve cero si no esta, ¢ mayor de cero si est .
|
||||
*
|
||||
* LOCAL aDir := DIRECTORY( "*.*")
|
||||
* ? ASCAN( aDir,,,{|x,y| x[1] == "test.prg" } )
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función no es compatible con CA-Clipper . La función ASCAN() de
|
||||
* Clipper es afectada por la condición SET EXACT ON/OFF
|
||||
* Esta funci¢n no es compatible con CA-Clipper . La funci¢n ASCAN() de
|
||||
* Clipper es afectada por la condici¢n SET EXACT ON/OFF
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* AEVAL(), EVAL()
|
||||
* $END$
|
||||
@@ -419,45 +422,45 @@
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Ejecuta un bloque de código por cada elemento en el array
|
||||
* Ejecuta un bloque de c¢digo por cada elemento en el array
|
||||
* $SYNTAX$
|
||||
* AEVAL(<aArray>, <bBlock>, [<nInicio>], [<nContador>]) --> aArray
|
||||
* $ARGUMENTS$
|
||||
* <aArray> es el array a ser evaluado.
|
||||
* <aArray> es el array a ser evaluado.
|
||||
*
|
||||
* <bBloque> es el bloque de código a evaluar para cada elemento
|
||||
* procesado
|
||||
* <nInicio> es el elemento de inicio del array a evaluar.
|
||||
* <bBloque> es el bloque de c¢digo a evaluar para cada elemento
|
||||
* procesado
|
||||
* <nInicio> es el elemento de inicio del array a evaluar.
|
||||
*
|
||||
* <nContador> es el número de elementos a procesar desde <nInicio>
|
||||
* <nContador> es el n£mero de elementos a procesar desde <nInicio>
|
||||
* hasta el final del array <aArray>
|
||||
* $RETURNS$
|
||||
* AEVAL() retorna una referencia a <aArray>
|
||||
* $DESCRIPTION$
|
||||
* Esta función evalúa y procesa los elementos en <aArray>.
|
||||
* Un bloque de código pasado como <bBloque> define la operacion a ser
|
||||
* Esta funci¢n eval£a y procesa los elementos en <aArray>.
|
||||
* Un bloque de c¢digo pasado como <bBloque> define la operacion a ser
|
||||
* ejecutada sobre cada elemento del array. Todos los elementos en
|
||||
* <aArray> serán evaluados a menos que sea especificada la posición de
|
||||
* <aArray> ser n evaluados a menos que sea especificada la posici¢n de
|
||||
* comienzo en <nInicio> por <nContador> elementos.
|
||||
* Por defecto <nInicio> es uno.
|
||||
*
|
||||
* Dos parámetros son pasados al bloque de código <bBloque>. Los elementos
|
||||
* individuales en el array son el primer parámetro y su posición en el
|
||||
* array es el segundo.
|
||||
* Dos par metros son pasados al bloque de c¢digo <bBloque>. Los
|
||||
* elementos individuales en el array son el primer par metro y su
|
||||
* posici¢n en el array es el segundo.
|
||||
*
|
||||
* AEVAL() no reemplaza al bucle FOR...NEXT para procesar arrays.
|
||||
* Si un array es una unidad autónoma, AEVAL() es apropiado. Si el array
|
||||
* va a ser alterado ó si los elementos van a ser reevaluados, un
|
||||
* bucle FOR...NEXT es más apropiado.
|
||||
* Si un array es una unidad aut¢noma, AEVAL() es apropiado. Si el array
|
||||
* va a ser alterado ¢ si los elementos van a ser reevaluados, un
|
||||
* bucle FOR...NEXT es m s apropiado.
|
||||
* $EXAMPLES$
|
||||
*
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* EVAL(),DBEVAL()
|
||||
* $END$
|
||||
@@ -475,34 +478,34 @@
|
||||
* ACOPY( <aOrigen>, <aDestino>, [<nInicio>], [<nContador>],
|
||||
* [<nPosDestino>] )--> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aOrigen> es el array desde el que se copian los elementos.
|
||||
* <aOrigen> es el array desde el que se copian los elementos.
|
||||
*
|
||||
* <aDestino> es el array al que se copian los elementos.
|
||||
* <aDestino> es el array al que se copian los elementos.
|
||||
*
|
||||
* <nInicio> es la posición desde donde se inicia la copia en <aOrigen>.
|
||||
* Por defecto es uno.
|
||||
* <nContador> es el número de elementos a copiar comenzando en la
|
||||
* posición <nInicio>
|
||||
* <nInicio> es la posici¢n desde donde se inicia la copia en
|
||||
* <aOrigen>. Por defecto es uno.
|
||||
* <nContador> es el n£mero de elementos a copiar comenzando en la
|
||||
* posici¢n <nInicio>
|
||||
*
|
||||
* <nPosDestino> es la posición de inicio en el array <aDestino> hacia
|
||||
* donde se copian los elementos. Por defecto es uno.
|
||||
* <nPosDestino> es la posici¢n de inicio en el array <aDestino> hacia
|
||||
* donde se copian los elementos. Por defecto es uno.
|
||||
* $RETURNS$
|
||||
* ACOPY() retorna una referencia al array <aDestino>
|
||||
* $DESCRIPTION$
|
||||
* ACOPY() copia elementos desde el array <aOrigen> hacia el array
|
||||
* <aDestino>. Esta función copia todo tipo de datos.
|
||||
* <aDestino>. Esta funci¢n copia todo tipo de datos.
|
||||
*
|
||||
* Si un elemento en el array <aOrigen> es un puntero de referencia a
|
||||
* otro array (submatriz), esa referencia será copiada al array
|
||||
* <aDestino> pero no todas las dimensiones serán copiadas de un array
|
||||
* al otro. Esto debe ser realizado via función ACLONE().
|
||||
* otro array (submatriz), esa referencia ser copiada al array
|
||||
* <aDestino> pero no todas las dimensiones ser n copiadas de un array
|
||||
* al otro. Esto debe ser realizado via funci¢n ACLONE().
|
||||
*
|
||||
* Note
|
||||
* Si el array <aOrigen> es mayor que <aDestino>, los elementos en el
|
||||
* array comienzan a ser copiados en <nPosDestino> y continuan copiandose
|
||||
* hasta que el final del array <aDestino> es alcanzado, los elementos
|
||||
* que sobran en <aOrigen> se descartan.
|
||||
* La función ACOPY() no agrega posiciones al array destino, el tamaño
|
||||
* array comienzan a ser copiados en <nPosDestino> y continuan
|
||||
* copiandose hasta que el final del array <aDestino> es alcanzado, los
|
||||
* elementos que sobran en <aOrigen> se descartan.
|
||||
* La funci¢n ACOPY() no agrega posiciones al array destino, el tama¤o
|
||||
* del array <aDestino> permanece constante.
|
||||
* $EXAMPLES$
|
||||
* * El ejemplo siguiente copia un array sobre otro.
|
||||
@@ -514,10 +517,10 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Esta función es totalmente compatible con CA-Clipper.
|
||||
* Esta funci¢n es totalmente compatible con CA-Clipper.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* ACLONE(),ADEL(),AEVAL(),AFILL(),AINS(),ASORT()
|
||||
* $END$
|
||||
@@ -530,7 +533,7 @@
|
||||
* $CATEGORY$
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Duplica un array anidado ó multidimensional
|
||||
* Duplica un array anidado ¢ multidimensional
|
||||
* $SYNTAX$
|
||||
* ACLONE( <aOrigen> ) --> aDuplicado
|
||||
* $ARGUMENTS$
|
||||
@@ -539,9 +542,9 @@
|
||||
* ACLONE() retorna <aDuplicate> un nueva referencia a otro array
|
||||
* exactamente igual al original.
|
||||
* $DESCRIPTION$
|
||||
* Esta función realiza una copia completa del array llamado <aOrigen>.
|
||||
* Esta funci¢n realiza una copia completa del array llamado <aOrigen>.
|
||||
* Crea todas las dimensiones en el array <aDestino> que existen en el
|
||||
* array original y luego llena cada dimensión con los mismos valores
|
||||
* array original y luego llena cada dimensi¢n con los mismos valores
|
||||
* de los elementos en el original.
|
||||
* Ambos arrays coexisten como entidades distintas.
|
||||
* $EXAMPLES$
|
||||
@@ -552,13 +555,13 @@
|
||||
* aOrigen := { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} }
|
||||
* aDestino := ACLONE( aOrigen )
|
||||
*
|
||||
* * primera dimensión
|
||||
* * primera dimensi¢n
|
||||
* ? "Impares son: " // Resultado: es {1, 3, 5, 7, 9}
|
||||
* FOR n := 1 TO LEN( aDestino)
|
||||
* ?? aDestino [n][1]
|
||||
* NEXT
|
||||
*
|
||||
* * segunda dimensión
|
||||
* * segunda dimensi¢n
|
||||
* ? "Pares son: " // Resultado: es {2, 4, 6, 8, 10}
|
||||
* FOR n := 1 TO LEN( aDestino)
|
||||
* ?? aDestino [n][2]
|
||||
@@ -567,10 +570,10 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* Clipper retorna NIL si el parámetro no es un array.
|
||||
* Clipper retorna NIL si el par metro no es un array.
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* ACOPY(),ADEL(),AINS(),ASIZE()
|
||||
* $END$
|
||||
@@ -581,49 +584,49 @@
|
||||
* $FUNCNAME$
|
||||
* ASORT()
|
||||
* $CATEGORY$
|
||||
* Array
|
||||
* ARRAY
|
||||
* $ONELINER$
|
||||
* Ordena un array
|
||||
* $SYNTAX$
|
||||
* ASORT( <aDestino>, [<nInicio>], [<nContador>],
|
||||
* [<bOrden>] ) --> aDestino
|
||||
* $ARGUMENTS$
|
||||
* <aDestino> es el nombre del array a ser ordenado.
|
||||
* <aDestino> es el nombre del array a ser ordenado.
|
||||
*
|
||||
* <nInicio> es el primer elemento para comenzar el ordenamiento.
|
||||
* Por defecto es uno.
|
||||
* <nInicio> es el primer elemento para comenzar el ordenamiento.
|
||||
* Por defecto es uno.
|
||||
*
|
||||
* <nContador> es el número de elementos a ordenar comenzando en la
|
||||
* posición <nInicio>. Por defecto son todos los elementos.
|
||||
* <nContador> es el n£mero de elementos a ordenar comenzando en la
|
||||
* posici¢n <nInicio>. Por defecto son todos los elementos
|
||||
*
|
||||
* <bOrden> es el bloque de código para el orden de ordenamiento, por
|
||||
* defecto es en orden ascendente {| x, y | x < y }.
|
||||
* El bloque de código debe recibir dos elementos del array como
|
||||
* parametros y debe retornar .T. si el orden es el correcto,
|
||||
* .F. en caso contrario.
|
||||
* <bOrden> es el bloque de c¢digo para el orden de ordenamiento,
|
||||
* por defecto es en orden ascendente {| x, y | x < y }.
|
||||
* El bloque de c¢digo debe recibir dos elementos del array
|
||||
* como parametros y debe retornar .T. si el orden es el
|
||||
* correcto, .F. en caso contrario.
|
||||
* $RETURNS$
|
||||
* ASORT() retorna una referencia al reciente array ordenado <aDestino>
|
||||
* ó NIL si el parámetro <aDestino> no es un array.
|
||||
* ¢ NIL si el par metro <aDestino> no es un array.
|
||||
* $DESCRIPTION$
|
||||
* Esta funcion ordena todo ó parte de un array dado. Si <bOrden> es
|
||||
* omitido, la función espera que <aDestino> sea un array unidimensional
|
||||
* conteniendo un solo tipo de datos (uno de: Character, Date, Logical,
|
||||
* Numeric) y ordena este array en orden ascendente: los caracteres son
|
||||
* ordenados por su valor ASCII, las fechas son ordenadas cronologicamente
|
||||
* el valor lógico .F. va antes de .T. y los valores numéricos son
|
||||
* ordenados por su valor.
|
||||
* Esta funcion ordena todo ¢ parte de un array dado. Si <bOrden> es
|
||||
* omitido, la funci¢n espera que <aDestino> sea un array unidimensional
|
||||
* conteniendo un solo tipo de datos (uno de: CHARACTER, DATE, LOGICAL,
|
||||
* NUMERIC) y ordena este array en orden ascendente: los caracteres son
|
||||
* ordenados por su valor ASCII, las fechas son ordenadas
|
||||
* cronologicamente el valor l¢gico .F. va antes de .T. y los valores
|
||||
* num‚ricos son ordenados por su valor.
|
||||
*
|
||||
* Si <bOrden> es especificado este es usado para manejar la forma de
|
||||
* ordenamiento. Cada vez que el bloque es evaluado, dos elementos del
|
||||
* array son pasados al bloque de código, y el bloque debe retornar un
|
||||
* valor lógico que define si esos elementos estan en orden (.T.) ó no
|
||||
* array son pasados al bloque de c¢digo, y el bloque debe retornar un
|
||||
* valor l¢gico que define si esos elementos estan en orden (.T.) ¢ no
|
||||
* (.F.). Usando este bloque se puede ordenar arrays multidimensionales
|
||||
* hacer un ordenamiento descendente ó aún (pero para que querria Ud.
|
||||
* hacer un ordenamiento descendente ¢ a£n (pero para que querria Ud.
|
||||
* hacerlo) ordenar un array que contenga diferentes tipo de datos.
|
||||
* $EXAMPLES$
|
||||
* * El siguiente ejemplo ordena valores numericos en orden ascendente
|
||||
*
|
||||
* ASORT( { 3, 1, 4, 42, 5, 9 } ) // Resultado: { 1, 3, 4, 5, 9, 42 }
|
||||
* ASORT( { 3, 1, 4, 42, 5, 9 }) // Resultado: { 1, 3, 4, 5, 9, 42}
|
||||
*
|
||||
* * El siguiente ejemplo ordena cadenas en orden descendente
|
||||
* LOCAL aKeys := { "Ctrl", "Alt", "Delete" }, n
|
||||
@@ -646,13 +649,15 @@
|
||||
* $STATUS$
|
||||
* R
|
||||
* $COMPLIANCE$
|
||||
* La frecuencia de llamada al bloque de código y el orden difiere de
|
||||
* Clipper debido a que Harbour usa un algoritmo distinto (más rápido)
|
||||
* La frecuencia de llamada al bloque de c¢digo y el orden difiere de
|
||||
* Clipper debido a que Harbour usa un algoritmo distinto (m s r pido)
|
||||
* de ordenamiento (quicksort).
|
||||
* $FILES$
|
||||
* El código fuente está en arrays.c
|
||||
* La librería asociada es vm
|
||||
* El c¢digo fuente est en source\vm\arrays.c
|
||||
* La librer¡a asociada es vm
|
||||
* $SEEALSO$
|
||||
* ASCAN(),EVAL(),SORT
|
||||
* $END$
|
||||
*/
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user