feed twitter facebook LinkedIn facebook

MongoDB » Operador MongoDB OR

febrero 4, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya hemos visto el funcionamiento del Operador MongoDB AND en el cual podíamos realizar operaciones en la cuales se cumpliesen dos condiciones o filtros. En este caso vamos a ver como realizar operaciones que se pueden realizar cuando se cumpla un campo u otro. Para ello vamos revisar el uso del operador MongoDB OR.

La estructura es muy similar al operador MongoDB AND, pero en este caso vamos a utilizar el elemento $or. La estructura del operador MongoDB es la siguiente:

  1. db.coleccion.find({$or:[{filtro1},{filtro2},...{filtroN}]});

De esta forma si, de nuestra colección de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Queremos sacar ciudades que bien empiecen por M o bien empiecen por Z tendremos que utilizar nuestro operador MongoDB OR de la siguiente forma:

  1. cursor = db.ciudades.find({$or:[{ciudad:/^M/},{ciudad:/^Z/}]});

Vemos que cada una de las opciones que queramos concatenar con el operador MongoDB OR van dentro del array separadas por comas.

Ya solo tenemos que mostrar el resultado recorriendo el cursor:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

Como podéis comprobar el uso del operador MongoDB OR es muy sencillo. Solo hay que tener cuidado con el uso de las llaves, como en todo MongoDB ;-).

MongoDB » Operador MongoDB AND

febrero 3, 2014 por Víctor Cuervo 2 Comentarios Imprimir Imprimir

Cuando estemos realizando consultas MongoDB es fácil que necesitemos concatenar filtros en las consultas. Es decir necesitemos realizar el operador MongoDB AND.

Por ejemplo, en nuestra colección de ciudades:

{ "_id" : ObjectId("525ab02733b01a66a9dcbc5b"), "ciudad" : "Madrid", "habitantes" : 3233527 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5c"), "ciudad" : "Barcelona", "habitantes" : 1620943 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5d"), "ciudad" : "Valencia", "habitantes" : 797028 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5e"), "ciudad" : "Sevilla", "habitantes" : 702355 }
{ "_id" : ObjectId("525ab02733b01a66a9dcbc5f"), "ciudad" : "Zaragoza", "habitantes" : 679624 }

Podemos querer el consultar por el nombre de la ciudad y por el número de habitantes. Lo que buscaremos realizar con el operador MongoDB AND es filtrar por ciudades que empiecen por una letra y cuyos habitantes sean mayor de un número indicado.

El operador MongoDB AND tiene la siguiente estructura:

  1. db.coleccion.find({$and:[{filtro1},{filtro2},...{filtroN}]});

Dónde los filtros podrán ser de cualquier tipo de los que soporta MongoDB.

De esta forma, para poder escribir el filtro con el operador MongoDB AND que hemos comentado antes tendremos la siguiente sentencia:

  1. cursor = db.ciudades.find({$and:
  2. [{ciudad:/^M/},{habitantes:{$lt:1000000}}]});

Vemos que dentro del documento asociado al AND va un array con los filtros, que a su vez tienen la estructura BSON. Todos ellos separados por comas.

Aunque MongoDB tiene otros operadores adicionales como $or, $eq, $neq,... El operador MongoDB AND o $and se puede asumir en la propia consulta, de forma implicita, en una secuencia de filtros. Es decir, que podríamos escribir la consulta .find() de la siguiente forma:

  1. db.coleccion.find({filtro1,filtro2,...filtroN});

Por lo que reescribiendo el anterior uso del operador MongoDB AND tendríamos lo siguiente de forma implicita:

  1. cursor = db.ciudades.find({ciudad:/^M/,habitantes:{$lt:1000000}});

Como en todos los ejemplos, al dejar el resultado de los documentos sobre un cursor, solo nos queda el volcar el cursor:

  1. while (cursor.hasNext()){
  2. printjson(cursor.next());
  3. }

MongoDB » Consultas MongoDB Like

febrero 2, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Cuando accedemos a los datos de los campos de un documento en MongoDB podemos encontrarnos la necesidad de realizar consultas MongoDB like. Es decir, realizar consultas por cadenas similares de texto. Por ejemplo, nombres que empiecen por una letra o letras, palabras que contengan una cierta cadena de caracteres,...

