Sintaxis PHP: Tipos de datos, variables, enteros, punto flotante, strings, booleanos, arreglos en PHP

PHP: tipos de datos, variables, arreglos...

En la sección anterior vimos que el lenguaje PHP ejecuta eventos de cálculo y exposión de datos e imágenes, primero desde el servidor (en modo remoto) y luego hacia el software navegador web frente a nosotros (en modo local).

En esta sección revisaremos importantes conceptos en tipos de datos, variables, constantes y funciones, entre otros. En casi todos los lenguajes de programación actuales, las variables guardan datos que se espera serán alterados luego; las constantes, en cambio, alojan datos que sabemos no podrán cambiar; y finalmente las funciones ejecutan un bloque de código, pero con diferentes valores en cada ejecución (en caso de requerirlo así). Eso, para ahorrar esfuerzo de cómputo al ejecutar un mismo bloque de código.

Literales, identificadores, variables

Los literales son caracteres usados para mostrar informaciín, calcular números o identificarlos como un significado útil. Por ejemplo son datos literales: 2025, 13.141643, "Guayaquil-Ecuador", false, null, 0.

Los identificadores son nombres que usamos para identificar datos o bloques de código (como las funciones). Ya que un valor por sí mismo no podría ser identificado o diferenciado de entre otros, entonces usamos nombres identificadores.

Variables

En PHP uno de esos identificadores son las variables. Para un lenguaje de programación, una variable permite recordar datos. Las variables son nombres de datos que representan un espacio de memoria en el sistema. Gracias a eso, ese dato podrá ser accedido para operarlo según necesidades de programación. Las variables en PHP inician con el signo $ seguido de uno o más caracteres-letras. No se aceptan números luego de ese caracter, pero sí al final del identificador.

En .PHP

<?php

     $ciudad = "Guayaquil";
     echo ($ciudad);
     // Muestra Guayaquil

     $ciudad3000 = "Guayaquil";
     echo ($ciudad3000);
     // Muestra Guayaquil

     $_ciudad_hermosa = "Guayaquil";
     echo ($ciudad3000);
     // Muestra Guayaquil

     $_ciudad_hermosa = "Guayaquil";
     echo ($_ciudad_hermosa);
     // Muestra Guayaquil

     $__ciudad0 = "Guayaquil";
     echo ($__ciudad0);
     // Muestra Guayaquil

     // Variable unica
     $paisBello = 593;
     echo ($paisBello);
     // Muestra 593

     // Variable unica
     $paisBELLO = 2025;
     echo ($paisBELLO);
     // Muestra 2025

     // Variable unica
     $PAISbello = "2025";
     echo ($PAISbello);
     // Muestra 2025

     // --ERROR- No debe haber numeros luego de signo $
     // $3ciudad = "Guayaquil";
     // echo ($3ciudad);
     // --ERROR

     // ERROR: los identificadores no son los mismos
     // detectar las diferencias
     // $_ciudad_hermosa = "Guayaquil";
     // echo ($_Ciudad_hermosa);
     // Muestra Guayaquil

?>

Las constantes también alojan datos, pero como valores fijos entre paréntesis, como en define('identificador', 'valor'). Los valores de las constantes en PHP son accedidos de forma global (también se les llama de ámbito global); es decir, aunque estén dentro de un bloque de código su valor podrá ser leído desde fuera de ese bloque. Los programadores han acordado escribir una constante en MAYÚSCULAS para así diferenciarlos de una variable (ojo, el sistema no acepta tildes).

En .PHP

<?php
// Contante: 'identificador',  "valor"
define('MUSICO', "Héctor Napolitano"); 

echo MUSICO; 
// Muestra Héctor Napolitano

// echo mUsicO; 
// ERROR!
?>

Variables de variables

Por otro lado, un caso especial de alojamiento de datos es la variable de variable. Es decir, cuando entre dos variables existe un parecido en nombre, pero con un valor diferente. No es una sintaxis comúmnente usada (una mejor opción es invocar elementos de arreglo, por ejemplo) y en muchos casos usar variable de variable es algo innecesario. Pero la agrego acá para entender los alcances de definir variables en PHP:

En .PHP

