miércoles, 20 de julio de 2011

Conectando Oracle con PHP (PDO)

 En esta ocasion veremos cómo hacer una conexión mediante PHP y Oracle, para esto nos basaremos en el objeto PDO mencionado anteriormente, hasta aquí se asume que ya está configurado el php.ini para usar el respectivo driver (Si no es así, puedes ver el artículo sobre la configuración del PDO aquí ).

Empecemos...

Voy a explicarles, línea por línea, posteriormente, mostraré el código completo.

La Conexión...
1. Para la conexión a Oracle, necesitaremos 3 datos indispensables:
  1. El listener o la cadena de host a conectarnos.
  2. La Contraseña.
  3. El Usuario
-Así pues,  para facilitar la visualización del código, declararemos 3 variables; la primera de ellas es la más larga, esta variable almacenará un TNSNAME, esto con el fin de que nuestra conexión sea exitosa; sin embargo, existe otra forma más corta, por el momento, en este ejemplo usaré la más robusta y eficaz de todas.

$tns="(DESCRIPTION=(ADDRESS_List=
                                   (ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521))
                      )
                      (CONNECT_DATA=
                              (SERVICE_NAME=DB1)
                      )
         )" ;
*En este punto, los tres campos que podrías modificar son:
  • HOST: Este se modifica en caso de que la Base de Datos se encuentre en otro host, diferente servidor, de lo contrario puede quedarse así tal cual se muestra (O escribir "localhost"). 
  • PORT: El puerto por defecto es el 1521, a excepción de que lo hayas modificado. 
  • SERVICE_NAME: Este pertenece a la base de datos, en muchas bases, se maneja el nombre de "orcl" por ejemplo.
-Posteriormente declararemos nuestras variables de usuario y contraseña.

$user="pruebas" ; //El nombre de usuario
$pass="daniboy"; //La contraseña
2. Ahora, nos centraremos en la creación del objeto que nos permitirá conectar a la Base de Datos.  Este objeto lo almacenaremos en una variable:
                $conexion =new PDO("oci:dbname".$tns,$user,$pass);

La cadena "oci:dbname:" es usada por el driver para generar la conexión, además de los parámetros ya mencionados.
A pesar de que la línea anterior nos permite conectar a la Base de Datos, puede ser que esta no exista, para tal caso, colocar la línea dentro de un bloque try/catch nos permitirá saber si la conexión fue exitosa.
try
{
      $conexion =new PDO("oci:dbname".$tns,$user,$pass);
      echo "Accediendo...";
} 
catch ( PDOException $e )
echo "Error: ".$e->getMessage( );  }
3. Capturar una excepción de esta forma, sólo nos limita a que aparezca el mensaje de error cuando no se pueda conectar a la base de datos, pero ¿Qué sucede si una transacción no se termina correctamente debido a algúna anomalía de integridad o alguna otra causa? Simplemente la excepción no nos mostraría nada (Esto se debe a los valores por defecto con que el objeto PDO se crea). Para poder activar la excepción cuando se produzca un error, basta con  colocar el atributo PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION en el método setAttribute del objeto PDO:
 $conexion->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
 Ahora nuestro bloque podrá capturar excepciones tanto a nivel de conexión, como a nivel de transacciones.

Las transacciones...
1. Realizar una operación como Insertar, Borrar, Modificar es una tarea fácil, para esto, el objeto cuenta con el método exec, el cual admite un parámetro que será nuestra  sentencia SQL.
  Para demostrar esto, insertaremos un registro en una tabla llamada prueba2.

          $inser="insert into prueba2 values('x',1,'z')"; //Cadena con la instrucción insert
          $conex->exec( $st );
//Ejecutamos la transacción
          
echo "La transacción fue realizada exitosamente";
            
Si la operación ha sido realizada exitosamente, se mostrará el mensaje "La transacción fue realizada exitosamente" de lo contrario, saltará al catch.

