SEO - Posicionamiento Web

Porque Objetos?
________________________________________
A medida que las secuencias de comandos se hacen cada vez mas complejas, la dificultad de mantenerlas aumenta extraordinariamente, especialmente si estamos programando con estilos de procedimientos. El concepto de programación orientada a objetos OOP, sirve para proporcionar una estructura organizativa real a nuestras secuencias de comandos a través del encapsulado.
Aunque PHP 4 introdujo la noción de OOP en PHP, no se puede considerar realmente una verdadera implantación orientada a objetos. Debido a las significativas limitaciones en PHP 4 a este respecto, el modelo de objetos de PHP 5 se ha rediseñado completamente para reflejar con precisión la definición académica de OOP.

Creación de clases básicas
________________________________________
Aunque denominemos programación orientada a objetos a este estilo de programación, la gran mayoría de la programación se realiza desarrollando clases. Una clase puede definirse como el diseño de un objeto y define todas las acciones que el objeto puede realzar. Por tanto, las definiciones de clase contienen variables, funciones (denominadas métodos) e incluso constantes que son especificadas solo para dicha clase o sus instancias.
Ejemplo:

class myEjemplo
{
public $Myvar
public function MiMetodo($parametro)
{
$this->Myvar = $parametro;
echo $this->Myvar;
}
}

Cuando se ha definido una clase se puede crear una instancia de dicha clase, una instancia de una clase es un objeto y representa una copia de la clase definida previamente. Para crear una instancia de myEjemplo utilizamos la sentencia new:

incluye_once(‘MiArchivo.php’);
$miInstancia = new myEjemplo();
$otraInstancia = new myEjemplo();

En este caso las dos variables representan objetos del tipo myEjemplo. Aunque se han creado de la misma definición de clase, son completamente diferentes entre si.

incluye_once(‘MiArchivo.php’);
$miInstancia = new myEjemplo();
$miInstancia -> MiMetodo(“Hola soy un parámetro recibido”);

Cuando se ejecute este comando en la pantalla se vera impreso lo que le pasamos por parámetros.

Métodos private, protected y public
________________________________________
En PHP 5 la definición y el uso de clases no ha cambiado mucho. De hecho, en PHP si definiéramos una clase al estilo PHP 4 trabajaría igual, pero en sintaxis 5, nos ofrece las diferencias arriba mencionadas.
Esta diferencia nos ofrece una nueva e importante opción en el modelo de orientación a objetos de PHP 5: los controles de acceso. En PHP 4 no había ningún concepto de control de acceso dentro de los objetos. Como desarrollador externo que utiliza la clase myEjemplo, no hay nada que me impida cambiar el valor de la variable $Myvar. Sin embargo en PHP 5 el modelo de objetos proporciona ahora tres niveles de acceso para los miembros de clase, que restringen los datos a los que se puede acceder y desde donde se pueden acceder a ellos en nuestras secuencias de comandos. Estos tres modelos de acceso son public(publico), private(privado) y protected(protegido) y se pueden aplicar tanto a métodos como a propiedades de la clase.
A los miembros de la clase declarados como públicos se puede acceder desde cualquier parte de una secuencia de comandos. Pueden modificarse o llamarse internamente por el objeto o desde fuera del objeto, algo que no se aplica a los miembros de clase solo desde dentro de una instancia de dicha clase a través de la variable $this.
El tercer y último nivel de acceso que proporciona PHP es el nivel protected. Este nivel es similar a la private, ya que evita el acceso a miembros de clase externamente. Sin embargo, al contrario de private que restringe el acceso solo a la clase especifica donde se ha definido, protected permite el acceso desde la misma clase o desde cualquier clase hija.

Indicaciones de tipo.
________________________________________

Otra mejora en PHP 5 para el modelo de objetos es el concepto de indicaciones de tipo. PHP es, por diseño, un lenguaje sin tipos, es decir, las variables no se restringen al tipo de datos que contienen. De hecho, algunas variables pueden tratarse en un momento como enteros y en otro como cadenas. Sin embargo, como los métodos dentro de los objetos normalmente aceptan parámetros que son instancias de otros objetos, PHP 5 nos permite restringir los tipos de datos de los parámetros de método.
Por ejemplo consideremos el siguiente ejemplo:

class entero
{
private $numero
public function getInt()
{
return (int) $this->numero;
}
public function setInt($num)
{
$this->numero = (int) $num;
}
}

class flotante
{
private $numero;
public function getFloat()
{
return (float) $this->numero;
}
public function setFloat($num)
{
$this->numero = (float) $num;
}
}

Estas clases definen entero y flotante, que aplican un envolvente simple para los tipos de datos enteros y de punto flotante dentro de php. Y que hay si necesitamos aplicar una clase de forma que se añadan solo los puntos flotantes? Con los conocimientos que ustedes tienen podríamos resolverlos de esta manera:

