Desarrollo

Funciones predefinidas en PHP – 1ª parte

Desarrollo PHP

Existen centenares de funciones predefinidas en PHP, para facilitar un buen número de procesos de lo más variados. Va a ser muy complicado que llegues a gastar siquiera el 50% de la enorme cantidad de funciones ya creadas. Sin embargo, hay un buen puñado que gastaremos muchas veces casi sin darnos cuentas. Algunas, muy pocas, ya las hemos visto. Otras las veremos en este artículo, que va a ser extenso.

En base a lo que hemos visto por ahora en anteriores artículos, vamos a dividir las funciones predefinidas en PHP que vamos a ver en cuatro bloques: variables, matemáticas, strings y arrays.

De entre ellas, vamos a ver unas de las funciones más utilizadas, aunque ésto siempre es muy subjetivo y vosotros podéis utilizar mucho más otras funciones. No pasa nada, pues en cada listado enlazaré al listado completo de funciones de cada una de esas ramas.

También podéis ver el listado de artículos que llevamos y los que están programados en el índice de contenidos.

Funciones predefinidas para manejo de variables

Ya hace tiempo que hablamos de las variables en PHP y cómo asignarlas correctamente. Vamos a ver ahora unas cuantas funciones que se aplican sobre nuestras variables y nos pueden dar información sobre ellas. El listado completo lo podemos encontrar aquí.

empty

Determina si una variable está vacía. Para que esté vacía, la variable no debe existir, su valor debe ser igual a false, null (aún no hemos visto qué es), una cadena vacía “”, 0, 0.0 o un array vacío. Nos devolverá true o false dependiendo si existe o no.

empty($variable)

gettype

Devuelve el tipo de variable que es. Nos puede devolver boolean, integer, double (para indicar que es un float), string, array y otros tipos que aún no hemos visto.

gettype($variable)

is_array, is_bool, is_float, is_int, is_string

Estas funciones comprueban si una variable es un array, booleana, float, int o string, respectivamente. Nos devolverá true o false si la comprobación es cierta o no.

is_array($variable)
is_bool($variable)
is_float($variable)
is_int($variable)
is_string($variable)

Funciones predefinidas para expresiones matemáticas

Si recordamos los operadores más básicos, nos encontrábamos con las expresiones más básicas para sumar, restar, multiplicar o dividir. PHP, y la mayoría de lenguajes de programación, también tienen un buen listado de funciones para realizar cálculos matemáticos. Vamos a ver unas pocas que quizá podamos utilizar más a menudo.

abs

Calcula el valor absoluto de un número. Nos devolverá el mismo número, con el mismo tipo de datos, pero sin su signo.

abs($valor)

max, min

Estas dos funciones nos devolverán, respetivamente, el valor máximo y el valor mínimo. Se le puede pasar un array, con lo cual nos devolverá el valor máximo/mínimo de entre sus elementos, o le podemos pasar varios argumentos sobre los que queremos obtener el valor máximo/mínimo.

Hay que tener cuidado con pasarle strings, pues automáticamente los transforma a un valor 0.

max($valor1, $valor2, $valor3, $valor4)
max($array)

min($valor1, $valor2, $valor3, $valor4)
min($array)

pow

Nos calcula el valor de un número elevado a otro. Es decir, calcula la exponenciación que inicialmente definimos con el símbolo **.

pow($base, $exponente)

rand

En ocasiones queremos obtener un número aleatorio. Esta función realiza ese papel, devolviendo un número entero aleatorio. Sin embargo, hay que resaltar que nunca será un número totalmente aleatorio, pero nos puede servir en muchos casos (excepto en temas de criptografía, por ejemplo).

Le podemos pasar un valor mínimo y uno máximo para que el número aleatorio esté entre ellos.

rand()
rand($minimo, $maximo)

sqrt

Calcula la raíz cuadrada de un valor. Nos devolverá, obviamente, el valor de la raíz cuadrada o un valor especial si le pasamos un número negativo.

sqrt($valor)

Funciones predefinidas para strings

