Como Lo Hago » Programacion

Cómo hacer un gadget en Windows 7

Cri — Tue, 10 Aug 2010 02:22:32 +0000

Hola amigos de Cómo Lo Hago, tratando de sorprenderlos día a día nos empeñamos en poder crear nuevos tutoriales y ayudarlos en adquirir un mayor conocimiento como también desenvolverse dentro de un nuevo tipo de desarrollo. Esta vez será la ocasión de crear un Gadget el cual nos puede servir para una infinidad de cosas dependiendo del uso que le queramos dar, en este caso veremos como hacer uno con alimentacion RSS de los tutoriales que se hacen en CómoLoHago. Partiendo por una cosa, es muy importante recalcar que no hay que ser programador para poder realizar este tuto, pero sí tener harta paciencia para darle al clavo. Los invito a seguir en este entretenido tuto como siempre despues del salto…

Cómo hacer un gadget en Windows 7

1. ¿Qué necesitamos?

Sistema operativo Windows 7
Aprender un poco de HTML + CSS. Para esto puede recurrir a los siguientes tutoriales

2. ¿Cómo lo hago?

1. Manos a la obra, primero a buscar donde tenemos nuestros Gadgets los cuales se encontrarán siempre por default en Archivos de programa>Windows Sidebar>Gadgets. Una vez ubicados en esta carpeta procederemos a crear la carpta contenedora de nuestro futuro Gadget por desarrollar. Es muy importante que la extensión del nombre sea así:

NOMBREDEMIGADGET.Gadget

2. Una vez creada nuestra carpeta contenedora necesitaremos algunos archivos indispensables para poder personalisar y a la vez desarrollar:

MiGadget.html: Contiene el código principal para los ajustes de color, fondo, letras, links, feeders, etc.

ComoLoHago mi primer gadget

ComoLoHago v1.0

Settings.html: Contiene el código para los ajustes de nuestro Gadget.

Aqui agregan su contenido

MiGadget.js: Contiene el código especial para poder tener ajustes en nuestro Gadget.

// Importantisimo para poder tener los ajustes de nuestro Gadget

System.Gadget.settingsUI = “Settings.html”;

System.Gadget.onSettingsClosing = SettingsClosing;

Gadget.xml: Contiene el autor, nombre, descripción, ícono, logo. En sí es lo necesario para aparecer en el menú para seleccionar el Gadget.

CómoLoHago – Novedades

1.0

© CómoLoHago 2010

Novedades acerca de tutoriales nuevos en tu escritorio

true

Full

2. La flecha blanca indica el ícono que aparecerá en el menú de Gadgets. Este ícono (icono.png) se direcciona desde nuestro archivo XML, en este caso Gadget.xml. También podemos agregar otra imagen para cuando arrastremos nuestro Gadget al escritorio (imagenarrastrada.png).

3. Finalmente nos podemos dar cuenta que nuestro Gadget va adquiriendo la forma que le damos con CSS y HTML ademas de las programaciones que cada uno le dé en javascript.

Para poder mostrar el contenido RSS, tuve que recurrir a la página http://rssxpress.ukoln.ac.uk/lite/include/?t=1 para obtener el script feeder el cual va inserto en MiGadget.html:

Espero les haya gustado, les motive para hacer sus propias creaciones y así poder compartirlas con los demas. Me despido

Como siempre exclusivamente ha sido:

Staff CLH

Cómo generar números aleatorios en C

Jorge Nitales — Wed, 23 Jun 2010 05:14:10 +0000

Quizás recuerden hace algún tiempo que el buen Xaba Daba Du, nos mostró como generar números aleatorios en PHP. Ésta vez y por petición expresa de nadie de millones de personas, les traemos lo mismo, pero ésta vez en otro lenguaje, el siempre presente y nunca querido C.

Para ver Cómo lo Hago, vamos después del salto.

Cómo generar números aleatorios en C

¿Qué necesitamos?

Un editor de lenguaje C, tipo Borland C++.

¿Cómo Lo Hago?

1.- Primero explicaremos algunos conceptos:

En C, existe una función llamada rand(), que genera números aleatorios. El problema que tiene esta función es que siempre que reinicies el programa, aparecerán los mismos números.

Para evitar esto, hay que darle un número “semilla”, el cual operará como base para la generación de la secuencia de números. El problema con esto, es que si le damos un número fijo, volvemos al problema anterior, ya que siempre utilizará la misma base definida y por ende la secuencia será la misma.

Entonces, lo que necesitamos es darle un número “semilla” dinámico, esto es, que vaya cambiando cada vez que ejecutemos el programa.

Sabiendo esto, la función que da la semilla a rand() es srand(), que recibe como parámetro (lo que va entre los paréntesis) el número semilla, que en este caso, será la hora del sistema en segundos. Así, a menos que el programa se ejecute 2 o más veces en menos de un segundo, los números cambiarán.

La función para saber la hora actual del sistema es time(NULL).

Sabiendo esto, vamos al código. Haremos un generador de números aleatorios, donde la cantidad de estos, la decidirá el usuario, ingresando esta cantidad por teclado.

