1

Programación Estructurada

Patricia Garzón Fajardo

Hugo Ortiz Barrero

Fecha de actualización: 23 de junio de 2020 (actualización Docente unidad de software y TIC)

 1

Contenido
Introducción ............................................................................................... 3
Ideograma .................................................................................................. 4
1. Programación Estructurada ................................................................. 5
1.1 Definición ...................................................................................... 5
1.2 Características de la Programación Estructurada ......................... 5
Diseño Top Down ............................................................................... 5
Programación Modular ....................................................................... 6
Codificación estructurada ................................................................... 8
1.3 Mapa conceptual de la programación estructurada ...................... 9
2. Que es una función ............................................................................. 9
3. Java .................................................................................................. 10
3.1 Que son Métodos ....................................................................... 10
3.2 Métodos predefinidos ................................................................. 10
Métodos definidos por el usuario ...................................................... 14
Métodos que no retornan valores ..................................................... 16
Métodos que retornan valores .......................................................... 16
3.3 Variables de entorno................................................................... 24
Visualizando las variables de entorno usando Java ......................... 25
Usando variables de entorno en Java............................................... 26
4. JavaScript ............................................................................................ 30
4.1 Funciones....................................................................................... 30
Declaración y llamado de funciones ................................................. 31
Funciones anónima como variables.................................................. 34
Recursividad ..................................................................................... 36
4.2 Objetos en JavaScript ................................................................. 37
Representación jerárquica de un objeto ........................................... 38
Creando objetos con el constructor .................................................. 38
Propiedades de los Objetos .............................................................. 38
Creando funciones como métodos ................................................... 39
Clases 40
Algunos objetos predefinidos en JavaScript ..................................... 41
5 Comparación entre Java y JavaScript............................................... 43
 2

Glosario ................................................................................................... 46
Bibliografía ............................................................................................... 47
 3

Introducción

De la presente asignatura se han presentado dos Módulos, el primero Lenguajes de

programación donde se dio una introducción a lo que son los lenguajes de
programación y se introdujo particularmente a dos lenguajes de programación como
son Java y JavaScript. En el Módulo 1, Algoritmia y Programación, se introdujeron las
estructuras de control en los lenguajes antes mencionados con el fin de poder hacer
programas de mediana complejidad. Para el módulo 2 continuaremos con Java y
JavaScript pero enfocados a la generación y utilización de funciones de acuerdo a la
programación estructurada.

Por todo lo anterior en el presente documento será presentado primero que todo el
concepto sobre programación estructurada y entraremos a profundizar la noción de
funciones. De igual manera será mostrado el tema de entorno de variables. En este
tema estaremos más enfocados sobre los ejemplos con el fin de dejar claro los
conocimientos aquí mostrados.

Es importante resaltar que el uso de funciones es muy utilizado en el ámbito de

programación, por esta razón, enfocaremos el tema desde el punto de vista práctico, o
sea mediante ejemplos.
 4

Ideograma

Diseño Top
Down

Programación
Modular

Definición y Codificación
características de la Estructurada
PE

Qué son Métodos

Mapa
conceptual
Métodos
Que son las predefinidos
funciones
Métodos en
Java Métodos definidos
por el usuario
Programación
Estructurada (PE)

Variables de
entorno

Declaración y
llamado de
funciones
Funciones
anónimas como
Funciones en variables
JavaScript
Recursividad
Comparando
Java y Objetos en
JavaScript JavaScript

Conclusión
 5

1. Programación Estructurada

1.1 Definición

La programación estructurada nace como una respuesta a resolver problemas de

mediana o alta complejidad, ya que en programas muy grandes se cometían muchos
errores lógicos debido a la dificultad de escribir programas que involucraban muchas
líneas de instrucciones.

Fundamentalmente, la programación estructurada es una técnica que permite resolver

problemas de forma modular, convirtiendo un problema complicado, en varios de
simple complejidad, donde cada uno de ellos tiene una función específica, pero que
todos ellos contribuyen a la solución del problema general.

Algunas de las ventajas de utilizar la técnica de programación estructurada, es,

primero, que al dividir el problema original en partes pequeñas, cada una de estas es
más manipulable, por lo tanto, más entendible. Segundo, habiendo modularidad se
facilita la detección de errores en las fases de prueba y mantenimiento. Tercero, el
código puede ser reutilizado, ya que ciertas tareas o funciones efectuadas por un
módulo pueden ser utilizadas nuevamente en el mismo programa o en otros. Por
último, se facilita el trabajo colaborativo, ya que varios programadores pueden trabajar
en diferentes módulos simultáneamente.

1.2 Características de la Programación Estructurada

Diseño Top Down

En primera instancia, el problema inicial es planteado en forma general considerando

los posibles sub-problemas en primer nivel sin entrar a especificar en detalle la
funcionalidad de cada uno de ellos. Posteriormente, cada sub-problema es definido en
detalle, muchas veces resulta en la definición de otro nivel de sub-problemas, hasta
que todo se reduce a elementos básicos.

Tal como se puede ver en la Figura 1, la representación de un diseño Top Down o

descendente, es un modelo jerárquico donde los niveles de menor jerarquía
contribuyen con la función que desempeña el de mayor jerarquía, para nuestro caso
vemos que al último nivel están los sub-problemas C1, C2, y C3 solucionando el sub-
problema C y a la vez A, B, C, y D resuelven el problema original.
 6

Figura 1. Ejemplo de Diseño descendente

Fuente: Tomado de Universidad Nacional de la Plata (2013)

Prácticamente el diseño Top Down o descendente se refiere a empezar por lo general

e ir a lo particular mediante versiones sucesivas del problema. Cada nueva versión
incluye más información detallada, hasta llegar al nivel más bajo que es la parte que ya
se puede llevar a un lenguaje de programación.

El diseño Top Down es definido por Peralta Murua (2006), como “refinamientos
sucesivos” el cual es constituido por varias versiones que proponen la solución al
problema, donde la versión inicial es la concepción informal del problema; las
versiones intermedias donde se detalla aún más el problema; y por último la versión
final la cual aporta la solución final que puede ser implementada en un lenguaje de
programación.

Programación Modular

Al utilizar la técnica Top Down, el problema se ha expresado en forma detallada en una

jerarquía de sub-problemas. Estos sub-problemas, posiblemente, pueden convertirse
en módulos.

Un programa puede ser dividido en módulos de manera que cada módulo haga una
función específica, así, un programa es más fácil de entender y mantener. La
característica principal de esta técnica es que cada solución es expresada en un
módulo y éste a su vez debe ser independiente. Para ello, cada módulo incluye un
algoritmo de solución con parámetros de entrada (si es necesario) y datos de salida.

Para hablar de modularidad, el cambio de un módulo no debe afectar a los otros

módulos, aunque puede afectar la funcionalidad del programa en general. Es
importante al momento de partir el problema original en módulos considerar: a) la
independencia entre módulos y b) un algoritmo para resolver el problema, c) los valores
 7

de entrada d) los valores de salida y e) las acciones a realizar incluyendo aquellas

cuando los datos de entrada no son válidos.(Peralta Murua, 2006)

La mayoría de Lenguajes de programación son diseñados usando esta técnica de

programación modular ya que ellos involucran funciones en sus librerías que pueden
ser genéricas y por lo tanto disponibles para ser utilizadas por diferentes aplicaciones.

En este caso, no es necesario que el programador sepa su implementación, pero si, su

utilización; se debe conocer qué hace una función específica, que parámetros de
entrada necesita y cuál es su resultado. Así y haciendo una analogía, una función en
este caso se comporta como una caja negra que procesa información (no sabemos
cómo) y arroja un resultado. Igualmente, el programador puede crear funciones de
su propia autoría.

VENTAJAS

Según el documento escrito por la Universidad Nacional de la Plata (2013), entre los
factores positivos de usar programación estructurada esta la independencia entre
módulos, facilidad de modificación, reusabilidad del código, y mantenimiento.

Independencia entre módulos: se consideran dos departamentos en una organización,

recursos humanos y contabilidad, en el primero se calculan los valores que se tienen
que pagar por concepto de nómina, en el segundo se registran las transacciones que
tienen que ver con el pago de impuestos. Los dos departamentos, en este caso, son
independientes el uno del otro, aunque, una transacción en el departamento de
contabilidad afecta los resultados en la contabilidad. De todas maneras, cada uno es
autónomo en lo que hace. Cualquier situación que no funcione en un departamento es
competencia de ese departamento y se tiene que resolver internamente. A si es el caso
con la programación modular, cada módulo tiene que ser independiente y autónomo.

