Desarrollo Web, PHP, Python, CSS, HTML, Javascript, GNU/Linux… » PHP

Aquí les traigo un trozo de código bastante interesante sobre Type Hinting.  Esto se refiere al tipo de parámetros que recibe un determinado método.  Personalmente me parece bastante útil,  ya que obtendremos un Fatal Error si el tipo de dato es incorrecto, esto nos ayuda a trabajar de manera más cuidadosa y prevenir futuros posibles errores, sólo por decir una de las utilidades.

1
2
3
4
5
6
7
8
9
10
11
12

< ?php
/**
 * @author Williams Mendez
 */
class MyClass {
    private $Database;
 
    public function __Construct(MyDB $Database = null) {
        $this->Database = $Database;
    }
   public function Insert(array $Data){ ..... }
}

Se pueden apreciar dos métodos, en el primer caso, se tiene la opción de no pasarle parámetro, pero si es invocado ese método, debe recibir un objeto del tipo MyDB. En el segundo caso, el método sólo debe recibir un parámetro del tipo “array”.

Otra buena aplicación de estas técnicas se puede apreciar en la creación de Interfaces y Clases Abstractas.

Suerte con el código .

Este ejemplo es muy bueno para aquellas ocaciones en las que quisieramos forzar a descargar un archivo, aun sea una imagen, ya que generalmente se abren dentro del mismo navegador.

Tambien es posible aprovechar este pequeño script para esconder nombres de archivos, de manera que se puede pedir un ID de un archivo y no su nombre, mucho menos su ruta.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

< ?php
// downloading a file
$filename = $_GET['path'];
 
// fix for IE catching or PHP bug issue
header("Pragma: public");
header("Expires: 0"); // set expiration time
header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
// browser must download file from server instead of cache
 
// force download dialog
header("Content-Type: application/force-download");
header("Content-Type: application/octet-stream");
header("Content-Type: application/download");
 
// use the Content-Disposition header to supply a recommended filename and
// force the browser to display the save dialog.
header("Content-Disposition: attachment; filename=".basename($filename).";");
 
/*
The Content-transfer-encoding header should be binary, since the file will be read
directly from the disk and the raw bytes passed to the downloading computer.
The Content-length header is useful to set for downloads. The browser will be able to
show a progress meter as a file downloads. The content-lenght can be determines by
filesize function returns the size of a file.
*/
header("Content-Transfer-Encoding: binary");
header("Content-Length: ".filesize($filename));
 
@readfile($filename);
exit(0);
?>

Hace unas semanas mi amigo David Tavarez publicó en su Blog un artículo sobre OpenCV, que no es mas que unas librerías bastante interesantes, que permiten identificar un rostro en una imagen.  Estas librerías no solo existen para PHP, sino que también la podemos encontrar en C++, Python, otros.

Les dejo una cita del post:

OpenCV wrapper to detect faces with PHP. The extension offers the two new functions: face_count() and face_detect(). In princible, they differ only by their return value. The first returns only the number of faces found on the given image and the other an associative array of their coordinates. face_count() serves only to save the loops for counting. Examples:

Face detection in pure PHP (without OpenCV). This is a PHP Class to face recognition without OpenCV, it use an data file, but not external libraries. We can use it with few code:

 
$detector = new Face_Detector('detection.dat');
$detector->face_detect('maurice_svay_150.jpg');
$detector->toJpeg();

Example:

Aquí les dejo una interesantísima función para imprimir el contenido de una variable, ya sea un objeto, un string, un array…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

< ?php
function show_php($var,$indent='&nbsp;&nbsp;',$niv='0')
{
    $str='';
    if(is_array($var))    {
        $str.= "<b>[array][".count($var)."]<br />";
        foreach($var as $k=>$v)        {
            for($i=0;$i< $niv;$i++) $str.= $indent;
            $str.= "$indent<em>\"{$k}\"=>";
            $str.=show_php($v,$indent,$niv+1);
        }
    }
    else if(is_object($var)) {
 
        $str.= "<b>[objet]-class=[".get_class($var)."]-method=[";
        $arr = get_class_methods($var);
           foreach ($arr as $method) {
               $str .= "[function $method()]";
           }
        $str.="]-";
        $str.="</b>";
        $str.=show_php(get_object_vars($var),$indent,$niv+1);
    }
    else {
        $str.= "<em>[".gettype($var)."]</em>=[{$var}]<br />";
    }
    return($str);
}
?>