#include  // libreria basica para entrada y salida
#include // libreria para el uso de rand()
#include  // libreria para el uso de getch()
#include   // libreria para el uso de time()
void main( )
{
     // Declaracion de variables
     int numero,cantidad,contador;
     int hora = time(NULL);

     // Semilla de rand();
     srand(hora);

     /* Recogemos por teclado la cantidad de
        numeros que quiere el usuario */

        printf("Ingrese la cantidad de numeros
        aleatorios que desea generar\n");
        scanf("%d",&cantidad);

        /* Generamos un ciclo que se repite la cantidad
           de veces indicada. En cada vuelta del ciclo se
           genera y se imprime un numero aleatorio. */

        for(contador = 0; contador
A pesar de que esta explicado con comentarios, desmenucemos un poco.
#include  // libreria basica para entrada y salida
#include // libreria para el uso de rand( )
#include  // libreria para el uso de getch( )
#include   // libreria para el uso de time( )

Estos cuatro includes, son para llamar a las librerías necesarias para ejecutar el programa. La librería conio.h, no es necesaria para que el programa funcione, solo la llamamos pasar usar la función getch( ) y generar una pausa en el programa. Con esto podremos ver el resultado por pantalla antes que se cierre el programa.
// Declaración de variables

int numero,cantidad,contador;
int hora = time(NULL);

Acá declaramos el tipo y que variables utilizaremos. Definimos 4 variables de tipo int (entero), 3 de ellos sin inicializar (es decir, sin valor inicial) y una de ella inicializada.
Las 3 sin valor inicial, serán el número aleatorio que se genera (número). La cantidad de números aleatorios que se generarán (cantidad) y un contador para crear un ciclo.
// Recogemos por teclado la cantidad de numeros que quiere el usuario

printf("Ingrese la cantidad de numeros aleatorios que desea generar\n");
scanf("%d",&cantidad);
Mostramos por pantalla el mensaje para el usuario y asignamos el valor que se ingrese, a la variable cantidad usando el símbolo & (ampersand).
// Generamos un ciclo que se repite la cantidad de veces indicada
// en cada vuelta del ciclo se genera y se imprime un numero aleatorio.

for(contador = 0; contador < cantidad; contador++)
{
      numero = rand()%100;
      printf("%d ", numero);
}

getch();     // genera una pausa en la ejecucion del programa

}

Aquí es donde generamos el ciclo, con el bucle for. Tenemos 3 parámetros separados por ; (punto y coma), en el primero inicializamos la variable contador con el valor cero. En la segunda ponemos la condición que se debe cumplir para terminar el ciclo, en este caso decimos que el ciclo se repita siempre que contador sea menor que cantidad. Ojo, aquí decimos que sea menor que el número porque el valor inicial es cero y empezamos a contar desde cero y no de uno.
Al final aplicamos un getch( ) para detener el programa y lograr ver los resultados.
Les invito a realizarlo y hacer sus aportes. Cualquier consulta o comentario que puedan tener, no duden en dejarnos unas líneas a continuación. Como siempre, este tutorial ha sido:



Por ahora,
Me despido.
Staff Cómo Lo Hago

Como Hacer una Macro en Excel

Dexter — Thu, 03 Jun 2010 22:51:01 +0000

Actualmente me encuentro realizando mi tercera práctica profesional en la cual me han dado como tarea la de realizar un resumen anual de unos servicios de enlaces de internet y telefonía IP. Al ser anual estamos hablando de al menos unos 4000, si cuatro mil, datos en Excel, los cuales se deben filtrar, ordenar y hacer cálculos respectivos.

Para que este proceso no se haga tan tedioso es que he recurrido a una herramienta que muchos han escuchado pero creo estar en la razón al decir que pocos saben utilizar.

Estamos hablando de las Macros.

Una pequeña introducción

Cuando hablamos de una Macro en Excel nos referimos a un lenguaje de programación orientado a aplicaciones. En este caso particular, se utiliza VBA (Visual Basic for Applications) el cual es un lenguaje de programación desarrollado por Microsoft. Excel, al igual que los otros programas de Microsoft Office incluyen el lenguaje VBA.

Imaginen un Robot que conoce todo sobre Excel. Este robot puede leer instrucciones y operar sobre Excel de manera rápida y precisa. Simplemente escribimos un lenguaje que este robot comprenda, para que luego el robot haga el trabajo sucio mientras nos relajamos y tomamos una limonada. Eso es justamente VBA. Un lenguaje en código para robots. Pero Ojo, Excel no viene ni con un robot ni con la limonada. =)

La combinación entre la generación de un código VBA y su posterior ejecución en Excel es lo que se llama una Macro. A fin de cuentas una Macro es un programa el cual contiene un trozo de código de manera que podemos automatizar procesos que el realizarlos a mano nos pueden tomar mucho tiempo.

La palabra Macro proviene del griego makros que significa grande-lo cual podría describir el tipo de pago que podrías recibir por convertirte en un experto en programación de Macros.

Otra cosa que se debe tener en cuenta es que VBA no es lo mismo que VB (Visual Basic), ya que VB es un lenguaje de programación que permite crear programas auto ejecutables (conocidos como archivos EXE). A pesar de que VBA y VB tienen mucho en común, son dos cosas distintas.

La idea de crear una Macro es la de automatizar tareas que son repetitivas o que deben ser desarrollas con frecuencia. Por ejemplo, preparar reportes mensuales de manera que todos los meses podrás presentarle a tu jefe reportes con un mismo formato. Él quedará impresionado por tu consistencia y la gran calidad de tu trabajo, e incluso te promoverá a un nuevo cargo al cual no estás capacitado!!

¡Comencemos!

Lo primero a realizar es hacer visible la lengüeta de “Programador”. Por defecto esta lengüeta viene oculta en Excel 2007.

Iremos a Inicio y daremos click en “Opciones de Excel”.

La primera opción es “Más Frecuente” y dentro de ella debemos marcar la opción de “Mostrar Ficha Programador en la cinta de Opciones”.

Acá podemos observar como la hemos marcado, que en este caso es la tercera opción.

Con ello la lengüeta “Programador” está visible y podemos comenzar a utilizar Macros en nuestro libro de Excel.

Lo que cubriremos en este instructivo es la grabación de Macros. Esto es muy parecido a la grabación de acciones que alguna vez cubrimos en un tutorial de Photoshop.

Grabando una Macro

Seleccionamos una celda; cualquier celda servirá.
En la lengüeta de programador damos click en “grabar Macro”.

Con ello nos aparece la ventana “Grabar Macro”.

En “Nombre de la macro” pondremos un nombre representativo (Ojo no puede llevar espacios por lo que si desean pueden usar guión bajo “_” para poner espacios entre palabras), en “método abreviado” pondremos una combinación de teclas como acceso directo (por defecto es CTRL +”algo ”, en mi caso utilizá la tecla Shift o Mayúscula más la tecla N), en “Guardar macro en: ” dejamos igual como está, y en “Descripción” anotamos justamente una descripción de lo que hará la macro.

Damos click en “Aceptar ”. Con ello la grabación de la Macro comienza, por lo tanto todos los movimientos que realicemos dentro del libro de Excel serán grabados.

Anotaremos nuestro nombre en una celda
Hacemos click en la celda bajo el nombre y anotaremos la siguiente fórmula: =AHORA()

Esta fórmula muestra la fecha y hora actual.

Seleccionamos la celda que contiene la fórmula y la copiaremos (Con CTRL+C o en la lengüeta Inicio -> Copiar)

En la lengüeta Inicio está el botón Pegar. Si damos Click en la flecha bajo el ícono verán que aparecen más opciones. Elegimos la opción “Pegar Valores”.

Esto convierte la fórmula a su valor correspondiente.

Seleccionamos ambas celdas, osea la celda con la fecha y la celda con el nombre.
Aplicamos a ambas celdas un formato, por ejemplo “Negrita ” y en el tamaño de la letra ponemos “16”.

Vamos a la lengüeta Programador y detenemos la grabación de la Macro con el botón respectivo.

¡Felicitaciones! Acabas de grabar tu primera Macro. Esta es una buena oportunidad para llamar a tu madre y contarle las buenas noticias.

Ahora solo nos falta correr la Macro y ver los resultados. Para ello iremos a una nueva hoja de cálculo. Seleccionamos la celda A1.

En la lengüeta de Programador hacemos click en Macros con lo cual se nos abre la ventana que administra las Macros.

Elegimos nuestra Macro, que en este caso es única y le damos click al botón ejecutar. También si prefieren pueden seleccionar la celda A1 y simplemente utilizar la combinación de teclas que configuramos, en este caso Ctrl+Shift+N.

Como observarán se ha pegado la información y se le ha dado el formato de letra en negrita y tamaño 16. Con un simple click o combinación de teclas sin necesidad de anotar el nombre, aplicar una fórmula, copiarla, pegarla, seleccionar ambas celdas y darles formato.

Ahora analicemos el código o lenguaje que se ha grabado.

Para ello podemos dar click en el botón “Visual Basic” de la lengüeta Programador o utilizar la combinación de teclas ALT+F11.

Con ello se nos abre el editor de VBA.

Damos click en el símbolo “+” de “Módulos” de manera de ampliar el árbol de módulos y con ello nos aparecerá “módulo 1” tal como se observa en la fotografía.

Con ello se abre el módulo y podemos obsevar el código que se ha generado.

Los comentarios se pueden anotar anteponiendo el símbolo de apóstrofe (’).

En este caso para explicar el código dejaré comentarios en cada línea.

Sub NombreyTiempo()

‘ NombreyTiempo Macro

‘ Esta Macro anota mi nombre y el tiempo

‘ Acceso directo: Ctrl+Mayús+N

Range(“A1″).Select ‘Se selecciona la celda A1

ActiveCell.FormulaR1C1 = “Dexter” ‘En ella se insertará Dexter

Range(“A2″).Select ‘Se selecciona la celda A2

ActiveCell.FormulaR1C1 = “=NOW()” ‘Se aplica la fórmula Ahora() que en VBA se anota por su nombre en inglés NOW()

Range(“A2″).Select ‘Nuevamente seleccionamos la celda A2

Selection.Copy ‘La selección se copia

Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _

:=False, Transpose:=False ‘Se vuelve a pegar pero como pegado especial, en este caso como Valor

Range(“A1:A2″).Select ‘Tomamos el Rango desde la celda A1 a la A2

Application.CutCopyMode = False ‘Esta linea no hace nada en particular ya que no estamos ni copiando ni pegando

With Selection.Font ‘Con la seleccion antes hecha, entramos a la configuracion de fuentes

.Name = “Calibri” ‘Se selecciona el tipo de fuente, en este caso Calibri

.Size = 16 ‘Se selecciona el tamaño de fuente, en este caso 16

.Strikethrough = False ‘los siguientes códigos representan otros parámetros que no son necesarios analizar

.Superscript = False

.Subscript = False

.OutlineFont = False

.Shadow = False

.Underline = xlUnderlineStyleNone

.ThemeColor = xlThemeColorLight1

.TintAndShade = 0

.ThemeFont = xlThemeFontMinor

End With

Selection.Font.Bold = True ‘Con la misma seleccion anterior (celdas A1 y A2), aplicamos el formato de Negrita

End Sub

Este código lo pueden copiar y pegar en el editor de Macros de Excel, correrlo y funcionará correctamente.

Bueno con esto me despido, espero que les haya gustado.

Y como siempre, este tutorial ha sido

Felices proyectos!!!!!

Para cualquier consulta no duden en escribirnos.

Estaremos felices de responderles y ayudarles en todo lo posible.

Cómo Lo Hago, si se puede, te lo enseñamos.

Staff CLH

Cómo aprender a programar y no morir en el intento – Parte 11

Xabadu — Tue, 27 Apr 2010 13:28:37 +0000

Bueno, bueno, bueno. Nos demoramos un poco (casi 13 meses), pero lo prometido es deuda: Volvemos con la saga que intenta guiarlos por el largo y complejo camino de la programación.

¿Por qué nos demoramos tanto? Es una buena pregunta, gracias por hacerla -> !. La verdad es que una vez que terminamos la parte 10 y estaban definidos los contenidos para continuar nos dimos cuenta que estábamos entrando en temas bastante avanzados, lo que se alejaba de la intención inicial de estas guías, por lo que decidimos pausar el tema y reconsiderar como seguir. Lamentablemente hubo otros temas que fue necesario cubrir en la cola de peticiones (nuestro buzón explota cada día con todo lo que llega) y el tiempo fue pasando hasta que llegamos a la fecha.

Pero ha llegado el día de continuar y hemos reestructurado el modelo de esta saga para que tengamos una gran cantidad de números por delante. ¿Cómo? se preguntarán. Bastante simple: En las primeras 10 partes estuvimos viendo desde los conceptos más básicos de antes de programar hasta la base de desarrollo estructurado, por lo que empezando en este número, veremos algo completamente nuevo (probablemente hasta el número 20) para entregar las nociones necesarias y luego continuaremos con otro enfoque. Lo sabemos, es enredado, pero con el tiempo se irá entendiendo, confíen en nosotros

Así que sin más introducción, los invitamos a seguirnos después del salto, en esta edición número 11 de “Cómo aprender a programar y no morir en el intento”, en donde empezaremos a cubrir un nuevo paradigma de desarrollo: Programación orientada a objetos.

Cómo aprender a programar y no morir en el intento – Parte 11

Nota: Si bien hoy comenzamos a trabajar con un paradigma nuevo, siempre recomendamos leer las partes anteriores de esta saga, las cuales pueden ser encontradas en nuestra categoría de Programación.

Pues bien, tal como anunciábamos, hoy comenzamos con programación orientada a objetos. Esta parte de la guía será mucho más conceptual que técnica, ya que hay varios contenidos que es bueno que aclaremos para establecer una base sólida y poder trabajar de mejor manera a futuro. Así que sin más, vamos:

Contenidos:

Introducción a la programación orientada a objetos.
Programación orientada a objetos vs Programación estructurada.
Hola, soy un objeto.
Clases.
Métodos.

Así que sin más, vamos, manos a la obra:

1.- Introducción a la programación orientada a objetos:

La programación orientada a objetos (o POO para los más amigos), es un paradigma de desarrollo definido y utilizado por una serie de lenguajes de programación que busca afrontar el desarrollo de aplicaciones desde un enfoque distinto al estructurado (que hemos visto hasta la fecha), mediante la definición y uso de, valga la redundancia, objetos que operen bajo un prisma similar a como vemos, reconocemos y actuamos las situaciones de la vida real.

A la fecha se ha convertido en el paradigma preferido por los principales lenguajes de programación, debido a una serie de ventajas (que iremos viendo a medida que avancemos) que permiten que el desarrollo sea más simple, seguro y completo. Si bien la transición desde el inicio a esta parte puede ser un poco compleja, especialmente por el cambio en el enfoque que se hace, una vez que las bases se entienden y dominan se puede comprender que es bastante simple.

Solo como referencia, algunos lenguajes que trabajan bajo este paradigma:

C++.
Java.
PHP (Desde la versión 5)
Ruby.
Objective C.
Python.

Iremos viendo nueva información en cada parte de esta nueva etapa con el fin de ir aprendiendo un poco más y no extendernos en demasía en un solo número.

2.- Programación orientada a objetos vs Programación estructurada:

Es inevitable que al comenzar a aprender un nuevo paradigma, empiecen las comparaciones y diferenciaciones de lo que ya se sabe. Y en este caso no será ninguna diferencia.

A la fecha todo lo que hemos visto en esta saga es relacionado al desarrollo estructurado, en el cual basicamente nos dedicamos a escribir programas con una lógica directa en base a una “plantilla”, la cual contiene código que es compilado y ejecutado desde un inicio hasta el final. Esta lógica opera bajo el uso de funciones y procesos que operan sobre una serie de datos de entrada y que finalmente nos despliegan resultados o salidas que dependen de cada tarea que se realizó. Bastante simple, de arriba a abajo, de principio a final.

Por otro lado, en la POO, cambiamos el enfoque y comenzamos a hablar de objetos y clases. Si bien seguimos utilizando elementos clásicos de la programación estructurada, o bien de la programación propiamente tal como variables, ciclos e iteraciones, la base se rige por estos 2 elementos y es así como nuestras aplicaciones operan, lo que podremos ir viendo de forma clara a medida que vayamos desarrollando ejemplos.

Si hicieramos un paralelo entre ambos paradigmas, algo que probablemente no sea correcto, pero a modo de ejemplo quizás nos aclare más los conceptos, si en la programación estructurada en ocasiones trabajamos con librerías, las cuales contienen funciones, en la programación orientada a objetos trabajamos con clases, las cuales a su vez contienen métodos, y estos operan sobre cada uno de los objetos que declaremos. Como indicábamos, lo anterior solo sirve para hacer un paralelo, ya que en lo real varía un poco.

No obstante, a medida que nos adentremos más en el tema, iremos viendo una serie de características en las que podremos ir estableciendo comparaciones y que finalmente nos servirá para entender de mejor manera todo esto.

Sin embargo, independiente de cuantas comparaciones o definiciones veamos, siempre llegaremos a las 2 unidades base que mencionábamos antes y que comenzaremos a ver a continuación: Objetos y clases. A partir de esto, es posible ir escalando el conocimiento relacionado a la programación orientada a objetos, y eventualmente empezar a desarrollar de aquella forma.

3.- Hola, soy un objeto:

Y llegamos a la unidad básica que de ahora en adelante aparecerá en cada cosa que veamos y en cada ejemplo que codifiquemos: Los objetos.

Si entramos a la definición más purista del paradigma, es posible definir un objeto como todo lo que vemos en el mundo real. Desde una casa, hasta un perro o incluso una fruta, todo es reconocido de esta forma y como tal debe ser modelado para luego poder operar sobre el.

Los objetos son la base de la POO, tal como indica el mismo nombre, y por ende es necesario cambiar la forma en que modelamos, diseñamos y desarrollamos aplicaciones para ajustarnos a este nuevo enfoque. Desde el inicio más básico hasta lo más avanzado, siempre operaremos en torno a ellos y serán lo que construirán y definirán los distintos procesos que utilizaremos.

Un objeto es definido, y diferenciado de otros, por sus características o atributos, tal como lo vemos en la vida real. Por ejemplo, si tomamos dos casos arbitrarios que consideraríamos objetos en la vida real, como una persona y un auto, es posible ver que cada uno de ellos posee atributos que lo diferencian el uno del otro:

Persona – Sus atributos serían: Nombres, Apellidos, Edad, etc.
Auto – Sus atributos serían: Marca, color, patente, etc.

Si comparamos los ejemplos anteriores, sus atributos específicos son los que nos ayudan a diferenciar cuando hablamos de uno y cuando hablamos del otro. En el caso de la POO es exactamente lo mismo. Definimos objetos y los diferenciamos en base a sus atributos. Posteriormente, dependiendo del objeto que tratemos, operamos de acuerdo a sus características para ejecutar procesos y obtener resultados, tal como cualquier tipo de programación.

Como podemos ver, esta es una definición bastante básica, e intencionalmente ha sido así considerando que este es nuestro primer acercamiento al paradigma. A medida que vayamos avanzando iremos viendo otros detalles importantes. Pero no se preocupen, con esto por ahora podremos seguir avanzando sin problemas. La intención es que vayamos comprendiendo cada concepto desde su punto de vista más básico y de a poco interiorizarnos en temas más avanzados.

4.- Clases:

Hemos hablado de los objetos y ahora es momento de cubrir el otro punto base que habíamos indicado.

¿Por dónde partir? Por lo más básico.

En su definición más básica podemos decir que una clase es una plantilla que describe a un objeto. ¿Cómo lo describe? con 2 partes:

Sus características.
Su comportamiento.

La manera en que una clase describe las características de un objeto es mediante la definición de sus atributos. Si, exactamente los mismos atributos que mencionábamos más arriba que ayudan a diferenciar a un objeto de otro. Al definirlos se nos dice que son estos, y solamente estos, los atributos reconocidos para tal objeto y los que nos servirán como base para operar en nuestras aplicaciones.

Por otro lado, describe el comportamiento de un objeto mediante la definición de métodos, los cuales operan y ejecutan tareas sobre los atributos de un objeto en particular entregándonos resultados para su respectivo despliegue.

La estructura básica de una clase es como sigue:

Definición de la clase.
Definición de atributos.
Métodos.

Tan simple como eso. A medida que veamos ejemplos podremos ir desglosando cada una de esas partes para un análisis más detallado.

5.- Métodos:

Un método es una función, declarada en una clase, que tiene como fin operar sobre un objeto para ejecutar tareas sobre sus atributos y obtener resultados, ya sea para seguir operando, o bien para entregar una salida al sistema y desplegarla en pantalla al usuario de la aplicación.

Tal como cuando se definían funciones en el desarrollo estructurado, los métodos corresponden a un tipo de dato que debe coincidir con el resultado que retornan.

Por ej: Podemos definir un método de tipo int que se llame retornaEdad y que devuelva un entero que contiene la edad de un objeto de tipo persona. Si este método fue definido como entero, no puede devolver un tipo de dato distinto, debido a su definición inicial.

Todos los métodos que definamos deben devolver un tipo de dato que coincida con su definición, a excepción de los tipo void, que tal como en la programación estructurada, pueden no devolver nada.

También, al igual que en las funciones, los métodos pueden recibir parámetros que pueden ser utilizados en sus operaciones internas para producir resultados.

En una clase cualquiera, declararemos siempre como mínimo 2 tipos de métodos: 1 que crea el objeto (constructor – que veremos en el próximo número) y 1 o más que operen sobre el objeto creado.

Con esta definición de los métodos, daremos por concluida la parte 11 de Cómo aprender a programar y no morir en el intento. Sabemos que este número ha sido mucho más conceptual que técnico y práctico, pero tengan paciencia. Los conceptos explicados acá son necesarios de entender antes de empezar a meter mano de lleno, algo que haremos desde el próximo número cuando ya empecemos a codificar nuestra primera aplicación.

A contar de la parte 12 ya comenzaremos a operar bajo un modelo de una parte de conceptos y un ejemplo al final de cada número, con el fin de que vayamos soltando la mano y vayamos aplicando todo lo que veamos.

En la próxima edición de ‘Cómo aprender a programar y no morir en el intento’:

El Constructor (Y no hablamos de Bob).
Permisos.
Clase principal.
Creando nuestra primera aplicación en POO.

Por ahora, como siempre, les recordamos que este tutorial ha sido:

Cualquier duda o comentario que puedan tener, los invitamos a dejarnos unas líneas en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH

Cómo optimizar tu código en 10 pasos

Xabadu — Sun, 10 Jan 2010 22:10:05 +0000

Hace algún tiempo publicamos un artículo con tips sobre como optimizar nuestros sitios Web. En esa ocasión recalcamos el hecho de que hubo algunos puntos que se nos escaparon o que queríamos profundizar de mejor manera, por lo que probablemente haríamos una nueva edición en el futuro. Bueno, el momento ha llegado, aunque no precisamente continuando el mismo tema, si no que algo relacionado. Hoy les traemos una segunda parte enfocada netamente a código, compuesta de consejos y buenas prácticas que nunca están demás, especialmente en estos momentos que casi todo lo que vemos en Web envuelve, aunque sea en una pequeña parte, programación.

El detalle, como siempre, después del salto.

Cómo optimizar tu código en 10 pasos

Al no haber implementos necesarios (a excepción quizás de un editor Web), vamos de lleno al contenido:

El siguiente tutorial está compuesto de un conjunto de consejos y buenas prácticas a la hora de programar. A pesar de que está orientado a Web, algunos puntos son aplicables a otro tipo de lenguajes en los que se puede extrapolar.

1.- Reutilización de variables

En la programación, las variables en las que almacenamos datos tienen lo que llamamos un “ciclo de vida”: Desde su nacimiento (el momento en el que las declaramos) hasta su muerte (última línea en que han sido utilizadas), toman distintos valores y forman parte de una serie de procesos que nos llevan a obtener resultados.

Posterior a su último uso, estas variables permanecen sin prestar utilidad. A pesar de que muchos lenguajes tienen implementada una característica conocida como recolector de basura, el cual se encarga de desocupar o limpiar todas las áreas de memoria que se encuentran utilizadas pero inactivas, en muchas ocasiones esto no ocurre o existe un periodo durante la ejecución de un programa en que seguimos creando variables y vamos ocupando más y más áreas de memoria, lo que adicionalmente nos puede llevar a confusión con el nombre de las mismas.

Es por esto que es recomendable, si vemos que hemos dejado de utilizar una variable en particular, reutilizarla, siempre y cuando no afecte el código donde las usamos originalmente. Por ejemplo, en vez de usar esto:

i=0;
while(i<10)
{
    echo 'Hola mundo';
    i++;
}

j=0;
while(j<10)
{
    echo 'Adios!';
    j++;
}

Podemos utilizar esto, obteniendo el mismo resultado de manera más óptima:

i=0;
while(i<10)
{
    echo 'Hola mundo';
    i++;
}
while(i>0)
{
    echo 'Adios!';
    i--;
}

No solo reutilizamos la misma variable para ejecutar ámbas tareas, sino que a su vez optimizamos el código, mejorando la ejecución final.

Claramente es un ejemplo bastante básico, pero nos sirve para ilustrar el punto. A medida que nuestras aplicaciones van creciendo, necesitamos manipular una mayor cantidad de variables, por lo que puede volverse algo confuso de manejar. La reutilización nos sirve para tener un mejor control de lo que tenemos y al mismo tiempo nos permite hacer nuestro código mucho más simple.

2.- Nombrar como corresponde

Escribir código es de cierta forma contar una historia. Desde la declaración o nacimiento de las variables, hasta lo que hace cada una de ellas hasta el final, tenemos actos claros y definidos que permiten a cualquiera con conocimientos de programación poder seguir la historia del principio hasta el término. Y como tal, es importante tener consistencia en lo que escribimos, con respecto al nombre que le damos a las variables y funciones que utilizamos.

En lo anterior recalcamos un hecho muy importante: todo el código que escribamos será revisado por alguien. Ya sea otros programadores o bien nosotros mismos más adelante cuando queramos optimizar o reutilizar, siempre habrá alguien que deba hacer la traza del código y ver que hace cada cosa. Es por esto que es importante que mantengamos concordancia con respecto a los nombres y seguir una lógica que nos permita mantener un orden y claridad a futuro.

Por ejemplo, si recibimos los datos de un usuario a través de un formulario, es bueno que las variables a las que asignemos valores tengan un prefijo definido (por ejemplo usuario). De esta forma, cuando nos encontremos 30 líneas más abajo y necesitemos recurrir a ellas, ya sabremos bajo que estructura trabajamos y minimizaremos el margen de error.

Existen 2 convenciones definidas para nombrar elementos a la hora de programar, que si bien no es obligación usarlas, si pueden servir en demasía:

camelCase: En esta, la primera letra de cada palabra nueva lleva mayúscula, a excepción de la primera. Ej: $usuarioClave o function devuelveDatos.
underscore: En la cual cada palabra es separada por un underscore o guión bajo. Ej: $usuario_clave o function devuelve_datos.

Al programar somos libres de definir nuestras propias reglas para nombrar. No obstante, si estamos realizando trabajo colaborativo con otros programadores, es bueno utilizar alguna de las convenciones aceptadas, con el fin de estandarizar el trabajo y hacer todo más entendible para los demas. Lo importante es definir una estructura y un estándar que nos permita hacer más uniforme nuestro código y de esta forma hacerlo mucho más entendible.

3.- Agrupar el código

Si tomamos cualquier programa que hayamos escrito en el pasado, podremos apreciar que dentro de el, hay pequeñas secciones de código relacionadas entre sí por las funciones o tareas que realizan y que pueden o no tener directa relación con lo que viene líneas más abajo. Por un tema de orden, y para facilitar la documentación (punto que veremos más adelante) es bueno ir agrupando estas secciones y separarlas del resto del código con una línea en blanco. De esta forma, cada vez que necesitemos modificar una porción del programa será mucho más sencillo aislarlas y trabajar sobre ellas, ya que sabremos exactamente en donde empieza y donde termina esa parte del programa.

Por ejemplo, en un programa donde recibimos datos a través de un formulario, los insertamos en una base de datos y desplegamos el resultado al visitante:

$usuario_id = $_POST["usuario_id"];
$usuario_clave = $_POST["usuario_clave"];
$usuario_correo = $_POST["usuario_correo"];

$conexion = mysql_connect("localhost", "usuariobd", "clavebd");
mysql_select_db("mibd");

$consulta = "INSERT INTO usuarios VALUES('$usuario_id', '$usuario_clave',
'$usuario_correo')";
$resultado = mysql_query($consulta);

