Anteriormente vimos cuales son los nuevos tipos de input de los que disponemos (ver post), y estos son parte clave en el desarrollo, pero aun tenemos más, y vamos a revisarlas:

1. Nuevos atributos:

HTML5 define nuevos atributos para trabajar con formularios, y su principal objetivo es reducir el código JavaScript que debemos escribir prácticamente a 0.

Los atributos son:

· placeholder: con este atributo podemos especificar un texto que trabaje como marca de agua para una caja de texto, el texto solo será mostrado si dicho campo esta vacía, un ejemplo:

   1:  <input id=”txtNombre” type=”text” placeholder=”Ingresa tu nombre” />

· required: con este atributo definimos si un campo es requerido o no, un ejemplo sería:

   1:  <input id=”txtNombre” type=”text” required />

· autofocus: establece el foco en un determinado control cuando se carga la página, solo se debe asignar este atributo a un elemento del DOM por página, un ejemplo sería:

   1:  <input id=”txtNombre” type=”text” autofocus />

· autocomplete: permite definir si un campo de texto debe recordar los valores ingresados anteriormente, puede tomar dos valores, true o false; un ejemplo sería:

   1:  <input id=”txtNombre” type=”text” autocomplete=”false” />

2. Lista de opciones:

Otra de las características que tenemos disponibles ahora en HTML5 para trabajar con formularios es la posibilidad de crear listas de opciones para nuestras cajas de texto, para realizar esto disponemos del elemento datalist en el cual definimos las opciones y del atributo list el cual tendrá como valor el id del datalist creado, un ejemplo sería:

   1:  <b>Ciudades:</b>

   2:  <input type="text" id="txtCiudad" list="listCiudad" placeholder="Ingresa tu ciudad"/>

   3:  <datalist id="listCiudad">

   4:      <option value="Bogota" label="Bogota">

   5:      <option value="Cali" label="Cali">

   6:      <option value="Medellin" label="Medellin">

   7:      <option value="Pereira" label="Pereira">

   8:  </datalist>

3. Validar formulario al enviarlo:

Por defecto, los botones de tipo submit realizan la validación de todos los campos con el atributo required en un formulario, sin embargo es posible tener botones que no realicen dichas validaciones, y como? muy fácil solo debemos incluir el atributo formnovalidate, un ejemplo sería:

   1:  <input id="btnLimpiar" formnovalidate type="submit" value="Limpiar" />

Ahora como ejemplo real vamos a crear un formulario de registro de usuario, y vamos a ver que realmente no nos es necesario escribir código cliente para realizar la validación de estos campos, en resumen nuestro HTML sería:

   1:  <h1>Validando un formulario</h1><hr>

   2:  <form id="form1" name="form1">

   3:     <table>

   4:          <tr>

   5:              <td>Nombre:</td>

   6:              <td><input type="text" required placeholder="Ingrese su nombre"></td>

   7:          </tr>

   8:          <tr>

   9:              <td>Apellido:</td>

  10:              <td><input type="text" required placeholder="Ingrese su apellido"></td>

  11:          </tr> 

  12:          <tr>

  13:              <td>Email:</td>

  14:              <td><input type="email" required placeholder="Ingrese su email"></td>

  15:          </tr>

  16:          <tr>

  17:              <td>Sitio Web:</td>

  18:              <td><input type="url" placeholder="Ingrese el sitio Web"></td>

  19:          </tr>

  20:          <tr>

  21:              <td><input type="submit" value="Enviar datos"></td>

  22:              <td><input type="submit" value="Limpiar datos" formnovalidate></td>

  23:          </tr>

  24:      </table>

  25:  <form>

Nos vemos en el siguiente post!

Descarga el ejemplo!

Entonces primero voy a listar los tipos nuevos, y luego comentará acerca de cada uno:

· search: para realizar búsquedas

· number: campo para números con spinboxes

· range: slider

· color: para la selección de un color

· tel: para números telefónicos

· url: para direcciones Web

· email: para direcciones de email

· date: para fechas

· month: para meses

· week: para semanas

· time: para horas

· datetime: para fecha y hora

Como se puede observar tenemos 12 nuevos tipos disponibles, pero como todo en la vida tiene un pero acá no será la excepción. Uno de los problemas iniciales a los cuales no enfrentamos cuando trabajamos con HTML5 es el soporte por parte de los exploradores, pero este tema va para otro post.

