Helpers – Array – Manipulación de arrays
En esta librerÃa se pueden encontrar funciones para diferentes funcionalidades todas ellas a plicacbles a arrays.
/**
* HelperArray.php
* @author Code Develium
*/
namespace Helpers;
/**
* Class HelperArray
*/
abstract class HelpArray
{
/**
* Ordena un array por los valores de forma natural.
* Se pierden las claves.
* Devuelve un array con los valores ordenados
*
* @param array $arr
* @param bool $ascendent
*
* @return array
*/
public static function sortNatural($arr, $ascendent = true)
{
$array_tmp = HelpConvert::toArray($arr);
usort($array_tmp, "strnatcmp");
if (!$ascendent) {
$array_tmp = array_reverse($array_tmp);
}
return $array_tmp;
}
/**
* Devuelve un array ordendo por las columna
* o columnas que queramos
* @return mixed
*/
function sortMultiValue()
{
$args = func_get_args();
$data = array_shift($args);
foreach ($args as $n => $field) {
if (is_string($field)) {
$tmp = array();
foreach ($data as $key => $row) {
$tmp[ $key ] = $row[ $field ];
}
$args[ $n ] = $tmp;
}
}
$args[] = &$data;
call_user_func_array('sortMultiValue', $args);
return array_pop($args);
}
/**
* Ordena los valores de un array, se mantienen las claves.
* Devuelve un array ordenado.
*
* @param array $arr
* @param bool $ascendent
*
* @return array
*/
public static function sort($arr, $ascendent = true)
{
$arrayTmp = HelpConvert::toArray($arr);
if ($ascendent) {
asort($arrayTmp);
} else {
arsort($arrayTmp);
}
return $arrayTmp;
}
/**
* Elimina el primer valor de una instancia del array.
* Devuelve un array sin el valor eliminado.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param $val
*
* @return array
*/
public static function removeValueFirst($arr, $val)
{
$arrayTmp = [];
$encontrado = false;
foreach (HelpConvert::toArray($arr) as $key => $value) {
if ($value == $val && !$encontrado) {
$encontrado = true;
} else {
$arrayTmp[ $key ] = $value;
}
}
return $arrayTmp;
}
/**
* Elimina todos los valores del array de una instancia.
* Devuelve un array sin los valores eliminados.
*
* @param array $arr
* @param $sStr
*
* @return array
*/
public static function removeValueAll($arr, $sStr)
{
$arrayTmp = [];
foreach (HelpConvert::toArray($arr) as $key => $value) {
if ($value != $sStr) {
$arrayTmp[ $key ] = $value;
}
}
return $arrayTmp;
}
/**
* Elimina una posición determinada del array.
* Devuelve una array sin el valor eliminado.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param int $pos
*
* @return array
*/
public static function removePos($arr, $pos)
{
$n = 0;
$arrayTmp = [];
foreach (HelpConvert::toArray($arr) as $key => $value) {
if ($pos != $n) {
$arrayTmp[ $key ] = $value;
}
$n++;
}
return $arrayTmp;
}
/**
* Devuelve un array sin el último valor del array.
*
* @param array $arr
*
* @return array
*/
public static function removeLast($arr)
{
$arr = HelpConvert::toArray($arr);
array_pop($arr);
return $arr;
}
/**
* Devuelve un array donde se ha eliminado una clave y su valor.
* El array original no se modifica.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
* Si la cale no se encuentra, devuelve el mismo array
*
* @param $arr
* @param $clave_eliminar
*
* @return array
*/
public static function removeKey($arr, $clave_eliminar)
{
$arrayTmp = [];
$encontrado = false;
foreach (HelpConvert::toArray($arr) as $clave => $valor) {
if ($clave == $clave_eliminar && !$encontrado) {
$encontrado = true;
} else {
$arrayTmp[ $clave ] = $valor;
}
}
return $arrayTmp;
}
/**
* Devuelve y elimina el primer valor del array
*
* @param array $arr
*
* @return mixed
*/
public static function removeFirst(&$arr)
{
return array_shift($arr);
}
/**
* Devuelve un array sin duplicados.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
*
* @return array
*/
public static function removeDuplicates($arr)
{
return array_unique(HelpConvert::toArray($arr));
}
/**
* Transforma un array en un string separados por un separador.
* Por defecto el separador es la coma (,).
*
* @param array $arr
* @param string $separador
*
* @return string
*/
public static function joinValues($arr, $separador = ',')
{
return join($separador, HelpConvert::toArray($arr));
}
/**
* Devuelve la posición que ocupa un valor de un array
* o -1 si no existe.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param mixed $value
*
* @return int
*/
public static function indexOfValue($arr, $value)
{
$arr = HelpConvert::toArray($arr);
if (count($arr) == 0) {
return -1;
}
// Como la función es sensitiva a mayúsculas i minúsculas
// hacemos una copia de array poniendo
// las claves en minúsculas
// la comparación se hace en minúsculas.
$arrayCopy = array_map(function ($val)
{
return HelpString::toLower($val);
}, array_values($arr));
$pos = array_search($value, $arrayCopy);
if (false === $pos) {
return -1;
}
return $pos;
}
/**
* Devuelve la posición que ocupa una clave o -1
+ si no la encuentra.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param mixed $clave
*
* @return int
*/
public static function indexOfKey($arr, $clave)
{
$n = 0;
foreach (HelpConvert::toArray($arr) as $clave_tmp => $value) {
if (HelpValidate::areEquals($clave_tmp, $clave)) {
return $n;
}
$n++;
}
return -1;
}
/**
* Devuelve el valor de la posición secuencial determinada
* o un valor por defecto so no existe.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param int $pos
* @param string $default
*
* @return mixed
*/
public static function getValueByPos($arr, $pos, $default = '')
{
$n = 0;
foreach (HelpConvert::toArray($arr) as $value) {
if ($n == $pos) {
return $value;
}
$n++;
}
return $default;
}
/**
* Devuelve el valor de una clave.
* Si el parámetro no es un array, se convierte a array.
* La clave es independiente de maýusculas, minúsculas y acentos.
*
* @param array $arr
* @param mixed $key
*
* @return mixed
*/
public static function getValueByKey($arr, $key)
{
$arrTmp = HelpConvert::toArray($arr);
$key = HelpString::toLower(HelpString::eliminarAcentos($key));
// Como la función array_key_exists es
// sensitiva a mayúsculas i minúsculas
// hacemos una copia de array poniendo las
// claves en minúsculas
// la comparación se hace en minúsculas.
$arrayCopy = array_map(function ($val)
{
$val = HelpString::eliminarAcentos($val);
return HelpString::toLower($val);
}, array_keys($arrTmp));
/* Si existe, tenemos su posición dentro del array */
$pos = array_search($key, $arrayCopy);
if ($pos === false) {
return null;
}
/* Obtenemos un array de un sólo valor, que es
el que nos interesa */
$arrSingle = array_slice($arrTmp, $pos, 1);
/* Devolvemos su valor */
return $arrSingle[ array_keys($arrSingle)[ 0 ] ];
}
/**
* Devuelve una parte del array entre dos posiciones.
* Si algún valor esta vacÃo o no es un array,
* este se convierte a un array.
*
* @param array $arr
* @param int $pos_inicio
* @param int $pos_fin
*
* @return array
*/
public static function getSubArray($arr, $pos_inicio, $pos_fin)
{
return array_slice( HelpConvert::toArray($arr),
$pos_inicio,
$pos_fin);
}
/**
* Devuelve el número de niveles de un array. Función recursiva.
* Si el parámetro no es un array, devuelve cero.
*
* @param array $array
* @param int $niveles
* @param array $array_actual
*
* @return int
*/
public static function getLevels( $array,
$niveles = -1,
$array_actual = [])
{
$niveles++;
if (is_array($array)) {
foreach ($array as $key => $value) {
$array_actual[] = self::getLevels($value, $niveles);
}
} else {
return $niveles;
}
foreach ($array_actual as $value) {
$niveles = $value > $niveles ? $value : $niveles;
}
return $niveles;
}
/**
* Devuelve y elimina el último valor del array.
* El array pasado al la función queda modificado.
*
* @param array $arr
*
* @return mixed
*/
public static function getLastAndRemove(&$arr)
{
$arr = HelpConvert::toArray($arr);
return array_pop($arr);
}
/**
* Devuelve el último valor del array.
* El array pasado al la función queda modificado.
*
* @param array $arr
*
* @return mixed
*/
public static function getLast($arr)
{
return array_pop(HelpConvert::toArray($arr));
}
/**
* Devuelve un array con todas las claves.
* Si es null o no es un array, devuelve un array vacÃo.
*
* @param array $arr
*
* @return array
*/
public static function getKeys($arr)
{
// Si no es un array, devolvemos un array vacÃo
if (!is_array($arr)) {
return [];
}
return array_keys($arr);
}
/**
* Indica si un valor existe en un array.
* Se comprueba que al parámetro sea un array.
* Es independiente de maýusculas y minúsculas pero no acentuadas
*
* @param array $arr
* @param mixed $value
*
* @return bool
*/
public static function existsValue($arr, $value)
{
// Si no es un array, devolvemos false (No existe)
if (!is_array($arr)) {
return false;
}
$value = HelpString::toLower($value);
// Como la función es sensitiva a mayúsculas i minúsculas
// hacemos una copia de array poniendo
//las claves en minúsculas
// la comparación se hace en minúsculas.
$arrayCopy = array_map(function ($val)
{
return HelpString::toLower($val);
}, $arr);
return !(false === array_search($value, $arrayCopy));
}
/**
* Indica si una clave existe en un array.
* Se comprueba que al parámetro sea un array.
* Es independiente de maýusculas, minúsculas y acentuadas
*
* @param array $arr
* @param mixed $key
*
* @return bool
*/
public static function existsKey($arr, $key)
{
// Si no es un array, devolvemos false (No existe)
if (!is_array($arr)) {
return false;
}
$key = HelpString::eliminarAcentos($key);
$key = HelpString::toLower($key);
// Como la función array_key_exists es sensitiva
// a mayúsculas i minúsculas
// hacemos una copia de array poniendo las claves
// en minúsculas
// la comparación se hace en minúsculas.
$arrayCopy = array_map(function ($val)
{
$val = HelpString::eliminarAcentos($val);
return HelpString::toLower($val);
}, array_keys($arr));
return (array_search($key, $arrayCopy) > 0);
}
/**
* Devuelve todas las claves/valores del array 1 que NO estan
* en las claves/valores del otro array.
*
* @param array $arr1
* @param array $arr2
*
* @return array
*/
public static function difByBeyValue($arr1, $arr2)
{
return array_diff($arr1, $arr2);
}
/**
* Devuelve todos los claves/valores del array 1 que NO están
* en las claves del otro array.
* Si algún valor esta vacÃo o no es un array, este se
* convierte a un array.
*
* @param $arr1
* @param $arr2
*
* @return array
*/
public static function difByKeys($arr1, $arr2)
{
return array_diff( HelpConvert::toArray($arr1),
HelpConvert::toArray($arr2));
}
/**
* Elimina toda una columna por si posición de un array.
* (0 es la primera)
*
* @param $array
* @param $position
*
* @return mixed
*/
public static function deleteColumnByPosition($array, $position)
{
array_walk(
$array,
function (&$arr) use ($position)
{
array_splice($arr, $position, 1);
}
);
return $array;
}
/**
* Devuelve un array sin valores vacÃos (null, '').
* Si el valor está vació, de vuelve un array vació, y si no
* es un array, lo convierte a un array.
*
* @param $arr
*
* @return array
*/
public static function compact($arr)
{
if (HelpValidate::isEmpty($arr)) {
return [];
}
$arrayTmp = [];
foreach (HelpConvert::toArray($arr) as $key => $value) {
if (!HelpValidate::isEmpty($arr[ $key ])) {
$arrayTmp[ $key ] = $value;
}
}
return $arrayTmp;
}
/**
* Combina los valores del primer array como las claves con los
* valores del segundo array.
* Si algún valor esta vacÃo o no es un array, este se convierte
* a un array.
*
* @param array $array_keys
* @param array $array_values
*
* @return array
*/
public static function combineKeysValue( $array_keys,
$array_values)
{
return array_combine( HelpConvert::toArray($array_keys),
HelpConvert::toArray($array_values) );
}
/**
* Inserta una valor en una posición determianda de un array.
* La primera posición es la 0 y ha de ser numérico.
* Los indices no tienen porque ser numéricos
*
* @param array $arr
* @param int $pos
* @param mixed $value
*
* @return array
*/
public static function appendToPos($arr, $pos, $value)
{
array_splice($arr, $pos, 0, [$value]);
return $arr;
}
/**
* Añade un valor al inicio del array.
* Devuelve un nuevo array con el valor insertado, no modifica
* el original.
*
* @param array $arr
* @param mixed $value
*
* @return array
*/
public static function appendFirst($arr, $value)
{
// Nos aseguramos de que sea un array
$arrTmp = HelpConvert::toArray($arr);
// Añadimos en la primnera posición
array_unshift($arrTmp, $value);
return $arrTmp;
}
/**
* Deveulve sólo los valores del array1 que estan en los valores
* del otro array.
* No devuelve ni compara claves.
* Si algún valor esta vacÃo o no es un array, este se convierte a
* un array.
*
* @param array $arr1
* @param array $arr2
*
* @return array
*/
public static function intersectionByValue($arr1, $arr2)
{
return array_intersect( HelpConvert::toArray($arr1),
HelpConvert::toArray($arr2) );
}
/**
* Devuelve sólo las claves/valores del array1 que están en las
* claves/valores del otro array.
* Si algún valor esta vacÃo o no es un array, este se convierte a
* un array.
*
* @param array $arr1
* @param array $arr2
*
* @return array
*/
public static function intersectionByKeyValue($arr1, $arr2)
{
return array_intersect_assoc( HelpConvert::toArray($arr1),
HelpConvert::toArray($arr2));
}
/**
* Deveulve sólo las claves/valores del array1 que están en las
* claves del otro array.
* No compaa en los valores del seguno array.
* Si algún valor esta vacÃo o no es un array, este se convierte a
* un array.
*
* @param array $arr1
* @param array $arr2
*
* @return array
*/
public static function intersectionByKey($arr1, $arr2)
{
return array_intersect_key( HelpConvert::toArray($arr1),
HelpConvert::toArray($arr2) );
}
}
