1 PHP Instrucciones Merged

Acceso a datos.
PHP Página 1
los bloques de código de PHP están delimitados con <?php y ?>.
<?php echo "Hola <br>";

$MYVAR = 1234;
$myvar = 4321;
echo $MYVAR."<br>" ;
echo $myvar;
?>
Guardarlo como primero.php en c:\xampp\htdocs o en c:\wamp\www y visualizarlo http://localhost/primero.php
Se pueden mezclar con HTML. Dentro del bloque php el código html siempre entre “ ”
<HTML>
<HEAD>
<TITLE>Título del documento</TITLE>
</HEAD>
<BODY>
<h1>Cabecera H1</h1>
<?php echo "Hola" ?>
<h1>Cabecera H1 segunda</h1>
<?php
$MYVAR = 1234;
$myvar = 4321;
echo $MYVAR. "<br>"; // los nombres de variables distingue entre mayúsculas y minúsculas
echo $myvar. "<br>";
print "variable myvar : $myvar"; //sirve con print o con echo
echo "variable MYVAR: $MYVAR ";
echo "<br> variable myvarb: $myvar";
// Este programa presenta en pantalla unos números

?>
</BODY>
</HTML>
Guradarlo como segundo.php y visualizarlo http://localhost/segundo.php cuidado con las comillas,
borrarlas y volver a ponerlas pues al hacer copiar y pegar pueden fallar.
los nombres de variables siempre deben empezar con $, diferencian mayúsculas y minúsculas.
para concatenar texto (las variables y “<br>“) utilizamos el carácter punto “.” o la coma ,
todas las sentencias terminan con “;”.
Comentarios
// Comentario de una sola línea
/* Esto es un comentario de varias líneas.
Para ello usamos este otro marcador
de inicio y final de comentario */
no precisa que declaremos a priori la variable que vamos a usar ni el tipo de ésta. PHP declarará la variable y le asignará el
tipo de datos correcto en el momento en que la usemos por primera vez
¿Comilla simples o dobles? Lo que hacen las comillas dobles es reemplazar las variables por su valor. En cambio las
comillas simples no leen el valor de las variables, solo entregan texto plano. Las simples son más rápidas aunque no
creo que se note demasiado en el rendimiento.
$variable="Cielo";
echo "El $variable es azul"; // El Cielo es azul aquí si quiero visualizar una comilla
simple como texto la pongo sin más
echo 'El $variable es azul'; // El $variable es azul
echo 'El '.$variable.' es azul'; // El Cielo es azul si aquí quiero poner comilla simple
como texto debo poner \'
Los tipos de datos en PHP son: Boolean , Integer, Double, String, Array, Object
Variables vectores o arrays

<?php
$mares = array(); //con array() declaramos un vector
$mares[0]= “Mediterráneo”;
$mares[1] = “Aral”;
$mares[2] = “Muerto”; ?>
Acceso a datos. PHP Página 2
Operadores matemáticos:
a) + Suma varios números: 5 + 4 = 9.
b) Resta varios números: 5 - 4 = 1.
c) * Realiza una multiplicación: 3 * 3 = 9.
d) / Realiza una división: 10/2 = 5.
e) % Devuelve el residuo de una división: 10 % 3 = 1.
f) ++ Incrementa en 1: $v++ (Incrementa $v en 1).
g) Decrementa en 1: $v-- (Decrementa $v en 1).
Operadores de comparación:
a) == Evalúa a cierto si la condición de igualdad se cumple: 2 == 2 (Verdadero).
b) != Evalúa a cierto si la condición de igualdad no se cumple 2 != 2 (Falso).
c) < Evalúa a cierto si un número es menor que el otro. 2 < 5(Verdadero).
d) > Evalúa a cierto si un número es mayor que el otro. 6 > 4 (Verdadero).
e) <=Evalúa a cierto si un número es menor o igual que otro. 2 <= 5 (Verdadero).
f) >=Evalúa a cierto si un número es mayor o igual que otro. 6 >= 4 (Verdadero).
• Operadores lógicos:
a) && Evalúa a cierto si los dos operadores son ciertos.
b) || Evalúa a cierto si alguno de los operadores es cierto.
c) And Evalúa a cierto si los operadores son ciertos.
d) Or Evalúa a cierto si alguno de los operadores es cierto.
e) Xor Evalúa a cierto si o un operador es cierto o lo es el otro.
f) ! Invierte el valor de verdad del operador.
Estructuras de control
If
Podemos, pues, definir la estructura de if/else como:
if(condición)
{
código que se ejecutará si la condición es cierta
}
else
{
código que se ejecutará si la condición es falsa
}
<?php
if($a>$b){
echo "a es mayor que b";
} elseif ($a == $b){
echo "a es igual que b";
} else {
echo "a es menor que b";
}
?>
switch.
<?php
$a=1;
switch($a)0791/00021
{
case 1:
case 2: echo “A es 1 o 2”; break;
case 3: echo “A es 3”; break;
default: echo “A es otro valor”;
}
El bucle while
<?php
$a = 1;
while($a < 4)
{
echo “a=$a<br>“;
$a++;
}
?>
El bucle for
El código anterior, usando for quedaría de la forma:
<?php
for($a=1;$a < 4; $a++)
{
echo “a=$a<br>“;
}
?>
foreach
Para aquellos casos en los que queremos que nuestro bucle haga un recorrido sobre los elementos de un vector disponemos de
una sentencia que nos simplifica este hecho: foreach asigna a una variable v uno a uno todos los valores de un vector a.
<?php
$a = array (1, 2, 3, 17);
foreach ($a as $v)
{
print "Valor: ".$v. "<br>";
}
?>
Funciones
<?php
function suma ($a1, $a2)
{
$retorno=$a1+$a2;
return $retorno;
}
function sumatorio ($b1, $b2, $b3)
{
for($i=$b1;$i<$b2;$i++)
{
$res=suma($res,$b3);
}
return $res;
}
echo sumatorio(1,3,2);
?>
Las funciones en PHP reciben habitualmente los parámetros por valor, es decir, la variable que se pasa como parámetro en el
código que llama no sufre modificaciones si el parámetro de la función es modificado.
Podemos, no obstante, pasar parámetros por referencia (de forma similar a los punteros de otros lenguajes de programación):
<?php
function modifi (&$a1, $a2) //VEr el & del parámetro a1 indica que se pasa por referencia
{
$a1=0;
$a2=0;
}
$b1=1;
$b2=1;
print " valor antes de la llamada $b1 y el segundo $b2 <br>";
modifi($b1,$b2);
print " valor despues de la llamada $b1 y el segundo $b2 <br>";
echo "tambien con echo ".$b1." ".$b2;
?>
En este caso, el resultado del programa será:
valor antes de la llamada 1 y el segundo 1
valor después de la llamada 0 y el segundo 1
también con echo 0 1
Variables globales o estáticas