Esta interesante función fue tomada de PHP.net

El uso de Frameworks hace la vida de un programador, muchas veces, más sencilla o menos monótona, no teniendo así que escribir y reescribir el mismo código decenas de veces en aplicaciones diferentes.  Además de esto, hacen que se mantenga cierto patrón al escribir programas(siempre y cuando estemos conscientes de lo que estamos haciendo), dándole algo de uniformidad al código y se puede decir que un estilo fácil de entender.

Por otro lado, tenemos otras ventajas obvias, como es el uso de clases y métodos que no nos interesa desarrollar, ya sea porque sería complicado o porque no nos importa.

Es claro que estas maravillosas herramientas han aportado al ágil desarrollo de aplicaciones, de la misma manera que han contribuido a que no nos preocupemos por ciertos algoritmos, pues ya están hechos y listos para ponerlos en práctica.  También es una grandísima ventaja el hecho de trabajar con códigos bien revisados y probados(cuando utilizamos frameworks Open-Source o de empresas que pagan por su mantenimiento).

Ahora bien, todo eso es maravilloso cuando ya hemos estudiado un framework en específico, pues para muchos el hecho de tener que aprender un framework o peor aún, luego de haber aprendido un framework, cambiarse a otro, es una tarea casi tan complicada como escribir tu propio código o desarrollar tu propio framework.

Según este post: Do Frameworks Fail? When?, el uso de frameworks aún presenta tres problemas:

• La curva de aprendizaje, que empeora cuando ya un framework no está siendo mantenido.
• Eficiencia del Código: Muchas veces consumen muchos recursos y el programador no tiene control sobre esto.
• El costo de Propiedad: Muchos te enseñan como hacer lo fácil, pero lo difícil seguirá siendo aún más difícil, y tendrás que invertir tiempo(lo cual es dinero) en buscar el framework más apropiado.

No por esto debemos dejar de utilizar un framework, pero si debemos tener en cuenta cuál es el que se ajusta a cada necesidad.

Cada día nos hacemos más dependientes de Internet, y ahora aún más con todos los Smartphones que tenemos en el mercado y los que se aproximan.  Las redes sociales nos hacen presión y nos dicen: “No te vayas!! Me necesitas!!”, y les hacemos caso.  Ya no sólo escuchamos música en nuestras computadoras mientras trabajamos o jugamos o navegamos, sino que hay todo un mundo diferente en la Web.

Con la llegada al medio de la Web 2.0, Web services,  Cloud Computing, entre otras cosas, me parece a mí que no hay grandes necesidades de Aplicaciones de Escritorio mas que para aquellas aplicaciones que necesariamente deban acceder el hardware del equipo, es decir, aplicaciones de bajo nivel.

Es por esto que Google ha tenido esa iniciativa de crear un Sistema Operativo basado en un Navegador(Google Chrome).  Hay personas que se están olvidando sus Laptops, pues con su iPhone hacen todo lo que “necesitan”.

Aparte de esto, cada día vemos como empresas han migrado sus Aplicaciones de Escritorio a Aplicaciones Web.  Y esa es la tendencia.  Un ambiente más ligero, más agradable a la vista, más seguro y sobre todo, pero muy sobre todo, totalmente multiplataforma.

Multiplataforma.  Microsoft Windows, GNU/Linux, Mac OS…Chrome OS??? Cual elegirías tú? Cuál versión? Por qué no nos olvidamos de eso y preguntamos: cuál Navegador voy a utilizar? Qué importa! Ya todos son buenos! Multiplataforma, el gran dolor de cabeza de los desarrolladores de Software.

Increíblemente estoy diciendo que Google Chrome OS tendrá su futuro…Yo mismo me negaba a creerlo, pero sí, sólo así podremos romper los problemas de compatibilidad de aplicaciones…Multiplataforma…Multiplataforma…La Web es el Futuro…

