Intro aplicaciones web con php

UNIVERSIDAD NACIONAL DE ANCASH SANTIAGO ANTUNEZ DE MAYOLO
UNASAM
Programacion III
APLICACIONES WEB CON PHP
La Programación Orientada a Objetos (POO) es un paradigma de desarrollo de software
que permite definir a las entidades como clases, permitiendo agrupar tareas similares.
Diferencias entre objetos y clases
Es importante definir las diferencias entre estos dos términos y entender que no son
sinónimos.
Una clase es como una plantilla (o molde). Define las propiedades, acciones y relaciones que posee
una entidad.
Un objeto es lo que se obtiene de la clase, es una instancia de ella.
Se pueden crear muchos objetos de una misma clase, todos ellos independientes de
otros.
Estructura
La sintaxis para crear una clase es bastante simple: se utiliza la palabra class, se le
indica un nombre y se encierra su código entre llaves.
<?php
class Producto
{
// código
}
?>
Luego de crear una clase, podemos instanciar una variable de la misma, esta variable es
un objeto. Para hacerlo, usamos la palabra reservada new.
$p = new Producto;
Propiedades
Una clase puede contener variables dentro, las cuales reciben el nombre de propiedades.
Estas funcionan igual que las variables normales, con la excepción que están atadas a la
clase y sólo pueden ser accesibles a través de un objeto de ella. Para agregar una
propiedad a nuestra clase tenemos que hacer lo siguiente:
class Producto
{
public $cantidad = 4;
}
La palabra public determina la visibilidad de la propiedad, significa básicamente que se
puede acceder al miembro por fuera de la clase. La propiedad se crea como una variable
normal y puede asignársele un valor inicial (aunque esto no es necesario).
Para leer la propiedad y mostrar su valor en el navegador, tenemos que acceder a ella a
través de nuestro objeto, de la siguiente forma:
echo $p->cantidad;

UNASAM
Programacion III
El operador flecha -> nos permite acceder a un miembro del objeto que se encuentra a su
izquierda.
Métodos
Si creamos una función dentro de una clase, ésta recibe el nombre de método. La idea es
que las acciones que un objeto puede realizar, sean definidas en la clase como métodos.
Si volvemos a ver nuestra clase producto, nos damos cuenta que podemos hacer algo
como lo siguiente:
$p->cantidad = 5;
Como la propiedad $cantidad es pública, podemos obtener su valor y también
establecerlo. Esto es un error, ya que no deberíamos poder modificar la cantidad de un
determinado producto. Para solucionar este problema, tenemos que hacer dos cosas:
1) No permitir acceder a la propiedad desde fuera de la clase, utilizando el modificador de
visibilidad private:
class Producto
{
private $cantidad = 4;
}
Si queremos ejecutar el ejemplo de nuevo, obtendremos un error como el siguiente:
Las variables privadas no pueden ser accedidas por fuera de la clase.
2) Agregar un método que nos permita saber la cantidad de un producto
class Producto
{
private $cantidad = 4;
public function getCantidad()
{
return $this->cantidad;
}
}
Creamos una función que llama a la propiedad a través de la variable $this. La
variable $this permite al objeto referenciarse a si mismo.
Para poder mostrar por pantalla la cantidad de ruedas, escribimos el siguiente código:
$p = new Producto;
echo $p->getCantidad();

UNASAM
Programacion III
Es una convención definir los métodos que retornan el valor de una propiedad (getter) con
el prefijo "get" y a los que establecen el valor de una propiedad (setter) con el prefijo
"set".
Supongamos que queremos establecer el nombre del propietario de un auto. Para eso
vamos a crear una nueva propiedad llamada $propietario y dos métodos: un get y un
set.
class Producto{
private $codigo='';
private $descripcion='';
private $precio=0;
private $stock=0;
//Implementación de los métodos SET
public function setCodigo($codigo){
$this->código=$codigo;
}
public function setDescripcion($descripcion){
$this->descripcion=$descripcion;
}
public function setPrecio($precio){
$this->precio=$precio;
}
public function setStock($stock){
$this->stock=$stock;
}
//Implementación de los métodos GET
public function getCodigo(){
return $this->codigo;
}
public function getDescripcion(){
return $this->descripcion;
}
public function getPrecio(){
return $this->precio;
}
public function getStock(){
return $this->stock;
}
}
$p = new Producto;
echo "Cantidad : " . $p->getCantidad() . "<br />";
echo $p-> setDescripcion("Impresora");
echo "Producto: " . $p->getDescripcion();
Constructores y Destructores
Cuando se instancia un objeto, generalmente es deseable dejar todas las propiedades del
mismo en un estado consistente. Para manejar esto, PHP ofrece un método