class math
{
public function add($op1, $op2)
{
return $op1->getFloar() + $op2->getFloat();
}
}

Sin embargo, debido a la naturaleza de PHP, no hay seguridad de que los parámetros $op1 y $op2 serán instancias de la clase flotante. Incluso aunque estuviésemos seguros de que fuesen objetos, no habría ningún método conveniente para saber si son del tipo correcto. Una posible solución es utilizar el nuevo operador instanceof en PHP 5, que devuelve un valor booleano que indica si una variable es una instancia de una determinada clase:

class math
{
public function add($op1, $op2)
{
if(($op1 instanceof flotante) && ($op2 intanceof flotante))
{
return $op1->getFloat() + $op2->getFloat();
}
else
{
echo ‘Deben pasar dos flotantes como instancias en los parámetros’;
}
}
}

Nuestra clase math tiene un método para asegurarse de que los parámetros que se pasan son objetos del tipo correcto. Sin embargo dicha técnica puede conseguir que nuestro código sea propenso a error y confuso en su lectura. Una mejor solución que consigue el mismo objetivo es especificar el tipo exacto que necesitamos en el prototipo de la función.

class math
{
public function add(flotante $op1, flotante $op2)
{
return $op1->getFloat() + $op2->getFloat();
}
}

De este modo podemos indicar claramente el tipo especifico requerido por el método add() y podemos suponer con seguridad de que va a existir el método getFloat().

Constructores y Destructores
________________________________________
Los constructores y destructores son funciones a las que llamamos cuando creamos una nueva instancia de un objeto(contructores), y/o la destruimos(destructores). Su proposito principal es permitir inicializar y limpiar después un objeto, por ejemplo:

class BaseClass
{
function __construct()
{
print ‘contructor en clase base\n’;
}
}

class SubClass extendí BaseClass
{
function __construct()
{
parent::__construct();
print ‘Constructor en subclase\n’;
}
}

$obj = new BaseClass();
$obj = new SubClass();

Los constructores padres no son llamados implícitamente si la clase hijo define un constructor. Para poder ejecutar el constructor de la clase padre, se debe hacer una llamada a parent::__construct() dentro del constructor de la clase hijo.
Este es un ejemplo de destructor:

class MyDestructableClass
{
function __construct()
{
print ‘In constructor\n’;
$this->name = ‘MyDestructableClass’;
}
function __destruct()
{
print ‘Destroying ‘ . $this->name – “\n”;
}
}
$obj = new MyDestructableClass();

Aunque los constructores son útiles para inicializar propiedades de clase, la combinación de constructores y destructores es igualmente útil de otras formas. Un ejemplo clásico es una clase para acceder a la conexión de una base de datos, donde un constructor crea la conexión y el destructor la cierra.

Constantes de Clase.
________________________________________

Las constantes de clase son una nueva caracteristica de PHP 5 que proporcionan, como su nombre implica, una opcion para definir valores constantes dentro de una definición de clase. Por ejemplo:

class MyClass
{
const constant = ‘Valor Constante’;
function showConstant()
{
echo self::constant . “\n”;
}
}
echo MyClass::constant . “\n”;

$class = new MyClass();
$class -> showConstant();
// echo $class::constant; NO ESTA PERMITIDO

El ejemplo ilustra el usa de las constantes de clase tanto en la propia clase como fuera de ella. Para acceder desde fuera de la clase tendríamos que usar el operador de resolución (también llamado Paamayim Nekudotayim) o en términos simples, dobles dos puntos (::), es un símbolo que permite acceso a los miembros o métodos estáticos, constantes y eliminados de una clase.

Métodos Estáticos
________________________________________

Los metodos estaticos son metodos que forman parte de una clase, pero que se han diseñado para llamarse desde fuera del contexto de la instancia de un objeto. Se comprotan de forma identica a los metodos normales en una clase desde todos los puntos de vista excepto en un detalle importante: los metodos estaticos no pueden utilizar la varibles $this para hacer referencia a la instancia actual del objeto.
Ejemplo de un metodo estatico:

class Foo
{
public static $my_Static = ‘foo’;
public function staticValue()
{
return self::$my_static;
}
}

class Bar extends Foo
{
public function fooStatic()
{
return parent::$my_static;
}
}

print Foo::$my_static . “\n”;
$foo = new Foo();
print $foo -> staticValue() . “\n”;
print $foo -> my_static . “\n”;
// Propiedad indefinida my_static
//$foo::my_static no es possible

print Bar::$my_static . “\n”;
$bar = new Bar();
print $bar -> fooStatic() . “\n”;

Herencia de Clases
________________________________________

La herencia es por definición, la capacidad de una definición de clase extender otra funcionalidad de definición de clase.
Cuando se hereda una clase de otra, todos los métodos, propiedades y constantes de la clase padre se encuentra n disponibles también desde la clase hija. Así mismo, las clases hijas también pueden volver a implantar algunos o todos los métodos, propiedades y constantes de una clase padre para proporcionar una funcionalidad adicional o diferente. Las clases se heredan de otra utilizando la palabra clave extends en la definición de clase.