Distinguir entre variables estáticas (static) y globales (global).
Las variables estáticas se definen dentro de una función, la primera vez que es llamada dicha función la variable se
inicializa, guardando su valor para posteriores llamadas. Si yo modifico el valor fuera de la función no lo modifica.
<?php
function contador ()
{
static $count = 0;
$count = $count + 1;
return $count;
}
echo contador()."<BR>"; // imprimirá 1

?>
Las variables globales, lo que hacemos al llamar a una variable que ya ha sido declarada, tomando el valor que tenga en
ese momento, pudiendo ser modificado en la función o fuera de ella.
<?php
$a = 1;
function ver_a()
{
global $a;
echo $a."<BR>"; // imprimirá el valor de $a
$a += 1; // sumamos 1 a $a
}
echo ver_a(); // imprimirá 1
$a = 7;
?>
Funciones de cadena
strlen Devuelve la longitud de una cadena.
explode Divide una cadena en función de un carácter separador, y devuelve un vector con cada uno de los trozos de la
cadena.
implode Actúa al revés que explode, uniendo diversas cadenas de un vector con un carácter de unión.
strcmp Compara dos cadenas a nivel binario.
strtolower Convierte una cadena a minúsculas.
strtoupper Convierte una cadena a mayúsculas.
chop Elimina el último carácter de una cadena, útil para eliminar saltos de línea o espacios finales superfluos.
strpos Busca dentro de una cadena otra cadena especificada y devuelve su posición.
str_replace Reemplaza en una cadena una aparición de una subcadena por otra subcadena.
Podemos ver el funcionamiento de algunas de estas funciones en el
siguiente ejemplo:
<?php
$cadena1 = 'hola';
echo "cadena1: $cadena1 <br>";
$cadena2 = 'pera,manzana,fresa';
$longitud = strlen($cadena1); //longitud=4

echo "longitud cadena1:$longitud <br>";
echo "cadena1=hola su longitud es : ".$longitud;

$partes = explode(',',$cadena2);
//genera el array $partes con $partes[0]=“pera”,
//$partes[1]=“manzana”; y $partes[2]=“fresa”;
echo "dividida: $partes[0] <br>";

$cadena3 = str_replace(',','-',$cadena2);
//$cadena3 contiene: pera-manzana-fresa