echo 'El usuario se ha creado satisfactoriamente';

En el código anterior podemos ver claramente que hace cada parte del programa: Primero recibimos los datos desde un formulario, luego hacemos la conexión y selección de base de datos, posterior a eso ejecutamos la consulta y finalmente mostramos el mensaje de éxito al usuario. Claro y limpio. Si al momento de ejecutar encontramos un error en una de las partes será mucho más sencillo volver a ella, ajustar y volver a probar.

4.- Indentar el código

Probablemente los 2 errores más clásicos que obtenemos al programar son la ausencia del punto y coma ( ; ) al terminar una sentencia y la falta de una llave de apertura o cierre en una iteración.

Sobre el primero no es mucho lo que se pueda hacer, más que fijarse, pero sobre el segundo una de las causas más comunes de la ocurrencia de este error es la falta de indentación del código, lo que muchas veces nos hace confundir una llave de otra iteración con la que estamos escribiendo actualmente, lo que puede llevar a 2 situaciones, o bien el código no se ejecuta bien, o la iteración se ejecuta como sub-sección de otra, lo que puede llevar a resultados aún peores.

Adicional a lo anterior, y tal como hemos remarcado en casi todos los puntos anteriores: orden. Siempre, y repito, siempre deberemos releer el código en algún momento y si bien cuando lo escribamos sabremos perfectamente que hace cada parte, no será así al tiempo después, por lo que mientras más ordenado y estructurado lo mantengamos, más sencillo será volver a trabajar sobre el.

Así que recapitulando, esto no es correcto:

while(i<10)
{
if(x == 'Letra equis')
{
echo 'Es la letra equis!';
}
else
{
echo 'No es la letra equis!';
}
}

Esto si es correcto:

while(i<10)
{
    if(x == 'Letra equis')
    {
        echo 'Es la letra equis!';
    }
    else
    {
        echo 'No es la letra equis!';
    }
}

De esta forma, a primera vista ya sabemos que el if y el else se ejecutarán dentro del while y cada vez que se repita la iteración, queda todo más ordenado y hasta estéticamente se ve mejor.

5.- No repetir, menos repetir y sobretodo no repetir