Clases y Métodos abstractos
________________________________________

Como su nombre implica, las clases abstractas se utilizan en OOP para definir objetos abstractos. Para entender lo que define a un objeto abstracto consideremos el concepto de la comida. Todos sabemos lo que es la comida, pero, lo hemos visto?. Hemos visto varios tipos de comida, carne, pollo, verdura, etc, pero el concepto de comida es en si un concepto abstracto. Ese concepto también se aplica a las clases abstractas. En OOP, las clases abstractas se diseñan para proporcionar una súper clase que define las características abstractas de las clases heredadas. Las clases abstractas pueden o no tener código en ellas, y nunca pueden crear instancias de ellas directamente.

Ejemplo de una clase abstracta y su herencia correspondiente:

abstract class AbstractClass
{
//Forza a las clases extendidas a implementar estos metodos
abstract protected function getValue();
abstract protected function prefixValue($prefix);

//metodo comun
public function printOut()
{
print $this -> getValue() . “\n”;
}
}

class ConcreteClass1 extends AbstractClass
{
protected function getValue()
{
return ‘concreteClass1’;
}
public function prefixValue($prefix)
{
return ‘{prefix]}ConcreteClass1’;
}
}

class ConcreteClass2 extends AbstractClass
{
protected function getValue()
{
return ‘concreteClass2’;
}
public function prefixValue($prefix)
{
return ‘{prefix]}ConcreteClass2’;
}
}

$class1 = new ConcreteClass1();
$class1 -> printout();
echo $class1 -> prefixValue(‘FOO_’) . “\n”

$class2 = new ConcreteClass2();
$class2 -> printout();
echo $class2 -> prefixValue(‘FOO_’) . “\n”

El resultado del ejemplo seria:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

Este articulo es a modo de introducción, luego voy a ir hilando mas fino sobre los temas planteados, y otros de los cuales todavía no se hablaron.

Para optimizar nuestro sitio, necesitaremos como primera instancia, seguir con las directrices que ya publique en el articulo Principios para posicionar tu sitio. Ahora para hilar un poco mas fino, vamos a ver algunos factores que debemos tener en cuenta para que nuestro sitio sea optimo.
Uno de los principales factores a tener en cuenta son las Meta-etiquetas que utilizamos, las principales son la de description (que describe el contenido de la pagina) y la de keywords (que son las palabras por las que pueden encontrar tu sitio en los motores de búsqueda)
También es importante que la etiqueta “title” sea lo mas descriptiva posible, pero a la ves no muy extensa, ya que esto ya no seria optimo.
Estas son las principales, ya que los motores de búsqueda toman la etiqueta title para mostrar en el buscador como link a tu pagina, la Meta-etiqueta description que es la descripción que aparece a continuación, y la Meta-etiqueta keywords que le dice al buscador que cuando un usuario ponga por ejemplo la palabra “Posicionamiento Web” y en tus keywords se encuentra esta palabra clave, entonces debe aparecer en el buscador como se ve en la imagen debajo. Esto no quiere decir que si nosotros ponemos una palabra clave en nuestro sitio, y luego ponemos esa palabra clave en el buscador, nuestro sitio aparecerá en primera posición, pero justamente de eso se trata la optimización, de llegar a un nivel tan optimo como se pueda como para que en el futuro aparezca en la primera posición.

Por otro lado, no sirve de nada, tener el title, las keywords y descriptions mas optimas del mundo para nuestro sitio, si este no tiene buen contenido, por este motivo hay que tratar de ser lo mas original posible, crear tu propio contenido, que concuerde con lo que según las etiquetas ofreces.
Otro punto importante es la optimización de las URLs, a los motores de búsqueda no les gusta las URLs que reciben parámetros, como por ejemplo:

tudominio.com/pagina.html?var1=variable1&var2=variable2

Este es difícil de entender para los motores de búsqueda y la idea es facilitarle las cosas lo mas que se pueda, y de esa manera el nos mejorar nuestra posición, es un simple ida y vuelta, volviendo a las URLs es bueno que estas también contengan palabras claves, y en vez de tener la URL con parámetros que no se entienden, la podríamos reemplazar por la siguiente:

tudominio.com/variable1/variable2

donde variable1 y variable2 seria palabras claves. Esto se suele optimizar con el conocido archivo .htaccess del cual hablaremos mas adelante.

SEO - Posicionamiento Web

jueves, 27 de marzo de 2008

1 - PHP 5 - Programación Orientada a Objetos

miércoles, 19 de marzo de 2008

Como optimizar tu sitio

Directorios de enlaces

martes, 18 de marzo de 2008

Siestita mientras trabajo?

Autor:

Blogs Amigos

Vinculos Interesantes

Categorias

Mis Publicaciones

Enlace Patrocinador: