Tambien Google estrena una nueva pagina Google Developer, donde encontraremos informacion sobre los terminos de usos, política de privacidad, documentación y muchas otras cosas mas!

Google nos ofrece librerías para varios lenguajes de programación, tales como:

• .NET
• Java
• Objetive C
• PHP
• Pyton
• Ruby
• Google Web Toolkit

Bootstrap, From Twitter es un conjunto de herramientas de Twitter diseñado el desarrollo de aplicaciones y sitios webs.

Incluye base de CSS y HTML para la tipografía, formas, botones, cuadros, redes, navegación, y mucho más.

Bootstrap para twitter fue desarrollado por @mdo y @fat

Con la ayuda y los comentarios de muchos ingenieros en Twitter, Bootstrap ha crecido significativamente para abarcar no sólo los estilos básicos, pero más elegante y duradero de front-end patrones de diseño.

Bootstrap fue testeado y soporta los browsers mas modernos como Chrome, Safari y Firefox, y hasta la porquería de Internet Explorer. Por suerte no dicen si soporta IE6, no entiendo porque la gente todavía sigue usándolo (que generoso que soy llamando gente a ese tipo de personas). Bueno mejor sigamos antes que uno se haga mala sangre y empiece a romper cosas.

Que es lo que contiene Bootstrap:

• Los archivos originales .less.
• Archivos CSS completos y minified.
• Documentación.
• Ejemplos.

Diseños :

Cuadriculas, Layouts, Encabezados, Textos, Citas, Listas, Tablas (distintos tipos, incluye ordenación de tablas), Todo tipo de Inputs para Formularios,  Botones, Mensajes de Alertas y Errores, Bloques de Mensajes, Barra de Navegación, Paginación, Modales, Tool Tips, Popovers, etc…
 
Link Sitio Oficial | http://twitter.github.com/bootstrap/

Tipos de Errores:

Existen varios tipos de errores, por lo general se refieran a niveles de error en PHP.

Errores de Compilación:

• Errores detectados por el IDE mientras se compila el script.

Configuración:

Existen varias opciones en la configuración de los errores y su registro, para ello tenemos el archivo php.ini que es la que se encargará de almacenar todas estas configuraciones.

Nota: Luego de cambiar algo del archivo php.ini es necesario reiniciar el apache para que los cambios surjan efecto, sino no se tomaran estos cambios.

Constantes Predefinidas:

Un listado de las constantes predefinidas para los distintos tipos de errores, son muy útiles para su reporte, podemos definir esto en nuestro archivo PHP.

Ejemplo:

error_reporting=E_ALL & ~E_NOTICE

En este caso mostraremos todos los errores, salvo las NOTICE.

E_ERROR

• Errores fatales que detienen la ejecución del script.

E_WARNING 

• Advertencias en tiempo de ejecución, no detienen la ejecución del script.

E_PARSE 

• Errores de análisis en tiempo de ejecución.

E_NOTICE 

• Avisos que se muestran en tiempo de ejecución. Indica algo que podría ser un error.

E_CORE_ERROR 

• Errores fatales que ocurren en el arranque del core de PHP. Parecido a  E_ERROR, salvo que son generados por el núcleo de PHP.

E_CORE_WARNING 

• Advertencias que ocurren en el arranque del core de PHP. Parecido a  E_WARNING, salvo que son generados por el núcleo de PHP.

E_COMPILE_ERROR 

• Errores fatales en tiempo de compilación. Parecidos a E_ERROR, salvo que son generados por el Motor de Script Zend.

E_COMPILE_WARNING 

• Advertencias en tiempo de compilación. Parecidos a E_WARNING, salvo que son generados por el Motor de Script Zend.

E_USER_ERROR 

• Errores generados por el usuario, mediante el uso de la función trigger_error().

E_USER_WARNING 

• Advertencias generadas por el usuario, mediante el uso de la función trigger_error() .

E_USER_NOTICE 

• Mensajes de avisos generadas por el usuario, mediante el uso de la función trigger_error().

E_STRICT 

• Habilítelo para que PHP sugiera cambios en su código, lo que asegurará la mejor interoperabilidad y compatibilidad con versiones posteriores de PHP de su código.

E_RECOVERABLE_ERROR 

• Errores fatales que son recuperables.

E_DEPRECATED 

• Avisos en tiempo de ejecución, que indicara el código que no funcionará en futuras versiones.

E_USER_DEPRECATED 

• Avisos generados por el usuario, mediante el uso de la función trigger_error().

E_ALL 

• Todos los errores y advertencias de PHP, excepto E_STRICT (Incluida en 5.4.0).

Se pueden combinar todos estos con los siguientes operadores ‘|’, ‘~’, ‘!’, ‘^’ y ‘&’.

Link Importante:

Listado de funciones para Manejo de errores | Link PHP.NET

Espero que les sea útil.

Despues dando vuelta si encontraba algo sobre este tema encontré el perfil de Brian Glick (YouTube Product Manager) en el cual anunciaba esta novedad.

A mi me parece algo interesante, pero no es algo 100% util, es algo mas que nos ofrece el gran mundo google, para simplificarnos la vida.

Que opinan ustedes sobre este, y otros, addons que van agregando a los demas sitios?

Por el momento la pagina contiene 8 cursos:

• Getting yo Know You
• Confirm or Deny
• Variables
• Letters n’ String
• Editor and Arrays
• What if?
• Bringing it UP (and Down)
• While You Wait

Cambien da la posibilidad de Crear una lección, para ello tenes que enviarles un mail.

Este sitio es bastante util para los que quieren aprender a programar cosas básicas con javascript, obviamente les va a faltar mucho camino por delante, pero es un comienzo.

Link al sitio -> http://www.codecademy.com/

Saludos!

Funciones definidas por el usuario

Simplemente son las funciones que nosotros vamos a ir definiendo,  cualquier código PHP valido puede ser incluido dentro de la función, hasta podemos incluir otra funciones y definiciones de clases (el tema clases lo veremos mas adelante)

function foo($arg_1, $arg_2, /* ..., */ $arg_n='')
{
    echo "Función de ejemplo.\n";
    return $valordevuelto;
}

