PHP Avanzado: Características avanzadas de PHP

Bloque IV: Usos avanzados
1. Subiendo archivos
2. Constantes mágicas
3. Métodos mágicos
4. Autoloading
5. Reflection
6. Objetos como arrays

Desarrollo web avanzado con PHP5

4.1. Subiendo archivos

El marcado HTML

<form
  action  ="index.php"
  enctype ="multipart/formdata"
  method  ="post"
>
    <input type="file" name="mi_archivo" />
    <input type="submit" />
</form>

Desarrollo web avanzado con PHP 5 Bloque IV: Usos avanzados de PHP


El array global $_FILES

[mi_archivo]

    [name] => Doc2.doc (Nombre dado por el navegador)

    [type] => application/msword (Tipo MIME del archivo)

    [tmp_name] => /tmp/phpBBq8Qa (Path del archivo en el servidor)

    [error] => 0 (Error producido durante la subida del archivo)

    [size] => 328192 (Tamaño en bytes)



Errores al subir un archivo (más comunes)

UPLOAD_ERR_OK == 0
Sin errores, subida satisfactoria.

UPLOAD_ERR_INI_SIZE == 1
El archivo subido excede el límite de la directiva upload_max_filesize en php.ini.

UPLOAD_ERR_FORM_SIZE == 2
El archivo subido excede el límite MAX_FILE_SIZE especificado en el formulario HTML.

UPLOAD_ERR_PARTIAL == 3
El archivo se subió sólo de manera parcial.



Errores al subir un archivo (menos comunes)
UPLOAD_ERR_NO_FILE == 4
No se subió ningún archivo

UPLOAD_ERR_NO_TMP_DIR == 6
No se encontró el archivo temporal de subida de archivos.

UPLOAD_ERR_CANT_WRITE == 7
No se tiene permisos de escritura en disco.

UPLOAD_ERR_EXTENSION == 8
Una extensión de PHP paró el proceso de subida.



Parámetros de configuración del servidor

file_uploads On On
max_file_uploads 20 20
upload_max_filesize 2M 2M
upload_tmp_dir No value No value



Y ahora sí, subiendo un archivo a nuestro servidor

<?php
$target_path =
".".DIRECTORY_SEPARATOR.$_FILES['mi_archivo']
['name'];
!! r
ad ra
if(move_uploaded_file($_FILES['mi_archivo']
rid ejo
gu m

['tmp_name'], $target_path)) {
se e
la qu

echo "El archivo ha sido subido”;
ay

} else{
H

echo "No se pudo subir el archivo";
}
?>


Mejorando la experiencia de usuario

http://www.swfupload.org http://www.uplodify.com


4.2. Constantes mágicas

¿Qué son?

Cconstantes predefinidas a cualquier script en ejecucción.



Listado de constantes mágicas

__LINE__ Línea actual en el fichero.

__FILE__ Ruta completa y nombre del fichero.

__DIR__ Directorio del fichero en el que se ejecuta.



Listado de constantes mágicas

__FUNCTION__ Nombre de la función.

__CLASS__ Nombre de la clase.

__METHOD__ Nombre del método de la clase.


// contansts.php

class Foo{

public function __construct(){
echo __CLASS__;
}

public function methodName(){
echo __METHOD__;
}
};

class Bar extends Foo{};

function functionName(){
echo __FUNCTION__;
};


// contansts.php

echo "donde estoy?".__DIR__;

echo "Pero, en que archivo?".__FILE__;

echo "Vale, pero en que linea?".__LINE__;

echo "Tendra esto sentido?".__CLASS__;

$foo = new Bar();

echo get_class($foo);

$foo->methodName();

functionName();


4.3. Métodos mágicos

Son métodos “especiales” (mágicos) comunes a todos los objetos que
empiezan por “__”

__construct() __get() __unset()

__destruct() __set() __invoke() 5.3

__call() __wakeup() __clone()

__callStatic() 5.3 __sleep()

__toString() __isset()


_sleep() y __wakeup() son ejecutados serializamos y
deserializamos un objeto.

O:3:"Foo":0:{}


class Connection
{
    protected $link;
    private $server, $username, $password, $db;

    public function __construct($server, $username,
$password, $db)
    {
        $this>server = $server;
        $this>username = $username;
        $this>password = $password;
        $this>db = $db;
        $this>connect();
    }
}



