UNIVERSIDAD SANTO TOMAS DE AQUINO

DUAD
FACULTAD DE CYT
PROGRAMA INGENIERIA EN INFORMATICA

BUENAS PRÁCTICAS EN LENGUAJE PHP

BUENAS PRÁCTICAS EN LENGUAJE PHP

DIRECCION NACIONAL DE DERECHOS DE AUTOR (DNDA)

REGISTRO DNDA No. 10-794-264

MARIO DUSTANO CONTRERAS CASTRO

INGENIERIO DE SISTEMAS
ESPECIALISTA EN MULTIMEDIA
MAESTRIA EN EDUMATICA

BOGOTA, 2023
Contenido
Antecedente. BUENAS PRÁCTICAS EN CODIFICACIÓN DE PROGRAMAS ........... 3
SOFTWARE WAMPPSERVER............................................................................................ 9
LENGUAJE DE PROGRAMACION PHP………………………………………………..…………….. 27

PROGRAMACION DE CLASES PHP ............................................................................... 42

ANTECEDENTE. BUENAS PRÁCTICAS EN CODIFICACIÓN DE PROGRAMAS
PRÁCTICA O PROCESO
Existe una distinción importante entre prácticas y procesos. Las prácticas son lo que
debe hacer y el proceso es la estructura para hacer las tareas. El proceso define el
orden en el cual aplicar las prácticas y hacer el trabajo, de forma que obtenga
resultados de ingeniería significativos. Las prácticas aprovechan el proceso de
ingeniería de software que explica las tareas y el orden en el que se deben realizar
para crear productos de trabajo específicos. Lasfases generales clave del proceso
son:
•Preparación del proyecto
•Análisis de requisitos
•Análisis funcional
•Síntesis de diseño
•Implementación
•Prueba de unidad

QUE SE ENTIENDE POR BUENAS PRACTICAS