iPHP es un proyecto que planea desarrollar un Shell interactivo para PHP, al igual que existe en Python y el “irb” en Ruby, que realmente son herramientas muy poderosas y, a mi entender, muchas veces necesarias.  Hace un buen tiempo que estuve esperando esto, pues muchas veces he sentido la necesidad de una aplicación de este tipo.

El Interactive Shell es un Shell que permite evaluar expresiones arbitrarias y que muestra el resultado en tiempo real a medida que vas escribiendo tu script.  Este Shell es sumamente útil si estamos Debbuging, probrando cosas rápidamente, en fin, una herramienta muy poderosa.

Aquí les dejo algo para que vean de que se trata:

iphp is an interactive php shell that solves a number of painful problems with normal php shells:

• Fatal Error handling – iphp doesn’t die even if your code does.

• readline support

• autocomplete support (tab key)

• history support across runs

• support ctags tags files

• implemented as a class for integration with your framework

• require support (supports dynamic includes)

• autoload support

Example:

> new ArrayObject(array(1,2))

ArrayObject Object
(
[0] => 1
[1] => 2
)

> $_[0] + 1
2

Mucha gente tiene la confusión de si se puede o no correr un programa escrito en PHP desde la línea de comandos.  Pues aquí les respondo que sí y les traigo algo para que vayan comprendiendo su funcionamiento.

El siguiente ejemplo se trata de un pequeño compresor de archivos con una técnica muy barata que he hecho para una clase de Codificación y que luego les mostraré de qué se trata.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

< ?php
/**
* Compress.php
*
* ejemplo de corrida:
* $ php compress.php  ARCHIVO_ENTRADA
* $ php compress.php -d ARCHIVO_ENTRADA  ARCHIVO_SALIDA
*/
//saber los parametros que fueron pasados al correr el programa
if($argc < 2 )
    exit("Debe especificar al menos el archivo de entrada.\n");
 
define('COMPRESS',1);
define('UNCOMPRESS',2);
 
//saber que opcion se ha tomado
/**
 * La opcion '-c' es para comprimir
 * La opcion '-d' es para decomprimir
 * si no se especifica opcion, se va a comprimir
 */
if($argv[1][0] == '-') {
    switch($argv[1]) {
        case '-c':
            $action = COMPRESS;
            break;
        case '-d':
            $action = UNCOMPRESS;
            break;
        default:
            die("Opcion '{$argv[1]}' Incorrecta. Utilice '-c' para comprimir y '-d' para decomprimir.\n");
    }
    //archivo de entrada
    $source_file = $argv[2];
    //se verifica si el usuario especifico archivo de salida, de lo contrario
    // se verifica si se va a comprimir para generar el fichero de salida.
    // Si es para decompresion, se debe especificar el fichero de salida.
    if($argc > 3)
        $destination_file = $argv[3];
    else if($action == COMPRESS){
        $ext = end(explode(".", $source_file));
        $destination_file = str_replace(basename($source_file),str_replace($ext,'wmz',basename($source_file)),$source_file);
    }else{
        die ("Debe especificar el archivo de salida, no se conoce la extension del archivo original\n.");
    }
}
else {
    //Lo mismo que el paso anterior, pero ahora se sabe que es compresion porque
    // no se especificó una opcion y se asume compresion.
    $action = COMPRESS;
    $source_file = $argv[1];
    if($argc > 2)
        $destination_file = $argv[2];
    else {
        $ext = end(explode(".", $source_file));
        $destination_file = str_replace(basename($source_file),str_replace($ext,'wmz',basename($source_file)),$source_file);
    }
}
 
//Incluimos la clase BitMapping
//Notese que se producirá un error Fatal si no existe el fichero BitMapping.php
require_once 'BitMapping.php';
// Crear instancia
$compressor = new BitMapping($source_file,$destination_file);
//Proceder a Comprimir o Decomprimir
switch($action) {
    case COMPRESS:
        $compressor->compress();
        break;
    case UNCOMPRESS:
        $compressor->uncompress();
        break;
}
?>

En los próximos días publicaré la Class que comprime y decomprime =)