Las reglas para nombres de funciones son las mismas que utilizamos en las etiquetas. Comienza con una letra o guión bajo, seguido por letra, numero o guiones bajos, sin importar la cantidad. Se puede validar con la siguiente expresión regular [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

A diferencia de otros lenguajes, en PHP no se necesita definir la función antes de que se haga referencia, excepto que dicha función esta condicionada, acá un ejemplo.

$haceralgo = true;

/* No podemos llamar a foo() desde aquí
   ya que no existe aún,
   pero podemos llamar a bar() */

bar();

if ($haceralgo) {
  function foo()
  {
    echo "No existo hasta que la ejecución del programa llegue hasta mí.\n";
  }
}

/* Ahora podemos llamar de forma segura a foo()
   ya que $haceralgo se evaluó como verdadero */

if ($haceralgo) foo();

function bar()
{
  echo "Existo desde el momento inmediato que comenzó el programa.\n";
}

No existe sobrecarga de funciones, tampoco se puede “desdefinir” ni predefinir una función previamente declarada.

También se puede llamar a funciones recursivas, acá un ejemplo:

function recursividad($a)
{
    if ($a < 20) {
        echo "$a\n";
        recursividad($a + 1);
    }
}

Mas información -> Link

Argumentos de funciones

Se le pueden pasar argumentos a las funciones, estos son pasados por una lista separados por coma, se les pueden enviar por valor (por defecto), por referencia y valores predeterminados.

Ejemplo enviado por valor: Al pasar los argumentos por valor, si dicho argumento cambia de valor dentro de la función, no sera cambiado fuera de la función.

function tomar_matriz($entrada)
{
    echo "$entrada[0] + $entrada[1] = ", $entrada[0]+$entrada[1];
}

Ejemplo enviado por referencia: Al pasar un argumento por referencia, si dicho argumento cambia de valor dentro de la función, al salir de la misma la variable contendrá el nuevo valor obtenido dentro de la función.

function añadir_algo(&$cadena)
{
    $cadena .= 'y algo más.';
}
$cad = 'Esto es una cadena, ';
añadir_algo($cad);
echo $cad;    // imprime 'Esto es una cadena, y algo más.'

Ejemplo valores predeterminados: Los argumentos predeterminados, serán usados si es que dicho argumento no es pasado a la función.

function hacercafé($tipo = "capuchino")
{
    return "Hacer una taza de $tipo.\n";
}
echo hacercafé();
echo hacercafé(null);
echo hacercafé("espresso");

Los valores predeterminados, NO puede ser una variable,  un miembro de una clase, o una llamada a una función. Ademas, los argumentos con valores predeterminados deberán estar a la derecha de TODOS los argumentos con valores no predeterminados.

Mas información -> Link

Retorno de Valores

Las funciones pueden devolver valores, para lograr esto debemos usar la sentencia return, esto causa la interrupción inmediatamente de dicha la función

Ejemplo:

function cuadrado($núm)
{
    return $núm * $núm;
}
echo cuadrado(4);   // imprime '16'.

Mas información -> Link

Funciones Variables

PHP soporta las  funciones variables. Si una variable tiene paréntesis anexos a él, PHP buscará una función con el mismo nombre e intentará ejecutarla. Las funciones variables se puede usar para implementar llamadas de retorno, tablas de funciones, etc.

function foo() {
    echo "En foo()
\n";
}

function bar($arg = '')
{
    echo "En bar(); el argumento era '$arg'.
\n";
}

// Esta es una función de envoltura alrededor de echo
function hacerecho($cadena)
{
    echo $cadena;
}

$func = 'foo';
$func();        // Esto llama a foo()

$func = 'bar';
$func('prueba');  // Esto llama a bar()

$func = 'hacerecho';
$func('prueba');  // Esto llama a hacerecho()

Mas información -> Link

Funciones Internas -> Link

Funciones Anónimas

Estas funciones, también conocidas como closures,  nos permiten crear funciones que no poseen un nombre especificado. Dichas funciones son útiles como valores de los parámetros de llamadas de retorno, entre otras cosas.

Ejemplo:

echo preg_replace_callback('~-([a-z])~', function ($coincidencia) {
    return strtoupper($coincidencia[1]);
}, 'hola-mundo');
// imprime holaMundo

Dichas funciones tambien se pueden utilizar como valores de una variable, PHP convierte dichas expresiones en instancias de la clase interna.

Ejemplo:

$saludo = function($nombre)
{
    printf("Hola %s\r\n", $nombre);
};

$saludo('Mundo');
$saludo('PHP');

Las funciones anónimas, también pueden heredar variables de una clase padre.

Las funciones anónimas están disponibles a partir de PHP 5.3.0

Ejemplo:

class Carro
{
    const PRECIO_MANTEQUILLA = 1.00;
    const PRECIO_LECHE       = 3.00;
    const PRECIO_HUEVOS      = 6.95;

    protected $productos = array();

    public function añadir($producto, $cantidad)
    {
        $this->productos[$producto] = $cantidad;
    }

    public function obtenerCantidad($producto)
    {
        return isset($this->productos[$producto]) ? $this->productos[$producto] :
               FALSE;
    }

    public function obtenerTotal($impuesto)
    {
        $total = 0.00;

        $llamadaDeRetorno =
            function ($cantidad, $producto) use ($impuesto, &$total)
            {
                $precioUnidad = constant(__CLASS__ . "::PRECIO_" .
                    strtoupper($producto));
                $total += ($precioUnidad * $cantidad) * ($impuesto + 1.0);
            };

        array_walk($this->productos, $llamadaDeRetorno);
        return round($total, 2);
    }
}

$mi_carro = new Carro;

// Añadir algunos artículos al carro
$mi_carro->añadir('mantequilla', 1);
$mi_carro->añadir('leche', 3);
$mi_carro->añadir('huevos', 6);

// Imprimir el total con un impuesto de venta del 5%.
print $mi_carro->obtenerTotal(0.05) . "\n";
// El resultado es 54.29
?>

Mas información -> Link

Espero que les sea útil este pos explicando todo sobre las funciones en PHP.

Saludos! Y espero sus comentarios!

Una constante es un identificador (nombre) para expresar un valor simple. Como el nombre sugiere, este valor no puede variar durante la ejecucción del script. Una constante es sensible a mayúsculas por defecto. Por convención, los identificadores de contantes siempre suelen declararse en mayúsculas.

El nombre de una constante sigue las mismas reglas que cualquier otra etiqueta de PHP. Un nombre de constante válido empieza por una letra o subguión, seguido por cualquier número o letras, números o subguiones. Usando una regular expression, se representaría de la siguiente manera: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*

Ejemplos de uso y nomenclaturas:

// Nombre de constantes correctos
define("FOO",     "something");
define("FOO2",    "something else");
define("FOO_BAR", "something more");

// Nombres de constantes incorrectos
define("2FOO",    "something");

// Esto es válido, pero debería ser evitado:
// Ya que quizá algún día PHP crea una constante mágica
// con el mismo nombre y en ese caso provocaría un error en tu script
define("__FOO__", "something");

Igual que las superglobals, el acceso a una constante es global. Se puede acceder a constantes desde cualquier sitio del script sin importar desde donde. Para más información en el acceso, lea el manual en la sección acceso a variables.

Sintaxis – Link

Se puede definir una constante usando la función define() o también declarándola fuera de la clase con const desde PHP 5.3.0. Una vez que la constante está definida, no puede ser cambiada o redifinida en ningún momento.

Solo se puede definir como constantes valores escalares (boolean, integer, float y string). Se puede definir resource en constantes, pero debería ser evitado, porque puede causar resultados inesperados. Para ver los diferentes tipos de datos entra al post de PHP – Tipo de Datos.

Para obtener el valor de una constante solo es necesarios especificar su nombre. A diferencia de las variables, no se debe prefijar una constante con el signo $. También se puede usar la función constant()para leer el valor de una constante si se desea obtener el valor de una constante de forma dinámica. Use get_defined_constants() para obtener una lista de todas las constantes definidas.

Nota: Las contantes y las variables (globales) se encuentran en un espacio de nombres distinto. Esto implica que por ejemplo TRUE y $TRUE son diferentes.

Si se usa una constante que todavía no está definida, PHP asume que se está refiriendo al nombre de la constante en si, igual que si fuera una string (CONSTANT vs “CONSTANT”). Cuando esto suceda, se mostrará un error de nivel E_NOTICE. Ver también la sección en el manual de porqué $foo[bar] es incorrecto (a no ser que primero define() bar como constante). Si simplemente quiere comprobar si una constante está definida, use la función defined().

Estas son las diferencias entre constantes y variables:

• Las constantes no llevan el signo dólar ($), como prefijo.
• Las constantes solo pueden ser definidas usando la función define(), y no por simple asignación.
• Las constantes pueden ser definidas y accedidas desde cualquier sitio sin importar las reglas de acceso de variables.
• Las constantes no pueden ser redefinidas o eliminadas una vez se han definido. Y
• Las constantes solo deberían contener valores escalares.

Defino una constante:

define("CONSTANT", "Hola mundo.");
echo CONSTANT; // muestra "Hola mundo."
echo Constant; // muestra "Constant" y provoca un error.

Definiendo constantes usando el keyword const:

// Funciona desde PHP 5.3.0
const CONSTANT = 'Hola Mundo';

echo CONSTANT;

Nota: A diferencia de definir constantes usando define(), las constantes definidas con la palabra clave const deben declararse en el nivel superior del entorno de la aplicación porque se definen en tiempo de ejecución. Esto significa que no pueden declararse dentro de funciones, loops o declaraciones if.

Constantes predefinidas – Link

PHP ofrece un largo número de constantes predefinidas a cualquier script en ejecución. Muchas de estas constantes, sin embargo, son creadas por diferentes extensiones, y sólo estarán presentes si dichas extensiones están disponibles, bien por carga dinámica o porque han sido compiladas.

Hay siete constantes predefinidas que cambian dependiendo de donde son usadas. Por ejemplo el valor de __LINE__ depende en la línea que se use en el script. Estas constantes especiales son sensibles a mayúsculas y son las siguientes:

Listado con todas las Constantes Reservadas – Link

Pronto seguiré con mas temas!

declare

El constructor declare es usado para fijar directivas de ejecución para un bloque de código. La sintaxis de declare es similar a la sintaxis de otros constructores de control de flujo:

declare (directive)
statement

La sección directive permite que el comportamiento de declare sea configurado. Actualmente, sólo dos directivas están reconocidas: ticks (Ver abajo para más información sobre la directiva ticks) y encoding (Ver abajo para más información sobre la directiva encoding).

La parte statement del bloque declare será ejecutada – como se ejecuta y que efectos secundarios ocurran durante la ejecución puede depender de la directiva fijada en el bloque directive.

El constructor declare también se puede utilizar en el alcance global, afectando a todo el código que le sigue (sin embargo, si el archivo con el declare fue incluido entonces no afectará al archivo padre).

// estos son lo mismo:

// se puede usar ésto:
declare(ticks=1) {
    // script entero aquí
}

// o se puede usar ésto:
declare(ticks=1);
// script entero aquí

Ticks

Un tick es un evento que ocurre para cada sentencia tickable N de bajo nivel ejecutada por el intérprete dentro del bloque declare. El valor para N se especifica usando ticks=N dentro del bloque de declare de la sección directive.

No todas las sentencias son tickable. Por lo general, expresiones de condición y expresiones de argumento no son tickables.

Los eventos que ocurren en cada tick se especifican mediante la register_tick_function(). Ver el ejemplo abajo para más detalles. Tener en cuenta que más de un evento puede ocurrir por cada tick.

declare(ticks=1);

// Una función llamada en cada evento tick
function tick_handler()
{
    echo "tick_handler() llamado\n";
}

register_tick_function('tick_handler');

$a = 1;

if ($a > 0) {
    $a += 2;
    print($a);
}

encoding

Una codificación de script puede ser especificada para cada script usando la directiva encoding.

declare(encoding='ISO-8859-1');
// código aquí

Mas información -> Link

return

Si se llama desde una función, la sentencia return() inmediatamente termina la ejecución de la función actual, y retorna su argumento como el valor de la llamada a la función. return() también pondrá fin a la ejecución de una sentencia eval() o a un archivo de script.

Si se llama desde el ámbito global, entonces la ejecución del script actual se termina. Si el archivo script actual fue incluido con include() o require(), entonces el control es pasado de regreso al archivo que hizo el llamado. Además, si el archivo script actual fue incluido, entonces el valor dado a return() será retornado como el valor de la llamada include(). Si return() es llamado desde dentro del archivo script principal, entonces termina la ejecución del script. Si el archivo script actual fue nombrado por las opciones de configuración auto_prepend_file o auto_append_file en php.ini, entonces se termina la ejecución de ese archivo script.

Mas información -> Link

include & include_once

La sentencia include() incluye y evalúa el archivo especificado.

Los archivos son incluidos con base en la ruta de acceso dada o, si ninguna es dada, el include_path especificado. Si el archivo no se encuentra en el include_path, include() finalmente verificará en el propio directorio del script que hace el llamado y en el directorio de trabajo actual, antes de fallar. El constructor include() emitirá una advertencia si no puede encontrar un archivo, éste es un comportamiento diferente al de require(), el cual emitirá un error fatal..

Si una ruta es definida — ya sea absoluta (comenzando con una letra de unidad o \ en Windows o / en sistemas Unix/Linux) o relativa al directorio actual (comenzando con . o ..) — el include_path será ignorado por completo. Por ejemplo, si un nombre de archivo comienza con ../, el interprete buscará en el directorio padre para encontrar el archivo solicitado.

Cuando se incluye un archivo, el código que contiene hereda el ámbito de las variables de la línea en la cual ocurre la inclusión. Cualquier variable disponible en esa línea del archivo que hace el llamado, estará disponible en el archivo llamado, desde ese punto en adelante. Sin embargo, todas las funciones y clases definidas en el archivo incluido tienen el ámbito global.

Si la inclusión ocurre al interior de una función dentro del archivo que hace el llamado, entonces todo el código contenido en el archivo llamado se comportará como si hubiera sido definida dentro de esa función. Por lo tanto, seguirá el ámbito de las variables de esa función. Una excepción a esta regla son las constantes mágicas las cuales son evaluadas por el intérprete antes que ocurra la inclusión.

La sentencia include_once() incluye y evalúa el fichero especificado durante la ejecución del script. Es un comportamiento similar al de la sentencia include(), siendo la única diferencia que si el código del fichero ya ha sido incluido, no se volverá a incluir. Como su nombre lo indica, será incluido sólo una vez.

include_once() puede ser usado en casos donde el mismo fichero podría ser incluido y evaluado más de una vez durante una ejecución particular de un script, así que en este caso, puede ayudar a evitar problemas como la redefinición de funciones, reasignación de valores de variables, etc.

Mas información include -> Link
Mas información include_once-> Link

require & require_once

require() es idéntico a include() excepto que en caso de fallo, además producirá un error de nivel E_COMPILE_ERROR fatal. En otras palabras, parará el script mientras que include() sólo emitirá una advertencia (E_WARNING) lo cual permite continuar el script.

La sentencia require_once() es idéntica a require() excepto que PHP verificará si el archivo ya ha sido incluido y si es así, no se incluye (require) de nuevo.

Mas información require -> Link
Mas información require_once -> Link

goto

El operador goto puede ser usado para saltar a otra sección en el programa. El punto de destino es especificado mediante una etiqueta seguida de dos puntos y la instrucción es dada como goto seguida de la etiqueta del destino deseado. Este goto no es completamente sin restricciones. La etiqueta de destino debe estar dentro del mismo fichero y contexto, lo que significa que no se puede saltar fuera de una función o método, ni se puede saltar dentro de uno. Tampoco se puede saltar dentro de cualquier clase de estructura de bucle o switch. Se puede saltar fuera de estos y un uso común es utilizar un goto en lugar de un break multi-nivel.

Ejemplo:

goto a;
echo 'Foo';

a:
echo 'Bar';

Ejemplo dentro de un bucle:

for($i=0,$j=50; $i<100; $i++) {
  while($j--) {
    if($j==17) goto end;
  }
}
echo "i = $i";
end:
echo 'j alcanzó 17';

Mas información -> Link

Exit & Die

exit — Imprime un mensaje y termina el script actual, se le puede pasar un string como parámetro para que lo imprima en pantalla.

die — Equivalente a exit()

Mas información Exit -> Link
Mas información Die -> Link

echo, print, printf, print_r & var_dump

echo — Muestra una o más cadenas
print — Mostrar una cadena
printf — Imprimir una cadena con formato
print_r — Imprime información legible para humanos sobre una variable
var_dump — Vuelca información sobre una variable

Mas información echo -> Link
Mas información print -> Link
Mas información printf -> Link
Mas información print_r -> Link
Mas información var_dump -> Link

empty, eval, isset, unset & list

empty — Determina si una variable está vacía
eval — Evaluar una cadena como código PHP
isset — Determina si una variable está definida y no es NULL
unset — Destruye una variable especificada
list — Asigna variables como si fuera un array

Mas información empty -> Link
Mas información eval -> Link
Mas información isset -> Link
Mas información unset -> Link
Mas información list -> Link

Existen muchas funciones mas útiles que podemos llegar a utilizar y que nos sean útil, acá les dejo los links para que puedan investigar y utilizar las que mas les sea útil.

Funciones de strings - Link
Funciones de manejo de variables - Link
Funciones de Arrays - Link
Funciones del Intérprete XML - Link
Funciones de Manejo de Funciones - Link
Funciones varias - Link

Ya iré agregando mas links, son varios!

Espero que les interese estos resúmenes.

Saludos y espero sus criticas!

While

Los bucles while son el tipo más sencillo de bucle en PHP. Se comportan igual que su contrapartida en C. La forma básica de una sentencia while es:

while (expr)
       sentencia

El significado de una sentencia while es simple. Le dice a PHP que ejecute las sentencias anidadas, tanto como la expresión while se evalúe como TRUE. El valor de la expresión es verificado cada vez al inicio del bucle, por lo que incluso si este valor cambia durante la ejecución de las sentencias anidadas, la ejecución no se detendrá hasta el final de la iteración (cada vez que PHP ejecuta las sentencias contenidas en el bucle es una iteración). A veces, si la expresión while se evalúa como FALSE desde el principio, las sentencias anidadas no se ejecutarán ni siquiera una vez.

/* ejemplo 1 */
$i = 1;
while ($i <= 10) {
    echo $i++;  /* el valor presentado sería
                   $i antes del incremento
                   (post-incremento) */
}

Sintaxis alternativa

/* ejemplo 2 */
$i = 1;
while ($i <= 10):
    echo $i;
    $i++;
endwhile;

Mas información -> Link

Do-While

Los bucles do-while son muy similares a los bucles while, excepto que la expresión verdadera es verificada al final de cada iteración en lugar que al principio. La diferencia principal con los bucles while es que está garantizado que corra la primera iteración de un bucle do-while (la expresión verdadera sólo es verificada al final de la iteración), mientras que no necesariamente va a correr con un bucle while regular (la expresión verdadera es verificada al principio de cada iteración, si se evalúa como FALSE justo desde el comienzo, la ejecución del bucle terminaría inmediatamente).

Hay una sola sintaxis para bucles do-while:

$i = 0;
do {
    echo $i;
} while ($i > 0);

El bucle de arriba se ejecutaría exactamente una sola vez, ya que después de la primera iteración, cuando la expresión verdadera es verificada, se evalúa como FALSE ($i no es mayor que 0) y termina la ejecución del bucle.

Mas información -> Link

For

Los bucles for son los ciclos más complejos en PHP. Se comportan como sus contrapartes en C. La sintaxis de un bucle for es:

for (expr1; expr2; expr3)
sentencia

La primera expresión (expr1) es evaluada (ejecutada) una vez incondicionalmente al comienzo del bucle.

En el comienzo de cada iteración, la expr2 es evaluada, Si es TRUE, el blucle continúa y las sentencias anidadas son ejecutadas. Si se evalúa como FALSE, termina la ejecución del bucle.

Al final de cada iteración, la expr3 es evaluada (ejecutada).

Cada una de las expresiones puede esta vacía o contener múltiples expresiones separadas por comas. En la expr2, todas las expresiones separadas por una coma son evaluadas pero el resultado se toma de la última parte. Que la expr2 esté vacía significa que el bucle deberá ser corrido indefinidamente (PHP implícitamente lo considera como TRUE, como en C). Esto puede no ser tan inútil como se pudiera pensar, ya que muchas veces se quiere terminar el bucle usando una sentencia condicional break en lugar de ustilizar la expresión verdadera del for.

Considere los siguientes ejemplos. Todos ellos muestran los números del 1 al 10:

//Ejemplo 1
for ($i = 1; $i <= 10; $i++) {
    echo $i;
}

Sintaxis Alternativa

for ($i = 1; $i <= 10; $i++) :
    echo $i;
endfor;

Mas información -> Link

Foreach

PHP 4 introdujo un constructor foreach, muy parecido al de Perl y algunos otros lenguajes. Simplemente da un modo fácil de iterar sobre arrays. Foreach sólo trabaja sólo sobre arrays y resultará en un error al intentar usarlo en una variable con un diferente tipo de datos o una variable no inicializada. Hay dos sintaxis; la segunda es una extensión menor, pero útil de la primera:

foreach (array_expression as $value)
sentencias
foreach (array_expression as $key => $value)
sentencias

La primera forma recorre el array dado por array_expression. En cada ciclo, el valor de el elemento actual es asignado a $value y el puntero interno del array es avanzado en uno (así en el próximo ciclo se estará mirando el siguiente elemento).

La segunda manera hace lo mismo, excepto que la clave del elemento actual será asignada a la variable $key en cada ciclo.

$a = array(1,2,3,4,5);
foreach ($a as $value){
    echo $value
}

Sintaxis alternativa

$a = array(1,2,3,4,5);
foreach ($a as $value):
    echo $value
endforeach;

A partir de PHP 5, se pueden modificar fácilmente elementos del array al preceder $value con &. Esto asignará una referencia en lugar de copiar el valor.

$arr = array(1, 2, 3, 4);
foreach ($arr as &$value) {
    $value = $value * 2;
}

Mas información -> Link

Break

Break termina la ejecución de la estructura actual for, foreach, while, do-while o switch.

Break acepta un argumento numérico opcional el cual indica de cuantas estructuras anidadas encerradas se debe salir.

$arr = array('uno', 'dos', 'tres', 'cuatro', 'pare', 'cinco');
while (list(, $val) = each($arr)) {
    if ($val == 'pare') {
        break;    /* Se puede también escribir 'break 1;' aquí. */
    }
    echo "$val\n";
}

/* Usando el argumento opcional. */

$i = 0;
while (++$i) {
    switch ($i) {
    case 5:
        echo "En 5\n";
        break 1;  /* Sólo sale del switch. */
    case 10:
        echo "En 10; saliendo\n";
        break 2;  /* Sale del switch y del while. */
    default:
        break;
    }
}

Mas información -> Link

Continue

Continue se utiliza dentro de las estructuras de bucle para saltarse el resto de la actual iteración del bucle y continuar la ejecución en la evaluación de la condición y entonces el comienzo de la siguiente iteración.

Continue acepta un argumento numérico opcional el cual indica hasta el final de cuantos niveles de bucles cerrados se debe saltar.

while (list($key, $value) = each($arr)) {
    if (!($key % 2)) { // saltar miembros impares
        continue;
    }
    do_something_odd($value);
}

$i = 0;
while ($i++ < 5) {
    echo "Outer\n";
    while (1) {
        echo "Middle\n";
        while (1) {
            echo "Inner\n";
            continue 3;
        }
        echo "This never gets output.\n";
    }
    echo "Neither does this.\n";
}

Mas información -> Link

Pronto seguiremos con mas resumenes de PHP!

IF

El constructor IF, es uno de los mas importantes en casi todos los lenguajes de programación, el constructor evalúa una expresión dada, si dicha expresión devuelve TRUE, PHP ejecutara la sentencia que se encuentra dentro del IF, caso contrario se ignorara.

La estructura del IF es similar a:

if ({expresión}){

{sentencia}

}

Ejemplo:

if ($a == $b){
      echo 'La variable a es igual a la variable b';
}

Mas información -> Link

ELSE

Con frecuencia se desea ejecutar una sentencia si una cierta condición se cumple y una sentencia diferente si la condición no se cumple. Esto es para lo que es else. El else extiende una sentencia if para ejecutar una sentencia en caso que la expresión e la sentencia if se evalúa como FALSE. Por ejemplo, el siguiente código deberá mostrar a es mayor que b si $a es mayor que $b y a NO es mayor que b en el caso contrario:

if ($a > $b) {
  echo "a es mayor que b";
} else {
  echo "a NO es mayor que b";
}

Mas información -> Link

ELSE IF

elseif, como su nombre lo sugiere, es una combinación de if y else. Del mismo modo que else, extiende una sentencia if para ejecutar una sentencia diferente en caso que la expresión if original se evalúe como FALSE. Sin embargo, a diferencia de else, esa expresión alternativa sólo se ejecutará si la expresión condicional del elseif se evalúa como TRUE. Por ejemplo, el siguiente código debe mostrar a es mayor que b, a es igual que b o a es menor que b:

if ($a > $b) {
    echo "a es mayor que b";
} elseif ($a == $b) {
    echo "a es igual que b";
} else {
    echo "a es menor que b";
}

Mas información -> Link

Sintaxis alternativa:

if ($a == 5):
    echo "a igual 5";
    echo "...";
elseif ($a == 6):
    echo "a igual 6";
    echo "!!!";
else:
    echo "a no es 5 ni 6";
endif;

Mas información -> Link

SWITCH

La sentencia switch es similar a una serie de sentencias IF en la misma expresión. En muchas ocasiones, es posible que se quiera comparar la misma variable (o expresión) con muchos valores diferentes, y ejecutar una parte de código distinta dependiendo de a que valor es igual. Para esto es exactamente la expresión switch.

switch ($i) {
    case 0:
        echo "i es igual a 0";
        break;
    case 1:
        echo "i es igual a 1";
        break;
    case 2:
        echo "i es igual a 2";
        break;
}

Sintaxis Alternativa

switch ($i):
    case 0:
        echo "i es igual a 0";
        break;
    case 1:
        echo "i es igual a 1";
        break;
    case 2:
        echo "i es igual a 2";
        break;
    default:
        echo "i no es igual a 0, 1 ni 2";
endswitch;

Mas información -> Link

Espero que les sirva, el próximo post sera dedicado a las estructuras de control de Loops

Existen varios tipos de operadores en PHP, hará un listado y luego explicaré brevemente cada uno de ellos.

• Operadores aritméticos
• Operadores de asignación
• Operadores bit a bit
• Operadores de comparación
• Operadores de control de errores
• Operadores de ejecución
• Operadores de incremento/decremento
• Operadores lógicos
• Operadores para strings
• Operadores para arrays
• Operadores de tipo

Operadores aritméticos

Son, simplemente, las operaciones aritméticas que uno aprendió en el colegio primario.

Mas información -> link

Operadores de asignación

El operador de asignación es el signo = (igual), el cual se encarga de definir el valor de lo que se encuentra a la derecha a lo que esta a la izquierda, siempre y cuando tenga sentido!

$a = 2; //Defino la variable $a con el valor 2

$b = &$a; // Hago una referencia a $b de $a

Mas información -> link

Operadores bit a bit

Los operadores bit a bit permiten la evaluación y la manipulación de bits específicos dentro de un integer.

Hay unos ejemplos muy buenos en la pagina oficial de PHP, para entender 100% cómo funcionan los operadores bit a bit

Mas información -> link

Operadores de comparación

Son los operadores que nos dejan comparar dos valores.

Mas información -> link

Operadores de control de errores

PHP soporta un operador de control de errores: el signo de arroba (@). Cuando se antepone a una expresión en PHP, cualquier mensaje de error que pueden ser generado por esa expresión será ignorado.

Mas información -> link

Operadores de ejecución

PHP soporta un operador de ejecución: las comillas invertidas (“). ¡Note que estas no son las comillas sencillas! PHP intentará ejecutar el contenido entre las comillas invertidas como si se tratara de un comando del shell; la salida será retornada (es decir, no será simplemente volcada como salida; puede ser asignada a una variable). El uso del operador de comillas invertidas es idéntico al de shell_exec().

Mas información -> link

Operadores de incremento/decremento

PHP posee operadores pre y post incremento y decremento.

Mas información -> link

Operadores lógicos

Mas información -> link

Operadores para strings

Existen dos operadores para datos tipo string. El primero es el operador de concatenación (‘.’), el cual retorna el resultado de concatenar sus argumentos derecho e izquierdo. El segundo es el operador de asignación sobre concatenación (‘.=’), el cual añade el argumento del lado derecho al argumento en el lado izquierdo. Por favor consulte Operadores de asignación para más información.

Mas información -> link

Operadores para arrays

Mas información -> link

Operadores de tipo

instanceof se utiliza para determinar si una variable de PHP es un objeto instanciado de una cierta clase

Mas información -> link

Espero que les sea útil, y cualquier cosa me consultan. Por lo menos a mi me es útil para refrescar conocimientos, aprender pequeños detalles que uno no había prestado atención con anterioridad, en fin… Empecemos!

• Tipos Escalares:
• Boolean – Link
• El boolean expresa un valor de verdad, puede ser TRUE o FALSE
• Integer – Link
• Un entero o integer es un número del conjunto Z = {…, -2, -1, 0, 1, 2, …}. Pueden ser especificados en notación decimal (base 10), hexadecimal (base 16) u octal (base 8).
• Float – Link
• Los números de punto flotante (también conocidos como “flotantes”, “dobles” o “números reales”) pueden ser especificados usando cualquiera de las siguientes sintaxis: $a = 1.234;  $b = 1.2e3;  $c = 7E-10;
• String - Link
• Un string es una serie de caracteres, y por lo tanto, un caracter es lo mismo que un byte. Es decir, hay exactamente 256 diferentes caracteres posibles. Esto implica tambien que PHP no tiene soporte nativo para Unicode. Consulte utf8_encode() y utf8_decode() para informarse de la funcionalidad básica de Unicode.
• Sintaxis, un string puede especificase de cuatro formas diferente.
• Comillas Simples
• echo ’Esto es una cadena sencilla’;
• Comillas Dobles – Si un string está encerrado entre comillas dobles (“), PHP interpretará más sentencias de escape como caracteres especiales:
• echo ”Esto es una $test”;
• Sintaxis Heredoc - Una tercera forma de delimitar strings es mediante la sintaxis heredoc: <<<. Después de este operador, se deberá ofrecer un identificador y después una nueva línea. A continuación va el propio string, y para cerrar la notación se pone el mismo identificador.
• $str = <<<EOD
  Ejemplo de una cadena
  expandida en varias líneas
  empleando la sintaxis heredoc.
  EOD;
• Sintaxis Nowdoc - Nowdocs son a las cadenas con comillas simples lo mismo que Heredoc lo es a las comillas dobles. Una cadena nowdoc se especifica de forma análoga a la heredoc, pero no se realiza ningún análisis dentro de nowdoc. Esta construcción es ideal para embeber codigo PHP o grandes fragmentos de texto sin necesidad de escaparlo. Comparte algunas características comunes con la construcción SGML <![CDATA[ ]]>, donde se declara un fragmento de texto que no debe ser analizado.
• $str = <<<’EOD’
  Ejemplo de una cadena
  expandida en varias líneas
  empleando la sintaxis nowdoc.
  EOD;

• Tipos Compuestos:
• Array – Link
  • Un array (matriz) en PHP es en realidad un mapa ordenado. Un mapa es un tipo de datos que asocia valores con claves. Este tipo es optimizado para varios usos diferentes; puede ser usado como una matriz real, una lista (vector), tabla asociativa (caso particular de implementación de un mapa), diccionario, colección, pila, cola y probablemente más. Ya que los valores de un array pueden ser otros arrays, también es posible crear árboles y arrays multidimensionales.
  • Sintaxis Asignación:
  • $arr = array(“foo” => ”bar”, 12 => true);
  • $arr["foo"] = “bar”;
  • $arr[] = “bar”;
  • Sintaxis print:
  • echo $arr["foo"];
  • print_r($arr);
  • var_dump($arr);
• Object – Link
• Nota: Este es un tema bastante complejo, por lo tanto sera tratado en otro post, cuando sea creado se agregara el link acá!
• Inicialización:
• Para crear un nuevo object, utilice la declaración new para instanciar una clase.

• Tipos Especiales:
• Resource - Link
• Un valor tipo resource es una variable especial, que contiene una referencia a un recurso externo. Los recursos son creados y usados por funciones especiales. Vea el apéndice para un listado de todas estas funciones y los tipos resource correspondientes.
• Conversión a recurso:
• Dado que las variables resource contienen gestores especiales a archivos abiertos, conexiones con bases de datos, áreas de pintura de imágenes y cosas por el estilo, la conversión a tiporesource carece de sentido
• Liberación de recursos:
• Gracias al sistema de conteo de referencias introducido con el Motor Zend de PHP 4, un recurso que ya no es referenciado es detectado automáticamente, y es liberado por el recolector de basura. Por esta razón, rara vez se necesita liberar la memoria manualmente.
• NULL - Link
• El valor especial NULL representa una variable sin valor. NULL es el unico posible valor de tipo NULL.
• Una variable es considerada null si:
• Se le ha asignado la constante NULL.
• No se ha establecido en un valor todavía.
• Se ha unset().

• Y también, por razones de legalidad, existen los pseudo-tipos:
• Mixed- Link
• Mixed indica que un parámetro puede aceptar múltiples tipos (pero no necesariamente todos).
• Number- Link
• Number indica que un parámetro puede ser tanto un integer como un float.
• Callback- Link
• Algunas funciones como call_user_func() o usort() pueden aceptar como parámetro funciones de devolución de llamada definidas por el usuario. Las funciones de devolución de llamada no sólo pueden ser funciones simples, sino también pueden ser métodos object, incluyendo métodos de clases estáticas.
• Una función de PHP puede ser pasada por su nombre como un string. Cualquier función incorporada o definida por el usuario puede ser usada, excepto los constructores de lenguaje como:array(), echo(), empty(), eval(), exit(), isset(), list(), print() o unset().
• Un método de un object instanciado puede ser pasado como un array conteniendo un object en el índice 1 y el nombre del método en el índice 1.
• Los métodos de clases estáticas también pueden ser pasdos sin instanciar un object de la clase pasando en el índice 0 el nombre de la clase en lugar del object.
• Junto a las típicas funciones definidas por el usuario, tambien se puede usar create_function() para crear una función de devolución de llamada anónima. Desde PHP 5.3.0 también es posible pasar un cierre como un parámetro de devolución.
• Void- Link
• void como un tipo de variable de retorno significa que el valor de retorno no es útil. void en una lista de parámetros significa que la función no acepta ningún parámetro.
• $… en el prototipo de funciones significa and so on. Este nombre de variable se usa cuando una función puede tomar un número infinito de argumentos.

Los tipos de una variable usualmente no son declaradas por el programador, es decidido en tiempo de ejecución por PHP dependiendo del contexto en el que se este utilizando la variable.

Espero que les sea util! y espero sus comentarios al respecto…

Bueno sin mas vueltas vamos a empezar con el tema que comente el post, Sintaxis Básicas, lo cual podemos separarlos en 3 temas principales; Tags,  Puntuación y Comentarios.

Tags:

Cuando PHP interpreta un archivo, el cual, por lo general contiene extensión PHP, busca tags de apertura y de fin, el cual se encarga de avisarle al interpretador donde comienza el código y donde finaliza. Esto nos permite tener código que sera “ignorado” por el interpretador. Esto nos puede llegar a ser útil para poder incluir código HTML, Javascript, CSS, entre otros a nuestro archivo.

Etiqueta de apertura y de fin en un archivo PHP:

Observe también que si se está incrustando PHP con XML o XHTML necesitará usar las etiquetas <?php ?> para seguir los estándares.

Example #2 Etiquetas de apertura y de fin de bloque de PHP
1. <?php echo ‘si se quiere mostrar documentos XHTML o XML, debe hacerse así’; ?>

2. <script language=”php”>
echo ‘algunos editores (como FrontPage) no les gusta
las instruciones de proceso’;
</script>

3. <? echo ‘esta es la forma más simple, una instrución de procesado SGML’; ?>
<?= expression ?> Esto es una forma corta para “<? echo expression ?>”

4. <% echo ‘Quizá use de forma opcional etiquetas de estilo ASP’; %>
<%= $variable; # Esto es una forma corta para “<% echo . . .” %>

Mas información -> link

Puntuación:

PHP requiere que las instrucciones terminen con un punto y coma al final de cada declaración.

echo 'Esto es una prueba';

Mas información -> link

Comentarios:

Los comentarios soportados por PHP, son los siguientes!

// Esto es un comentario estilo c++ de una sola línea

# Esto es un comentario estilo consola de una sola línea

/* Esto es un comentario multi-línea
       si! otra línea de comentarios */

Mas información -> link

Esta función es muy útil para enviar templates de mails en Zend Framework, utilizando Zend View y Zend Mail, pueden ser archivos con texto plano, archivos HTML, o archivos con HTML y PHP! Tan solo tienen q hacer lo siguiente..

1) Tienen que agregar al archivo de configuración las siguientes lineas:

settings.email = "service@sparkboxtoys.com"
settings.template.dir = APPLICATION_PATH "/theme/mail_template/"

en “settings.template.dir” pongan el directorio donde estarán puestos los mail’s template.

La extensión de los mismos pueden ser:

• TXT si van a ser textos planos.
• PHTML si van a ser mails con html y/o php (para enviarles paramentos)

2) Dentro de la carpeta library crear los directorios y archivo correspondientes (tener en cuenta las mayúsculas)

/App/Mail/Template.php

3) Dentro del archivo Template.php copiar el siguiente código:

/**
 * A template based email system
 *
 * Supports the sending of multipart txt/html emails based on templates
 *
 */
class App_Mail_Template
{

    /**
     * Variable registry for template values
     */
    protected $templateVariables = array();

    /**
     * Template name
     */
    protected $templateName;

    /**
     * Zend_Mail instance
     */
    protected $zendMail;

    /**
     * Email recipient
     */
    protected $recipient;

    /**
     * Email subject
     */
    protected $subject;

    /**
     * __construct
     *
     * Set default options
     *
     */
    public function __construct ()
    {
        $this->zendMail = new Zend_Mail();
    }

    /**
     * Set variables for use in the templates
     *
     * Magic function stores the value put in any variable in this class for
     * use later when creating the template
     *
     * @param string $name  The name of the variable to be stored
     * @param mixed  $value The value of the variable
     */
    public function __set ($name, $value)
    {
        $this->templateVariables[$name] = $value;
    }