Facilidad de modificación: los módulos tienen que ser definidos claramente,

especificando exactamente el papel a desempeñar, evitando de esta manera
ambigüedades.

Reusabilidad del código: Cuando un módulo es específico y claro, este puede ser
utilizado por varias aplicaciones. Un ejemplo claro es el modulo que imprime etiquetas.
Este puede ser utilizado por nómina, para imprimir las etiquetas para enviar los recibos
de pago a los empleados, de igual forma, puede ser utilizado para enviar los extractos
bancarios a los clientes. No hay necesidad de crear dos veces el mismo código para
efectuar la misma función.

Mantenimiento: cuando un módulo ha sido bien diseñado, su modificación posterior se

hace fácil. Cualquier persona lo puede modificar, desde que sus especificaciones son
claras.
 8

DESVENTAJAS

Por otro lado, Joyanes Aguilar (2006), manifiesta que la Programación Estructurada, da
signos de debilidad a medida que los programas crecen y se hacen más complejos.

Primero que todo, porque las funciones pueden usar los datos globales ilimitadamente
y al hacer una modificación en un dato global puede afectar todas las funciones que la
utilizan. Además, porque la “disposición separada de datos y funciones” no modelan
situaciones del mundo real, como es el caso de la programación por objetos. Ver Figura
2.

Figura 2. Relación de las funciones con los datos globales

Fuente: Tomado de Joyanes, Aguilar (2006, p.21)

Codificación estructurada

La codificación estructurada es aquella que contempla las estructuras de control

básicas para la elaboración de un programa. Las estructuras básicas son: la secuencial
que ejecuta instrucciones una seguida de otra, la condicional IF_THEN_ELSE que
genera alternativas de acuerdo a si se cumple una condición o no, y la repetitiva
DO_WHILE que ejecuta un conjunto de instrucciones mientras se cumple una
condición.

Es importante resaltar que aunque es cierto que un programa de cualquier magnitud

puede ser escrito únicamente con estas estructuras de control, se han ido involucrando
otras como CASE y DO_UNTIL.

La finalidad de este tipo de codificación fue hacer un código más legible, fácil de
entender, y mantener. Ya que un código escrito de esta manera es un código que se
puede leer de principio a fin en forma secuencial.
 9
En esta forma de programación, según Molina (2006), un programa debe poderse leer
consecutivamente y no hacer uso de la instrucción “goto” implementada en lenguajes
como COBOL. Los lenguajes que usen las tres estructuras básicas (secuencia,
selección, e iteración) son considerados Estructurados.

1.3 Mapa conceptual de la programación estructurada

Estructura de control
Secuencial

Codificación
Estructura de control
Estructurada.
Problemas de mediana Condicional
complejidad involucra
es
resuelve Estructura de control
Repetitiva
Una técnica Programación
Estructurada

involucra involucra

Programación Modular
Diseño Top Down

Se divide en
hace

“refinamientos
sucesivos”

2. Que es una función

Podemos decir que la función es una consecuencia de un análisis estructurado

previamente hecho. Un problema general se dividió en partes o módulos con el fin de
hacerlo más manejable y así más fácil de controlar.
Desde el punto de vista de la programación podemos decir que un módulo es una
función formada por un conjunto especializado de instrucciones que ejecuta una tarea
específica; por consecuencia, un programa es un conjunto de funciones que se
ejecutan para dar la solución a un problema.

Dentro de las ventajas que brinda el uso de funciones están:

 Son especializadas en solucionar un problema en particular.

 Mayor claridad en la lectura del programa.
 Mayor facilidad para el desarrollo y mantenimiento del mismo programa.
 10
 Si necesita una función en varias partes de la aplicación sólo la escribe una vez
y la emplea en todas las partes que lo requiera.
 Desarrollo de proyectos de amplio impacto que se pueden trabajar en conjunto y
de forma simultánea.
Haciendo una analogía de la construcción de software con el ensamble de automóviles
podemos decir que, debido al m o d u l a r i d a d , el desarrollo de software se
comporta como la industria de ensamble de automóviles, ya que no todo se
desarrolla en la misma parte. Se están utilizando empresas que actúan como terceros
en la fabricación de elementos especializados.

Así, y para citar un ejemplo, la función matemática que calcula la potencia de un

número, es una función prefabricada que viene con el lenguaje de programación y la
cual puede ser integrada dentro de una nueva aplicación. El programador no necesita
conocer el código de la función, lo único a saber, es como funciona, cuáles son sus
parámetros de entrada y cuál es el resultado que suministra.

3. Java
Por supuesto que con Java se juntan diferentes enfoques de programación, como es el
caso de la programación estructurada por el uso de los tres tipos de estructuras vistos
anteriormente, la secuencial, de decisión y de ciclos; igualmente está presente el
enfoque Orientado a Objetos.

3.1 Que son Métodos

En Java en particular las funciones reciben el nombre de Métodos. Existen métodos

que ya vienen predefinidos con el lenguaje y lo único que se necesita es conocer cómo
invocarlos y usarlos. Sin embargo, los métodos prefabricados no son suficientes para la
creación de un nuevo aplicativo, por lo que, de la misma manera, Java permite la
creación de nuevos métodos.

Hay que tener en cuenta que por su estructura, los métodos en Java están clasificados
en clases, es decir, por tipo de función. Por ejemplo, un método que calcula el valor
absoluto de un número pertenece a una clase que se llama Math. De igual manera, un
método que convierte una cadena de caracteres de minúsculas a mayúsculas,
pertenece a una categoría o clase, llamada Char.
3.2 Métodos predefinidos

Son aquellos métodos cuyas instrucciones ya fuéron escritas y lo único que tenemos
que hacer es invocarlos, se ejecutan de manera automática, sin tener que
preocuparnos acerca de cómo están escritos. Tomemos como ejemplo los métodos
que calculan la potencia y raíz cuadrada de un número.
 11

METODO QUE CALCULA LA POTENCIA DE UN NUMERO, pow (x,y)

Los parámetros de la función son x y y, donde x=al número que se va a elevar a la “y”
potencia. Ejemplo: Pow (2,3)=8

Como el valor de pow(x, y) es de tipo double (doble precisión) decimos que el método
es de tipo double y retorna valores de tipo double.

METODO QUE CALCULA LA RAIZ CUADRADA DE UN NUMERO, sqrt(x)

Este método toma como parámetro de entrada, el número al cual se le va a calcular la

raíz cuadrada. El método calcula la raíz cuadrada no negativa de x para x >= 0.0. Por
lo que el método es de tipo double. Ejemplo: sqrt(2.25)=1.5.

ALGUNOS METODOS PREDEFINIDOS EN JAVA

En Java, los métodos predefinidos están organizados como colecciones de clases

llamadas bibliotecas de clases o class libraries. Por ejemplo, la clase Math contiene
los métodos de matemáticas. Los métodos que vimos anteriormente (sqrt y pow) están
contenidos dentro de la clase Math.

En la Tabla 1 se presentan algunos de los métodos matemáticos que vienen con el

lenguaje Java. La tabla presenta el nombre del método (en negrilla), número de
parámetros, tipo de datos de los parámetros, y el tipo del método. El tipo del método
es el tipo de valor que retorna el método. La tabla también muestra cómo trabaja el
método. La clase Math está contenida en el paquete (package) [Link].
Un paquete es un conjunto de clases que están relacionadas y agrupadas bajo un
nombre. El paquete [Link] tiene el propósito de agrupar clases que dan soporte a
Java. Dentro de este paquete hay varias clases una de ellas es Math, la cual a su vez
contiene el conjunto de funciones (métodos, así se llaman en Java) como pow y sqrt
que usamos arriba y muchos más que se relacionan más adelante.
 12
Tabla 1. Algunos Métodos predefinidos en la Clase Math en Java

Fuente: Tomado y modificado de Malik (2010, pp. 353,354)

Java también provee los métodos para manipular caracteres contenidos en la clase
class Character. En la Tabla 2 se presentan algunos de los métodos más usados. La
clase Character está en le paquete [Link].
 13
Tabla 2. Algunos métodos predefinidos en la clase Carácter

Fuente: Tomado de Malik (2010, p. 355)

USO DE METODOS PREDEFINIDOS

En general para utilizar un método predefinido en un programa como los presentados

en las Tablas 1 y 2, primero se debe importar la clase desde el paquete que la
contiene.