Así, si por ejemplo queremos trabajar con el tipo date, vamos a escribir:

<input type="date" />

Y una vez en el browser vamos a tener (imagen tomada de opera):

Lo importante a tener en cuenta es que con estos nuevos controles podemos ahorrar mucho código JavaScript, bueno espero les sea de utilidad este artículo, en el siguiente post vamos a ver las nuevas funcionalidades para construir formularios HTML y como nos hacen la vida más fácil.

Les dejo un ejemplo en donde listo todos los nuevos tipos de input.

Descarga el ejemplo!

Y los elementos son:

· section: Se utiliza para una sección genérica de una página, sirve para agrupar contenido de un mismo tema.

· header: Utilizado para servir de contenedor para la información de cabecera de la página, generalmente esa información es el logo, nombre, lema y vínculos de navegación.

· hgroup: Utilizado para agrupar un grupo de elementos de encabezado (h1 – h6), actúa como un subheader.

· footer: Utilizado como contenedor para la sección de información de la parte inferior de la página, generalmente datos de contacto.

· nav: Utilizado para servir de contenedor para links de navegación, un ejemplo puede ser el menú de navegación del sitio.

· article: Utilizado para servir como contenedor para el contenido, un ejemplo puede ser un post en un blog.

· aside: Utilizado como contenedor para el contenido relacionado, es decir se puede manejar como un sidebar.

Un ejemplo (y aclaro es solo una posible distribución) de cómo sería la estructura de una página en HTML5 es:

Espero les sea de utilidad, en el próximo post hablaré sobre los nuevos tipos de input.

Entonces con HTML5 tenemos un nuevo set de opciones para el desarrollo de aplicaciones Web, así es que la barrera entre aplicaciones Web y aplicaciones cliente es cada vez más pequeña.

HTML5 aún no esta listo en su totalidad, pero aún así ya lo podemos utilizar es más, recomiendo altamente su uso. Si bien es cierto que tenemos problemas de compatibilidad con los browsers antiguos por falta de soporte, esto no es una limitación realmente, puesto que existen librerías, mecanismos y estrategias para dar soporte a estos browsers.

Entonces amigo desarrollador, que esperas para conocer HTML5? vas a esperar que todos los browsers lo soporten? vas a esperar que el estándar este listo? si tu respuesta es NO primero te felicito, y luego te digo que vas por un buen camino.

Yo no soy un experto en HTML5, solo soy un desarrollador que quiere dar lo mejor de si y compartir sus conocimientos… bueno suficiente de palabras bonitas y de motivación (jajaja).

Bueno y para que este post nos ayude a iniciar con HTML5:

1. ¿Qué es HTML5?

En resumen es el nuevo estándar para la creación de aplicaciones Web, pero no viene solo (como así?) HTML5 viene acompañado de tres amigos, de los cuales tenemos que ir hablando en cada post, y dichos amigos son: a) HTML, b) JavaScript y c) CSS 3. 

Así que ahora ya saben que debemos aprender.

2. Herramientas

Bueno, existen varias herramientas en el mercado para trabajar con HTML5, de las cuales yo uso generalmente 2:

• Microsoft Visual Studio 2010
• Microsoft WebMatrix

Visual Studio 2010 es una excelente herramienta, y en mi opinión es el mejor IDE que existe, claro esta enfocado a trabajar con lenguajes .net, con ASP.NET y ASP.NET MVC (entre otros), pero como ya sabrán es mi trabajo diario, en próximos post hablaré de como Visual Studio nos ayuda a trabajar con HTML5, CSS  y JavaScript.

WebMatrix es una herramienta ligera, sencilla de utilizar y lo mejor de todo es gratuita. Una de las características más interesantes es el poder trabajar con lenguajes NO Microsoft como PHP, además de tener la posibilidad de descargar, instalar, administrar y trabajar con multitud de aplicaciones de una manera bastante sencilla, y que aplicaciones? la verdad son muchas, así que nombraré algunas de las más renombradas, y son: WordPress, BlogEngine, DotNetNuke, Joomla, Umbraco, etc.

3. ¿Y qué tiene de nuevo HTML5?

De nuevo mucho, así que las voy a listar las nuevas características, si me escapa alguna me dejan un comentario y con gusto la adiciono:

• Nuevos tags semánticos
• Nuevos tipos de input
• Nueva API para el trabajo con formularios
• Elementos media, audio y video
• Geolocalización
• Canvas
• Web Storage
• Nuevas API’s de comunicación
• Web Sockets
• Aplicaciones offline
• Web Workers
• HTML5 FileSystem
• y mucho más…

Y hemos llegado al final de este post, he querido hacer una introducción bastante sencilla, para no enredarlos con conceptos y definiciones extensas. Espero les sea de utilidad y estén pendientes de los próximos post.

Nos vemos!

Para realizar la búsqueda, todo lo vamos a realizar en el cliente, así evitamos tener que volver a consultar nuestro modelo,  acá quiero utilizar algo conocido como Linq to JavaScript, y lo vamos a utilizar específicamente para realizar consultas sobre nuestros datos que tenemos en JSON.

Linq to JavaScript permite realizar consultas con la misma estructura/filosofía que utilizamos en Linq to Objects, o Linq to Entities, etc.

Ahora manos a la obra, aclaro algo, solo voy a colocar acá lo relevante de este ejemplo, ya que en el post anterior revisamos los demás puntos.

1. Definir el criterio de búsqueda

Vamos a definir un campo el cual vamos a utilizar como filtro, en este caso el seleccionado es el nombre del municipio, así que primero definimos el HTML:

   1:  <b><label>Municipio:</label></b><input id="txtMunicipio" type="text" placeholder="Escribe un municipio" />

2. Variable para contener los datos

Ahora, necesitamos tener una variable en donde almacenar los datos retornados por el servidor, así que creamos una variable global llamada objJSON:

   1:  var objJSON;

3. Guardar los datos retornados

Ya hemos definido la variable global para contener los datos, ahora lo que hacemos es que en el llamo AJAX, en la función relacionada con success la llenamos, es decir, nuestro llamado AJAX se verá así:

   1:  var CargarTemplate = (function () {

   2:      $.ajax({

   3:          type: "POST",

   4:          url: "GetDepartamentos.asmx/ObtenerDepartamentos",

   5:          contentType: "application/json; chartset=utf-8",

   6:          dataType: "json",

   7:          success: function (resul) {

   8:              objJSON = resul.d;

   9:              if (resul.d)

  10:                  $("#TemplateDepto").tmpl(resul.d).appendTo("#tableDepartamentos");

  11:          },

  12:          error: function (error) {

  13:              alert('Se ha producido un error al realizar la petición.');

  14:          }

  15:      })

  16:  });

Lo importante acá es la línea 8, allí es donde le estamos dando un valor a la variable global, y los que le estamos asignando es el objeto JSON con los datos.

4. Implementado el filtro

Y llegamos a lo interesante, como filtrar los datos? bueno lo que tenemos que hacer es utilizar el evento keyup del campo de texto txtMunicipio, les coloco el código y luego lo explicamos:

   1:  $("#txtMunicipio").on("keyup", function () {

   2:      var filtro = $(this).val().toLowerCase();

   3:      if (filtro == "") {

   4:          $("#tableDepartamentos tr.contenido").remove();

   5:          $("#TemplateDepto").tmpl(objJSON).appendTo("#tableDepartamentos");

   6:      }

   7:      else {

   8:          var query = Enumerable.From(objJSON)

   9:              .Where(function (x) { return x.Municipio.toLowerCase().indexOf(filtro) != -1 })

  10:              .Select(function (x) { return x })

  11:              .ToArray();

  12:   

  13:          $("#tableDepartamentos tr.contenido").remove();

  14:          $("#TemplateDepto").tmpl(query).appendTo("#tableDepartamentos");

  15:      }

  16:  })

Y que hace ese código??… lo voy a explicar:

Línea 2: guardamos en una variable lo ingresado en el campo de texto.

Línea 3 – 6: Si la variable viene en blanco, entonces se elimina el template, luego se le asignan de nuevos lo datos y se añade al contenedor.

Línea 8 – 11: Creamos una variable para almacenar el resultado de la consulta, lo primero que hacemos con Enumerable.From por decirlo de una manera amigable es que convertimos la variable objJSON a un tiempo ienumerable para poder ser consultado con Linq, luego simplemente realizamos la consulta de forma muy similar a como lo haríamos por ejemplo utilizando Linq to Entities.

Línea 13 – 14: Limpiamos la tabla, y le volvemos a asignar los datos al template y este lo añadimos al contenedor.