//Cambiamos las , por –*/
echo "cadena 3 : $cadena3 <br>"
?>
Acceso a ficheros
PHP proporciona un amplio repertorio de métodos para el acceso a ficheros. Vamos a mostrar la más práctica y simple, muy
adecuada si los ficheros a los que accederemos son pequeños.
El código que comentaremos es el siguiente:
<?php
$fichero = file('entrada.txt'); //carga el fichero en un vector
$numlin = count($fichero); //obtiene el numero de líneas del fichero
echo "numero de lineas del fichero $numlin <br>";
for($i=0; $i < $numlin; $i++)
{
echo "linea $i :$fichero[$i] <br>"; //visualiza cada linea
}
?>
En este ejemplo leemos un archivo que tiene por nombre entrada.txt y lo mostramos como salida.
declarar la variable fichero, lo que nos genera un vector en el que PHP colocará todas las líneas del archivo. Para ello
usaremos la función de librería file.
El siguiente paso consiste en averiguar cuántos elementos contiene fichero. Para ello usamos la función count, que nos
devuelve el tamaño de un vector, en este caso el vector que hemos generado al leer el fichero. Finalmente podemos escribir un
bucle que recorrerá el vector tratando cada una de las líneas del archivo.
Otro modo
<?php
$file = fopen("archivo.txt", "r"); // abre el fichero en modo lectura, “w” en escritura que sobreeescribe y “a” añade
While (! feof($file)) { // si no ha llegado al final del fichero
echo fgets($file). "<br />"; //lee una línea y le añade para la visualización un salto de línea según html
}
fclose ($file);
?>
<?php
//Ejemplo archivo escribir.php
$file = fopen("archivo.txt", "w"); //abre el fichero en escritura“w” en escritura que sobreeescribe y “a” añade
fwrite($file, "Esto es una nueva linea de texto". PHP_EOL); // PHP_EOL para que le ponga al texto el salto de linea
fwrite($file, "Otra más". PHP_EOL);
fclose($file);
?>
Incluir archivos
Requiere e include. La diferencia entre los dos es que si el fichero a incluir o requerir no existe con requiere dá error y con
include da un warnning. También existe requiere_once e include_once que solo incluyen el fichero una vez aunque en el
programa se encuentre en diversas posiciones, pero es más pesado en rendimiento que sin el once.
vars.php
<?php
$color ='verde';
$fruta ='manzana';
?>
test.php
<?php
echo "Una $fruta $color"; // Una
include 'vars.php';
echo "Una $fruta $color"; // Una manzana verde
?>
Pasar información con formularios
En el formulario en la instrucción form en action indicamos el fichero donde recogeremos los valores y en method con
post. Al recoger los valores en el otro fichero hacemos referencia a ellos con $_POST[‘nombre de variable’] o también
con _request.
<html>
<head>
<title>Please Log In</title>
</head>
<body>
<form method="post" action="recoge_variable_form.php">
<p>Enter your username:
<input type="text" name="uno"/>
</p>
<p>Enter your password:
<input type="text" name="pass"/>
</p>
<p>
<input type="submit" name="submit" value="Submit"/>
</p>
</form>
</body>
</html>
Fichero: recoge_variable_form.php
<?php
echo 'variables uno: ', $_POST['uno'];
echo '<br>variables pass: ', $_POST['pass'];
echo '<br>variables pass: ', $_REQUEST['pass'];
?>
La diferencia entre estos dos métodos GET/POST radica en la forma de enviar los datos a la página, mientras que el
método GET envía los datos usando la URL, el método POST los envía por la entrada estándar STDIO.
Si en lugar de POST pongo GET, se visualizan los valores en la barra del navegador y en el otro fichero al visualizarlas
tendrá que ser con GET o REQUEST.
$_REQUEST es un array que contiene todas las variables de los arrays $_GET, $_POST y $_COOKIE.
Es preferible usar cada uno de los contenedores anteriores individualmente porque permite "controlar" el origen de
las variables que paso a los scripts. De esta forma, se detectan posibles errores y cierro una puerta a posibles códigos
maliciosos.
Pasar variables por URL
pasar variables dentro del enlace hipertexto
Para pasar las variables de una página a otra lo podemos hacer introduciendo dicha variable dentro del enlace
hipertexto de la página destino. La sintaxis sería la siguiente:
<a href="destino.php?variable1=valor1&variable2=valor2&...">Mi enlace</a>
Podéis observar que estas variables no poseen el símbolo $ delante. Esto es debido a que en realidad este modo de
pasar variables no es específico de PHP sino que es utilizado por otros lenguajes.
Ahora nuestra variable pertenece también al entorno de la página destino.php y está lista para su explotación.
Nota: No siempre se definen automáticamente las variables recibidas por parámetro en las páginas web,
depende de una variable de configuración de PHP: register_globals, que tiene que estar activada para que
así sea. En el fichero php.ini poner register_globals=on
Para aclarar posibles dudas, veamos esto en forma de ejemplo. Tendremos pues dos páginas, origen.html (no es
necesario darle extensión PHP puesto que no hay ningún tipo de código) y destino.php:
<HTML>
<HEAD>
<TITLE>origen.html</TITLE>
</HEAD>
<BODY>
<a href="destino.php?saludo=hola&texto=Esto es una variable texto">Paso variables saludo y texto a la página
destino.php</a>
</BODY>
</HTML>
<HTML>
<HEAD>
<TITLE>destino.php</TITLE>
</HEAD>
<BODY>
<?php
echo "Variable \$saludo: ".$_GET['saludo']." <br>\n";
echo "Variable \$texto: ". $_GET['texto']." <br>\n";
?>
</BODY>
</HTML>
pasar variables con $_GET
_get es una matriz donde se almacenan los valores de las variables y para hacer referencia a uno de ellos es
_get[‘nombre_variable’]
echo '<br>Variable \$saludo:', $_GET['saludo'] ;

