Llevaba mucho tiempo usando MODx y WordPress como base para la mayoría de paginas que requerian un administrador de contenidos, hoy me encontre con October CMS y puedo decir que es un gran pero gran competidor en el mercado.

Carácteristicas principales.

  • Escrito en Laravel
  • Usa LESS
  • Tiene un gran Backend
  • Sistema de eventos inigualable
  • Arquitectura de plugins kick-ass
  • Una instalación realmente ligera por medio de composer

A veces tenemos la necesidad de utilizar partes del framework en algunos otros proyectos en los cuales no queremos cargar todo y mucho menos utilizar el Front Controller que tiene Zend_Application.

Ejemplo:

Queremos usar Zend_Db en un proyecto para utilizar la abstracción de la base de datos.

Cargar la carpeta que tiene las clases Zend que requerimos, en este caso esta es la estructura que tengo para cargar Zend_Db

Zend

Configuramos el autoloader

$paths = array(
    realpath(dirname(__FILE__) . '/library/'),
    '.',
);
set_include_path(implode(PATH_SEPARATOR, $paths));
require "Zend/Loader/Autoloader.php";
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->setFallbackAutoloader(true);

Procedemos a usarlo :) ya podemos usar las clases que están autocargadas

<?php
$view = new Zend_View();
 
//o bien quizá un
 
use Zend_Db_Table_Abstract as DataTable;
 
class Blog extends DataTable{
 
}

Muchas veces necesitamos “informarle” a una función, objeto, callback cuando un proceso ya terminó sin embargo debido a los procesos asíncronos empezamos a acoplar mucho nuestras funciones abusando de los callbacks, cuando estuve utilizando Objetive C encontré muy útil la clase NSNOtificationCenter que nos permite manejar los eventos de los objetos de una manera sencilla y poder compartir estados de nuestros objetos con quien desee suscribirse a ellos.

Usar Tyny pub/sub

https://gist.github.com/cowboy/661855

Imaginemos el siguiente escenario clásico en una webapp

Tenemos un div con información sobre un usuario, que necesitamos se actualice cuando “suceda” algo por ejemplo cuando acabe de invocarse un ajax.

<div class="persona">
   <div class="nombre">Oscar</div>
   <div class="sueldo">$0.0</div>
<div>
//función encargada de actualizar el usuario
function actualizarUsuario(event,param) {
  $('.sueldo').text(param);
}
 
//le ponemos un nombre a nuestro listener encargado de "escuchar" cuando se "publique" una actualización y pasarle el control a actualizarUsuario
$.subscribe("/actualiza/usuario", actualizarUsuario);
 
//hacemos en algún punto de nuestro código un ajax.
 
$.ajax({
    url: '/api/done',
    success:function(r){
      //enviamos un "update" a todos los que se suscribieron al evento que nos interesa
      //suponemos que r es un object que tiene el sueldo en una de sus propiedades
      $.publish("/actualiza/usuario", [r.sueldo]);
    }
});
 
};

He creado un paquete en “composer” para que puedan bajarse una versión de Zend 1 lista para usarse sin complicaciones :)

Paso 1. Ir a tu terminal y teclear

composer create-project icode.mx/zf1skeleton app -s dev

Paso 2. Cuando el instalador de pregunte, si deseas mantener los datos del control de versiones, preferiblemente seleccionaras que NO ya que seguramente tu harás tu propio repositorio – fork del proyecto.

screen

Paso 3. Disfrutar :)

Hello World Zend

<?php
 
namespace PHP55;
 
$amigo = ["amigo1", "amigo2", "amigo3", "amigo4"][1];
// $amigo = "amigo2"
 
$inicial = "Palabra"[0];
// $inicial = 'P'
 
class User{
 
}
 
$obj = new User();
 
echo User::class;
 
$productos = [
    ["Nombre 1", "Precio 1", "Descripción 1"],
    ["Nombre 2", "Precio 3", "Descripción 2"],
    ["Nombre 3", "Precio 3", "Descripción 3"]
];
 
foreach ($productos as $producto) {
    $nombre      = $producto[0];
    $precio      = $producto[1];
    $descripcion = $producto[2];
}
 
foreach ($productos as list($nombre, $precio, $descripcion)) {
    echo $nombre."<br>";
}
 
//El constructor del lenguaje empty acepta expresiones
 
if (empty(function () { return false; })) {
    echo "El valor pasado es vacío.";
}
 
function findProducto(){
 
}
 
function error(){
 
}
 
// antes de PHP 5.5 había que hacer así las comprobaciones
if (empty($producto = findProducto($productoId))) {
    error('No se ha encontrado el producto');
}
 
// con PHP 5.5 el código anterior se simplifica
if (empty(findProducto($productoId))) {
    error('No se ha encontrado el producto');
}

Javascript es un lenguaje realmente fantástico sin embargo hay que comprender las diferencias que tiene frente a otros lenguajes en cuanto a la “orientación a objetos”

Tenemos el siguiente ejemplo:

var myApp = function(){
type = "Friend" // ERROR: estamos creando la variable en el global scoope
var name = "World" // CORRECTO: creando variable en el scoope de MyApp
var sayHello = function(){
//ERROR: pensaríamos que funciono :) y que this.type esta correctamente asignada en el objeto my app
//pensariamos erroneamente y nos preguntariamos por que this.name no imprime nada.
//la sorpresa es que this no esta apuntando al objeto MyAPP si no al GLOBAL scoope :o
console.log( 'Hello, ' + this.type + this.name );
};
sayHello(); // invocar la función
};
 
myApp(); // Hello, Friend

Cuidado con el scoope :)

El Type hinting o (implicación de tipos) es una manera genial de obligar a que los usuarios cumplan con un “contrato de implementación”, obligándolos a pasar parámetros de determinado tipo, cabe mencionar que en PHP solo funciona con objetos y Arrays.

<?php
//review type hinting
//http://php.net/manual/es/language.oop5.typehinting.php
//Usarse con clases e Interfaces
interface Facturable{
    function calcularIva();
    function validarRfc();
}
class FacturaDigital implements Facturable{
    function calcularIva() {
        return 'Calculando Iva Factura';
    }
    function validarRfc() {
 
    }
}
class ReciboBarato implements Facturable{
    function calcularIva() {
        return 'Calculando Iva Recibo';
    }
    function validarRfc() {
 
    }
}
function CalcularMonto(Facturable $factura){
    return $factura->calcularIva();
}
echo CalcularMonto(new ReciboBarato());

Lo hermoso de los callback o retrollamadas es que nos salvan el trasero cuando necesitamos que una función sea llamada justamente cuando haya terminado “su proceso”.

Ejemplo:

Vamos a simular Ajax de jQuery pero con PHP :p

<?php
function ajax($url,$llamada){
    $data = file_get_contents($url);
    if($data){
        $llamada(array('success'=>true,'data'=>$data));
    }else{
        $llamada(array('success'=>false));
    }
}
//¿cool cierto?
//no nos interesa cuanto se tarde file_get_contents en procesar su contenido la función $llamada sera invocada.
ajax('http://icode.mx',function($response){
    if($response['success']){
        print_r($response['data']);
    }else{
        echo 'No existe';
    }
});