Bueno espero les sea interesante este post, es dejo la solución completa donde están los tres ejemplos de los post sobre templates:

Descarga la solución!

Entonces manos a la obra:

1. Base de datos

Vamos a tener una base de datos bastante sencilla, la cual maneja los mismos datos que teníamos en el ejemplo anterior, la idea es tener una tabla para departamentos y otra para ciudades, ahora para este ejemplo vamos a crear una vista donde consultemos esas dos tablas y solo vamos a traer los primeros 50 registros, la explicación de como crear vistas se sale de este tema, por eso solo coloco el T-SQL de la misma:

   1:  CREATE VIEW [dbo].[VIEW_DEPTO_MUNICIPIOS]

   2:  AS

   3:  SELECT TOP 50 Departamentos.CodDepto, Departamentos.Departamento, 

   4:          Municipios.CodMunicipio, Municipios.Municipio

   5:  FROM Departamentos 

   6:      INNER JOIN Municipios 

   7:      ON Departamentos.CodDepto = Municipios.CodDepto

2. Creando nuestro modelo de datos

Ya una vez tenemos la vista creada, creamos un modelo de EDM para ser consultado, lo importante acá es que cuando nos de la opción de seleccionar que objetos deseamos seleccionemos la vista creada anteriormente, para este ejemplo he seleccionado la tabla departamentos y ciudades, así como la vista creada, entonces nuestro modelo se verá así:

En este caso he creado un nuevo proyecto de librería de clases y allí he agregado mi modelo, lo he hecho así para poder utilizarlo en el siguiente demo.

3. Creando las plantillas T4

Aunque este es un tema bastante grande, voy a usar las plantillas para tener en un proyecto diferente mi entidades de dominio, estas se generan utilizando ADO.NET Self Tracking Entities, si desena ver como se hace pueden ver este post. Estas plantillas las he enviado a un nuevo proyecto, para que puedan ser referenciadas por cualquier otro proyecto.  Una vez generadas las plantillas vemos que por cada entidad tenemos una clase (se me paso cambiarle el nombre por default, por eso quedo Model1.tt):

4. Definiendo el HTML y la plantilla

En este punto, ya entramos al proyecto Web, allí al igual que en el post inicial creamos el contenedor y la plantilla, y no olviden agregar las referencias a los archivos js, entonces vamos a tener algo así:

   1:  //La plantilla

   2:  <script type="text/x-jquery-tmpl" id="TemplateDepto">

   3:      <tr class="contenido">

   4:          <td>${CodDepto}</td>

   5:          <td>${Departamento}</td>

   6:          <td>${CodMunicipio} </td>

   7:          <td>${Municipio}</td>

   8:      </tr>

   9:  </script>

  10:   

  11:  //El contenedor

  12:  <table border="1" cellspacing="2" cellpadding="2" id="tableDepartamentos">

  13:      <tr class="header">

  14:          <td>Cod Departamento</td>

  15:          <td>Departamento</td>

  16:          <td>Cod Municipio</td>

  17:          <td>Municipio</td>

  18:      </tr>

  19:  </table>

5. Obteniendo los datos

Ahora, para obtener los datos vamos a utilizar un Web Service, y dentro de el vamos a crear una función que se llama ObtenerDepartamentos(), dicha función va a devolver una lista genérica, y de que tipo? del tipo de la vista que hemos mapeado, y claro para consultar nuestro modelo vamos a utilizar Linq, entonces nuestra función se verá así:

   1:  <WebMethod()>

   2:  Public Function ObtenerDepartamentos() As List(Of VIEW_DEPTO_MUNICIPIOS)

   3:      Using contexto As New DeptoEntities

   4:   

   5:          Dim query As List(Of VIEW_DEPTO_MUNICIPIOS) = (From c In contexto.VIEW_DEPTO_MUNICIPIOS

   6:                                                         Select c).ToList()

   7:   

   8:          Return query

   9:   

  10:      End Using

  11:  End Function

6. Consumiendo el Web Service con jQuery y AJAX

Listo, ya tenemos los datos, tenemos el servicio, ahora llego el momento de consumir ese Web Service y esto lo haremos utilizando jQuery.