<?php
     $menu = "encebollado ";
     $$menu = " pan de sal!";

     echo "Este es un " . $menu . "con" . $$menu;

     // Resultado
     // Este es un encebollado con pan de sal! 
?>

Referencia de variables o alias de variable

Las variables pueden ser referenciadas desde otro identificador o alias (adjuntando el signo & al alias) y así apuntar al mismo valor. Sin embargo, usar un alias en exceso podría crear un código confuso de mantener, en la que diferentes nombres tienen un mismo valor. Se recomienda usarlo en casos bien definidos.

En .PHP

<?php 
// Forma incorrecta
	// Se crea variable
	$ciudad = "Guayaquil";
	// El operador & junto al nuevo nombre crea la referencia
	$ciudad = &$laPerla;
	// No hay resultado: $laPerla no ha sido declarada antes 
	echo $ciudad;
	// Sin resultado

// Forma correcta
	// Asigna valor a $laPerla
	$laPerla = "Guayaquil";
	// Crear referencia
	// En otras palabras, referenciamos la variable declarada. 
	$ciudad = &$laPerla;    

	// Ambas muestran Guayaquil
	echo $ciudad . "<hr>";
	echo $laPerla . "<hr>"; 

// ---------- * ----------

// UN USO PODRÍA SER:
// Nombre de variable muy largo
$codigo_casaGrande_EnLacosta = "00323";

// El mismo valor tiene otro identificador
$c1a = &$codigo_casaGrande_EnLacosta;

// Se invoca el identificador más corto
echo $c1a . "<hr>";

// Pero su identificador original será
echo $codigo_casaGrande_EnLacosta . "<hr>";
?>

// Ambos muestran
// 00323

Alcances de variables

El alcance de una variable es igual a determinar desde dónde es permitido (y desde dónde no) acceder a un valor de variable. Para Tatroe y MacIntyre (2020), el alcance de una variable se determina según dónde haya sido declarada (es decir, nombrada y asignada con un valor).

Como ejemplo es útil usar funciones para ejemplificar los alcances de una variable. Una función es similar a una cada vallada en donde no se permite el acceso desde afuera (solo de sus dueños, quiénes estan dentro).

Existen 4 tipos de alcances de una variable: alcance local, global, estático y desde parámetros de función.

Alcance (scope) local

Cuando la variable es declarada dentro de una función, su valor puede ser accedido solo desde esa función y no desde afuera de ella.

Alcance global

Cuando la variable es declarada fuera de función, lo que permite apuntar y acceder desde cualquier ubicación del código. Excepto que se añada la clave global al lado de una variable de función para que esta pueda ser accedida desde fuera.

Variables estáticas

Una variable estática se declara únicamente dentro de una función, utilizando la palabra clave static. A diferencia de las variables comunes (en Javascript debo primero declarar la variable fuera de la función, para que la función haga el incremento y se aloje en la variable externa) en PHP la variable estática tan solo requiere ser declarada dentro de la función.

Así, en caso de ser alterado su valor, este se acumulará entre invocaciones de la función, pero sin reiniciar la variable en cada llamado de función. En cambio (y dentro de la función) la variable static mantendrá su valor acumulado desde la última invocación, sin necesidad de declararla fuera de la función para que reciba el incremento, como sí ocurre en Javascript.

Parámetros de función

En lenguajes de programación un parámetro es un nombre identificador que espera un valor. Este valor se alojará dentro de los paréntesis junto al nombre de la función. Los parámetros solo tienen alcance local.

En .PHP

<?php 
     // Se declara función
     // Parámetros : $gallinas y $quint
     function hacienda($gallinas, $quint){
          echo "Hay " 
          . $gallinas . " gallinas y " 
          . $quint . " quintales de arroz.";
     }

     // Se invoca función y se agregan datos en parámetros
     hacienda(3, 5);
     // Se muestra:
     // Hay 3 gallinas y 5 quintales de arroz. 

     // echo $gallinas;
     /* ERROR! No se accede a los parámetros 
     desde fuera de la función hacienda */
?>

Tipos de valores de datos: enteros, punto flotante, strings, booleanos, arreglos en PHP

