Para ejecutar código PHP, primero hay que tener un intérprete a mano. Hay varias formas de hacerlo: Instalar sólo el ejecutable (poco recomendable para no-linuxeros), instalar el ejecutable con algún servidor web (IIS, Apache, el que más le guste a cada uno), o conseguirse un hosting que provea PHP.

Los que opten por el primer camino suelen saber cómo hacerlo solos, así que los dejo (para probar uno de sus scripts, ejecutan php < script.php). Para los que elijan el segundo, tienen amplia documentación en el sitio de PHP. Y para los últimos, a usar Google.

PHP es un lenguaje que se “embebe” en el código HTML; se lo entremezcla con el contenido estático, cosa de no tener que poner un echo adelante de cada línea.

El intérprete simplemente imprime todo el contenido que entra, hasta que encuentra uno de los símbolos de apertura. por lo general es la secuencia <?php, aunque en algunos casos basta con <?. Luego, procesa toda la entrada hasta llegar a un ?>. Entonces, un archivo test.php que contenga:

echo "hola";
< ?php
echo "ejecutable";
?>

Daría como salida:

echo "hola";
ejecutable

(Aunque, dado que en HTML cualquier fin de línea, espacio, tabulación, etc., se reemplaza por un espacio (independientemente de la cantidad de espacios que haya), en un navegador se vería ‘echo “hola”; ejecutable’, todo en una misma línea.)

Una variable es un contenedor que almacena un valor. Una constante también. La diferencia radica, como indican sus nombres, en que el valor que guarda una variable puede cambiar en el transcurso de un programa, mientras que el de una constante se determina en un momento, y permanece igual hasta que éste se termina.

El ejemplo típico de constante es pi.

En algunos lenguajes, como en C, es necesario declarar una variable antes de poder utilizarla. En otros, como en PHP, una variable se declara tan pronto se le otorga un valor.

Variables:

$valor=1;

Constantes:

define("PI",3.14159);

Al principio puede parecer inútil una constante, después de todo se la puede reemplazar por una variable, pero con el tiempo se aprende que sí son útiles: si un valor se usa repetidamente en varios lugares diferentes, es bueno definirlo como una constante para evitar errores, o por si luego queremos cambiar su valor… en el primer caso, si en algún lugar escribimos 31.4159, el valor final estará mal. En el segundo, si queremos cambiar la precisión de PI de 3.14159 a un valor con 15 decimales, simplemente cambiamos el valor de la constante, y no en todos los lugares donde lo usemos (ejemplo: podemos calcular el área y perímetro de un círculo, y el volumen y superficie de una esfera, a partir de un radio, y todos éstos cálculos involucran a PI).

La asignación, simplemente, es el hecho de poner un valor en una variable. Se hace con el operador =. El valor asignado puede ser un literal (5, “Tordek”, 3.14159…), o el resultado de una operación (matemática, la aplicación de una función, una operación sobre cadenas, o alguna combinación de esto):

$a = 5;
$nombre = "Tordek";
$cuadrado = 4 * 4;
$saludo = "Hola, " . $nombre;

Para ver el valor de una variable (o el resultado de una operación), llamamos a echo.

Si no tuviéramos variables ni constantes, para imprimir los 4 valores que dije antes (perímerto y área de un círculo, y superficie y volumen de una esfera), deberíamos escribir algo así (para un radio 10):

(Nota: el punto es un operador de concatenación, es decir, “a”.”b”=”ab”. Cuando veamos cadenas lo explicaré más profundamente.)

echo "Perimetro: ". 2 * 3.14159 * 10;
echo "Superficie: ". 3.14159 * 10 * 10;
echo "Area: ". 4 * 3.14159 * 10 * 10;
echo "Volumen: ". 4/3 * 3.14159 * 10 * 10 * 10;

Si ahora hacemos que PI sea una constante, se ve todo más limpio:

define("PI", 3.14159);
echo "Perimetro: ".2 * PI * 10;
echo "Superficie: ". PI * 10 * 10;
echo "Area: ". 4 * PI * 10 * 10;
echo "Volumen: ". 4/3 * PI * 10 * 10 * 10;