    public function setVariables($data)
    {
        foreach($data as $key => $value){
            $this->__set($key,$value);
        }
    }

    /**
     * Set the subject to use
     *
     * @param string $subject Subject text
     */
    public function setSubject ($subject)
    {
        $this->subject = $subject;
    }

    /**
     * Set the template file to use
     *
     * @param string $filename Template filename
     */
    public function setTemplate ($filename)
    {
        $this->templateName = $filename;
    }

    /**
     * Set the recipient address for the email message
     *
     * @param string $email Email address
     */
    public function setRecipient ($email)
    {
        $this->recipient = $email;
    }

    /**
     * Send the constructed email
     *
     * @todo Add from name
     */
    public function send ()
    {
        /*
         * Get data from config
         * - From address
         * - Directory for template files
         */
        $config = Zend_Registry::get('config');
        $templateDir = $config->settings->template->dir;
        $fromAddr = $config->settings->email;

        //Build template
        //Check that template file exists before using
        $viewConfig = array('basePath' => $templateDir);
        $subjectView = new Zend_View($viewConfig);

        foreach ($this->templateVariables as $key => $value)
        {
            $subjectView->{$key} = $value;
        }

        $textView = new Zend_View($viewConfig);
        foreach ($this->templateVariables as $key => $value)
        {
            $textView->{$key} = $value;
        }
        try {
            $text = $textView->render($this->templateName . '.txt');
        } catch (Zend_View_Exception $e) {
            $text = false;
        }

        $htmlView = new Zend_View($viewConfig);
        foreach ($this->templateVariables as $key => $value)
        {
            $htmlView->{$key} = $value;
        }

        try {
            $html = $htmlView->render($this->templateName . '.phtml');
        } catch (Zend_View_Exception $e) {
            $html = false;
        }

        //var_dump($subject);
        //var_dump($text);
        //var_dump($html);

        //Pass variables to Zend_Mail
        $mail = new Zend_Mail();
        //var_dump($fromAddr);
        $mail->setFrom($fromAddr);
        //var_dump($this->recipient);
        $mail->addTo($this->recipient);

        $mail->setSubject($this->subject);

        if ($html !== false) {
            $mail->setBodyText($text);
        }

        if ($html !== false) {
            $mail->setBodyHtml($html);
        }

        //Send email
        $mail->send();
    }

}