Las consultas MongoDB like se resuelven mediante expresiones regulares. Lo que realizaremos mediante la siguinte sintaxis:

  1. db.coleccion.find({campo:expresión_regular});

Para los patrones de las expresiones regulares MongoDB utiliza “Perl Compatible Regular Expressions” (PCRE). De esta forma tendremos las siguientes similitudes con los patrones LIKE.

cadena% /^cadena/
%cadena% /cadena/
%cadena /cadena$/

De esta forma la sentencia para realizar consultas MongoDB like será la siguiente:

  1. cursor = db.ciudades.find({ciudad:/^M/});

En este caso hemos realizado un filtro LIKE de ciudades que empiecen por M.

A la hora de utilizar las expresiones regulares, los índices solo se utilizarán de forma eficiente cuando utilizemos la forma /^cadena/

Otros podrían ser ciudades que contengan una "r":

  1. cursor = db.ciudades.find({ciudad:/r/});

O ciudades que acaben en d:

  1. cursor = db.ciudades.find({ciudad:/d$/});

Ya solo nos quedará recorrer con un cursor el resultado para volcar los documentos devueltos por la expresión regular:

  1. while (cursor.hasNext()) {
  2. printjson(cursor.next());
  3. }

De esta forma vemos que es sencillo realizar consultas MongoDB Like.

MongoDB » Consultas MongoDB con límite de documentos

febrero 1, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Cuando estamos realizando consultas en MongoDB podemos tener la necesidad de establecer un límite en el número de documentos a devolver. En este artículo vamos a ver como podemos realizar consultas MongoDB con límite de documentos.

Lo primero que repasaremos será la forma de realizar una consulta mediante el método .find()

  1. cursor = db.ciudades.find();
  2.  
  3. while (cursor.hasNext()) {
  4. printjson(cursor.next());
  5. }

El método .find() se lanza sobre la colección que queremos consultar. En el caso del ejemplo sobre la colección ciudades. Dentro del método .find podemos establecer los filtros que necesitemos para realizar la consulta.

Cuando el cursor recorra todos los datos de la colección devolverá todos aquellos que contemplen el filtro. Si no ponemos nada, nos devuelve todos.

Así, si tenemos la colección ciudades como:

{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5b"),
	"ciudad" : "Madrid",
	"habitantes" : 3233527
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5c"),
	"ciudad" : "Barcelona",
	"habitantes" : 1620943
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5d"),
	"ciudad" : "Valencia",
	"habitantes" : 797028
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5e"),
	"ciudad" : "Sevilla",
	"habitantes" : 702355
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5f"),
	"ciudad" : "Zaragoza",
	"habitantes" : 679624
}

Nos devolverá todos esos documentos.

Para realizar consultas MongoDB con límite de documentos utilizaremos el método .limit(). El método .limit() tiene como parámetro el número de documentos a los que queremos limitar la respuesta. Es decir, que aunque haya más documentos que cumplen la condición, solo se devolverán tantos como indique el parámetro de .limit()

El código será el siguiente:

  1. cursor = db.ciudades.find().limit(2);
  2.  
  3. while (cursor.hasNext()) {
  4. printjson(cursor.next());
  5. }

En este caso el código limita a dos resultados como respuesta. Así, si partimos de la anterior colección, el resultado será el siguiente:

{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5b"),
	"ciudad" : "Madrid",
	"habitantes" : 3233527
}
{
	"_id" : ObjectId("525ab02733b01a66a9dcbc5c"),
	"ciudad" : "Barcelona",
	"habitantes" : 1620943
}

Lógicamente el uso del método .limit() a la hora de realizar consultas MongoDB con límite de documentos permite una optimización en el tiempo de respuesta de las consultas. Ya que la base de datos MongoDB solo recorrerá los documentos a los que nos hemos limitado y no todos.

Java » Convertir una Lista en un Array

enero 31, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Ya vimos en su momento como podíamos convertir, de una forma sencilla, un array en una lista en Java. En este caso vamos a ver la operación contraria que será convertir una lista en un array con Java.