Las funciones predefinidas en PHP para tratar con strings nos van a venir muy bien en muchos aspectos, pues podremos realizar varias funcionalidades sin esfuerzo. Existen también decenas de funciones para strings ya predefinidas, pero vamos a ver aquí una selección de las que más puede que usemos.

explode

Con esta función podremos dividir un string en varios strings en base a un carácter que le indiquemos como delimitador. Es decir, que el string “hola mundo” podríamos dividirlo con el carácter de espacio en blanco y esta función nos devolvería un array con dos elementos: “hola” y “mundo”. También podemos colocarle un límite de divisiones, devolviendo el último valor el string entero restante.

explode($delimitador, $string, $limite) // Límite cuenta con un valor por defecto

// Ejemplos
$colores = 'verde rojo azul amarillo blanco negro';
$array_colores = explode(' ', $colores); // Tendríamos un array('verde', 'rojo', 'azul', 'amarillo', 'blanco', 'negro')

$texto = 'Hola,estoy,abusando,de,las,comas';
$array_texto = explode(',', $colores); // Tendríamos un array('Hola', 'estoy', 'abusando', 'de', 'las', 'comas')

$numeros = '1|2|3|4|5';
$array_numeros = explode(' ', $numeros, 3); // Tendríamos un array('1', '2', '3|4|5')

implode

Hace lo contrario a explode, es decir, une los elementos de un array en un string. Para ello, le indicamos un carácter que hará de “pegamento”.

implode($pegamento, $array)

// Ejemplo
$array_nombre = array('Juan', 'Pérez', 'Martínez');
$nombre = implode(' ', $array_nombre); // Tendríamos un string 'Juan Pérez Martínez'

str_replace

Esta función reemplaza todas las apariciones de un string que le indiquemos por otro string que le pongamos como reemplazo. Podemos indicarle un límite de reemplazos.

str_replace($valor_buscado, $valor_reemplazo, $string, $contador) // Contador tiene un valor predefinido

// Ejemplo
$titular = 'Estamos en el año %año%';
$titular_final = str_replace('%año%', '2020', $titular); // Tendríamos un string 'Estamos en el año 2020'

str_split

Convierte un string en un array. Le podemos indicar la longitud que debe tener cada elemento del array. Si no le indicamos nada, cogerá cada carácter del array.

str_split($string, $longitud) // El argumento $longitud tiene un valor predefinido

// Ejemplos
$string = 'Hola';
$array1 = str_split($string); // Tendríamos array('H', 'o', 'l', 'a')
$array2 = str_split($string, 2); // Tendríamos array('Ho', 'la')

strcmp

Compara dos strings $string_a y $string_b. Devolverá un valor menor que 0 si $string_a es menor que $string_b, mayor que 0 si es mayor, y 0 si son iguales. Ten en cuenta que diferencia entre mayúsculas y minúsculas.

strcmp($string_a, $string_b)

strlen

Muy usada, pues nos devuelve la longitud del string.

strlen($string)

strpos

Nos devuelve la posición de una subcadena dentro de un string. Podemos, además, indicarle desde qué valor debe comenzar.

strpos($string, $valor_a_encontrar, $posicion_inicial) // La posición inicial tiene un valor por defecto

// Ejemplos
$string = 'abcdefg';
$encuentra = 'c';
$posicion = strpos($string, $encuentra); // Devolverá 2, pues el primer elemento es el 0

$string = 'abcdefg abcdefg';
$encuentra = 'c';
$posicion = strpos($string, $encuentra, 7); // Devolverá 10, pues empezamos desde la posición 7

strtolower, strtoupper

Devuelven un string con todos los valores en minúsculas y todos en mayúsculas, respectivamente.

strtolower($string)

strtoupper($string)

substr

Devuelve parte de un string. Se le indica obligatoriamente la posición inicial desde donde queremos partir la cadena y, opcionalmente, el número de caracteres a devolver. Se pueden utilizar números negativos para comenzar desde el final del string. El número de caracteres a devolver también puede ser negativo, con lo que se omitirían esos carácteres desde el final.