4) Luego en el archivo en el cual vas a enviar el mail copiar el siguiente código:

$emailObj = new App_Mail_Template;
$emailObj->setRecipient('test@avlog.com.ar');
$emailObj->setTemplate('welcome');
$dataArray = array(
    'name' => 'Pablo',
    'mail' => 'test@avlog.com.ar',
);
$emailObj->setSubject('Welcome to AgeValed!');
$emailObj->setVariables($dataArray);
$emailObj->send();

Con esto estamos enviando un mail del archivo welcome.phtml q adentro tiene los parámetros $this->name y $this->mail

Espero que les sea útil, cualquier consulta no duden en escribirme!

Presentación:

Audio:

Las sesiones ZendCon se distribuye bajo una licencia creative commons Attribution-Noncommercial-No Derivative Works 3.0, por favor cumple con esta licencia y los derechos de nuestros autores.

Espero que les resulte interesante! saludos!

Referencia: DevZone Zend

Espero que les sirva para su proyecto o para cualquier cosa que lo lleguen a utilizar.

Link de Descarga:

Dando vueltas por Internet encontré la siguiente discusión, como siempre stackoverflow, nos da una mano en todo!

Siguiendo unos simples pasos podemos solucionarlo:

1. Correr regedit.
2. Encontrar [HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit]
3. Click derecho sobre “Java Development Kit”, click Export, y guardar el archivo en el desktop.
4. Click derecho y click en edit
5. Agregar Wow6432Node al path por cada key en el archivo, ver ejemplo a continuación, y guardar.
6. Volver al regedit, click en File->Import y seleccionamos el archivo.
7. Intentar instalar nuevamente SDK.

