Introducción al PHP y a las librerías 2

Printf, sprintf

El formato de llamada de estas funciones es exactamente igual que en C.

Echo

Echo
en realidad no es una función sino una construcción del lenguaje, por
ello se puede poner tanto con paréntesis como sin paréntesis.

Evaluación de variables con Eval

La
función Eval($strExpr) permite evaluar la expresión $strExpr, de manera
que si contiene código PHP válido, éste será interpretado. Esto permite
cosas muy flexibles como por ejemplo callbacks:

function mycallback($strParam) {
Echo("Dentro del callback
con parámetro $strParam");
}

function myfunc($fnCallback) {
// Creamos una tabla
Echo("

Callback1:

"); // Llamamos al callback Eval($fnCallback); // Cerramos la tabla Echo("

");
}
$strCode = 'global $strParam; mycallback($strParam);';
$strParam = "Soy el parámetro del callback";
myfunc($strCode);


Podemos emplear otra técnica para hacer callbacks más sencillos con:

function mycallback() {
Echo("Dentro del callback.
");
}
$strCallback = "mycallback";
// Llamamos al callback
$strCallback();


Variables variables

No, el título no está equivocado, las variables variables son formas de indireccionamiento a la hora de referirse a variables.

Si
tenemos dos variables $strVarName y $nValue y hacemos que $strVarName
contenga la cadena "nValue", al referirnos a $$strVarName (nótese el
doble dólar "$$") nos estamos refiriendo a la variable que tiene como
nombre el contenido de $strVarName, es decir, a $nValue.

Lo anterior plasmado en un ejemplo sería:

$nValue = 5;
$strVarName = "nValue";
Echo("Mostrando el valor de $strVarName: $$strVarName.
");
$$strVarName = 5;
Echo("Ahora $strVarName vale $$strVarName.
");


En los casos en los que haya ambigüedad, puede emplearse el agrupador {}, por ejemplo, para $$myarray[0]), podríamos referirnos:

1. Al primer elemento del array que tiene como nombre el contenido de la variable $myarray.
2. A la variable que tiene como nombre el contenido de $myarray[0].

Si
empleásemos el operador de agrupación para evitar la ambigüedad, el
primer caso lo escribiríamos ${$myArray}[0] y ${$myArray[0]} en el
segundo.

Control de errores Error_Reporting

Mediante la
función Error_Reporting(mask) se pueden limitar los errores que captura
el intérprete de PHP y ante los que aborta la ejecución del programa de
entre los siguientes:

* E_ERROR (1)
* E_WARNING (2)
* E_PARSE (4)
* E_NOTICE (
* E_CORE_ERROR (16)
* E_CORE_WARNING (32)

Por ejemplo, con:

Error_Reporting(E_NOTICE | E_WARNING);


Se hará que el intérprete de PHP no capture los errores distintos de NOTICEs o de WARNINGs, para que podamos tratarlos nosotros.

Es
habitual deshabilitar E_NOTICE cuando se emplea la función IsSet para
comprobar si se inicializó una variable, ya que si no se hace así, y la
variable no fue inicializada dará un error y el intérprete abortará la
ejecución:

// Deshabilitamos notices
$nOldMask = Error_Reporting(~E_NOTICE);
if (IsSet($btnAlta)) {
// Pulsó el botón de alta en el form
Echo("Dando de alta el elemento solicitado.
");
} elseif (IsSet($btnBaja)) {
// Pulsó el botón de baja en el form
Echo("Dando de baja el elemento solicitado.
");
}
// Restauramos la máscara de error antigua
Error_Reporting($nOldMask);


Opcionalmente puede deshabilitarse la detección de errores para una sola sentencia anteponiendo la arroba "@" a la sentencia.

Die, exit

Se emplean para terminar la ejecución del script abruptamente.

* Die($msg) muestra el mensaje $msg antes de salir.
* Exit() sale de la ejecución del script.

1.9 Librerías

Include

Incluye el fichero cada vez, por si se desea meter esta instrucción en un bucle:

// Array con los nombres de las librerías
$arrLibraries = Array("include1.php3", "include2.php3",
"include4.php3");
// Iteramos por cada nombre de librería
while (list($nIndex, $strLibname) = each(arrLibraries)) {
// Incluímos esta librería
include($strLibname);
}


Require

Se
reemplaza la instrucción Require("nomfich") por el fichero. Es lo que
se suele usar normalmente para incluir librerías externas.

1.10 Clases (Objetos)

Para
declarar un objeto en PHP usamos la construcción class, las variables
de instancia se declaran anteponiendo var al nombre y las funciones
miembro se definen dentro del bloque de la clase como funciones
normales y corrientes. Un constructor se define como una función con el
mismo nombre que el objeto.

Para referirnos al propio objeto o a variables miembro, empleamos $this->.

Un ejemplo de todo lo anterior sería:

class MyObject {
var $nCount = 0;
var $strName;
function MyObject($strName="Nonamed") {
$this->strName = $strName;
}
function AddCount($nDelta) {
$this->nCount += $nDelta;
}
function GetCount() {
return $this->nCount;
}
}


Como
vemos, en las funciones miembro podemos emplear parámetros por defecto
y cualquier cosa que emplearíamos en una función normal.

Para usar este objeto, haríamos:

$myObj = new MyObject("Pepito");
Echo("Count vale " . $myObj->GetCount() . "
");
$myObj->AddCount(5);
Echo("Ahora count vale " . $myObj->GetCount());


Mucho
cuidado con las mayúsculas y minúsculas en los nombres de las variables
de tipo objeto, porque el PHP tiende a ser case sensitive con éstas.

2. Librerías de Bulma

A
lo largo de todos los ficheros PHP de Bulma, se sigue la notación
húngara (bueno, técnicamente es un derivado denominado notación
checoslovaca, creo), es decir, anteponer el prefijo de tipo al nombre
de la variable.

Me gustaNo me gusta