jueves, 29 de diciembre de 2011

construir un Mojito




Voy a tratar un problema que ocurre por estas fechas navideñas cuando un menor de edad te pide que le prepares un Mojito o cualquier tipo de bebida alcohólica.

Por si no lo habéis notado el ejemplo que os voy a mostrar es como preparar un Mojito en condiciones :)






public class Mojito {
        private final int mRon; //centilitros
        private final int mAzucar; //cucharadas
        private final int mLima; // un trozo es lo recomendable
        private final int mMenta; // 2 hojas está bien
        private final int mRefresco; // decilitros

       public Mojito(int ron, int azucar, int lima, int menta, int refresco){
               mRon = ron;
                mAzucar = azucar;
                mLima = lima;
                mMenta = menta;
                 mRefresco =  refresco ;
        }

/* Como es normal  la cantidad de lima y de menta siempre va ser la misma. Por eso para hacerlo mas cómodo y rápido usamos el siguiente constructor y que cada uno se eche la cantidad de ron, azucar y gaseosa que prefiera */

        public Mojito(int ron, int azucar, int gaseosa){
                this(ron, azucar, 1, 2, gaseosa);
        }

/* El problema ocurre cuando un niño te pide que le prepares una de esas bebidas tan chulas. Así que tenemos que crear otro constructor y usar lo siguiente */

        public Mojito(int azucar, int lima , int gaseosa){
                this(0, azucar, lima, 2, gaseosa);
        }

}

Bien ahora ocurre lo siguiente al crear un mojito pasa lo siguiente

Mojito m = new Mojito(5, 3, 0, 6, 2);

Que cantidad corresponde a que elemento si todos reciben los mismos parametros. Bien esto se soluciona de la siguiente manera.

public class Mojito {
        private final int mRon; // centrilitros
        private final int mAzucar; // cucharadas
        private final int mLima; // un trozo es recomendable
        private final int mMenta; // 2 hojas esta bien
        private final int mRefresco; // decilitros

        private Mojito(Builder builder) {
                mRon = builder.mRon;
                mAzucar = builder.mAzucar;
                mLima = builder.mLima;
                mMenta = builder.mMenta;
                mRefresco = builder.mRefresco;
        }

        public static class Builder {
                private int mRon; // centilitros
                private int mAzucar; // cucharadas
                private int mLima; // un trozo es recomendable
                private int mMenta; // 2 hojas esta bien
                private int mRefresco; // decilitros

                public Builder() {
                }

                public Builder setRon(int ron) {
                        mRon = ron;
                return this;}

                public Builder setAzucar(int azucar) {
                        mAzucar = azucar;
                return this;}

                public Builder setLima(int lima) {
                        mLima = lima;
                return this;}

                public Builder setMenta(int menta) {
                        mMenta = menta;
                return this;}

                public Builder seRefresco(int refresco) {
                        mRefresco = refresco;
                return this;}

                public Mojito build() {
                return new Mojito(this);}
        }
}

De esta forma el crear un mojito será un poco largo pero facil de entender.
Mojito m = new Mojito.Builder().setRon(5)
                                                     .setAzucar(3)
                                                     .setLima(3)
                                                     .setMenta(5)
                                                      .setRefresco(2).build();
El paso anterior no se debe omitir ya que es el que inicializa la cantidad de cada elemento, para ahorrarnos podemos indicar en la Class inicial que cantidad tiene cada elemento.

Bien, explicado esto la creación de los Mojitos es muy sencilla.
        Mojito offical = new Mojito.Builder().build();
        // mojito para niños
        Mojito sinMojito = new Mojito.Builder().setRon(0).build();
        // O ...
        Mojito sinMojito2 = new Mojito.Builder(0).build();

Que disfrutéis de un buen Mojito, hasta la próxima ;) Y Feliz Año Nuevo

viernes, 23 de diciembre de 2011

.htaccess: No mostrar las www

Ya sea por estética o por razones de SEO, podemos añadir las siguientes lineas en nuestro fichero .htaccess, de tal forma que cualquier URL con WWW pasará a no mostrarse las WWW.

RewriteEngine On
RewriteCond% {} HTTP_HOST! ^ tu-sitio-web.com $ [NC]
RewriteRule ^(.*)$ http://tu-sitio-web.com/ $ 1 [L, R = 301]

Pero cuidado que por motivos de SEO no es nada bueno indexar un contenido dos veces (una con www y la otra sin www) 
un saludo y Feliz Navidad!!!

domingo, 11 de diciembre de 2011

API de smushit

Retomo un antiguo amigo que siempre me ha ayudado a la hora de optimizar los elementos gráficos de un proyecto, estoy hablando de Smush.it de Yahoo! Que!!!!!! no me lo creo!! yo tampoco lo creía pero su API es realmente útil, simplifica mucho el trabajo de optimizar las imágenes.

Para los desconocidos de esta herramienta comentar que su función es eliminar los datos poco útiles, información no necesaria en nuestras imágenes. De esta forma logramos un peso menor en el gráfico sin perder calidad.

¿Como se usa esta API?
Es muy sencillo solo tenemos que introducir la URL de nuestra imagen, este la procesa y devuelve una URL de la imagen optimizada. De esta forma con un simple script en JAVA, PHP... se podrá hacer un File, fopen... donde se podrá descargar el nuevo gráfico y trabajar con el.




viernes, 2 de diciembre de 2011

PHP y los números grandes

Uno de los lenguajes de script más utilizado del mundo no es capaz de hacer comparaciones adecuadas.
<?php
$t1 = "1244431010010381771";
$t2 = "1244431010010381772";
if ($t1 == $t2) {
    print "iguales\n";
}
?>