Antes:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit]
“CurrentVersion”=”1.6″

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit\1.6]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_23″
“MicroVersion”=”0″

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit\1.6.0_21]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_21″
“MicroVersion”=”0″

[HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Development Kit\1.6.0_23]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_23″
“MicroVersion”=”0″

Despues:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\JavaSoft\Java Development Kit]
“CurrentVersion”=”1.6″

[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\JavaSoft\Java Development Kit\1.6]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_23″
“MicroVersion”=”0″

[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\JavaSoft\Java Development Kit\1.6.0_21]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_21″
“MicroVersion”=”0″

[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\JavaSoft\Java Development Kit\1.6.0_23]
“JavaHome”=”C:\\Program Files\\Java\\jdk1.6.0_23″
“MicroVersion”=”0″

Y listo ya podemos continuar! Espero q les sea util.

Historia:

Cassandra es una base de datos NoSQL, hoy en día es un proyecto de Apache. Cassandra fue desarrollado por Facebook (la versión original fue escrita por un ex empleado de Amazon y otro de Microsoft), en el 2008 fue liberado como un proyecto open source en Google code, en el 2009 se convirtió en un proyecto “Apache Incubator“, y finalmente en el 2010 se convirtió en un proyecto TOP-LEVEL.

Información:

Las la información en las bases de datos relacionales, se almacenan en forma de filas, pero en Cassandra la información se almacena en columnas con pares key-value, key-map para múltiples valores, que se agrupan en column families (familia de columnas). Las column families son fijas cunado una base de datos Cassandra es creado, pero las columns se pueden agregar a la column families en cualquier momento. Por otra parte, las columns se agregan solo a las keys especificas, por lo tanto diferentes keys pueden tener diferentes números de columns en cualquier columns family.