UNASAM
Programacion III
llamado __construct() (doble guión bajo), que se llama automáticamente cuando se crea
un nuevo objeto. Este método forma parte de los denominados "métodos mágicos" que
PHP posee para hacer más simple el uso de los objetos.
class Producto{
private $codigo='';
private $precio=0;
private $stock=0;
public function __construct()
{
$this->codigo = "P0001”;
$this->descripcion = “Impresora”;
$this->precio = 4;
$this->stock = 90;
}
//Getters y Setters
}
De esta forma, podemos acceder a la propiedad sin indicar un propietario para ella,
estamos seguros que va a poseer un valor que tenga sentido. También indicamos cuál es
el valor para la propiedad $descripcion ya que toda inicialización de variables debería
hacerse en el constructor.
De la misma forma que existen los constructores, existen los destructores,
denominados __destruct(). Estos métodos se utilizan para limpiar el objeto y liberar
todos los recursos que pudieron ser abiertos por el mismo (archivos, bases de datos,
etc.). Estos métodos se ejecutan cuando finaliza la ejecución del script. Para ver un
ejemplo, agreguemos un destructor que informe que se ejecutó (para poder ver su
funcionamiento).
class Producto{
private $codigo='';
private $precio=0;
private $stock=0;
public function __construct()
{
$this->codigo = "P0001”;
$this->descripcion = “Impresora”;
$this->precio = 4;
$this->stock = 90;
}
//Getters y Setters
public function __destruct()
{
echo 'El objeto fue destruido';

UNASAM
Programacion III
}
}
También es posible destruir un objeto de manera explícita utilizando la función unset().
unset($p);
Conexión a MySQL mediante PDO
PHP dispone de una serie de funciones "mysql_...()" y "mysqli_...()" para acceder a datos
almacenados en una base de datos MySQL; sin embargo, este tipo de funciones no son el método
más aconsejable de acceder a MySQL: adolecen de problemas de rendimiento, seguridad y
soporte, y poco a poco irán quedando obsoletos.
En la actualidad, PHP ofrece un método más conveniente para acceder a bases de datos MySQL,
y es PDO (PHP Data Objects). Algunas de sus ventajas sobre las clásicas funciones "mysql_...()"
son:
 Interfaz más elegante, basado en objetos.
 Compatibilidad con diversos motores de bases de datos, no sólo MySQL.
 Mayor seguridad a la hora de construir consultas SQL.
 Compatibilidad con herramientas avanzadas de bases de datos: procedimientos
almacenados, transacciones, sentencias preparadas...
 Mejor rendimiento y optimización frente a las funciones clásicas de PHP.
 Gestión de errores más conveniente.
A continuación mostraremos unos ejemplos básicos de la utilización de PDO.
Para establecer una conexión con una base de datos MySQL:
$usuario_db = "user";
$pass_db = "passwd";
$db = new PDO('mysql:host=localhost;dbname=bdtest;charset=utf8', $usuario_db, $pass_db);
Una consulta SQL sencilla, con gestión de errores:
try {
$statement = $db->query("SELECT * FROM tabla");
$resultados = $statement->fetchAll(PDO::FETCH_OBJ);
} catch (PDOException $e) {
echo $e->getMessage();
}
Es interesante especificar un modo de obtención de resultados ("PDO::FETCH_OBJ" para obtener
objetos, "PDO::FETCH_ASSOC" para obtener un array asociativo de valores, etc) para evitar que
las funciones "fetch()" y "fetchAll()" del objeto PDOStatement devuelvan datos duplicados.
Para el caso de sentencias INSERT, UPDATE o DELETE:

UNASAM
Programacion III
$resultado = $db->exec("INSERT INTO tabla (col1, col2, col3) VALUES('A', 'B', 'C')");
$ultimo_id = $db->lastInsertId();
Para ejecutar varias sentencias SQL en una misma transacción:
try {
$db->beginTransaction();
//Aquí irían las sentencias SQL a ejecutar, usando por supuesto las funciones de los objetos
PDO correspondientes
$db->commit();
} catch (PDOException $e) {
$db->rollBack();echo $e->getMessage();
}
La Clase PDO
PDO::beginTransaction — Inicia una transacción
PDO::commit — Consigna una transacción
PDO::__construct — Crea una instancia de PDO que representa una conexión a una base de datos
PDO::errorCode — Obtiene un SQLSTATE asociado con la última operación en el manejador de la base de
datos
PDO::errorInfo — Obtiene información extendida del error asociado con la última operación del manejador de
la base de datos
PDO::exec — Ejecuta una sentencia SQL y devuelve el número de filas afectadas
PDO::getAttribute — Devuelve un atributo de la conexión a la base de datos
PDO::getAvailableDrivers — Devuelve un array con los controladores de PDO disponibles
PDO::inTransaction — Comprueba si una transacción está activa
PDO::lastInsertId — Devuelve el ID de la última fila o secuencia insertada
PDO::prepare — Prepara una sentencia para su ejecución y devuelve un objeto sentencia
PDO::query — Ejecuta una sentencia SQL, devolviendo un conjunto de resultados como un objeto
PDOStatement
PDO::quote — Entrecomilla una cadena de caracteres para usarla en una consulta
PDO::rollBack — Revierte una transacción
PDO::setAttribute — Establece un atributo
La Clase PDOStatement
PDOStatement::bindColumn — Vincula una columna a una variable de PHP
PDOStatement::bindParam — Vincula un parámetro al nombre de variable especificado
PDOStatement::bindValue — Vincula un valor a un parámetro
PDOStatement::closeCursor — Cierra un cursor, habilitando a la sentencia para que sea ejecutada otra vez
PDOStatement::columnCount — Devuelve el número de columnas de un conjunto de resultados
PDOStatement::debugDumpParams — Vuelca un comando preparado de SQL
PDOStatement::errorCode — Obtiene el SQLSTATE asociado con la última operación del gestor de sentencia
PDOStatement::errorInfo — Obtiene información ampliada del error asociado con la última operación del
gestor de sentencia

UNASAM
Programacion III
PDOStatement::execute — Ejecuta una sentencia preparada
PDOStatement::fetch — Obtiene la siguiente fila de un conjunto de resultados
PDOStatement::fetchAll — Devuelve un array que contiene todas las filas del conjunto de resultados
PDOStatement::fetchColumn — Devuelve una única columna de la siguiente fila de un conjunto de resultados
PDOStatement::fetchObject — Obtiene la siguiente fila y la devuelve como un objeto
PDOStatement::getAttribute — Recupera un atributo de sentencia
PDOStatement::getColumnMeta — Devuelve metadatos de una columna de un conjunto de resultados
PDOStatement::nextRowset — Avanza hasta el siguiente conjunto de filas de un gestor de sentencia
multiconjunto de filas
PDOStatement::rowCount — Devuelve el número de filas afectadas por la última sentencia SQL
PDOStatement::setAttribute — Establece un atributo de sentencia
PDOStatement::setFetchMode — Establece el modo de obtención para esta sentencia
PDOException — La clase PDOException
EJEMPLO PRACTICO
Crear la siguiente Base de Datos
Creamos una Clase Pojo.
<?php
class Producto {
private $codigo = '';
private $descripcion = '';
private $precio = 0;
private $stock = 0;
private $imagen;
public function __construct($cod, $des, $pre, $sto, $img) {
$this->codigo = $cod;
$this->descripcion = $des;
$this->precio = $pre;
$this->stock = $sto;
$this->imagen = $img;
}
// Implementación de los métodos SET
public function setCodigo($codigo) {
$this->código = $codigo;
}
public function setDescripcion($descripcion) {
$this->descripcion = $descripcion;
}
public function setPrecio($precio) {
$this->precio = $precio;
}

UNASAM
Programacion III
public function setStock($stock) {
$this->stock = $stock;
}
public function setImagen($imagen) {
$this->imagen = $imagen;
return $this;
}
// Implementación de los métodos GET
public function getCodigo() {
return $this->codigo;
}
public function getDescripcion() {
return $this->descripcion;
}
public function getPrecio() {
return $this->precio;
}
public function getStock() {
return $this->stock;
}
public function getImagen() {
return $this->imagen;
}
}
?>
Creamos una Clase para realizar la conexión llamada conex
<?php
class conex
{
public $db;
private static $dns = "mysql:host=localhost;dbname=Ventas";
private static $user = "root";
private static $pass = "abcd";
private static $instance;
public function __construct ()
{
$this->db = new PDO(self::$dns,self::$user,self::$pass);
}
public static function getInstance()
{
if(!isset(self::$instance))
{
$object= __CLASS__;
self::$instance=new $object;
}
return self::$instance;
}
}
?>