Ayer sábado estuvimos reunidos en Colina’s Mall, Santiago, un grupo de personas que creemos en lo que hacemos, que sabemos  que quizás no somos los mejores del planeta, pero estamos mas conscientes de lo que hacemos que una gran mayoría en nuestro país.  Hemos llegado a esta reunión por un deseo que @davidtavarez y yo (@wm3ndez) nos expresamos hace tan sólo una semana atrás y que fue acojida rápidamente por un gran número de personas.

Luego, vía Twitter(nuestro mejor aliado hasta el momento), fuimos “regando” la idea y hemos tenido apoyo de varias personas en Sto. Dgo. que también piensan que estamos en lo correcto y que es buena iniciativa.  Por esto hicimos una primera reunión informal, a solo unos días de haber decidido que esto era bueno!!

Allá llegamos a las 4 PM @ingluisjimenez y yo(@wm3ndez), luego llegó @KDeMoya y al poco rato Hector Marrero y Saury Bravo (aún no conozco sus cuentas de twitter).  El señor @davidtavarez se presentó minutos después con @carlosjln.  Más tarde @Shady y @pavelonsky.

Estando todos allá empezamos a hablar sobre el gran proyecto de @carlosjln y su Framework Javascript, le comentabamos que aparte de todo el conocimiento que él ha adquirido desarrollando su FW es de gran satisfacción para él, pero que el debe darle otro enfoque.  En lo personal, todavía le sugiero que lo de a conocer, porque sin dudas es bastante eficiente.

Hablamos de temas interesantes, como es el hecho de que en nuestro país hay gran cantidad de personas haciendo disparates, dañando nuestra imagen y dañando el mercado.  Hay mucha gente “buscandoselas” en la calle y “pasandose de vivos”, viendiendo sueños y haciendo mega estupideces(si así se puede decir).  Es decir, estabamos tocando el importantísimo punto que nos ha hecho pensar que debemos organizarmos para que cosas como estas no afecten trabajos de calidad.

También planteamos la problemática situación del Ing. Telemático/Informático  que va a la Universidad y “compra” un título y luego tú, que haces un buen trabajo, eres juzgado por el pésimo desempeño como profesional -y quien sabe si como persona- de ese “colega” tuyo.  Es esto lo que andamos buscando, mostrar a nuestro país que esa no es la totalidad de los profesionales, que profesional no es un título, es conocimiento, práctica…

Por otro lado, tenemos el problema de nuestros empresarios: La gente que “tiene los cuartos” en este país aún no sabe lo que significa la palabra “Internet”.  Creen que cada sistema web based que hagas es “una paginita” en una manera despectiva.  Y no sólo los empresarios, sino otros Ingenieros de carreras como Ing. Electromecánica, que están mal informados.  El sector inmobiliario, por ejemplo, es un sector que maneja buen dinero, pero los propietarios de esas empresas de bienes raíces creen que todo es sencillo y quieren que les regalen las cosas!(Abusadores!!!).

Hector Marrero comentaba que nuestros pensamientos e ideales están demasiado adelantados a la de nuestros empresarios.  Gran problema porque  luego no hay forma de confiar en nosotros…

Entre otras cosas, quedamos en crear un Site(que ya está arriba): http://apoyalolocal.com y puedes seguirnos en twitter: @apoyalolocal.  La próxima reunión será en Sto. Dgo., más o menos dentro de un mes(aún no tenemos fecha).

Apoya lo local es más que decir “yo te apoyo”, es un movimiento que pretende destacar lo bueno.  Quiero destacar que cuando hablé de aquellos que andan “buscandoselas”, no me refiero a que hay que hundirlos y desaparecerlos, más bien sugiero orientarlos y si de verdad quieren crecer, se les ayuda, pero que no hagan daño a los que si hacemos lo correcto.

Perseguimos que nuestro país reconozca nuestro trabajo, reconozca que hay gente que hace bien las cosas, que no hay que buscar peruanos, colombianos, etc. para implementar soluciones de Software o de cualquier cosa que “huela” a tecnología.

Tu que estás leyendo esto, abre los ojos, mira lo que hay en tu país y #apoyalolocal @apoyalolocal http://apoyalolocal.com