El código entonces jQuery para consumir ese Web Service es:

   1:  <script type="text/javascript">

   2:      $(document).on("ready", function () {

   3:          CargarTemplate();

   4:      })

   5:      var CargarTemplate = (function () {

   6:          $.ajax({

   7:              type: "POST",

   8:              url: "GetDepartamentos.asmx/ObtenerDepartamentos",

   9:              contentType: "application/json; chartset=utf-8",

  10:              dataType: "json",

  11:              success: function (resul) {

  12:                  if (resul.d)

  13:                      $("#TemplateDepto").tmpl(resul.d).appendTo("#tableDepartamentos");

  14:              },

  15:              error: function (error) {

  16:                  alert('Se ha producido un error al realizar la petición.');

  17:              }

  18:          })

  19:      });

  20:  </script>

En este caso lo importante es la línea 13, puesto que allí con el método tmpl le asignamos los datos al template, y como la respuesta del Web Service es en formato JSON le decimos resul.d, los demás parámetros de configuración ya los hemos tratado en post anteriores.

Bueno y una vez ejecutemos el ejemplo vamos a obtener lo siguiente:

Espero este post les haya gustado bastante, como ven es un implementación de las jQuery Templates más completa, y los espero en el otro post, donde a este mismo ejemplo le vamos a añadir la posibilidad de realizar búsquedas, para así luego de cargar los datos podamos ir filtrando los mismos.

El código del ejemplo, o mejor dicho la solución completa lo subiré con el siguiente post.

Así que iniciemos:

1. Archivos JavaScript

Para poder trabajar con estos templates, debemos agregar al menos dos archivos JavaScript, el primero será el plugin de jQuery y e segundo será el archivo propio del plugin, y por supuesto referenciarlo en nuestra página:

   1:  <script src="js/jquery-1.7.1.js" type="text/javascript"></script>

   2:  <script src="js/jquery.tmpl.js" type="text/javascript"></script>

2. Definir el contenedor

La idea de este ejemplo es mostrar información sobre departamentos y sus municipios, para ello vamos a utilizar una tabla, pero en este caso solo definimos la tabla y la primera fila que contiene el nombre de la columna:

   1:  <table border="1" cellspacing="2" cellpadding="2" id="tableDepartamentos">

   2:          <tr>

   3:              <td>Cod Departamento</td>

   4:              <td>Departamento</td>

   5:              <td>Cod Municipio</td>

   6:              <td>Municipio</td>

   7:          </tr>

   8:  </table>

3. Definir la plantilla

Ahora es momento de definir la plantilla, esta es en resumen el HTML que se va a generar, nótese que para definir el dato que se va a enlazar se utiliza ${nombre}, además la definimos en el head dentro de las etiquetas script, donde su type debe ser: text/x-jquery-tmpl

   1:  <script type="text/x-jquery-tmpl" id="TemplateDepto">

   2:      <tr>

   3:          <td>${CodDep}</td>

   4:          <td>${Dep}</td>

   5:          <td>${CodMun} </td>

   6:          <td>${Mun}</td>

   7:      </tr>

   8:  </script>

4. Enlazando datos

Y llego el momento de enlazar datos a la plantilla, esto lo realizamos con código cliente, y en este primer post vamos a tener datos fijos (en el siguiente vamos a usar datos desde una base de datos, usaremos Entity Framework, Linq y plantillas T4), entonces el código sería:

   1:  <script language="javascript" type="text/javascript">

   2:      $(document).on("ready", function(){

   3:          var datos = [

   4:               { CodDep: "05", Dep: "Antioquia", CodMun: "05001", Mun: "Medellín" },

   5:               { CodDep: "05", Dep: "Antioquia", CodMun: "05002", Mun: "Abejorral" },

   6:               { CodDep: "05", Dep: "Antioquia", CodMun: "05004", Mun: "Abriaquí" },

   7:               { CodDep: "05", Dep: "Antioquia", CodMun: "05021", Mun: "Alejandría" }

   8:           ];

   9:          $("#TemplateDepto").tmpl(datos).appendTo("#tableDepartamentos");

  10:      });

  11:  </script>

Lo interesante del código, primero validamos que la página este lista (línea 2), recuerda que desde jQuery 1.7 utilizamos on (si no lo sabes mira este link), luego declaramos la variable datos la cual contiene 4 registros (línea 3 – 8) para hacerlo sencillo, y finalmente en la línea 9 a la plantilla (ver paso 3) utilizando el método tmpl le asignamos la fuente de datos y se lo añadimos a nuestra tabla (ver paso 2)

Una vez listo, al ejecutar el ejemplo vamos a tener algo así:

Espero les haya gustado el post, como les comente antes en el próximo artículo vamos a realizar otro ejemplo un poco más complicado, ya que los datos los vamos a traer desde una base de datos, vamos a utilizar Entity Framework, generaremos unas plantillas T4, usaremos Linq para realizar consultas y un WebService para comuniciar el cliente con el servidor…

Como siempre les dejo el ejemplo para su descarga:

Descarga el ejemplo!

   1:  Page.ClientScript.RegisterClientScriptBlock(tipo,nombreScript,codigoScript,insertaScriptTags)

Entonces los parámetros de este método, según la documentación de MSDN es:

1. tipo [Type]: Tipo del script de cliente que se va a registrar
2. nombreScript [String]: Clave del script de cliente que se va a registrar
3. codigoScript [String]: Literal del script de cliente que se va a registrar
4. insertaScriptTags [Boolean]: Valor booleano que indica si se agregan etiquetas de script.

Ahora vamos a hacer un pequeño ejemplo que ilustra como hacerlo, creamos una página aspx, le agregamos dos botones, y programamos el evento click de cada uno, para el primer botón entonces tenemos:

   1:  Protected Sub btnScript1_Click(sender As Object, e As EventArgs) Handles btnScript1.Click

   2:      Dim sScript As New StringBuilder()

   3:   

   4:      With sScript

   5:          sScript.Append("alert('Este es un script dinámico');")

   6:      End With

   7:   

   8:      Page.ClientScript.RegisterClientScriptBlock(Me.GetType(), "ScriptDinamico1", sScript.ToString(), True)

   9:  End Sub

Con el anterior código la idea es simplemente mostrar un alert en la página, lo primero que hacemos es declara una variable de tipo StringBuilder, luego de la línea 4 – 6 lo que hago es a mi variable darle como valor el texto del alert, si es verdad una sola línea de código, entonces para que usar el StringBuilder? bueno lo he colocado para que cuando se cree un script mucho más largo (como es generalmente lo que yo hago) entonces no usemos una variable de tipo string, finalmente utilizamos el método RegisterClientScriptBlock, lo interesante acá es que como valor en el último parámetro le establecemos el valor de True, es decir le decimos que nos genere las etiquetas de apertura y cierre de scripts solo, es decir las etiquetas <script type=”text/javascript”> y </script>.

Ahora el código del segundo botón será prácticamente igual, solo que en este caso le vamos a decir que no genera las etiquetas de scripts automáticamente, en dicho caso tenemos que especificárselas:

   1:  Protected Sub btnScript2_Click(sender As Object, e As EventArgs) Handles btnScript2.Click

   2:      Dim sScript As New StringBuilder()

   3:   

   4:      With sScript

   5:          sScript.Append("<script type='text/javascript'>")

   6:          sScript.Append("alert('Este es un script dinámico');")

   7:          sScript.Append("</script>")

   8:      End With

   9:   

  10:      Page.ClientScript.RegisterClientScriptBlock(Me.GetType(), "ScriptDinamico2", sScript.ToString(), False)

  11:  End Sub

Bueno es un tema sencillo, pero espero el post les sea de utilidad.

La conferencia se realizará el día 24 de Enero de 6:00 pm – 8:30 pm.

Si estas en Bogotá puedes asistir de manera presencial a la charla en las oficinas de Microsoft (cupos limitados), o sino síguelo de manera online:

Registro presencial!

Registro online!

Bueno entonces allá nos vemos!

jQuery Intermedio

La fecha de este curso será febrero 1 y 2 de 6:00 pm a 9:00 pm.

Y lo que veremos en el curso:

• Que es jQuery?.
• Características generales de jQuery.
• Como incluir jQuery es una aplicación Web
• Selectores
• Filtros
• Trabajando con estilos y clases css
• Atributos
• Trabajando con eventos
• Eventos especiales
• Animaciones básicas

jQuery Avanzado

La fecha de este curso será febrero 8 y 9 de 6:00 pm a 9:00 pm.

Y los temas a ver en este curso son:

• Easing
• Colas de animaciones
• Animaciones personalizadas
• Qué es AJAX
• Qué es JSON
• Cargando html remoto
• Realizando peticiones AJAX.

Bueno espero verlos allá!