logo cosasdedevs

Primeros pasos en PHP

Primeros pasos en PHP

My Profile
Oct 19, 2020

¡Hola! Lo prometido es deuda y como dije vamos a empezar a ver tutoriales de PHP en cosasdedevs 💪. Para empezar vamos a crear un tutorial introductorio con lo más básico de PHP para entender la estructura básica a todo el que se quiera iniciar en este lenguaje. ¡Empezamos!

Instalación de PHP

Para instalar PHP podéis ver como hacerlo desde la página de PHP según el SO que tengáis o bien utilizar xampp que es una herramienta que además de instalar PHP te instala apache y mariadb para tener un server completo en tu máquina local. Para instalarlo podéis seguir el siguiente enlace:

https://www.apachefriends.org/es/index.html

Para este tutorial usaremos PHP 7.3 aunque los ejemplos que usemos funcionarán en todas las versiones de PHP 7.

Hola mundo

Ahora que ya tenemos PHP instalado, es hora de crear nuestro hola mundo. Para ello crearemos un archivo llamado primeros-pasos.php (muy importante la extensión PHP).

Para hacer él hola mundo, añadiremos el siguiente código a nuestro archivo:

<?php

echo 'Hola Mundo';

Lo primero que siempre tenemos que hacer al crear un script con PHP es añadir <?php, esto hará que todo lo que se cree después de esta línea lo interprete como código PHP.

Utilizaremos echo para imprimir texto y entre comillas añadimos el texto que queremos mostrar. Por último cerramos con ; para terminar la instrucción.

Para lanzar el script, abrimos nuestro terminal en el directorio donde tenemos alojado el archivo y lo ejecutamos de la siguiente forma:

php primeros-pasos.php

Comentarios

Hay tres formas de crear comentarios en nuestro código. Para crear comentarios de una línea usamos // o # y para comentarios en los que queramos englobar más de una línea usaremos /* <comentarios> */

// Esta es una forma de crear comentarios
#  Esta es la segunda forma
/*
De esta forma podemos añadir comentarios 
en varias líneas
*/

Variables

Para declarar una variable en PHP solo debemos añadir el símbolo del dólar seguido del nombre que le queramos dar a la variable. Al no existir tipado (al menos por ahora) según el formato en el que asignemos el valor será de un tipo u otro:

// $var será de tipo int
$var = 1;
// Sin embargo $var2 al estar entre comillas se considerará de tipo string
$var2 = '1';
// También podemos crear variables de tipo float como se ve en $var3
$var3 = 1.1;

Si queremos imprimir el valor de nuestras variables además de echo podemos utilizar print_r o var_dump. print_r mostrará el valor de la variable y var_dump además del valor nos mostrará el tipo. Si por ejemplo queremos imprimir el valor de las variables creadas anteriormente lo haremos de la siguiente forma:

print_r($var);
print_r($var2);
print_r($var3);

var_dump($var);
var_dump($var2);
var_dump($var3);

Al ejecutar el script este será el resultado:

1
1
1.1
int(1)
string(1) "1"
float(1.1)

Variables dinámicas

También podemos crear variables dinámicas y llamarlas con doble símbolo del dólar ($$), esto hará que si tenemos guardado el nombre de una variable en otra, podamos obtener el valor de la primera sin llamarla directamente:

$call_me = 'Hola mundo';
$saludar = 'call_me';
echo $$saludar . PHP_EOL;
// El resultado es Hola mundo

A parte del imprimir la variable, en el echo podréis ver que he añadido PHP_EOL, esto es una constante de PHP que significa end of line, esto generará un salto de línea y hará más legibles los resultados que imprimamos por pantalla. El punto lo utilizamos para concatenar cadenas, en este caso la variable dinámica con PHP_EOL.

Aritmética

La aritmética en PHP es similar a otros lenguajes, para realizar los cálculos utilizaremos los siguientes operadores:

//Sumar
$suma = 2 + 4;
echo $suma . PHP_EOL;
//Restar
$resta = 2 - 4;
echo $resta . PHP_EOL;
//División
$dividir = 10 / 2;
echo $dividir . PHP_EOL;
//Multiplicar
$multiplicar = 5 * 2;
echo $multiplicar . PHP_EOL;
// Exponencial
$exponencia = 5 ** 5;
echo $exponencia . PHP_EOL;