PHP nos ofrece la facilidad de usar algunos métodos mágicos en nuestras Classes que pueden servirnos de muchísima ayuda y que muchos dejan pasar por alto estas herramientas, muchas veces muy eficientes y útiles.  Hoy les traigo algunos ejemplos del uso del método mágico “__set”.

El método __set es invocado cuando intentamos asignarle valor a una propiedad existente o no de un objeto.  Veamos este primer ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

< ?php
class MyClass{
  private $_var1;
  public function __construct($var = null){
     $this->_var1 = $var;
  }
  public function printVar($varname){
     print $this->$varname;
  }
  public function __set($var, $value){
    $this->$var = $value;
  }
}
?>
/***************************************************/
//Ejemplo de uso:
$MyObject = new MyClass;
$MyObject->myvar = 5;
$MyObject->printVar('myvar'); // Salida sera: 5

En el ejemplo anterior, la propiedad MyClass::myvar no existe, pero es creada en ese instante que se le asigna el valor “5″.

Otro buen ejemplo puede ser este que encontré en TuxRadar.com:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

 < ?php
    //...[snip - add your MySQL connection code here]...
 
    class mytable {
        public $Name;
 
        public function __construct($Name) {
            $this->Name = $Name;
        }
 
        public function __set($var, $val) {
            mysql_query("UPDATE {$this->Name} SET $var = '$val';");
        }
 
        // public $AdminEmail = 'foo@bar.com';
    }
 
    $systemvars = new mytable("systemvars");
    $systemvars->AdminEmail = 'telrev@somesite.net';
?>

Ayer mi compañero David Tavarez hizo un tweet diciendo que debemos apoyar lo nuestro, los dominicanos generalmente no apoyamos nuestras cosas, nuestra cultura, nuestra gente, nuestras creaciones, nada nuestro.  Es por eso que David y yo estamos en el plan de empezar a unir a todos los desarrolladores de Software y amantes de la tecnología de la región, principalmente de Santiago.

La iniciativa pretende unir, en encuentros sociales, a todos aquellos que sean muy famosos como aquellos que no lo sean tanto pero que se identifican con lo que hacen porque les encanta igual que a nosotros…

Apoyemos lo nuestro!!

Esta es una función realmente útil que muchas veces hacemos 3000 cosas para lograr algo parecido y algoritmos super complicados.  Esta forma de contar elementos la aprendí del Profesor Felipe Núñez en una clase de Estructura de Datos, y la he puesto aquí porque vi algo parecido en el blog de mi pana David Tavarez

1
2
3
4
5
6
7
8
9

function getRepetitions($value, array $values){
	if(!sizeof($values))
             return false;
	foreach($values as $v){
		$rep[$v]++;
	}
	return (int)$rep[$value];
}
print getRepetitions(3,array(3,3,3,5,6,4,3,6,5,4,6,3,2,8,8))."\n";

Esta es una expresión regular bastante fea, pero igual funciona y puede ser muy útil el ejemplo para quien quiera tomar de ejercicio el ejemplo, pues apuesto a que alguno de ustedes que me visitan quizas no saben lo que es una expresion regular y puede que sea un buen momento para que empiecen a investigar…

1
2
3
4
5
6

< ?php
function valid_ip($ip) {
    return preg_match("/^([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])" .
            "(\.([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}$/", $ip);
}
?>

PHP 5.3.0 offers a wide range of new features:

• Support for namespaces has been added.
• Support for Late Static Bindings has been added.
• Support for jump labels (limited goto) has been added.
• Support for native Closures (Lambda/Anonymous functions) has been added.
• There are two new magic methods, __callStatic and __invoke.
• Nowdoc syntax is now supported, similar to Heredoc syntax, but with single quotes.
• It is now possible to use Heredocs to initialize static variables and class properties/constants.
• Heredocs may now be declared using double quotes, complementing the Nowdoc syntax.
• Constants can now be declared outside a class using the const keyword.
• The ternary operator now has a shorthand form: ?:.
• The HTTP stream wrapper now considers all status codes from 200 to 399 to be successful.
• Dynamic access to static methods is now possible.
• Exceptions can now be nested.
• A garbage collector has been added, and is enabled by default.

Source: PHP.net