Por ejemplo, para usar el método nextInt de la clase Scanner debe importar la clase
desde el paquete [Link]. Sin embargo, si usted necesita usar una clase contenida en
el paquete [Link], Java no requiere que incluya una declaración explícita para
importar dicha clase. Por defecto, Java automáticamente importa las clases del
paquete [Link].
 14
Al inicio de cualquier programa se deben importar los paquetes que se necesiten y
donde estén contenidos los métodos que se van a utilizar, para ello se escribe la
instrucción como sigue:

import static [Link].*; (para el caso que se quiera importar la clase Math. Note
que el * indica que se quieren importar todos los métodos contenidos en esa clase.)

Como consecuencia, se puede utilizar cualquier método en esa clase. A si,

considerando que se va a elevar a la potencia un número, podemos hacer o no
mención de la clase: [Link](2.0, 30) o, pow(2.0, 3.0). Para el caso de la clase
Character el tratamiento de los métodos es igual.

EJEMPLO 3.1. Uso del método toUpperCase de la clase Character y el método pow de
la clase Math. Fuente: Tomado y modificado de Malik (2010)

import static [Link].*; //importa todos los métodos de la

clase Math
import static [Link].*; //importa toda la clase Character
public class MetodosPredefinidos {
/**
* @param args
*/
public static void main(String[] args) { // inicio del programa
// TODO Auto-generated method stub
int x; double u; double v;
[Link]("Línea 1: Mayúscula de a es: " + toUpperCase('a')); u = 4.0;
v = 3.0;
[Link]("Linea 2: %.1f a la potencia " + "de %.1f = %.2f%n", u, v, pow(u, v));
}
}

En el programa anterior se puede ver el uso del método “toUpperCase”, a este se le

pasa un parámetro, la letra “a”, la cual debe ser convertida a mayúsculas. Igualmente,
se llama el método “pow” que resuelve la ecuación (4 3). Después de ejecutado el
programa se puede ver lo siguiente:

Línea 1: Mayúscula de a es: A

Línea 2: 4,0 a la potencia de 3,0 = 64,00

Métodos definidos por el usuario

 16

15

Aunque Java provee algunos métodos, no puede ofrecer todos los métodos que un
programador puede necesitar en un momento dado, por lo tanto se requiere aprender a
definir los propios métodos que el programador necesite.

Los métodos que define el usuario se clasifican en dos categorías:

1. Métodos que no retornan valor (void). Son métodos que no tienen un

tipo de valor de retorno, no usan la declaración return.
2. Métodos que retornan valor. Estos métodos retornan un valor de un
tipo de dato
mediante la declaración return.

Métodos que no retornan valores

Los métodos que no retornan valor (void) y los que retornan valor tienen estructuras
similares. Ambos tienen encabezados y cuerpo. Usted puede colocar los métodos
void antes o después del método main. Ver Figura 3 para una mejor ilustración.

La sintaxis para el método tipo void es la siguiente:

modifier (s) void methodName (formal parameter list) { statements

}

Métodos que retornan valores

En los ejemplos antes mencionados se vieron métodos como pow(x,y) y

toUpperCase(Char) que tienen un valor de retorno, es decir, hacen el cálculo y retornan
un valor. Los valores que retorna un método, típicamente son utilizados para guardar
el valor para un cálculo posterior, para desplegarlo, o para imprimirlo.

Para usar estos métodos en los programas se debe tener en cuenta la definición del
método el cual está conformado por los siguientes 5 elementos:

1. El nombre del método

2. El número de parámetros, si los hay
3. El tipo de dato de cada parámetro
4. El tipo de dato del valor que devuelve el método
5. El código requerido que acompaña la tarea a ejecutar

Los primeros cuatro puntos mencionados arriba se conocen como el encabezado del
método, el quinto se llama el cuerpo del método.
 17
Veamos el encabezado del método abs que determina el valor absoluto de un número
dado.

public static int abs (int numero)

El modificador public quiere decir que lo puede invocar cualquier otra clase de la misma
aplicación. El modificador static quiere decir que dicho método pertenece a la clase
donde está inscrito.

Tipos de parámetros

Parámetros actuales: AL INVOCAR EL METODO, en este caso las variables “u” y “v”
son llamadas parámetros actuales

double u = 2.0; double v = 3.0;

x = pow(u, v); // u, y v son llamados parámetros actuales
...

Parámetros formales: EN EL ENCABEZADO DEL METODO, en este caso las variables

“base” y “exponente” son llamadas como parámetros formales.

public static double pow(double base, double exponente); // base y

exponente son llamados parámetros formales.

Sintaxis del encabezado al definir un método que retorna un valor

La sintaxis de este tipo de método se presenta a continuación:

modifier (s) retunType methodName (formal parameter list) { statements;

}

Esta sintaxis nos dice:

1. modifier (s) indica la visibilidad del método ante otro método o clase, esto es,
dónde el método puede ser usado o llamado. Algunos de los modificadores son
public, private, protected. Si incluye más de un modificador deben ir separados por
espacios. El modificador public especifica que el método puede ser llamado desde
afuera de la clase donde es definido; private indica que el método no puede ser
usado fuera de la clase donde se definió. Protected indica que el método se puede
invocar desde otro método pero dentro de la misma clase.
2. returnType es el tipo de valor que el método retorna. Como entero, doble u otro.
3. methodName es el nombre que se le da al método definido por el usuario.
4. statements son las instrucciones que forman el cuerpo del método.
 18

Ejemplo: public static double pow(double base, double exponente)

Sintaxis al hacer el llamado del método

La llamada a un método que retorna un valor es:

methodName (actual parameter list)

Ejemplo: pow(u, v)

Es importante destacar que una lista de parámetros formales puede estar vacía, pero
de todas formas los paréntesis son requeridos. Tanto el encabezado de la definición del
método como el llamado del mismo deben estar emparejados en cuanto a tipo de dato
como el orden lógico de los parámetros. Esto quiere decir que los parámetros formal y
actual deben tener una relación uno-a-uno. En la Figura 3 se puede observar la síntesis
del encabezado del método llamado y del método llamador.

Figura 3. Sintaxis al definir y llamar un método en Java

Fuente: Tomado y modificado de Malik (2010)

Declaración return

Cuando el método completa su ejecución devuelve en la sentencia return el valor

calculado. La sintaxis tiene la siguiente forma: return expr; donde expr es una
variable, una constante o una expresión. El tipo de dato del valor que expr calcula debe
ser compatible con el tipo de retorno del método. Cuando se ejecuta la sentencia
return el método inmediatamente termina y el control del programa regresa al método
llamador.

Veamos a continuación un ejemplo de un programa en Java haciendo uso de un

método (función) que se encargará de determinar el mayor número entre dos.

Como los números que vamos a analizar son de tipo punto flotante es decir son de tipo
double entonces el método también será de tipo double. De manera que la definición
 19
del método se verá así:

public static double mayor (double x, double y) { double maximo;

if (x >= y)
maximo = x;
else
maximo = y;
return maximo;
}
En la Figura 4 se puede observar los distintos componentes del método con sus
respectivas definiciones.

Figura 4. Descripción del Cuerpo del Método en Java

Fuente: Tomado y modificado de, Malik (2010, p.364)

Ahora veamos un ejemplo de llamado a un método, suponga que num, num1, num2
son variables de tipo double. En la Figura 5, se puede observar diferentes llamados al
método máximo (larger).

Figura 5. Diferentes formas de llamar a un método.

Fuente: Tomado y modificado de Malik (2010, p. 365)

 19

EJEMPLO 3.2. Programa que determina el número de mayor valor, tomando como
base dos números. Fuente: Tomado y modificado de Malik (2010)

import [Link].*;
public class NumeroMayor {
static Scanner consola = new Scanner ([Link]);
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double num1;
double num2;

[Link]("Linea 3: El mayor entre " + "5.6 y 10.8 es " + mayor(5.6,

10.8));
[Link]("Linea 4: Entre dos " + "numeros: "); //Linea 4
num1 = [Link](); //Linea 5
num2 = [Link](); //Linea 6
[Link](); //Linea 7
[Link]("Linea 8: El mayor entre " + num1 + " y " + num2 + " es "
+ mayor(num1, num2));
}

public static double mayor (double x, double y) {

double maximo;

if (x >= y)
maximo = x;
else
maximo = y;
return maximo;
}
}

Los resultados arrojados por consola son:

Linea 3: El mayor entre 5.6 y 10.8 es 10.8

Linea 4: Entre dos numeros: 32 56
Linea 8: El mayor entre 32.0 y 56.0 es 56.0

