Subiendo de Nivel en Programacion

[oskar_calvo]

te paso el mail que me envio un compañero de la lista gulc (grupo de usuarios de linux de la carlos III, leganes).

Una función es un trozo de código que utilizas a menudo. Por ejemplo,
conectar a una BBDD o comprobar que un dato que el usuario haya
pasado no contenga código malicioso o simplemente palabrotas (lo que
se dice "filtrar" una entrada).

Cada trozo de código que quieres encapsular en una función debe tener
un nombre. Por ejemplo, si quiero crear una función para conectar con
una BBDD puedo llamarla "conectarConBaseDatos" o "setupDB" o como
quiera.

Es muy recomendable poner nombres que identifique claramente lo que
hace la función. Algunos humanos tienden a utilizar nombres como
"cosa", "kk" o "haz". Eso hay que evitarlo :)

Una función puede o no recibir entradas. Las entradas son
"información adicional" o "información necesaria". Por ejemplo, una
función que ponga la fecha en una página web no recibirá entradas (en
principio) ya que no necesita información adicional (la fecha es la
fecha de la máquina y punto). Una función que filtre una entrada de
texto normalmente recibirá como entrada el texto que quiero filtrar.

Los parámetros que pasas lo decide el programador en función del
diseño de su aplicación. No hay una norma para decidir si una función
debe recibir parámetros. El programador hace un diseño y escribe las
funciones acorde a él.

Una función se declara así:

function nombre (parámetros)
{
..... código de la función.....
}

Y se invoca así:

nombre(parámetros);


Por ejemplo:

function saludaAlUsuarioConNombre($nombre)
{
echo "Hola $nombre!";
}

saludaAlUsuarioConNombre("Pato");



Si no recibe parámetros los paréntesis se quedan vacíos, tanto en la
declaración como en la invocación:

function imprimeFecha()
{
echo date("d-m-y");
}

imprimeFecha();

Por último, una función puede devolver un valor. Por ejemplo, si
quieres filtrar una entrada de texto, la función que la filtre puede
devolver el texto filtrado. Por ejemplo, si soy el webmaster de la
SGAE y quiero censurar los textos enviados por los visitantes a su
web...

function censura($texto)
{
$texto = str_replace("ladrones", "CENSURADO", $texto);
$texto = str_replace("mafiosos", "CENSURADO", $texto);
$texto = str_replace("estafadores", "CENSURADO", $texto);
return $texto;
}

Supongamos que la web tiene un campo de texto llamado "comentario".
Yo podría hacer:

// obtengo el comentario del campo de texto
$textoDelComentario = $_REQUEST["comentario"];

// lo dejo "políticamente correcto"
$textoDelComentarioFiltrado = censura($textoDelComentario);

// lo imprimo
echo "El comentario es: " . $textoDelComentarioFiltrado;


Si una función devuelve un valor, por ejemplo un código de error,
dicho valor puede perfectamente ignorarse

function conectaBBDD()
{
$db = new PDO(...);

if (es valido)
return true;
else
return false;
}

$exito = conectaBBDD(); // la función devuelve algo y lo meto en $exito
conectaBBDD(); // la función devuelve algo pero lo ignoro


Una cosa muy importante es que cuando pasas una variable a una
función tal y como la hemos definido, la función es incapaz de
cambiar la variable que le pasas. Me explico:

function duplica($valor)
{
$valor = $valor * 2;
}

$pato = 10;
duplica($pato);
echo $pato;

¿Qué se espera que aparezca imprimido? 20
¿Qué aparece en realidad? 10

La función no es capaz de cambiar el valor de $pato.

Esto se llama "paso de argumentos por valor".

Para conseguir que una función cambie un valor se hace así:

function duplica(&$valor) // atención al &
{
$valor = $valor * 2;
}

$pato = 10;
duplica($pato);
echo $pato;

Ahora la función duplica sí tiene la capacidad de cambiar el
contenido de $pato. A esto se llama "paso de parámetros por
referencia".

Utilizando esta técnica puedes hacer que una función tenga varias
entradas y varias salidas. En cualquier caso te recomiendo que no lo
uses, puede dar quebraderos de cabeza. Para hacer esto de forma
elegante se usan objetos.