echo '<br>Variable \$texto:', $_GET['texto'] ;
Pasar variables con sesiones

Los métodos anteriores tienen el problema de la confidencialidad, todos las ven en la barra de direcciones del
navegador.
Una sesión es un conjunto de variables que solo existen hasta que se cierra el explorador. Cada sesión tiene un
identificador (ID). En cada fichero hay que abrir la sesión. Y debemos hacer referencia a las variables co
$_SESSION[‘nombre_variable’]
<?php
session_start();
$_SESSION['username'] = "pepe";
$_SESSION['authuser'] = 1;
$_SESSION['otra'] = "otro valor";
$_SESSION['saludo']="*hola";
$_SESSION['texto']="esto es una variable texto";
?>
<a href="destino_sesion.php">Paso variables por sesion saludo y texto</a>;
Fichero destino_sesion.php
<?php
session_start();
//check to see if user has logged in with a valid password
if ($_SESSION['authuser'] !=1 ) {
echo "Sorry; but you don't have permission to view this page!";
exit();
}
echo 'variable'; /* no se puede acceder directamente como variables
echo $username;
echo $authuser; */
echo '<br>variable saludo', $_SESSION['saludo'];
echo '<br>variable texto:',$_SESSION['texto'];
echo '<br>variable sesion otra', $_SESSION['otra']
?>
Pasar variables con cookies.
Las cookies son fragmentos de información que se almacenan en el equipo de los usuarios del sitio web.
Para configurar las cookies hay que usar la función setcookie()
Setcookie
int setcookie ( string name, string value, int expire, string path, string domain, int secure)
setcookie() define una cookie para ser enviada con el resto de la información de la cabecera. Las cookies
deben enviarse antes de mandar cualquier otra cabecera (esta es una restricción de las cookies, no de PHP).
Esto requiere que sitúe las llamadas a esta función antes de cualquier etiqueta <html> o <head>.
Todos los parámetros excepto name son opcionales. Si sólo se especifica el parámetro name, la cookie con ese
nombre se borrará del cliente remoto. También puede sustituir cualquier parámetro por una cadena de texto
vacía ("") y saltar así ese parámetro. Los parámetros expire (tiempo en el que expira la cookie, en segundos)
y secure son números enteros y no se pueden saltar con una cadena de texto vacía. En su lugar utilice un cero
(0). El parámetro expire es un entero de tiempo típico de UNIX tal como lo devuelven las funciones time() o
mktime(). El parámetro secure indica que la cookie se debe transmitir única y exclusivamente sobre una
conexión segura HTTPS. Path indica la ruta en el servidor donde se almacenará. Domain el dominio para la
cual al cookie está disponible, por ejemplo www.example.com .
Fallos habituales:
Las cookies no se hacen visibles hasta la siguiente carga de una página para la que la cookie deba estar visible.
Las llamadas múltiples a setcookie() en el mismo script se ejecutarán en orden inverso. Si está intentando
borrar una cookie antes de insertar otra, debe situar la llamada de inserción antes de la de borrado.
A continuación se muestran algunos ejemplos::
<?php
setcookie('username','pepito',time()+60);
setcookie('authuser',1,time()+60);
setcookie('otra','valor de otravariable',time()+60);
?>
<a href="destino_cookie.php">Paso variables por sesion saludo y texto</a>;
Fichero destino_cookie.php
<?php
echo 'variables cookies';
echo $username; // esta línea y las dos siguientes dará error pues no se puede usar
como una variable , es una cookie
echo $authuser;
echo $otra;
echo '<br>variable saludo', $_COOKIE['username'];
echo '<br>variable texto:',$_COOKIE['authuser'];
echo '<br>variable sesion otra', $_COOKIE['otra']
Tenga en cuenta que el campo value de la cookie se codifica como URL automáticamente cuando envía la
cookie. Cuando ésta se recibe, se descodifica autómaticamente y se asigna a una variable con el mismo
nombre que el nombre de la cookie.
Desde una página que se cargue otra ( no puede ir después de un echo o print pues no se vería)
<?php
header(‘location:pagina.html’);
?>
Ver todos los valores pasados como parámetros de un formulario.