2. Una vez que hayamos insertado nuestro registro, nos dispondremos a ver si realmente se ha guardado además de ver las otras filas que existen en la tabla prueba2.

    Para esto, usaremos tres funciones: prepare, executefetchAll. La primer función(prepare) almacena la consulta que vayamos a ejecutar; la segunda función (execute) precisamente se encarga de eso, de ejecutar la sentencia; por último, la función fetchAll nos devolverá un arreglo, en el cual cada registro obtenido se almacena también como un arreglo, es decir se produce un arreglo que contiene 'x' arreglos de filas.

    Aunque toda esta definición parece ser muy difícil de llevarla a la práctica, en realidad no demuestra ser gran ciencia, para mostrar los datos, usaremos un ciclo foreach para recorrer todo el arreglo, también usaremos la herramient list ( ) para obtener los valores por cada fila (En este caso, la tabla sólo contiene tres campos).

$st=$conex->prepare("Select * from prueba2"); //La función devuelve un statement object

            $st->execute( );

            $resultado=$st->fetchAll( ); //El resultado lo guardamos en una variable diferente.

            foreach($resultado as $mat//Por cada arreglo guardalo en $mat
            {
              //Declaro mi list con tres variables, cada una tendrá el valor de cada columna por registro.
               list($c1,$c2,$c3)=$mat;    
                //Mandamos a imprimir en pantalla
                  echo "$c1---$c2--- $c3";
            }
Con esto el código quedaría de la siguiente manera:
< ?php
 
$user="pruebas" ; 
$pass="daniboy"; 
$tns="(DESCRIPTION=(ADDRESS_List=
                                   (ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521))
                      )
                      (CONNECT_DATA=
                              (SERVICE_NAME=DB1)
                      )
         )" ;
try
{
      $conexion =new PDO("oci:dbname".$tns,$user,$pass);
      $conexion->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
       echo "Accediendo..."
      $inser="insert into prueba2 values('x',1,'z')"; //Cadena con la instrucción insert
     $conex->exec( $st ); //Ejecutamos la transacción
      echo "La transacción fue realizada exitosamente";          
$st=$conex->prepare("Select * from prueba2"); //La función devuelve un statement object
            $st->execute( )
            $resultado=$st->fetchAll( ); //El resultado lo guardamos en una variable diferente.
            foreach($resultado as $mat//Por cada arreglo guardalo en $mat
            {
       //Declaro mi list con tres variables, cada una tendrá el valor de cada columna por registro.
               list($c1,$c2,$c3)=$mat;  
                    echo "$c1---$c2--- $c3"; //Mandamos a imprimir en pantalla
            }//Fin Foreach
  }
catch ( PDOException $e )
echo "Error: ".$e->getMessage( );  }
? >

martes, 19 de julio de 2011

Objetos PDO y los controladores para Bases de Datos- PHP

El PDO (PHP DataObjects) es un objeto que nos brinda una interfaz en PHP para realizar conexiones a bases de datos (Oracle, MySQL, Firebird, Informix, PostgreSQL, etc) y realizar transacciones.

Ventaja de usar PDO
          La interfaz de un objeto PDO, permite usar las mismas funciones sin importar la Base de Datos que vayas a usar (Oracle, MySQL, Informix, etc), esto proporciona un entorno, en el cual sólo nos preocupemos por las operaciones que vayamos a realizar con la Base de Datos. 