Cassandra puede manejar varios terabytes de datos si lo necesita y puede, fácilmente, manejar millones de files, incluso en un cluster pequeño. Cassandra puede hacer alrededor de 20k de insert por segundos.

La rendimiento de Cassandra es muy alta, y mantener ese rendimiento alto mayormente depende del hardward, la configuración y el numero de nodos en nuestro cluster.

Terminologia de Cassandra:

Column: Es la unidad mas básica de la representación en el modelo de datos Cassandra. Una column es un triplete de un key (un nombre) un value (un valor) y un timestamp. Los valores son todos suministrados por el cliente. El tipo de dato del key y el value son Matrices de bytes de Java, el tipo de dato del timestamp es un long primitive. Las column son inmutables para evitar problemas de multithreading. Las columns se organizan dentro de las columns families. Las columns se ordenan por un tipo, que pueden ser uno de los siguientes:

• AsciiType
• BytesType
• LexicalUUIDType
• LongType
• TimeUUIDType
• UTF8Type

Modelo de datos:

1. Keyspace -> Column Family
2. Column Family -> Column Family Row
3. Column Family Row -> Columns
4. Column -> Data value

Super Column: Es una column cuyos values no son strings, sino una o mas columns, que en este contexto se llamaran subcolumns. Las subcolumns están ordenadas, y el numero de columnas que se puede definir es ilimitada. las Super columns, a diferencias de las columns, no tienen un timestamp definido. No son recursivas, es decir, solamente tienen un nivel de profanidad.