<?php
print_r($_REQUEST);
?>
Array ( [nombre_parametro1] => valor [nombre_parametro2] => valor )
En ocasiones nos interesa poner campos de un formulario a hidden asignándole un valor para no visualizar
esos valores en el formulario pero si pasarlos al otro programa que los necesita.
<input type=”hidden” name=”nombre” value=” “>
isset (mixed variable [, mixed variable [, ...]])

Determina si una o más variables están definidas o no contienen el valor NULL. Devuelve true si lo están o
false en caso contrario.
Solo debe ser utilizado con variables. Si se le pasa como parámetro una constante devolverá un error.
if (isset($nombre) && $nombre!="") {

echo "Hola $nombre, bienvenido a PHP";}
else {
echo "No has escrito nada"; }
PHP Orientado a Objetos Página 1
Tabla de contenido
• · Clases y Objetos
• · Métodos y atributos
• · Constructores
• . Herencia de clases
• . Clonación de objetos
Clases y Objetos
class [Nombre de la Clase] {
[atributos]
[métodos]
}
Métodos y atributos
Atributos
Métodos, que programaremos como funciones usando function.
Como llamar a los métodos
[nombre del objeto]->[nombre del método]
Es decir antecedemos al nombre del método el nombre del objeto y el operador ->
Ahora bien que pasa si queremos llamar dentro de la clase a otro método que pertenece a la misma
clase, la sintaxis es la siguiente:
$this->[nombre del método]
Ejemplo:
<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php
class Persona {
private $nombre;
public function inicializar($nom)
{
$this->nombre=$nom;
}
public function imprimir()
{
echo $this->nombre;
echo '<br>';
}
}
$per1=new Persona();
$per1->inicializar('Juan');
$per1->imprimir();
$per2=new Persona();
$per2->inicializar('Ana');
$per2->imprimir();
?>
</body>
</html>
PHP Orientado a Objetos Página 2
Constructor
También podemos hacerlo utilizando el constructor, definiremos el método con nombre __constructor( )
<html>
<head>
<title>Pruebas</title>
</head>
<body>
<?php /* programa en php usando clases y el constructor */
class Persona {
private $nombre;
public function __construct($nom) //ojo el constructor tiene delante 2 _
{
$this->nombre=$nom;
}
public function imprimir()

{
echo this->nombre;
echo '<br>';
}
}
$per1=new Persona('Juan'); //creamos el objeto y lo inicializamos de una vez

$per1->imprimir();
$per2=new Persona('Ana');
$per2->imprimir();
?>
</body>
</html>
Herencia de clases
Utilizando extends
<?php
class profe extends Persona{
}
$profe1=new profe('Betty');
$profe1 ->imprimir();
?>
Clonación de objetos
Si queremos crear un nuevo objeto idéntico a uno ya existente debemos emplear el operador clone.
Para crear un segundo objeto y clonarlo del objeto referenciado por $persona1:
$persona2=clone($persona1);
Acceso a bases de datos con PHP
Procedimientos con PDO
1.- Conectar a la base de datos usando try/catch.

$pdo = new PDO("mysql:host=$host;dbname=$dbname, $user, $pass");
$pdo
Objeto conexión
2.- Preparar la consulta (insert,update,delete).

2.1.- Preparar la consulta:
$stmt = $pdo->prepare("INSERT INTO alumnos( nombre, apellidos) values ( 'Taylor','Swift' )");
$stmt = $pdo->prepare("INSERT INTO colegas (name, addr, city) values (?, ?, ?)");
$stmt = $pdo->prepare("INSERT INTO colegas (name, addr, city) value (:name, :addr, :city)");
2.2.- Asignar parámetros en la consulta:

$stmt->bindParam(':name', $name);
$name='Pepito';
$datos = array('Cathy', '9 Dark and Twisty Road', 'Cardiff');

$datos = array( 'name' => 'Cathy', 'addr' => '9 Dark and Twisty', 'city' => 'Cardiff' );
$stmt = $pdo->prepare("INSERT INTO colegas (name, addr, city) value (:name, :addr, :city)");
2.3.- Ejecutar la consulta

$stmt->execute();
$stmt->execute($datos);
2.- Preparar la consulta (select).

2.1.- Preparar la consulta:
$stmt = $pdo->query('SELECT name, addr, city from colegas'); (si no tenemos parámetros la ejecutamos con
->query)
$stmt = $pdo->prepare('SELECT name, addr, city from colegas where city =:ciudad'); (con parámetros)
$datos = array( 'ciudad' => 'Santiago');
2.2.- Leemos los datos del recordset (conjunto de registros) que nos devuelve SELECT en el objeto
PDOStatement.
2.2.1.- Se puede leer cada fila del recordset con ->fetch() del objeto PDOStatement o mediante ->fetchAll()
(obtiene todas las filas del recordset).
while($row = $stmt->fetch()) {
echo $row['name'] . "<br/>";
echo $row['addr'] . "<br/>";
echo $row['city'] . "<br/>";
}
$row = $sql->fetchAll();
foreach($data as $row)
$id = $row['id'];
$content = $row['content'];
}
3.- Cerrar la conexión.

$pdo = null;
Rafa Veiga 2014-2015
http://manuais.iessanclemente.net
Acceso a datos. PHP. Acceso a Mysql con PDO Página 1
La extensión PDO (PHP Data Objects) permite acceder a distintas bases de datos utilizando las misma
funciones, lo que facilita la portabilidad.
Conexión con la base de datos

Para conectar con la base de datos hay que crear una instancia de la clase PDO, que se utiliza en todas las
consultas posteriores. En cada página php que incluya consultas a la base de datos es necesario conectar
primero con la base de datos.
Si no se puede establecer la conexión con la base de datos, puede deberse a que la base de datos no esté
funcionando, a que los datos de usuario no sean correctos, a que no esté activada la extensión pdo
Conexión con MySQL
En el caso de MySQL, para crear el objeto PDO se necesita proporcionar el nombre del servidor, el nombre de
usuario y la contraseña.
Para poder acceder a MySQL mediante PDO, debe estar activada la extensión php_pdo_mysql en el archivo
de configuración php.ini
// FUNCIÓN DE CONEXIÓN CON LA BASE DE DATOS MYSQL

function conectaDb()
{
try { # MySQL con PDO_MYSQL
# Para que la conexion al mysql utilice las collation UTF-8 añadir charset=utf8 al string
de la conexion.
$pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8", $user, $pass);
# Para que genere excepciones a la hora de reportar errores.

$pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
}
catch(PDOException $e) {
echo $e->getMessage();
}}
} return $pdo ;
}
// EJEMPLO DE USO DE LA FUNCIÓN ANTERIOR
// La conexión se debe realizar en cada página que acceda a la base de datos
$db = conectaDB();
Desconexión con la base de datos

Para desconectar con la base de datos hay que destruir el objeto PDO. Si no se destruye el objeto PDO, PHP
lo destruye al terminar la página. Se recomienda cerrar siempre la conexión a la base de datos cuando no se
vaya a utilizar más durante nuestro proceso.
Al cerrar la conexión de forma explícita aceleramos la liberación de recursos para que estén disponibles para
otros usuarios.
$db = null;
Consultas a la base de datos

Una vez realizada la conexión a la base de datos, las operaciones se realizan a través de consultas.
El método para efectuar consultas es PDO->query($consulta), que devuelve el resultado de la consulta en una
variable de tipo especial llamado recurso que no se puede acceder directamente, pero que se puede recorrer
con un bucle foreach() , fetch() , while ….
// EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS
$stmt = $pdo->query('SELECT * from cliente where id_cliente = '."$codigo"); // con

variables, sin parametros
echo $row['id_cliente'] . "<br/>"; //siendo id_cliente y nombre los campos de la
base de datos
echo $row['nombre'] . "<br/>";
}
Estas instrucciones permiten la inyección de sql pues si yo en lugar de un codigo introduzco 1 or 1=1 ; --
visualiza todos los datos en lugar de solo el registro que se solicita.
Para evitar esto tenemos las sentencias preparadas
Consultas preparadas
Una consulta preparada es una sentencia SQL precompilada que se puede ejecutar múltiples veces
simplemente enviando datos al servidor.
ATENCIÓN: EL USO DE CONSULTAS PREPARADAS CON PREPARE NOS AYUDARÁ A

EVITAR LA INYECCIÓN SQL, CON LO QUE RECOMENDAMOS USAR ->prepare()
Para construir una sentencia preparada hay que hacerlo incluyendo unos marcadores en nuestra sentencia
SQL.
Ejemplos de como hacerlo:
# Marcadores anónimos
# Marcadores conocidos
$stmt = $pdo->prepare("INSERT INTO colegas (name, addr, city) values (:name, :addr,
:city)");
# Aquí no lleva marcadores - ideal para una inyección SQL! ('''no usar este método''').
!! Hay que usar los marcadores !!
$stmt = $pdo->prepare("INSERT INTO colegas (name, addr, city) values ($name, $addr,
$city)");
Deberás usar el primer o segundo método de los mostrados anteriormente. La elección de usar marcadores
anónimos o conocidos afectará a cómo se asignan los datos a esos marcadores.
Asignación con marcadores anónimos
Para vincular los marcadores anónimos con su correspondiente valor se puede utilizar bindParam o
bindValue:
# Asignamos variables a cada marcador, indexados del 1 al 3

$stmt->bindParam(1, $name);
$stmt->bindParam(2, $addr);
$stmt->bindParam(3, $city);
# Insertamos una fila.

$name = "Daniel"
$addr = "1 Wicked Way";
$city = "Arlington Heights";
$stmt->execute();
# Insertamos otra fila con valores diferentes.

$name = "Steve"
$addr = "5 Circle Drive";
$city = "Schaumburg";
$stmt->execute();
Otra forma de asignación con marcadores anónimos a través de un array asociativo:
# Los datos que queremos insertar

$datos = array('Cathy', '9 Dark and Twisty Road', 'Cardiff');
Diferencia entre el uso de bindParam y bindValue
• Con bindParam se vincula la variable al parámetro y en el momento de hacer el execute es cuando se asigna
realmente el valor de la variable a ese parámetro.
• Con bindValue se asigna el valor de la variable a ese parámetro justo en el momento de ejecutar la instrucción
bindValue.
Ejemplo de diferencia entre bindParam y bindValue:
// Ejemplo con bindParam:

$sex = 'hombre';
$s = $dbh->prepare('SELECT name FROM studiantes WHERE sexo = :sexo');
$s->bindParam(':sexo', $sexo);
$sex = 'mujer';
$s->execute(); // se ejecutó con el valor WHERE sexo = 'mujer'
// El mismo ejemplo con bindValue:

$sex = 'hombre';
$s = $dbh->prepare('SELECT name FROM students WHERE sexo = :sexo');
$s->bindValue(':sexo', $sexo);
$sex = 'mujer';
$s->execute(); // se ejecutó con el valor WHERE sexo = 'hombre'
Asignación con marcadores conocidos
Los marcadores conocidos es la forma más recomendable de trabajar con PDO, ya que a la hora de
hacer el bindParam o el bindValue se puede especificar el tipo de datos y la longitud máxima de los
mismos.
Formato de bindParam con marcadores conocidos:
bindParam(':marcador', $variableVincular, TIPO DATOS PDO)
Ejemplo de uso de bindParam:
$stmt->bindParam(':calorias', $misCalorias, PDO::PARAM_INT);

$stmt->bindParam(':apellidos', $misApellidos, PDO::PARAM_STR, 35);
Ejemplo
$stmt = $pdo->prepare('SELECT * from cliente where id_cliente =:cliente or nombre=:nomcliente');
$stmt->bindparam(":cliente", $codigo,PDO::PARAM_INT);
$stmt->bindparam(":nomcliente", $nombre,PDO::PARAM_STR, 30);
$stmt->execute(); //ejecuto
echo $row['id_cliente'] . "<br/>";
echo $row['nombre'] . "<br/>"; }
Otra forma:
$stmt = $pdo->prepare('SELECT * from cliente where id_cliente =:cliente or nombre=:nomcliente');

//(con parámetros)
$datos = array( 'cliente' => $codigo, 'nomcliente'=> $nomcliente); // asigno los parametros con
sus valores
echo $stmt->rowCount(); // indica el numero de registros afectado por la ultima

instrucción ejecutada.
Utilizando Objetos:
try{ # Creamos la consulta
$stmt = $pdo->query('SELECT * from cliente' );
# Ajustamos el modo de obtención de datos, los resultados los tendremos en objetos

$stmt->setFetchMode(PDO::FETCH_OBJ);
# Mostramos los resultados.

# Fijaros que se devuelve un objeto cada vez que se lee una fila del recordset.
echo $row->id_cliente . "<br/>";
echo $row->nombre . "<br/>";
}
# Liberamos los recursos utilizados por $stmt
$stmt=null;
}
catch(PDOException $err)
{
// Mostramos un mensaje genérico de error.
echo "Error: ejecutando consulta SQL."; }
Acceso a datos. Programa de PHP y base de datos Productos
Realizar en PHP sobre la base de datos de bdProductos:
Consulta, alta, baja y modificación de la tabla productos, teniendo en

cuenta que deberá aparecer un combo en familia donde visualizaremos
las familias que existen en la tabla familia (el combo se actualizará de
forma automática con la tabla familias existentes de la tabla
correspondiente).
Los datos de conexión con la base de datos estarán en un solo fichero.
Al eliminar un producto tendrás que confirmar el producto que vas a

eliminar, mostrando sus datos.
Al modificar deberán aparecer los datos que tenga el producto que vas
a actualizar, solo escribirás los valores que modifiques.
Añade las opciones necesarias para utilizar los procedimientos y

funciones creados en mysql.
Cada vez que se pueda utilizar un combo deberás hacerlo.
Es obligatorio que utilices varias ventanas y que se pasen datos entre

ellas, también es obligatorio utilizar alguna tabla para la visualización.
Si quieres puedes añadir más opciones al programa.
En cada ventana deberá aparecer tu nombre.
Es obligatorio presentar un documento con todas las pantallas de tu

programa, previamente a la creación del programa.
Acceso a datos. Mysql y PHP. Procedimientos Almacenados y Funciones
Uso de los procedimientos almacenados y Funciones de Mysql desde php
Procedimientos que visualizan registros