Se recomienda escribir el programa anterior en Eclipse y ejecutarlo en modo “debug”

para una mejor comprensión. Recuerde que debe ingresar a debug configuration y
seleccionar la opción “stop in main”. Luego seleccionar el ícono (step into). Con esta
opción puede ir mirando la ejecución del programa paso a paso; en la ventana
“variables” de la vista “debug” aparecen los valores de las variables que usa en el
programa.

20

En la siguiente imagen se presenta la ejecución del programa en modo debug

(depuración). Recuerde que debe ingresar los números a través de la consola. Cuando
esté resaltada la línea de código: num1 = [Link](); debe posar el cursor
sobre la ventana de consola y allí digitar el número que quiere ingresar luego dar enter,
oprimir en el ícono de step into, volver a pararse en la consola y digitar el otro número,
dar enter y luego presionar el icono de step over .

Volviendo sobre el programa de ordenamiento del módulo anterior pero ahora haciendo
uso de funciones, se puede ver que en el programa principal se colocaron las
instrucciones que debían hacer el ordenamiento, de la siguiente manera:

public static void main(String[] args) {

// TODO Auto-generated method stub
int [] lista = {16,30,24,7,62,45,5,55};
[Link] ("arreglo sin ordenar ");
for (int i=0; i < [Link] ; i++){
[Link](lista[i]+ ", ");
}
for (int anterior = 0; anterior < [Link] -1;
anterior ++){

for (int siguiente = anterior + 1; siguiente < [Link]; siguiente ++){

if (lista[siguiente] < lista[anterior]){ .
..
EJEMPLO 3.3. Ordenar los números de una lista que se toma como parámetro de
entrada.

Pues bien, lo que se va hacer es dejar el módulo del programa principal solamente
iniciando el vector de números con su respectiva impresión, y el ordenamiento de
losnúmeros se van a llevar a cabo en un método aparte con el fin de que el
programa principal quede claro, de esta manera un método especializado se encarga
de hacer el ordenamiento.

import [Link].*;
public class Ordenamiento {
static int temporal = 0;

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

int [] lista = {16,30,24,7,62,45,5,55};

[Link] ("arreglo sin ordenar ");
imprimirLista (lista); // Llamado a la función imprimirLista

ordenar (lista); // aquí se invoca el método llamado “ordenar”

[Link]();
[Link] ("arreglo ordenado");
imprimirLista (lista);

}// Fin del programa principal

// A continuación se define el método que hace la impresión del vector lista

private static void imprimirLista(int[] lista) {
// TODO Auto-generated method stub
for (int i=0; i < [Link] ; i++){
[Link](lista[i]+ ", ");
}
}

// A continuación se define el método que hace el ordenamiento

private static void ordenar(int[] lista) {

// TODO Auto-generated method stub

for (int anterior = 0; anterior < [Link] - 1; anterior ++){

for (int siguiente = anterior + 1; siguiente < [Link];siguiente ++){
if (lista[siguiente] < lista[anterior]){

temporal = lista [anterior];

lista [anterior] = lista[siguiente]; lista [siguiente] = temporal;
}
}
}
}
}

Observaciones sobre el programa anterior:

1. Como se puede observar el programa principal se encarga de crear el

vector lista e imprimirlo, la primera vez desordenado y luego ya ordenado.
2. El programa principal tiene dos funciones, una que se encarga de la
impresión y la otra del ordenamiento del vector. De manera que el programa
principal sólo se encarga de estar pasando el control a las funciones según lo va
necesitando.
3. La función imprimirLista se encarga de eso, imprimir, es una
función especializada; lo mismo ocurre con la función ordenar, cuya tarea es
hacer el ordenamiento.
4. En este caso, los dos métodos fueron creados por el usuario, pero
ellos no retornan ningún valor, por eso se definieron usando la cláusula “void”.

Teniendo funciones que hacen tareas específicas, permite hacer un mantenimiento

puntual, ya que solo se modifica la función en particular que requiere cambio.
Igualmente, si alguna función no hace su trabajo como debe ser es más fácil
determinar el área donde se focaliza el problema y solucionarlo. En conclusión hemos
aplicado el principio “divide y vencerás”, es decir, el problema hay que dividirlo en
partes para encontrar su solución. Esta es una manera estructurada de programar, se
dividió el programa en varias partes, donde cada una de ellas es encargada de efectuar
una tarea, pero las dos, resuelven el problema en general.

3.3 Variables de entorno

Las variables de entorno son variables que maneja el Sistema Operativo (SO) con el
propósito de mantener la configuración de la computadora. El SO necesita de estas
variables para estar monitoreando y controlando las diferentes tareas que lleva a cabo
tanto el usuario en la máquina como el propio SO.

Algunas de las tareas típicas que realiza el SO son: direccionar el lugar donde debe
ubicar archivos de programa, archivos temporales, ruta de instalación de programas y
muchas más.

Estas variables de entornos sirven de enlace entre el SO y el (los) paquetes de

software que se ejecuten sobre la máquina. Ya sea paquetes de ofimática (Microsoft
Office) o paquetes para desarrollo de software como Java, Eclipse; Bases de datos
como Oracle, Postgresql. Cuando se está haciendo desarrollo de software es
altamente probable que haya que recurrir al uso de estas variables.

A continuación, en la Tabla 3, se presenta una lista parcial de las variables de entorno

bajo sistema operativo Windows XP.

Tabla 3. Lista parcial de las variables de entorno en Windows XP

NOMBRE DE LA VARIABLE DESCRIPCION

%ALLUSERSPROFILE% Localización del perfil de todos los usuarios, por lo

general es C:\Documents and Settings\All Users
Carpeta oculta donde guardan sus datos las
%APPDATA% aplicaciones, se
encuentra dentro de la carpeta de usuario.
C:\Documents and
%CLIENTNAME% Settings\NombredeUsuario\Datos de programa
Nombre del equipo

%CommonProgramFiles% Archivos comunes:

C:\Archivos de programa\Archivos comunes

%COMPUTERNAME%
Nombre del equipo

%ComSpec% Ruta al ejecutable de CMD:

C:\WINDOWS\system32\[Link]
%HOMEDRIVE% y
%SystemDrive% Unidad de sistema
 NOMBRE DE LA VARIABLE DESCRIPCION

%HOMEPATH% Ruta relativa a la carpeta del usuario:

\Documents and Settings\NombredeUsuario

%Path%
Rutas a los ejecutables del sistema

%PATHEXT% Archivos ejecutables predeterminados:

.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.
WSF;.WSH
%ProgramFiles% Ubicación de los archivos de programas,
normalmente: C:\Archivos de programa

%SystemRoot% y %Windir%
Carpeta de Windows, generalmente:
C:\WINDOWS

%TEMP% y %TMP% Ubicación de archivos temporales, generalmente:

C:\Documents and Settings\Configuración local\Temp

%USERNAME%
Nombre del Usuario

%USERPROFILE% Carpeta del usuario, generalmente: C:\Documents

and Settings\NombredeUsuario
Fuente: Tomado y modificado de Carradeguas (2014)

Visualizando las variables de entorno usando Java

A continuación, se puede ver un programa (tomado de Oracle, 2014) en Java el cual

obtiene el valor de las variables de entorno mediante la función “getenv”. Este
programa se puede ejecutar desde el IDE de Eclipse.

import [Link];
public class Variables {
public static void main (String[] args) { Map<String, String> env = [Link](); for
(String envName : [Link]()) {
[Link]("%s=%s%n", envName, [Link](envName));
}
}
}

El resultado de la ejecución del anterior programa se puede ver como sigue:

USERPROFILE=C:\Documents and Settings\UMB PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH
JAVA_HOME=C:\Archivos de programa\Java\jdk1.6.0_21 TEMP=C:\DOCUME~1\UMB\CONFIG~1\Temp
SystemDrive=C: ProgramFiles=C:\Archivos de programa
Path=C:/Archivos de programa/Java/jre7/bin/client;C:/Archivos de programa/Java/jre7/bin;C:/Archivos de programa/Java/jre7/lib/
i386;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Archivos de programa\Intel\WiFi\bin\;C:\Archivos de
programa\PostgreSQL\8.4\bin;C:\Archivos de programa\Java\jdk1.6.0_21\bin;C:\Archivos de programa\TortoiseHg\;C:\Archivos de
programa\Mercurial;C:\Archivos de programa\Eclipse\eclipse;
HOMEDRIVE=C: PROCESSOR_REVISION=0f0d
CLIENTNAME=Console USERDOMAIN=NICO1
ALLUSERSPROFILE=C:\Documents and Settings\All Users ADEMPIERE_HOME=C:\Adempiere
PROCESSOR_IDENTIFIER=x86 Family 6 Model 15 Stepping 13, GenuineIntel SESSIONNAME=Console
TMP=C:\DOCUME~1\UMB\CONFIG~1\Temp

Usando variables de entorno en Java

Ahora veremos otro ejemplo que hace uso de variables de entorno, en particular para el
manejo de la fecha que tiene el sistema operativo. En este caso debemos importar la
clase Date y/o Calendar que están contenidas en el paquete [Link]. Luego se crea
Otra manera de tener acceso a algún dato en particular de la fecha del sistema hay que
hacer uso de la clase Calendar. Con ella se puede tomar objetos particulares de la
fecha como mes, año, día, hora, segundos, milisegundos. Para ello,
se obtiene la fecha del sistema mediante el método getInstance().
un objeto de tipo Date (tiene el propósito específico para manejo de fechas) cuyo
nombre es fecha. Para obtener la fecha se utiliza el método getTime().

Recuerde, el método getInstance(), se encuentra dentro de la clase Calendar, a su vez

la clase está contenida en el paquete [Link]. Esto es como una jerarquía, donde el
elemento de más bajo nivel es el método, el cual ejecuta la acción.

A continuación, se presenta la codificación en Java del manejo de la variable de

entorno fecha (Date) del sistema.

EJEMPLO 3.4. Utilizando variables del sistema o variables de entorno. Fuente: Autor,
(2014)

Suponga que usted tiene que imprimir facturas, cheques o dar acceso a funcionarios a
alguna área de la empresa, para todos estos casos necesita capturar la fecha del
sistema para imprimirla y/o dejar registro de la misma en su sistema de información.
Veamos como Java resuelve esta situación:

import [Link];
import [Link];

public class Fecha {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int mes, dia, anho;

Date fecha = new Date();

[Link] ("El tiempo de la computadora es: %d\n", [Link]());
[Link]("Equivalente a: %s\n" , [Link]());

Calendar calendario = [Link]();

dia = [Link](Calendar.DAY_OF_MONTH); mes =

[Link]([Link])+ 1;
anho =[Link]([Link]);
[Link]("El día es " + dia + ", el mes es " + mes + ", el año es: " +
anho);
}
}
Ejemplo 3.5. Utilizando funciones en Java. Fuente: Autor (2014) Planteamiento del

problema:

Calcular una tasa de rendimiento o descontar una cuota de administración para los
clientes de un banco dependiendo de la categoría de cuenta que posean. Si es de
ahorro tendrá una rentabilidad de 2% sobre su saldo, si la cuenta es corriente tendrá un
costo de $15000 por administración; valor que se descontará del saldo que posea en la
cuenta.

Codificación de la solución:
import [Link].*; //se importa la clase [Link]
public class Repaso {
static Scanner consola = new Scanner ([Link]); //se define objeto consola
private static String nombre;
private static double saldo; private static String mensaje; static boolean parar =
false; private static String seguir,SiNo;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
while (!parar) {
ingresarDatosCliente();

int control;
do {
[Link] ("ingrese 1 para cuenta de Ahorro, 2 para cuenta Corriente");
control = [Link]();
}
while (control != 1 && control != 2);
if (control == 1)
calcularCuentaAhorro();
else

calcularCuentaCorriente();

imprimirNuevoSaldo(); masClientes(); limpiarBufferConsola();

if ([Link]("N"))
parar = true;
}
[Link] ("Fue un placer servirle. Fin del programa.");

}
// Llamado a las distintas funciones o métodos

private static void ingresarDatosCliente() {

// TODO Auto-generated method stub

[Link] ("Ingrese el nombre del cliente");

nombre = [Link]();
[Link] ("Ingrese saldo de la cuenta");
saldo = [Link]();
}
private static void calcularCuentaAhorro() {
// TODO Auto-generated method stub final double TASA_INTERES = 0.02; saldo =
saldo + (saldo * TASA_INTERES);
mensaje = ("su cuenta recibió intereses de rendimiento.");
}
private static void calcularCuentaCorriente() {
final double COSTO_CUENTA_CORRIENTE = 15000;
saldo = saldo - COSTO_CUENTA_CORRIENTE;
mensaje = ("Su cuenta tuvo descuento por administración.");
}

private static void imprimirNuevoSaldo() {

// TODO Auto-generated method stub
[Link]("Señor(a) " + nombre);
[Link] (mensaje +" El nuevo saldo de su cuenta es: " + saldo);

}
private static void masClientes() {

// TODO Auto-generated method stub

do {

limpiarBufferConsola();
[Link] ("Va a ingresar más clientes ?, S/N" );
seguir = [Link]();
SiNo = [Link]();

}
while (![Link]("S") && ![Link]("N"));
}
private static void limpiarBufferConsola() {
// TODO Auto-generated method stub
[Link]();

}
}
Explicación del programa anterior:
1. El programa en principio aborda la solución leyendo los datos de
entrada a través del teclado, para esto es necesario importar la clase [Link].*.
Debemos definir un objeto tipo Scanner que llamamos consola. Como vamos a entrar
datos tipo String como enteros y de precisión doble, es absolutamente necesario
limpiar el área en memoria (buffer) donde se almacenan los datos que van entrando
por el teclado; para este propósito usamos un método llamado limpiarBufferConsola()
que se encarga de esta tarea. Esta limpieza del buffer es necesaria hacerla entre
el ingreso de datos de tipo string y datos numéricos.
2. El programa inicia con el método ingresarDatosCliente(), va lo
ejecuta y el control regresa a ejecutar la siguiente instrucción después del método
llamado. Es decir, ejecuta la instrucción int control. Ingresamos a un ciclo tipo haga-
mientras (do_while). Observe la condición del ciclo while.
3. Saliendo del ciclo y según el valor que tenga la variable control se
llama a uno de los dos métodos, calcularCuentaAhorro() o calcularCuentaCorriente().
En cualquier caso, debe imprimir el nuevo saldo por medio del método
imprimirNuevoSaldo(), luego, se le pregunta al usuario si desea continuar
ingresando nuevos clientes, situación que se maneja por medio del ciclo
haga_mientras (do_ while) en el método masClientes(). Aquí aparece el llamado al
método limpiarBufferConsola() de acuerdo a la explicación dada anteriormente, la
ubicación de esta instrucción es precisa con el fin de no tener un comportamiento
inestable del programa.

4. Tome nota del desempeño de este método con la variable, SiNo que
es la variable que tiene como propósito manejar el ciclo while mediante la variable
parar que es de tipo boolean (true o false). Recuerde que: como profesional de
Ingeniería de software se debe tener presente criterios de eficiencia en cuanto a
rendimiento de máquina y uso adecuado de memoria, sin sacrificar la claridad del
programa.

4. JavaScript

4.1 Funciones

El concepto de función es la misma en cualquier lenguaje de programación. Se ha

definido las funciones como unidades de un programa que ejecutan una tarea
específica; por ejemplo, una función puede ser aquella que valida si el número de la
cédula de ciudadanía es válido; otra puede ser, la que calcula el promedio de
rendimiento en la clase de programación. Esto quiere decir que una función no es solo
un bloque que ejecuta una tarea, sino también que devuelve un valor como resultado.

En JavaScript una función puede ser lo que en otros lenguajes es llamado

procedimiento, subrutina, y funciones. (Goodman, 2010, p.438)

Declaración y llamado de funciones

Las funciones en JavaScript tienen que ser definidas antes que vayan a hacer
utilizadas. Normalmente, las funciones son puestas dentro del bloque <head> del
programa HTML. Las funciones son almacenadas en archivos externos de JavaScript o
en librerías.

Para definir una función se le da el nombre, seguido de un par de paréntesis () dentro

de los cuales se definen los parámetros de entrada de la función. Las instrucciones que
ejecuta esta función deben ir dentro de paréntesis {} curvos.

Veamos su sintaxis a través de un ejemplo:

Function bye(){
[Link] (“bye, adiós, adieu,…”);
}

Viendo lo anterior, deducimos que el nombre de la función es bye y no tiene

parámetros de entrada. Lo único que hace esta función es desplegar el mensaje “bye,
adiós, adieu, ….”. Seguidamente, encontramos otro ejemplo:

EJEMPLO 4.1. Envía un mensaje a pantalla.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"[Link]
<html lang="EN">
<head><title>Mi primera Funcion</title>
<script type="text/javascript">
function bienvenido(){ // la function es incluida dentro de las etiquetas <head>
var place="Universidad Manuela Beltran";
alert("Bienvenido a: "+ place + "!"); // envia un mensaje a la pantalla
}
</script>
</head>
<body bgcolor="lightblue">
<big>
<div align="center">
<script type="text/javascript">
bienvenido(); // aqui se hace el llamado de la funcion “bienvenido”
</script>
<b>Universidad Manuela Beltran</b><br />
<img src="[Link]" width="400" height="300">
</div>
</big>
</body>
</html>

Explicación: El anterior ejemplo no toma ningún valor de entrada. Al ejecutarse el

programa, primero muestra un mensaje en la pantalla que dice: Bienvenido a:
Universidad Manuela Beltrán. Posteriormente, al aceptar el mensaje, se despliega una
imagen en la pantalla.

PASANDO PARAMETROS

A una función se le pueden pasar valores que van a hacer utilizados dentro de la
función. Se pueden enviar varios valores pero estos deben ir separados por comas y
deben ir en paréntesis (), después del nombre de la función.
En el ejemplo anterior se quiere mandar el nombre de la Universidad como un
parámetro para que se despliegue el mensaje, para poder escribir la función se tendría
que seguir la siguiente sintaxis:

1. bienvenido (“Universidad Manuela Beltrán”) // aquí se hace el

llamado de la función y se envía el nombre la universidad
2. Function bienvenido (nombre_univ) // se define función con 1
argumento, en la variable nombre_univ se guarda el nombre de la universidad

Modificando el Ejemplo 4.1, tenemos lo siguiente:

EJEMPLO 4.2. Enviando parámetros. Fuente: tomado y adaptado de Quigley (2010)

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"[Link]
<html lang="EN">
<head><title>Funcion con parametros</title>
<script type="text/javascript"> function bienvenido(nombre_univ){
// la function es incluida dentro de las etiquetas <head>
alert("Bienvenido a: "+ nombre_univ + "!"); // envia un mensaje a la pantalla
}
</script>
</head>
<body bgcolor="red">
<big>
<div align="center">
<script type="text/javascript"> bienvenido("Universidad Manuela Beltran");
// aquí se hace el llamado de la función “bienvenido” y se envía el
nombre como parámetro
</script>
<b>Brock University</b><br />
<img src="[Link]" width="400" height="300">
</div>
</big>
</body>
</html>

Recuerde que usted puede copiar el anterior programa, guardarlo en un archivo tipo
texto, con extension .html, y ejecutarlo en un explorador de internet.

Otra cosa importante: Las variables que son definidas dentro de una función son
LOCALES, queriendo decir, que los valores son reconocidos únicamente dentro de la
función. Cuando las variables se definen fuera de la función son llamadas GLOBALES.

EJEMPLO 4.3. Definiendo variables globales y locales

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"[Link]
<html lang="EN">
<head><title>Variables dentro de las funciones</title>
<script type="text/javascript">
var nombre ="Aurora"; // Estas son variables globales var
ciudad ="Bogota";
function saludame(){
var nombre = "Ricardo"; // Estas son variables locales var ciudad = "St. Catharines";

alert("Dentro de la función el nombre es " + nombre + " la ciudad es: "+ ciudad);
}
</script>
</head>
<body>
<script type="text/javascript">
saludame(); // llamado de la función
alert("Fuera de la función los valores son: "+ nombre +
" y la ciudad es: " + ciudad);
</script>
</body>
</html>

El anterior ejemplo fue tomado y modificado de, Quigley (2010). Se recomienda al

estudioso ejecutarlo para que entienda la diferencia entre valores locales y globales.

RETORNO DE VALORES

Así como se pueden enviar valores que son procesados por una función, esta última
puede devolver valores procesados para que sean conocidos por el usuario. Por
ejemplo en el cálculo del área de un rectángulo, los valores de entrada son: base y
altura; el valor a retornar es: el área. Veamos un ejemplo:

EJEMPLO 4.4. Retornando valores

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"[Link]
<html lang="EN">
<head><title>Retorno de Variables</title>
<script type="text/javascript">
function areaRectangulo(base, altura){
return base*altura; // Retorna el valor de multiplicar base por altura
}
</script>
</head>
<body bgcolor="lightgreen">
<font face="arial" size="+1">
<div align="center">
<img src="[Link]">
<script type="text/javascript">
var base=eval(prompt("Escriba el valor de la base? ", "")); var
altura=eval(prompt("Escriba el valor de la altura?", ""));
var areaR = areaRectangulo(base, altura); //llama function y asigna valor
retornado a la variable “areaR”

// Asigna el valor de base*altura a la variable “areaR”

alert("El area del rectangulo es: "+ areaR +" metros cuadrados\n");
</script>
</div>
</font>
</body>
</html>

Recuerde que: dentro de la definición de la función se debe incluir el valor que se debe
retornar.
Funciones anónima como variables

Veamos el siguiente bloque de instrucciones:

[Link] = function() { Alert (“ Buenos días clase”);

}

Después de que la página web ha cargado, el evento “onload” es disparado y

JavaScript ejecuta el bloque de instrucciones contenidas en la función. Es bueno
resaltar que este tipo de funciones no tiene nombre y que los paréntesis (), son como
un tipo de operador que indica que se va a ejecutar una función anónima. Las
funciones anónimas no tienen nombre, pero deben ser asignadas a una variable
para poder ser utilizadas, de otra manera seria imposible ejecutarlas. En este
caso, las funciones anónimas son llamadas con el nombre de la variable a la cual se
le asignó la función. Entendamos mejor mediante el siguiente ejemplo:

EJEMPLO 4.5. Creando una función anónima que envía un mensaje a pantalla

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"[Link]
<html lang="EN">
<head><title>funciones anonimas</title>
<script type="text/javascript">
var varSaludo= function(){ // funciones anonimas no tienen nombre
varMensaje="Buenos dias! "; // aqui se define la funcion
return varMensaje; // aqui se retornan valores
}
</script>
</head>
<body>
<big>
<script type="text/javascript">
texto=varSaludo; // varSaludo es una
variable

// su valor es la definicion de una funcion

alert(texto + "\n VARIABLE texto ANTES DE LLAMAR LA FUNCION\n OBSERVE
CONTIENE LA DEFINICION DE LA FUNCION.\nOK para continuar");
texto= varSaludo(); // Llama la funcion
alert (texto + "\nVARIABLE texto DESPUES DE EJECUTADA LA FUNCION");
</script>
</big>
</body>
</html>

En el anterior ejemplo (tomado y adaptado de Quigley), la función es asignada a la

variable “varSaludo” dentro del bloque <head> del HTML. Después, la función es
llamada (dentro de las etiquetas <body>) con el nombre de la variable “varSaludo” y
asignada a una nueva variable “texto”.

Observe que antes de llamar la función, la variable texto contiene la definición de la

función, por eso es que el primer mensaje muestra todas las líneas que aparecen en la
definición de la función, tal como aparece en la siguiente captura de pantalla:
Ahora veamos el valor de la misma variable texto, después que se ejecuta la función
varSaludo(); ahora sí, la variable texto contiene el valor “Buenos días” tal como se
muestra a continuación:

Hay que recordar que una función anónima no tiene nombre, por eso su
comportamiento es un poco diferente de aquellas que lo tienen. La función anónima se
invoca con la variable que contiene su definición, tal como se muestra en el Ejemplo
4.5; una función sin nombre es asignada a una variable ( varSaludo=function() ) por
consecuencia la función es llamada con el nombre de la variable ( varSaludo() ).

Recursividad

Podemos tomar como ejemplo la serie de fibonacci, donde un número en la serie es

compuesto de la suma de los dos números anteriores, a partir del tercer elemento de la
serie. Se habla de recursividad cuando una función se llama a sí misma.

EJEMPLO 4.6. Entendiendo recursión mediante la serie de fibonacci. Este ejemplo fue
tomado y modificado de Quigley (2010)

<!DOCTYPE HTML>
<html lang="EN">
<head><title>Recursividad mediante la serie de Fibonacci</title>
<style> table,th,td
{
border:1px solid black;
}
td
{
heigh:50px;
text-align:center; vertical-align:center;
}
</style>
<script type="text/javascript"> var count = 0;
function fib(num){ count++;
switch(num){ case 0 : return(0);
break; case 1:
return(1); break;
default:
return(fib(num - 1) + fib( num - 2 )); break;
}
}
</script>
</head>
<body>

<table style="width:300px">
<script type = "text/javascript"> for( n=0; n < 20; n++){
value = fib(n);
[Link]("<td>" + value + "</td>");
}
alert("Llamados de la funcion asi misma: "+ count + " veces!!");
</script>
</table>
</body>
</html>

Al ejecutarse el programa descrito en el EJEMPLO 4.6 se puede observar que la

función se llamó a sí misma, 35400 veces, tal como se muestra en el pantallazo
siguiente:

4.2 Objetos en JavaScript

De acuerdo a Quigley, ciertamente JavaScript es un lenguaje de programación basado

en objetos ya que todo es considerado objeto en JavaScript, por ejemplo: los botones
en una página web, las formas que capturan información, las imágenes, los enlaces,
etc.; sin embargo, este no es considerado como un lenguaje de programación orientado
a Objetos como lo es Java. De todas maneras, de una u otra forma JavaScript refleja
objetos de la vida real considerando algunas de las características que tienen los
lenguajes orientados a objetos, veamos como:
Representación jerárquica de un objeto

Todo objeto en JavaScript es representado como se muestra en la Figura 6, la cual es

una jerarquía de tres niveles, donde la de menos categoría corresponde a los atributos
del objeto. En ella se puede apreciar dos ramas conectadas a la raíz “object”, la
primera es “cat”, la segunda es “dog”. Para referirse por ejemplo a los atributos de un
objeto, solo hay que mencionar el objeto seguido de un punto. Ejemplo: [Link] o
[Link], etc.. No es necesario mencionar el objeto “object” cuando se está
descendiendo en la jerarquía.

Figura 6. Jerarquía para representación de un objeto

Fuente: Tomado de Quigley (2010)

Creando objetos con el constructor

Un constructor en JavaScript es como una función la cual crea como el plano que sirve
de referencia a un objeto. Se pueden crear objetos de la siguiente manera:

USANDO EL OPERADOR “new”

Var cat=new Object()

Var amigos = new array (“maria”, “esperanza”, “teresa”) Var festivos = new Date (“July
20, 2014”)

USANDO EL CONSTRUCTOR “Object”

Por ejemplo en el caso de var cat=new Object(), la variable “cat” tiene una referencia a
una instancia de un nuevo objeto.

Propiedades de los Objetos

Entendamos mediante el siguiente ejemplo:

EJEMPLO 4.7. Creando objetos definidos por el usuario. Fuente: tomado y adaptado
de Quigley (2010)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"[Link]
<html lang="EN">
<head><title>Objetos Definidos por el usuario</title>
<script type = "text/javascript">
var toy = new Object(); // Crea una instancia del objeto [Link] = "Lego"; // Asigna
propiedades al objeto [Link] = "rojo";
[Link] = "rectangulo";

</script>
</head>
<body bgcolor="blue">
<script type = "text/javascript">
[Link]("<b>El juguete es un: " + [Link] + "."); [Link]("<br />Este
es: " + [Link] + " " + [Link]+ ".");
</script>
</body>
</html>

En el programa anterior se puede ver que se definió un objeto llamado “toy” al cual se
le dieron los atributos de “nombre”, “color”, y “forma”. Note que para referirse a un
atributo primero se debe referenciar el nombre del objeto seguido por un punto y por
último, el nombre del atributo (en este caso “[Link]”)

En JavaScript se puede ver algo como [Link]=”red”; donde

“Window”, es el objeto de más alto nivel en la jerarquía, después sigue el objeto
document, el cual por estar subordinado es también un atributo de “window”, finalmente
“bgColor” es un atributo de “document”, pero por si solo no es un objeto. (Quigley,
2010).

Creando funciones como métodos

Los métodos son utilizados por lenguajes orientados a objetos para describir el
comportamiento de los mismos.

Por ejemplo, en JavaScript: [Link]();

[Link](“hello world”);

Para referirnos a un método específico hay que mencionar el objeto al cual este
método está asociado. Igual que las propiedades, los métodos son referenciados de la
misma manera. Primero el nombre del objeto, un punto, y el nombre del método. En los
dos anteriores ejemplos “close” and “write” son los métodos a ejecutar por los objetos
“window” y “document” respectivamente.

EJEMPLO 4.8. Creando funciones como métodos. Fuente: tomado y adaptado de

Quigley (2010)

<html>
<head><title>Creando Metodos</title>
<script type= "text/javascript">
var toy = new Object(); // Crea un objeto

[Link] = "Lego"; // Asigna propiedades a los objetos

[Link] = "rojo";
[Link] = "rectangular";
[Link]=printObject; /* El nombre de la función es asignada como propiedad de un
objeto*/
function printObject(){
[Link]("<b>El juguete es un: " + [Link] + ".<br>");
[Link]("Este es un: " + [Link] + " " + [Link] + ".<br />");
}
</script>
</head>
<body>
<script type = "text/javascript">
[Link](); //El método es llamado [Link]="azul";
[Link]();
</script>
</body>
</html>

En el anterior programa, se define un objeto llamado “toy” con sus propiedades, entre
ellas la propiedad “display” a la cual se le asigna el nombre de una función llamada
“printObject”. Posteriormente para ser invocada esta función solo se hace referencia al
atributo “[Link]()”. Esto último, la asignación de una función a una propiedad de un
objeto, es lo que en JavaScript se llama método.

Clases

Segun Quigley (2010), JavaScript no define clases como lo hace por ejemplo Java o
C++, pero éste usa un mecanismo para efectuar la misma tarea de las clases. En el
siguiente ejemplo podemos entender la anterior afirmación:

<script type="text/javascript">
function Book(){ // Crea una clase llamada
Book
[Link] = "The White Tiger"; // Propiedades
[Link] = "Aravind Adiga";
}
var bookObj = new Book; // Crea un objeto book llamado
bookObj
alert([Link] + " by " + [Link]);
</script>

En el anterior bloque de programa se crea una función llamada “Book”, a la cual se le

definen dos atributos “title” y “autor”. Al definir los atributos dentro de la función se hace
con la palabra reservada “this” la cual sirve de referencia al objeto que se está creando.

Posteriormente, se crea un objeto basado en las características definidas en la función;

de esta manera el nuevo objeto “bookObj” hereda los atributos definidos en la función.

Figura 7. Describiendo clases en JavaScript

Fuente: Tomado de Quigley (2010)

En la Figura 8, se muestra que los objetos “cat” y “dog” pertenecen a una misma clase
la cual es llamada “pet”, por lo tanto, heredan todas las características o atributos de
esta clase.

Algunos objetos predefinidos en JavaScript

JavaScript tiene objetos que vienen ya con el lenguaje de programación por ejemplo
aquellos que permiten manipular la fecha, funciones matemáticas, manipulación de
caracteres y otros.

Los objetos tienen asociados propiedades y métodos. Recuerde que los métodos son
como las acciones que se aplican sobre estos objetos. A continuación se listan los
objetos:

1. Array: Con el constructor Array() se pueden crear nuevos arreglos.

Con los métodos de este objeto se pueden manipular los arreglos efectuando
operaciones como concatenación, unión, ordenar los elementos de un arreglo en
orden alfabético y numérico, etc.
2. Date: se pueden hacer operaciones con fechas tales como retornar el
día y el mes de una fecha determinada, el día correspondiente (Sábado, Domingo,
etc), el número de mes, etc.
3. Math: mediante el uso de métodos permite efectuar
operaciones aritméticas
complejas tal como hallar la raíz cuadrada de un número, generar números
aleatoriamente o hacer uso de las funciones trigonométricas.
4. String: Mediante el constructor string() se pueden crear objetos
tipo string los cuales se pueden asignar a una variable. De igual manera con los
métodos se pueden efectuar operaciones como encontrar un carácter, en una palabra,
pasar una letra minúscula a mayúscula, cambiar el tamaño de la letra, etc.
5. Number: Con los métodos de esto objeto se pueden formatear
los valores numéricos con el fin de ser desplegados.
6. Boolean: convierte un valor non-booleano a un valor booleano
7. Function: permite crear una función como objeto

Cada uno de los anteriores objetos tiene propiedades las cuales pueden ser accesadas
en un programa de JavaScript. Durante los temas abarcados durante los tres módulos
se han visto por ejemplo el uso del objeto string, función, y array. No es competencia
de este modulo profundizar sobre estos temas, sin embargo a continuación podemos
ver un ejemplo pequeño que hace uso del objeto Math.

EJEMPLO 4.9. Uso del objeto Math. Fuente: Tomado y modificado de, Quigley (2010)

<html>
<head><title>El objeto Math</title></head>
<body>
<h2>Redondeo de numeros</h2>
<p>
<h3>
<script type="text/javascript"> var num=99.6;
[Link]("<I>El número a redondear es: ", num, "</I><br /><br />");
[Link]("El <I>[Link]</I> redondeando hacia abajo: "
+ [Link](num) + "<br />");
[Link]("El <I>[Link]</I>redondeando hacia arriba: " + [Link](num) +"<br
/>");
[Link]("El <I>[Link]</I> El method redondea a:\ el entero más cerca: " +
[Link](num) + "<br />");
</script>
</h3>
</body>
</html>
En el anterior programa se pudo ver el uso del objeto Math a través de sus métodos
floor, ceil, y round. El primero redondea el número al entero mayor, el Segundo,
redondea al entero menor. El método “round” redondea al entero más cercano. Vea los
resultados con el fin de aclarar lo antes dicho.
5 Comparación entre Java y JavaScript

Tal como nos pudimos dar cuenta a través de este documento, Java y JavaScript son
dos lenguajes totalmente diferentes, el primero puede crear aplicaciones por sí solo,
mientras que JavaScript tiene que estar embebido dentro de un HTML para hacerlo.

Otra cosa que se pudo observar es que JavaScript maneja conceptos más sencillos, tal
vez porque es un programa que resuelve situaciones específicas. Por el contrario, Java
por ser un lenguaje de propósito general maneja conceptos y terminología propios de
una plataforma robusta.

Java es un lenguaje completamente orientado a objetos, maneja los conceptos de

objetos, clases, y métodos completamente. Por otro lado, JavaScript utiliza
mecanismos para alcanzar esta funcionalidad, tal es el caso de la definición de clases
como funciones asignadas a variables, aunque JavaScript es basado en objetos.

Java es un lenguaje que necesita ser compilado para producir un programa ejecutable.
Por otra parte, JavaScript es interpretado para lo que necesita un intérprete, en este
caso el navegador de internet.

Java y JavaScript se pueden comparar en el sentido que, el primero puede crear

pequeñas piezas de código (applets) las cuales son ejecutadas por un navegador. Por
otro lado el código de JavaScript esta embebido dentro de un programa html el cual es
interpretado y ejecutado por el navegador.

Se pueden comparar por su popularidad, Java es muy conocido en el ámbito de

desarrollos de aplicaciones, de igual forma JavaScript es famoso creando dinamismo
en casi toda página web.
Se continuo con los temas de algoritmia y programación, donde se hizo un repaso
sobre los conceptos relacionados con los algoritmos resaltando sus características
principales (precisión, secuencia, finito) y su estructura básica (datos, instrucciones,
estructuras de control). Adicionalmente, se reforzaron los conceptos de tipos de
datos vistos en el Módulo 1. Seguidamente, se continuó con el uso de Java y
JavaScript dando más elementos de estos lenguajes que le permitieran al estudioso,
desarrollar algoritmos de mediana complejidad. Para ello se vieron las estructuras de
control, tales como la secuencial, condicional, y repetitiva.

Para finalizar, en el presente módulo se abordó el tema de la programación

estructurada y sus principales características como son diseño top Down, programación
modular y codificación modular. De igual manera se continuó con el uso de Java y Java
Script los cuales usan la programación estructurada. Tomando como base los
lenguajes de programación antes mencionados se expusieron los temas relacionados
con métodos y funciones. Adicionalmente se proveyó el concepto de variables de
ambiente y su uso en un lenguaje de programación.
Glosario

Applets. Se puede decir que es un programa pequeño hecho en Java y que por sí
solo no puede ejecutarse. Este es ejecutado mediante un navegador como lo es el
caso de Google.

MVC (Model-View-Control): Modelo Vista Controlador, este tipo de arquitectura para el

desarrollo de sistemas de información se divide en tres capas, la primera; el modelo,
contiene todos los datos y la lógica del negocio, la segunda; la vista, provee la
presentación visual, pantallazos, la tercera; el controlador, define el comportamiento
del sistema al enviar el usuario la opción deseada al modelo.

Recursividad. Cuando una función se llama a sí misma, esta acción es llamada

recursividad.

Particionar. Se basa en el principio “divide y conquistarás”. Por ejemplo, se puede

decir que un programa se particiona o divide en varias partes o módulos.

Depuración. Corregir errores dentro de un programa.

Void. Es un tipo de método en Java, el cual no retorna valores.

Invocar: Se dice invocar en lugar de decir llamar, se usa por ejemplo para decir,
invocar o llamar el método; invocar o llamar la función.

ReturnType: Tipo de valor que el método retorna

Parámetros formales: Son los valores de entrada al definir un método en Java

Parámetros actuales: Valores dados al hacer el llamado de un método en Java

Double. En este contexto, se refiere a datos de doble precisión

Doble precisión. Cuando se requiere manejar números que tienen parte decimal es
necesario definirlos como Doble precisión de punto flotante para que Java pueda
almacenar el número de forma completa.

Consola: Se refiere a la pantalla del computador

Variables de entorno: son variables innatas del sistema operativo. Por ejemplo, la
fecha y la hora del computador son variables de entorno.

Clases: Son como un témplate o un plano el cual describe las propiedades y

comportamientos de un objeto. De esta manera es más fácil definir objetos que tengan
las mismas características dentro de una misma clase. Por ejemplo, se puede hablar
de una clase “Alumno”, donde se definen sus propiedades y métodos, por consiguiente
se pueden crear tantos alumnos como sean necesarios utilizando la clase como
témplate. Otra definición: es como la conceptualización de una entidad del mundo real
o abstracto la cual requiere atributos y métodos.

Métodos: Son las operaciones/servicios que se realizan sobre el objeto y que

determinan su comportamiento. Este término particularmente en Java se refiere a
subrutinas que pueden ser llamadas dentro de un programa para ejecutar una tarea
específica, por ejemplo, printIn() and print(). Los métodos también pueden ser definidos
por el usuario ya que se implementan mediante funciones. Por ejemplo, en la clase
“Alumno” se puede definir un método que calcule el promedio de un estudiante.

Atributos: Son las características que posee un objeto y que lo hacen pertenecer a
una clase. Por ejemplo, en la clase “Alumno”, sus atributos pueden ser “nombre”,
“apellidos”, e “identificación”.

Instancias: Son ocurrencias de una entidad o una clase, por ejemplo, en la clase
“Alumno” cuyos atributos son “nombre”, “apellidos”, e “identificación”, dos instancias
pueden ser: “Manuela, Ramírez, 99.999.999” y “Pepe, Pérez, 88.888.888”.
Generalizando se puede definir una instancia como un elemento que pertenece a una
clase y que está integrado por sus atributos y métodos.

Bibliografía
 Carradeguas, N. (2014). Lista de las variables de entorno de Windows y usos
prácticos.

Ed.). Boston, MA: Cengage Learning.

Friesen, J. (2011). Beginning Java 7. New York: Apress.

Goodman, D., Morrison M., Novitski, P. & Gustaff, T. (2010). JavaScript Bible.
[Link]

Joyanes Aguilar, L. (2006). Introducción a la Ciencia de la Computación y a la

Programación. Recuperado de, [Link]

[Link]/bcv/guide/capitulo/[Link]

Malik, D. (2010). Java Programming: from problem analysis to program design,

(4a.)
Molina, M. (2006). Programación en Lenguajes Estructurados. Programación
Estructurada (1ª. Ed., Cap.5). [Link]: McGraw-Hill. Recuperado de,
[Link]

Nixon, R. (2012). PHP, MySQL, JavaScript, & CSS (2ª. Ed.), pp.318-320.
Sebastopol, California, [Link].: O’Reilly Media Inc.

Oracle. (2014). The Java Tutorials. Recuperado de,

Peralta Murua, L. (s.f). Análisis de Lenguaje. Técnicas de Diseño (Cap.6).

Recuperado de, [Link]

Programming Fundamentals (7a. Ed.), cap.8-12. Indianapolis, [Link].: Wiley

Publishing Inc.

Quigley, Ellie (2010). JavaScript by Examples, (2ª Ed). [Link]: Pearson

Education, Inc. Recuperado de, [Link] [Link]

Universidad Nacional de la Plata. (2003). Programación Estructurada (Cap.5).

Recuperado de,
[Link] -
Programacion%[Link]