Modelo de datos:

1. Keyspace -> Super Column Family
2. Super Column Family -> Super Column Family Row
3. Super Column Family Row -> Super Columns
4. Super Column -> Columns
5. Column -> Data value

Column Family: Es mas o menos análogo a una tabla en un modelo relacional. Se trata de un contenedor para una colección ordenada de columns. Debido a que cada column family se almacena en un archivo separado, asegúrese de definir las columns que sea probable que acceda juntas en la misma column family. Tenemos que definir las column family de la aplicación en el archivo de configuración.

Keyspace: Es el contenedor para un column family. Es mas o menos análogo a una base de datos en un modelo relacional, usado en Cassandra para separar aplicaciones. Cuando una base de datos relacional es una colección de tablas, un keyspace es una colección ordenada de columns family. Tenemos que definir los keyspace de la aplicación en el archivo de configuración o usando métodos definidos en la API.

Caracteristicas de Cassandra:

Fault Tolerant (Tolerancia a los fallos): Los datos se replican automáticamente a varios nodos. Perder un nodo no  causa la baja del cluster.

Flexible Schema (Flexible esquema): Estamos hablando en términos de las columns, super columns y column families en lugar de filas y tablas. Modelo de datos BigTable.

Symmetric (Simétrica): No hay único punto de fallo, todos los nodos en el cluster son idéntica y no hay cuellos de botella.

Scalable (Escalable): Lineal con la adición de nuevas máquinas, sin tiempo de inactividad o interrupción de las aplicaciones. Leer y escribir aumentar el rendimiento de forma lineal a medida que las maquinas se van agregando.

Support for Large Data (Apoyo a grandes de datos): La capacidad para escalar a cientos de gigabytes de datos.

Links de interés:

• Pagina oficial Apache Cassandra
• Apache Cassandra Wikipedia
• Getting Started Cassandra
• Articles and Presentations

Cualquier cosa que quiera aclarar sobre el articulo, preguntar, corregir o lo que tengan ganas comenten.

Saludos

Estos datos son muy útiles tanto para la programación en grupo, como cuando uno esta programando solo, tendrás información mas detallada, mas ordenada y bien separada para poder reutilizar código en un futuro o para entender lo que se hizo.

también les dejo un link muy útil estándares de programación Zend (Zend Wiki) o estándares de programación Zend (Zend Manual) .

Espero que les sea útil para sus proyectos actuales como futuros.

Ejemplo en PHP, el mas lindo va primero (si si el corazón tira para un lado)

Ejemplo en .NET C#

String patchServer = Server.MapPath("pdf/pdftk.exe");

 Process myProcess = Process.Start(patchServer, "\""+Server.MapPath("pdf/A.pdf") + "\" \"" + Server.MapPath("pdf/B.pdf")+" cat output  \"" + Server.MapPath("pdf/AB.pdf") + "\"  dont_ask");
 if (myProcess != null)
 {
      myProcess.StartInfo.CreateNoWindow = false;
      myProcess.EnableRaisingEvents = true;
      while (!myProcess.HasExited) { }
      Response.Redirect("pdf/AB.pdf");
 }

En el código lo que estamos haciendo es decirle que tome el archivo A.pdf y el archivo B.pdf, lo concatene y lo guarde en el archivo AB.pdf, el comando dont_ask sirve para decirle que si el archivo AB.pdf existe lo sobrescribe. La linea de código while (!myProcess.HasExited) { } ,en .NET, la utilizo para esperar que el proceso termine y luego redirige para que lo abra.

Noten que es mucho mas lindo PHP que .NET jeje

Tengan en cuenta que PDF Toolkit, no es solamente para concatenar, sino también se pueden utilizar para:

• Separar paginas del PDF en un nuevo documento.
• Rotar paginas del PDF o un PDF entero.
• Encrpitar y desencriptar un PDF.
• Llenar formularios PDF con datos FDF o datos XFDF.
• Poner un fondo al PDF.
• entre otras cosas.

En la pagina de PDF Toolkit pueden encontrar ejemplos de como utilizarlo con todos los comandos.

Link para la descarga! (existe versiones para Linux, Windows y MAC)

Espero que les sea útil, cualquier cosa no dejen de preguntarme!