Para Tatroe y MacIntyre (2020) los hay escalares, como los números enteros, decimales, caracteres alfanuméricos y booleanos (False, True).

Otros son datos compuestos, como los objetos y los arreglos.

Tipos de valores enteros (Integers)

Son los mínimos negativos hasta los máximos positivos de la regla numérica común. Los enteros literales, en cambio, son aquellos números decimales (como 0.99999) o en alfanuméricos (como 0xFF) que representa el número 255; o como el binario -0b10, que representa el -2.

En .PHP

<?php 
     $valorA = 0.999;
     echo ($valorA);
     // Muestra 0.999

     $valorB = 0,999;
     echo ($valorB);
     // Da error. No acepta coma

     $valorb = 0,999;
     echo ($valorB);
     // Da error. Identificadores parecidos PERO NO idénticos!

     // Determinar si es decimal con la funcion is_float()
     if ( is_float($valorA) ) {
     echo " ...Sí es un decimal";
     // Muestra 0.999 ...Sí es un decimal
     }
?> 

Un tipo de dato string es un valor entre comillas. Sea número o una palabra, el sistema reconocerá como string isi está entre comillas.

Los valores booleanos son todos aquellos que puedan representar uno de los dos estados binarios: Falso (false) o vacio; Verdad (true) o lleno.

En .PHP

<?php
$bool_A = "";
if ($bool_A == false){
echo "Es falso";}
// Comillas vacias, entonces es falso

$bool_B = 0.0;
if ($bool_B == false){
echo "Es falso";}
// Decimal 0.0, entonces es falso

$bool_C = null; 
if ($bool_C == null){
echo "Es falso";}
// Es falso

$bool_D = []; 
if ($bool_D == null){
echo "Es falso";}
// Arreglo esta vacio, entonces es falso
?>

Un método para organizar datos vinculados con otros datos (es decir, organizados en un par 'propiedad = valor') es el arreglo. Un arreglo es un grupo de valores (también llamados elementos) contenidos en corchetes rectos como (10, 20, 30) o ("Hola", "amigos"). A la posición de cada valor se le llama índice (porque su ubicación tiene posición numérica), de cero en adelante.

Si un arreglo común cuenta con un elemento por valor, un arreglo asociativo cuenta dos valores por elemento. Hay dos formas para, mediante el constructor array, crear índices en arreglos:

// EJEMPLO DE ARREGLO BÁSICO, CON POSICIÓN DE ÍNDICE
// arreglo ("pos. 1", "pos. 2", "pos. 3");
// arreglo ("dato A", "dato B", "dato C");

// Esto dará ERROR
// arreglo ["dato A", "dato B", "dato C"];

/* ARREGLO ASOCIATIVO CON CONSTRUCTOR array
$nombreArreglo = array(
     'datoA' => "valorA",
     'datoB' => "valorB"
     );
*/

<?php 
// Uso del constructor array
$cangrejales00 = array("Ochipinti", "Manu", "PataGolosa");

// Se apunta al elemento del indice 0 (la primera posición)
echo $cangrejales00 [0];
// Se mostrará 'Ochipinti'

// Arreglo asociativo
// Ojo: primero comillas simples, luego dobles
$bandas = array(
     'rock' => "NoToken",
     'punk' => "NTN");

// Se invoca el arreglo $bandas y se apunta al primer par
echo $bandas['rock'];
// Se muestra 'NoToken'
?>

Con la función foreach() es posible recorrer (para mostrar, o para contabilizar) los elementos (o los índices) de un arreglo:

En .PHP

<?php
// Se crea un arreglo sencillo
$cc = array("Mall del Sol", "San Marino", "Policentro");

// Recorrido con foreach
// variable $mostrar es temporal (no existe antes)
// Ojo con el uso del tag HTML <hr>
foreach ($cc as $mostrar) { 
    echo "Holi, {$mostrar}<hr>";
}

/* Se muestra
Holi, Mall del Sol
Holi, San Marino
Holi, Policentro
*/

// # # # # # # # # # # # #

// Se crea un arreglo asociativo (propiedades = valores)
$ciudadelas = array(
	'Alborada' => "Norte",
	'Urdesa' => "Norte",
	'Esteros' => "Sur"
);