substr($string, $inicio, $caracteres) // La variable $caracteres tiene un valor predefinido

// Ejemplos
substr('abcdef', 1);     // bcdef
substr('abcdef', 1, 3);  // bcd
substr('abcdef', 0, 4);  // abcd
substr('abcdef', 0, 8);  // abcdef
substr('abcdef', -1, 1); // f
substr("abcdef", -1);    // f
substr("abcdef", -2);    // ef
substr("abcdef", -3, 1); // d
substr("abcdef", 0, -1);  // abcde
substr("abcdef", 2, -1);  // cde
substr("abcdef", 4, -4);  // devuelve false
substr("abcdef", -3, -1); // de

trim

Elimina los espacios en blanco (y algunos caracteres epeciales como \n o \t al principio y al final de un string.

trim($string)

// Ejemplo
$string_con_espacios = '       Programación Básica       ';
$string = trim($string_con_espacios); // Tendríamos 'Programación Básica'

Funciones predefinidas para arrays

Nuestro último bloque del artículo presentará algunas de las funciones predefinidas en PHP para tratar con arrays. En su momento vimos algunas para eliminar un elemento de un array o para contar todos los elementos. Ampliaremos ahora estos conocimientos con nuevas funciones que nos serán muy útiles para trabajar con ellos, pero en el listado completo encontraremos muchísimas más si se nos quedan cortas.

array_key_exists

Dada una clave, esta función nos devuelve si dicha clave (o índice) existe en el array. Nos será muy útil para comprobar si existe un índice en el array antes de acceder a él erróneamente.

array_key_exists($clave, $array)

// Ejemplos
$array = array('primero' => 1, 'segundo' => 2);
$existe1 = array_key_exists('primero', $array); // Tendríamos el valor verdadero, pues sí existe
$existe2 = array_key_exists('tercero', $array); // Tendríamos el valor falso, pues no existe

array_keys

Devuelve un array con todos los índices de un array. Podemos especificarle, también, que nos devuelva los índices de un valor concreto de un array. De igual forma, también podemos indicarle si la igualdad debe ser estricta (===) o no (==).

array_keys($array, $indice_buscado, $estricto) // Los dos últimos argumentos tienen valores predefinidos

// Ejemplos
$array = array('uno' => 1, 'dos' => 2, 'tres' => 3);
$indices = array_keys($array); // Tendríamos array('uno', 'dos', 'tres')

$array = array(1, 2, 3, 2, 3, 1, 2, 3, 2);
$indices = array_keys($array, 2); // Tendríamos array(1, 3, 6, 8)

array_merge

Esta función combina dos o más arrays y nos devuelve un array como resultado. Si encuentra un índice igual a otro, se sobreescribe y siempre quedará el último. Todo ello excepto si es un índice numérico, en cual caso se agregará al final. Además, las claves numéricas serán renumeradas y volverán a comenzar desde el 0.

array_merge($array1, $array2, ...)

// Ejemplo
$array1 = array('rojo', 'azul', 'color' => 'verde', 3, 4);
$array2 = array('rojo', 'color' => 'amarillo', 3);
$union = array_merge($array1, $array2); // Tendríamos array('rojo', 'azul', 'color' => 'amarillo', 3, 4, 'rojo', 3)

array_pop

Extrae el último elemento de un array, quedándose el array con un elemento menos.

array_pop($array)

// Ejemplo
$array = array(1, 2, 3, 4, 5);
$ultimo = array_pop($array); // Tendríamos un 5 y, en $array, tendríamos array(1, 2, 3, 4)

array_push

Coloca uno o más elementos al final de un array. Si se va a añadir únicamente un elemento, se aconseja utilizar mejor la sintaxis $array[] = elemento.

array_push($array, $elemento1, $elemento2, ...)

// Ejemplos
$frutas = array('manzana', 'pera');
array_push($frutas, 'platano', 'cereza'); // Tendríamos array('manzana', 'pera', 'platano', 'cereza')

array_reverse

Devuelve un nuevo array con el orden de los elementos invertido. Podemos indicarle que se conserven los índices numéricos o no, pero los índices que no sean numéricos se conservarán siempre.

array_reverse($array, $conservar_indices) // La variable $conservar_indices tiene un valor predeterminado

// Ejemplos
$array = array(1, 2, 3);
$reverso = array_reverse($array); // Tendríamos array(3, 2, 1)
$preservador = array_reverse($array, true); // Tendríamos array(2 => 3, 1 => 2, 0 => 1)

asort, arsort, ksort, krsort, sort, rsort

Funciones para ordenar. Las dos primeras, asort y arsort ordenan el array pero manteniendo el índice, con la diferencia de que la segunda función ordena de manera inversa. Con las funciones ksort y krsort tenemos lo mismo pero, en esta ocasión, ordenan en base a los índices en lugar de los elementos. Por último, sort y rsort ordenan el array sin preocuparse de los índices, que desaparecen.

asort($array)
arsort($array)
ksort($array)
krsort($array)
sort($array)
rsort($array)

// Ejemplos
$array = array('a' => 5, 'c' => 8, 'b' => 3);

// $array tendría array('b' => 3, 'a' => 5, 'c' => 8)
asort($array);

// $array tendría array('c' => 8, 'a' => 5, 'b' => 3)
arsort($array);

// $array tendría array('a' => 5, 'b' => 3, 'c' => 8)
ksort($array);

// $array tendría array('c' => 8, 'b' => 3, 'a' => 5)
krsort($array);

// $array tendría array(3, 5, 8) con índices numéricos
sort($array);

// $array tendría array(8, 5, 3) con índices numéricos
rsort($array);

count

Ya comentamos acerca de esta función, la cual cuenta el número de elementos de un array. Pero vamos a ampliar la información comentando que podemos definir un segundo parámetro, llamado COUNT_RECURSIVE, para contar todos los elementos de un array multidimensional.

count($array, $modo) // La variable $modo tiene un valor predefinido

// Ejemplos
$array = array(1, 2, 3, 4, 5);
$contador = count($array); // Tendríamos el valor 5

$array = array('uno' => array(1, 2), 'dos' => array(3, 4, 5));
$contador = count($array); // Tendríamos el valor 2
$contador_multi = count($array, COUNT_RECURSIVE); // Tendríamos el valor 7

in_array

Esta función comprueba si un valor existe en un array. Podemos indicarle comprobación estricta o no. Nos devolverá un valor true o false.

in_array($valor_buscado, $array, $estricto) // La variable $estricto tiene un valor predefinido

// Ejemplos
$array = array(1, 2, 3, 4, 5);
$existe = in_array(3, $array); // Tendríamos el booleano true
$no_existe = in_array(6, $array); // Tendríamos el booleano false

unset

Elimina el elemento del array al que se le pasa. Realmente, esta función es mucho más amplia y puede eliminar otros elementos que no estén en un array, pero nos sirve con este comportamiento.

unset($elemento)

// Ejemplo
$array = array(1, 2, 3);
unset($array[1]); // Tendríamos en $array array(1, 3)

Conclusión

Muchas, hay muchísimas funciones predefinidas en PHP. Una cantidad enorme de ellas para casi cualquier funcionalidad más o menos básica que podamos requerir. Por ello, es muy importante ir a la documentación de cada lenguaje de programación en el que estemos programando para ver si, por ejemplo, esa necesidad que tenemos de ordenar un array ya está cubierta y nos ahorramos así pasos, código y posibles errores.

Hemos visto aquí bastantes funciones que puede que sean de las que más vayas a usar, al menos al principio cuando vayas a operar con strings y arrays principalmente. Pero, en el futuro, iremos introduciendo poco a poco más y más funciones según vayamos requiriendo funcionalidades nuevas.

Con todo lo que tenemos, ya podemos realizar una nueva entrega de A practicar… utilizando las funciones para, posteriormente, comenzar a ver cómo instalar un servidor local y solicitarle datos al usuario.

Deja una respuesta