Documente Academic
Documente Profesional
Documente Cultură
Como sabemos PostgreSQL es un sistema de gestión de base de datos relacional orientada a obje-
tos y libre, publicado bajo la licencia BSD y PHP es un lenguaje de programación interpretado, diseñado
originalmente para la creación de páginas web dinámicas. Es usado principalmente en interpretación del
lado del servidor, como sabemos entre las ventajas de php tiene la capacidad de conexión con la mayoría
de los motores de base de datos que se utilizan en la actualidad, destaca su conectividad
con MySQL y PostgreSQL.
Crando User
# createuser -Upostgres -sDRP town
Passwd: 12345
Luego de haber creado el usuario, vamos a crear la Base de Datos que usara este usuario.
tienda=>
Listado de relaciones
Schema | Nombre | Tipo | Dueño
--------------+----------------------+-----------+-------
public | cliente | tabla | town
Tabla «public.cliente»
Columna | Tipo | Modificadores
-------------+-------------------------+-------------------------------
idcliente | integer | not null default extval('cliente_idcliente_seq'::regclass)
nombre | character varying(30) |
apellido | character varying(30) |
direccion | character varying(200) |
telefono | numeric(10,0) |
Índices:
«cliente_pkey» PRIMARY KEY, btree (idcliente)
Listo hemos creado un user para nuestra DB, una base de datos, tabla y hemos insertado registros a la ta-
bla, todo desde la consola. Ahora crearemos un file.php para conectar nuestras DB a php, y asi desde web
insertar archivos y consultar.
inc.php
$user = 'town';
$passwd = '12345';
$db = 'tienda';
$port = 5432;
$host = 'localhost';
$strCnx = "host=$host port=$port dbname=$db user=$user password=$passwd";
?>
agregar.php
<html>
<head>
<title>postgreSQL - tienda</title>
</head>
<body>
<h1>postgreSQL - cliente</h1>
<?php
include_once '../inc.php';
$cnx = pg_connect($strCnx) or die ("Error de conexion. ". pg_last_error());
echo "Conexion exitosa<br>";
# Ejecutando la Consulta
if ( $_POST ) {
$result = pg_query($cnx, "INSERT INTO cliente (nombre,apellido,direccion,telefono) VALUES ('" .
pg_escape_string($_POST['nombre']) . "','" . pg_escape_string($_POST['apellido']) . "','" . pg_escape_string
($_POST['direccion']) . "'," . ((int)$_POST['telefono']) . " )");
if (!$result) {
echo "Query: Un error ha occurido.\n";
exit;
}
}
if ( $_POST )
echo "<div class=\"info\">Registro insertado
<a href=\"./ver\">volver</a></div>";
?>
<form action="" method="post">
<label>Nombre</label>
<input type="text" name="nombre" value="" class="txtbox long"/>
<label>apellido</label>
<input type="text" name="apellido" value="" class="txtbox long"/>
<label>Direccion</label>
<input type="text" name="direccion" value="" class="txtbox long"/>
<label>Telefono</label>
<input type="text" name="telefono" value="" class="txtbox"/>
<label>Password</label>
<input type="text" name="password" value="" class="txtbox"/>
<br />
<br />
<input type="submit" value="Guardar" class="btn"
/> <a href="./ver">volver</a>
</form>
<?php
pg_close($cnx);
?>
</table>
</body>
</html>
http://localhost/agregar.php
listo!! usted puede ingresar sus clientes desde php, sin estar en la consola.
Seguire en otra entrada con la consulta de estos dados...
PHP y PostgreSQL
Veamos un ejemplo de cómo trabajar con bases de datos PostgreSQL, para ello en la base de da-
tos template1 crea la siguiente tablaque utilizaremos en el ejemplo:
1º create table tbl_personas (
2º id integer not null check (id > 0),
3º nombre varchar(50) not null,
4º primary key (id)
5º )
NOTA: a día de hoy, la última versión disponible (PostgreSQL 9) no soporta unsigned, en su lugar podemos usar
la cláusula check.
Creamos una función usando pg_connect() para conectar con PostgreSQL, y pg_last_error() que nos devolverá
un mensaje de error si se produjo alguno (lo detectamos con or die, que detendrá la ejecución):
1º <?php
2º function conectar_PostgreSQL( $usuario, $pass, $host, $bd )
3º {
4º $conexion = pg_connect( "user=".$usuario." ".
5º "password=".$pass." ".
6º "host=".$host." ".
7º "dbname=".$bd
1º ) or die( "Error al conectar: ".pg_last_error()
);
1º
2º return $conexion;
3º }
4º ?>
Creamos otra función para borrar todos los registros de la tabla o sólo el especificado. Para procesar una consul-
ta (tanto de selección como de actualización) usaremos la función pg_query():
1º <?php
2º function borrarPersona( $conexion, $id )
3º {
4º $sql = "DELETE FROM tbl_personas";
5º
6º // Si 'id' es diferente de 'null' sólo se borra la persona con el
'id' especificado:
7º if( $id != null )
8º $sql .= " WHERE id=".$id;
9º
10º // Ejecutamos la consulta (se devolverá true o false):
1º return pg_query( $conexion, $sql );
1º }
2º ?>
Función para insertar un registro en la tabla:
1º <?php
2º function insertarPersona( $conexion, $id, $nombre )
3º {
4º $sql = "INSERT INTO tbl_personas VALUES (".$id.", '".$nombre."')";
5º
6º // Ejecutamos la consulta (se devolverá true o false):
1º return pg_query( $conexion, $sql );
1º }
2º ?>
Otra función para modificar un registro:
1º <?php
2º function modificarPersona( $conexion, $id, $nombre )
3º {
4º $sql = "UPDATE tbl_personas SET nombre='".$nombre."' WHERE id=".$id;
5º
6º // Ejecutamos la consulta (se devolverá true o false):
1º return pg_query( $conexion, $sql );
1º }
2º ?>
Creamos una función más para listar la tabla completa, en la cual utilizamos pg_num_rows() (devuelve el nú-
mero de registros encontrados) y pg_fetch_object() (devuelve los valores de los campos en un Objeto de PHP):
1º <?php
2º function listarPersonas( $conexion )
3º {
4º $sql = "SELECT * FROM tbl_personas ORDER BY id";
5º $ok = true;
6º
7º // Ejecutar la consulta:
1º $rs = pg_query( $conexion, $sql );
1º
2º if( $rs )
3º {
4º // Obtener el número de filas:
1º if( pg_num_rows($rs) > 0 )
1º {
2º echo "<p/>LISTADO DE PERSONAS<br/>";
3º echo "===================<p />";
4º
5º // Recorrer el resource y mostrar los datos:
1º while( $obj = pg_fetch_object($rs) )
2º echo $obj->id." - ".$obj->nombre."<br />";
1º }
2º else
3º echo "<p>No se encontraron personas</p>";
4º }
5º else
6º $ok = false;
7º
8º return $ok;
9º }
10º ?>
Por último, creamos una función que procesará una consulta y nos devolverá un Objeto en PHP con los datos del
registro encontrado:
1º <?php
2º function buscarPersona( $conexion, $id )
3º {
4º $sql = "SELECT * FROM tbl_personas WHERE id=".$id."";
5º $devolver = null;
6º
7º // Ejecutar la consulta:
1º $rs = pg_query( $conexion, $sql );
1º
2º if( $rs )
3º {
4º // Si se encontró el registro, se obtiene un objeto en PHP con
los datos de los campos:
1º if( pg_num_rows($rs) > 0 )
2º $devolver = pg_fetch_object( $rs, 0 );
1º }
2º
3º return $devolver;
4º }
5º ?>
A continuación, el código fuente principal del programa. Observa que debemos introducir los datos de acceso
(usuario, contraseña, dirección IP y nombre de la base de datos) para conectar con PostgreSQL:
Expand Code
También disponemos de la función pg_send_query() que permite enviar una consulta de forma asíncrona, pu-
diendo así enviar varias a la vez e irlas obteniendo de una en una con pg_result().
Notas ¶
Nota:
No todas las funciones son compatibles con todas las versiones. Eso depende de la ver-
sión de libpq (librería cliente C de PostgreSQL) y cómo ha sido compilado libpq. Si las ex-
tensiones de PHP PostgreSQL faltan, entonces es porque su versión de libpq no los admi-
te.
Nota:
La mayoría de las funciones PostgreSQL aceptan connection como primer parámetro op-
cional. Si no está siempre se usa la última conexión abierta. Si esta no existe las funcio-
nes retornarán FALSE.
Nota:
PostgreSQL cambia automáticamente todos los identificadores (ejm. tablas/nombres de
columnas) a minúsculas en el momento de la creación y al hacer las consultas. Para for-
zar el uso de mayúsculas se debe escapar el identificador usando comillas dobles ("").
Nota:
PostgresSQL no tiene comandos especiales para mostrar la información del esquema de
la base de datos (ejm. todas las tablas de la actual base de datos). En cambio, hay un es-
quema estándar llamado information_schema en PostgreSQL 7.4 o superior que contiene
las vistas del sistema con toda la información necesaria, es facilmente consultable. Vea
la » Documentación de PostgreSQL para más detalles.
Tabla de contenidos ¶
pg_affected_rows — Devuelve el número de registros afectados (filas)
pg_cancel_query — Cancelar una consulta asíncrona
pg_client_encoding — Obtiene la codificación del cliente
pg_close — Cierra una conexión PostgreSQL
pg_connect_poll — Verifica el estado de un intento de conexión asíncrono en curso de
PostgreSQL
pg_connect — Abre una conexión a PostgreSQL
pg_connection_busy — Permite saber si la conexión esta ocupada o no
pg_connection_reset — Restablece conexión (reconectar)
pg_connection_status — Obtener estado de la conexión
pg_consume_input — Reads input on the connection
pg_convert — Conviertir valores de un array asociativo en valores adecuados para sen-
tencias SQL
pg_copy_from — Insertar registros dentro de una tabla desde un array
pg_copy_to — Copiar una tabla a un array
pg_dbname — Obtiene el nombre de la base de datos
pg_delete — Borra registros
pg_end_copy — Sincronizar con PostgreSQL
pg_escape_bytea — Escapar un string para insertarlo en un campo bytea
pg_escape_identifier — Escape a identifier for insertion into a text field
pg_escape_literal — Escape a literal for insertion into a text field
pg_escape_string — Escape a string for query
pg_execute — Envía una solicitud para ejecutar una setencia preparada con paráme-
tros dados, y espera el resultado
pg_fetch_all_columns — Fetches all rows in a particular result column as an array
pg_fetch_all — Obtiene todas las filas de un resultado como un array
pg_fetch_array — Fetch a row as an array
pg_fetch_assoc — Fetch a row as an associative array
pg_fetch_object — Fetch a row as an object
pg_fetch_result — Returns values from a result resource
pg_fetch_row — Get a row as an enumerated array
pg_field_is_null — Test if a field is SQL NULL
pg_field_name — Returns the name of a field
pg_field_num — Returns the field number of the named field
pg_field_prtlen — Returns the printed length
pg_field_size — Returns the internal storage size of the named field
pg_field_table — Returns the name or oid of the tables field
pg_field_type_oid — Returns the type ID (OID) for the corresponding field number
pg_field_type — Devuelve el nombre de tipo para el número de campo correspondiente
pg_flush — Flush outbound query data on the connection
pg_free_result — Free result memory
pg_get_notify — Gets SQL NOTIFY message
pg_get_pid — Obtiene la ID del proceso del backend
pg_get_result — Get asynchronous query result
pg_host — Devuelve el nombre de host asociado a la conexión
pg_insert — Insert array into table
pg_last_error — Obtiene una cadena con el último mensaje de error de la conexión
pg_last_notice — Devuelve el último aviso del servidor PostgreSQL
pg_last_oid — Returns the last row's OID
pg_lo_close — Close a large object
pg_lo_create — Create a large object
pg_lo_export — Export a large object to file
pg_lo_import — Import a large object from file
pg_lo_open — Open a large object
pg_lo_read_all — Reads an entire large object and send straight to browser
pg_lo_read — Read a large object
pg_lo_seek — Seeks position within a large object
pg_lo_tell — Returns current seek position a of large object
pg_lo_truncate — Truncates a large object
pg_lo_unlink — Delete a large object
pg_lo_write — Write to a large object
pg_meta_data — Get meta data for table
pg_num_fields — Returns the number of fields in a result
pg_num_rows — Returns the number of rows in a result
pg_options — Obtener las opciones asociadas con la conexión
pg_parameter_status — Looks up a current parameter setting of the server
pg_pconnect — Abre una conexión persistente a PostgreSQL
pg_ping — Ping a conexión de base de datos
pg_port — Devuelve el número de puerto asociado con la conexión
pg_prepare — Submits a request to create a prepared statement with the given para-
meters, and waits for completion
pg_put_line — Send a NULL-terminated string to PostgreSQL backend
pg_query_params — Submits a command to the server and waits for the result, with the
ability to pass parameters separately from the SQL command text
pg_query — Ejecutar una consulta
pg_result_error_field — Returns an individual field of an error report
pg_result_error — Get error message associated with result
pg_result_seek — Set internal row offset in result resource
pg_result_status — Get status of query result
pg_select — Select records
pg_send_execute — Sends a request to execute a prepared statement with given pa-
rameters, without waiting for the result(s)
pg_send_prepare — Sends a request to create a prepared statement with the given pa-
rameters, without waiting for completion
pg_send_query_params — Submits a command and separate parameters to the server
without waiting for the result(s)
pg_send_query — Sends asynchronous query
pg_set_client_encoding — Set the client encoding
pg_set_error_verbosity — Determines the verbosity of messages returned by
pg_last_error and pg_result_error
pg_socket — Obtener un identificador de sólo lectura en el socket subyacente a una
conexión de PostgreSQL
pg_trace — Enable tracing a PostgreSQL connection
pg_transaction_status — Devuelve el estado actual de la transaccion del servidor
pg_tty — Devolver el nombre TTY asociado con la conexión
pg_unescape_bytea — Unescape binary for bytea type
pg_untrace — Desactivar el rastreo de una conexión de PostgreSQL
pg_update — Actualizar tabla
pg_version — Devuelve un array con el cliente, protocolo y versión del servidor (si está
disponible)
A simple conversion for 1D PostgreSQL array data:
// =====
//Example #1 (An array of IP addresses):
<?php
$pgsqlArr = '{192.168.1.1,10.1.1.1}';
print_r($phpArr);
}
// Output:
// Array
// (
// [0] => 192.168.1.1
// [1] => 10.1.1.1
// )
// =====
// =====
// Example #2 (An array of strings including spaces and commas):
<?php
$pgsqlArr = '{string1,string2,"string,3","string 4"}';
print_r($phpArr);
}
// Output:
// Array
// (
// [0] => string1
// [1] => string2
// [2] => string,3
// [3] => string 4
// )
// =====
up
down
3
saberit at home dot com ¶
17 years ago
I tried compiling PHP from source with PostgreSQL support (./configure --with-
pgsql=/usr/local/pgsql) and ran into a bunch of problems when trying to 'make'. The pro-
blem was that some of the PostgreSQL headers were not installed by default when I insta-
lled PostgreSQL from source. When installing PostgreSQL make sure you 'make install-all-
headers' after you 'make install'.
up
down
1
1413 at blargh dot com ¶
13 years ago
Here is some quick and dirty code to convert Postgres-returned arrays into PHP arra-
ys. There's probably a billion bugs, but since I'm only dealing with variable-depth-and-
length arrays of integers, it works for my needs.
Most notably, any data that might have commas in it won't work right...
<?php
function PGArrayToPHPArray($pgArray)
{
$ret = array();
$stack = array(&$ret);
$pgArray = substr($pgArray, 1, -1);
$pgElements = explode(",", $pgArray);
ArrayDump($pgElements);
foreach($pgElements as $elem)
{
if(substr($elem,-1) == "}")
{
$elem = substr($elem,0,-1);
$newSub = array();
while(substr($elem,0,1) != "{")
{
$newSub[] = $elem;
$elem = array_pop($ret);
}
$newSub[] = substr($elem,1);
$ret[] = array_reverse($newSub);
}
else
$ret[] = $elem;
}
return $ret;
}
?>
up
down
1
74012 dot 2773 at compuserve dot com ¶
14 years ago
for just a list of tables, this works with postgresql-7.2.1:
function pg_list_tables($db) {
$sql = "select relname from pg_stat_user_tables order by relname;";
return pg_query($db, $sql);
}
up
down
1
daniel at bichara dot com dot br ¶
16 years ago
Running RedHat Linux and Apache with suexec enabled you must include pgsql.so on
each .php file using dl("pgsql.so") and remove "extension=pgsql.so" from php.ini, other-
wise Apache (httpd) will not start.
up
down
0
WillowCatkin at hotmail dot com ¶
13 years ago
There is an example:
<?php
/*
* Define PostgreSQL database server connect parameters.
*/
define('PGHOST','10.0.0.218');
define('PGPORT',5432);
define('PGDATABASE','example');
define('PGUSER', 'root');
define('PGPASSWORD', 'nopass');
define('PGCLIENTENCODING','UNICODE');
define('ERROR_ON_CONNECT_FAILED','Sorry, can not connect the database server
now!');
/*
* Merge connect string and connect db server with default parameters.
*/
pg_pconnect('host=' . PGHOST . ' port=' . PGPORT . ' dbname=' . PGDATABASE . '
user=' . PGUSER . ' password=' . PGPASSWORD);
/*
* generate sql statements to call db-server-side stored procedure(or function)
* @parameter string $proc stored procedure name.
* @parameter array $paras parameters, 2 dimensions array.
* @return string $sql = 'select "proc"(para1,para2,para3);'
* @example pg_prepare('userExists',
* array(
* array('userName','chin','string'),
* array('userId','7777','numeric')
* )
*)
*/
function pg_prepare($proc, $paras)
{
$sql = 'select "' . $proc . '"(';
$sql .= $paras[0][2] == 'numeric' ? $paras[0][1] : "'" . str_replace("'","''",$paras[0][1]) . "'";
$len = count($paras);
for ($i = 1; $i < $len; $i ++)
{
$sql .= ',';
$sql .= $paras[$i][2] == 'numeric' ? $paras[$i][1] : "'" . str_replace("'","''",$paras[$i][1])
. "'";
}
$sql .= ');';
return $sql;
}
?>
up
down
0
abondi at ijk dot it ¶
14 years ago
I've found another function to mimic the following mysql list tables function
(http://www.php.net/manual/en/function.mysql-list-tables.php) that's more useful for my
target:
function pg_list_tables() {
$sql = "SELECT a.relname AS Name
FROM pg_class a, pg_user b
WHERE ( relkind = 'r') and relname !~ '^pg_' AND relname !~ '^sql_'
AND relname !~ '^xin[vx][0-9]+' AND b.usesysid = a.relowner
AND NOT (EXISTS (SELECT viewname FROM pg_views WHERE
viewname=a.relname));";
return(pg_query($conn, $sql));
}
up
down
-1
Anonymous ¶
12 years ago
Lots of advice on stored procedures didn't work for me. This did:
<?php
$response = pg_query( $connection, "BEGIN; DECLARE s CURSOR FOR SELECT
get_consumer('harry'); FETCH ALL IN s; END;" );
?>
<value> takes:
i for keys,
r for relations,
S for sequences
Note that all tables names that begins with 'pg_' are PostgreSQL internal tables (this ex-
plain why I use AND relname !~ '^pg_' condition).
up
down
-1
passion at monkey dot org ¶
17 years ago
I've tried to mimic the following mysql database connection functions for postgres.
http://www.php.net/manual/en/function.mysql-list-dbs.php
http://www.php.net/manual/en/function.mysql-list-tables.php
These are assuming that you're passing in $link as the result from pg_connect:
function pg_list_dbs($link)
{
$sql = 'SELECT datname FROM pg_database';
return (pg_query($link, $sql));
}
function pg_list_tables($link)
{
$sql = "SELECT relname FROM pg_class WHERE relname !~ '^pg_'";
return (pg_query($link, $sql));
}
up
down
-1
!spamcraig at ahdore dot com ¶
17 years ago
If you want to extract data from select statements, you need to store the result index, and
then apply pg_result to that value. Basically, do this
I'm new to php and had to do some fiddling around to work this out. It's reasonably ele-
mentary, but not demonstrated by the examples on these pages. Hopefully it will come in
useful to someone else.
up
down
-1
bleach at chek dot com ¶
18 years ago
If you want to see all the objects in a database, you can find that information in the
pg_class table. <BR>
SELECT * FROM pg_class;<BR>
Now this is going to be kind of long and complex, to see how psql command handles the \d
and other things. use the syntax. psql -E <Database>, ie psql -E mydatabase <BR>
What this will do is show the SQL command used for everything. So when you type a \d or
something, it shows the SQL query used for the result.
up
down
-2
Chris KL ¶
13 years ago
Here is a better array parser for PHP. It will work with 1-d arrays only. Unlike the example
below it will work in all cases.
/**
* Change a db array into a PHP array
* @param $arr String representing the DB array
* @return A PHP array
*/
function phpArray($dbarr) {
// Take off the first and last characters (the braces)
$arr = substr($dbarr, 1, strlen($dbarr) - 2);
// Do one further loop over the elements array to remote double quoting
// and escaping of double quotes and backslashes
for ($i = 0; $i < sizeof($elements); $i++) {
$v = $elements[$i];
if (strpos($v, '"') === 0) {
$v = substr($v, 1, strlen($v) - 2);
$v = str_replace('\\"', '"', $v);
$v = str_replace('\\\\', '\\', $v);
$elements[$i] = $v;
}
}
return $elements;
}
up
down
-2
adaml at mimuw edu pl ¶
14 years ago
Yes, PHP does support stored procedures
You have to add "select" before the name of the
procedure, just like that:
PHP will return values of PostgreSQL boolean datatype as single character strings "t" and
"f", not PHP true and false.
[Editor's Note]
't' or 'f' is valid boolean expression for PostgreSQL.
All values from PostgreSQL are strings, since PostgreSQL integer, float may be much lar-
ger than PHP's native int, double can handle. PostgreSQL array is not supported.
up
down
-1
anonymous at unknown dot com ¶
16 years ago
I just wanted to add to my previous post I've got the system up and running.
Environment: Windows XP, Apache 1.3.23, Php 4.3 RC2, PostGreSQL beta4 native win-
dows build
You must load the postgresql extension by editing the php.ini and restarting apache in or-
der to access psql with php.
Oh yeah, I created the data dir manually - don't know whether that was necessary
Grtz Vargo
up
down
-1
anis_wn at gawab dot com ¶
13 years ago
Setting up PostgreSQL for higher security PHP connection.
Case:
We want to connect to PostgreSQL database using username and password supplied by
webuser at login time.
Fact (Linux):
Apache (perhaps other servers, too) running the server as (default to) apache user ac-
count. So if you connect to PostgreSQL using default user, apache will be assingned for it.
If you hard code the user and password in your PHP script, you'll loose security restriction
from PostgreSQL.
Solution:
(You are assumed to have enough privilege to do these things, though)
1. Edit pg_hba.conf to have the line like the one below
host db_Name [web_server_ip_address] [ip_address_mask] md5
2. Add to you script the login page that submits username and password.
3. Use those information to login to PostgreSQL like these...
<?
$conn = "host=$DBHost port=$DBPort dbname=$DBName ".
"user='{$_POST['dbUsername']}' password='{$_POST['dbPassword']}'";
$db = pg_connect ($conn);
[your other codes go here...]
?>
4. You must add users in PostgreSQL properly.
5. For your convenience, you can store the username and password to $_SESSION varia-
ble.
Good luck.
Anis WN
up
down
-5
Anonymous ¶
12 years ago
Chris KL: Will parse well {"\\"}? The second " will be treat as escaped while it shoudn't...
El archivo de configuración de PHP
PHP posee un archivo de configuración cuyo nombre es php.ini y que podrás encontrar en el directorio de instala-
ción de PHP, o bien en la carpeta de tu sistema operativo Windows.
Si usas una distribución basada en Linux su ubicación varía dependiendo de la que uses. Una forma de localizarlo
es usando el siguiente comando:
find / -name "*php.ini*"
Para evitar posibles confusiones y quebraderos de cabeza a causa de editar un archivo php.ini que no es el que
está siendo realmente usado, lo mejor es crear un archivo llamado por ejemplo info.php (por ejemplo) con el si-
guiente código PHP:
1º <?php
2º phpinfo();
3º ?>
Tras copiarlo a la carpeta htdocs del servidor web Apache y ejecutarlo introduciendo
la URL http://127.0.0.1/info.php navegador web, deberías ver algo como:
En Loaded Configuration File podrás ver la ruta en la que se encuentra el archivo de configuración que está
siendo actualmente usado.
Sin embargo, existe una forma de configurar la ruta del archivo php.ini que deseemos usar, añadiendo al final
del archivo de configuración del servidor web Apache (llamado httpd.conf y que se encuentra en la subcarpe-
ta conf dentro del directorio de instalación del mismo) la siguiente línea, reiniciándolo posteriormente:
PHPIniDir "c:/php5"
NOTA: también podemos indicar la ruta usando doble barra inversa \\.
Añade también a las variables de entorno de tu sistema operativo el directorio en el que tengas instalado PHP, y
también el subdirectorio ext (en el que se encuentran las extensiones).
En los siguientes apartados te mostraremos algunas opciones de configuración útiles.
Recuerda que tras hacer algún cambio en el archivo de configuración de PHP deberás reiniciar el servidor web
Apache, para que surtan efecto los cambios.
ini_set
(PHP 4, PHP 5, PHP 7)
ini_set — Establece el valor de una directiva de configuración
Descripción ¶
string ini_set ( string $varname , string $newvalue )
Establece el valor de la directiva de configuración dada. La opción de configuración man-
tendrá este nuevo valor durante la ejecución del script, y se restaurará cuando acabe el
mismo.
Parámetros ¶
varname
No todas las directivas pueden ser modificadas con ini_set(). Hay una lista con todas las
directivas disponibles en el apéndice.
newvalue
El nuevo valor para la opción.
Valores devueltos ¶
Devuelve el valor anterior en caso de éxito, FALSE en caso de error.
Ejemplos ¶
Ejemplo #1 Establece una opción ini
<?php
echo ini_get('display_errors');
if (!ini_get('display_errors')) {
ini_set('display_errors', '1');
}
echo ini_get('display_errors');
?>
setlocale
(PHP 4, PHP 5, PHP 7)
setlocale — Establecer la información del localismo
Descripción ¶
string setlocale ( int $category , string $locale [, string $... ] )
string setlocale ( int $category , array $locale )
Establece la información del localismo.
Parámetros ¶
category
category es una constante con nombre que especifica la categoría de las funciones afec-
tadas por el localismo:
LC_ALL para establecer todas las siguientes
LC_COLLATE para la comparación de cadenas; véase strcoll()
LC_CTYPE para la clasificación y conversión de caracteres, por ejemplo strtoupper()
LC_MONETARY para localeconv()
LC_NUMERIC para el separador decimal (véase también localeconv())
LC_TIME para el formato de fecha y hora con strftime()
LC_MESSAGES para las respuestas del sistema (disponible si PHP fue compilado
con libintl)
locale
Si locale es NULL o el string vacío "", los nombres de los localismos se establecerán a
partir de los valores de las variables de entorno con los mismos nombres que las catego-
rías anteriores, o desde "LANG".
Si locale es "0", el localismo no se ve afectado, solamente devuelve la configuración ac-
tual.
Si locale es un array o le siguen parámetros adicionales, cada elemento del array o pará-
metro se intenta establecer como nuevo localismo hasta que se tenga éxito. Esto es útil si
un localismo se conoce con diferentes nombres en diferentes sistemas, o para proporcio-
nar un respaldo para un localismo posiblemente no disponible.
...
(String opcional o array de parámetros para probarlos como localismos hasta que se ten-
ga éxito.)
Nota:
En Windows, setlocale(LC_ALL, '') establece los nombres del localismo desde la configu-
ración regional o del lenguaje del sistema (accesible por medio del Panel de Control).
Valores devueltos ¶
Devuelve el nuevo localismo actual o FALSE si la funcionalidad del localismo no está im-
plementada en la plataforma, el localismo especificado no existe, o el nombre de la cate-
goría no es válido.
Un nombre de categoría no válido también produce un mensaje de advertencia. Se pue-
den encontrar los nombres de las categorías/localismos en la » RFC 1766 y en la » ISO
639. Diferentes sistemas tienen diferentes nomenclaturas para los localismos.
Nota:
El valor de retorno de setlocale() depende del sistema donde se está ejecutando PHP.
Devuelve exactamente lo que la función setlocale del sistema devuelve.
/* Probar diferentes nombres posibles de localismos para el alemán a partir de PHP 4.3.0
*/
$loc_de = setlocale(LC_ALL, 'de_DE@euro', 'de_DE', 'de', 'ge');
echo "El localismo preferido para el alemán en este sistema es '$loc_de'";
?>
Ejemplo #2 Ejemplos para Windows de setlocale()
<?php
/* Establecer el localismo al holandés */
setlocale(LC_ALL, 'nld_nld');
/* Probar diferentes nombres posibles de localismos para el alemán a partir de PHP 4.3
.0 */
$loc_de = setlocale(LC_ALL, 'de_DE@euro', 'de_DE', 'deu_deu');
echo "El localismo preferido para el alemán en este sistema es '$loc_de'";
?>
ini_get_all
(PHP 4 >= 4.2.0, PHP 5, PHP 7)
ini_get_all — Obtiene todas las opciones de configuración
Descripción ¶
array ini_get_all ([ string $extension [, bool $details = true ]] )
Devuelve todas las opciones de configuración registradas.
Parámetros ¶
extension
Un nombre de extensión opcional. Si se establece, la función de retornará únicamente op-
ciones específicas para esa extensión.
details
Recupera los detalles de configuración o sólo el valor actual de cada configuración. Por
omisión es TRUE(recuperar detalles).
Valores devueltos ¶
Devuelve un array asociativo con el nombre de la directiva como la clave del array.
Cuando el parámetro details es TRUE (por omisión) el array conten-
drá global_value (establecido en php.ini), local_value (tal vez establecido
con ini_set() o .htaccess), y access (el nivel de acceso).
Cuando el parámetro details es FALSE el valor será el valor actual de la opción.
Vea la sección del manual para obtener información sobre lo que significan los niveles de
acceso.
Nota:
Es posible que una directiva tenga múltiples niveles de acceso, por lo que
el access muestra los valores de máscara de bits adecuado.
Notas ¶
Nota:
ini_get_all() ignora las opciones ini de "array" como pdo.dsn.*.
Historial de cambios ¶
Versión Descripción
5.3.0 Se añadió details.
Ejemplos ¶
Ejemplo #1 ini_get_all() ejemplos
<?php
print_r(ini_get_all("pcre"));
print_r(ini_get_all());
?>
El resultado del ejemplo sería algo similar a:
Array
(
[pcre.backtrack_limit] => Array
(
[global_value] => 100000
[local_value] => 100000
[access] => 7
)
)
Array
(
[allow_call_time_pass_reference] => Array
(
[global_value] => 0
[local_value] => 0
[access] => 6
)
...
)
Ejemplo #2 Disabling details
<?php
print_r(ini_get_all("pcre", false)); // Se añadió en PHP 5.3.0
print_r(ini_get_all(null, false)); // Se añadió en PHP 5.3.0
?>
El resultado del ejemplo sería algo similar a:
Array
(
[pcre.backtrack_limit] => 100000
[pcre.recursion_limit] => 100000
)
Array
(
[allow_call_time_pass_reference] => 0
[allow_url_fopen] => 1
...
)
ini_restore
(PHP 4, PHP 5, PHP 7)
ini_restore — Restablece el valor de una opción de configuración
Descripción ¶
void ini_restore ( string $varname )
Restaura una opción de configuración dado su valor original.
Parámetros ¶
varname
El nombre de la opción de configuración.
Valores devueltos ¶
No devuelve ningún valor.
Ejemplos ¶
Ejemplo #1 ini_restore() ejemplo
<?php
$setting = 'y2k_compliance';
ini_restore($setting);
echo 'Valor original \'' . $setting . '\': ' . ini_get($setting), PHP_EOL;
?>
El resultado del ejemplo sería:
Valor actual 'y2k_compliance': 1
Nuevo valor 'y2k_compliance': 0
Valor original 'y2k_compliance': 1
Ver también ¶
ini_get() - Devuelve el valor de una directiva de configuración
ini_get_all() - Obtiene todas las opciones de configuración
ini_set() - Establece el valor de una directiva de configuración
add a note
<?php
/**
* Executes a function using a custom PHP configuration.
*
* @param array $settings A map<ini setting name, ini setting value>.
* @param callable $doThis The code to execute using the given settings.
* @return mixed Returns the value returned by the given callable.
*/
function ini_using_do(array $settings, callable $doThis){
foreach($settings as $name => $value){
$previousSettings[$name] = ini_set($name, $value);
}
$returnValue = $doThis();
if(isset($previousSettings)){
foreach($previousSettings as $name => $value){
ini_set($name, $value);
}
}
return $returnValue;
}
?>
También disponemos de la función parse_ini_string(), con la que podremos analizar una cadena de configura-
ción.
parse_ini_file
(PHP 4, PHP 5, PHP 7)
parse_ini_file — Analiza un fichero de configuración
Descripción ¶
array parse_ini_file ( string $filename [, bool $process_sections = false [, int $scanner_mode =
INI_SCANNER_NORMAL ]] )
parse_ini_file() carga el fichero ini especificado en filename, y devuelve las configuracio-
nes que hay en él a un array asociativa.
La estructura del ficher0 ini es la misma que la de php.ini.
Parámetros ¶
filename
El nombre del fichero ini que va a ser analizado.
process_sections
Al establecer el parámetro process_sections a TRUE, se obtiene un array multidimesional,
con los nombres de las secciones y las configuraciones incluidas. El valor por defecto
de process_sections es FALSE
scanner_mode
Puede ser o INI_SCANNER_NORMAL (por defecto) o INI_SCANNER_RAW.
Si INI_SCANNER_RAW es proporcionado, los valores de las opciones no serán analiza-
das.
A partir de PHP 5.6.1 también se puede especificar como INI_SCANNER_TYPED. En es-
te modo, los tipos boolean, null e integer se preservan siempre que sea posible. Los valo-
res de string "true", "on" y "yes" son convertidos a TRUE. "false", "off", "no" y "none" se
consideran como FALSE. "null" se convierte a NULL en el modo tipificado. También, todos
los string numéricos son convertidos al tipo integer fuera es posible.
Valores devueltos ¶
Las configuraciones son devueltas como un array asociativo si se tiene éxito,
y FALSE si falla.
parse_ini_string
(PHP 5 >= 5.3.0, PHP 7)
parse_ini_string — Analiza una cadena de configuración
Descripción ¶
array parse_ini_string ( string $ini [, bool $process_sections = false [, int $scanner_mode =
INI_SCANNER_NORMAL ]] )
parse_ini_string() devuelve las configuraciones de la cadena ini a una matriz asociativa.
La estructura de la cadena ini es la misma que la de php.ini.
Parámetros ¶
ini
El contenido del archivo ini que va a ser analizado.
process_sections
Al establecer el parámetro process_sections a TRUE, se obtiene una matriz multidimesio-
nal, con los nombres de las secciones y las configuraciones incluidas. El valor por defecto
de process_sections es FALSE
scanner_mode
Puede ser o INI_SCANNER_NORMAL (por defecto) o INI_SCANNER_RAW.
Si INI_SCANNER_RAW es proporcionado, los valores de las opciones no serán analiza-
das.
A partir de PHP 5.6.1 también se puede especificar como INI_SCANNER_TYPED. En es-
te modo, los tipos boolean, null e integer se preservan siempre que sea posible. Los valo-
res de string "true", "on" y "yes" son convertidos a TRUE. "false", "off", "no" y "none" se
consideran como FALSE. "null" se convierte a NULL en el modo tipificado. También, todos
los string numéricos son convertidos al tipo integer fuera es posible.
Valores devueltos ¶
Las configuraciones son devueltas como un array asociativo si se tiene éxito, y FALSE si
falla.
Notas ¶
Nota: Hay palabras reservadas que no se deben usar como claves en los archivos ini. És-
tas incluyen: null, yes, no, true, false, on, off, none. Los valores null, off, no y false resultan
en "", y los valores on, yes y true resultan en "1", a menos que se emplee el mo-
do INI_SCANNER_TYPED. Los caracteres ?{}|&~![()^" no se deben usar en ningún lugar
de la clave y tienen un significado especial en el valor.
Ver también ¶
parse_ini_file() - Analiza un fichero de configuración
add a note
User Contributed Notes 3 notes
up
down
22
epicmaxim at gmail dot com ¶
5 years ago
parse_ini_string_m is analog for a parse_ini_string function.
had to code this function due to the lack of a php 5.3 on some hosting.
parse_ini_string_m:
- ignores commented lines that start with ";" or "#"
- ignores broken lines that do not have "="
- supports array values and array value keys
<?php
function parse_ini_string_m($str) {
foreach($lines as $line) {
$line = trim($line);
if($inside_section) {
$key = rtrim($tmp[0]);
$value = ltrim($tmp[1]);
if(!isset($ret[$inside_section][$arr_name]) ||
!is_array($ret[$inside_section][$arr_name])) {
$ret[$inside_section][$arr_name] = array();
}
if(isset($matches[1]) && !empty($matches[1])) {
$ret[$inside_section][$arr_name][$matches[1]] = $value;
} else {
$ret[$inside_section][$arr_name][] = $value;
}
} else {
$ret[$inside_section][trim($tmp[0])] = $value;
}
} else {
$ret[trim($tmp[0])] = ltrim($tmp[1]);
}
}
return $ret;
}
?>
example usage:
<?php
$ini = '
[simple]
val_one = "some value"
val_two = 567
[array]
val_arr[] = "arr_elem_one"
val_arr[] = "arr_elem_two"
val_arr[] = "arr_elem_three"
[array_keys]
val_arr_two[6] = "key_6"
val_arr_two[some_key] = "some_key_value"
';
$arr = parse_ini_string_m($ini);
?>
Array
(
[simple] => Array
(
[val_one] => some value
[val_two] => 567
)
[array] => Array
(
[val_arr] => Array
(
[0] => arr_elem_one
[1] => arr_elem_two
[2] => arr_elem_three
)
)
)
up
down
2
Peter Baylies ¶
5 years ago
Replacement for php_ini_string() for PHP pre 5.3 - uses php_ini_file() and streams
<?php
if ( !function_exists( 'parse_ini_string' ) ) {
function parse_ini_string( $string, $process_sections ) {
if ( !class_exists( 'parse_ini_filter' ) ) {
/* Define our filter class */
class parse_ini_filter extends php_user_filter {
static $buf = '';
function filter( $in, $out, &$consumed, $closing ) {
$bucket = stream_bucket_new( fopen('php://memory', 'wb'), self::$buf );
stream_bucket_append( $out, $bucket );
return PSFS_PASS_ON;
}
}
/* Register our filter with PHP */
stream_filter_register("parse_ini", "parse_ini_filter")
or return false;
}
parse_ini_filter::$buf = $string;
re-
turn parse_ini_file( "php://filter/read=parse_ini/resource=php://memory", $process_section
s );
}
}
?>
up
down
0
msegit post pl ¶
6 months ago
With function parse_ini_stringM() below you can:
- fix unvalued fields ('key' (invalid) ==> 'key=' (OK) )
- fix unquotted values with equal sign '=' ('key=value_part1=value_part2' ==>
'key="value_part1=value_part2"')
- fix (solve) multidimensional arrays (makes 'key[key1][key2]=value' valid)
// Example:
$ini = '[a]
b
c=d
e=';
$ini .= '
f[g][2]=h
f[g][i]=j
f[g][][]=k
m=n=o';
Otra opción de la que disponemos es usar la función de PHP ini_set() para modificar temporalmente el valor de la op-
ción de configuración (durante el script PHP actual) sin tener que modificar el archivo de configuración:
Otra opción de configuración que podemos usar en el archivo php.ini es error_reporting, con la que podremos definir
qué tipos de mensajes deberían ser mostrados. Puede tomar como valor alguna de las constantes predefinidas que se
indican en el enlace facilitado al final de la presenta sección (su descripción también se encuentra en el archi-
vo php.ini).
También podemos configurar esta opción en tiempo de ejecución usando la función de PHP error_reporting().
1º <?php
2º error_reporting(E_ALL | E_STRICT);
1º ini_set('display_errors', "On");
1º ...
2º ?>
Recuerda que tras hacer las modificaciones en el archivo php.ini deberás reiniciar el servidor web Apache.
Configuración regional
Para configurar la zona horaria del servidor web, en el archivo php.ini disponemos de la opción de configura-
ción date.timezone, que podrá tener como valor uno de los timezones soportados especificados en el enlace al final de
la presente sección.
También podemos usar la función de PHP setlocale(), en la que especificaremos como primer parámetro la salida de
determinadas categorías de funciones en tiempo de ejecución, pudiendo éstas ser:
LC_COLLATE: para la comparación de cadenas de texto, ver strcoll().
LC_CTYPE: para la clasificación y conversión de caracteres, por ejemplo con strtoupper().
LC_NUMERIC: configura el carácter utilizado como separador decimal (ver también localeconv()).
LC_MESSAGES: para los mensajes devueltos por el sistema (disponible si PHP fue compilado con libintl).
error_reporting
(PHP 4, PHP 5, PHP 7)
error_reporting — Establece cuáles errores de PHP son notificados
Descripción ¶
int error_reporting ([ int $level ] )
La función error_reporting() establece la directiva error_reporting en tiempo de ejecu-
ción. PHP tiene varios niveles de errores para notificar, al utilizar ésta función se define el
nivel de duración (tiempo de ejecución) de sus scripts. Si el parámetro opcional level no
se define, la función error_reporting() sólo devolverá el nivel actual de notificación de
error.
Parámetros ¶
level
El nuevo nivel de error_reporting. Este nivel toma una máscara de bit o constantes nomi-
nadas. Al utilizar constantes nominadas se recomienda encarecidamente asegurar la
compatibilidad para versiones futuras. Según se añaden niveles de error, el rango de los
enteros incrementa, por lo que los niveles antiguos de errores basados en enteros no
siempre se comportarán como se esperaba.
Las constantes de niveles de error disponibles, y los significados actuales de esos niveles
de error están descritos en constantes predefinidas.
Valores devueltos ¶
Devuelve el nivel antiguo de error_reporting o el nivel actual si el parámetro level no se
proporciona.
session.auto_start = 0
session.use_only_cookies = 1
session.gc_maxlifetime = 1440
session.cookie_lifetime = 0
session.save_path: indica la ruta en la que se guardarán los archivos temporales de la sesión. Ejemplo (obser-
va la doble barra inversa, como configuración para Windows:
session.save_path = "c:\\Temp\\Sesiones"
session.cookie_path: indica la ruta en la que se guardarán las cookies de sesión. Ejemplo (observa la doble
barra inversa, como configuración para Windows):
session.cookie_path = "c:\\Temp\\Cookies"
Recuerda que tras hacer las modificaciones en el archivo de configuración deberás reiniciar el servidor web Apa-
che.
Es recomendable comprobar si las operaciones realizadas con las funciones de archivos explicadas se han realizado
correctamente (mediante los valores que devuelven en caso de error).
También podemos usar readfile() junto la función header() para enviar un archivo de modo que pueda ser descargado
por el usuario:
1º <?php
2º $archivo = "test.pdf";
3º
4º if( file_exists($archivo) )
5º {
6º // Enviamos el PDF al cliente
1º header("Content-type: application/pdf");
2º header("Content-Disposition: attachment; filename=".$archivo);
3º header("Content-length: ".filesize($archivo));
1º
1º readfile($archivo);
1º }
2º ?>
26º copy
(PHP 4, PHP 5, PHP 7)
copy — Copia un fichero
Descripción ¶
bool copy ( string $source , string $dest [, resource $context ] )
Realiza un copia del fichero source a dest.
Si se quiere mover un fichero, use la función rename().
Parámetros ¶
source
Ruta al fichero de origen.
dest
La ruta de destino. Si dest es un URL, la operación de copiado puede fallar si la envoltura
no admite la sobrescritura de ficheros existentes.
Advertencia
Si el fichero destino ya existe, será sobrescrito.
context
Un recurso de contexto válido creado con stream_context_create().
Valores devueltos ¶
1º Devuelve TRUE en caso de éxito o FALSE en caso de error.
Ejemplos ¶
Ejemplo #1 Ejemplo de copy()
<?php
$fichero = 'ejemplo.txt';
$nuevo_fichero = 'ejemplo.txt.bak';
if (!copy($fichero, $nuevo_fichero)) {
echo "Error al copiar $fichero...\n";
}
?>
move_uploaded_file
(PHP 4 >= 4.0.3, PHP 5, PHP 7)
move_uploaded_file — Mueve un archivo subido a una nueva ubicación
Descripción ¶
bool move_uploaded_file ( string $filename , string $destination )
Esta función intenta asegurarse de que el archivo designado por filename es un archivo
subido válido (lo que significa que fue subido mediante el mecanismo de subida HTTP
POST de PHP). Si el archivo es válido, será movido al nombre de archivo dado
por destination.
El orden de comprobación es especialmente importante si hay cualquier posibilidad de
que cualquier cosa hecha con los archivos subidos pueda revelar su contenido al usuario,
o incluso a otros usuarios en el mismo sistema.
Parámetros ¶
filename
El nombre de archivo del archivo subido.
destination
El destino del archivo movido.
Valores devueltos ¶
Devuelve TRUE en caso de éxito.
Si filename no es un archivo válido subido, no sucederá ninguna acción,
y move_uploaded_file() devolveráFALSE.
Si filename es un archivo subido válido, pero no puede ser movido por algunas razones,
no sucederá ninguna acción, y move_uploaded_file() devolverá FALSE. Adicionalmente,
se emitirá un aviso.
Ejemplos ¶
Ejemplo #1 Subida de múltiples archivos
<?php
$uploads_dir = '/uploads';
foreach ($_FILES["pictures"]["error"] as $key => $error) {
if ($error == UPLOAD_ERR_OK) {
$tmp_name = $_FILES["pictures"]["tmp_name"][$key];
// basename() puede evitar ataques de denegación de sistema de ficheros;
// podría ser apropiada más validación/saneamiento del nombre del fichero
$name = basename($_FILES["pictures"]["name"][$key]);
move_uploaded_file($tmp_name, "$uploads_dir/$name");
}
}
?>
rename
(PHP 4, PHP 5, PHP 7)
rename — Renombra un fichero o directorio
Descripción ¶
bool rename ( string $oldname , string $newname [, resource $context ] )
Intenta renombrar oldname a newname, moviéndolo a otro directorio si fuera necesario.
Si newname existe, lo sobrescribirá.
Parámetros ¶
oldname
Nota:
El nombre antiguo. La envoltura usada en oldname debe coincidir con la envoltura usada
en newname.
newname
El nuevo nombre.
context
Nota: Soporte para context fue añadido en PHP 5.0.0. Para una descripción de contexts,
refiérase aFlujos.
Valores devueltos ¶
Devuelve TRUE en caso de éxito o FALSE en caso de error.
tmp_name: nombre temporal del archivo subido junto con la ruta temporal (los archivos subidos se guardan
en un directorio temporal).
Comprimir y descomprimir
Desde PHP podremos comprimir y descomprimir archivos y carpetas de forma muy sencilla, pudiendo hacerlo en
los principales formatos de compresión de archivos: gz, rar, zip, etc.
En el siguiente ejemplo puedes ver cómo crear un archivo comprimido en formato ZIP utilizando la Cla-
se ZipArchive:
1º <?php
2º $archivo_origen1 = "logo.jpg";
3º $archivo_origen2 = "archivo.html";
4º $archivo_zip = "comprimido.zip";
5º
6º // Creamos una instancia de la clase ZipArchive:
7º $zip = new ZipArchive();
8º
9º // Creamos el archivo zip:
1º if ($zip->open($archivo_zip, ZIPARCHIVE::CREATE) === true )
1º {
2º // Añadimos archivos:
1º $zip->addFile( $archivo_origen1 );
2º $zip->addFile( $archivo_origen2 );
1º
2º // Cerramos el archivo zip:
1º $zip->close();
1º
2º echo "Proceso finalizado";
3º }
4º else
5º {
6º echo "Ha ocurrido un error";
7º }
8º ?>
Para descomprimir todos los archivos usaremos el método extractTo() (si la carpeta en la que se desea extraer
los archivos no existe será creada):
1º <?php
2º $archivo_zip = "comprimido.zip";
3º
4º // Creamos una instancia de la clase ZipArchive:
5º $zip = new ZipArchive();
6º
7º // Abrimos el archivo zip:
8º if( $zip->open($archivo_zip) === true )
9º {
1º $zip->extractTo('./temp/');
1º $zip->close();
2º
3º echo 'Archivo descomprimido';
4º }
5º else
6º {
7º echo 'Error al descomprimir';
8º }
9º ?>
Asegúrate de que queden descomentadas las líneas SMTP, smtp_port y sendmail_from (quitando el punto y coma) y
con los valores mostrados en la imagen anterior, guarda los cambios en el archivo y después reinicia el servidor web.
Si no tienes acceso a dicho archivo de configuración o no deseas realizar cambios en él, puedes usar la función de
PHP ini_set() para realizar dicha configuración en tiempo de ejecución del siguiente modo (los cambios se aplicarán
sólo hasta finalizar el script en PHP):
1º <?php
2º ini_set("SMTP", "localhost");
1º ini_set("smtp_port", 25);
2º ini_set("sendmail_from", "postmaster@localhost.com");
1º
2º ...
3º ?>
Si al volverlo a intentar aparece el siguiente mensaje, será porque no tienes instalado un servidor de correo electróni-
co, o no se encuentra bien configurado:
Failed to connect to mailserver at "localhost" port 25, verify your "SMTP" and "smtp_port" setting in php.ini or
use ini_set() in...
Si lo que deseas es enviar un Email desde tu ordenador y usas XAMPP en Windows, consulta el enlace al final de este
apartado para aprender a configurar el servidor de correo Mercury Mail que trae incorporado.
Normalmente los servicios de alojamiento web ya disponen de un servidor de correo instalado y configurado, con lo
que si tras realizar los cambios explicados anteriormente subes los archivos a tu cuenta de hosting y cargas la página
web desde allí, deberías poder enviar correos electrónicos sin mayor problema.
Si ves que el envío se realizó correctamente pero transcurridos unos minutos no te ha llegado el correo electrónico,
comprueba si está en tu carpeta de Correo no deseado o SPAM. Si tampoco lo ves allí comprueba la configuración de
tu cortafuegos o firewall
Recuerda que tras hacer las modificaciones en el archivo php.ini deberás reiniciar el servidor web Apache.
Vea también: [ Enviar EMail con PHP ] - [ Configurar XAMPP para enviar EMail a través de GMail (Windows) ]
Windows Vista: Inicio, Panel de Control, Sistema y Mantenimiento, Sistema, Configuración avanzada del
sistema, y en el cuadro de diálogo que se mostrará haremos clic en el botón Variables de entorno.
Windows XP: Inicio, Panel de Control, Sistema y en el cuadro de diálogo que aparecerá seleccionaremos la pes-
taña Opciones avanzadas y después haremos clic en el botón Variables de entorno.
Aparecerá la siguiente ventana, en la que editaremos y crearemos las variables de sistema mencionadas:
En el directorio de instalación de PHP localiza el archivo php.ini y busca en él la opcion de configura-
cion extension_dir: indica en ella la ruta al directorio ext que se encuentra dentro de la carpeta de instalacion de PHP,
por ejemplo:
A continuación sigue los pasos indicados para el sistema gestor de bases de datos (SGBD) deseado:
MySQL:
Si estás intentando acceder desde un ordenador diferente al que tiene instalado el servidor de bases de datos
MySQL y recibes el mensaje:
Warning: mysql_connect() [function.mysql-connect]: Host 'TU-HOST' is not allowed to connect to this MySQL
server in...
... debes crear un usuario indicando la direccion IP desde la cual podrá acceder (también se le podría dar acceso
desde cualquier IP), y asignarle los permisos deseados del siguiente modo (para ello deberás acceder como usua-
rio root):
PostgreSQL:
Si estás intentando conectar desde un ordenador diferente al que tiene instalado al servidor de bases de datos Post-
greSQL y te aparece el mensaje...
Unable to connect to PostgreSQL server: could not connect to server: Connection refused
... edita el archivo de configuración de PostgreSQL pg_hba.conf añadiendo la dirección IP desde la que deseas
acceder, por ejemplo (cambia la dirección IP que se muestra por la de tu ordenador):
Deberás editar otro archivo de configuración de PostgreSQL llamado postgresql.conf, añadiendo la siguiente línea:
Oracle:
En el archivo php.ini descomenta sólo la línea correspondiente a la versión de Oracle que utilices (las últimas ver-
siones de PHP incluyen soporte para Oracle 11g):
Si vas a acceder a Oracle de forma remota (no lo tienes instalado en el ordenador desde el que vas a acceder a
dicha base de datos) descarga e instala Instant Client desde este enlace:
Marca la opcion Accept License Agreement y selecciona Instant Client Package - Basic: antes de comenzar con
la descarga deberás introducir los datos de acceso de tu cuenta de Oracle, o crear una si no tienes.
Una vez descargado Instant Client, descomprímelo en un directorio y luego añádelo a la variable de en-
torno PATH de tu sistema operativo. Después reinicia el servidor web Apache.
En este punto, tras haber realizado los pasos anteriores deberíamos poder realizar la conexión con Oracle.
Aún nos resta un paso más: para configurar el juego de caracteres de modo que aparezcan las letras con tilde así
como las 'ñ' y otros caracteres especiales como el símbolo del euro, en el mismo cuadro de diálogo crea una varia-
ble de entorno llamada NLS-LANG y asígnale el valor SPANISH_SPAIN.WE8MSWIN1252 (consulta el enlace al
final de este apartado para ver otros valores admitidos).
Si sólo tenemos instalado Instant Client no es necesario definir las variables de en-
torno ORACLE_HOME ni ORACLE_SID.
Instant Client 11g funciona con Oracle 9.2, Oracle 10.x y Oracle 11.x.
Si continúas teniendo problemas después de seguir los pasos indicados anteriormente, comprueba también la configura-
ción de tu cortafuegos o firewall.
Recuerda que tras hacer las modificaciones en el archivo de configuración de PHP deberás reiniciar el servidor web
Apache.
Observa que hemos añadido el Content-type adecuado para enviar el correo electrónico en formato HTML, y
que usamos la etiqueta <br /> para insertar saltos de línea.
Fíjate también que hacemos uso de la función de PHP nl2br(): esto es así porque en los <textarea> se guardan los
saltos de línea con los caracteres utilizados por el sistema operativo, y puesto que vamos a enviar el Email en for-
mato HTML, con dicha función los convertimos a la etiqueta HTML <br> (si no lo hiciéramos, todo el cuerpo del
mensaje se mostraría en una sola línea).
Luego, por razones de seguridad comprobamos si estamos trabajando realmente sobre un archivo subido al
servidor y lo leemos obteniendo una cadena de texto, que posteriormente dividiremos en otras más pequeñas.
A continuación creamos la cabecera del EMail, teniendo en cuenta que lo siguiente a boundary debe ir entre
comillas dobles.
Después construimos el cuerpo del mensaje (la parte que corresponde al texto del E-Mail) insertando un sepa-
rador sl principio (fíjate en que se deben poner dos guiones medios seguidos).
Seguidamente y entre otros separadores, especificamos el comienzo y fin del archivo adjunto.
Una vez realizados todos los pasos, enviamos el correo electrónico (si no se seleccionó un archivo simplemen-
te se enviaría el texto del E-Mail).
IMPORTANTE: hay que tener en cuenta que si no se selecciona ningún archivo, el array $_POST[] contendrá un
elemento con un valor en la clave error de '4': dicho código informa de que no se subió ningún archivo. Para ver
otros códigos de error comprueba el enlace facilitado a continuación.
A continuación te mostramos otro ejemplo en el que podrás ver cómo enviar varios archivos adjuntos.
03_mail_adjuntos_2.html:
copytextpop-up
1º <html>
2º
3º <head>
4º <title>Enviar E-Mail desde PHP | informaticapc.com</title>
5º </head>
6º
7º <body>
8º <form name="frmMail" id="frmMail" action="03_mail_adjuntos_2.php"
method="post" enctype="multipart/form-data">
9º
10º Nombre del remitente: <input type="text" name="txtNombre"
id="txtNombre" /><br />
11º EMail destinatario: <input type="text" name="txtMail"
id="txtMail" /><br />
12º Mensaje:<br />
13º <textarea name="txtMensaje" id="txtMensaje" /></textarea><br
/>
1º Archivo adjunto 1: <input type="file" name="txtFile" id="txtFile"
/><br />
2º Archivo adjunto 2: <input type="file" name="txtFile2"
id="txtFile2" /><p />
1º
2º <input type="submit" name="btnSubmit" value="Enviar" />
3º
4º </form>
5º </body>
6º
</html>
03_mail_adjuntos_2.html:
7º <html>
8º
9º <head>
10º <title>Enviar E-Mail desde PHP | informaticapc.com</title>
11º </head>
12º
13º <body>
14º <form name="frmMail" id="frmMail" action="03_mail_adjuntos_2.php"
method="post" enctype="multipart/form-data">
15º
16º Nombre del remitente: <input type="text" name="txtNombre"
id="txtNombre" /><br />
17º EMail destinatario: <input type="text" name="txtMail"
id="txtMail" /><br />
18º Mensaje:<br />
19º <textarea name="txtMensaje" id="txtMensaje" /></textarea><br
/>
1º Archivo adjunto 1: <input type="file" name="txtFile" id="txtFile"
/><br />
2º Archivo adjunto 2: <input type="file" name="txtFile2"
id="txtFile2" /><p />
1º
2º <input type="submit" name="btnSubmit" value="Enviar" />
3º
4º </form>
5º </body>
6º
</html>
7º <?php
8º /*
9º En caso de que no puedas enviar los correos electrónicos y no puedas o quieras
10º editar el archivo de configuración 'php.ini', descomenta las siguientes líneas
con
11º las que modificamos la configuración en tiempo de ejecución. Si es necesario,
modifica
12º el valor adecuado.
13º */
14º //ini_set('SMTP', "localhost");
15º //ini_set('smtp_port', 25);
16º //ini_set('sendmail_from', "postmaster@localhost.com");
17º //ini_set('display_errors', "On"); // Mostrar los errores (usar sólo durante las
pruebas)
18º
19º // Comprobar si llegaron los datos requeridos:
20º if( !empty($_POST) &&
21º (isset($_POST['txtNombre']) && !empty($_POST['txtNombre'])) &&
22º (isset($_POST['txtMail']) && !empty($_POST['txtMail']))
23º )
24º {
25º // Indicar cabecera con el nombre del remitente. Si no indicamos la dirección de
correo puede que
26º // no se realice el envío a a otros servicios como Hotmail o Yahoo
27º $cabecera = "From: TU_NOMBRE <TU_CUENTA_DE_EMAIL@TU_SERVIDOR.com>\r\n";
28º
1º $datos = "";
2º $mensaje = "";
3º $contenido_archivos = "";
4º $hay_archivos = false;
1º
2º // Creamos una cadena aleatoria como separador entre cuerpo y archivos adjuntos:
1º $separador = md5(uniqid(time()));
1º
2º // Recorremos el array para leer cada archivo recibido:
1º foreach( $_FILES as $adjunto )
1º {
2º // Comprobamos si el archivo fue subido, y leemos su contenido:
1º if( is_uploaded_file($adjunto['tmp_name']) )
1º {
1º $hay_archivos = true;
1º
2º // Leemos el archivo obteniéndolo como una cadena de texto:
3º $archivo = fopen($adjunto['tmp_name'], "rb");
1º $datos = fread( $archivo, filesize($adjunto['tmp_name']) );
1º fclose($archivo);
2º
3º // Dividimos la cadena de texto en varias partes más pequeñas:
1º $datos = chunk_split( base64_encode($datos) );
1º
2º // Continuamos construyendo el cuerpo del mensaje, añadiendo el archivo:
1º $contenido_archivos .= "--".$separador."\r\n";
2º $contenido_archivos .= "Content-Type: ".$adjunto['type'].";
name='".$adjunto['name']."'\r\n";
3º $contenido_archivos .= "Content-Transfer-Encoding: base64\r\n";
4º $contenido_archivos .= "Content-Disposition: attachment; filena-
me='".$adjunto['name']."'\r\n\r\n";
5º $contenido_archivos .= $datos."\r\n\r\n";
1º }
2º }
3º
4º // Si se subieron archivos creamos las cabeceras necesarias:
1º if( $hay_archivos == true )
1º {
1º // Creamos la cabecera del mensaje:
2º $cabecera .= "MIME-Version: 1.0\r\n".
3º "Content-Type: multipart/mixed; boundary=\"".$separador."\"\r\n\r\n";
4º
5º // Construimos el cuerpo del mensaje para el texto, añadiendo al final los archivos
adjuntos:
6º $mensaje = "--".$separador."\r\n";
7º $mensaje .= "Content-Type:text/plain; charset='iso-8859-1'\r\n";
8º $mensaje .= "Content-Transfer-Encoding: 7bit\r\n\r\n";
9º $mensaje .= $_POST['txtMensaje']."\r\n\r\n".$contenido_archivos;
10º
11º // Separador de final del mensaje:
12º $mensaje .= "--".$separador."--";
1º }
2º else
3º {
4º // No se adjuntó ningún archivo, enviamos sólo el texto del mensaje:
5º
6º $mensaje = "Mensaje de: ".$_POST['txtNombre'].PHP_EOL;
7º $mensaje .= "EMail: ".$_POST['txtMail'].PHP_EOL.PHP_EOL;
8º $mensaje .= $_POST['txtMensaje'];
9º }
10º
11º // IMPORTANTE: debes sustituir la dirección de correo por aquella en que deseas
recibir el EMail:
1º $ok = mail( trim($_POST['txtMail']), "Mensaje de prueba", $mensaje, $cabecera );
1º
2º if( $ok == true )
3º echo "<p>El E-Mail ha sido enviado</p>";
4º else
5º echo "<p>ERROR al enviar el E-Mail</p>";
6º
7º echo "<p>Haz <a href='03_mail_adjuntos_2.html'>clic para volver al formula-
rio</a></p>";
8º }
9º else
10º {
11º $html = "<html>";
12º $html .= "<head>";
13º
14º // Después de cuatro segundos de mostrarse esta página web de error se redirig i-
ría a la URL especificada.
15º $html .= "<meta http-equiv='refresh' content='4;url=03_mail_adjuntos_2.html'>";
16º
17º $html .= "</head>";
18º $html .= "<body>";
19º $html .= "No han llegado todos los datos. En unos segundos será redirigido a la
página principal.";
20º $html .= "</body>";
21º $html .= "</html>";
22º
23º echo $html;
24º }
?>
Enviar E-Mail usando PHPMailer
La clase PHPMailer es una poderosa herramienta gratuita que nos facilitará la tarea de enviar correos electróni-
cos. Puedes descargarla gratis desde los enlaces facilitados al final de este apartado.
En el siguiente ejemplo, mediante PHPMailer accedemos al servidor de correo de GMail para enviar nuestros
correos electrónicos a través de dicho servicio (necesitaremos tener una cuenta en él).
04_mail_phpmailer.html:
copytextpop-up
1º <html>
2º <head>
3º <title>Enviar E-Mail desde PHP | informaticapc.com</title>
4º </head>
5º
6º <body>
7º <form name="frmMail" id="frmMail" action="04_mail_phpmailer.php" met-
hod="post">
8º
9º <textarea name="txtMail" id="txtMail" rows="10"
cols="60"></textarea><p/>
10º
11º <input type="submit" name="btnSubmit" value="Enviar" />
12º
13º </form>
14º </body>
</html>
15º <?php
16º /*
17º IMPORTANTE: descarga PHPMailer para tu versión de PHP desde el enlace facilitado
18º al final de este apartado, y copia los archivos incluídos con 'require()' en la
misma
19º carpeta del ejemplo.
20º */
21º require("class.phpmailer.php");
1º require("class.smtp.php");
1º
2º // Comprobar si se llegaron los datos
1º if( !empty($_POST) &&
1º (isset($_POST['txtNombre']) && !empty($_POST['txtNombre'])) &&
2º (isset($_POST['txtMail']) && !empty($_POST['txtMail'])) &&
3º (isset($_POST['txtMensaje']) && !empty($_POST['txtMensaje']))
4º )
5º {
6º
7º try
8º {
1º $mail = new PHPMailer(); // Crear una instancia de la Clase
1º
2º // Configuraciones para GMail
1º $mail->Host = "smtp.gmail.com"; // DATOS SERVIDOR CORREO
2º $mail->SMTPAuth = true; // Indicamos que el servidor requiere auten-
ticación
3º $mail->SMTPSecure = "tls";
4º $mail->Port = "587";
1º
2º // Datos de acceso a tu cuenta en GMail (usuario y contraseña):
3º $mail->Username = "TU_EMAIL@TU_SERVIDOR.com";
4º $mail->Password = "TU_PASSWORD";
5º
6º // FROM (la dirección de correo y el nombre que queremos que vea el usuario que lee
nuestro correo):
7º $mail->From = "test@prueba.com";
8º $mail->FromName = "TU NOMBRE";
9º
10º // Datos del Mensaje:
11º $mail->AddAddress($_POST['txtMail'], "DESTINATARIO"); // Email del DESTINATA-
RIO
12º $mail->Subject = "Asunto del mensaje"; // ASUNTO
13º $mail->IsHTML(false); // Indica si el CUERPO
estará en formato HTML
14º
15º // Cuerpo del mensaje:
16º $mail->AltBody = $_POST['txtMensaje']; // ... si el proveedor de correo
de destino no soporta HTML
17º $mail->Body = nl2br($_POST['txtMensaje']); // ... en HTML (obligatorio)
18º
19º // Si se adjuntó un archivo se añade al EMail:
1º if( empty($_FILES['txtFile']['name']) == false )
2º $mail->AddAttachment($_FILES['txtFile']['tmp_name'], $_FILES['txtFile']['name']);
1º
2º // Enviar el EMail
1º if(!$mail->Send())
1º echo "<p>No se puedo enviar el EMail</p>";
2º else
3º echo "<p>EMail enviado correctamente</p>";
4º }
5º catch(Exception $e )
6º {
7º echo "<p>Ha ocurrido un error al enviar el EMail</p>";
8º }
9º
10º }
11º else
12º {
13º echo "<p>No llegaron datos</p>";
14º }
15º
16º echo "<p>Haz <a href='04_mail_phpmailer.html'>clic para volver al formula-
rio</a></p>";
?>
Fíjate en que debes rellenar algunos datos: escribir tu cuenta de correo y su contraseña en GMail, así como el
nombre que deseas que aparezca como destinatario y la dirección de correo del destinatario.
Al igual que en el apartado anterior, si no te funciona el ejemplo por no tener de un servidor de correo instalado en
tu ordenador prueba a ejecutar la página web desde un alojamiento web, ya que probablemente tendrán un servi-
dor de correo preparado.
Mostrar y ocultar mensajes de error
Cuando estamos desarrollando una página o aplicación web es recomendable configurar PHP para que muestre los
mensajes de aviso o error, mientras que al pasar el proyecto a producción deberemos desactivarlos.
Para mostrar u ocultar los mensajes debemos tener descomentada la opción de configuración display_errors() en
el archivo php.ini, asignándole los valores 'On' (para mostrarlos) u 'Off' (para ocultarlos):
Otra opción de la que disponemos es usar la función de PHP ini_set() para modificar temporalmente el valor de la
opción de configuración (durante el script PHP actual) sin tener que modificar el archivo de configuración:
Otra opción de configuración que podemos usar en el archivo php.ini es error_reporting, con la que podremos
definir qué tipos de mensajes deberían ser mostrados. Puede tomar como valor alguna de las constantes predefi-
nidas que se indican en el enlace facilitado al final de la presenta sección (su descripción también se encuentra en
el archivo php.ini).
También podemos configurar esta opción en tiempo de ejecución usando la función de PHP error_reporting().
copytextpop-up
1º <?php
2º error_reporting(E_ALL | E_STRICT);
1º ini_set('display_errors', "On");
1º ...
?>
Después haremos clic en Admin... y en la ventana principal de Mercury iremos al menú Configuration, Mer-
curyS SMTP Server: seleccionaremos la pestaña Connection Control, desmarcaremos la casilla Don not
Permit SMTP relaying of non-local mail y pulsaremos el botón Aceptar.
A continuación iremos al menú Configuration, Protocol Modules..., marcaremos la casilla MercuryC SMTP
relaying client y pulsaremos el botón OK.
Posteriormente iremos al menú Configuration, MercuryC SMTP Client y estableceremos las opciones que
se muestran en la siguiente imagen (en Login username y Password indicaremos la dirección de correo elec-
trónico y contraseña de nuestra cuenta en GMail, respectivamente):
Para comprobar si los EMail se envían correctamente iremos al menú File, Send mail message. En el cua-
dro de diálogo que se mostrará escribiremos una dirección EMail en To y el asunto del mensaje en Subject,
para finalmente pulsar en Send:
Es posible que el Email tarde hasta un par de minutos en llegar en ser recibido.
Si ves que el envío se realizó correctamente pero transcurridos unos minutos no te ha llegado el correo electróni-
co, comprueba si está en tu carpeta de Correo no deseado o SPAM. Si tampoco lo ves allí comprueba la configura-
ción de tu cortafuegos o firewall
Recuerda que tras hacer las modificaciones en el archivo php.ini deberás reiniciar el servidor web Apache.