Call pListaRegistros(:parametroEntrada) en lugar del select,
$stmt = $pdo->prepare("Call pListaRegistros(:parametroEntrada)"); el resto igual , asociar el parámetro con

bindParam, ejecutar y recorrer el resultado.
Procedimientos que devuelven valores en parámetros de salida

Ojo, los parámetros de salida deben tener el mismo nombre que en el procedimiento y se le antepone el símbolo@.
Tendremos que hacer la ejecución del Call y la del Select
Call nombreProcedimiento(parametroSalida);
Select @parametroSalida;
$stmt = $pdo->prepare('Call pDevuelveValores(:parámetroEntrada, @parametroSalida)');

$stmt->bindParam(': parámetroEntrada', $valordelparámetroEntrada);
$stmt->execute(); //ejecuto
$stmt=$pdo->query('select @parametroSalida as parametroSalida');
$row = $stmt->fetch();
echo $row['parametroSalida'] ;
Procedimientos que ejecutan acciones

Call procedimiento( :parametroentrada )
Asignacion de parámetros
Ejecutar.
Funciones que retornan un valor

Select nombrefuncion(:parametroentrada)
Asigno parámetro
Ejecuto
Recorro

1 PHP Instrucciones Merged

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

1 PHP Instrucciones Merged

Cargado por

Copyright:

Formatos disponibles

Acceso a datos.

los bloques de código de PHP están delimitados con <?php y ?>.

<?php echo "Hola <br>";

// Este programa presenta en pantalla unos números

Variables vectores o arrays

Variables globales o estáticas

echo contador()."<BR>"; // imprimirá 1

$longitud = strlen($cadena1); //longitud=4

echo "cadena1=hola su longitud es : ".$longitud;

echo "cadena2: $cadena2 <br>";

echo "dividida: $partes[0] <br>";

//$cadena3 contiene: pera-manzana-fresa

El código que comentaremos es el siguiente:

Pasar información con formularios

pasar variables dentro del enlace hipertexto

<a href="destino.php?variable1=valor1&variable2=valor2&...">Mi enlace</a>

echo "Variable \$saludo: ".$_GET['saludo']." <br>\n";

echo "Variable \$texto: ". $_GET['texto']." <br>\n";

echo '<br>Variable \$saludo:', $_GET['saludo'] ;

Pasar variables con sesiones

Pasar variables con cookies.

A continuación se muestran algunos ejemplos::

<a href="destino_cookie.php">Paso variables por sesion saludo y texto</a>;

Ver todos los valores pasados como parámetros de un formulario.

isset (mixed variable [, mixed variable [, ...]])

if (isset($nombre) && $nombre!="") {

public function imprimir()

$per1=new Persona('Juan'); //creamos el objeto y lo inicializamos de una vez

1.- Conectar a la base de datos usando try/catch.

2.- Preparar la consulta (insert,update,delete).

2.2.- Asignar parámetros en la consulta:

$datos = array('Cathy', '9 Dark and Twisty Road', 'Cardiff');

2.3.- Ejecutar la consulta

2.- Preparar la consulta (select).

3.- Cerrar la conexión.

Conexión con la base de datos

Conexión con MySQL

// FUNCIÓN DE CONEXIÓN CON LA BASE DE DATOS MYSQL

# Para que genere excepciones a la hora de reportar errores.

Desconexión con la base de datos

Consultas a la base de datos

// EJEMPLO DE CONSULTA DE SELECCIÓN DE REGISTROS

$stmt = $pdo->query('SELECT * from cliente where id_cliente = '."$codigo"); // con

Para evitar esto tenemos las sentencias preparadas

ATENCIÓN: EL USO DE CONSULTAS PREPARADAS CON PREPARE NOS AYUDARÁ A

Ejemplos de como hacerlo:

Asignación con marcadores anónimos

# Asignamos variables a cada marcador, indexados del 1 al 3

# Insertamos una fila.

# Insertamos otra fila con valores diferentes.

Otra forma de asignación con marcadores anónimos a través de un array asociativo:

# Los datos que queremos insertar

Diferencia entre el uso de bindParam y bindValue

Ejemplo de diferencia entre bindParam y bindValue:

// Ejemplo con bindParam:

// El mismo ejemplo con bindValue:

Asignación con marcadores conocidos

Formato de bindParam con marcadores conocidos:

bindParam(':marcador', $variableVincular, TIPO DATOS PDO)

Ejemplo de uso de bindParam:

$stmt->bindParam(':calorias', $misCalorias, PDO::PARAM_INT);

$stmt = $pdo->prepare('SELECT * from cliente where id_cliente =:cliente or nombre=:nomcliente');

echo $stmt->rowCount(); // indica el numero de registros afectado por la ultima