¿Cómo instalarlo?
 (*Fuentes: Domine PHP5 -José López Quijado, editorial Alfaomega y http://www.php.net/manual/en/pdo.installation.php)

 En sistemas UNIX (configurar primero la extensión PDO como un módulo compartido):
    ./configure --with-zlib --enable-pdo=shared

Ahora, buscaremos el archivo php.ini y vamos a modificarlo según lo siguiente:

Encontrar la siguiente línea y descomentarla (Es decir, quitarle el  que le precede):
     En  UNIX:
          extension=pdo.so
     En WINDOWS:
           extension=php_pdo.dll
(*Si no aparece,  puedes escribirla en el mismo archivo).


Posteriormente descomentar la línea del controlador correspondiente al motor de la base de datos que vas a usar (Si no aparece la línea en el archivo de configuración, la puedes escribir ahí mismo, pero asegúrate de que no aparezca en otro lado del archivo o no se esté llamando de otra forma genérica. Nota: Ver más abajo sobre drivers genéricos). A continuación se muestran los drivers que se pueden utilizar, según el motor de la base de datos a usar y el sistema operativo.

Motor UNIX Windows
Firebird/Interbase pdo_firebird.so php_pdo_firebird.dll
Informix pdo_informix.so php_pdo_informix.dll
MsSQL pdo_mssql.so php_pdo_mssql.dll
MySQL pdo_mysql.so php_pdo_mysql.dll
Oracle Call Interface pdo_oci.so php_pdo_oci.dll
Oracle Call Interface 8 pdo_oci8.so php_pdo_oci8.dll
ODBC v3 pdo_odbc.so php_pdo_odbc.dll
PostgreSQL pdo_pgsql.so php_pdo_pgsql.dll
SQLite pdo_sqlite.so php_pdo_sqlite.dll
 (-Fin de las fuentes citadas).



No olvidar que...
  • Los controladores deben estar almacenados en la carpeta "ext"  o carpeta de extensiones, del directorio PHP. Asegúrate de que tu controlador (el archivo .dll ó  .so) esté en esa carpeta.
  • Por lo regular  las líneas vienen comentadas, a fin de que sólo se descomente aquella que se vaya a utilizar.

Usando XAMPP....

Si utilizas XAMPP, no hay que preocuparse por buscar y descargar los drivers, estos ya vienen junto con  la instalación. Este punto sólo puedo asegurarlo para Windows, desconozco si en la instalación en los sistemas Unix/Linux sea igual.

Drivers Genéricos...
Puede suceder que, alguno de los drivers citados anteriormente, no se encuentre en el php.ini, sin embargo, esto no quiere decir que no queda de otra más que escribirlo, posiblemente ya exista otra línea con otro driver PDO similar. Por ejemplo:
Seguramente en el php.ini que trae XAMPP no aparezca la línea "extension=php_pdo_mysql.dll" . Sin embargo antes de escribirla, recomiendo que primero busquen la línea:
   extension=php_pdo_mysql_libmysql.dll
Esta línea es equivalente a la anterior. Posiblemente esta última tenga más funcionalidades a comparación de la primera.

Escribir la línea del driver a usar  es la última opción a la cuál recurrir.

Dejar dos drivers iguales activados...
Por otro lado, no intenten dejar dos líneas de drivers iguales descomentadas, ya que el servidor les mostrará una molesta advertencia indicando que el controlador ya está en uso. Por ejemplo, retomando el caso anterior de MySQL, dejen sólo una de las dos líneas descomentadas.




Por mi parte, esto es lo más esencial acerca de lo que hay que saber sobre el PDO y los drivers. Dudas, comentarios, lo que sea, háganmelo saber, saludos.

viernes, 1 de julio de 2011

Un contador de palabras iguales en PL SQL

Este procedimiento permite buscar una palabra a partir de un texto y devolver el número de ocurrencias.

El procedimiento admite dos argumentos, el primero es la cadena (texto) a evaluar y el segundo argumento es la palabra a buscar.


Puntos a tomar en cuenta:



  • Necesitamos tener una variable de tipo number que nos permita guardar el total de las palabras iguales( cont number(3) ).
  • Como PL SQL no tiene una función específica para separar palabra por palabra de una cadena, nos serviremos de las funciones count, substr e instr (más adelante veremos porqué).
  • Debemos tener en cuenta  (para casos más detallistas) por ejemplo  la palabra "Hola" es diferente a "hola", así que lo mejor es darle formato  al texto y a la palabra a buscar, en este caso, lo que yo hice fue poner todo el texto en minúsculas mediante la función lower.
  • Al punto anterior se le añade  también la diferencia por ejemplo entre "Hola." y "Hola", debido a que en la primera existe un punto final, así que debemos de tener en cuenta esos signos de puntuación (;  , . :) , así bien lo que recomiendo es tener una variable por cada caso de signo.
Manos a la obra: 

/* Creamos el bloque con los dos argumentos, el primero es la cadena (párrafo) y el segundo la palabra a buscar.
El procedimiento se llama buscador
*/

create or replace procedure buscador (parrafo in varchar, palabra in varchar)
is
cont number(3):=0; -- Inicializamos el contador a 0
token varchar2(30); -- Almaceno una palabra que termine sin ningun signo de puntuacion.
tokpc varchar2(30); --
Almaceno una palabra que termine con punto y coma.
tokpf varchar2(30); --
Almaceno una palabra que termine con punto final
tokcc varchar2(30); --
Almaceno una palabra que termine con coma
tokdp varchar2(30); --
Almaceno una palabra que termine con dos puntos

/* Almacenaremos en una variable llamada parr el párrafo y le agregaremos un espacio en blanco
   El espacio en blanco es para evitar problemas en los cursores implicitos. 
   En esta variable el parrafo se le da el formato de minúsculas.
*/
parr  varchar2(1000):=lower(parrafo)||' ';
ntoken number(2):=0; -- Para contar si todavia hay palabras en la cadena
begin

 -- Haremos un ciclo para obtener palabra por palabra del párrafo.  
LOOP
-- A partir de la consulta, obtendremos una palabra del párrafo o cadena de texto.
-- La tabla dual viene por defecto y no hay que crearla (Esta es de mucha utilidad). 
select count(substr(parr,0,(instr(parr,' ')-1)))  into ntoken from dual;
 -- Si hay palabras  disponibles,entonces entra al if; de lo contrario saliir del ciclo.
   if ntoken > 0 then
-- Obtenemos cualquier palabra que pueda contener algún o ningún signo de puntuación
    select substr(parr,0,(instr(parr,' ')-1)) into token from dual;
     select substr(parr,0,(instr(parr,'. ')-1)) into tokpf from dual;
     select substr(parr,0,(instr(parr,'; ')-1)) into tokpc from dual;
     select substr(parr,0,(instr(parr,', ')-1)) into tokcc from dual;
     select substr(parr,0,(instr(parr,': ')-1)) into tokdp from dual

-- Comparamos si las palabras obtenidas son iguales a la palabra a buscar
-- En caso de ser cierto, incrementamos el contador.
    if token=palabra or tokpc=palabra or tokcc=palabra or tokpf=palabra or tokdp=palabra then
       cont:=cont+1;
     end if;

-- Aquí simulamos avanzar a la palabra siguiente descartando la palabra anterior.
 select substr(parr,(instr(parr,' ')+1)) into parr from dual;  

else 
  -- Salir de ciclo
  exit; 

end if; 
END LOOP;
DBMS_output.put_line('Palabras encontradas: '||cont);
end;
/


Resultados:

Llamaremos a nuestro procedimiento mediante la instrucción exec y los cuatro ejemplos deben devolver 4 palabras encontradas, las palabras en este color representan la cadena de texto y las que tienen este color, representan la cadena a buscar .
 
exec buscador('Uno. uno dos uno.','uno');
exec buscador('Dos; dos tres dos; ','dos');
exec buscador('Tres: TrEs cuatro tres','tres');
exec buscador('Cuatro, cuaTro cinco, CuATRo','cuatro');





Detalles:
  • La intstrucción count ( ) la utilizamos para verificar si aún podemos obtener alguna palabra del párrafo o cadena de texto.
  •  La instrucción substr ( )  nos ayuda a obtener una cadena, en este caso la combino con la función instr( ) que nos devuelve el índice del primer elemento (que coincida en su segundo argumento) para obtener el límite de una palabra y así obtener una palabra completa.
  • Así también uso las dos últimas funciones para descartar la palabra que hemos comparado y avanzar a una nueva.

domingo, 19 de junio de 2011

Ventanas en Javascript

Javascript nos proporciona 3 tipos de ventanas para interactuar con el usuario.
  • alert( mensaje ) : Una simple ventana para mostrar un mensaje al usuario.
  • prompt ( mensaje, valor ) : Una ventana que nos permite capturar datos por teclado. Recibe dos parámetros, el primero es el mensaje a mostrar; el segundo,  es un valor por defecto. La ventana devuelve el valor que haya tecleado el usuario o bien el valor por defecto en caso de que no se haya tecleado nada.
  • confirm ( mensaje ): Una ventana que nos devuelve un valor booleano (true o false) según la opción que escojamos (Aceptar ó Cancelar).
Ejemplo de la función alert( ):

< script language="Javascript" >
< !--
alert ("Mostrando un mensaje de prueba" );

// Mostrar el contenido de una variable.
var nombre="Daniel";
alert("Valor de la variable cad: "+nombre+" .\nTipo de la variable: "+typeof( nombre ) );

//-- >
< /script >
  El Resultado:

   Ejemplo de la función prompt ( ):
< script language="Javascript" >
     < !--
       //Pediremos por teclado el nombre y edad de una persona y mostraremos los datos en la pantalla.
       var nombre=prompt("Porfavor, teclee su nombre"  "anonimo"); //La palabra 'anonimo' es el valor por defecto
       var edad=prompt("Porfavor, teclee su edad",0); // Cero es el valor por defecto
       alert("Nombre: "+nombre+"\n Edad:"+edad);
    //-- >
 < /script >


Si el usuario tecleó sus datos el resultado sería:



Si el usuario no escribe nada, los valores que habíamos colocado por defecto se almacenarán en las variables; observe que los valores asignados por defecto, aparecen seleccionados en el cuadro de texto:

Ejemplo de la función confirm( )
 < script language="Javascript" >
     < !--
     /*Recuerde que esta ventana devuelve un valor booleano (true ó false) según
       la opción que nosotros seleccionemos: aceptar o cancelar respectivamente.*/
       
     //Declaramos una variable para almacenar
       var opc;
       opc=confirm ("Escoja un botón");
       var boton=(opc==true)?"Aceptar":"Cancelar"; //Operador ternario. Equivalente a un if
          alert("Presionó el boton: "+boton);
    //-- >
 < /script >
El resultado sería alguna de las ventanas inferiores según el botón seleccionado:
Por si se han perdido algo de estos tutoriales de Javascript, aquí les dejo los enlaces hacia mis publicaciones anteriores:
Saludos.

jueves, 16 de junio de 2011

Las variables en Javascript

Javascript es un lenguaje muy flexible al momento de declarar variables, una variable se declara precediendo la palabra "var" antes del nombre de la variable:
var variable;

¿Y donde queda el tipo de dato?
Pues bien, en Javascript una variable puede almacenar tanto enteros, como cadenas, caracteres, flotantes, booleanos, etc. Todos estos se centran en 4 tipos:
  • Number- Para número (reales, flotantes, negativos,etc.).
  • String- Cadenas y caracteres
  • Boolean-Para condicionales true o false
  • Undefined- Para variables que se les ha asignado un valor

Aunque para una variable no importa el tipo de dato al momento de asignarle un valor, por ejemplo:

 < script language="Javascript" >
     < !--
var x="La variable almacena una cadena";
alert( x ); //Mostramos el valor de x
x=12;
alert(x); //Nuevamente lo volvemos a mostrar
     //-->
 < /script >
El resultado sería:


Aunque esto incluye algunas excepciones. Por ejemplo, el resultado de sumar un valor de tipo String y un Number no puede ser lo que esperaríamos.

var x="10";
x=x+10;
alert (x);// Aquí podriamos esperar el número 20 como resultado.


Como vemos lo que ha sucedido fue una concatenación del valor de x y el número 10.
Si nosotros no queremos eso, basta con llamar a la función parseInt( variable).
var x="10";
x=parseInt( ) +10;

alert (x);// El resultado será 20

 ¿Cómo saber el tipo de dato que mi variable tiene?
La función typeof( variable ) nos devuelve el tipo de dato que tiene nuestra variable:

var x="10";
alert ( typeof( x ) );
x=10;
alert ( typeof( x ) );
x=true; //booleano
alert ( typeof( x ) );
Y el resultado sería:


 Así pues es como uno puede declarar una variable y mediante la función typeof( ) uno puede saber qué tipo de dato está almacenando la variable.

sábado, 11 de junio de 2011

Javascript Estructura Básica

Javascript es un lenguaje interpretado y orientado a html; por tanto, no necesitamos ningún compilador, nos basta y sobra con que nuestro navegador sea compatible con javascript (Hoy en día la mayoría de los navegadores de internet admiten Javascript, aunque en unos casos el navegador tiene deshabilitado por defecto la ejecución de scripts).

Pues bien, la incrustación de un código de Javascript puede ser de dos formas:

1. Desde la misma página HTML.

2. Llamar el código desde un archivo externo

1.  Desde la página HTML
Se toman en cuenta los siguientes puntos:
  • El script se coloca dentro de las etiquetas < head > y < / head > .
  • Las etiquetas para ejecutar este script son  < script > y < / script >
  • Dentro de estas etiquetas se incluye el atributo language="javascript" el cual indica que nuestro script se basa bajo este lenguaje ( Hay otros lenguajes, por ejemplo vbscript, JScript, etc.).
  • Una buena costumbre es colocar el código dentro de las etiquetas de comentario del lenguaje HTML, esto es en casos en que el navegador de internet no soporte scripts y evite visualizar el código del script. Las etiquetas de comentarios inician con < ! --   y terminan con // -- >
Veamos un ejemplo:

< html >
< head >
< script language= "javascript" >
< !--
alert ("Mi primer programa en Javascript");  //alert es una función para mostrar en pantalla un mensaje
//-- >
< / script >
< / head >

< body >
< / body >
< / html >

2. Desde un archivo externo

Puntos a Tomar en cuenta:

  • Para llamar un archivo con el código en Javascript basta con colocar las mismas etiquetas de < script > y < / script > dentro de la cabecera (head) y  colocar dos atributos que son type="text/javascript" y src="ruta del archivo" .
  • El código se guarda en un archivo con extensión .js ;que es la extensión de los archivos Javascript y el código ya no se encierra entre los comentarios de HTML.

Veamos el siguiente ejemplo:

En un archivo llamado codigo.js usaremos la función alert("Mi Primer programa en Java" ); como en el ejemplo anterior para mostrar en pantalla un mensaje. El archivo se ubica en la misma carpeta que nuestra página web.

< html >
< head >
< script type="text/javascript" src="codigo.js" > < / script >
< / head >
< body >
< / body >
< / html >

 El resultado, en cualquiera de las dos formas es:
 Dependiendo de las necesidades o facilidades del programador, uno decidirá cuál es la mejor opción para sus aplicaciones web, ya sea desde un archivo externo o desde la misma página.

jueves, 9 de junio de 2011

Pila En Ruby

Les dejo un pequeño programa en Ruby para el algoritmo de la Pila

#Clase para implementar el algoritmo de una pila en Ruby
#El algoritmo de una pila se basa en LIFO (Last in First Out o lo que es: El ultimo en entrar es el primero en salir)
#Acentos y otra la letra enie nos las acepta Ruby, o en mi caso marca error

class Pila

  def initialize      #Metodo para inicializar variables de tipo instancia
    @pos=0        #Una variable de tipo instancia se precede con un @
    @tam=0        #Variable Pos me ubicará el puntero de mi matriz y variable tam me indicara el tamanio de esta
  end  #Fin de initialize

 def mat            #Metodo para obtener el tamaño de la matriz
  print "Define tamanio de la matriz: "
  @tam=gets.chomp  
  @tam=@tam.to_i
  @matriz=Array.new(@tam)  #Creo la matriz con el tamaño obtenido
  menu        #Llamo al metodo menú
 end          #Fin del método mat

 def menu    #Metodo que muestra y llama a las opciones disponibles
   opc=1   
  while opc.to_i!=0   # Convertir el valor pedido por teclado a entero con la funcion .to_i  
   puts "*************"
   puts "*0 Salir    *"
   puts "*1 Insertar *"
   puts "*2 Liberar  *"
   puts "*3 Mostrar  *"
   puts "*************"
   print "Opcion: "
  STDIN.flush
  opc=gets.chomp
  opc=opc.to_i
   case opc
    when 1
       meter
    when 2
       sacar
    when 3
       mostrar
   end     #Fin del Case
  end    #Fin del ciclo while
 end     #Fin del metodo menu

 def meter
  if @pos < @tam
    print "Dame un valor numerico: "
    STDIN.flush
    val=gets.chomp
    @matriz[@pos.to_i]=val
    @pos += 1
  else
    print "=========>Error, la matriz esta llena\n"
  end    #Fin del if
 end    #fin del metodo meter
 
 def sacar
   if @matriz[0]==nil or @pos==0
    print "=========>Error: matriz vacia!!!! \n"
   else
     @pos -=1
     @matriz[@pos]=nil     #Adjunto valor nil o nulo
    print "Eliminado \n"
   end    #Fin del if
 end    #Fin del metodo sacar

 def mostrar
  for i in 0..(@matriz.length-1)
   print "Posicion #{i}---> "
   print @matriz[i]
   print "\n"
  end    #Fin del ciclo for
 end    #Fin del metodo mostrar
end    #Fin de la clase Pila

#Crearemos un objeto.
pil=Pila.new    #Con la palabra new, automaticamente llama al metodo initialize
pil.mat      #Llamamos al metodo mat

lunes, 14 de febrero de 2011

Ejecutar el RMA (Remote Monitoring Agent) en línea de comandos -Linux y/o Windows

El RMA es una herramienta que nos permite iniciar,suspender, reiniciar y matar un agente JADE; entre otras cosas.

El RMA lo podemos descargar de la página oficial de JADE, (tienen que registrarse previamente para poder proceder a descargarlo y pueden bajar todos los archivos con el jadeAll.zip o bien si sólo quieren el RMA descarguen el jadeBin.zip) y una vez descargado lo descomprimiremos y guardamos en una carpeta, la carpeta donde voy a guardarlo será JADE1

Pues bien, ahora que ya lo tenemos en nuestra carpeta ahora nos dispondremos a abrir una línea de comandos (o terminal para los Linuxeros) y mediante los comandos nos posicionaremos en la carpeta donde hemos descomprimido nuestro archivo descargado y posteriormente entraremos a la carpeta descomprimida.

Si han descomprimido la carpeta con el mismo nombre que tenía el comprimido entonces su carpeta debería tener un nombre parecido a este 'JADE-bin-4.0.1' o simplemente 'jade' (Si tienes problemas o dudas, consulta la nota que está al final).

SUGERENCIA: Para efectos prácticos, les recomiendo que todo esto lo hagan sobre el Escritorio (desktop), esto con el fin de ahorrar tiempo al momento de cambiar y redireccionar rutas en la línea de comandos y/o terminal, o bien, para cuando todo esto es sólo para alguna tarea de alguna materia.

Aquí les dejo una tabla de los comandos para posicionarse en un directorio tanto en Windows como en Linux.
Comando en: Windows Linux Ejemplo
Ir a una ruta hija cd cd cd Desktop
Regresar a ruta padre cd.. cd .. (espaciado) cd.. | cd ..
Mostrar directorio dir ls dir | ls



 Pues bueno... ahora que estamos dentro de la carpeta descomprimida nos posicionaremos en la carpeta jade (cd jade) y posteriormente a la carpeta lib (cd lib).








Ahora con el siguiente comando (tanto en Linux como en Windows sirve) invocaremos al RMA(cuiden  mayúsculas y minúsculas):

java -cp jade.jar jade.Boot -gui

Si esto les da algún error o muestra un mensaje relacionado con el host entonces escriban:

java -cp jade.jar jade.Boot -gui -host 127.0.0.1








Con esto el RMA iniciará...

Una vez que se haya abierto ahora podremos disponer tambiénde 4 herramientas que nos proporcionan, las más usadas son la de el envío de mensajes ( con Dummy Agent) y el Agente Sniffer (sniffer Agent) el cual puede ver los mensajes entre los agentes que uno desee.

NOTA: NO IMPORTA EL NOMBRE QUE LE DEN A SU CARPETA DESCOMPRIMIDA, LO IMPORTANTE ES ENCONTRAR Y POSICIONARSE EN LA CARPETA "lib" YA QUE DENTRO DE ESTA SE ENCUENTRA EL "jade.jar". PARA NO PERDERSE PUEDEN ABRIR LA CARPETA DESDE EL MISMO ESCRITORIO Y VER LA RUTA EN LA BARRA DE DIRECCIONES.










Espero les sirva de algo, ¡Saludos!

miércoles, 12 de enero de 2011

Compilar y ejecutar programas C en Linux desde terminal

El compilador de C y C++  viene ya incluido en las últimas versiones de Ubuntu, sin embargo si es necesario instalarlo, basta con abrir una terminal y colocar el siguiente comando:

sudo apt-get install gcc

Asi que una vez que ya tengamos nuestro compilador, abrimos una terminal y nos posicionamos en el directorio donde está nuestro archivo a compilar, la forma más fácil de compilar es:

gcc archivo.c -o archivo_generado

El gcc hace referencia al compilador, el archivo.c es el archivo que vamos a compilar (No olviden la extensión, en este caso .c), el argumento -o (minúscula) nos permite generar un nombre al archivo resultante de la compilación y el archivo_generado es el archivo que resultó de la compilación.

Ejemplo:

#include < stdio.h >

int main( )
{
  printf("Hola Mundo \n ");
 return 0;
}

Supongamos que este archivo lo guardamos con el nombre de "PruebaCompilador.c" (sin comillas) y lo guardamos en una carpeta, abrimos una terminal, nos posicionamos en nuestra carpeta y escribimos:

gcc PruebaCompilador.c -o ArchivoCompilado




Si no se muestran errores, entonces nuestro archivo ya habrá sido compilado y creado el archivo a ejecutar.

Para ejecutarlos simplemente precederemos de un punto y una diagonal seguido del nombre del archivo:

./ArchivoCompilado


Existen otros argumentos más para compilar y cada uno tiene una función especial, pero la más usada es la presentada anteriormente.

domingo, 2 de enero de 2011

Ciclo for-each en java

"En algún sitio, algo increíble espera ser descubierto..."

En lenguajes como Python, Php, entre otros, existe un ciclo denominado "for each", lo que hace este ciclo es asignar el valor de una colección a una variable.
Este ciclo fue implementado en java a partir de la versión 5 y aunque se generan los mismos resultados que un for normal, su sintáxis es más sencilla.
   for (tipo variable : colección)

Como observamos, creamos el ciclo for  y dentro de este declaramos la variable del tipo de la colección seguida de dos puntos y por último colocamos la colección de datos(Vectores, Listas ligadas, etc...).

Veamos un ejemplo:

public class CicloFor
{
 //declaramos un arreglo estático
   static String vector[ ]={"Este es " , " un ejemplo del " , " ciclo for-each"};
  public static void main(String [ ]args)
     {
         for(String salida : vector)
             System.out.print(salida);//imprimimos y el resultado se muestra en una sola línea
             System.out.println( );
    } 
}//fin de la clase

El resultado es el siguiente:

 Como se habran dado cuenta,  lo que hace el ciclo es asignar en la variable cada valor que contiene el vector "vector" de manera automática. Lo cual también es equivalente a que hicieramos esto:


public class CicloFor
{
 //declaramos un arreglo estático
   static String vector[ ]={"Este es " , " un ejemplo del " , " ciclo for-each" };
public static void main(String [ ]args)
  {
         for(int i= 0; i < vector.length ; i ++) 
             System.out.print( vector[ i ] );
             System.out.println( );
  } 
}//fin de la clase




Este ciclo nos ahorra ciertas cosillas, al mismo tiempo que nos evita posibles errores de programación tales como errores de cálculo en los tamaños de las colecciones.