Lo primero será definir una Lista. Para ello utilizamos el interface List implementado mediante una clase ArrayList. Hay que recordar que cuando utilicemos colecciones tenemos que indicar el tipo de colección que estamos utilizando. En nuestro caso vamos a crear una lista de cadenas o String.

  1. List<String> milista = new ArrayList<String>();

Para insertar cada uno de los elementos en la lista utilizamos el método .add().

  1. milista.add("Elemento 1");
  2. milista.add("Elemento 2");

Lo siguiente será crear el array sobre el que vamos volcar el contenido de la lista. A la hora de crear el array deberemos de asignarle el tamaño que tenga la lista. Para saber el tamaño de una lista en java utilizamos el método .size()

  1. String[] miarray = new String[milista.size()];

El interface List tiene un método .toArray() este es el método clave que nos va a convertir una lista en un array con Java. Así que simplemente invocamos el método indicando como parámetro el array sobre el que queremos volcar el contenido.

  1. miarray = milista.toArray(miarray);

Ahora, para comprobar que hemos realizado bien el proceso de convertir una lista en un array con Java vamos a recorrer el contenido del array y ver que es el mismo que insertamos en la lista.

  1. for(String s : miarray)
  2. System.out.println(s);

Y hasta aquí nuestro ejemplo de como convertir una lista en un array con Java. Esperamos que os haya ayudado.

Java » Números repetidos en un array Java

enero 30, 2014 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

Los ejercicios de manipulación de arrays son muy recomendables para aprender la lógica de programación Java, así como sus estructuras. De esta forma tenemos algunos ejemplos como encontrar el primer número repetido, encontrar el número mayor y su posición,...

En este caso vamos a ver como podemos encontrar los números repetidos en un array Java. Es decir, la idea es partir de un primer array que contenga los números a buscar.

  1. int numeros[] = {1,2,3,4};

Y tener un segundo array que contenga la lista sobre la que buscamos.

  1. int lista[]= {2,4,5,2,4,4,4,3,4,2,3};

Una solución rápida sería realizar dos bucles for, el primero que recorra el primer array Java y el segundo que recorra el segundo array Java.

  1. for (int x=0;x<numeros.length;x++) {
  2. for (int y=0;y<lista.length;y++) {
  3. if (numeros[x]==lista[y])
  4. System.out.println("El número "+numeros[x]+" está repetido");
  5. }
  6. }

La verdad que este código funcionaría ya que al recorrer los dos arrays Java chequearíamos todos los números. Si bien vamos a intentar que sea un poco más óptimo en la búsqueda. Y es que la idea es en primer lugar ir recorriendo el array de números (igual que hacíamos antes).

  1. for (int x=0;x<numeros.length;x++) {
  2. ....
  3. }

Pero en la búsqueda sobre la lista vamos a utilizar un bucle while de Java. Este bucle contendrá dos condiciones, por un lado la del límite del array y por otro un flag que nos diga si hemos encontrado el número, ya que en este caso no hace falta buscar más y podremos parar la búsqueda.

El código sería el siguiente:

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {...}
  6. }

Vemos que hemos utilizado un flag encontrado que estará a "false" mientras no encuentre el número, será en este momento cuando cambiemos su valor para salir del bucle.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10. }

Ya solo nos quedará preguntar por la variable encontrado para ver si se ha encontrado el número.

  1. for (int x=0;x<numeros.length;x++) {
  2. encontrado = false;
  3. iter = 0; // Iterador
  4.  
  5. while ((!encontrado) && (iter < lista.length)) {
  6. if (lista[iter] == numeros[x])
  7. encontrado = true;
  8. iter++;
  9. }
  10.  
  11. if (encontrado)
  12. System.out.println (numeros[x] + " es un número repetido. Encontrado en " + iter + " búsquedas");
  13. else
  14. System.out.println (numeros[x] + " no está en la lista. No encontrado en " + iter + " búsquedas");
  15. }

Adicionalmente vemos que en la variable iter tenemos el número de búsquedas que hemos realizado en el segundo array Java. Con esto ya tenemos resuelto como buscar números repetidos en un array Java.

JavaScript » Acceder al hash de la URL con Javascript

