Para ir un poco mas adelante en la construcción de un sitio web con Yii Framework nos encontramos con un tema básico en el desarrollo de cualquier sistema, la implementación de un sistema de logueo, usuarios, roles y permisos para diferentes acciones en el sistema.

Comenzando por explicar como tiene Yii configurado en su sistema base el logueo, nos encontramos con una acción en el controller “site/login” en la cual recibe la información de un formulario con usuario y contraseña.

public function actionLogin() {
$model = new LoginForm;

// if it is ajax validation request
if (isset($_POST['ajax']) && $_POST['ajax'] === 'login-form') {
 echo CActiveForm::validate($model);
 Yii::app()->end();
}

// collect user input data
if (isset($_POST['LoginForm'])) {
 $model->attributes = $_POST['LoginForm'];
 // validate user input and redirect to the previous page if valid
 if ($model->validate() && $model->login())
$this->redirect(array("perfil"));
}
// display the login form
$this->render('login', array('model' => $model));
}

Esta acción a menos que tengamos algún requerimiento muy específico no debe cambiar, ya que solo nos permite desplegar el formulario y cuando ingresa la información mandarla a validar, a donde? pues esa es una pregunta importante.

En “protected/components/UserIdentity” nos encontramos con una función llamada authenticate, que por default valida sobre un Array, que contiene los usuarios admin y demo, y que sirven en la forma más sencilla de nuestro sistema, pero que puede ser sustituida por:

public function authenticate() {
$registro = Usuario::model()->findByAttributes(array('email' => $this->username));

if ($registro === null) {
$this->errorCode = self::ERROR_USERNAME_INVALID;
} else if ($registro->password === crypt($this->password,$registro->salt)) {//
$this->setState('id_usuario', $registro->id);
$this->setState('id_rol', $registro->id_rol);
$this->errorCode = self::ERROR_NONE;
} else {
$this->errorCode = self::ERROR_PASSWORD_INVALID;
}
return !$this->errorCode;
}

El código anterior consulta nuestra base de datos buscando el usuario con el que coincida el correo que fue ingresado en el formulario de login, una vez encontrado, si existe, compara la contraseña almacenada en la base con la que fue enviado por el usuario, utilizando el mismo método de cifrado que se utilizó para almacenarla al principio.

Una vez comparado, y si no manda error, se declaran las variables de sesión que pudiéramos utilizar en el sistema para identificar a este usuario. Se pueden definir tantas variables como sea necesario, recordando que si se agrega una nueva variable o modifica la información, esta se tomará en cuanta cuando se vuelvan a loguear.

Estas variables podrán ser utilizadas a lo largo de la sesión del usuario utilizando las variables con formato:

 
Yii::app()->user->id_usuario;

Una buena practica es utilizar primero un “isset” para ver si el usuario de verdad tiene sesión, de lo contrario, el sistema arrojara un error al no encontrar dicha variable.

En cuanto a los roles en las acciones, los controladores generados con crud, traen por default el access rules, que define quien si y quien no, pasa a las acciones correspondientes del controlador:

public function accessRules() {
return array(
 array('allow', // allow all user perform 'index' and 'view' actions
'actions' => array('index', 'view'),
'users' => array('*'),
 ),
 array('allow', // allow authenticated user to perform 'create' and 'update' actions
'actions' => array('create', 'update'),
'users' => array('@'),
 ),
 array('allow', // allow admin user to perform 'admin' and 'delete' actions
'actions' => array('admin', 'delete'),
'users' => array('admin'),
 ),
 array('deny', // deny all users
'users' => array('*'),
 ),
);
}

Como podemos ver, tenemos cuatro escenarios:

En el primero, permitimos a todos los usuarios(*) entrar a la accion index y view

En el segundo, permitimos a todos los usuarios que tengan sesión iniciada(@) entrar a la acción create y update

En el tercero, permitimos a todos los usuarios que tengan sesión iniciada y que su usuario sea admin(admin) entrar a la acción admin y delete

En el cuarto, Negamos cualquier acción que no haya sido definida antes

Pero como esto no aplica para todos los casos, sino que podemos manejar roles, podríamos poner una regla como la siguiente:

array('allow',
'actions' => array('create', 'update'),
'users' => array('@'),
'expression' => 'Yii::app()->user->id_rol==1 || Yii::app()->user->id_rol==3',
),

Con esta regla, permitimos a todos los usuarios con sesión y que cuenten con un rol de usuario 1 o 2 a que ejecuten la acción create y update.

Existen otra formas de llevar a cabo acciones, permisos y roles, aunque esta puede adaptarse a las necesidades de tu proyecto, espero les sea útil

Felices Códigos

Hola a todos, traigo a ustedes una mini-guía para la utilización de Yii-Framework. Sirve para empezar a utilizar este Framework de desarrollo ágil muy recomendable para todo tipo de proyectos web, espero les sirva, cualquier duda estoy disponible en @Joge23_rm o por correo joge23@gmail.com. Saludos.

NOMENCLATURA

Cambios a líneas

Agregados de líneas

INSTALACIÓN

Lo primero que debes hacer es descargar el  Framework del sitio: http://www.yiiframework.com/ (versión actual: v1.1.13)

Descomprimir y colocar carpeta sin renombrar (para mantener un control de la versión utilizada para cada proyecto) en la carpeta de elección, sugerida en ambiente linux: /opt/

Para la creación del proyecto utilizamos el Shell de Linux, estando en la carpeta donde se va a alojar el proyecto se escribe /opt/yii_version/framework/yiic webapp nombreProyecto

          p.e. jorge@jorge:/var/www$ /opt/yii-1.1.13.e9e4a0/framework/yiic webapp prueba

El sistema te solicitará confirmar la creación del proyecto, recordar que esto generará una carpeta con el nombre de dicho proyecto en donde estes ubicado. Puedes probar tu proyecto creado, en este ejemplo en el navegador:

http://localhost/prueba/

** En caso de mostrar el siguiente error

PHP warning

date() [<a href=’function.date’>function.date</a>]: It is not safe to rely on the system’s timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected ‘America/Chicago’ for ‘CDT/-5.0/DST’ instead

Verificar la configuración de PHP el default_time_zone (Este problema suele presentarse con Zend Studio)

Ya en este punto podrás ver tu sitio funcionando.

A partir de aquí se configurarán los archivos del proyecto, no debes modificar los del Framework a menos que sea muy necesario.

Podemos identificar que se han creado las carpetas de nuestro proyecto, debemos identificar la carpeta Protected que es donde estan los archivos de configuración, las extensiones, y el MVC (Models, Views, Controllers). En este punto están los de la estructura básica del proyecto.

CONFIGURACIÓN Y BASES DE DATOS

prueba/protected/config/main.php

<?php

// uncomment the following to define a path alias

// Yii::setPathOfAlias(‘local’,’path/to/local-folder’);

// This is the main Web application configuration. Any writable

// CWebApplication properties can be configured here.