Ahora, podemos poner el valor del radio en una variable, y si lo queremos cambiar, sólo tocamos un lugar:

define("PI", 3.14159);
$r=10;
echo "Perimetro: ".2 * PI * r;
echo "Superficie: ". PI * r * r;
echo "Area: ". 4 * PI *  r * r;
echo "Volumen: ". 4/3 * PI *  r *  r * r

Pero se sigue viendo algo apretado… podríamos hacer todos los cálculos primero, e imprimirlos después:

define("PI", 3.14159);
$r=10;

$perimetro = 2 * PI * r;
$superficie =  PI *  r * r;
$area = 4 * PI *  r * r;
$volumen = 4/3 * PI *  r *  r * r;

echo "Perimetro: ". $perimetro;
echo "Superficie: ". $superficie;
echo "Area: ". $area;
echo "Volumen: ". $volumen;

Sí, ahora es un poco más amplio, pero es discutiblemente más legible. Algún matemático en la audiencia puede notar que la operación PI * r se repite siempre, así que podría almacenar su valor en una constante, y reemplazarlo donde se lo necesite… pero esto termina haciendo que el código sea más difícil de leer (y feo), y lo que ganamos en velocidad en ahorrarnos tres multiplicaciones (se usa 4 veces, y se calcula 1) es tan minúsculo que es despreciable. Siempre se tiene que intentar que lo que se escribe sea fácil de entender, y por las variables se empieza.

• Resultado: El propósito es, precisamente, hacer algo…
• Orden: No podemos cocinar la torta antes de mezclar los ingredientes.
• Fin: En algún momento tiene que terminar. Un bucle infinito no sirve para nada.

Casi siempre existe más de un algoritmo para resolver la misma tarea. Por ejemplo, los algoritmos de ordenamiento: Dada una lista de elementos (por lo general son números en los ejemplos, pero se puede ordenar cualquier cosa que se pueda comparar como mayor/menor/igual que), devolver los elementos en orden.

Uno de los más simples es el llamado “Burbuja”:

Dada una lista L[1..n] de n elementos desordenados, recorrerla comparando cada par de elemento L[i] y L[i+1]; si L[i] > L[i+1], intercambiarlos. Si se hizo un cambio, repetir.

El algoritmo es simple y llega a un resultado ordenado, pero tiene un problema:

Por ejemplo, la lista L = [3,4,2,1]:

1. Primera pasada:
   1. 3
   2. 4 > 2: intercambiar. L = [3, 2, 4, 1]
   3. 4 > 1: intercambiar. L = [3, 2, 1, 4]
2. Segunda pasada:
   1. 3 > 2: intercambiar. L = [2, 3, 1, 4]
   2. 3 > 1: intercambiar. L = [2, 1, 3, 4]
   3. 3
3. Tercera pasada:
   1. 2 > 1: intercambiar. L = [1, 2, 3, 4]
   2. 2
   3. 3
4. Cuarta pasada (comprobación):
   1. Nada cambia.

Lista devuelta: [1, 2, 3, 4].

El problema del algoritmo: la velocidad. En el mejor de los casos (la lista está ordenada), es necesario hacer n-1 comparaciones. En el peor, n²-n (n pasadas de n-1 comparaciones). Para números chicos, no pasa nada, pero en una lista medianamente grande, digamos, 1000 elementos, son 999000 pasadas.

Se puede arreglar un poco: en cada pasada, el elemento más grande se va al final (pruebenlo todas las veces que quieran), así que no es necesario comparar los dos últimos elementos (entonces cada recorrido hacemos n, n-1, n-2, …, 3, 2, 1 comparaciones). La cantidad de pasadas total entonces se hace igual a la suma de todos los números entre 1 y n-1 (inclusive): n²/2. Sigue siendo medio millón.

Claro que, así como este algoritmo es lentísimo, ocupa muy poca memoria; al elegir un algoritmo se tienen que comparar todas las ventajas y desventajas que tenga.