October 2, 2008
soullost
Programación
5 Comments
Aquí tienen la versión (mi versión, claro) de C++ de un programa que nos ayudará para cuando estemos indecisos. Cuantas veces nos ha pasado que no sabes que hacer, con esto, escogemos tres opciones y nuestra computadora con ayuda de números aleatorios nos va decir que hacer.
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
class QueHacer
{
public:
QueHacer(char [], char [], char []);
private:
int sugerir;
};
QueHacer::QueHacer(char opc1[], char opc2[], char opc3[])
{
srand( time(0) );
sugerir = 1 + rand() % 3;
if( sugerir == 1 )
{
cout<<"Hacer: "<< opc1 << endl;
}
else if( sugerir == 2 )
{
cout<<"Hacer: "<< opc2 << endl;
}
else if( sugerir == 3 )
{
cout<<"Hacer: "<< opc3 << endl;
}
else
{
cout<<" Sopenco!";
}
}
int main(int argc, char *argv[])
{
if(argc != 4 )
{
cout<<"Uso: ./que_hacer [opc1] [opc2] [opc3]"<<endl;
while( cin.get() != '\n' );
}
else
{
QueHacer obj( argv[1], argv[2], argv[3] );
}
return 0;
}
Ejemplo:
soullost@UnderHouse ~/c++/tmp $ g++ que_hacer.cxx -o que_hacer
soullost@UnderHouse ~/c++/tmp $ ./que_hacer "Ir a desayunar" "Seguir en la pc" "Ir a dormir"
Hacer: Ir a desayunar
La idea se ha iniciado en los foros de Picando Codigo (con un script de shell en bash), después fernando lo ha puesto en su blog. Unos días más tarde, hugo_dc lo ha pasado en python y ahora, yo lo he escrito en C++.
Esto podría convertirse en una meme para programadores 
y tal vez, podría competir con el ya famoso: Hola Mundo!!..
PD: Por ahora, hoy no he tenido dolores de cabeza 
.
Califica el tema:
Loading ...
September 20, 2008
soullost
Lenguaje Ensamblador, Programación
No Comments
Una aclaración antes de empezar. El lenguaje ensamblador tiene mucho que ver con arquitectura de computadoras (http://es.wikipedia.org/wiki/Arquitectura_de_computadores) y de hecho, trabaja con muchos conceptos que se generan a partir de esta. No voy a explicar cada uno de estos conceptos, lo que voy hacer es, tratar de dar las bases para que entiendan “cómo” empezar a crear programas en lenguaje ensamblador. Así que, si quieren una base teórica más profunda, pueden buscar referencias en otra parte.
¿Lenguaje ensamblador?
Según wikipedia: http://es.wikipedia.org/wiki/Lenguaje_ensamblador
El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de computadoras legible por un programador.
Fue usado ampliamente en el pasado para el desarrollo de software, pero actualmente sólo se utiliza en contadas ocasiones, especialmente cuando se requiere la manipulación directa del hardware o se pretenden rendimientos inusuales de los equipos.
Conceptos básicos.
El lenguaje ensamblador tiene contrastes con los lenguajes de programación de alto nivel.
- La estructura de un programa hecho en lenguaje ensamblador es diferente a los lenguajes de alto nivel.
- El lenguaje ensamblador trabaja más directamente con el hardware (con registros del microprocesador, memoria, dispositivos,..,etc.).
- El sistema numérico por excelencia no es el decimal.
Para nuestros programas, disponemos de varios registros, 4 de lo más importantes son:
AX - Acumulador.
BX - Base.
CX - Contador.
DX - Registro.
Cada uno de estos es de 16 bits. Se puede usar sólo la mitad de esos 16 bits, seleccionando la parte correspondiente del registro. Cada uno de estos registros están formados por su parte baje y su parte alta de 8 bits.
Nota: Para el manejo de aplicaciones de 32 bist, los registros pasan a ser: EAX, EBX, ECX, EDX,..,etc.
http://es.geocities.com/e0n_ftp/TallerASM/Imagen1.jpg” alt=”Registros 32bits” />
Existe otro registro importante, es el registro de banderas. El registro de banderas (flags) te proporcionará información al hacer uso de varias operaciones (suma (ADD), por ejemplo).
Otra cuestión importante a mencionar son las Interrupciones. Las interrupciones son un conjunto de instrucciones que detiene el flujo de un programa para hacer una tarea determinada. Por ejemplo, la captura de un carácter del teclado es una interrupción.
Estructura de un programa en lenguaje ensamblador.
No existe una convención establecida para la estructura de un programa en lenguaje ensamblador (no como sucede con otros lenguajes, como C/C++). Como regla de oro, es necesarios la declaración de dos segmentos, la de código (CODE) y la de pila (STACK). En total, hay 4 segmentos principales: Segmento de datos, Segmento de código, Segmento de pila y Segmento Extra.
La diferentes segmentos tienen las siguientes funciones:
Segmento de datos: Contiene la dirección donde inicia la declaración de variables. Aquí, escribiremos nuestras variables.
Segmento de código: Contiene la dirección de inicio donde se encuentran las instrucciones del programa. Aquí, escribiremos todo el código de nuestro programa
Segmento de pila: Contiene la dirección donde se encuentra la pila.
Segmento Extra: Contiene la dirección donde podemos almacenar datos extras.
Hay que aclarar que si existen directivas dependiendo del programa ensamblador (http://es.wikipedia.org/wiki/Assembler) que se utilicé (en mi caso, estoy utilizando TASM como programa ensamblador). En TASM las declaraciones de los segmentos se hace de la forma: .[SEGMENTO].
Para declarar la estructura de un programa básico (que no hace nada), sería de la forma:
; Define el modelo de memoria
;
.MODEL SMALL ; Modelo de memoria
.STACK ; Se necesita una PILA.
.CODE ; Area de codigo
Empieza: ; Etiqueta de comienzo de programa
mov Ax,4c00h ; Regresa a MS-DOS por medio de la
int 21h ; funcion 4c.
END Empieza ; Fin del programa
En TASM también es necesario especificar el modelo de memoria. Además, hay que especificar la función (4c00h) de salir del programa mediante la interrupción 21h de MSDOS, si no, el programa nunca termina y nunca vamos a regresar al prompt.
Programando en lenguaje ensamblador.
Para programar en ensamblador es necesario conocer las instrucciones con las que podemos realizar nuestras tareas. Estas instrucciones se llaman mnemónicos (http://es.wikipedia.org/wiki/Mnemónico). Tienen la siguiente sintaxis:
[nombre] mnemónico [operandos] [;comentarios]
[nombre]. Es una etiqueta que se puede usar (es opcional) para controlar el flujo de nuestro programa.
mnemónico. Es la instrucción a usar.
[operandos]. Son los operandos con los que va a trabajar.
[;comentarios]. Comentarios.
Ejemplo: MOV AX,BX.
Si buscamos la definición de MOV, nos vamos a encontrar que mov sirve para pasar datos de un registro a otro. En este caso, pasamos los datos de BX a AX.
Declaración de variables. La declaración de variables se hace en el segmento .DATA. La sintaxis es de la siguiente forma:
[nombre] Tipo [valor]
Tipo de datos:
DB (bytes), DW (palabras), DD (palabra doble), DQ (palabra cuádruple), DT (diez bytes)
Ejemplo:
Mensaje DB 'Bienvenido!.$' ; Cadena a desplegar
Interrupciones. Existen diversas interrupciones de las que podemos hacer uso. Lo más importante no es aprendernos todas, si no tener una referencia donde fijarnos si existe una interrupción para lo que queremos hacer. Entre las que más se ocupan, son las de MSDOS (si trabajamos en un ambiente con él) y las del BIOS.
Ejemplo:
Interrupción: 21h
Entrada (rutina/función): AH=01h
Descripción: Espera entrada desde el teclado (un carácter).
Salida: Lo que tecleemos lo coloca en el registro AL.
mov Ah,01h ; Llamamos a una funcion del MSDOS
int 21h ; para leer un caracter del teclado
Ejemplo práctico y descripción.
Suma de dos valores de una sola cifra:
.MODEL SMALL ; Modelo de memoria
.DATA ; Segmento de datos
Mensaje DB 'Programa para sumar: $' ; Cadena a desplegar
.STACK ; Se necesita una pila
.CODE ; Area de codgio
Main: ; Etiqueta de comienzo del programa
mov Ax, @Data ; Inicializa DS con la direccion de
mov Ds, Ax ; @data
mov Dx, Offset Mensaje ; Direccion de mensaje en DX
mov Ah, 9h ; para poder desplegarloa traves de
int 21h ; la Int 21h de MSDOS
mov Ah,01h ; Llamamos a una funcion del MSDOS
int 21h ; para leer un caracter del teclado
sub Al,30h ; Ajuste de caracter a numero
mov Bl,Al ; Pasamos el contenido de AL a BL
; Llamamos a una funcion del MSDOS
int 21h ; para leer un caracter del teclado
sub Al,30h ; Ajuste de caracter a numero
mov Cl,Al ; Pasamos el contenido de AL a CL
add Bl,Cl ; Realizamos operacion
add Bl, 30h ; Convertimos resultado a ASCII
mov DX,BX ; Copiamos BX a DX para presentar en
; pantalla
mov ah,02h ; Int 02h mostrar caracter
int 21h ; Muestra en pantalla el valor de DL
mov Ax, 4c00h ; Regresa al MSDOS por medio de la
int 21h ; funcion 4c
END Main ; Fin del programa
Voy a tratar de explicarlo por partes:
Definición de datos e inicio de programa.
.DATA ; Segmento de datos
Mensaje DB 'Programa para sumar: $' ; Cadena a desplegar
Simplemente definimos un mensaje a mostrar en pantalla. Para mostrarlo:
mov Ax, @Data ; Inicializa DS con la direccion de
mov Ds, Ax ; @data
En esta parte, obtenemos la dirección donde inicia el segmento de datos y lo pasamos a Ax, de Ax a Ds.
mov Dx, Offset Mensaje ; Direccion de mensaje en DX
mov Ah, 9h ; para poder desplegarla traves de
int 21h ; la Int 21h de MSDOS
Ahora hacemos un offset a la dirección donde apunta la variable Mensaje, con esto, obtenemos la dirección de Mensaje en DX.
¿Para qué pasamos las direcciones correspondientes a DX y DS?. Porque la rutina Ah=09h de la interrupción 21h (que sirve para desplegar una cadena de caracteres por la pantalla de MSDOS), ocupa estos registros para encontrar la cadena de caracteres a mostrar.
Información de la interrupción.
Sacar un string a la pantalla
INT 21H AH = 9H
Descripción: Su función es la de sacar una cadena de caracteres ASCII por pantalla.
Uso: Entrada: AH = 9H
DS contiene el valor de la dirección del segmento del comienzo de la cadena de caracteres a sacar.
DX contiene el offset de dicha cadena en el segmento anterior.
El último byte de la cadena de caracteres debe ser el carácter $, que no se muestra en pantalla.
Salida: Ninguna
Registros afectados: AX
Captura de datos.
mov Ah,01h ; Llamamos a una funcion del MSDOS
int 21h ; para leer un caracter del teclado
sub Al,30h ; Ajuste de caracter a numero
mov Bl,Al ; Pasamos el contenido de AL a BL
Esta interrupción ya se explicó anteriormente, obtenemos el carácter que pulsamos en Al. Después, pasamos el valor ASCII a numérico para proceder con la operación. Además, respaldamos el número en Bl (para poder ingresar el siguiente número).
La conversión se lleva a cabo restando 30h al valor que pulsamos. Ejemplo, si pulsamos un 3, el valor que se asigna a Al es 33 en hexadecimal (33h), hacemos la operación: 33h -30h = 3h. 3h = 3 en Decimal.
int 21h ; para leer un caracter del teclado
sub Al,30h ; Ajuste de caracter a numero
mov Cl,Al ; Pasamos el contenido de AL a CL
Lo mismo que lo anterior, pero ahora, respaldamos en valor numérico en Cl.
Suma.
add Bl,Cl ; Realizamos operacion
Se hace la suma. Ejemplo: 3+2 =5. El resultado se guarda en Bl con un valor de 5h.
Muestra del resultado.
add Bl, 30h ; Convertimos resultado a ASCII
mov DX,BX ; Copiamos BX a DX para presentar en
; pantalla
mov ah,02h ; Int 02h mostrar caracter
int 21h ; Muestra en pantalla el valor de DL
Antes de mostrar el carácter, debemos convertir el valor número a ASCII para mostrarlo en pantalla. Así que, le sumamos 30h. Siguiendo con el ejemplo anterior:
5h + 30 h = 35h.
3 * 16^1 = 48.
5 * 16^0 = 5.
48 + 5 = 53. El carácter ASCII del valor 53 es ‘5′.
La rutina 02h muestra el carácter que se encuentre en Dl (por eso pasamos el valor de BX a DX, igual sólo se pudo haber pasado la parte baja de los dos registros correspondientes).
Terminación de programa.
mov Ax, 4c00h ; Regresa al MSDOS por medio de la
int 21h ; funcion 4c00h
END Main ; Fin del programa
Regreso al prompt del msdos y termina el programa (END). El Main indica en que etiqueta inicia el programa, en este caso, sólo se maneja esa.
Captura de pantalla:
Quickpost this image to Myspace, Digg, Facebook, and others!
Conclusión.
El lenguaje ensamblador no se limita a un programa de suma y resta (o similares), tiene aplicación en muchas áreas, como la electrónica digital, cracking, .., etc. Espero que con el articulo tengan una idea mejor sobre lo que trata el lenguaje ensamblador y cuando menos, dar las bases para que se animen a probarlo. Nos vemos.
Mirror: http://foros.hackerss.com/t8496/lo-que-he-entendido-del-lenguaje-ensamblador
Califica el tema:
Loading ...
September 13, 2008
root
GNU/Linux, Lenguaje Ensamblador, Programación
4 Comments
Resulta que a pesar de tener alternativas libres y más actualizadas para trabajar en lenguaje ensamblador (sintaxis de Intel), en la universidad, nos piden que trabajemos con TASM. Quiero creer que es porque el laboratorio que se asignó para la materia tiene computadoras IBM PC (no sé exactamente el modelo pero, creo son del año en que nací) bastante viejas con un flamante Windows 98. El caso es que, era una tontería (al menos para mi) arrancar la maquina virtual de Windows XP para trabajar en TASM, así que, terminé instalando TASM en Dosbox 
.
Dosbox según Wikipedia:
DOSBox es un emulador que recrea un entorno similar al sistema DOS con el objetivo de poder ejecutar programas y videojuegos originalmente escritos para el sistema operativo MS-DOS de Microsoft en ordenadores más modernos o en diferentes arquitecturas (como Macintosh). También permite que estos juegos funcionen en otros sistemas operativos como GNU/Linux.
DOSBox es software libre, y está disponible para muchos sistemas operativos, como Linux, FreeBSD, Windows, Mac OS X, OS/2 y BeOS. Incluso recientemente ha sido adaptado a las consolas portatiles PSP y GP2X.
La versión de Dosbox que estoy utilizando es la 0.72. Cabe destacar que Dosbox utiliza un fichero de configuración que hay que crear con la siguiente instrucción: config -writeconf dosbox.conf, en la línea de comandos del MSDOS al arrancar Dosbox, esto, creará un archivo dosbox.conf en el directorio home de nuestro usuario (/home/soullost, en mi caso). Además del archivo de configuración de Dosbox, otra de las primeras cosas que tenemos que hacer es crear la Unidad C:\, ya qué, Dosbox por defecto sólo cuenta con una unidad virtual llamada Z:\, donde, dispone de los archivos elementales de un ambiente normal de DOS. Para tal motivo contamos con el comando mount, muy al estilo Unix (para más detalles, consultar el Wiki de Dosbox), procedemos a crear la unidad C:\ a partir de un directorio físico de nuestro disco: mount c /home/soullost/dos. Hay que tener en cuenta que el montaje sólo dura hasta que cerremos el programa, podemos, hacer que se cargue automáticamente al iniciar Dosbox mediante su archivo de configuración, especificamente en la sección [autoexec]. Quedando:
[autoexec]
# Lines in this section will be run at startup.
mount c /home/soullost/dos
c:
Ahora si, estamos listos para instalar programas en ambiente DOS. Yo instalé TASM y un IDE para programar en ensamblador:
El IDE Asm Edit lo pueden descargar de la siguiente dirección: http://www.o-love.net/asmedit/ae_down.html. Tiene un ambiente muy parecido al famoso Turbo C++, por lo que, podemos agilizar la tarea de compilar y ejecutar los programas que realizamos (eso de usar comandos para compilar cada programa que se realiza, es muy aburrido, además necesitaba un editor para crear los programas porque Dosbox no dispone de ninguno), también, se puede invocar al turbo debugger desde ahí y regresar al editor cuando terminemos de usarlo. Sólo tuve un único problema al configurar el Asm Edit y es que, los archivos DPMI16BI.OVL y RTM.EXE son incompatibles con la versión que instalé de TASM (5.0), basta entonces, con reemplazarlos por los archivos que se encuentran en la carpeta BIN de TASM (C:\TASM\BIN, no es necesario usar conmandos de DOS, se puede copiar desde nautilus, en caso de GNOME). Aqui algunas capturas de cómo he configurado el IDE:
Hay que cambiar los directorios donde instalamos el TASM (TASM.EXE, TLINK.EXE, TD.EXE). Ojo, para que queden grabadas para la próxima vez que se inicie el programa hay que seleccionar Options > Save [ASMEDIT.DSK]:
También, los directorios donde se guardarán los archivos generados durante la compilación:
Si todo está correcto, puede empezar a ejecutar sus programas en ensamblador:
.
Por último, les dejo mi archivo de configuración de dosbox para ganar un poco de velocidad al ejecutar Asm Edit (ya que se sentía lento, antes de hacer las modificaciones), claro, que he probado y me han funcionado a mi; y, el archivo fuente de Hola, que tal!. que se muestra en las capturas:
Archivo ASM.
;***************************************************************************
; Nombre del programa: MENSAJE.ASM
;***************************************************************************
; COMANDO DE ENSAMBLE : MASM MENSAJE;
; COMANDO DE ENLACE : LINK MENSAJE;
; COMANDO DE EJECUCION : MENSAJE [Enter]
;***************************************************************************
;
; Define el modelo de memoria
;
.MODEL SMALL ; Modelo de memoria
.DATA ; Segmento de datos
Mensaje DB 'Hola, que tal !.$' ; Cadena a desplegar
.STACK ; Se necesita una PILA.
.CODE ; Area de codigo
Empieza: ; Etiqueta de comienzo de programa
mov Ax, @Data ; Inicializa DS con la
mov Ds, Ax ; direccion de @Data
mov Dx, Offset Mensaje ; Direccion de Mensaje
mov Ah, 9 ; en Dx para poder desplegarlo
Int 21h ; a traves de la Int 21 de MS-DOS.
mov ax,4c00h ; Regresa a MS-DOS por medio de la
int 21h ; funcion 4c.
END Empieza ; Fin del programa
Archivo de configuración: Descargar.
Nos vemos.
Califica el tema:
Loading ...
June 7, 2008
soullost
Desarrollo web, GNU/Linux, Programación
No Comments
Gedit [gnome.org] es el editor predeterminado del entorno de escritorio GNOME ( que uso diariamente ). Algunas de sus características son:
* Soporte de textos internacionalizados, usando la codificación UTF-8.
* Coloreado del texto según la sintaxis de varios lenguajes de programación: C, C++ Java, Python…
* Corrector ortográfico multi-idioma.
* Incorporación de plugins para ampliar las funcionalidades básicas del programa.
* Posibilidad de cambiar el color y fuente del texto del editor.
* Numeración de líneas.
* Búsqueda y reemplazo de texto.
* Edición de archivos remotamente.
* Copia de seguridad de los ficheros sobre los que se trabaja.
* Soporte propio para SCIM, pudiendo escribir en distintos alfabetos como el japonés, chino, etc. activándolo desde el menú y teniendo instalado el SCIM.
…y un largo etcétera de nuevas funcionalidades que se van incorporando en sucesivas versiones.
http://es.wikipedia.org/wiki/Gedit.
Y bueno, navegando en busca de las funcionalidad de PHP sobre gedit, me di cuenta que tiene soporte para varios plugins que extienden dicha funcionalidad. No, esto no es guía, más bien, es la recopilación de algunos artículos que tratan del tema que me parecieron interesantes:
Customizing gedit as a Web Developer’s IDE. Esta entrada es de uno de los creadores de precisamente un plugin de gedit, habla sobre sus preferencias al usar Gedit, su plugin, cómo tener a la mano las diferentes etiquetas de (X)HTML/CSS/PHP y de algunas herramientas externas (que es algo como crear scripts para que se integren con el editor).
Usar gEdit como si fuera Dreamweaver (o como IDE Web). Trata de básicamente lo mismo pero en español .
Haciendo gedit más sociable para el programador. Este me ha gustado por la mención de algunos ejemplos sobre una de las características de gedit, que es la de Recortes (insertar texto que usamos seguido de forma rápida).
Ahora la pregunta obligada: Cuál es mi aporte al tema? xD, ps ninguno 
(no, mentira). Si leyeron algunas de las entradas de blog anteriores, seguramente se dieron cuenta sobre un complemento en gedit que se llama “Herramientas Externas” (External Tools) o en el peor de los casos , están fastidiados por ir al navegador y escribir la URL de la página que están creando (gedit nativa-mente no puede mandar a mostrar en el navegador predeterminado de GNOME la página que estén programando). Entonces, hice un pequeño script para poder mandar al navegador la página actual que se esté editando, para crearlo habrá que ir a Editar > Preferencias > Plugins y seleccionar Herramientas Externas, pulsar en Configurar Plugin. Crear uno nuevo con las siguientes características:
El script es:
#!/bin/sh
# By soullost.org xD
USER=`id --name -u`
NUMBER=`ls -d /home/${USER}/public_html/ | wc -m`
CUT=`echo cut -c${NUMBER}-`
DIR=`echo $GEDIT_CURRENT_DOCUMENT_DIR | $CUT`
NAME=`echo $GEDIT_CURRENT_DOCUMENT_NAME`
if [ -n "$DIR" ]
then
URL=`echo http://localhost/~${USER}/${DIR}/${NAME}`
else
URL=`echo http://localhost/~${USER}/${NAME}`
fi
gnome-open $URL > /dev/null 2> /dev/null
Limitaciones del script:
- Hay que tener configurado el Apache para poder tener una carpeta (public_html) en nuestro home (/home/[usuario]/public_html/) y almacenar ahí nuestras páginas web. Esto hace que al acceder desde el navegador, la URL tenga que escribirse así: http://localhost/~[usuario]/. Por lo tanto, la página web a visualizar tiene que estar dentro de este directorio (si no es así, no va a funcionar!).
- gnome-open toma el navegador predeterminado que se especifica en: Sistema > Preferencias > Aplicaciones Preferidas. Yo tengo a epiphany para que abra un nuevo enlace en una pestaña nueva .
Uso:
- Si está todo bien, cuando quieras visualizar la página web que estés editando basta con pulsar Ctrl + F12.
Nota: Por supuesto, te puedes sentir libre de modificar el script a tus necesidades (sólo basta saber un poco de bash).
Espero les sea útil. Nos vemos y a programar con Gedit 
.
Califica el tema:
Loading ...
May 6, 2008
soullost
Desarrollo web, Programación
4 Comments
Ya tiene algo de tiempo desde que empecé a programar en PHP, desde luego, nada serio. Actualmente estoy tomando un curso de PHP en la universidad (no forma parte de alguna materia xD), ya más serio, lleva algo de CSS, MySQL, POO. Así que bueno, ahora estaré escribiendo en una nueva categoría, Desarrollo Web.
Ya que este viernes pasado no asistimos, nos dejaron algunos ejercicios para hacer, de los cuales uno es hacer una pequeña encuesta. Veamos, a simple vista necesitamos:
- La pregunta.
- Las opciones.
- Algunas estadísticas.
- Manejo de Base da Datos.
Para empezar, hacemos el formulario con la pregunta y las opciones:
¿América ganará su próximo partido?
La página se llamará así misma al momento de hacer el voto, entonces, procesará la información a la base de datos para almacenar los valores. Además, si observan, hay que mostrar el número de votantes y el porcentaje de votos para las dos diferentes opciones (si y no).
La base de datos se llamará encuesta1 y es la siguiente (Ojo, por prisa lo hice de la forma menos apropiada xD):
-- phpMyAdmin SQL Dump
-- version 2.8.2.4
-- http://www.phpmyadmin.net
--
-- Servidor: localhost
-- Tiempo de generación: 25-04-2008 a las 18:43:50
-- Versión del servidor: 5.0.24
-- Versión de PHP: 5.1.6
--
-- Base de datos: `ENCUESTA1`
--
-- --------------------------------------------------------
--
-- Estructura de tabla para la tabla `opciones`
--
CREATE TABLE `opciones` (
`id` int(10) unsigned NOT NULL auto_increment,
`nombre` char(30) NOT NULL,
`valor` int(10) unsigned NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `id` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;
--
-- Volcar la base de datos para la tabla `opciones`
--
INSERT INTO `opciones` (`id`, `nombre`, `valor`) VALUES (1, 'Si', 0),
(2, 'No', 0);
Como ven, registramos las dos opciones de la encuesta: Si y No, estableciendo las dos con un valor inicial de cero (ya que nadie ha votado todavía). Una vez teniendo la base de datos tenemos que hacer varias cosas (empezar a armar el funcionamiento de la página web):
1) Conexión con la base de datos:
< ?php
$link=mysql_connect ("localhost","admin","*****") or die ("Error en la conexion");
//se selecciona la base
mysql_select_db("ENCUESTA1",$link);
?>
2) Registrar el voto del usuario:
< ?php
if($_POST['opc']=='si'){
$valor[0]++;
$sql="update opciones set valor=$valor[0] where id='1';";
mysql_query($sql) or die('Lo sentimos, hay un error en la BD');
}
elseif($_POST['opc']=='no'){
$valor[1]++;
$sql="update opciones set valor=$valor[1] where id='2';";
mysql_query($sql) or die('Lo sentimos, hay un error en la BD');
}
?>
$valor[], es un array que contiene las veces que el usuario a votado por dicha opción. $valor[0] para la opción Si, $valor[1] para la opción No. Estos valores junto con el total de votos los sacamos en la siguiente parte:
< ?php
$sql="select * from opciones";
$res=mysql_query($sql);
$total=0;
$indice=0;
while($fila=mysql_fetch_object($res)){
$total += $fila->valor;
$valor[$indice]=$fila->valor;
$indice++;
}
?>
Para obtener el porcentaje de votos de cada opción respecto al total de los mismo, necesitamos, una pequeña operación aritmética (la clásica regla de 3):
< ?php
$porcentaje[0]=intval(($valor[0]*100)/$total);
$porcentaje[1]=intval(($valor[1]*100)/$total);
?>
Nota: la función intval() regresa el valor entero de una variable.
3) Lo único que hace falta es agregar las estadísticas (mostrar a los usuarios como va la votación), eso lo he puesto abajo de la encuesta (mirar el código html al principio). Entonces, falta sólo agregar el código PHP que haga lo descrito anteriormente.
Número de votantes: < ?php echo " ".$total; ?>
Si:
< ?php
for ( $i = intval($porcentaje[0]/10); $i>0; $i-=2){ ?>
< ?php } ?>
Porcentaje: < ?php echo " " . $porcentaje[0] . " % con " . $valor[0] . " votos"; ?>
No:
< ?php
for ( $i = intval($porcentaje[1]/10); $i>0; $i-=2){ ?>
< ?php } ?>
Porcentaje: < ?php echo " " . $porcentaje[1] . " % con " . $valor[1] . " votos"; ?>
Si se dan cuenta, debes tener la imagen palomita.gif en el directorio images (me quebré mucho la cabeza buscando-la, que tardé ~1/2 min. en obtenerla de google). Ésta imagen sirve como un pequeño histograma del porcentaje que ocupa la opción en comparación con el total de votos emitidos (que ya calculamos antes).
Una forma de hacer el histograma es de una escala de 20%, osea, quedaría:
1 Palomita: 20%
2 Palomitas: 40%
3 Palomitas: 60%
4 Palomitas: 80%
5 Palomitas: 100%
Por ejemplo, si el porcentaje de la opción Si es 40.5%, divididos sobre 10, es igual a 4 (el resultado lo deja sin decimales por la función intval()). El for toma este 4 y en cada ciclo le resta 2 y coloca una palomita; hasta que este 4 sea menor que cero. En el ejemplo del 40%, realizará 2 ciclos y por lo tanto, dibujará la palomita dos veces .
La página final queda de esta manera:
Código:
< ?php
$link=mysql_connect ("localhost","admin","******") or die ("Error en la conexion");
//se selecciona la base
mysql_select_db("ENCUESTA1",$link);
//consulta
$sql="select * from opciones";
$res=mysql_query($sql);
$total=0;
$indice=0;
while($fila=mysql_fetch_object($res)){
$total += $fila->valor;
$valor[$indice]=$fila->valor;
$indice++;
}
$porcentaje[0]=intval(($valor[0]*100)/$total);
$porcentaje[1]=intval(($valor[1]*100)/$total);
if($_POST['opc']=='si'){
$valor[0]++;
$sql="update opciones set valor=$valor[0] where id='1';";
mysql_query($sql) or die('Lo sentimos, hay un error en la BD');
}
elseif($_POST['opc']=='no'){
$valor[1]++;
$sql="update opciones set valor=$valor[1] where id='2';";
mysql_query($sql) or die('Lo sentimos, hay un error en la BD');
}
/*
elseif(!$_POST['opc']){
echo "
No se ha seleccionado nada!.
";
}*/
?>
¿América ganará su próximo partido?
< ?php mysql_close($link); ?>
Obviamente se puede mejor bastante, agregando CSS, Ajax y cualquier cosa que se nos ocurra (hasta llegar a crear un sistema que cree encuestas).
Califica el tema:
Loading ...