Un objeto es un conjunto de variables y funciones. Los 'planos' del
objeto se llaman "clases" y se definen así:

class Nombre
{
... variables ...

... funciones ...
}

Los objetos son como los que vemos en la vida real: tienen
propiedades (variables!) y hacen cosas (funciones!). Por ejemplo, un
pato tiene un nombre y hace cuack cuack.

Las variables de un objeto pueden ser públicas (cualquier trozo de
código de tu aplicación podrá ver y cambiar su valor) o privadas
(sólo el código de la clase puede acceder a esas variables). En
principio las variables de una clase suelen ('¡suelen!') ser privadas.

class Pato
{
private $nombre;

function hazCuak()
{
echo "cuack cuack!";
}
}

Para que una función de una clase obtenga el valor de una propiedad
de esa clase se usa $this->variable

class Pato
{
private $nombre;

function hazCuak()
{
echo "cuack cuack! soy el pato " . $this->nombre;
}
}

Para crear un objeto se hace así:

$miPatito = new Pato();

y para usar el objeto:

$miPatito->hazCuack();

Si una clase "Pato" define una función "Pato", esta función pasa a
llamarse "constructor" y tiene un papel muy importante: iniciar las
variables del objeto:

class Pato
{
private $nombre;

function Pato($nuevoNombre)
{
$this->nombre = $nuevoNombre;
}

function hazCuak()
{
echo "cuack cuack! soy el pato " . $this->nombre;
}
}

$miPatito = new Pato("Manolo");
$miPatito->hazCuack();

Si necesito cambiar el valor de una propiedad privada, tendré que
crear una función para ello:

class Pato
{
private $nombre;

function Pato($nuevoNombre)
{
$this->nombre = $nuevoNombre;
}

function rebautiza($nuevoNombre)
{
$this->nombre = $nuevoNombre;
echo "Cuack! ahora me llamo " . $this->nombre;
}

function hazCuak()
{
echo "cuack cuack! soy el pato " . $this->nombre;
}
}

$miPatito = new Pato("Manolo");
$miPatito->hazCuack();
$miPatito->rebautiza("Arturo");
$miPatito->hazCuack();

Las funciones que cambian propiedades privadas se llaman "setters"
porque suelen llamarse de la forma setPropiedad(...), por ejemplo:

class Pato
{
private $nombre;

function Pato($nuevoNombre)
{
$this->nombre = $nuevoNombre;
}

function setNombre($nuevoNombre)
{
$this->nombre = $nuevoNombre;
echo "Cuack! ahora me llamo " . $this->nombre;
}

function hazCuak()
{
echo "cuack cuack! soy el pato " . $this->nombre;
}
}

$miPatito = new Pato("Manolo");
$miPatito->hazCuack();
$miPatito->setNombre("Arturo");
$miPatito->hazCuack();

Por último, hay funciones y propiedades estáticos que se pueden usar
sin instanciar un objeto. En lugar de $this-> se usa el nombre de la
clase y "::"

Por ejemplo, como sólo hay una base de datos, tiene sentido crear una
clase que tenga sus funciones estáticas:

class Database
{
private static $db;

static function conecta()
{
Database::$db = new PDO(........);
}

static function hazConsulta($sql)
{
return Dabase::$db->query($sql);
}
}

Database::conecta();
Database::hazConsulta("delete from users where login='voiser'");

Espero que este repaso sirva de ayuda. Quizá deba mandártelo en
privado pero ya que está, que se quede en el foro y que lo indexe
google.

Por cierto, si vas a usar objetos _usa PHP5_. Recuerda que en la
charla tuve que cambiar un $PATH para usar php5 porque por defecto
usaba php4 y salían errores raros. PHP4 malo. PHP5 bueno.

dos cosas, como puedes ver los objetos son funciones más complejas pero que tienen muchas más salidas y utilidades.
yo también utilizo como manuales, la web de desarrolloweb. y el manual de introudcción a php5, donde viene un capítulo dedicado a la poo.

Un saludo y animo, es un mundo fascinante.

oskar