Bloques de código

Comparaciones por asignación

Para realizar comparaciones por asignación en PHP y saber si una comparación es verdadera o falsa tenemos los siguientes operadores, estos nos devolverán un valor booleano true si se cumple y false si no se cumple la condición:

Si queremos comparar si dos valores son iguales pero no nos importa si su tipo es distinto usaremos ==.

// Tanto en un caso como en el otro devolverá true, ya que el valor es igual aunque en el segundo ejemplo el tipo es distinto
echo(5 == 5) . PHP_EOL;
echo('5' == 5) . PHP_EOL;

En el caso de que queramos comparar tanto el tipo como el valor usaremos la triple igualdad ===.

echo(5 === 5) . PHP_EOL;// El resultado es true
echo('5' === 5) . PHP_EOL;// El resultado es false

Si queremos comprobar si dos datos son ejemplos tenemos la negación por valor != y por valor y tipo !==:

echo (4 != 5) . PHP_EOL;// Devuelve true
echo (4 != '4') . PHP_EOL;// Devuelve false ya que no compara los tipos
echo (4 !== 5) . PHP_EOL;// Devuelve true
echo (4 !== 4) . PHP_EOL;// Devuelve false

Ahora vamos a ver los casos para mayor o mayor igual y menor o menor igual:

Para comparar si un dato es mayor a otro usaremos >, si queremos saber si es mayor o igual usaremos >=:

echo (5 > 3) . PHP_EOL;// Devuelve true
echo (5 > 5) . PHP_EOL;// Devuelve false
echo (5 >= 5) . PHP_EOL;// Devuelve true
echo (5 >= 4) . PHP_EOL;// Devuelve false

Para el caso de querer comprobar si es menor utilizaremos < y para comparar si es menor o igual usaremos <=:

echo(2 < 3) . PHP_EOL;// Devuelve true
echo(6 < 5) . PHP_EOL;// Devuelve false
echo(5 <= 5) . PHP_EOL;// Devuelve true
echo(5 <= 4) . PHP_EOL;// Devuelve false

Operadores lógicos

Los operadores lógicos más utilizados son && (y) || (o) y ! (distinto) pero veámoslos en unos ejemplos.

Cuando utilizamos && queremos saber si se cumplen dos o más condiciones:

$var1 = 1;
$var2 = 1;
$var3 = 0;
echo ($var1 === 1 && $var2 === 1) . PHP_EOL;// Devuelve true
echo ($var1 === 1 && $var2 === 1 && $var3 === 1) . PHP_EOL;// Devuelve false ya que $var3 no es igual a true y si usamos el operador && necesitamos que se cumplan todas las condiciones

En el caso || queremos saber si se cumple una condición u otra:

$var1 = 1;
$var2 = 1;
$var3 = 0;
echo($var1 === 1 || $var2 === 1) . PHP_EOL;// Devuelve true
echo($var1 === 1 || $var2 === 1 || $var3 === 1) . PHP_EOL;// Devuelve true ya que al menos se cumple una condición
echo($var1 === 0 || $var2 === 0 || $var3 === 1) . PHP_EOL;// Devuelve false ya que no se cumple ningúna condición

Con el operador ! comprobaremos sino se cumple una condición, sino se cumple devolverá true y si es afirmativo devolverá false:

$var1 = true;
$var2 = false;

echo(!$var1) . PHP_EOL;// Devuelve false ya que comprueba si el valor es falso.
echo(!$var2) . PHP_EOL;// Devuelve true ya que ve que el valor es falso.

Estructuras de control

Las estructuras de control nos permiten ejecutar partes de código si se cumplen unas condiciones:

La primera estructura de la que vamos a hablar es if, si se cumple la condición accederá a la parte del código contenida en él:

$edad = 20;
if($edad >= 18){
  echo "Eres mayor de edad";
}
// Al cumplirse la condición se imprimirá por pantalla el echo

También podemos ejecutar otra instrucción distinta si no se cumple la condición con else:

$edad = 17;
if($edad >= 18){
  echo "Eres mayor de edad";
}else{
  echo "Eres menor de edad";
}
// En este caso al no cumplirse la condición del if se muestra el mensaje contenido en el else

Por último con la estructura if también podemos encadenar varias condiciones con elseif:

$edad = 40;
if ($edad >= 65) {
    echo "Estas en la tercera edad";
} elseif ($edad >= 18 && $edad < 65) {
    echo "Eres mayor de edad";
} else {
    echo "Eres menor de edad";
}
// En este caso comprueba la primera condición, como no se cumple pasa a revisar la segunda condición, al cumplirse, muestra el resultado contenido en el elseif

El siguiente bloque que vamos a ver es el ciclo for, este iterará sobre un rango de números y se ejecutará hasta que se cumpla una condición:

for ($i=0; $i < 10; $i++) {
    echo $i . PHP_EOL;
}

El ciclo for tiene tres partes, la primera es la variable y el punto desde que se va a iniciar, en este caso desde el número 0, la segunda parte será la que dirá al for hasta cuando tiene que ejecutarse, en este caso el ciclo se ejecutará mientras el valor de $i sea menor a 10. Por último $i++ hará que con cada iteración el valor de $i se incremente en 1, por lo tanto, cuando se ejecute 10 veces se cumplirá el ciclo y terminará. El resultado del ciclo for será el siguiente:

0
1
2
3
4
5
6
7
8
9

Ahora veremos el ciclo while. Este es similar al ciclo for pero no contiene ni la variable inicial ni el valor que podemos incrementar o disminuir hasta que se cumpla la condición:

$i = 0;
while ($i < 25) {
    echo $i . PHP_EOL;
    $i++;
}

En este caso, el ciclo while se ejecutará mientras se cumpla la condición de $i menor a 25. En cada ciclo lo incrementamos porque si no crearíamos un ciclo infinito y la podríamos liar parda 😂.

A parte del ciclo while, existe una versión llamada do while que es similar a while pero en este caso la comprobación de sí se cumple la condición, la realiza al final del ciclo por lo que al menos se ejecutará una vez el ciclo se cumpla o no:

$continua = false;
do {
    echo 'Hola' . PHP_EOL;
} while ($continua === true);

En este caso el ciclo se ejecutará una sola vez, ya que no cumple la condición de que la variable $continua es igual a false.

Por último vamos a ver la sentencia switch. Esta es similar a if pero en este caso la sentencia switch recibirá una variable o valor y tendrá 1 o varios casos, si el valor del caso coincide con el valor enviado al switch, se ejecutará el código contenido en ese caso. Si no se cumple ninguna condición también tienes la posibilidad de que se ejecute un código default.:

$variable = 'test1';

switch ($variable) {
    case 'test1':
        echo 'Test 1' . PHP_EOL;
        break;
    case 'test2':
        echo 'Test 2' . PHP_EOL;
        break;
    default:
        echo 'Test no encontrado' . PHP_EOL;
        break;
}

En este caso se imprimirá el texto Test 1, ya que el texto añadido en él case coincide con la variable enviada por el switch. Al entrar dentro del caso se ejecuta el código añadido en el switch y por último utiliza break que lo que hace es romper el ciclo y evita que se siga ejecutando el ciclo para comprobar los demás casos, ya que ha encontrado el caso que buscaba. Sino hubiera encontrado ninguna coincidencia, se habría ejecutado el código dentro del caso default.

Conclusiones

Si ya habéis programado anteriormente en otros lenguajes, este será un buen punto para iniciarse, de todas formas si tienes algún problema, no dudes en consultarlo en los comentarios 😁.

Como siempre, os recomiendo seguirme en Twitter y nos vemos en el siguiente tutorial 👋.

También te puede interesar:

Nos tomamos en serio tu privacidad

Utilizamos cookies propias y de terceros para mejorar la experiencia del usuario a través de su navegación. Si pulsas entendido aceptas su uso. Ver política de cookies.

🐍 Sígueme en Twitter

Si te gusta el contenido que subo y no quieres perderte nada, sígueme en Twitter y te avisaré cada vez que cree contenido nuevo 💪
Luego ¡Te sigo!