UNASAM
Programacion III
isset — Determina si una variable está definida y no es NULL
self y parent
Cuando queramos acceder a una constante o método estático desde dentro de la clase, usamos
la palabra reservada: self.
Cuando queramos acceder a una constante o método de una clase padre, usamos desde la clase
extendida la palabra reservada: parent. Un caso típico es cuando en una clase extendida se
sobreescribe el mismo método eliminando las definiciones y cambiando su visibilidad del método
de la clase padre, como en el ejemplo anterior.
__CLASS__
Nombre de la clase. El nombre de la clase incluye el namespace.
Captación de filas o columnas de conjuntos de
resultados en PHP (PDO)
Después de ejecutar una sentencia que devuelve uno o más conjuntos de
resultados, utilice uno de los métodos disponibles en la API de PDO para iterar
por las filas devueltas. La API de PDO ofrece también métodos para captar una
única columna de una o varias filas en el conjunto de resultados.
Antes de empezar
Debe tener un recurso de sentencia que haya devuelto el
método PDO::query o PDOStatement::execute que tenga asociados uno o
varios conjuntos de resultados.
Procedimiento
Para captar datos de un conjunto de resultados:
1. Capte los datos de un conjunto de resultados llamando a uno de los
métodos de captación:
o Para devolver una única fila de un conjunto de resultados como una
matriz u objeto, llame al métodoPDOStatement::fetch.
o Para devolver todas las filas del conjunto de resultados como una
matriz de matrices u objetos, llame al
métodoPDOStatement::fetchAll.
Por omisión, PDO devuelve cada fila como una matriz indexada por el
nombre de columna y la posición de columna indexada 0 en la fila. Para
solicitar un estilo de devolución diferente, especifique una de las

UNASAM
Programacion III
constantes PDO::FETCH_*como primer parámetro al llamar al
método PDOStatement::fetch:
PDO::FETCH_ASSOC
Devuelve una matriz indexada por nombre de columna tal y como se ha
devuelto en el conjunto de resultados.
PDO::FETCH_BOTH (valor por omisión)
Devuelve una matriz indexada tanto por nombre de columna como por
número de columna indexado 0 en el conjunto de resultados
PDO::FETCH_BOUND
Devuelve TRUE y asigna los valores de las columnas del conjunto de
resultados a las variables de PHP a las que estaban vinculadas con el
método PDOStatement::bindParam.
PDO::FETCH_CLASS
Devuelve una nueva instancia de la clase solicitada, correlacionando las
columnas del conjunto de resultados con las propiedades con nombre de
la clase.
PDO::FETCH_INTO
Actualiza una instancia existente de la clase solicitada, correlacionando
las columnas del conjunto de resultados con las propiedades de la clase.
PDO::FETCH_LAZY
Combina PDO::FETCH_BOTH y PDO::FETCH_OBJ, creando los nombres
de variable de objeto conforme se accede a los mismos.
PDO::FETCH_NUM
Devuelve una matriz indexada por número de columna tal y como se ha
devuelto en el conjunto de resultados, empezando en la columna 0.
PDO::FETCH_OBJ
Devuelve un objeto anónimo con nombres de propiedad que se
corresponden con los nombres de columna devueltos en el conjunto de
resultados.

Intro aplicaciones web con php

Más contenido relacionado

La actualidad más candente (20)

Similar a Intro aplicaciones web con php (20)

Último (20)

Intro aplicaciones web con php