meetandroids – Bogotá 9 de Marzo

El próximo miércoles 9 de Marzo a las 5:00pm en el Juan Valdez de la Calle 73 con Carrera 9° se llevará acabo un evento de desarrolladores y usuarios de Android, para compartir experiencias, conocer gente, actualizarse sobre el tema Android y crear una comunidad alrededor de quienes nos dejamos llevar por el robot y no por la manzana.

La idea del evento es reunir a los desarrolladores que trabajan alrededor de la plataforma y ver lo que pueda salir de este primer encuentro bautizado como el “meetandroids” (puedes encontrar más en twitter con su hashtag#meetandroids). Para llevar un control de los asistentes es recomendable confirmar la asistencia acá: http://twtvite.com/iifgbk

Leer más...

Ordenar arreglos con Linq

Uno de los grandes logros personales de este año, fue empezar a trabajar con la tecnología Linq del .NET Framework 4.0, no sabía todas las bondades que tiene trabajar con este "nuevo" tipo de recursos que ofrece Microsoft y que realmente optimiza varios procesos además de agilizar mucho la codificación.

Para empezar con Linq es necesario estar dispuesto a olvidar muchas de las cosas de las antiguas tecnologías como ADO.NET y viejas maneras de trabajar con elementos como arreglos y listas, además parte fundamental del proceso de aprendizaje es repetir constantemente la palabra "NOO!!" o la frase "NO puede ser tan fácil!" así que espero que tras leer éste artículo me regalen un gran "NOOO!!! increible!"

--

En tiempos antiguos, donde el macho alfa era quien más líneas de código podía escribir sin volverse loco o atentar contra la integridad de sus grupo de trabajo, los procesos de organización de arreglos y cosas por el estilo eran un calvario y más cuando el profesor era uno de esos malditos que quería que todos supieran como se trabaja con el antiguo método burbuja (lo sé, muchos quizá piensen en mi).
Con linq, no es necesario hacer nada de ésto, es más ni siquiera es necesario utilizar ciclos repetitivos o la clase Array para organizar un arreglo, un ArrayList o un List, así que paso a explicar como es posible organizar un arreglo con Linq.
Empecemos con un Arreglo de Strings

   string[] x = new string[] {"a","b","c","d","e"};              
   var q = from f in x                      
           orderby f descending                      
           select f;              
   x = q.ToArray();

Con éste sencillo proceso, el arreglo x que está lleno de strings, queda ordenado de manera descendente. La última linea simplemente se encarga de almacenar el resultado que está en el objeto anonimo q de nuevo en la variable x para poderlo utilizar como un arreglo, pero para esta instancia el arreglo x está compuesto por las letras en orden descendente.
Ahora vamos a hacer un ordenamiento más complejo utilizando objetos de una clase dentro de una lista, para ello vamos a utilizar la clase Auto.

        public class Auto {
          public string marca { get; set; }
          public string color { get; set; }
          public string modelo { get; set; }
        }

Ahora vamos a crear una lista de objetos de tipo Auto para hacer varios ejercicios de consulta con Linq

List carros = new List();
carros.Add(new Auto() { marca="Renault", color="Negro", modelo="Logan" });
carros.Add(new Auto() { marca = "Mazda", color = "Blanco", modelo = "Mazda2" });
carros.Add(new Auto() { marca = "Renault", color = "Azul", modelo = "Twingo" });

Teniendo la lista creada vamos a crear las consultas de Linq necesarias para ordenar por medio de la marca, sin embargo, la consulta es igual para organizar los elementos por su color o por su modelo, lo único que debemos cambiar es el nombre del atribto por medio del cual queremos hacer que se organice la lista.

var q = from f in carros
                    orderby f.marca ascending
                    select f;

Ahora paso a describir un poco el funcionamiento de las consultas de Linq que estamos utlizando, estas consultas están basadas en la estructura de consulta del lenguaje SQL por lo tanto contamos con clausulas como el where, orderby, groupby, etc. La diferencia con las consultas de SQL está en el orden, ya que aquí debemos iniciar la consulta con la palabra reservada "from" después debemos poner el nombre de la variable temporal que almacenará la consulta, en este caso es "f", seguido de esto definimos el origen de los datos que es la lista carros, Podemos agregar las condiciones que queramos después de esa primera linea, así que podemos agregar la clausula where para crear condiciones o la clausula groupby para agrupar los elementos de acuerdo a un criterio. Finalmente agregamos "select f" que se encarga de hacer la consulta en el origen de datos ("carros") y almacena el resultado en el objeto anonimo q que se maneja como si fuera un objeto creado a partir de la Interfaz IEnumerable ya que cuenta con los mismos métodos y atributos.
Para obtener más información sobre Linq recomiendo que sigan el Blog de mi amigo Sergio, quien también cuenta con tutoriales y explicaciones de las nuevas tecnologías de .NET.

Leer más...

Introducción a WPF

En esta ocasión @EdwinCruces, blogger del sitio Ante todo variedad me ha permitido colgar un artículo que escribió, que da una idea de como empezar a trabajar con WPF, así que aquí les dejo el post.

Con el rápido avance de la tecnología, es inevitable que los lenguajes de programación también mejoren cada día más. Es por eso que desde la salida al mercado del sistema operativo Microsoft Windows Vista los sistemas Windows incorporan una tecnología llamada Windows Presentation Foundation, la cual además de separar eficientemente la parte lógica de la parte gráfica haciendo uso del Lenguaje XAML, también hace las interfaces de usuario mucho más agradables y dinámicas. De ahí que para un desarrollador sea más fácil y práctico trabajar junto a un experto en interfaces (Diseñador Gráfico) o bien hacer uso de su buen gusto y "cacharrearle" un poco al tema para pulir sus aplicaciones con sencillos Skins, Templates y/o Temas para WPF. Pero de esto hablaremos luego. Hoy quienes tengan aunque sea un poco de experiencia en desarrollo .Net podrán realizar este sencillo How-To.

pulsa clic en la imagen para verla más grande

__

Lo primero que debes hacer es abrir Visual Studio (2008 ó 2010) y crear una nueva solución con la plantilla de Aplicación WPF en el lenguaje de tu preferencia (VB ó C#), dale un nombre y clic en Crear. Lo primero que verás será una especia de texto XML con un diseñador de interfaz arriba de él; ése es el lenguaje declarativo XAML (eXtensible Application Markup Language) que es con el cual se crean las interfaces WPF. Allí puedes crear botones, paneles, contenedores, elementos para multimedia, etc. Crea un TextBox, un Botón y un ListBox y dale un nombre a cada uno. Para acceder al código de la parte lógica de tu aplicación basta con dar clic derecho en el diseñador y seleccionar 'Ver código', esto te llevará al archivo Code-Behind que contiene tan solo el constructor de la clase. Ahora agrega una nueva clase estática llamada Commands que contenga un objeto estático de tipo RoutedCommand.

De vuelta al XAML. Si te habías fijado el primer Tag que aparece en el archivo dice "Window", dentro de él escribe:

xmlns:local="

...y se desplegará una lista con los Assemblies que tengas en el proyecto. Escoge el de tu aplicación que se ha de llamar algo así como "MiPrimerAppEnWpf (MiPrimerAppEnWpf)". Dentro del Tag del botón que creaste antes escribe:

Command="{x:Static local:Commands.Agregar}"

Y ya tan solo queda que agregues en el Code-Behind el Command a la lista de CommandBindings de la aplicación y especificar cuales son los Manejadores de sus dos eventos: Execute y CanExecute. El código fuente de este ejemplo lo pueden descargar de:Eso es todo. Hasta una próxima oportunidad...

Leer más...

Controlar eventos de teclado en C#

En ocasiones, cuando creamos aplicaciones para Windows Forms con C# tenemos la necesidad de capturar los gestos del teclado del usuario para ejecutar determinada acción, ejemplo de eso es cuando para enviar la información de un formulario o iniciar sesión en algún programa presionamos la tecla Enter o cuando presionamos teclas como Ctrl+W en el navegador para cerrar una pestaña.

..

--
En el programa que vamos a hacer, vamos a programar un TextBox que indique las teclas que se han presionado o la combinación de teclas que se está utilizando, después de esto el desarrollo para un método específico debe ser muy sencillo.

Lo primero que haremos, será crear un proyecto de Windows Forms con dos TextBox, uno en el que crearemos la lógica para determinar la tecla o teclas presionadas y otro que muestre la información correspondiente a la acción de usuario.

El primer campo se llamará eventoTxt y el siguiente se llamará informacionTxt. Después de agregar los controles al formulario, debemos ir al método constructor del formulario, para agregar el delegado encargado de las acciones del teclado (sí no sabes qué es un delegado, deberías revisar este articulo, que habla sobre los listeners en ActionScript que son muy parecidos).

En el método constructor se agrega el nuevo delegado por medio de la expresión += y dentro de los paréntesis se debe poner el nombre la función que se va a invocar cuando se produzca el evento KeyDown. En el método validarTeclas, se pueden ver 2 variables que pone por defecto en Visual Studio, para acceder a la información de la tecla presionada debemos ver los atributos del párametro e que contiene toda la información.

Y eso es todo, espero sus comentarios, y los archivos quedan disponibles para trabajarlos con el Framework 4.0.

--

Leer más...

Lenguaje C# - Tercera parte (Condicionales)

Retomando la serie de tutoriales sobre el lenguaje C#, esta vez escribiré sobre el manejo de condicionales. En el tutorial sobre operadores se toco algo del tema, al referirnos a los distintos tipos de operadores que existen en los lenguajes de programación, siendo los operadores parte fundamental en la construcción de condiciones.

Antes de empezar a definir técnicamente, es necesario definir el concepto de condición, las condiciones son preguntas o evaluaciones de los elementos que se presentan antes de poder realizar una acción. Según la RAE una condición (en una de sus tantas definiciones) se refiere a "circunstancias que afectan a un proceso o al estado de una persona o cosa" ahora en programación quizás la definición sea más sencilla.

--

--

En cualquier lenguaje de programación la condición está dada por la evaluación y comparación de dos o más valores siempre teniendo en cuenta que estas condiciones se deben dar en parejas (esto ya lo dije en el anterior tutorial) es decir que las comparaciones solo se pueden hacer de dos en dos, cada una de las comparaciones entrega un valor booleano, es decir solo puede entregar valores verdaderos y/o falsos.

Después de obtener el valor booleano de cada comparación estos se pueden comparar por medio de las compuertas lógicas AND (&&), OR (||) y NOT (!), existen las tablas de verdad que representan los resultados que podemos obtener el comparar los valores de tipo booleano entre ellos.

Tabla de Verdad para AND (&&)

V	&&	V	V
V	&&	F	F
F	&&	V	F
F	&&	F	F

Tabla de Verdad para OR (||)

V	||	V	V
V	||	F	V
F	||	V	V
F	||	F	F

La compuerta lógica representa una negación de una expresión de esta manera:

! verdadero = falso

! falso = verdadero

!(verdadero && falso) = verdadero (recordemos que V y F da falso, al negar la expresión se vuelve verdadero).

Las condiciones en el lenguaje C# al igual que en lenguajes como JAVA, PHP, JavaScript, ActionScript, etc están dadas por la palabra if (sí) seguida de las condiciones entre paréntesis y las acciones dentro de llaves ( {...} ).

if(a == b){
//acciones en caso de que se cumpla la condición

}

Por defecto el if siempre valida la última respuesta contra un verdadero es decir:

bool a = true;

if(a==true) // es lo mismo que decir: if(a)

En caso de que no se cumpla la condición también es posible utilizar la sentencia else (de lo contrario) que representa la otra posibilidad dentro de una condición que tiene número limitado de acciones.

Suponiendo el caso de un interruptor que solo puede estar encendido o apagado la condición sería esta:

bool interruptor = true //está encendido
if(interruptor){ //si el interruptor está encendido
...
}
else{ //de lo contrario
...

}

Suponiendo que se tengan más de dos opciones es posible agregar un if a un else, por ejemplo en el caso de determinar el signo de un número:

int x = valor;

if(x>0){

//x es positivo

}

else if(x<0){

//x es negativo

}

else{

//x es neutro (0 es un valor neutro)

}

Dentro de C# también existe el Switch Case que es una herramienta muy buena en caso de tener una serie de opciones preestablecidas, sin embargo no vamos a tocar esa herramienta todavía.

Esto es todo por este tutorial y dentro de un tiempo seguiré escribiendo, el siguiente tutorial será sobre ciclos repetitivos.

--

Leer más...

Adobe Enterprise Café - Resumen

Hoy me encontraba navegado por la WEB, y encontré una excelente aplicación hecha por Adobe, que permite estar al tanto de las novedades de sus productos empresariales y de comunidad, además de otras decenas de características. Adobe Enterprise Café es una herramienta basada en Adobe AIR, que permite conectarse a los servicios más utilizados por los desarrolladores de Adobe, todo desde el mismo lugar.

..
Adobe Enterprise Café, requiere que tengas cuenta de Adobe si todavía no la tienes una buena idea es obtenerla ya que gracias a esa cuenta, se pueden obtener varios beneficios en el sitio y es una cuenta que sirve para todos los productos web de Adobe.

Antes de poder iniciar se selecciona la herramienta favorita podemos seleccionar entre Adobe LiveCycle, Acrobat, Connect, ColdFusion y Flash Plataform (supongo que ya saben cual escogí), al ingresar a la información de la herramienta, encontramos una serie de botones que sirven para conocer las novedades, estar al pendiente de foros, RSS, eventos, notas, etc.

Cabe destacar el hecho de que desde esta plataforma podemos visitar Tv.Adobe, Tour de Flex, Tour de LiveCycle, Air Marketplace y muchas de las herramientas más utilizadas, todo desde el mismo entorno, esto es una gran ventaja y representa ahorro de tiempo para la consulta de información.

Realmente recomiendo mucho al herramienta para estar al tanto de las novedades de los proyectos Adobe.

..

Leer más...

Crear controles personalizados en Flex

Una de las ventajas que tiene el desarrollo con el framework de Flex, es la capacidad de crear controles personalizados basados en otros controles es decir, crear controles de usuarios con características especiales, que cumplan con ciertos procesos y que nos ahorren trabajo.

..
Para iniciar, vamos a crear un nuevo proyecto de Adobe Flash Builder 4, para este caso lo llamare ControlPersonalizado, en tipo de proyecto seleccionamos proyecto WEB y utilizamos la SDK4 (con Flex 3 también es posible). Una buena práctica en el desarrollo de software, es tener un proyecto de pruebas, donde se creen las rutinas de prueba, los controles personalizados y todo lo que eventualmente pueda llegar a constituir un problema en el desarrollo, bien sea por su complejidad o por los riesgos del ejercicio.

Presionamos el botón “Finish” para cargar la aplicación.

Una de las ventajas del nuevo Flash Builder, es la posibilidad de trabajar paquetes (package), los paquetes son carpetas lógicas que permiten administrar de una manera ordenada nuestros componentes, clases, y recursos de código, etcétera. En el explorador de proyectos, buscamos la carpeta src, presionamos clic derecho, new package, y lo llamamos Componentes (la primera letra de la palabra debe están en mayúscula).

En el paquete, presionamos clic derecho, new, MXML Component.

Ponemos el nombre del Componente (cómo este funcionará como una clase, entonces la primera letra debe ir en mayúscula al igual que la primera letra de cada palabra compuesta). Para este ejercicio, vamos a crear un Campo de texto que tenga restricciones para que solo acepte números, en el campo Base don, seleccionamos la clase Group, cambiamos el tamaño por defecto a 200px por 200px (estos valores van a cambiar), y presionamos Finish.

Ahora, tenemos un nuevo archivo con código independiente de la aplicación, que también cuenta con un entorno de diseño, sin embargo no lo vamos a utilizar. Después de la etiqueta “s:Group” vamos a crear un campo de texto y debe quedar de esta manera:

Descripción: En la etiqueta s:Group, editamos el valor de ancho y alto, y lo ponemos del mismo tamaño de un campo de texto clásico: 132 x 22.

Creamos una etiqueta TextInput, esto crea un campo de texto en el formulario, el campo id, es muy importante, ya que gracias a este id, podemos acceder directamente a la información del campo. Las propiedades X y Y quedan en 0, para que se alineen al borde superior izquierdo del grupo. La propiedad restrict nos permite restringir o permitir valores dentro del campo de texto, en este caso, el campo solo admite valores numéricos, al intentar ingresar letras o caracteres especiales no será posible entrar ese tipo de datos. Finalmente las propiedades de ancho y alto del campo, las dejamos en 100% cada una, esto asegura que sin importar el tamaño final del control, el campo de texto se acoplara a su contenedor.

Guardamos y vamos al archivo del proyecto, es decir a ControlPersonalizado.mxml, estando en la vista de diseño, vamos al panel components y nos podemos dar cuenta que hay un nuevo control en la carpeta Custom:

Ahora solo basta con arrastrar el control y probar el proyecto:

Si intentamos introducir algún carácter que no sean números, no los acepta el campo de texto. La propiedad restrict se puede adicionar a cualquier campo de texto, la ventaja de hacerlo de esta manera es que no es necesario añadir esa línea cada vez que necesitemos hacer un control numérico, solo basta con crear un componente personalizado y utilizarlo las veces que sea necesario.

Finalmente para acceder a la información del campo de texto, es necesario recurrir al id del control en el formulario y al id del campo de texto, de esta manera:

Lo último que hacemos es poner un botón en el formulario, que al presionar click, llame al método mostrarTexto(), este método muestra una alerta con el texto del campo de texto. Lo realmente importante es que para acceder a la información del campo de texto, solo se necesita poner el nombre del control en el formulario (campo1Txt), el nombre del campo de texto en el componente (campoTexto) y la propiedad text de este último.

Este es el ejemplo:

Espero sus comentarios.

Leer más...

Lenguaje C# - Segunda parte (Operadores)

Siguiendo con la serie de tutoriales para aprender a programar con C#, esta vez escribiré sobre el uso de los operadores, su importancia y algunos ejemplos de como funcionan, no es un tema complicado pero siempre es necesario saber cómo funcionan.

Nota: recuerda que este es el segundo de una serie de tutoriales, el primero esta aquí.

--

--

Lo primero es definir el concepto de operador. Un operador es un símbolo que representa una acción determinada para una variable o valor y así como en español la coma ( , ) indica una pausa corta y el punto ( . ) indica una pausa un poco más larga, en aritmética existen operadores que indican la ejecución de determinado proceso, por ejemplo:

2 + 2 = 4

En este caso el operador es el signo mas ( + ) que indica que se debe hacer una suma o un incremento de dos valores dados.

Los operadores en programación están en categorías dependiendo de su funcionalidad, los primeros son los operadores aritméticos que a su vez se dividen en binarios y unarios, los operadores relacionales y los operadoresLógicos.

Operadores Aritméticos

Binarios: los operadores binarios indican operaciones sencillas de incremento (suma o multiplicación ) y decremento (resta, división y modulo), estos son los operadores binarios:

• +: representa la suma de dos o más valores o variables.
• -: representa la resta de dos o más valores o variables.
• *: representa la multiplicación de dos o más valores o variables.
• /: representa la división de dos o más valores o variables.
• %: representa el modulo (obtención del residuo de una división) de dos o más valores o variables.

Unarios: los operadores unarios representan operaciones simplificadas de incremento decremento y modificación de signos, estos son los operadores unarios:

• ++: Incrementa el valor de una variable en una unidad.
• --: Decrementa el valor de una variable en una unidad.
• -: Cambia el signo de una variable, es como multiplicar por -1.

Ejemplos:

• 2 + 2 = 4
• 10 - 5 = 5
• 4 * 6 = 24
• 8 / 2 = 4
• 8 % 2 = 0 (cero es el residuo de la división 8/2)

• c=4; c++; //c=5 (c inicia siendo igual a 4, después del incremento [c++], c vale 5)
• d=10; d--; //d=9
• e = -(4) // e = -4
• f = -(-6) // f = 6 (por regla de signos menos por menos igual a mas)

En conclusión los operadores unarios, simplifican el proceso de modificación de valores ya que al escribir c++ se hace lo mismo que c=c+1.

Operadores Relacionales

Son operadores que se encargan de unir y comparar dos o más valores, siempre se utilizan en comparaciones de parejas y están dadas por los símbolos:

• = : igual que
• != : diferente a
• > : mayor que
• < : menor que
• >= : mayor igual que
• <= : menor igual que

Estos operadores se usan para comparar valores de variables por pares es decir,no se pueden comparar más de 2 valores al tiempo:

• a > b > c //ERROR
• (a > b) && (b > c) //BIEN

Cuando se requiere hacer una comparación de varios valores se deben usar losOperadores Lógicos, que son operadores de unión, también llamados compuertas lógicas, estos operadores pueden unir dos o más pares de valores comparados por medio de los operadores relaciones y están dados por estos símbolos:

• && : Operador AND (Y) quiere decir que todas las condiciones deben ser verdaderas para que se ejecute una acción.
• || : Operador OR (O) quiere decir que de todas las condiciones solo una debe ser verdadera y se asume que con eso es suficiente para hacer determinada acción.
• ! : Operdaro NOT (NO) quiere decir que se niega la afirmación para cambiar su valor, es decir cambia de verdadero a falso y de falso a verdadero.

Es muy importante reconocer cuando y como se deben utilizar los operadores lógicos, ya que estos indican cual será el flujo de ejecución de nuestras aplicaciones. Supongamos que estamos desarrollando un formulario en el que todos los datos del usuario son obligatorios, cuando el usuario final presione clic en el botón para guardar los datos, debemos validar si toda la información está debidamente diligenciada, en ese caso usaríamos al operador && ya que este indica que todo debe ser igual a verdadero.

if(nombre.text != "" && apellido.text != "" && telefono.text != "" ) // OK

La condición pregunta por el valor del texto de tres campos de texto (nombre, apellido, telefono), si el valor de texto es diferente de nada (es decir, si está lleno) quiere decir que todo está bien, ahora en caso de que alguno de los campos no cumpla la condición no se puede guardar la información y se le mostrará una alerta o un mensaje al usuario.

Es importante ver como las condiciones están dadas por parejas: telefono.text!= "" estas parejas se forman por valor operador relacional valor y cuando se desea comparar ese resultado por otro valor es necesario implementar los operadores lógicos.

Esto es todo para este tutorial, en el siguiente escribiré sobre las tablas de verdad, y sobre el manejo de condiciones en C#.

Espero sus comentarios.

--

Leer más...

Lenguaje C# - Primera parte (variables)

Del mismo modo como hice un post para iniciar con el lenguaje ActionScript, voy a hacer uno de como iniciar con C#, ya que he tenido que dar clases de algoritmia con el lenguaje y una constante es la dificultad para aprender el lenguaje desde ceros.

Antes que nada es necesario entender los conceptos básicos de la algoritmia, conceptos como variables, condiciones, ciclos, arreglos son necesarios para empezar a trabajar con cualquier lenguaje de programación, así que haré un pequeño resumen de cada uno de los elementos que acabo de mencionar.

..

Varibles: las variables son espacios en memoria RAM que almacenan información que necesitan los sistemas para su ejecución, ejemplos de variables, son los datos del usuario en el correo electrónico o en Facebook, generalmente están compuestas por Nombre, Tipo de Dato y Valor.

La memoria RAM, funciona como un gran Bus, que tiene espacios disponibles para N cantidad de variables entre más grande sea la memoria RAM, más variables puede manejar sin fallar, y del mismo modo que un bus, la memoria puede funcionar con sobrecupo, sin embargo el rendimiento va a ser lento.

lo sé, esto no es un bus, pero la imagen expresa lo que quiero decir.

La variable como su nombre lo indica, es un objeto que está cambiando, y por lo tanto no cuenta con información constante, el cambio de la información se ve reflejado en tiempo de ejecución, es decir cuando una aplicación desarrollada es ejecutada al final por el usuario.

En C# la declaración de las variables se hace con un orden especifico, este orden es igual para lenguajes como JAVA. Esta es una demostración del orden en el que se deben declarar las variables.

Como se ve en la imagen, la declaración de las variables esta dada primero que todo por el tipo de dato, esto funciona como una categoría para almacenar información, de esta manera, se pueden crear variables de tipo numéricas, de cadenas de caracteres, de valores verdaderos o falsos, etcétera, después del tipo de dato va el nombre de la variable así pues si lo que vamos a almacenar es la suma de dos números enteros el resultado se debe almacenar en una variable de tipo entero.

int resultado = 2+2;

Nota: Una de las condiciones del lenguaje C#, así como de JAVA y por herencia tomadas del lenguaje C es que todas las sentencias de código deben terminar con punto y coma ( ; ) exceptuando condiciones, ciclos y funciones.

Los tipos de datos más comunes son los numéricos (int, double, float, uint, entre otros), los de caracteres (char y string) y los de valores verdaderos o falsos (bool).

Teniendo en cuenta lo anterior es posible crear una variable de cualquier tipo de dato, pero la condición es que esa variable solo almacenará información de ese tipo de dato, es decir en un contenedor de agua no se puede depositar cerveza (si, yo siempre con el cuento de la cerveza)

Estos son algunos ejemplos de como se crean variables para cada tipo de información:

string saludo = "Hola, cómo estas?";

double gradosCentigrados = 4.5;

int totalManzanas = 50;

bool habilitado = true;

Nota: las variables tienen una definición que está orientada bajo los estándares de la ECMAScript, por eso no tienen espacios ni caracteres especiales, si quieres ver más de eso, puedes leer esto.

Este es el primer articulo de una serie que iré escribiendo en primera medida para retomar el blog y en segunda para explicar los conceptos básicos del lenguaje C#.

Espero sus comentarios.

..

Leer más...

Expresiones regulares Uso en JAVA

Nuevamente Fabian Castro ha escrito un nuevo tutorial en su blog sobre expresiones regulares aplicado a JAVA, gracias a su infinita entrega y benevolencia me permitió colgarlo en este blog como recopilación de información.

JAVA + Expresiones regulares; lo prometido es deuda (eso es lo que enseñan los abuelos), en este post implementaremos las expresiones regulares en JAVA, la verdad es fácil, claro si ya sabemos cómo funcionan.

--


Expresiones regulares Uso en JAVA

JAVA + Expresiones regulares; lo prometido es deuda (eso es lo que enseñan los abuelos), en este post implementaremos las expresiones regulares en JAVA, la verdad es fácil, claro si ya sabemos cómo funcionan.

JAVA nos ofrece un paquete especial para el manejo de expresiones regulares el cual esjava.until.regex presentándose dos clases: Pattern y Matcher donde dichas clases son finales (final) y con método constructor privado (Private) por ende no se puede crear Objetos ni heredar de dichas clases… ¿Cómo?!! ¿No puedo crear objetos de estas clases? No, no puedes crear objetos ni heredar de estas clases, ahí es donde uno dice “que clases tan inservibles” pero no es así porque al no poder heredar de ellas no se pueden modificar sus funciones y así las clases sirven para lo que fueron hechas, además al no poder crear objetos ellas nos entregan un objeto estándar para la clasificación y uso de las Expresiones regulares.

Muy bien la clase Pattern tiene un método que es: compile(String regex), este método recibe como parámetro un String el cual es la expresión regular con la que queremos validar nuestros datos, dicho método nos devuelve un objeto estándar de la clase Pattern usándolo de la manera que queramos.

Después de tener el objeto de la clase Pattern, que es el que nos ayudara a contener el patrón, necesitamos la clase Matcher este compara los datos contra la expresión regular, para obtener el objeto de dicha clase se usa el método matcher(CharSequence input) cuyo parámetro es en pocas palabras un String el cual es el dato que se quiere validar, al tener ya el objeto que valida el patrón contra el dato, podemos usarlo de cualquier forma, para identificar si el dato coincide con el patrón se usa el método .find() que retorna un booleano pero dicho método se entiende mejor en la práctica.

Nota: el siguiente ejemplo esta desarrollado en Netbeans 6.8, los archivos podrán ser descargados en formato .java y en proyecto Netbeans.

El ejemplo está basado en la validación de un correo electrónico, creare un formulario JAVA (JFrame) el cual contendrá un campo de texto y un botón; no me extenderé mucho con la creación de botones y campos de texto dentro del formulario la idea principal es entender cómo se implementan las expresiones regulares, en un próximo tutorial profundizaremos sobre la interfaz grafica en java; para la creación del formulario usaremos el siguiente fragmento de código:

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.regex.*;

import javax.swing.*;

public class Main extends JFrame {

JTextField texto;

JButton boton;

public Main(){

this.setDefaultCloseOperation(EXIT_ON_CLOSE);

this.setLayout(null);

this.setLocation(200, 200);

this.setSize(225,100);

texto = new JTextField();

texto.setLocation(10, 10);

texto.setSize(200, 20);

this.add(texto);

boton = new JButton();

boton.setLocation(60, 30);

boton.setSize(100, 30);

boton.setText("Validar");

boton.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

validar(texto.getText());

}

});

this.add(boton);

}

private void validar(String dato){

}

public static void main(String[] args) {

new Main().setVisible(true);

}

}

Lo que nos interesa es que al pulsar el botón se ejecutara el método validar(String dato), en este momento dicho método se encuentra vacio, así que le daremos el código de la validación para que el método quede así:

private void validar(String dato){

Pattern pat = Pattern.compile("^[a-zA-Z0-9_-]{2,}@[a-zA-Z0-9_-]{2,}\\.[a-zA-Z]{2,4}(\\.[a-zA-Z]{2,4})?$");

Matcher mat = pat.matcher(dato);

if(mat.find()){

JOptionPane.showMessageDialog(null, "el texto escrito es un correo");

}else{

JOptionPane.showMessageDialog(null, "el texto escrito NO! es un correo");

}

}

Si señores la expresión regular que esta hay valida un correo, casualmente es la misma que usamos para el tutorial anterior y ahora expliquemos línea por línea:

Pattern pat = Pattern.compile("^[a-zA-Z0-9_-]{2,}@[a-zA-Z0-9_-]{2,}\\.[a-zA-Z]{2,4}(\\.[a-zA-Z]{2,4})?$");

Esta Línea de código Activa el patrón a usar; es decir compila la expresión regular para poderla usar.

Matcher mat = pat.matcher(dato);

Esta línea de código crea el objeto de la clase Matcher para comparar el patrón con el dato que queremos validar, pero para que eso ocurra debemos usar el método find() de dicha clase así:

if(mat.find()){
JOptionPane.showMessageDialog(null, "el texto escrito es un correo");
}else{
JOptionPane.showMessageDialog(null, "el texto escrito NO! es un correo");
}

El método find() devuelve un booleano el cual es verdadero si el dato coincide con el patrón y un false en caso contrario.

Este es el Final del Tutorial, espero haya sido de gran utilidad para ud's y pronto tutoriales de como crear interfaz gráfica en JAVA

DESCARGABLES

Proyecto NEtBeans 6.8

Archivos .JAVA

Archivo ejecutable .JAR

Leer más...