return array(

          ‘basePath’=>dirname(__FILE__).DIRECTORY_SEPARATOR.’..’,

          ‘name’=>’Prueba’,

          ‘language’=>’es’,

          // preloading ‘log’ component

          ‘preload’=>array(‘log’),

          // autoloading model and component classes

          ‘import’=>array(

                   ‘application.models.*’,

                   ‘application.components.*’,

          ),

          ‘modules’=>array(

                   // uncomment the following to enable the Gii tool

                   ‘gii’=>array(

                             ‘class’=>’system.gii.GiiModule’,

                            ‘password’=>’hfdjkhf’,

                            // If removed, Gii defaults to localhost only.

                             ‘ipFilters’=>array(‘127.0.0.1′,'::1′),

                        ),

                 ),

          // application components

          ‘components’=>array(

                   ‘user’=>array(

                             // enable cookie-based authentication

                             ‘allowAutoLogin’=>true,

                   ),

                               // JQUERY nativo desactivado

                               ‘clientScript’=>array(
‘scriptMap’=>array(
‘jquery.js’=>false,
‘jquery.min.js’=>false,
)
),

                   // uncomment the following to enable URLs in path-format

                    ‘urlManager’=>array(
‘urlFormat’=>’path’,
‘rules’=>array(
‘<controller:\w+>/<id:\d+>’=>'<controller>/view’,
‘<controller:\w+>/<action:\w+>/<id:\d+>’=>'<controller>/<action>’,
‘<controller:\w+>/<action:\w+>’=>'<controller>/<action>’,
),
),

                         ‘db’=>array(
‘connectionString’ => ‘sqlite:’.dirname(__FILE__).’/../data/testdrive.db’,
),

// uncomment the following to use a MySQL database

                         ‘db’=>array(
‘connectionString’ => ‘mysql:host=localhost;dbname=prueba’,
’emulatePrepare’=> true,
‘username’ => ‘usuario’,
‘password’ => ‘dsfsfsdfs’,
‘charset’ => ‘utf8′,
),

‘errorHandler’=>array(

                             // use ‘site/error’ action to display errors

‘errorAction’=>’site/error’,

),

‘log’=>array(

‘class’=>’CLogRouter’,

‘routes’=>array(

array(

‘class’=>’CFileLogRoute’,

‘levels’=>’error, warning’,

),

// uncomment the following to show log messages on web pages

/*

array(

‘class’=>’CWebLogRoute’,

),

*/

),

),
),

// application-level parameters that can be accessed

// using Yii::app()->params[‘paramName’]

‘params’=>array(

// this is used in contact page

‘adminEmail’=>’webmaster@example.com’,

),

);

Lo que hicimos fue modificar el nombre de nuestra aplicación, modificar el lenguaje para el sitio, descomentar el código que permite utilizar Gii (generación de modelos y crud) y le modificamos el campo de Password; agregar el código para deshabilitar el JQuery nativo (recomendado para incluir la versión más nueva y que no choquen), descomentar UrlManager (esto hace que los métodos se muestren con Friendly Url), descomentamos la configuración de DB y agregamos los datos de nuestra base de datos. Con esto finalizamos la modificación de este archivo.

CREACIÓN DE MODELOS

Es importante que el usuario www-data tenga permisos, se sugiere cambiar el propietario del proyecto cuando se utiliza el Gii(esto es porque se generan archivos a partir del navegador), en consola:

sudo chown -R www-data.www-data prueba

En el navegador: http://localhost/prueba/index.php/gii/default/login

Utilizamos nuestra contraseña (la que asignamos para el componente Gii en el archivo de configuración).

Una vez adentro, seleccionamos la sección de Model Generator y en esta parte ingresamos en el campo de Table Name el nombre de la tabla; lo demás es bueno dejarlo por Default. Seleccionamos el botón Preview y te mostrará la lista de archivos generados, en este caso sería un archivo Tablename.php, le das Generate y te regresará un mensaje de éxito.

Este es el proceso para crear los modelos de cada tabla, los cuales permitirán la conexión a la base y a dicha tabla.

p.e. Tablename::model()->findAll();//Con este comando recuperarías todos los registros de la tabla en concreto en forma de array de objetos.

CREACIÓN DE CRUD (CONSULTAS, ALTAS, BAJAS Y CAMBIOS)

A partir de nuestro archivo de modelo generado, podemos crear la consulta, altas, bajas y cambios a nuestra tabla con la opción de Crud Generator, donde sólo ingresaremos el nombre del modelo: Tablename

Al seleccionar Preview  nos mostrará todos los archivos (un Controller y varias vistas) que se van a generar, le damos Generate y listo, podemos empezar a utilizar/modificar según las necesidades del proyecto.

PUNTOS CLAVES

Modelo

Apartado de Rules: Reglas que van aplicarse tanto al Create como al Update de los registros de cada modelo.

Apartado de AttributeLabels: Permite definir las etiquetas de los campos, es muy útil si a lo largo de todo el proyecto se utilizan porque si hay un cambio sólo se modifica una vez.

Controller

Al principio se define el layout general, recomiendo moficar dicha línea y utilizar layout main,

public $layout=’//layouts/main';

El apartado de accessRules  permite definir las reglas de accesso, en la configuración por Default se da acceso a todo(*) a algunas acciones de las clases, a los usuarios logueados(@) a otras y a un usuario en específico a otras (Admin). Este puede ser customizado con opciones como ‘expression’, todo esto viene en la documentación de Yii.

Más adelante están todos los métodos de la clase, los que vienen por Default y los que se crearán para el proyecto.

Views

Gracias al Crud, por cada Controller se generán:

• index.php (Página principal, por Default viene un listado de los elementos de la tabla).
• _view.php (Se renderea parcialmente dentro de index.php, representa uno a uno los elementos que se muestran en la lista).
• view.php (Es la vista individual de cada elemento de la tabla, si se utiliza el controller tablename/1) dirigirá por Default al View de ID 1
• create/update (Contienen al _form que es donde se puede modificar al registro).

Entre otras…

Views site y Layout

En las vistas que vienen generadas desde el principio se encuentran las de Site (vistas básicas, el Index del Home, el contacto y otras. Todas estas son las vistas que serían relativamente estáticas) y las de Layout (main.php contiene el código que envuelve a todas las vistas que se renderean, es decir, el cascarón del sitio).

Espero que esta información les sea de utilidad, aquí les dejos algunos links en donde pueden encontrar más información.

http://www.yiiframework.com/

http://www.yiiframework.com/doc/guide/1.1/en/quickstart.first-app

http://www.yiiframework.com/wiki/

Alguna vez te has preguntado ¿cómo se logra obtener o qué es el famoso HTTPS que vemos en algunas direcciones URL?.

¿Qué es?

Utiliza un cifrado basado en SSL/TLS para crear un canal cifrado (cuyo nivel de cifrado depende del servidor remoto y del navegador utilizado por el cliente) más apropiado para el tráfico de información sensible que el protocolo HTTP. De este modo se consigue que la información sensible (usuario y claves de paso normalmente) no pueda ser usada por un atacante que haya conseguido interceptar la transferencia de datos de la conexión, ya que lo único que obtendrá será un flujo de datos cifrados que le resultará imposible de descifrar.

El puerto estándar para este protocolo es el 443. (Fuente: es.wikipedia.org/wiki/Hypertext_Transfer_Protocol_Secure )

¿Cómo obtengo un Certificado SSL para mi sitio web?

A continuación una descripción paso a paso :

1 Asegurate que OpenSSL esté instalado en tu PATH de Linux.

2 Crea una llave privada RSA para tu servidor  Apache (será Triple-DES encriptada y en formato PEM): $ openssl genrsa -des3 -out server.key 1024

Haz un respaldo del archivo de llave server.key en un lugar seguro. Si quieres ver los detalles de la llave privada que acabas de crear entonces usa el siguiente comando: $ openssl rsa -noout -text -in server.key

Si es necesario puedes crear una versión no encriptada PEM de la llave privada con: $ openssl rsa -in server.key -out server.key.unsecure

3 Crea un archivo CSR (Certificate Signing Request) utilizando la llave privada RSA que creamos previamente y para esto utilizamos el siguiente comando: $ openssl req -new -key server.key -out server.csr

En este paso nos pedirá información acerca de el dominio que queremos tener bajo HTTPS, hay que asegurarnos de ingresar el FQDN (“Fully Qualified Domain Name”) del servidor cuando el OpenSSL te lo pregunte lo que sería el “CommonName”, ejemplo cuando generamos un CSR para un sitio web el cual será accesado de la forma  https://www.foo.dom/,  entonces tendremos que ingresar “www.foo.dom” en este campo. Al final después de creado el archivo podrás ver el contenido del CSR utilizando: $ openssl req -noout -text -in server.csr

4  Ahora debemos enviar este el Certificate Signing Request (CSR) a un Autoridad Certificadora (CA) al cual deberás pagar para que te firme o valide. Una vez que el CSR ha sido firmado entonces obtendrás un Certificado el cual podrás usar en tu servidor Apache; el Certificado que te manden lo almacenas en un archivo con terminación .crt (server.crt ). Estas son algunas Autoridades Certificadoras:

Verisign http://digitalid.verisign.com/server/apacheNotice.htm

Thawte http://www.thawte.com/

CertiSign Certificadora Digital Ltda. http://www.certisign.com.br

IKS GmbH http://www.iks-jena.de/leistungen/ca/

Uptime Commerce Ltd. http://www.uptimecommerce.com

BelSign NV/SA http://www.belsign.be

GeoTrust http://www.geotrust.com/

Si desear ver los detalles de tu certificado firmado necesitas usar el siguiente comando: $ openssl x509 -noout -text -in server.crt

5 Ahora tendremos dos archivos: server.key y server.crt. Estos pueden ser utilizados en tu archivo de configuración httpd.conf  o en el Virtualhost del dominio de la siguiente manera:

6 Necesitaras una  IP dedicada para cada SSL si es que en el server alojas más de un dominio,  en este caso deberás solicitarla con tu proveedor de servicios de hosting. El archivo server.csr ya no se necesita más.

Espero que esta información te sea útil.

Para subir un archivo con  jQuery y Ajax + PHP, en lugar de  utilizar un plugin ya desarrollado y probado,  podemos utilizar la lógica de cómo se envía un archivo con Ajax:

function uploadAjax(){

var inputFileImage = document.getElementById(“archivoImage”);

var file = inputFileImage.files[0];

var data = new FormData();

data.append(‘archivo’,file);

var url = “upload.php”;

$.ajax({

url:url,

type:’POST’,

contentType:false,

data:data,

processData:false,

cache:false});

}

Configurando el Html de la página, algo similar tiene que quedar el Input:

<input type=’file’ name=’archivoImage’ id=’archivoImage’ />

<input type=’button’ id=’botonSubidor’ onclick=’uploadAjax()’ />

También pueden hacerlo con jQuery:

$(document).ready(function() {     $(‘#botonSubidor’).click(‘uploadAjax’);})

Obviamente el html tiene que quedar así:

<input type=’file’ name=’archivoImage’ id=’archivoImage’ />

<input type=’button’ id=’botonSubidor’ />

El archivo upload.php

//upload.php

$return = Array(‘ok’=>TRUE);

$upload_folder =’images';

$nombre_archivo = $_FILES[‘archivo’][‘name’];

$tipo_archivo = $_FILES[‘archivo’][‘type’];

$tamano_archivo = $_FILES[‘archivo’][‘size’];

$tmp_archivo = $_FILES[‘archivo’][‘tmp_name’];

$archivador = $upload_folder . ‘/’ . $nombre_archivo;

if (!move_uploaded_file($tmp_archivo, $archivador)) {

$return = Array(‘ok’ => FALSE, ‘msg’ => “Ocurrio un error al subir el archivo. No pudo guardarse.”, ‘status’ => ‘error’);

}

echo json_encode($return);

Espero que esta información les sea de utilidad ¿Ustedes cómo lo harían?

Debemos recordar lo complicado que era hacer formularios complejos con el componente Form en ZendFramework 1; un formulario que te llevaba un par de horas se podía extender hasta más de cinco horas dependiendo de la complejidad del diseño, debido a que los decoradores (decorators) son un poco ambiguos y a veces, practicamente se lograba el resultado final a prueba y error, sin olvidar los dolores de cabeza y la presión para entregar el resultado.

Afortunadamente para ZendFramework 2 los decoradores han desaparecido, lo que para algunos fueron excelentes noticias (me incluyo) para otros no fue algo con lo que estuvieran muy de acuerdo. Lo que se implementó en el nuevo componente Zend\Form es una separación de los conceptos, es decir, podremos manejar totalmente en partes cada parte que conforma un campo de entrada de datos en un formulario (etiquetas, mensajes de error, campos de texto, checkbox, etc.)

Veremos ahora un poco de código para entender como se hace esto.

Consideren lo siguiente:

– Un simple formulario con para obtener la contraseña olvidada: caja de texto para correo electrónico y el botón de envío de datos al server.

El código en la clase de formulario sería de la siguiente forma:

namespace Application\Form;

use Zend\Form\Form;

class ObtenPass extends Form

{

     public function __construct($name = null)

    {

                 $this->add(array(

                                ‘name’ => ’email’,

                                ‘type’ => ‘Zend\Form\Element\Text’,

                                ‘options’ => array(

                                ‘label’ => Tu Correo’,

                                ),

                                ‘attributes’ => array(‘id’ => ’email’),

                ));

                 $this->add(array(

                                ‘name’ => ‘submit’,

                                ‘type’ => ‘Zend\Form\Element\Submit’,

                                ‘attributes’ => array(

                                ‘value’ => ‘Obtener’,

                                ‘class’ => ‘btn-success’,

                                ),

                ));

     }

}

En el controlador tendríamos lo siguiente:

namespace Application\Controller;

use Zend\Mvc\Controller\AbstractActionController;

use Application\Form\ObtenPass as ObtenPassForm;

class IndexController extends AbstractActionController

{

public function obtenPassFormAction()

{

$form = new ObtenPassForm();

return array(‘form’ => $form);

}

}

Ahora la parte interesante, ¿cómo lo representamos en la vista (view)?

Veamos más código.

$form = $this->form;

$form->setAttribute(‘action’, $this->url(obten-pass’));

 $form->prepare();

 echo $this->form()->openTag($form) . PHP_EOL;

 echo $this->formLabel($form->get(’email’)) . PHP_EOL;

 echo $this->formInput($form->get(’email’)) . PHP_EOL;

 echo $this->FormElementErrors($form->get(’email’)) . PHP_EOL;

 echo $this->formSubmit($form->get(‘submit’)) . PHP_EOL;

 echo $this->form()->closeTag($form) . PHP_EOL;

Como se puede observar claramente tenemos cada parte del elemento del formulario por separado, esto gracias a los ViewHelpers que ya se encuentran listos para usar dentro de ZendFramework 2;  de tal formar que podemos insertar cada pieza de este en diferentes tags de HTML y prácticamente acomodarlos a nuestro gusto o adaptarlo a un código HTML que previamente nos hayan proporcionado.

En mi opinión esto es una maravilla. ¿Y tú qué opinas?

Que tal, en esta ocasión me gustaría compartir con ustedes este documento de comandos básicos de Linux, el cual fue recabado directamente del Manual de Linux. Espero les sea de utilidad:

$                      Antes de una variable nos permite acceder a su valor

Ejemplo:

$ echo $variable

;                       Separa dos comandos en una misma línea

Ejemplo:

$ read variable ; echo el valor de variable es: $variable

awk                 Escáner de patrones y lenguaje de programación para procesar textos

Ejemplo:

$ echo Hola amigo como estas | awk ‘{ print $1, $2 “!,”,  $3, $4 “?” }’

Algunos ejemplos de comandos básicos de Linux, que son ayuda para la utilización del sistema operativo son:

cal                    Muestra el calendario del mes actual

cat                   Muestra el contenido de un fichero

cd                     Cambia de directorio de trabajo y si este no se indica, nos traslada a $HOME

chgrp              Cambia el grupo propietario de un fichero

chmod            Cambia los permisos de un fichero

chown             Cambia el propietario de un fichero

clear                Limpia la información que hay en pantalla

cp                     Copia archivos y directorios

Ejemplo:

cp archivo1.txt archivo1_respaldo.txt

cut                   Elimina partes de ficheros

Ejemplo:

echo Hola amigo como estas | cut -d ” ” -f 2

date                 Muestra hora y fecha actual

df                      Muestra el espacio del disco

du                    Calcula el espacio de disco usado

echo                 Imprime en pantalla

env                  Muestra las variables de entorno del programa

exit                  Termina la sesión

export             Exporta una variable al entorno del programa

false                 Falso, boleano

file                    Indica de qué tipo es un fichero

find                  Búsqueda avanzada de ficheros

fmt                   Da formato los párrafos de un fichero

grep                 Busca ocurrencias de una cadena en un fichero

gunzip             Descomprime un fichero comprimido con gzip

gzip                  Comprime un fichero

halt                   Apaga la máquina

head                 Muestra “n” líneas del inicio de un fichero (10 por defecto)

kill                    Termina un proceso indicando su PID (Identificador del proceso)

ldd                    Muestra las librerías que usa un programa

less                   Una versión más elaborada de “more” que permite desplazarnos por el texto, hacer búsquedas, etc.

ln                      Enlazar (referenciar) ficheros

locate               Busca ficheros

logout              Termina la sesión y muestra el login del sistema

ls                       Muestra el contenido de un directorio

mail                 Programa simple para enviar y leer correo

man                 Muestra la página del manual de un comando

mkdir              Crea directorios

more                Muestra el contenido de un fichero haciendo pausas entre pantallas si el fichero es largo

mv                    Mueve ficheros

passwd             Cambia la contraseña de un usuario

ps                      Muestra los procesos en el sistema

pwd                  Muestra el directorio de trabajo actual

read                 Lee una línea de la entrada estándar y la almacena en una variable

reboot              Reinicia la máquina

reset                 Restaura la terminal de texto

rm                    Borra ficheros

rmdir               Borra directorios (vacíos)

sed                    Realiza transformaciones en flujos de bytes

seq                    Genera una secuencia de números

shutdown       Apaga o reinicia la máquina

sleep                 Detiene el proceso durante “n” segundos

sort                   Ordena ficheros de texto

tac                    Concatena ficheros y los muestra a la inversa

tail                   Muestra las “n” últimas líneas de un fichero (10 por defecto)

tar                    Empaquetar ficheros

touch               Actualiza la fecha y hora de un fichero, si no existe lo crea

tr                      Elimina o traduce caracteres

true                 Cierto, o uno

uniq                 Lee de “stdin” y compara líneas adyacentes escribiendo las líneas únicas a “stdout”

wc                     Cuenta lineas, palabras o bytes en ficheros

whereis            Indica donde se puede encontrar un fuente, binario o manual

which               Indica donde está un comando

who                   Quién tiene sesión abierta en la máquina

zcat                   Muestra el contenido de un fichero comprimido con gzip

La intención de compartir estos comandos es que los aprendamos para más adelante ver Programación Shell.

En esta ocasión les hablaré acerca de JavaScript Object Notation (JSON, en español se conoce como Notación de Objetos de JavaScript), que es una notación Javascript para escribir objetos que se ha hecho popular en el mundo del desarrollo de webs, componentes (Ajax), entre otros. Es una excelente forma para almacenar la información que deseamos compartir en distintos componentes o lenguajes de las aplicaciones web.

PHP dispone de varias funciones para hacer distintos tratamientos con notación de objetos JSON, que permite convertir un objeto PHP o cualquier otro tipo de variable a un string con notación JSON, así como crear un objeto PHP a partir de un string codificado con JSON.

A partir de PHP 5.2 las funciones JSON están disponibles siempre, pero si utilizamos PHP 4 tendríamos que instalarlas manualmente. Para ello existen varios paquetes de librerías, que provienen de diversas fuentes que tienen funciones para tratar con JSON desde PHP.

– Paquete JSON de PECL

Este paquete, del repositorio de librerías PHP PECL, es compatible con PHP 4.3.0 o superior. En versiones superiores a PHP 5.2 está disponible por defecto. En versiones anteriores del lenguaje se tendría que instalar de manera separada.

– Librería JSON-PHP

Es una librería de funciones que se conoce también con el nombre de “Services_JSON”. Originariamente escrita por Michal Migurski, en la actualidad se encuentra disponible dentro del framework PHP PEAR: http://pear.php.net/package/Services_JSON

– JSON Lib en Zend Framework

Es una librería de funciones para tratamiento con JSON que forma parte del framework PHP Zend.

Así que, si nuestro servidor PHP no dispone de las funciones JSON por estar poco actualizado, nos costará mucho menos esfuerzo y dolores de cabeza utilizar otra librería distinta a la básica de PECL. En este caso, por la facilidad de instalación, se recomendaría la utilización de la librería que viene en PEAR, que se puede descargar del propio sitio de PEAR, en la URL http://pear.php.net/package/Services_JSON

JSON es un formato ligero, fácil de escribir y codificar; por lo que ha sido adoptado universalmente. Para más informaciónvisita el sitio http://www.json.org/.