Este es un error bastante común que todos cometemos, especialmente cuando empezamos a programar y de forma inconsciente. Es natural que dentro de nuestros programas escribamos una, y otra, y otra vez el mismo código, o que bien en distintos programas de una misma aplicación (por ej. en distintas páginas PHP que forman parte de un mismo sistema) repitamos el mismo proceso o tengamos líneas repetidas.

La gracia de la programación es justamente evitar eso y nos entrega una serie de herramientas a tener en consideración. Tal como utilizamos ciclos para ejecutar una misma tarea varias veces, siempre es posible parametrizar un proceso. Solo bastante notar que es lo que estamos repitiendo, descubrir o definir el algoritmo, buscar los parámetros y formar una función a la que podamos llamar que haga la tarea independiente de los valores entregados.

Por otro lado, ¿tenemos un pié de página que se repite en cada página del sitio?, ¿un menú fijo que aparece en cada sección?. Hagamos uso de los includes y requires que PHP nos entrega, definamos funciones y plantillas que podamos reutilizar una y otra vez sin problemas. Una de las mayores bellezas de la programación es justamente esa: reutilizar. Podemos adaptar un mismo trozo de código para múltiples situaciones, haciendo la ejecución mucho más rápida y armónica.

6.- Orden en sentencias SQL

Esta es una costumbre personal que adopté cuando empecé a hacer mis primeras armas en programación Web, por lo que fue una agradable sorpresa ver que estaba considerado como una buena práctica, y por eso hoy la remarcamos acá.

Las sentencias SQL pueden llegar a ser largas, y por ende complejas de leer, especialmente si están insertas en una maraña de código PHP y/o HTML, por lo que debemos hacer lo posible para mantener un orden dentro de ellas y así hacerlas más fáciles de revisar en caso de errores. ¿A qué nos referimos con esto?, en particular a un punto: Poner en mayúscula las palabras reservadas de SQL. Esto nos permitirá siempre saber a primera vista que es lo que se hace y no nos llevará a confusión en caso de que alguna tabla o variable con la que estemos trabajando tenga un nombre similar a ellas. Por ejemplo:

SELECT auto_patente, auto_marca, auto_color, auto_id_propietario,
propietario_nombre, propietario_telefono FROM auto a,
propietario p WHERE auto_id_propietario = propietario_rut
ORDER BY auto_patente DESC

Es mucho más sencilla de leer que:

select auto_patente, auto_marca, auto_color, auto_id_propietario,
propietario_nombre, propietario_telefono from auto a,
propietario p where auto_id_propietario = propietario_rut
order by auto_patente desc

Cuando estemos revisando código en texto plano a las 3 AM buscando el fatídico error agradecerán destacar las palabras reservadas, las cuales si se fijan, establecen una separación entre las distintas partes de la consulta.

7.- No reinventar la rueda

Famosa frase que más de alguno ha escuchado anteriormente. Al programar, muchas veces tenemos la mala costumbre de querer hacer todo y confundimos la propiedad sobre una aplicación con generar el 100% del código. Nada más alejado de la realidad. Una de las gracias de esta gran red llamada Internet (¿Inter.. net?) es la cantidad de recursos que tenemos a nuestra disponibilidad, desde clases a trozos de código, es muy probable que muchas de las funcionalidades que necesitamos implementar ya hayan sido desarrolladas y puestas a disposición para utilizarlas, así que ¿por qué no aprovecharlas?.

No tiene nada de malo, y en realidad es muy ventajoso. No perdamos tiempo reinventado la rueda, y mejor veamos que podemos construir a partir de ella. No hay que tener dudas sobre incorporar librerías externas a nuestros desarrollos, siempre que respetemos cualquier licencia bajo las que hayan sido liberadas obviamente. Esto nos permitirá ahorrar un tiempo considerable que podemos dedicar a mejorar otras partes más críticas de la aplicación y mejorar los tiempos totales del desarrollo, que es algo que siempre debemos vigilar.

Lo más importante de recordar es que ser un buen programador no significa hacer todo desde cero, si no que tener la habilidad de identificar que integraciones podemos hacer con herramientas existentes y optimizar así el tiempo total de trabajo.

8.- Codificar genéricamente

Un par de puntos más atrás hablábamos justamente de no repetir código. Este punto va precisamente de la mano. En muchos desarrollos en los que trabajemos a través del tiempo, veremos que es necesario desarrollar funcionalidades similares a las que hemos trabajado en el pasado, por lo que un buen consejo es hacer desarrollos genéricos con el fin de poder reutilizarlos y ahorrar tiempo.

Por ejemplo, si inicialmente hacemos un sistema que incluya un registro de usuarios y en otro sistema necesitamos de lo mismo, ¿por qué no desarrollar una función genérica que reciba los parámetros necesarios para crear el usuario y así reutilizar bajo distintas situaciones?. De tal forma son muchos los casos en los que podremos ver que es posible reutilizar código de desarrollos anteriores, así que ahorremos tiempo y preparemos código estándar para utilizar.

9.- Revisar código de otros programadores

Hace algún tiempo tuve la fortuna de trabajar como ayudante en un curso de programación gráfica en la Universidad, lo que me dió la oportunidad de revisar código de otros desarrolladores todas las semanas, una experiencia a la que todos deberíamos someternos en algún momento.

Todos pensamos de forma distinta, y como tal, todos encontramos distintas soluciones o distintas formas de ejecutar una solución en particular, por lo que siempre es bueno revisar código de otros programadores, ya sea en librerías que descargamos o en sistemas que tengamos la posibilidad de ver. Eso nos ampliará la visión que tenemos sobre un lenguaje en particular y muchas veces nos permitirá ver formas más óptimas que las nuestras de codificar, lo que podremos incorporar a futuro.

De la mano con lo anterior, siempre es una buena práctica plantearse nuevos desafíos al momento de hacer un desarrollo comparado con lo que hemos hecho anteriormente, y revisando código de otros programadores es una buena forma de plantearselos.

10.- Documentar como un campeón

Uno de los puntos más importantes, sino el más importante, de esta guía. No podemos enfatizar lo suficiente la importancia de documentar el código y sobretodo de hacerlo correctamente.

Si hay un punto en común de casi todo lo que vimos hoy, es el de facilitar la revisión del código, ya sea para otros desarrolladores o para nosotros mismos a futuro, y la documentación es fundamental en aquella tarea. Comentar que hace cada función, que rol cumple una variable en especial o porque hicimos algo de cierta manera será clave cuando los recuerdos no sean tan frescos en el futuro y necesitemos hacer modificaciones sobre el código.

Adicionalmente a lo anterior, no es bueno exagerar. Si bien mientras más documentado esté el código será mejor, es bueno evitar comentarios obvios. Por ejemplo, si tenemos un ciclo que lo único que hace es mostrar el valor de una variable, no es necesario comentarlo, ya que a primera vista se puede ver sin problemas lo que hace.

Así que en resumen es eso, comentar, pero ser criterioso a la hora de hacerlo. A final de cuentas es por nuestro propio bien, así que estimemos de forma correcta cuando y como hacerlo.

Y con eso terminamos esta sencilla guía sobre 10 consejos para optimizar nuestro código, la que esperamos que sea de utilidad para todos aquellos dedicados a la programación o que buscan aprender más al respecto.

Como siempre, les recordamos que este tutorial ha sido:

Cualquier duda o comentario que puedan tener, los invitamos a dejarnos unas líneas en el área habilitada a continuación.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH

Cómo crear archivos Excel desde PHP – Parte 2

Xabadu — Thu, 24 Sep 2009 22:41:43 +0000

Hace algún tiempo, Jorge Nitales nos enseñaba como exportar a Excel desde PHP, mediante un sencillo método en el que mediante el envío de cabeceras era posible formatear un documento para ser leído desde Excel.

Como en CLH estamos en constante investigación para presentar nuevos métodos y alternativas para hacer las cosas, hoy les traemos, mediante un sencillo tutorial una nueva forma para que puedan generar archivos en formato Excel de forma rápida y con una flexibilidad increible en cuanto a la configuración del documento.

El detalle, como siempre, después del salto.

Cómo crear archivos Excel desde PHP

En el tutorial pasado, Jorge Nitales nos enseñaba un proceso en el cual, mediante el uso de cabeceras, hacíamos una exportación directa de un archivo en formato HTML, el cual era convertido y enviado a quien ejecutaba el código en formato xls.

Si bien ese método presenta ventajas notables, como principalmente su rapidez y facilidad de generación de los archivos, así como la sencillez de la organización de la información del documento (ya que podíamos hacer usos de tablas para tabular los datos), por otro lado se presentan las desventajas de que el archivo creado no es realmente un formato propio de Excel y por ende presenta una pequeña advertencia al abrirlo (aunque funciona sin problemas, puede presentar alguna mala experiencia para los usuarios), lo cual puede traer algunos problemas, especialmente si estamos trabajando con alguna clase en PHP para leer estos archivos generados.

Hoy presentaremos un nuevo método, en el cual utilizaremos un paquete de PEAR, el cual está diseñado especialmente para crear archivos de este tipo y nos proveerá de una serie de métodos para darle formato hasta el más mínimo detalle del documento, permitiéndonos incluso bloquear y proteger las hojas y/o celdas.

Antes de empezar:

¿Qué es PEAR?

PEAR es un conjunto de componentes reutilizables especialmente diseñado para el uso con PHP. Es posible descargar e instalar una serie de paquetes pertenecientes a el, los cuales a su vez nos proveen una serie de clases para realizar distintos tipos de operaciones, ya sea de manipulación de cierto tipo de archivos hasta procesos de imágenes, red e incluso integración de distintos servicios Web.

Desde la versión 4.3.0 de PHP, PEAR viene incluido. De lo contrario es necesario instalarlo de forma manual.

Con esa explicación, vamos a lo que necesitamos:

Implementos necesarios:

Un servidor Web que ejecute archivos en PHP. Una buena opción es la instalación de XAMPP.
PEAR. Si nuestra versión de PHP es superior a la 4.3.0, lo tendremos instalado por defecto. De lo contrario cubriremos el proceso más adelante.
El paquete Spreadsheet Excel Writer de PEAR, que pueden encontrarlo aqui. Cubriremos su instalación más adelante.
Alguna versión de Excel para leer los archivos generados. Idealmente 2003 o superior.
Un editor Web o entorno de programación para PHP.

Nota: Si están trabajando en algún hosting y no están seguros de si está instalado PEAR o el paquete a utilizar, les recomendamos ponerse en contacto con su proveedor de servicios y ver la factibilidad de que lo instalen.

Con eso claro, manos a la obra:

Procedimiento:

1.- Si ya contamos con PEAR instalado en nuestro servidor, podemos adelantarnos estos pasos. De lo contrario, debemos ir al directorio donde tenemos la instalación de PHP (Si instalamos Xampp, sería c:\xampp\php\).

2.- Dentro de ese directorio encontraremos un archivo llamado go-pear.bat

3.- Ejecutamos el archivo y se iniciará la instalación de PEAR. Si al iniciar nos aparece algún Warning o Error, es muy probable que ya contemos con PEAR instalado en nuestro sistema, por lo que no será necesario llevar a cabo el proceso.

4.- Una vez que termine la instalación, debemos proceder a la instalación del paquete Spreadsheet Excel Writer. Para eso vamos a Menu Inicio > Ejecutar y escribimos cmd para abrir Símbolo de sistema.

5.- Con Símbolo de sistema abierto, nos trasladamos al directorio de PHP, el mismo donde hicimos la instalación de PEAR y escribimos el siguiente comando:

pear install Spreadsheet_Excel_Writer-0.9.1

6.- Al ejecutar el comando anterior, se instalará el paquete:

7.- Con esto ya tenemos nuestro paquete instalado y podemos empezar a programar. Para esto abrimos nuestro editor Web o entorno de programación para PHP y creamos un nuevo archivo al que llamaremos ejemplo.php.

8.- Generaremos un código como el siguiente (comentarios en negrita, cursiva y entre /* y */):

/* Llamamos a la clase que ejecutará la exportación a Excel. Esta clase está guardada en el directorio que tenemos habilitado por defecto en nuestro php.ini para los include y require. Si no hemos modificado el php.ini no debemos cambiar nada acá */
require_once ‘Spreadsheet/Excel/Writer.php’;