private function connect(){
  $this>link = mysql_connect($this>server, $this
>username, $this>password);
      mysql_select_db($this>db, $this>link);
}

public function __sleep(){
  return array('server', 'username','password', 'db');
}

public function __wakeup(){
        $this>connect();
}


_toString() nos permite indicarle al compilador que mostrar
cuando se le pida al objeto que se comporte como un string

class TestClass{
    public $foo;

    public function __construct($foo){
        $this>foo = $foo;
    }

    public function __toString(){
        return $this>foo;
    }
}


_toString() nos permite indicarle al compilador que mostrar
cuando se le pida al objeto que se comporte como un string

$class = new TestClass('Hello');

echo $class; // Hello


_call() Es invocado cuando se llama al método de un objeto que
no existe.

class Foo{
    public function __call($name, $arguments) {
        echo "Llamando al método call";
    }
}

$foo = new Foo();
$foo>noMetodo(); // Llamando al método call


_callStatic() Es invocado cuando se llama a un método estático
de una clase que no existe.

class Foo{
    public function __callStatic($name, $arguments) {
        echo "Llamando al método call";
    }
}

Foo::noMetodo(); // Llamando al método call


_get() Es invocado cuando se llama a un atributo de un objeto que
no existe.

_set() Es invocado cuando se intenta fijar el valor de un atributo
que no existe.

__isset() Es invocado cuando se pregunta si está fijado un atributo
que no existes


4.4. Autoloading
Una buena forma de escribir código mantenible es tener la definición
de cada clase en un archivo distinto.

El inconveniente es que para poder usar esa clase tenemos que
hacer un include o require y nuestro código se complica.

Programar de esta manera se convierte en algo pesado y tedioso.


4.4. Autoloading
Utilizamos la funcion __autoload()

function __autoload($class_name) {

include $class_name . '.class.php';

}


4.4. Autoloading
La función __autoload no se puede reescribir.

¿Qué ocurre cuando haya distintas estrategias de carga de clases?

/db/
El nombre del archivo empieza con
  factory.php minúscula.
  driver_mysql.php
Se utilizand guiones como separadores.
  driver_oracle.php

/user/
La primer mayúscula
  User.class.php
  SecurityUser.clas.php Camelcase
  ParameterHolder.class.php Se añade “class” al nombre del script


4.4. Autoloading
Utilizamos la funcion spl_autoload_register($callable)

function autoload($class_name) {

include strtoupper($class_name) . '.class.php';

}

spl_autoload_register('autoload');


4.4. Autoloading
La función __autoload no se puede reescribir.

¿Qué ocurre cuando haya distintas estrategias de carga de clases?

/db/
  db_autoloader.php
  factory.php
  driver_mysql.php
  driver_oracle.php
/user/
  user_autoloader.php
  User.class.php
  SecurityUser.clas.php
  ParameterHolder.class.php


4.5. Reflection
Introspección de clases:
Saber cómo son nuestras clases y funciones por dentro.

Anterior a PHP 5 basado en un conjunto de funciones y directivas.

Reflection API, implementado a partir de PHP 5 basada en objetos.


4.5. Reflection

Buscando entre mis clases

get_prepared_classes() me devuelve todas las clases disponibles

<?php

class HelloClass{}

echo "<pre>";
print_r(get_declared_classes());
echo "</pre>";


4.5. Reflection

Comprobando que una clase existe

class_exists($classname) devuelve verdadero o falso dependiendo si la clase
existe

<?php

class_exists('HelloClass'); // true

class HelloClass{}

class_exists('HelloClass'); // true


4.5. Reflection

Comprobando que un método existe

mehod_exists($class_name o $object, $method_name) devuelve
verdadero o falso dependiendo si el método existe en la clase o no

<?php
class Foo{
public function Bar(){ }
}

method_exists('Foo', 'Bar'); // true

$foo = new Foo();
method_exists($foo, 'Bar'); // true


4.5. Reflection

Conociendo información sobre una clase u objeto

get_class($object) devuelve el nombre de la clase del objeto

<?php

class HelloClass{}

$hello = new HelloClass();
echo get_class($hello); // HelloClass

No muy útil para ver analizar las distintas “caras” de una clase polimórfica


4.5. Reflection

Conociendo información sobre una clase u objeto