enero 29, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Si miras una URL el fina de esta puede contener una palabra separada por un símbolo de almohadilla (#). Esto es lo que se conoce como elemento hash de la URL y nos sirve para posicionarnos dentro de una parte determinada de la página. Esto lo conseguimos de forma sencilla mediante HTML.

La URL miweb.html#elemento se va a posicionar en la página allí dónde utilicemos el siguiente código:

  1. <a name="elemento"></a>

Si quieres más información al respecto puedes leer el artículo Enlace a una parte concreta de la página el cual te resolverá todas tus dudas.

Pero, ¿cómo podemos acceder al hash de la URL con Javascript? Es decir, qué hacer si queremos controlar cuando el usuario llegue con una URL que contenga una etiqueta o elemento de hash.

La solución es bastante sencilla y es que en Javascript tenemos el objeto location, el cual hace referencia a la URL que maneja el navegador, este objeto nos va a facilitar acceder al hash de la URL con Javascript.

  1. locatio

En concreto tenemos una propiedad del objeto location llamada .hash (el nombre que ni pintado) que nos devuelve el hash de la URL.

  1. //Volvar el hash a la consola
  2. console.log(location.hash;)

Como podemos ver, el uso de la propiedad location.hash nos facilita el acceso al hash de la URL con Javascript. Eso sí, solo tenemos que tener cuidado con una cosa, y es que no nos devuelve el elemento correspondiente con el hash, si no que nos devuelve el elemento precedido de la almohadilla.

Así de la URL

http://lineadecodigo.com/#acerca-de

El objeto location.hash nos devolverá:

#acerca-de

Ahora ya solo queda decidir qué hacer con el hash. Por ejemplo mostrar un contenido u otro, mostrar una pestaña u otra,... ¿qué más casos se te ocurren para utilizar la propiedad hash en Javascript?

Conversación » Conversaciones sobre Programación. Build 2014.01

enero 28, 2014 por Víctor Cuervo 2 Comentarios Imprimir Imprimir

Hemos empezado el 2014 un poco trastabillados, pero ya estamos aquí con un nuevo resumen de los grupos de conversaciones sobre programación. Nuestro primero resumen del año, nuestra Build 2014.01.

Estamos muy contentos viendo la cantidad de gente que está en los grupos. Algunos de ellos ya por cifras cercanas a los 15.000 usuarios. Y aunque el SPAM nos haga un poco la puñeta vemos que siguen siendo muy útiles para la gente. Algo que nos alegra mucho.

Estamos recibiendo avalancha de enlaces, así que aquí pondremos un pequeño (o grande, dependiendo de la calidad) de los enlaces que realmente aporten una gran calidad a los grupos de conversación.

Recordar que hay una serie de normas de comportamiento para los grupos de conversaciones sobre programación que se deben de acatar. Por favor, no dejéis de leerlas.

Por cierto, ¿Sabes cuantos grupos de Conversación en Español tenemos?

Las cosas interesantes que hemos visto en los grupos de conversaciones sobre programación son:

Si quieres que tu enlace esté aquí, solo tienes que crear contenido de calidad, compartirlo en los grupos de conversación o indicarlo en los comentarios.

Y para despedirnos, entrar en vuestros pensamientos... no digáis que alguna vez no habéis soñado así...

software-engineers

Más en el próximo resumen. Mientras, seguir utilizando los grupos de conversación.

Linea de Codigo » Feliz 2014

enero 2, 2014 por Víctor Cuervo 1 Comentario Imprimir Imprimir

Un nuevo año y nuevos retos por delante. Desde Línea de Código desear lo mejor para todos los que nos acompañáis día tras día. Que todos vuestros proyectos se cumplan... Disfrutemos juntos de este nuevo año.

¡¡ Feliz 2014 !!

Puedes ver el vídeo en http://www.youtube.com/watch?v=S_cmT5A7h44

HTML » Vídeo para crear tu primera página web

diciembre 22, 2013 por Víctor Cuervo Sin Comentarios Imprimir Imprimir

En este vídeo tutorial vamos a ver cómo puedes crear tu primera página web con el lenguaje HTML. Para ello revisamos cuales son los primeros pasos y explicamos los elementos básicos del lenguaje HTML que nos permitan crear tu primera página web.

Espero que os guste y os sea útil el vídeo tutorial...

Puedes ver el vídeo de cómo crear tu primera página web en http://www.youtube.com/watch?v=gCK_sDaoxiA