Por buenas prácticas se entiende como un conjunto coherente de acciones que han
rendido buen o incluso excelente servicio en un determinado contexto y que se espera
que, en contextos similares, rindan similares resultados.
ANTECEDENTE.SQL
1. QUE ES SQL
https://bookdown.org/paranedagarcia/database/sql.html#sql
SQL es un lenguaje estructurado de consulta (Structured Query Language, en inglés).
diseñado específicamente para administrar información en sistemas de gestión de
bases de datos de tipo relacional.
No es un lenguaje de programación propiamente tal, como lo son Python, Java o
Javascript
Este lenguaje define tanto los inputs com outputs que son ejecutadas por el motor de
aplicaciones sobre una base de datos.
Los tipos de datos manejados por SQL incluyen:
Numéricos
Moneda
Caracter
Binario
Fecha/hora
Lógicos (booleanos)
Enumerados
Geometricos
Redes
Bit String
Texto
UUID
XML
JSON
Arreglos
Compuestos (Composite)
Rangos
Identificadores de objetos
SELECT CAST(123 AS DECIMAL(5,2)) --returns 123.00
SELECT CAST(12345.12 AS NUMERIC(10,5)) --returns 12345.12000
1.1. Tipos Numericos
Los de tipo numéricos incluyen enteros y decimales con un almacenamiento desde -
32768 a +32767 para “smallint”, hasta +9223372036854775807 para un “bigint”
1.2. Tipos Serial
Los tipos serial (serial, smallserial, bigserial no son tipos efectivos sino una convención
para anotar un identificador único auto incrementado). AUTO_INCREMENT en otras
bases de datos.
CREATE TABLE xxxx (
id SERIAL
)
1.3. Tipos Char y varchar
CHARACTER VARYING(n), VARCHAR(n)
CHARACTER (n), CHAR(n)
Tipos CAST
SELECT CAST('ABC' AS CHAR(10)) -- 'ABC ' se completa con espacios a la izquierda
SELECT CAST('ABC' AS VARCHAR(10)) -- 'ABC' sin espacios
SELECT CAST('ABCDEFGHIJKLMNOPQRSTUVWXYZ' AS CHAR(10)) --
'ABCDEFGHIJ' se trunca a 10 caracteres
1.4. Tipos Arrays
-- declarando un arreglo
SELECT INTEGER[];
SELECT INTEGER[3];
SELECT INTEGER[][];
SELECT INTEGER[3][3];
SELECT INTEGER ARRAY;
SELECT INTEGER ARRAY[3];
-- creando un arreglo
SELECT '{0,1,2}';
SELECT '{{0,1},{1,2}}';
SELECT ARRAY[0,1,2];
SELECT ARRAY[ARRAY[0,1],ARRAY[1,2]];
2. Definición de Datos (DDL)
Este lenguaje esta orientado a la definición de las estructuras de datos dentro de la
base de datos. Las estructuras son las tablas, índices, vistas, etc. Las funciones
principales son CREATE, ALTER y DROP (crear, modificar y eliminar
respectivamente).
2.1 CREATE
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF
NOT EXISTS ] table_name ( [
{ column_name data_type [ COMPRESSION compression_method ] [ COLLATE
collation ] [ column_constraint [ ... ] ]
| table_constraint
| LIKE source_table [ like_option ... ] }
[, ... ]
])
[ INHERITS ( parent_table [, ... ] ) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [
COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING method ]
[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace_name ]
-- crea una base de datos y la coloca en uso
CREATE DATABASE ejemplo;
USE ejemplo;
-- crear las tablas
CREATE TABLE [database_name.][schema_name.]table_name (
pk_column data_type PRIMARY KEY,
column_1 data_type [NOT NULL][UNIQUE][UNIQUE KEY],
column_2 data_type,
...,
table_constraints
);
NOT NULL - este parámetro asegurará que la columna no almacene un valor NULL
UNIQUE - este parámetro va a prevenir que el valor de la columna sea unico.
UNIQUE KEY - este parámetro designará la columna como un identificador único.
2.2 ALTER
Modifica la estructura de una tabla sin suprimirla y volver a crearla, como añadir
columnas, eliminar columnas o cambiar definiciones de columna (por ejemplo, longitud
o los valores predeterminados).
ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
action [, ... ]
ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
RENAME [ COLUMN ] column_name TO new_column_name
ALTER TABLE [ IF EXISTS ] [ ONLY ] name [ * ]
RENAME CONSTRAINT constraint_name TO new_constraint_name
ALTER TABLE [ IF EXISTS ] name
RENAME TO new_name
ALTER TABLE [ IF EXISTS ] name
SET SCHEMA new_schema
ALTER TABLE ALL IN TABLESPACE name [ OWNED BY role_name [, ... ] ]
SET TABLESPACE new_tablespace [ NOWAIT ]
ALTER TABLE [ IF EXISTS ] name
ATTACH PARTITION partition_name { FOR VALUES partition_bound_spec |
DEFAULT }
ALTER TABLE [ IF EXISTS ] name
DETACH PARTITION partition_name [ CONCURRENTLY | FINALIZE ]
-- agregar una clave primaria a un tabla
ALTER TABLE nombretabla ADD PRIMARY KEY (nombrecolumna);
2.3 DROP
-- elimina una tabla
DROP TABLE nombretabla;
-- elimina una base de datos
DROP DATABASE nombrebasededatos;
-- elimina una vista
DROP VIEW nombrevista;
2.4 TRUNCATE
Elimina los datos de una tabla sin alterar la estructura de la tabla.
TRUNCATE TABLE nombretabla;
3 Manipulación de Datos (DML)
Lleva a cabo las tareas de consultar (selección), adicionar, editar y eliminar (registros
dentro de una tabla).
• Consultar información
SELECT [ALL | DISTINCT] <seleccion> FROM <tablas>
WHERE <condiciones de seleccion> [ORDER BY <columna> [ASC | DESC]
[,<columna> [ASC | DESC]]...]
• Adicionar información
INSERT INTO <nombre tabla>
[(<nombre columna> [,<nombre columna>]...)]
VALUES (<expresion> [,<expresion>]...)
• Eliminar registros
DELETE FROM <nombre tabla> WHERE <condicion busqueda>
• Editar registros
UPDATE <nombre tabla>
SET <nombre columna> = ( <expresion> | NULL )
[, <nombre columna> = ( <expresion> | NULL )]... WHERE <condicion
busqueda>
4 Ejemplos
En el primer ejemplo de código, se devuelven todas las filas (no se especifica la
cláusula WHERE) y todas las columnas (con *) de la tabla Product de la base de datos
AdventureWorks2012.
USE AdventureWorks2012;
GO
SELECT *
FROM Production.Product
ORDER BY Name ASC;
-- los primeros 5 registros de ordenes
SELECT * FROM ordenes LIMIT 5;
-- cuenta de los distintos productos desde ventas
SELECT count(distinct idproducto)
FROM ventas;
-- las ventas realizadas del producto id=89
SELECT idproducto, sum(cantidad) as total
FROM ventas
WHERE idproducto = 89;
-- titulo y el año de estreno de las películas emitidas en 1990 y 2000 y con una
duración mayor a dos horas.
SELECT titulo, year
FROM peliculas
WHERE year IN (1990,2000)
AND duracion > 120
-- el titulo e idioma de las películas con idioma ingles, español o francés
SELECT titulo, idioma
FROM peliculas
WHERE idioma IN ('English', 'French', 'Spanish')
-- Obtenga todos los detalles de las películas en español estrenadas después del
2000, pero antes del 2010
SELECT * FROM peliculas
WHERE idioma = 'Spanish'
AND year > 2000
AND year < 2010
-- Obtener el porcentaje de personas que ya no están vivas. Alias el resultado como
porcentaje_muerto. ¡Recuerda usar 100.0 y no 100!
SELECT (count(muerte)*100.0)/count(*) AS porcentaje_muerto
FROM persona
-- numero de años entre la película mas vieja y la mas nueva. establezca el resultado
como ‘diferencia’
SELECT max(year) - min(year) AS diferencia
FROM peliculas
-- condición múltiple
SELECT *
FROM clientes
WHERE ciudad = 'Concepción' AND edad >= 45
AND fecha IS NOT NULL
-- condición múltiple
SELECT *
FROM clientes
WHERE (ciudad = 'Concepción' AND edad >= 45 OR estado = TRUE)
AND fecha IS NOT NULL
9.4.1 Ejemplos con funciones
-- el total de productos vendidos
SELECT sum(cantidad)
FROM ventas;
-- la mayor cantidad de venta de un producto
SELECT max(cantidad)
FROM ventas;
-- total de unidades vendidas por producto (los primeros 5 más vendidos)
SELECT idproducto, sum(cantidad) as total
FROM ventas
GROUP BY idproducto
HAVING cantidad > 0
ORDER BY total DESC
LIMIT 5;
-- cuantas consultas por usuario medico (simple)
SELECT count(idmedico), ex_idm as medicos
FROM consultas c
GROUP BY idmedico
-- lista de edades y cantidad de pacientes para cada edad
SELECT DISTINCT count(*),pa_edad
FROM bio_pacientes bp GROUP BY pa_edad
ORDER BY pa_edad
-- Encontrar la mayor diferencia en el total de puntajes de todas las tareas. Mostrar la
diferencia.
SELECT MAX(puntaje)-MIN(puntaje) AS diferencia FROM
(SELECT student,
SUM(tarea1 + tarea2 + tarea3) AS puntaje
FROM clase_puntajes
GROUP BY student) a;
-- Los empleados quereciben más de un bono.
SELECT e.employee_title, e.sex,
AVG(e.salary + b.ttl_bonus) AS avg_compensation FROM sf_employee e
INNER JOIN
(SELECT worker_ref_id,
SUM(bonus) AS ttl_bonus
FROM sf_bonus
GROUP BY worker_ref_id) b ON e.id = b.worker_ref_id GROUP BY employee_title,
sex;
-- Número de tiendas abierta en domingo
SELECT sunday, COUNT(*) AS total_business
FROM yelp_business_hours bh
LEFT JOIN yelp_business b ON bh.business_id = b.business_id
WHERE sunday IS NOT NULL
AND is_open = 1
GROUP BY sunday
ORDER BY total_business DESC;
-- Total de ventas de Alicia y Renato
SELECT SUM(ventas) AS total_ventas FROM ventas_general
WHERE vendedor = 'Alicia' OR vendedor = 'Renato'
BUENAS PRÁCTICAS EN LENGUAJE PHP

SOFTWARE WAMP SERVER

QUE ES WAMP SERVER
WAMP SERVER es un software que permite instalar de forma conjunta:
- un servidor web HTTP de código abierto para plataformas (Apache)
- un lenguaje de servidor (PHP)
- administrador de base de datos (MySQL)
- una interfaz grafica para el MySQL(phpMyAdmin)
Primer Momento. DESCARGA DE WAMP SERVER DE INTERNET
URL https://sourceforge.net/projects/wampserver/

Image 1. Descargar Wamp Server

Image 2. Descargar Wamp Server.

.
Segundo Momento. INSTALACION DE WAMP SERVER

Ejecutar

Pulsar OK

Pulsar Next
Pulsar Next

Seleccionar MariaDB 10.6.11 y MySQL 8.0.11

Pulsar Next
Pulsar Next

Pulsar Install
Boton Abrir

Boton Si

Boton Abrir
 Image. Instalaciòn Wamp Server

Image. Completitud Instalaciòn Wamp Server

User: root
Password:
Iniciar sesion
Tercer Momento. CREACION DE LA BASE DE DATOS
Abra la aplicación bloc de notas, coloque el siguiente código:
DROP DATABASE IF EXISTS `encuesta`;
Se va crear una base de datos denominada encuesta entonces:

Image. Creaciòn de Base de Datos

Nombre de la base de Datos: encuesta

Esquema: Cotejamiento
Pulsar Boton Crear
Cuarto Momento. CREACION DE TABLAS
Hacer doble click sobre la base de datos encuesta

Image. Creaciòn de una Tabla

Se va crear una tabla denominada encuesta con 7 campos entonces

Image. Creaciòn de Tabla Encuesta

cedula:INT, 10,UNIQUE
Pulsar Boton Continuar
nombre:VARCHAR,30
ciudad: VARCHAR,30
domicilio: VARCHAR,30
telefono:INT, 10
idcontrato:INT, 2
idservicio:INT, 2

Image. Creaciòn de Tabla Encuesta

Se pulsa el botón Guardar

:

idservicio:INT, 2, UNIQUE
nombre:VARCHAR,30

Image. Creaciòn de Tabla Servicios

Se pulsa el botón Guardar
idcontrato:INT, 2, UNIQUE
nombre:VARCHAR,30

Image. Creaciòn de Tabla Contratos

Se pulsa el botón Guardar

Image. Tablas Diseñadas

Quinto Momento. ADMINISTRACION DE LLAVES FORANEAS
En el caso de la Tabla encuesta se tiene:
Primary key: cedula
Foreing Key: idcontrato
Foreing Key: idservicio

Debe seleccionar el botón e escribir las siguientes sentencias sql-

mysql:
use `encuesta`;
ALTER TABLE encuesta ADD FOREIGN KEY ( idcontrato )
REFERENCES contratos( idcontrato ) ON DELETE CASCADE;
ALTER TABLE encuesta ADD FOREIGN KEY ( idservicio )
REFERENCES servicios( idservicio ) ON DELETE CASCADE;

Image. Sentencias SQL

Pulse el botón Continuar

Sexto Momento. ADICION DE REGISTROS

Debe seleccionar el botón e escribir las siguientes sentencias sql-

mysql: para adicionar dos registros en la tabla contratos como:
use `encuesta`;
INSERT INTO `encuesta`.`contratos` (
`idcontrato` ,
`nombre`
)
VALUES (
'01', 'Mensual'
), (
'02', 'Bimensual'
);

Image. Sentencia SQL Insert

Pulsar Botón Continuar

Image. Sentencia SQL Insert tabla encuesta

Debe seleccionar el botón e escribir las siguientes sentencias sql-
mysql: para adicionar dos registros en la tabla servicios como:
use `encuesta`;
INSERT INTO `encuesta`.`servicios` (
`idservicio` ,
`nombre`
)
VALUES (
'01', 'Familiar'
), (
'02', 'Premiere'
);

Image. Ejecucion Sentencia SQL Insert Tabla servicios

Pusar Boton Continuar

Image. Ejecucion Sentencia SQL Insert Tabla servicios

Ahora, debe seleccionar el botón e escribir las siguientes sentencias
sql-mysql: para adicionar dos registros en la encuesta:
use `encuesta`;
INSERT INTO `encuesta`.`encuesta` (
`cedula` ,
`nombre` ,
`ciudad` ,
`domicilio` ,
`telefono` ,
`idcontrato` ,
`idservicio`
)
VALUES (
'01', 'Carolina Cruz', 'Cali', 'La Quinta', '223323', '01', '02'
), (
'02', 'Natalia Paris', 'Medellin', 'Nutibara', '33333', '02', '01'
);

Image. Ejecucion Sentencia SQL Insert Tabla encuesta

Pusar Boton Continuar

Image. Ejecucion Sentencia SQL Insert Tabla encuesta

VERIFICAR EXISTENCIA DE BASE DE DATOS
Verificar la carpeta encuesta en el path \wamp64\bin\mysql\mysql8.0.31\data

Image. Verificar existencia carpeta encuesta

CREACION DE CARPETA SCRIPT PHP

Acceder a la carpeta wamp64>>www

Image. Creacion de carpeta Script PHP

Crear la carpeta encuesta

Image. Creacion de carpeta Script PHP

 BUENAS PRÁCTICAS EN LENGUAJE PHP

LENGUAJE DE PROGRAMACION PHP

APRENDIZAJE LENGUAJE PHP
Primer Momento. INTRODUCCION
Delimitación del código PHP
Al iniciar la ejecución de un script, el servidor PHP busca código instrucciones
PHP que deban ser interpretadas, entonces, en PHP hay tags que le van a
decir al intérprete PHP que el código que está entre ellos es código PHP. Los
más conocidos son <?php para iniciar el código, y ?> para cerrarlo. Sin
embargo, son 4 las opciones que se tienen.
* <?php ... ?>
* <script language="php"> ... </script>
* <? ... ?>
* <% ... %>
De ellos, los dos Primeros siempre estarán disponibles, y los dos últimos deben
ser habilitados en la configuración de PHP para que funcionen correctamente.
Es por eso que se recomienda siempre usar el Primer conjunto de tags: <?php
y ?> para lograr la mayor compatibilidad de nuestros scripts en todos los
servidores. En PHP6 se eliminará el soporte al último de ellos <% y %>.
Todo lo que esté encerrado entre esos símbolos será reconocido por el
servidor como código PHP, y empezará a leerlo e interpretarlo. El siguiente
ejemplo es para mostrar sólo la correcta inclusión de código PHP en un script:
<?php
echo "Hola mundo";
?>
El tag de cierre ?> es opcional, y se usa solamente cuando se desea dejar de
interpretar PHP, por lo general, se recomienda no usarlo si el archivo es de
puro código PHP.
Separación de instrucciones
Un programa o script en PHP es un conjunto de instrucciones que deben ser
leídas por el servidor para generar un resultado. Para separar las diferentes
instrucciones se utiliza el operador punto y coma (;).
PHP es un lenguaje "ciego" a los espacios en blanco y saltos de línea antes o
después de una instrucción. Para eso, se puede insertar tabulaciones y saltos
de línea en el código.
<?php
$variable = "Esta es una variable PHP";
echo $variable;
echo "Dos instrucciones..."; echo "...en la misma línea";
?>
Desplegar la información
Para desplegar o imprimir información en la pantalla se utilizan las
instrucciones como echo o print
echo "Texto impreso con echo";
print "Texto impreso con print";
VARIABLES Y CONSTANTES
Variables:
Las variables deben precedidas por signo dólar ($), y le asignamos contenido
con el signo igual (=). PHP distingue entre mayúsculas y minúsculas.
<html>
<body>
<?php
$myvar = "BOGOTA \n";
$Myvar = "CALI \n";
//Esto imprimirá BOGOTA
echo $myvar;
//Esto imprimirá CALI
ECHO $Myvar;
?>
</body>
</html>
Conclusión. $myvar y $Myvar, son dos variables diferentes.
Constantes:
Las constantes son similares a las variables, con la salvedad de que no llevan
el signo dólar delante, y sólo la podemos asignar una vez. Para definir una
constante se utiliza la función define como sigue:
<html>
<body>
<?php
define ("CONSTANTE", "Hola Mundo");
printf (CONSTANTE);
?>
</body>
</html>
OPERADORES
Operadores Aritméticos:
$a + $b Suma
$a - $b Resta
$a * $b Multiplicación
$a / $b &ss=codigoenlinea>$a / $b División
$a % $b Resto de la división de $a por $b
$a++ Incrementa en 1 a $a
$a-- Resta 1 a $a
Operadores de Cadenas:
El único operador de cadenas que existen es el de concatenación, el punto.
Pero no os asustéis, PHP dispone de toda una batería de funciones que os
permitirán trabajar cómodamente con las cadenas.
$a = "Hola";
$b = $a . "Mundo"; // Ahora $b contiene "Hola Mundo"
En este punto hay que hacer una distinción, la interpretación que hace PHP de
las simples y dobles comillas. En el segundo caso PHP interpretará el
contenido de la cadena.
$a = "Mundo";
echo = 'Hola $a'; //Esto escribirá "Hola $a"
echo = "Hola $a"; //Esto escribirá "Hola Mundo”
Operadores de Comparación:
$a < $b $a menor que $b
$a > $b $a mayor que $b
$a <= $b $a menor o igual que $b
$a >= $b $a mayor o igual que $b
$a == $b $a igual que $b
$a != $b $a distinto que $b
Operadores Lógicos:
$a AND $b Verdadero si ambos son verdadero
$a && $b Verdadero si ambos son verdadero
$a OR $b Verdadero si alguno de los dos es verdadero
$a !! $b Verdadero si alguno de los dos es verdadero
$a XOR $b Verdadero si sólo uno de los dos es verdadero !$a Verdadero
si $a es falso, y recíprocamente
Operadores de Asignación:
$a = $b Asigna a $a el contenido de $b
$a += $b Le suma a $b a $a
$a -= $b Le resta a $b a $a
$a *= $b Multiplica $a por $b y lo asigna a $a
$a /= $b Divide $a por $b y lo asigna a $a
$a .= $b Añade la cadena $b a la cadena $a
LAS ESTRUCTURAS DE CONTROL
Las estructuras de control permiten ejecutar bloque de códigos dependiendo de
unas condiciones. Para PHP el 0 es equivalente a Falso y cualquier otro
número es Verdadero.
IF...ELSE
Sintaxis. if (condición) {
} else {
}
Sintaxis. IF ANIDADOS
La sentencia IF...ELSEIF...ELSE permite ejecuta varias condiciones en
cascada. Para este caso veremos un ejemplo, en el que utilizaremos los
operadores lógicos.
<?php
if ($edad> =18)
{ echo "Mayor de Edad";}
elseif ($edad>=14)
{echo " Juvenil";}
else
{echo "Niño "; }
?>
SWITCH...CASE...DEFAULT
Sintaxis.
switch(variable)
{
case valor:
bloque de sentencias
break;
default:
bloque de sentencias
}
Nota. Se puede romper cualquier ciclo utilizando la sentencia break
WHILE
while (condicion) {
<Bloque de Instrucciones>
}
DO...WHILE
SINTAXIS PHP:
do {
<Bloque de Instrucciones>
} while (condicion);
FOR(CICLO FINITO)
SINTAXIS PHP:
for( a; b; d)
<Bloque de Instrucciones>
FUNCIONES
Una Función no es más que un bloque de instrucciones al que le pasamos una
serie de parámetros y nos puede o no devolver un valor
Las Funciones de Usuario
Para declara una función se utiliza la clausula function seguido del nombre que
le vamos a dar, y después entre paréntesis la lista de argumentos separados
por comas, también, se puede presentar funciones que no poseen ningún
argumento.
function nombre_de_funcion (argumento_1, argumento_2, ...)
{
bloque de instrucciones
}
Cuando invocamos una función, se ejecutan las líneas de código que contenga
la función, y una vez terminado, el programa continúa su ejecución desde el
punto en que fue llamada la función.
Mediante la instrucción return se termina la ejecución del código de una
función y se retorna o devuelve un valor.
<?php
function mayor ($x, $y)
{
$msg = "";
if ($x > $y) {
$msg = $x." es mayor que".$y;
} else {
$msg = $y." es mayor que".$x;
}
return $msg;
}
?>
Parámetros de las funciones
En PHP, las variables se pasan por valor. Para hacerlo por referencia se debe
anteponer un ampersand (&) a la variable.
<?php
function suma ($x, $y)
{
$x = $x + 1;
return $x+$y;
}
$a = 1;
$b = 2;
//parámetros por valor
echo suma ($a, $b); // imprimirá 4
echo $a; // imprimirá 1
//parámetros por referencia
echo suma (&$a, $b); // imprimirá 4
echo $a; //imprimirá 2
?>
ÁMBITO DE LAS VARIABLES
Se debe 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.
<?php
function contador ()
{
static $count = 0;
$count = $count + 1;
return $count;
}
echo contador()."<BR>"; // imprimirá 1
echo contador()."<BR>"; // imprimirá 2
echo contador()."<BR>"; // imprimirá 3
?>
Las variables globales, no pertenecen ni se declaran en una función, se
declaran a parte de cualquier función (normalmente después del tag <?php),
pero las mismas pueden tomar el valor que tenga en ese Momento, pudiendo
ser modificado en la función.
<?php
var $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
echo ver_a(); // imprimirá 2
$a = 7;
echo ver_a(); // imprimirá 7
echo ver_a(); // imprimirá 8
?>
Matriz GLOBALS
Existe un array en PHP llamado $GLOBALS, que guarda una referencia a
todas las variables creadas de manera global a la página. Es una matriz o array
asociativo, de los que en lugar de índices numéricos utilizan índices de texto,
donde cada índice es el nombre que hemos dado a la variable y cada valor es
el contenido de cada variable.
Ejemplo:
<? php
$mivariable = "mario edad: ";
$otravariable = 60;
Si se quiere acceder a estas variables dentro de una función utilizando el array
$GLOBALS se debe tener el siguiente código:
function mifuncion(){
//estoy dentro de la función, para aceder a las variables utilizo $GLOBALS
echo $GLOBALS["mivariable"];
echo $GLOBALS["otravariable"];
}
Como se puede ver, se accede al contenido de las variables globales con el
array $GLOBALS, utilizando como índices de la matriz los nombres de
variables que se desean mostrar.
Esto imprimiría por pantalla el texto "mario edad: 60", el valor de las dos
variables uno detrás del otro.
Declaración de uso de variables globales dentro de una función
Otra manera de acceder a variables globales dentro de una función es
especificar al comienzo de dicha función la lista de variables que vamos a
utilizar dentro. Para especificar esas variables se utiliza la palabra "global"
seguida de la lista de variables que se van a utilizar del entorno global.
function mifuncion(){
global $mivariable, $otravariable
//con esa línea dentro de la función, declaramos el uso de variables globales
echo $mivariable;
echo $otravariable;
}
Con "global" se especifica que se va utilizar unas variables que fueron
declaradas como globales a la página. Una vez hecho esto, ya se puede
acceder a esas variables globales como si estuvieran declaradas dentro de la
función.
Cualquier alteración que se haga a las variables dentro de la función
permanecerá cuando se haya salido de la función, tanto si accedemos a través
del array $GLOBALS o declarando con "global" el uso de esas variables.
FUNCIONES PHP DE ACCESO A MySQL
Referencia: PHP: MySQLi - Manual
mysqli — La clase mysqli
mysqli::$affected_rows — Obtiene el número de filas afectadas en la última
operación MySQL
mysqli::autocommit — Activa o desactiva las modificaciones de la base de
datos autoconsignadas
mysqli::begin_transaction — Inicia una transacción
mysqli::change_user — Cambia el usuario de la conexión de bases de datos
especificada
mysqli::character_set_name — Devuelve el juego de caracteres
predeterminado para la conexión a la base de datos
mysqli::close — Cierra una conexión previamente abierta a una base de datos
mysqli::commit — Consigna la transacción actual
mysqli::$connect_errno — Devuelve el código de error de la última llamada
mysqli::$connect_error — Devuelve una cadena con la descripción del último
error de conexión
mysqli::__construct — Abre una nueva conexión al servidor de MySQL
mysqli::debug — Realiza operaciones de depuración
mysqli::dump_debug_info — Volcado de información de depuración en el
registro
mysqli::$errno — Devuelve el código del error de la última función llamada
mysqli::$error_list — Devuelve una lista de errores desde el último comando
ejecutado
mysqli::$error — Devuelve una cadena que describe el último error
mysqli::execute_query — Prepares, binds parameters, and executes SQL
statement
mysqli::$field_count — Devuelve el número de columnas para la consulta más
reciente
mysqli::get_charset — Devuelve un objeto que contiene el conjunto de
caracteres
mysqli::get_client_info — Obtiene información de la biblioteca cliente de
MySQL
mysqli_get_client_version — Devuelve la versión clientes de MySQL como
valor de tipo integer
mysqli::get_connection_stats — Devuelve estadísticas sobre la conexión del
cliente
mysqli::$host_info — Devuelve una cadena que representa el tipo de conexión
usada
mysqli::$protocol_version — Devuelve la versión del protocolo MySQL utilizada
mysqli::$server_info — Devuelve la versión del servidor MySQL
mysqli::$server_version — Devuelve la versión del servidor MySQL como un
valor entero
mysqli::get_warnings — Obtiene el resultado de SHOW WARNINGS
mysqli::$info — Obtiene la información de la última consulta ejecutada
mysqli::init — Inicializa y devuelve un recurso para utilizarlo con
mysqli_real_connect()
mysqli::$insert_id — Devuelve el id autogenerado que se utilizó en la última
consulta
mysqli::kill — Pide al servidor poner fin a un hilo de MySQL
mysqli::more_results — Comprueba si hay más resultados de una multi
consulta
mysqli::multi_query — Realiza una consulta a la base de datos
mysqli::next_result — Prepara el siguiente resultado de multi_query
mysqli::options — Establecer opciones
mysqli::ping — Comprueba la conexión al servidor, o trata de reconectar si se
perdió la conexión
mysqli::poll — Almacena en caché conexiones
mysqli::prepare — Prepara una sentencia SQL para su ejecución
mysqli::query — Realiza una consulta a la base de datos
mysqli::real_connect — Abre una conexión a un servidor mysql
mysqli::real_escape_string — Escapa los caracteres especiales de una cadena
para usarla en una sentencia SQL, tomando en cuenta el conjunto de
caracteres actual de la conexión
mysqli::real_query — Ejecuta una consulta SQL
mysqli::reap_async_query — Obtener el resultado de una consulta asincrónica
mysqli::refresh — Refresca
mysqli::release_savepoint — Elimina el punto salvado con nombre del conjunto
de puntos salvados de la transacción actual
mysqli::rollback — Revierte la transacción actual
mysqli::savepoint — Define el nombre de un punto de salvaguarda de la
transacción
mysqli::select_db — Selecciona la base de datos por defecto para realizar las
consultas
mysqli::set_charset — Establece el conjunto de caracteres predeterminado del
cliente
mysqli::$sqlstate — Devuelve el error SQLSTATE de la operación de MySQL
previa
mysqli::ssl_set — Usada para establece conexiones seguras usando SSL
mysqli::stat — Obtiene el estado actual del sistema
mysqli::stmt_init — Inicializa una sentencia y devuelve un objeto para usarlo
con mysqli_stmt_prepare
mysqli::store_result — Transfiere un conjunto de resultados de la última
consulta
mysqli::$thread_id — Deveulve el ID del hilo de la conexión actual
mysqli::thread_safe — Devuelve si la seguridad a nivel de hilos está dada o no
mysqli::use_result — Inicia la recuperación de un conjunto de resultados
mysqli::$warning_count — Devuelve el número de mensajes de advertencia de
la última consulta para un enlace dado
mysqli_stmt — La clase mysqli_stmt
mysqli_stmt::$affected_rows — Devuelve el número total de filas cambiadas,
borradas, o insertadas por la última sentencia ejecutada
mysqli_stmt::attr_get — Se utiliza para obtener el valor actual de un atributo de
la sentencia
mysqli_stmt::attr_set — Se utiliza para modificar el comportamiento de una
sentencia preparada
mysqli_stmt::bind_param — Agrega variables a una sentencia preparada como
parámetros
mysqli_stmt::bind_result — Vincula variables a una sentencia preparada para el
almacenamiento de resultados
mysqli_stmt::close — Cierra una sentencia preparada
mysqli_stmt::__construct — Construye un nuevo objeto mysqli_stmt
mysqli_stmt::data_seek — Busca una fila arbitraria en un conjunto de
resultados de una sentencia
mysqli_stmt::$errno — Devuelve el código de error de la llamada de la
sentencia más reciente
mysqli_stmt::$error_list — Devuelve una lista de errores de la última sentencia
ejecutada
mysqli_stmt::$error — Devuelve una descripción en forma de string del último
error de una sentencia
mysqli_stmt::execute — Ejecuta una consulta preparada
mysqli_stmt::fetch — Obtiene los resultados de una sentencia preparadas en
las variables vinculadas
mysqli_stmt::$field_count — Devuelve el número de campos de la sentencia
dada
mysqli_stmt::free_result — Libera la memoria de los resultados almacenados
del gestor de sentencia dado
mysqli_stmt::get_result — Obtiene un conjunto de resultados de una sentencia
preparada
mysqli_stmt::get_warnings — Obtener los resultados de SHOW WARNINGS
mysqli_stmt::$insert_id — Obtener el ID generado en la operación INSERT
anterior
mysqli_stmt::more_results — Comprobar si existen más resultados de una
consulta de consultas múltiples
mysqli_stmt::next_result — Lee el siguiente resultado de una consulta múltiple
mysqli_stmt::$num_rows — Devuelve el número de filas de un conjunto de
resultados de una sentencia
mysqli_stmt::$param_count — Devuelve el número de parámetros de la
sentencia dada
mysqli_stmt::prepare — Preparar una sentencia SQL para su ejecución
mysqli_stmt::reset — Reinicia una sentencia preparada
mysqli_stmt::result_metadata — Devuelve los metadatos del conjunto de
resultados de una sentencia preparada
mysqli_stmt::send_long_data — Enviar datos en bloques
mysqli_stmt::$sqlstate — Devuelve el error SQLSTATE de la operación de
sentencia previa
mysqli_stmt::store_result — Transfiere un conjunto de resultados desde una
sentencia preparada
mysqli_result — La clase mysqli_result
mysqli_result::__construct — Constructs a mysqli_result object
mysqli_result::$current_field — Obtener posición del campo actual de un
puntero a un resultado
mysqli_result::data_seek — Ajustar el puntero de resultado a una fila arbitraria
del resultado
mysqli_result::fetch_all — Obtener todas las filas en un array asociativo,
numérico, o en ambos
mysqli_result::fetch_array — Obtiene una fila de resultados como un array
asociativo, numérico, o ambos
mysqli_result::fetch_assoc — Obtener una fila de resultado como un array
asociativo
mysqli_result::fetch_column — Fetch a single column from the next row of a
result set
mysqli_result::fetch_field_direct — Obtener los metadatos de un único campo
mysqli_result::fetch_field — Retorna el próximo campo del resultset
mysqli_result::fetch_fields — Devuelve un array de objetos que representan los
campos de un conjunto de resultados
mysqli_result::fetch_object — Devuelve la fila actual de un conjunto de
resultados como un objeto
mysqli_result::fetch_row — Obtener una fila de resultados como un array
enumerado
mysqli_result::$field_count — Obtiene el número de campos de un resultado
mysqli_result::field_seek — Establecer el puntero del resultado al índice del
campo especificado
mysqli_result::free — Libera la memoria asociada a un resultado
mysqli_result::getIterator — Retrieve an external iterator
mysqli_result::$lengths — Retorna los largos de las columnas de la fila actual
en el resultset
mysqli_result::$num_rows — Obtiene el número de filas de un resultado
mysqli_driver — La clase mysqli_driver
mysqli_driver::embedded_server_end — Detener el servidor incrustado
mysqli_driver::embedded_server_start — Inicializa e inicia el servidor embebido
mysqli_driver::$report_mode — Habilita o desabilita las funciones internas de
notificación
mysqli_warning — La clase mysqli_warning
mysqli_warning::__construct — Private constructor to disallow direct
instantiation
mysqli_warning::next — El propósito next
mysqli_sql_exception — La clase mysqli_sql_exception
Alias y Funciones de MySQLi obsoletos
mysqli_connect — Alias de mysqli::__construct
mysqli_escape_string — Alias de mysqli_real_escape_string
mysqli_execute — Alias para mysqli_stmt_execute
mysqli_get_client_stats — Returns client per-process statistics
mysqli_get_links_stats — Devolver información sobre enlaces abiertos y
almacenados en caché
mysqli_report — Alias de mysqli_driver->report_mode
mysqli::set_opt — Alias de mysqli_options
Segundo Momento. CREACION DE UN PROGRAMA PHP
Primer ejemplo verificar conexion. Seleccionar las lineas a continuacion
<?php
$user = 'root';
$password = ''; //To be completed if you have set a password to root
$database = 'encuesta'; //To be completed to connect to a database. The data-
base must exist.
$port = NULL; //Default must be NULL to use default port
$mysqli = new mysqli('127.0.0.1', $user, $password, $database, $port);

if ($mysqli->connect_error) {
die('Connect Error (' . $mysqli->connect_errno . ') '
. $mysqli->connect_error);
}
echo '<p>Conexion OK '. $mysqli->host_info.'</p>';
echo '<p>Informacion Servidor '.$mysqli->server_info.'</p>';
$mysqli->close();
?>
Abrir bloc de notas
Salvar como Archivo primeraconexion.php en la subcarpeta
\wampp64\www\encuesta (publicación web).
Segundo ejemplo Consulta de una tabla. Seleccionar las lineas a continua-
cion
<?php
$user = 'root';
$password = ''; //To be completed if you have set a password to root
$database = 'encuesta'; //To be completed to connect to a database. The
database must exist.
$port = NULL; //Default must be NULL to use default port
$conn = new mysqli('127.0.0.1', $user, $password, $database, $port);
if ($conn->connect_error) {
echo "Conexion fallida: " . $conn->connect_error;
}
$query ="use `encuesta`";
if ($conn->query($query) === TRUE) {
$query= mysqli_query($conn,"SELECT * FROM encuesta;");
while ( $row = mysqli_fetch_array($query) )
{
echo $row['cedula'].' | '.$row['nombre'].' | '.$row['ciudad'].' |'; '';
}
}
else {
echo "Error de Apertura base de datos: " . $conn->error;
}
$conn->close();
?>

Abrir bloc de notas

Salvar como Archivo consulta. php en la subcarpeta \wampp64\www\encuesta
(publicación web).
Análisis:
1. La línea $conn = new mysqli('127.0.0.1', $user, $password, $database,
$port); se establece la conexión
2. La línea $query ="use `encuesta`"; para apertura de la base de datos
3. if ($conn->query($query) === TRUE) verifica apertura de la base de da-
tos
4. La línea $query= mysqli_query($conn,"SELECT * FROM encuesta;"); se
crea una sentencia select SQL para la variable de conexión conn
5. Las sentencias:
while ( $row = mysqli_fetch_array($query) )
{
echo $row['cedula'].' | '.$row['nombre'].' | '.$row['ciudad'].' |'; '';
}
Se ejecuta el bucle for imprimiendo los valores de los campos cedula, nom-
bre,ciudad de cada fila de tabla encuesta
6. Se cierra la conexión mysql_close($conexion);
7. Este codigo permite realizar una consulta a una tabla de una base de
datos
8. A continuacion se presentan codigos para adicion, edicion y borrado de
fila/registro de una tabla de una base de datos.
Tercer ejemplo adicion de fila/registro de una tabla. Seleccionar las lineas a
continuacion
<?php
$user = 'root';
$password = ''; //To be completed if you have set a password to root
$database = 'encuesta'; //To be completed to connect to a database. The data-
base must exist.
$port = NULL; //Default must be NULL to use default port
$conn = new mysqli('127.0.0.1', $user, $password, $database, $port);
if ($conn->connect_error) {
echo "Conexion fallida: " . $conn->connect_error;
}
$query ="use `encuesta`";
if ($conn->query($query) === TRUE) {
$query= mysqli_query($conn,"INSERT INTO contratos (`idcontrato`
,`nombre` )VALUES ('03', 'Trimestral');");
}
else {
echo "Error de Apertura base de datos: " . $conn->error;
}
$conn->close();
?>
Abrir bloc de notas.Salvar como Archivo adicion.php en la subcarpeta
\wampp64\www\encuesta (publicación web)
Cuarto ejemplo edicion fila/registro de una tabla.
<?php
$user = 'root';
$password = ''; //To be completed if you have set a password to root
$database = 'encuesta'; //To be completed to connect to a database. The
database must exist.
$port = NULL; //Default must be NULL to use default port
$conn = new mysqli('127.0.0.1', $user, $password, $database, $port);
if ($conn->connect_error) {
echo "Conexion fallida: " . $conn->connect_error;
}
$query ="use `encuesta`";
if ($conn->query($query) === TRUE) {
$query= mysqli_query($conn,"UPDATE contratos SET nombre='Anual'
WHERE idcontrato=3;");
}
else {
echo "Error de Apertura base de datos: " . $conn->error;
}
$conn->close();
?>
Seleccionar texto anterior y Abrir bloc de notas.Salvar como Archivo
edicion.php en la subcarpeta \wampp64\www\encuesta (publicación web)
Quinto ejemplo borrado fila/registro de una tabla. Seleccionar las lineas a
continuacion
<?php
$user = 'root';
$password = ''; //To be completed if you have set a password to root
$database = 'encuesta'; //To be completed to connect to a database. The
database must exist.
$port = NULL; //Default must be NULL to use default port
$conn = new mysqli('127.0.0.1', $user, $password, $database, $port);
if ($conn->connect_error) {
echo "Conexion fallida: " . $conn->connect_error;
}
$query ="use `encuesta`";
if ($conn->query($query) === TRUE) {
$query= mysqli_query($conn,"DELETE FROM contratos WHERE
idcontrato=3;");
}
else {
echo "Error de Apertura base de datos: " . $conn->error;
}
$conn->close();
?>
Abrir bloc de notas.Salvar como Archivo borrar.php en la subcarpeta
\wampp64\www\encuesta (publicación web)
Tercer Momento. EJECUCION DE UN PROGRAMA PHP
Activar wampserver64

La carpeta de practica encuesta:

 Abrir el explorador de Internet y colocar en la linea de comando la direccion:
localhost/encuesta/primeraconexion.php

Image. Resultado ejecuciòn primeraconexion.php

Abir otra ventana del explorador y colocar

localhost/encuesta/consulta.php

Realizar las practicas con adicion, edicion y borrar

BUENAS PRÁCTICAS EN LENGUAJE PHP

PROGRAMACION DE CLASES PHP

PROGRAMACION DE CLASES PHP
Primer Momento. DEFINICION DE CLASES PHP
El código para definir una clase es la siguiente:
class nombre_ clase{
var $variable1;
var $variable2; //variables de clase
function nombre_funcion(argumentos)
{
//aquí el código del método
}
}
Instanciar objetos a partir de clases
Para instanciar un objeto se utiliza el operador new
$nombre_objeto = new nombre_clase();
Para llamar un Método de un Objeto se utiliza los signo -> (menos y mayor)
de la siguiente manera:
Nombreobjeto->nombreMetodo(argumentos)
Conclusión Es importante darse cuenta de la diferencia entre un objeto y una
clase. La clase es una definición de unas características y funcionalidades, algo
abstracto que se concreta con la instanciación de un objeto de dicha clase.
Un objeto ya tiene propiedades, con sus valores concretos, y se le pueden
pasar mensajes (llamar a los métodos)
Segundo Momento. CREAR UNA CLASE EN PHP
1. Abrir el aplicativo bloc de notas
2. Copiar el siguiente código:
<?php
class DB_mysql {
/* variables de conexión */
var $BaseDatos;
var $Servidor;
var $Usuario;
var $Clave;
/* identificador de conexión y consulta */
var $Conexion_ID = 0;
var $Consulta_ID = 0;
/* número de error y texto error */
var $Errno = 0;
var $Error = "";
/* Método Constructor: Cada vez que creemos una variable
de esta clase, se ejecutará esta función */
function DB_mysql($bd = "", $host = "localhost", $user = "nobody",
$pass = "") {
$this->BaseDatos = $bd;
$this->Servidor = $host;
$this->Usuario = $user;
$this->Clave = $pass;
}
/*Conexión a la base de datos*/
function conectar($bd, $host, $user, $pass){
if ($bd != "") $this->BaseDatos = $bd;
if ($host != "") $this->Servidor = $host;
if ($user != "") $this->Usuario = $user;
if ($pass != "") $this->Clave = $pass;
// Conectamos al servidor
$this->Conexion_ID =new mysqli($this->Servidor, $this->Usuario,
$this->Clave, $this->BaseDatos);
if (!$this->Conexion_ID->connect_error) {
$this->Error = "Ha fallado la conexión.";
return 0;
}
//seleccionamos la base de datos
if (!@mysqli_select_db($this->BaseDatos, $this->Conexion_ID)) {
$this->Error = "Imposible abrir ".$this->BaseDatos ;
return 0;
}
/* Si hemos tenido éxito conectando devuelve
el identificador de la conexión, sino devuelve 0 */
return $this->Conexion_ID;
}
/* Ejecuta un consulta */
function consulta($sql = "")
{
echo $sql;echo " Operacion consulta...";echo "<br>";
if ($sql == "") {
$this->Error = "No ha especificado una consulta SQL";
return 0;
}
//ejecutamos la consulta
$this->Consulta_ID = @mysqli_query($this->Conexion_ID,$sql );
if (!$this->Consulta_ID) {
$this->Errno = mysqli_errno();
$this->Error = mysqli_error();
}
/* Si hemos tenido éxito en la consulta devuelve
el identificador de la conexión, sino devuelve 0 */
return $this->Consulta_ID;
}
// Funcion de existencia de llave primaria
function existe($sql)
{
echo $sql;echo " Operacion consulta...";
//ejecutamos la consulta
$this->Consulta_ID = @mysqli_query($this->Conexion_ID,$sql);
if($this->Consulta_ID->num_rows>0)
{
echo "Registro Existente <br>";
return 1;
}
else
{
echo "Registro Inexistente <br>";
return 0;
}
}
function adicion($query)
{
$resultado = mysqli_query($this->Conexion_ID,$query);
if ($resultado)
{
echo "Exito Adicion <br>";
}
else
{
echo "Error de Adicion <br>";
}
}
function borrar($query)
{
$resultado = mysqli_query($this->Conexion_ID,$query);
if ($resultado)
{
echo "Exito en borrar <br>";
}
else
{
echo "Error de borrado <br>";
}
}
/* Devuelve el número de campos de una consulta */
function numcampos() {
return mysqli_num_fields($this->Consulta_ID);
}
/* Devuelve el número de registros de una consulta */
function numregistros(){
return mysqli_num_rows($this->Consulta_ID);
}
/* Devuelve el nombre de un campo de una consulta */
function nombrecampo($numcampo) {
return mysqli_fetch_field_direct($this->Consulta_ID, $numcampo);
}
/* Muestra los datos de una consulta */
function verconsulta() {
$info_campo = $this->Consulta_ID->fetch_fields();
foreach ($info_campo as $valor) {
printf("Nombre: %s\n", $valor->name);
printf("Tabla: %s\n", $valor->table);
printf("Longitud máx.: %d\n", $valor->max_length);
printf("Longitud: %d\n", $valor->length);
printf("Nº conj. caract.: %d\n", $valor->charsetnr);
printf("Banderas: %d\n", $valor->flags);
printf("Tipo: %d\n\n", $valor->type);
}
while ($fila = $this->Consulta_ID->fetch_row()) {
printf ("%s (%s)\n", $fila[0], $fila[1]);
}
}
function edicion($query)
{
echo " Operacion Edicion...";
$resultado=mysqli_query($query);
if ($resultado)
{
echo "Exito Edicion <br>";
}
else
{
echo "Error de Edicion <br>";
}
}
} //fin de la Clse DB_mysql
?>
3. Pegar en bloc de notas
4. Guardar Como> tipo: Todos los archivos >nombre de archivo: cla-
se_mysql.inc.php en la subcarpeta www>>encuesta (publicación
web)
Tercer Momento. CREAR PROGRAMA QUE REQUIERE CLASE PHP
1. Abrir el aplicativo bloc de notas
2. Copiar el siguiente código:
<html>
<body>
<?php
require ("clase_mysql.inc.php");
$miconexion = new DB_mysql ;
$miconexion->conectar("encuesta", "localhost", "root", "root");
$miconexion->consulta("SELECT * FROM encuesta");
$miconexion->verconsulta();
if(!$miconexion->existe("SELECT * FROM encuesta where
cedula=405"))
{
$query='insert into encuesta values(405,"Pedro
Gomez","Cucunuba","calle 1 con 3",333333,1,2)';
$miconexion->adicion($query);
}
if(!$miconexion->existe("SELECT * FROM encuesta where
cedula=208"))
{
$query='insert into encuesta values(208,"Luis C.
Angulo","Bogota","calle 23 con 8",23232,2,1)';
$miconexion->adicion($query);
}
$miconexion->consulta("SELECT * FROM encuesta");
$miconexion->verconsulta();
if($miconexion->existe("SELECT * FROM encuesta where
cedula=208"))
$miconexion->borrar("DELETE FROM encuesta where cedula=208");
$miconexion->consulta("SELECT * FROM encuesta");
$miconexion->verconsulta();
?>
</body>
</html>
3. Pegar en bloc de notas
4. Salvar el Archivo en la subcarpeta www>>encuesta (publicación web) de
la carpeta appserver. Entonces, seleccionar Guardar Como> tipo: Todos
los archivos >nombre de archivo: clase.php. Pulsar el Botón Guardar
5. Inicializar el Servidor Apache y MySql asi:
inicio > programa > appserver > Control Server by Service
Apache Restart
Apache start
mysql start

6. Abrir el explorar de Internet y colocar en la caja de texto dirección:

http://localhost/encuesta/clase.php