instaceof nos permite conocer si una clase extiende otra o implementa una
determinada interfaz

<?php

class Foo{}
class Bar extends Foo{}
class Qux extends Bar{}

$qux = new Qux();
$qux instanceof Foo; // true
$qux instanceof Bar; // true


4.5. Reflection

Conociendo los métodos de un objeto

get_class_methods($class_name o $object) nos devuelve un array con
todos los métodos de esa clase. Sólo los métodos públicos.

<?php

  print_r(get_class_methods('Exception'));

  $exception = new Exception();
  print_r(get_class_methods($exception));


4.5. Reflection

Conociendo los atributos de un objeto

get_class_vars($class_name o $object) nos devuelve un array con todos
los atributos de esa clase. Sólo los atributos públicos.

<?php

  class Foo{
public $bar;
  }

  print_r(get_class_vars('Foo'));


4.5. Reflection

Reflection API

Librería de PHP que permite introspección no sólo de objetos, sino funciones y
extensiones del lenguaje.

Se compone de las siguientes clases

Reflection

ReflectionClass ReflectionFunction

ReflectionMethod ReflectionExtension

ReflectionParameter ReflectionException

ReflectionProperty


4.5. Reflection

Reflection API: Examinando una clase

<?php

  class Foo{
    public $bar;
    public function Baz(){}
  }

  $foo_class = new ReflectionClass('Foo');

  Reflection::export($foo_class);


4.5. Reflection
Class [ class Foo ] {
@@ /home/javier/workspace/mockups/reflection.php 4-8

- Constants [0] {
}

- Static properties [0] {
}

- Static methods [0] {
}

- Properties [1] {
Property [ public $bar ]
}

- Methods [1] {
Method [ public method Baz ] {
@@ /home/javier/workspace/mockups/reflection.php 7 - 7
}
}
}


4.5. Reflection

Reflection API: Explorando una clase

La clase ReflectionClass ofrece una serie de métodos que nos permite obtener
información de la clase a examinar. Algunos de estos métodos son:

ReflectionClass::isUserDefined ReflectionClass::getName

ReflectionClass::isInternal ReflectionClass::getMethods

ReflectionClass::isAbstract ReflectionClass::getProperties

ReflectionClass::isFinal ReflectionClass::getConstants

ReflectionClass::isInstantiable ...


4.5. Reflection

Reflection API: Explorando una clase

Si quieres conocer todos los métodos es fácil

<?php

$class = new ReflectionClass('ReflectionClass');

Reflection::export($class);


4.6. Objetos como array
Recordemos por un momento como era el patrón Observer

class Observable implements IObservable {
  private $observers;

  function attach(Observer $observer){
    $this>observers[] = $observer;
  };

  function detach(Observer $observer){
    $key = array_search($this>observers, $observer);
    unset($this>observers[$key]);
  };

  function notify(){
    foreach($this>observers as $observer){
      $observer>update($this);
    }
  }
}


Lo utilizabamos de la siguiente manera

$observable = new Observable();
$observable>attach(new Observer());

Imaginemos que pudiesemos hacer esto
$observable = new Observable();
$observable[] = new Observer();

$observable['observer_1']>update();

unset($observable['observer_1']);


1. El objeto extiende de la clase ArrayAccess

class Observable implements ArrayAccess {
// ...
}

2. Implementar cuatro métodos de la interfaz ArrayAccess

ArrayAccess::offsetExists

ArrayAccess::offsetSet

ArrayAccess::offsetGet

ArrayAccess::offsetUnset


class Observable implements ArrayAccess {
  private $observers;
  public function offsetExists($offset){
    return isset($this>observers[$offset]);
  }

  public function offsetGet($offset){
    return $this>observers[$offset];
  }

  public function offsetSet($offset, $value){
$this>observers[$offset] = $value;
  }

  public function offsetUnset($offset){
unset($this>observers[$offset]);
  }
   public function notify(){ //... }
}


Y si quisieramos contar el número de observadores

count($observable);

Tenemos que implementar la interfaz Countable y su método count

class Observable implements ArrayAccess, Countable
{
  // …
  public function count(){
return count($this>observers);
  }

}


PHP Avanzado: Características avanzadas de PHP

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a PHP Avanzado: Características avanzadas de PHP (20)

PHP Avanzado: Características avanzadas de PHP