/* Creamos un nuevo objeto de tipo Spreadsheet_Excel_Writer que refleja un nuevo libro de Excel */
$libro = new Spreadsheet_Excel_Writer();

/* Definimos mediante el método send que el archivo debe enviarse al usuario al ejecutar el código y le damos el nombre que tendrá. En este caso ejemplo.xls */
$libro->send(‘ejemplo.xls’);

/* Definimos una variable y se la asignamos a nuestro objeto como una hoja del mismo mediante el método addWorksheet, el cual lleva como parámetro el nombre de la hoja. Tal como si crearamos una en un libro normal de Excel */
$hoja =& $libro->addWorksheet(‘Hoja de prueba’);

/* Escribimos los datos en la hoja mediante el método write, el cual toma como parámetros el número de fila, número de columna y el contenido. Si es texto debe ir entre comillas como una cadena. */
$hoja->write(0, 0, ‘Nombre’);
$hoja->write(0, 1, ‘Apellido’);
$hoja->write(1, 0, ‘Maria’);
$hoja->write(1, 1, ‘Lopez’);
$hoja->write(2, 0, ‘Eulalio’);
$hoja->write(2, 1, ‘Ramirez’);
$hoja->write(3, 0, ‘Lalo’);
$hoja->write(3, 1, ‘Landas’);

/* Mediante el método close cerramos y enviamos el archivo al usuario */
$libro->close();
?>

9.- Ahora si ejecutamos ejemplo.php nos lanzará un archivo en formato excel llamado ejemplo.xls

Fácil y bonito, ¿no?. Complíquemoslo un poco, démosle un poco de formato a nuestro texto.

10.- Con el mismo código como base, ahora añadiremos algunas cosas. El formato se crea definiendo una variable y adjuntándola como formato a un libro en particular. Luego, cada vez que queramos utilizar ese formato, lo añadimos como parámetro al momento de escribir datos. Esto quedará más claro en nuestro ejemplo:

/* Llamamos a la clase que ejecutará la exportación a Excel. Esta clase está guardada en el directorio que tenemos habilitado por defecto en nuestro php.ini para los include y require. Si no hemos modificado el php.ini no debemos cambiar nada acá */
require_once ‘Spreadsheet/Excel/Writer.php’;

/* Creamos un nuevo objeto de tipo Spreadsheet_Excel_Writer que refleja un nuevo libro de Excel */
$libro = new Spreadsheet_Excel_Writer();

/* Definimos mediante el método send que el archivo debe enviarse al usuario al ejecutar el código y le damos el nombre que tendrá. En este caso ejemplo.xls */
$libro->send(‘ejemplo.xls’);

/* Definimos una variable y se la asignamos a nuestro objeto como una hoja del mismo mediante el método addWorksheet, el cual lleva como parámetro el nombre de la hoja. Tal como si crearamos una en un libro normal de Excel */
$hoja =& $libro->addWorksheet(‘Hoja de prueba’);

/* Declaramos una variable llamada negrita y la adjuntamos a nuestro libro definiendola como formato mediante el método addFormat */
$negrita = &$libro->addFormat();
/* Luego con la variable negrita, llamamos al método setBold para definir que será negrita */
$negrita->setBold();

/* Repetimos la operación con la variable cursiva pero ahora llamando al método setItalic */
$cursiva = &$libro->addFormat();
$cursiva->setItalic();

/* Escribimos los datos en la hoja mediante el método write, el cual toma como parámetros el número de fila, número de columna, el contenido y la variable con el formato que le daremos a esa celda. Si es texto debe ir entre comillas como una cadena. */
$hoja->write(0, 0, ‘Nombre’, $negrita);
$hoja->write(0, 1, ‘Apellido’, $negrita);
$hoja->write(1, 0, ‘Maria’, $cursiva);
$hoja->write(1, 1, ‘Lopez’, $cursiva);
$hoja->write(2, 0, ‘Eulalio’, $cursiva);
$hoja->write(2, 1, ‘Ramirez’, $cursiva);
$hoja->write(3, 0, ‘Lalo’, $cursiva);
$hoja->write(3, 1, ‘Landas’, $cursiva);

/* Mediante el método close cerramos y enviamos el archivo al usuario */
$libro->close();
?>

11.- Ejecutamos el archivo y nos enviará ejemplo.xls como descarga, el cual si lo abrimos podremos ver que tiene los datos formateados, tal como definimos:

El formato podemos manejarlo con muchos métodos, tanto de la hoja como de las celdas propiamente tal. Este paquete de PEAR nos permite personalizar todos los aspectos existentes de un libro de Excel, desde colores, codificación del texto, tamaños de letra, formatos de celda e incluso formulas. Lamentablemente son tantos métodos que necesitaríamos bastantes tutoriales para cubrirlos todos, por lo que hemos intentado cubrir su funcionamiento y enseñar la lógica de su uso para que puedan seguir experimentando y llegar al nivel de detalle que deseen.

Pueden encontrar un detalle de los métodos para utilizar en la documentación de Spreadsheet Excel Writer.

Ahora tenemos un método simple y seguro para exportar de PHP a Excel en caso de que necesiten mayor precisión o bien manipular los archivos después con alguna otra clase.

Les recordamos que como siempre, este tutorial ha sido:

Cualquier duda o comentario que puedan tener, los invitamos a dejarnos unas líneas en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH

Como hacer un diagrama de flujo

Jorge Nitales — Tue, 16 Jun 2009 04:51:25 +0000

Hoy vamos a ver como realizar un digrama de flujo, vamos a mostrar a un nivel básico, con algunos elementos.
Un diagrama de flujo es muy util a la hora de ordenar casi todo tipo de procesos, para realizar algoritmos, etc…

Para ver Como Lo Hago, vamos despues del salto.

Como hacer un diagrama de flujo

¿Que necesitamos?

- Papel y lápiz

¿Como Lo Hago?

Nota: Primero que todo, tenemos que aclarar que, a pesar de que existe una especie de lenguaje universal, la simbologia de los diagramas de flujo puede variar, de pais a pais, empresa a empresa o incluso de persona a persona, lo importante es conocer el significado de cada uno.

Para este caso vamos a utilizar lo siguiente:

: Inicio o Término del diagrama.

: Condición (Bifurcación)

: Proceso

: Ingreso y Salida de datos

: Conector

Vamos a tomar un problema que deseamos pasar a diagrama de flujo, por ej:

Calcular los promedios de un numero X de alumnos, cada uno con 3 notas, se debe mostrar por pantalla si esta aprobado o reprobado (usaremos la escala que se usa en Chile, del 1 al 7, de un 4 para arriba esta aprobado):

1.- Vemos que procesos se deben realizar:

a) Declarar (“nombrar”) variables a utilizar: Nota1,Nota2,Nota3,Suma,Promedio
b) Ingresar notas
c) Sumar las notas
d) El resultado de la suma, dividirlo por 3
e) Ver si este nuevo resultado es mayor o igual a 4
f) Si es mayor, mostrar aprobado, de lo contrario mostrar reprobado
e) Pregunta si se quieren ingresar las notas de otro alumno
g) Si la respuesta es si, volver al paso “b” (no es necesario volver al a, ya que las variables estan declaradas)

2.- Entonces, primero que todo, iniciamos el diagrama y declaramos variables:

3.- Ahora ingresamos las notas:

4.- Realizamos el proceso de sumar las 3 notas:

5.- Dividimos la suma en 3 (Cantidad de notas, en este caso es un numero fijo):

6.- Vemos si es igual o mayor a 4:

7.- Preguntamos si quieren calcular otro promedio:

Y el Diagrama completo se ve así (no se puede agrandar):

Y con esto ya tenemos nuestro diagrama de flujo.

Por ahora,

Me despido

Staff Comolohago.cl

Cómo aprender a programar y no morir en el intento – Parte 10

Xabadu — Sun, 29 Mar 2009 19:19:24 +0000

Se nos acabaron las imágenes humorísticas

Bienvenidos a una nueva edición de “Como aprender a programar y no morir en el intento”. Soy su anfitrión, Juan Xabadu, y tal vez me recuerden de películas como: “Querida, me caí del Taxi” y “Jurassic Park vs Forrest Gump” como siempre, los acompañare en esta gran aventura en que nos hemos embarcado hace bastante tiempo, dando nuestros primeros pasos en el mundo de la programación.

Hoy veremos los primeros contenidos sobre métodos de búsqueda y ordenamiento, así como funciones y continuaremos con nuestro ejemplo del terminal de venta.

El detalle, como siempre, después del salto.

Cómo aprender a programar y no morir en el intento – Parte 10

Tal como adelantábamos en el número anterior, los contenidos de hoy:

Contenidos

Métodos de ordenamiento: Método de la burbuja.
Métodos de búsqueda: Método secuencial.
Funciones.
Añadiendo un menú al terminal de venta.

Vamos, manos a la obra:

1.- Métodos de ordenamiento: Método de la burbuja.

En un escenario normal, el 99,9% de los programas que realicemos operan con una cantidad de datos mediana a alta, los cuales pueden ser o no ingresados por un usuario y son almacenados en distitnos medios, ya sea en variables, arreglos o archivos entre otras cosas.

Ahora, en un escenario más normal aún, estos datos nunca estarán necesariamente ordenados bajo algún criterio en particular, por lo que si necesitaramos acceder a ellos bajo un orden especial, sería imposible lograrlo por si solo.

Para esto es que en la programación existen los métodos de ordenamiento, los cuales son básicamente algoritmos que realizan una lectura de una serie de datos y un posterior ordenamiento de acuerdo a ciertos criterios (alfabeticamente, menor a mayor, etc).

Existen una serie de métodos de ordenamiento como el de la burbuja, quicksort, inserción, selección, etc. Cada uno de ellos se diferencia del otro tanto en su funcionamiento como en el costo (de ejecución) que significan para el programa en sí.

¿Qué método utilizar?

Si bien, como decíamos, cada método presenta ciertas ventajas por sobre otro, en ningún caso son diferencias radicales y en estricto rigor no se notan a menos que trabajemos con cantidades másivas de datos, por lo que el consejo por ahora es utilizar el método que encontremos más sencillo y/o nos acomode más. A pesar de esto hay escenarios que presentan una mejor adaptabilidad a un método en particular. Ya iremos viendo más de esto en futuras guías.

Partiendo veremos uno de los métodos más conocidos y utilizados como es el método de la burbuja, llamado de esta forma por la forma en que se realiza el ordenamiento de datos, emulando una burbuja.

¿Cómo funciona el método de la burbuja?

Este método, utilizado comunmente cuando se necesita ordenar datos dentro de un vector o una matriz, funciona mediante el uso de 4 variables:

Un vector o matriz donde están almacenados los datos.
Una variable que recorre el vector.
Una variable que recorre el vector una posición más adelante que la variable anterior.
Una variable auxiliar.

La forma de funcionamiento es bastante simple: Nuestro vector es recorrido por una variable (la definida en el número 2) y por otra en una posición más adelante. Vamos realizando una comparación entre las 2 variables y si se cumple el criterio establecido se hace un movimiento circular: El valor más adelantado pasa a la variable auxiliar, el valor más atrasado pasa a la posición adelantada y el valor de la variable auxiliar pasa a la posición retrasada. Esto se realiza hasta que se alcanza el final del vector en cuestión.

Veamos un ejemplo de este método de ordenamiento:

Ejemplo: Ordenar un vector de tamaño 5 de menor a mayor mediante el método de la burbuja (los comentarios, como siempre, en negrita, cursiva y entre /* y */):

#include
#include
#include // Incluimos las librerías

int main()
{
int arreglo[5], aux, i, j;
/* Declaramos las siguientes variables:

arreglo = Un vector de 5 posiciones donde tendremos los valores.
i,j = Variables para recorrer el vector.
aux = Variable para guardar un valor mientras lo ordenamos
*/

printf (“Ingrese valores para llenar el vector:\n”);
// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);

/* Luego, ordenamos el vector mediante el algoritmo de burbuja:

Recorremos el vector con una variable más adelantada que la otra y
comparamos. Si el valor de la posición actual es mayor al de una
posición más, guardamos el valor actual en la variable auxiliar,
luego en la posición actual ponemos el valor de la posición siguiente
y en la posición siguiente guardamos el valor de la variable auxiliar*/

for (j=1; j <= 5; j++)
for (i=0; i< 4; i++)
if (arreglo[i] > arreglo[i+1])
{
aux = arreglo[i];
arreglo[i] = arreglo[i+1];
arreglo[i+1] = aux;
}

printf (“\nValores ordenados exitosamente!\n”);
// Mostramos el vector ordenado
for (i=0; i< 5; i++)
printf (“arreglo[%d] = %d\n”, i, arreglo[i]);

getch();
}

Como podemos ver, es un algoritmo bastante simple que cumple la función solicitada, ordenar de menor a mayor aplicando el método de la burbuja. Existen otros métodos que serán de mayor utilidad cuando trabajemos con una cantidad de datos mayor, pero por ahora con este podremos cumplir el objetivo sin problemas.

2.- Métodos de búsqueda: Método secuencial

Una funcionalidad que siempre es útil al momento de hacer un programa, es la de poder buscar un dato específico del que necesitamos saber información o bien trabajar con el.

En lenguajes de programación de 3a generación, orientados al proceso, como C, existen una serie de métodos de búsqueda que nos permiten cumplir esa tarea, entre ellos podemos destacar la búsqueda secuencial, la binaria, acceso directo y el trabajo mediante índices.

¿En que se diferencian?, tal como en el caso de los métodos de ordenamiento, cada uno de estos métodos se separa de otro por la forma en la que trabajan y el costo de ejecución que implica para el programa en sí. Todas a su vez tienen una serie de ventajas y desventajas, siendo la más “costosa” de todas la búsqueda secuencial, debido a que su forma de trabajo es buscar una referencia indicada registro por registro, uno a la vez como si examináramos una serie de filas una por una hasta encontrar lo que buscamos. Sin embargo, es esta última, la más sencilla de implementar y la que menos requerimientos tiene.

Su funcionamiento se explica mediante el siguiente algoritmo:

Consideremos que tenemos un vector, el cual está lleno de códigos numéricos de productos de un supermercado y necesitamos buscar un producto en particular. Al ingresar el código a buscar y decirle al programa que lo ubique en tal vector, operaría de la siguiente manera:

Va a la posición 1.
Compara el valor de esa posición con el ingresado a buscar.
Si son iguales lanza un mensaje o guarda la posición para futuras referencias.
De lo contrario pasa a la posición siguiente.
Repite pasos 2,3,4.

Como podemos apreciar, es un funcionamiento simple y básico, pero que funciona. El gran problema radica cuando estamos operando con una cantidad masiva de datos, ya que los accesos a memoria serían demasiados y el costo de ejecución (algo que los programadores siempre deben tener en cuenta) sería alto.

Adicionalmente es bueno añadir que ese ejemplo referencia a un escenario ideal donde los códigos no están repetidos. En caso de que lo estuviesen, deberíamos avisar en cada posición que se encuentre una coincidencia.

Veamos un ejemplo de búsqueda secuencial:

Ejemplo: Llenar un vector de tamaño 5 con números y luego buscar algún valor y mostrar por pantalla la posición en la que se encuentra:

#include
#include
#include // Incluimos las librerías

int main()
{
int arreglo[5],i,valor,x;
/* Declaramos las siguientes variables:

arreglo = Un vector de 5 posiciones donde tendremos los valores.
i = Variable para recorrer el vector.
valor = Variable para guardar el valor a buscar
x = Bandera que utilizamos para marcar que hayan valores.
*/
x=0; // Dejamos como 0 a x, lo que significa que no se han encontrado coincidencias
printf (“Ingrese valores para llenar el vector:\n”);
// Mostramos un mensaje e introducimos valores al vector
for (i=0; i< 5; i++)
scanf(“%d”,&arreglo[i]);

// Solicitamos que se ingrese un valor a buscar
printf(“\nIngrese un valor a buscar: “);
scanf(“%d”,&valor);

/* Recorremos el vector y vamos comparando las posiciones con el valor a buscar,
si hay una coincidencia, mostramos la posición por pantalla y marcamos la variable
x con un 1 para indicar que se encontro valor */
for (i=0; i < 5; i++)
if (arreglo[i] == valor)
{
printf(“\nEl valor se encuentra en la posicion %d”,i);
x=1;
}
if(x==0)
printf(“\nNo se encontraron coincidencias”);

getch();

}

3.- Funciones

En la Parte 6 de esta saga, veíamos en una primera instancia lo que eran las funciones cuando hablabamos de pseudo-código. Los conceptos son exactamente los mismos, así como la forma de funcionamiento y operación de la función en sí, es decir:

tipo nombre_funcion(valor 1, valor 2… valor n)
{
operación 1;
operación 2;
.
.
operación n;

retorno de valor;
}

Veamos un ejemplo para dejar todo más claro:

Ejemplo: Determinar el mayor entre 2 números mediante el uso de una función:

#include
#include
#include // Incluimos las librerías

int numero_mayor(int valor1, int valor2); // Declaramos inicialmente la función
int main()
{
int num1, num2, mayor; //Declaramos las variables que utilizaremos

// Pedimos que se ingresen los numeros
printf(“\nIngrese Numero 1: “);
scanf(“%d”,&num1);
printf(“\nIngrese Numero 2: “);
scanf(“%d”,&num2);

// A mayor le asignaremos el resultado de la función
mayor=numero_mayor(num1,num2);

// Mostramos el resultado por pantalla
printf(“\nEl numero mayor es: %d”,mayor);

getch();

}

int numero_mayor(int valor1, int valor2) // Recibimos los valores
{
// Comparamos cual es mayor y lo retornamos
if(valor1>valor2)
return valor1;
else
return valor2;
}

4.- Añadiendo un menú al terminal de venta

Siguiendo con nuestro clásico ejemplo del terminal de ventas, si recordamos, la última vez habíamos dejado nuestro ejemplo adaptado para poder realizar más de una venta y vender en cada una de ellas más de un producto.

Bueno, el trabajo que realizaremos hoy será confeccionar un menú para que la aplicación sea más completa y la función de ventas solo sea una parte de ese menú.

Como recordaremos, al final del ejemplo anterior, teníamos el siguiente código:

#include
#include
#include /* Incluimos las librerías */

int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos en el proceso */
int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer más de una venta */

int main()
{
while(opcion==1)
{
while(codigo!=4) /* Definimos un ciclo que se ejecute siempre que el usuario no presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”); /* Listamos los productos */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nPara cerrar la venta, presione 4″); /* Añadimos la opción para cerrar la venta */

printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código del producto */
scanf(“%d”,&codigo); /* Leemos el código del producto */
if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada, así que cerramos el proceso de venta */
break;
printf(“\nIngrese la cantidad que desea llevar: “); /* Pedimos la cantidad */
scanf(“%d”,&cantidad); /* Leemos la cantidad */

if(codigo==1) /* Igualamos el código para asignar el precio */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;

total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */

}
printf(“\nEl total es de: %d”,total); /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
printf(“\nIngrese el pago: “); /* Solicitamos el pago */
scanf(“%d”,&pago); /* Leemos el pago */
if(pago printf(“\nEl pago no es suficiente”);
else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos los mensajes de vuelto */
{
ok=0;
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
}

printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea hacer otra venta */
scanf(“%d,”,&opcion); /* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */

}

Todo aquel código se refiere a lo que nombraríamos como “módulo de ventas”, que es la funcionalidad principal del programa. Para confeccionar un menú, algo muy conveniente es hacer uso de un ciclo tipo do-while y un switch, de la siguiente forma, utilizando una nueva variable llamada menu para recoger la opción elegida, nuestro programa quedaría así:

llamado a librerías

declaración de variables

inicio de función main

do
{
printf(“1.- Módulo de ventas\n”);
printf(“2.- Administrar productos\n”);
printf(“3.- Administrar clientes\n”);
printf(“4.- Cerrar sistema\n”);
printf(“Ingrese opción: “);
scanf(“%d”,&menu);

switch(menu)
{
case 1: Aquí insertaríamos nuestro código anterior del módulo de ventas
break;
case 2: Por ahora en blanco, pero iría el código para administrar los productos
break;
case 3: Por ahora en blanco, pero iría el código para administrar los clientes
break;
case 4: break;
}
}while(menu!=4);

fin de función main

Con ese código, que dejaríamos al principio de nuestro programa, insertando el código anterior en el caso 1 del switch, le diríamos al menú que se ejecutase hasta que se seleccione la opción 4, que es cerrar sistema.

No es un código difícil de implementar, solo debemos fijarnos en el orden y no tendremos problemas.

Y eso sería en la edición de hoy de Como aprender a programar y no morir en el intento. En el próximo número cubriremos:

Paso de parámetros por valor y por referencia.
Estructuras.
Recursividad.

Como siempre, les recordamos que este tutorial ha sido:

Cualquier duda que puedan tener, los invitamos a dejarnos un comentario en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH

Cómo aprender a programar y no morir en el intento – Parte 9

Xabadu — Sun, 04 Jan 2009 22:02:54 +0000

Empezamos ya de lleno el 2009, y que mejor que seguir con lo que el 2008 nos dió tantos dolores de cabeza ayudó a entrar de mejor forma al mundo de la programación.

Hoy, en la parte 9, o primera del 2009, seguiremos viendo contenidos del lenguaje C, así como el programa que empezamos a confeccionar en la edición pasada.

Así que los invitamos a seguirnos, como siempre, después del salto.

Cómo aprender a programar y no morir en el intento – Parte 9

Nota: Como siempre, les recomendamos, si es que no lo han hecho, leer los números anteriores de esta guía, los cuales pueden ser encontrados en nuestra categoría de programación.

Si recuerdan el número anterior, en esta ocasión veremos:

Contenidos:

Iteración Switch.
Vectores.
Matrices.
Continuación de la confección de un terminal de venta.

Así que vamos de lleno a la guía de hoy:

1.- Iteración Switch:

En el número anterior, veíamos las iteraciones condicionales if y else, las cuales nos permitían tomar distintos caminos dentro de un programa, dependiendo de una condición determinada. Además, cuando veíamos los números sobre pseudo-lenguaje, conocímos una iteración llamada Switch, la cual presentaba una funcionalidad bastante similar, pero tal como explicábamos aquella vez, es bastante mejor para usar en casos determinados.

El funcionamiento de esta iteración, ya lo hemos detallado en números anteriores, por lo que no adentraremos en repetir lo mismo, si no que veremos como funciona en lenguaje C.

Ahora, una buena pregunta, es ¿Cuándo usar if/else y cuándo usar switch?. La verdad, es que como todo en la programación, es cosa de gustos. A pesar de que pueden haber casos en los que sea más cómodo y/o ordenado usar una iteración sobre otra, las 2 cumplen la misma funcionalidad, por lo que pueden ser usadas sin problemas. En lo personal, lo cual en ningún sentido es un estándar, prefiero usar iteraciones de tipo Switch cuando en los programas definimos algún tipo de menú, por un tema de orden. En un ejemplo más adelante podremos apreciar porque.

Entonces, usando switch en C, lo primero que necesitamos es una variable que tome un valor (todo switch debe ser inicializado por una variable) y conocer los valores, o la mayoría de ellos, que pudiése tomar, como veremos en el siguiente ejemplo.

Además, dentro de los casos, podemos definir un caso por defecto, el cual cubrirá todas las opciones no definidas. Esto es muy útil para prevenir que el usuario ingrese un valor que no tenemos cubierto dentro de nuestras opciones.

Veamos un ejemplo.

Ejemplo: Plantearemos un pequeño menú, y definiremos cada caso, utilizando una iteración de tipo switch.

#include
#include
#include

int opcion;

int main()
{
/* A continuación escribimos nuestro menú, tabulando y dando saltos de línea */
printf(“\tMenu”);
printf(“\n1.- Mostrar hola mundo”);
printf(“\n2.- Dar los buenos dias”);
printf(“\n3.- Salir”);
printf(“\nIngrese su opcion: “);
scanf(“%d”,&opcion); /* Leemos la opción que ingrese el usuario */

switch(opcion) // Activamos el switch con la variable opción.
{
case 1:      printf(“\nHola mundo”); /* En el caso que ingrese 1 */
break;
case 2:      printf(“\nBuenos dias”); /* En el caso que ingrese 2 */
break;
case 3:      break; /* En el caso que ingrese 3 */

default:     printf(“\nOpcion no valida”); /* Caso por defecto */
break;
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}

Como podemos ver, al final de cada caso, debemos incluir la sentencia break;, que indicará que después de ejecutar las sentencias correspondientes al caso, se debe salir del switch.

Compilamos y probamos. Ahora, como podrán apreciar, este switch solo se ejecuta una vez. En caso de que quisieramos hacerlo repetitivo hasta que se diga salir, podemos insertarlo dentro de un ciclo y poner como condición que se ejecute mientras no se seleccione la opción de salida.

Así de simple es la iteración switch. Es de gran utilidad para ordenar nuestras opciones y en especial para utilizarlo con menús, así que es muy recomendable aprender a usarlo y manejarlo para los programas que vayamos a desarrollar.

2.- Vectores:

Tal como veíamos en pseudo-lenguaje, en la programación existen unas variables especiales conocidas como arreglos, las cuales presentan la facultad de almacenar múltiples valores, ya sea unidimensionalmente o bidimensionalmente. Los vectores representan los primeros.

En C, también podemos utilizar vectores, de la misma forma en la que los planteabamos para pseudocódigo, es decir, declarándolos y rellenándolos según su posición, así como las mismas condiciones para recorrerlos y leerlos.

Tal como en todos los casos, no entraremos a repetir las definiciones que hemos hecho en guías anteriores y sólo nos preocuparemos de su uso en lenguaje C.

Veamos un pequeño ejemplo, para que nos quede todo más claro:

Ejemplo: Declararemos un vector, lo rellenaremos y luego mostraremos su contenido:

#include
#include
#include

int vector[5]; // Declaramos el vector

int main()
{
for(int i=0; i<5; i++) /* Definimos un ciclo para llenar el vector */
{
printf(“\nIngrese el valor de la posicion %d del vector: “,i);
scanf(“%d”,&vector[i]); /* Leemos los datos de cada posición */
}
printf(“\nLos valores ingresados fueron: “); /* Mostramos los valores */
for(int i=0;i<5; i++)
{
printf(“%d\t”,vector[i]);
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}

Como podemos ver, el procedimiento es el mismo que usabamos para pseudo-código, utilizando ciclos tanto para rellenar posiciones secuencialmente, como para leerlas, accediendo mediante el índice que marcamos con la variable i, que se va moviendo a lo largo del vector.

Ahora, si nos fijamos en el ejemplo, podemos ver que dentro del ciclo for, hemos definido la variable i y no al principio del programa. Esto es posible en este tipo de ciclos, pero esa variable solamente vive dentro del búcle y no después (por eso la volvemos a declarar en el segundo ciclo). Esta es una gran forma de matar variables rápidamente después de su uso y no gastar espacio innecesariamente.

3.- Matrices:

En el caso de las matrices, utilizamos procedimientos bastante similares a los de los vectores, salvo que, siendo arreglos bidimensionales, para recorrer una matriz necesitaremos de 2 ciclos, uno para las filas, y 1 para las columnas.

La definición también varía en el número de dimensiones que declaramos. Si para los vectores hacíamos una declaración del tipo “vector [5]“ por su unidimensionalidad, para las matrices aplicamos una definición del tipo “matriz [5[[5]“, la primera relacionada con sus filas, y la 2da con sus columnas.

Veamos un ejemplo para que nos quede más claro.

Ejemplo: Repetiremos el ejemplo anterior, pero en este caso utilizaremos una matriz:

#include
#include
#include

int matriz[3][3]; // Declaramos la matriz

int main()
{
for(int i=0; i<3; i++) /* Definimos un ciclo para las filas */
{
for(int j=0; j<3; j++) /* Otro ciclo para las columnas */
{
printf(“\nIngrese el valor para la fila %d y la columna %d: “,i,j);
scanf(“%d”,&matriz[i][j]);
}
}
printf(“Los valores ingresados son:\n “);
for (int i=0; i<3; i++) /* Mostramos los valores ingresados, tabulando y dando salto de línea para hacer la forma de la matriz */
{
for (int j=0; j<3; j++)
{
printf(“%d\t”,matriz[i][j]);
}
printf(“\n”);
}
getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */
}

El procedimiento es el mismo, pero solo nso enfocamos en recorrer 2 dimensiones en vez de una. A medida que vayamos utilizando vectores y matrices en nuestros programas nos iremos acostumbrando cada vez más a su funcionamiento.

4.- Terminal de venta:

Si recuerdan, al final del número anterior, realizamos la confección de un terminal de venta, en el cual listabamos unos productos y realizabamos una venta, especificando el vuelto correspondiente al cliente.

Hoy, seguiremos trabajando sobre ese terminal, añadiendo la funcionalidad de poder vender más de un producto en una venta y de realizar más de una venta. Si recordamos, teníamos este código:

include
#include
#include

int codigo, cantidad, valor, total, vuelto, pago;

int main()
{
printf(“\t Lista de productos\n”);
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);

printf(“\nIngrese el codigo del producto que desea llevar: “);
scanf(“%d”,&codigo);
printf(“\nIngrese la cantidad que desea llevar: “);
scanf(“%d”,&cantidad);

if(codigo==1)
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;

total=valor*cantidad;

printf(“\nEl total es de: %d”,total);
printf(“\nIngrese el pago: “);
scanf(“%d”,&pago);
if(pago printf(“\nEl pago no es suficiente”);
else
{
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
printf(“\nVenta finalizada”);
getch();

}

Y ahora, añadiendole algunos ciclos, tendremos un código como este:

#include
#include
#include /* Incluimos las librerías */

int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos en el proceso */
int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de bandera para un ciclo que usaremos */
int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer más de una venta */

int main()
{
while(opcion==1)
{
while(codigo!=4) /* Definimos un ciclo que se ejecute siempre que el usuario no presione la tecla para finalizar la venta */
{
printf(“\t Lista de productos\n”); /* Listamos los productos */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);
printf(“\nPara cerrar la venta, presione 4″); /* Añadimos la opción para cerrar la venta */

printf(“\nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código del producto */
scanf(“%d”,&codigo); /* Leemos el código del producto */
if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada, así que cerramos el proceso de venta */
break;
printf(“\nIngrese la cantidad que desea llevar: “); /* Pedimos la cantidad */
scanf(“%d”,&cantidad); /* Leemos la cantidad */

if(codigo==1) /* Igualamos el código para asignar el precio */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;

total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */

}
printf(“\nEl total es de: %d”,total); /* Saliendo de la venta, indicamos el total */
while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */
{
printf(“\nIngrese el pago: “); /* Solicitamos el pago */
scanf(“%d”,&pago); /* Leemos el pago */
if(pago/* Si el pago es inferior al total, mostramos un mensaje de error */
printf(“\nEl pago no es suficiente”);
else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos los mensajes de vuelto */
{
ok=0;
vuelto=pago-total;
printf(“\nEl vuelto es de: %d”,vuelto);
}
}

printf(“\n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea hacer otra venta */
scanf(“%d,”,&opcion); /* Leemos la respuesta */
}
printf(“\nVenta finalizada”); /* Mensaje final */
getch(); /* Programa en pausa hasta pulsar una tecla */

}

Como podemos apreciar en esta nueva versión, hacemos uso de algunos ciclos. De esta forma, podemos hacer una venta de múltiples productos, y validamos el pago hasta que sea el correcto, para así completar de forma correcta la venta. Además, luego de finalizar una venta, podemos hacer otra automáticamente al señalarlo y de esta forma no necesitamos volver a ejecutar el programa cada vez que queramos vender algo.

Recordemos que nuestro programa lo vamos construyendo de a poco, aún hay muchos puntos que pueden ser mejorados y eso es lo que iremos haciendo en los próximos números. Por ahora lo dejaremos aquí, pero los incentivamos a que vayan añadiendo nuevas cosas de lo que hemos ido aprendiendo.

En la próxima edición de “Cómo aprender a programar y no morir en el intento”:

Método de ordenamiento: El método de la burbuja.
Método de busqueda: Búsqueda secuencial.
Funciones.
Continuación del términal de ventas: Añadiendo un menú.

Como siempre, recuerden que este tutorial ha sido:

Cualquier duda o comentario que puedan tener, los animamos a dejarnos unas líneas en el área habilitada a continuación.

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer y será hasta una próxima oportunidad.

Staff CLH

Cómo aprender a programar y no morir en el intento – Parte 8

Xabadu — Sun, 28 Dec 2008 21:56:39 +0000

Ya dejando un poco atrás la locura navideña, y preparándonos para recibir este año 2009, hemos decidido hacer un alto de las festividades (en confabulación con nuestro “maravilloso” servicio de hosting que nos ha fallado a diestra y siniestra, por lo que ofrecemos nuestras disculpas) y traerles un nuevo número de esta gran saga que ha sacado chispas busca darles una pequeña manito durante sus primeros pasos del mundo de la programación.

En el número anterior, nos adentramos en nuestro primer lenguaje real, C, haciendo una larga introducción y comparación con lo que habíamos visto hasta ahora, terminando con nuestro primer programa. En esta ocasión, seguiremos adentrándonos más en el tema y terminaremos con la confección de un programa algo más complejo.

Así que sin más espera, los invitamos a seguirnos después del salto, que no es en verdad un salto, sino que un “leer más”.

Cómo aprender a programar y no morir en el intento – Parte 8

Nota: Como es habitual, les recomendamos, si no lo han hecho ya, leer los números anteriores de esta saga, que pueden encontrar en la categoría de Programación de CLH.

Tal como prometimos en el número anterior, en este veremos los siguientes contenidos:

Contenidos:

Comentarios.
Leyendo datos desde teclado.
Iteraciones condicionales.
Ciclos o búcles.
Ejercicio: Programando un terminal de venta simple.

Veremos bastante hoy, así que vamos, manos a la obra:

1.- Comentarios.

Si nos hemos fijado hasta ahora, siempre que realizamos algún ejemplo o ejercicio de código, en C, Pseudo-código o bien en nuestros tutoriales de PHP, siempre ponemos las explicaciones entre unos símbolos /* y */.

Esto, junto a otros símbolos, es lo que en la programación (a todo nivel) se conoce como comentarios.

Los comentarios en la programación, si bien no son obligatorios, se convierten en una herramienta util y su mayor función es entregarnos la posibilidad de añadir pequeñas anotaciones sobre lo que estimemos conveniente, ya sea sobre el código propiamente tal u otras cosas como notas de autoría o funcionamiento del programa en sí.

¿Por qué usar comentarios?

Principalmente por un tema de orden. Tenemos que pensar de que si bien nuestra memoria puede ser excelente, en más de alguna ocasión nos tocará revisar códigos que hayamos realizado hace algún tiempo y puede que en ese programa hayamos utilizado alguna función o lógica que no tiene sentido en este momento. Por eso el uso de comentarios nos simplifica el tener que estar mucho tiempo deduciendo lo que alguna vez hicimos. Lo mismo se presta para cuando nuestro código es revisado por terceros o bien nosotros revisamos códigos hechos por alguien más.

Hay 2 formas de comentarios: los de línea simple y los de múltiples líneas. La única diferenciación es en los símbolos que utilizamos para iniciar y terminar los comentarios.

Cuando los comentarios son de línea simple solo debemos añadir al principio de la línea el símbolo // . Debemos tener en cuenta de que solo será válido como comentario lo que escribamos en la misma línea. Si pasamos a otra línea lo tomará como código y nos lanzará error, por lo que debemos utilizar símbolo de comentario de múltiples líneas.

Para múltiples líneas, utilizamos el mismo que hemos usado hasta ahora, o sea al principio del comentario ponemos /* y al final del comentario cerramos con */. Todo lo que escribamos entremedio será considerado como comentario.

De cualquier forma, si es que les complica recordar los símbolos para cada caso, pueden utilizar siempre el formato de múltiples líneas, que cubre comentarios ya sea en 1 línea o en varias.

2.- Leyendo datos desde teclado.

Cuando trabajabamos en Pseudo-código, una de las funcionalidades que más utilizabamos, era la lectura o recepción de datos ingresados por un usuario vía teclado. Eso nos permitía interactuar de una mayor forma con quien utilizaba el programa y realizar procesamientos mucho mejores y personalizados.

Pues bien, en C también podemos leer datos desde teclado, de una forma tan similar como en pseudolenguaje. Si recordamos el tutorial anterior, hablábamos de la función scanf, la cual nos permitía realizar esa tarea y que se utiliza de la siguiente forma:

scanf(“%tipodevariable”, &nombredelavariable);

Como podemos observar, esta función presenta 2 parámetros: %tipodevariable (entre comillas) y &nombredelavariable, los cuales a su vez presentan 2 signos: % y &. Vamos por parte explicando:

tipodevariable: Tal como hemos visto en numerosas ocasiones, cada variable que definimos en un programa contiene un tipo de datos que puede almacenar (int, float, char, etc). A su vez, el lenguaje C utiliza unos simbolos que representan esos tipos y que se incluyen en las funciones scanf y printf para decirle al compilador que tipo de dato es el que estamos leyendo/mostrando. Estos simbolos son la d para variables de tipo int, la f para variables de tipo float y la c para variables de tipo char entre otras.
El símbolo %: Este símbolo siempre debe ir por obligación acompañando a los símbolos indicados en el punto anterior, de esta forma el compilador comprenderá que estamos hablando de un tipo de dato y no de una consonante por sí sola.
nombredevariable: Es el nombre que le damos a una variable en particular cuando la definimos.
El símbolo &: En el lenguaje C, cuando utilizamos el símbolo & junto al nombre de una variable, le estamos diciendo al compilador que nos estamos refiriendo al área de memoria en el que esa variable almacena su información. Como dijimos hace algún tiempo, toda variable al momento de ser creada, apunta a un área de memoria interna del computador para manipular su información. A esta área accedemos con el símbolo & cuando leemos un dato.

Con esas definiciones claras, veamos un pequeño ejemplo, para lo que utilizaremos el entorno de programación que instalamos en el número anterior:

Ejemplo: Realizar un programa que lea un dato numérico por teclado y luego mostrarlo por pantalla. (La explicación del código, como siempre en negrita, cursiva y entre /* y */.

#include
#include
#include

/* Partimos por agregar las librerías necesarias para nuestro programa, incluida la conio.h para hacer uso de la función getch( ); */

int numero;

/* Declaramos una variable llamada numero de tipo int */

int main( )
{
/* Declaramos la función main o principal */

printf(“Ingrese un numero del 1 al 10: “);
/* Mostramos un mensaje al usuario para que ingrese un numero del 1 al 10 */

scanf(“%d”, &numero);
/* Con scanf leemos el dato, indicando con %d que es un dato de tipo int e indicamos que guardaremos la información en el área de memoria de la variable numero poniendo &numero */

printf(“Ingreso el numero %d”, numero);
getch();
/* Mostramos el numero que ingreso el usuario, poniendo un mensaje con printf y en la posición donde mostraremos el número ponemos el símbolo correspondiente al tipo de dato, o sea %d, y luego de la coma la variable que mostraremos. En la línea siguiente ponemos un getch ( ); para que el programa quede en espera hasta que presionemos una tecla y así podamos ver el resultado antes que se cierre */

} // Cerramos llave de la función main.

Compilamos el programa y no deberíamos tener errores. Lo ejecutamos y probamos que funcione.

Así de simple es la captura de datos vía teclado.

3.- Iteraciones condicionales.

Las iteraciones condicionales en C son bastante similares a las que vimos en pseudocódigo (Si y Si No, Switch) y cumplen exactamente la misma función, esto es, ejecutar una serie de acciones a partir del cumplimiento de una condición. No entraremos en mayor detalle, pues lo vimos de forma bastante completa en el pasado.

En lo que si adentraremos es en como se usan en C:

Si y Si no

En C se utiliza de la misma forma, radicando la diferencia en que en vez de ser Si y Si no, hablamos de if y else. Esta iteración tiene las mismas características que en pseudo, o sea, todo else debe ir luego de un if y dentro de un if y de un else pueden ir múltiples if y elses. La forma de declaración es:

if(condición)
{
sentencia 1;
sentencia 2;
}
else
{
sentencia 3;
sentencia 4;

}

Cuando utilizamos if y else, podemos o no usar llaves para abrir y cerrar el if. Cuando un if y/o un else tienen solo una sentencia a ejecutar, podemos escribirlos sin llaves para abrir y cerrar. Si es más de una sentencia, necesariamente deben llevar llaves. Si desean, para evitar confusiones, podemos utilizar siempre las llaves.

Veamos un ejemplo ampliando el caso anterior. También pediremos un dato al usuario, pero en vez de mostrarlo lo someteremos a un simple if y else para ver si el número es mayor a 5:

#include
#include
#include

int numero;

int main()
{
printf(“Ingrese un numero del 1 al 10: “);
scanf(“%d”,&numero);

/* Primero vemos con un if si el numero es igual a 5. Recordemos que para comparar utilizamos doble signo igual */
if(numero==5)
printf(“El numero ingresado es 5″);
else // Si no es igual a 5
if(numero > 5) // Si es mayor a 5 mostramos el mensaje
printf(“El numero ingresado es mayor a 5″);
else // Si es menor a 5 mostramos el mensaje
printf(“El numero ingresado es menor a 5″);
getch();

}

A medida que vayamos avanzando, el uso de if y else será más complejo y largo, pero la lógica es básicamente la misma.

La iteración switch la veremos en el próximo número, ya que implica un mayor nivel de detalle y no queremos extendernos por sobre los demás contenidos de momento.

4.- Ciclos o búcles.

Tal como las iteraciones, en pseudolenguaje también definimos y utilizamos ciclos y búcles que cumplen la misma funcionalidad que en C, por lo que no nos desviaremos definiendo nuevamente esos temas, si no que veremos cada caso para C y luego un ejemplo que los reune a todos.

Mientras

El ciclo mientras que usabamos en Pseudocódigo, en C (y otros lenguajes) es conocido como while y es uno de los más usados. La forma de utilizarlo es la misma, o sea:

while(condición)
{
sentencia 1;
sentencia 2;
}

Tal como en Pseudo, este ciclo sólo se ejecutará (y se mantendrá en ejecución) mientras la condición se cumpla.

Para

Este ciclo en lenguaje C es conocido como for y se utiliza de la misma forma, o sea:

for(inicialización de variable ; condición ; aumento o decremento de la variable)
{
sentencia 1;
sentencia 2;
sentencia 3;
}

Tal como en el caso del ciclo while, este ciclo se continuará ejecutando mientras se cumpla la condición, pero a diferencia del anterior, este siempre se ejecutará, ya que la variable para la condición se inicializa dentro del propio ciclo.

Haga mientras

Corresponde al ciclo do-while, bastante similar al caso del while pero con 2 diferencias. Este ciclo se ejecutará al menos 1 vez aunque la condición no se cumpla y el while del final debe ir con punto y coma, o sea:

do
{
sentencia 1;
sentencia 2;
sentencia 3;
}while(condición);

Tal como en pseudolenguaje, hay ocasiones ideales para el uso de cada tipo de ciclo, pero en muchas ocasiones podemos usar cualquiera de los 3 y dependerá más que nada del gusto personal.

A continuación veremos un ejemplo en donde utilizaremos los 3 ciclos para resolver un mismo problema.

Ejercicio: Enumerar del 1 al 10 utilizando los 3 ciclos vistos hasta ahora.

#include
#include
#include

int numero;

int main()
{
numero=1; // Asignamos el valor inicial a la variable
while(numero<=10) // Partimos con un ciclo while
{
printf(“%d\n”,numero); /* Mostramos el número y utlizamos \n para hacer salto de línea */
numero++; // Incrementamos el valor
}

for(numero=1;numero<=10;numero++) // Seguimos con un ciclo for especificando los parámetros
{
printf(“%d\n”,numero); // Mostramos el número
}
numero=1; // Reinicializamos el número a 1

do // Terminamos con un ciclo do-while
{
printf(“%d\n”,numero); // Mostramos el número
numero++; // Incrementamos el valor
}while(numero<=10); // Definimos la condición
getch(); // Dejamos el programa en espera

}

Luego de compilar y ejecutar podemos ver que como resultado se enumerará del 1 al 10, 3 veces seguidas, 1 por cada ciclo que definimos.

5.- Ejercicio: Programando un terminal de venta simple.

Ahora que hemos visto aspectos básicos del lenguaje C, desarrollaremos un ejercicio en el que combinaremos todos los conocimientos adquiridos hasta ahora.

Lo que haremos será programar un terminal de venta simple, en donde primero desplegaremos una lista de productos, luego pediremos el código del producto, la cantidad que se desea llevar y mostraremos el total a cancelar. No nos complicaremos mucho y en el futuro iremos añadiendo nuevas funcionalidades. Así que manos a la obra:

#include
#include
#include

int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos, todas de tipo int */

int main()
{
printf(“\t Lista de productos\n”); /* Partimos por listar los productos, utilizamos \t para separar los textos, tal como si utilizaramos la tecla TAB */
printf(“Codigo\t Nombre\t Precio\n”);
printf(“1\t Silla\t 100\n”);
printf(“2\t Puerta\t 350\n”);
printf(“3\t Sillon\t 200\n”);

printf(“\nIngrese el codigo del producto que desea llevar: “); /* Solicitamos el código del producto*/
scanf(“%d”,&codigo); /* Leemos el código */
printf(“\nIngrese la cantidad que desea llevar: “); /* Solicitamos la cantidad que llevarán */
scanf(“%d”,&cantidad); /* Leemos la cantidad */

if(codigo==1) /* Comparamos mediante iteraciones el código para asignar el valor total */
valor=100;
if(codigo==2)
valor=350;
if(codigo==3)
valor=200;

total=valor*cantidad; /* Multiplicamos el valor por la cantidad para obtener el total */

printf(“\nEl total es de: %d”,total); /* Mostramos el total */
printf(“\nIngrese el pago: “); /* Solicitamos el pago */
scanf(“%d”,&pago); /* Leemos el pago */
if(pago/* Vemos mediante un if si el pago es suficiente */
printf(“\nEl pago no es suficiente”);
else
{
vuelto=pago-total; /* Obtenemos el vuelto */
printf(“\nEl vuelto es de: %d”,vuelto); /* Mostramos el vuelto */
}
printf(“\nVenta finalizada”); /* Damos el mensaje de despedida */
getch();

}

Y así tenemos nuestro simple terminal de venta. Como podemos apreciar, este programa no es lo suficientemente óptimo, ya que solo podemos realizar 1 venta por sobre 1 sólo producto, así que su aplicación es bastante limitada. Para poder realizar múltiples ventas o 1 venta de múltiples productos es necesario el uso de ciclos para poder repetir las acciones necesarias.

Desde ya los incentivamos a que vayan modificando este programa y agregando esa funcionalidad. De cualquier forma en las próximas lecciones le iremos añadiendo más y más cosas a este programa para crear una aplicación mucho más completa.

Con esto damos por terminada la lección de hoy, hemos cubierto bastante y aún nos queda un largo camino por recorrer, así que mucha paciencia.

En la próxima edición de Como aprender a programar y no morir en el intento veremos:

Iteración Switch.
Vectores.
Matrices.
Terminal de venta – 2da parte.

Recuerden que como siempre, este tutorial ha sido:

Esperamos que este tutorial haya sido de utilidad para Uds.

Muchas gracias por leer, y será hasta una próxima oportunidad.

Staff CLH