// Se recorre arreglo
// Variable $ubicacion es temporal (no existe antes)
foreach ($ciudadelas as $ciudadela => $ubicacion) {
    echo "{$ciudadela} está al {$ubicacion}.<hr>";
}

/* Se muestra
Alborada está al Norte.
Urdesa está al Norte.
Esteros está al Sur.
*/
?>

Así mismo se puede recorrer arreglos asociativos en paralelo; es decir, donde más de un arreglo comparte una propiedad o una clave con otro arreglo, lo que permite apuntar a una propiedad para obtener un valor:

En .PHP

<?php 

// Primero, crear arreglos que compartan propiedades
// Arreglo ciudadelas
$ciudadelas = array(
    'Alborada' => "Norte",
    'Urdesa' => "Norte",
    'Esteros' => "Sur"
);

// Arreglo administrador
$administrador = array(
    'Alborada' => "Ramon",
    'Urdesa' => "Sandra",
    'Esteros' => "Edu"
);

// Segundo, recorrer arreglos vinculados por sus claves
// $ubi es variable temporal
foreach ($ciudadelas as $ciudadela => $ubi) {
    
    // Nueva variable '$admin' aloja propiedad junto con índice de ciudadela
    $admin = $administrador[$ciudadela];
    // Alborada + Norte + Ramon

    // Se muestran:
    // Cada índice de $ciudadela
    // Cada índice de variable $ubi
    // Cada par de elementos alojados en $admin
    echo "{$ciudadela} 
    está en el {$ubi} 
    y va con {$admin}.<br/>";
}

/* Se muestra
Alborada está en el Norte y va con Ramon.
Urdesa está en el Norte y va con Sandra.
Esteros está en el Sur y va con Edu.
*/
?>

Operadores

De todos los operadores aritméticos de lenguajes de programación como PHP, los de incremento-decremento suelen ser un poco crípticos. Un incremento (o a la inversa, un decremento) altera el valor original sumando o restando una unidad al valor de una variable:

En .PHP

<?php 
// OPERADORES DE INCREMENTO/DECREMENTO

$valor = 0;
// Incrementa una unidad
echo $valor++;
// 1

// Decrementa una unidad
echo $valor--;
// 0
?>

Sus posibilidades empiezan a expanderse cuando los signos se colocan como prefijo (antes de la variable) o como sufijo (después de la variable). Cada posición tiene un resultado que muestro a continuación con el siguiente código:

En .PHP

<?php 

// OPERADORES DE INCREMENTO
$num = "0";
$letra = "A";

// Incrementa antes de operar
// Es decir el incremento es inmediato
echo "Ejemplos de ++variable (signos antes de variable)" . "<hr>";

	// ... El valor 0 ahora es 1
	echo "... El valor " . $num . " ahora es ". ++$num . "<hr>";
	// ... El valor A ahora es B
	echo "... El valor " . $letra . " ahora es " . ++$letra . "<hr><br>";

// Incrementa solo luego de operar
// Es decir el posterior a una operación
echo "Ejemplos de ++variable (signos antes de variable)" . "<hr>";

echo "... El valor " . $num . " ahora es ". $num++ . "<hr>";
echo "... El valor " . $letra . " ahora es ". $letra++ . "<hr>";
?>

Siendo el resultado del código anterior, donde:

• Una primera variable inicia con el valor cero
• Una segunda variable inicia con el valor literal A

Interpretado por el servidor, lo anterior resulta en:

Ejemplos de ++variable (signos antes de variable), donde solo cambiará cuando el valor sea usado u operado.

... El valor 0 ahora es 1

... El valor A ahora es B

Ejemplos de variable++ (signos después de variable), donde el valor cambiará sea o no usado por un operador.

El valor cambió (de inmediato) a 1

El valor cambió (de inmediato) a B

Lo anterior significa lo siguiente: los incrementos (++) o decrementos (--) tendrán los siguienes comportamientos según su ubicación:

• Con signo antes de variable, como en ++$variable: el valor de esa variable será incrementado en una unidad antes de usarlo en cualquier operación. Por ejemplo, se mostrará alterado cuando el valor sea usado mediante echo "...". Lo de antes significa que el valor primero se mantendrá en su valor original y luego, durante la operación, tendrá su incremento en una unidad.


• Con signo después de variable, como en $variable++: el valor de esa variable será incrementado de inmediato, aún si ese valor no será usado en alguna operación.

Operadores de comparación

Comparan valores entre sí para determinar valores o tipos de datos. Aquí se mostrará solo los de mayor, menor y comparativos de tres respuestas (o también llamado operador de nave espacial) en la forma $a <=> $b

En .PHP

<?php 
     $a = 10;
     $b = 20;
     $c = 30;
     $d = 40;

     /* En echo ($a > $b) . "<hr>"; 
     - Se agrupó la comparación y luego se concatenó <hr>. 
     - Si todo estaba entre paréntesis, el servidor lo hubiera interpretado como un dato más.*/

     /* 
     - Concatenar significa unir. 
     - Al haber estado todo entre paréntesis, 
     la variable hubiera sido leída con el tag.
     - Por eso no se mostrana la línea. */
     echo ($a > $b) . "<hr>";
     // 1

     echo ($a < $b) . "<hr>";
     // False, pero será una cadena vacía.

     // Mediante operador ternario
     echo ($d > $a) ? "Es verdad" : "Es falso" . "<hr>";
     echo "<hr>"; 
     // true

     var_dump ($a > $b);
     echo "<hr>"; 
     // False, pero será una cadena vacía.

     // asad
     print_r ($a > $b) . "<hr>" . "asda";

     // Comparador tri-respuesta o de nave Espacial
     	// Cuando son iguales retorna 0
     	// Cuando el primero es menor que el segundo retorna -1
     	// Cuando el primero es mayor que el segundo retorna 1
     echo ($a <=> $b) . "<hr>";
     // -1

?>

Donde las respuestas al código anterior son:

En pantalla del navegador

// $a = 10;
// $b = 20;
// $c = 30;
// $d = 40;

// ($a > $b) 
1

// ($a < $b)
// Cadena vacia (no muestra nada)

// ($d > $a) ? "Es verdad" : "Es falso"
Es verdad

// var_dump ($a > $b);
bool(false)

     // Operador tri respuesta o nave espacial
     // print_r ($a > $b)
     -1
     // Cuando son iguales retorna 0
     // Cuando el primero es menor que el segundo retorna -1
     // Cuando el primero es mayor que el segundo retorna 1

Operadores lógicos o booleanos en PHP

Tal como en casi todos los lenguajes de programación desde hace 50 años, es necesario evaluar la condición de verdad o falsedad de un dato a partir de su valor o de su comparación entre datos. Los operadors lógicos necesarios serán los siguientes. Recordar: Se debe agrupar los operandos que no se desean concatenados con otros elementos, pues el operador de concatenación (el punto) evaluará primero la concatenación y luego el resto de operadores.

En .PHP

<?php
// Variables
$true = true;
$false = false;

// OPERADORES LÓGICOS EN PHP

// Tamb se usa AND
echo "Entre true Y false, al menos una es " . ($true && $false ? 'true' : 'false') . "
";
// Da: Entre true Y false, al menos una es false

// Tamb se usa OR
echo "Entre true O false, al menos una es " . ($true || $false ? 'true' : 'false') . "
";
// Da: Entre true O false, al menos una es true

// Operador XOR o de TRUE exclusivo: Solo será TRUE si solo uno de los valores es TRUE
echo "Entre true XOR false, solo será TRUE si uno de los dos es TRUE, y nada más: Entonces es; " . ($true ^ $false ? 'true' : 'false') . "
";
// Da: true

// Inversor de valor booleano
// Invierte valor de true a false
echo !$true ? "Es false" : "Es true"; 
// Da: Es true 

/* Análisis:
     - $true tiene un valor inicial de true
     - Operador ! invierte valor booleano de true a false
     - Condicional: !$true es true o false?
     - Si !$true es falso, entonces la respuesta es true.
*/
?>

En la siguiente sección seguimos con otras especiales propiedades de PHP, especialmente con la programación orientada a objetos, entre otros.