Secciones

Componente Ayudante


Resumen

Phalcon\Helper un componente que expone las clases ayudantes y métodos estáticos usados por el framework.

Arr

Phalcon\Helper\Arr expone métodos estáticos que ofrecen un acceso rápido a funcionalidades comunes cuando se trabaja con vectores.

chunk

final public static function chunk(
    array $collection, 
    int $size, 
    bool $preserveKeys = false
): array

Trocea un vector en vectores más pequeños de un determinado tamaño.

<?php

use Phalcon\Helper\Arr;

$source   = [
    'k1' => 1,
    'k2' => 2,
    'k3' => 3,
    'k4' => 4,
    'k5' => 5,
    'k6' => 6,
];

$chunks = Arr::chunk($source, 2);

// [
//    [1, 2],
//    [3, 4],
//    [5, 6],
// ]

first

final public static function first(
    array $collection, 
    mixed $method = null
): var

Devuelve el primer elemento de la colección. Si se indica una invocable, el elemento devuelto es el primero que valida a true

<?php

use Phalcon\Helper\Arr;

$collection = [
    'Phalcon',
    'Framework',
];

echo Arr::first($collection); // 'Phalcon'

$result = Arr::first(
    $collection,
    function ($element) {
        return strlen($element) > 8;
    }
);

echo $result; // 'Framework'

firstKey

final public static function firstKey(
    array $collection, 
    mixed $method = null
): var

Devuelve la clave del primer elemento de la colección. Si se indica una invocable, el elemento devuelto es el primero que valida a true

<?php

use Phalcon\Helper\Arr;

$collection = [
    1 => 'Phalcon',
    3 => 'Framework',
];

echo Arr::firstKey($collection); // 1

$result = Arr::firstKey(
    $collection,
    function ($element) {
        return strlen($element) > 8;
    }
);

echo $result; // 3

flatten

final public static function flatten(
    array $collection, 
    bool $deep = false
): array

Aplana un vector hasta tener un sólo nivel de profundidad. Si $deep se configura a true, recorre todos los elementos y los aplana todos.

<?php

use Phalcon\Helper\Arr;

$source   = [1, [2], [[3], 4], 5];
var_dump(
    Arr::flatten($source)
);

// [1, 2, [3], 4, 5];

$source   = [1, [2], [[3], 4], 5];
var_dump(
    Arr::flatten($source, true)
);
// [1, 2, 3, 4, 5];

get

final public static function get(
    array $collection, 
    mixed $index, 
    mixed $defaultValue = null,
    string $cast = null
): mixed

Recupera un elemento de un vector. Si el elemento existe se devuelve su valor. Si no, se devuelve defaultValue. El parámetro cast acepta una cadena que define a qué tipo será convertido el valor devuelto. Los valores disponibles son:

  • array
  • bool
  • boolean
  • double
  • float
  • int
  • integer
  • null
  • object
  • string
<?php

use Phalcon\Helper\Arr;

$data = [
    'colors' => [
        'red',
        'white',
        'blue',
    ],
    'year'   => 1776,
];

echo Arr::get($data, 'year');                    // 1776
echo Arr::get($data, 'unknown', 1776);           // 1776
echo Arr::get($data, 'unknown', 1776, 'string'); // '1776'

group

final public static function group(
    array $collection, 
    mixed $method
): array

Agrupa los elementos de un vector basándose en la invocable indicada y devuelve el vector con los elementos agrupados. La invocable puede ser una cadena con el nombre del elemento, una llamable o un método disponible. El vector puede contener subvectores como elementos u objetos con propiedades relevantes.

<?php

use Phalcon\Helper\Arr;

$collection =  [
    ['name' => 'Paul',  'age' => 34],
    ['name' => 'Peter', 'age' => 31],
    ['name' => 'John',  'age' => 29],
];

$result = Arr::group($collection, 'age');
var_dump($result);

// [
//     34 => [
//         [
//             'name' => 'Paul',
//             'age' => 34,
//         ],
//     ],
//     31 => [
//         [
//             'name' => 'Peter',
//             'age' => 31,
//         ],
//     ],
//     29 => [
//         [
//             'name' => 'John',
//             'age' => 29,
//         ],
//     ],
// ]


$peter = new \stdClass();
$peter->name = 'Peter';
$peter->age = 34;

$paul = new \stdClass();
$paul->name = 'Paul';
$paul->age = 31;

$collection = [
    'peter' => $peter,
    'paul'  => $paul,
];

$result = = Arr::group($collection, 'name');
var_dump($result);

// [
//     'Peter' => [
//          stdClass(
//              name : 'Peter',
//              age  : 34
//          ),
//      ],
//     'Paul'  => [
//          stdClass(
//              name : 'Paul',
//              age  : 31
//          ),
//      ],
// ]


$collection = ['one', 'two', 'three'];

$result = Arr::group($collection, 'strlen');
var_dump($result);

// [
//     3 => ['one', 'two'],
//     5 => ['three']
// ]

has

final public static function has(array $collection, mixed $index): bool

Comprueba si un elemento existe en un vector. Devuelve true si se encuentra, false en caso contrario.

<?php

use Phalcon\Helper\Arr;

$data = [
    'colors' => [
        'red',
        'white',
        'blue',
    ],
    'year'   => 1776,
];

echo Arr::has($data, 'year');          // true
echo Arr::has($data, 'unknown');       // false

isUnique

final public static function isUnique(array $collection): bool

Comprueba valores duplicados en una lista plana. Devuelve true si existen valores duplicados y false si todos los valores son únicos.

<?php

use Phalcon\Helper\Arr;

$collection = [
    'Phalcon',
    'Framework',
];

$result = Arr::isUnique($collection); // true

$collection = [
    'Phalcon',
    'Framework',
    'Phalcon',
];
$result = Arr::isUnique($collection); // false

last

final public static function last(
    array $collection, 
    mixed $method = null
): var

Devuelve el último elemento de la colección. Si se indica una invocable, el elemento devuelto es el último que valida true

<?php

use Phalcon\Helper\Arr;

$collection = [
    'Phalcon',
    'Framework',
];

echo Arr::last($collection); // 'Framework'

$result = Arr::last(
    $collection,
    function ($element) {
        return strlen($element) < 8;
    }
);

echo $result; // 'Phalcon'

lastKey

final public static function lastKey(
    array $collection, 
    mixed $method = null
): var

Devuelve la clave del último elemento de la colección. Si se indica una invocable, el elemento devuelto es el último que valida true

<?php

use Phalcon\Helper\Arr;

$collection = [
    1 => 'Phalcon',
    3 => 'Framework',
];

echo Arr::lastKey($collection); // 3

$result = Arr::lastKey(
    $collection,
    function ($element) {
        return strlen($element) < 8;
    }
);

echo $result; // 1

order

final public static function order(
    array $collection, 
    mixed $attribute, 
    string $order = 'asc'
): array

Ordena una colección de vectores u objetos por attribute y devuelve el vector ordenado. El tercer parámetro controla el sentido de la ordenación.

<?php

use Phalcon\Helper\Arr;

$collection = [
    ['id' => 2],
    ['id' => 3],
    ['id' => 1],
];

$result = Arr::order($collection, 'id');
var_dump($result);
// [
//     ['id' => 1],
//     ['id' => 2],
//     ['id' => 3],
// ]

$result = Arr::order($collection, 'id', 'desc');
var_dump($result);
// [
//     ['id' => 3],
//     ['id' => 2],
//     ['id' => 1],
// ]

pluck

final public static function pluck(
    array $collection, 
    string element
): array

Recupera todos los valores para una clave dada, devolviéndolos como un vector

<?php

use Phalcon\Helper\Arr;

$collection = [
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
];

$result = Arr::pluck($collection, 'name');
var_dump($result);
// [
//     'Desk', 
//     'Chair'
// ]

set

final public static function set(
    array $collection, 
    mixed $value, 
    mixed $index = null
): array

Establece un elemento vector y devuelve un nuevo vector. El tercer parámetro es el índice/clave.

<?php

use Phalcon\Helper\Arr;

$collection = [];
$result = Arr::set($collection, 'Phalcon');
var_dump($result);
// [
//     0 => 'Phalcon',
// ]


$collection = [
    1 => 'Phalcon'
];
$result = Arr::set($collection, 'Framework', 1);
var_dump($result);
// [
//     1 => 'Framework',
// ]

sliceLeft

final public static function sliceLeft(
    array $collection, 
    int $elements = 1
): array

Devuelve un nuevo vector con n elementos eliminados desde la izquierda.

<?php

use Phalcon\Helper\Arr;

$collection = [
    'Phalcon',
    'Framework',
    'for',
    'PHP',
];

$result = Arr::sliceLeft($collection, 1);
var_dump($result);
// [
//     'Phalcon',
// ]

$result = Arr::sliceLeft($collection, 3);
var_dump($result);
// [
//     'Phalcon',
//     'Framework',
//     'for',
// ]

sliceRight

final public static function sliceRight(
    array $collection, 
    int $elements = 1
): array

Devuelve un nuevo vector con n elementos eliminados desde la derecha.

<?php

use Phalcon\Helper\Arr;

$collection = [
    'Phalcon',
    'Framework',
    'for',
    'PHP',
];

$result   = Arr::sliceRight($collection, 1);
var_dump($result);
// [
//     'Framework',
//     'for',
//     'PHP',
// ]

$result   = Arr::sliceRight($collection, 3);
var_dump($result);
// [
//     'PHP',
// ]

split

final public static function split(array $collection): array

Devuelve un nuevo vector con las claves del vector indicado como un elemento y los valores en otro.

<?php

use Phalcon\Helper\Arr;

$collection = [
    1 => 'Phalcon',
    3 => 'Framework',
];

$result = Arr::split($collection);
var_dump($result);
// [
//     [1, 3],
//     ['Phalcon', 'Framework']
// ]

toObject

final public static function toObject(array $collection)

Convierte un vector a un objeto

<?php

use Phalcon\Helper\Arr;

$collection = [
    1 => 'Phalcon',
    3 => 'Framework',
];

$result = Arr::toObject($collection);
var_dump($result);
// object(stdClass)#1 (2) {
//   ["1"] => string(7) "Phalcon"
//   ["3"] => string(9) "Framework"
// }

validateAll

final public static function validateAll(
    array $collection, 
    mixed $method
): bool

Devuelve true si la función indicada devuelve true para todos los elementos de la colección, false en caso contrario.

<?php

use Phalcon\Helper\Arr;

$collection = [2, 3, 4, 5];
$result     = Arr::validateAll(
    $collection,
    function ($element) {
        return $element > 1;
    }
);

var_dump($result); // true

validateAny

final public static function validateAny(
    array $collection, 
    mixed $method
): bool

Devuelve true si la función indicada devuelve true para al menos un elemento de la colección, false en caso contrario.

<?php

use Phalcon\Helper\Arr;

$collection = [2, 3, 4, 5];
$result     = Arr::validateAny(
    $collection,
    function ($element) {
        return $element > 4;
    }
);

var_dump($result); // true

whiteList

final public static function whiteList(
    array $collection, 
    array $whiteList 
): array

Devuelve un subconjunto del vector, elementos de lista blanca por clave. El vector devuelto contiene sólo los elementos del vector original que tiene claves idénticas al vector lista blanca pasado como parámetro.

<?php

use Phalcon\Helper\Arr;

$collection = [
    2     => 'Phalcon',
    3     => 'Apples',
    'one' => 'Framework',
    'two' => 'Oranges',
];
$result     = Arr::whiteList(
    $collection,
    [2, 'one']
);

var_dump($result);
// [
//     2     => 'Phalcon',
//     'one' => 'Framework'
// ]

Excepción

Cualquier excepción lanzada en los componentes Phalcon\Helper\* serán de este tipo: Phalcon\Helper\Exception

Fs

Phalcon\Helper\Fs expone métodos estáticos que ofrecen métodos de ayuda para operaciones con ficheros

basename

final public static function basename(
    int $uri, 
    mixed $suffix
) -> string

Obtiene el nombre de fichero de una ruta dada, Este método es similar a la función PHP basename() pero con soporte de caracteres no-ASCII. La función de PHP basename() no soporta correctamente flujos o nombres de archivo que empiecen con un carácter no-US-ASCII.

<?php

use Phalcon\Helper\Fs;

$file = '/file/热爱中文.txt';

echo Fs::basename($file); // '热爱中文.txt'

$file = '/myfolder/日本語のファイル名.txt';

echo Fs::basename($file); // '日本語のファイル名.txt'

$file = '/root/ελληνικά.txt';

echo Fs::basename($file); // 'ελληνικά.txt';

Json

Phalcon\Helper\Json actúa como una envoltura de los métodos PHP json_encode y json_decode, comprobando errores y lanzando excepciones en consecuencia.

decode

final public static function decode(
    string $data,
    bool $associative = false,
    int $depth = 512,
    int $options = 0
 ): mixed

Decodifica una cadena usando json_decode y lanza una excepción si los datos JSON no pueden ser decodificados

use Phalcon\Helper\Json;

$data = ' {"one":"two","0":"three"}
';

var_dump(Json::decode($data));
// [
//     'one' => 'two',
//     'three'
// ];

encode

final public static function encode(
    $data,
    int $depth = 512,
    int $options = 0
): string

Codifica una cadena usando json_encode y lanza una excepción si los datos JSON no se han podido codificar

use Phalcon\Helper\Json;

$data = [
    'one' => 'two',
    'three'
];

echo Json::encode($data);
// {"one":"two","0":"three"}

Number

Phalcon\Helper\Number expone métodos estáticos que ofrecen un acceso rápido a funcionalidades comunes cuando se trabaja con números.

between

final public static function between(
    int $value, 
    int $from, 
    int $to
) -> bool

Comprueba si el valor pasado está entre el rango especificado en from y to

<?php

use Phalcon\Helper\Number;

$min   = 10;
$max   = 100;
$value = 13;

echo Number::between($value, $min, $max);   // true

$value = 2;
echo Number::between($value, $min, $max);   // false

Str

Phalcon\Helper\Str expone métodos estáticos que ofrecen manipulaciones ágiles sobre cadenas.

camelize

final public static function camelize(string $text, mixed $delimiter = null): string

Convierte una cadena a estilo camelize

<?php

use Phalcon\Helper\Str;

echo Str::camelize('coco_bongo');         // CocoBongo
echo Str::camelize('co_co-bon_go', '-');  // Co_coBon_go
echo Str::camelize('co_co-bon_go', '_-'); // CoCoBonGo

concat

final public static function concat(
    string $separator, 
    string $a, 
    string $b 
    [, string $x] ... 
): string

Concatena cadenas usando el separador sólo una vez, quitando delimitadores duplicados. El primer parámetro es el separador, los siguientes son las cadenas a concatenar. Los parámetros mínimos obligatorios son tres.

<?php

use Phalcon\Helper\Str;

$folder = Str::concat(
    '/',
    '/tmp/',
    '/folder_1/',
    '/folder_2',
    'folder_3/'
);

echo $folder; // /tmp/folder_1/folder_2/folder_3/

countVowels

final public static function countVowels(string $text): int

Devuelve el número de vocales de la cadena indicada. Usa una expresión regular para contar el número de vocales (A, E, I, O, U) en una cadena.

<?php

use Phalcon\Helper\Str;

$source = 'Luke, I am your father!';

echo Str::countVowels($source); // 8

decapitalize

final public static function decapitalize(
    string $text, 
    bool $upperRest = false, 
    string $encoding = 'UTF-8'
): string

Convierte a minúscula la primera letra de la cadena y luego la añade. Si el parámetro upperRest se establece a false el resto de la cadena permanecece intacto, en caso contrario se convertirá a mayúsculas. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa. El último parámetro es la codificación que usarán los métodos mbstring. Por defecto UTF-8.

<?php

use Phalcon\Helper\Str;

$source   = 'BeetleJuice';

echo Str::decapitalize($source);       // beetleJuice
echo Str::decapitalize($source, true); // bEETLEJUICE

decrement

final public static function decrement(
    string $text, 
    string $separator = '_'
): string

Elimina un número de una cadena o decrementa ese número si está definido.

<?php

use Phalcon\Helper\Str;

echo Str::decrement('a_1'); // 'a'
echo Str::decrement('a_2'); // 'a_1'

dirFromFile

final public static function dirFromFile(string $file): string

Acepta un nombre de fichero (sin extension) y devuelve una estructura de directorio calculada con el nombre del fichero al final

<?php

use Phalcon\Helper\Str;

echo Str::dirFromFile("file1234.jpg"); // fi/le/12/

dirSeparator

final public static function dirSeparator(string $directory): string

Acepta un nombre de directorio y se asegura que termina con DIRECTORY_SEPARATOR

<?php

use Phalcon\Helper\Str;

echo Str::dirSeparator("/home/phalcon"); // /home/phalcon/

dynamic

final public static function dynamic(
    string $text,
    string $leftDelimiter = '{',
    string $rightDelimiter = '}',
    string $separator = '|'
): string

Genera texto aleatorio basado en la plantilla. La plantilla necesita separadores y delimitadores para los diferentes valores. Los valores por defecto para éstos se pueden anular con los parámetros del método.

<?php

use Phalcon\Helper\Str;

echo Str::dynamic('{Han|Leia|Luke} {Solo|Skywalker}!');  // Han Solo!
echo Str::dynamic('{Han|Leia|Luke} {Solo|Skywalker}!');  // Leia Skywalker!
echo Str::dynamic('{Han|Leia|Luke} {Solo|Skywalker}!');  // Luke Solo!

endsWith

final public static function endsWith(
    string $text, 
    string $end, 
    bool $ignoreCase = true
): bool

Devuelve true si una cadena termina con la cadena dada. Si el último parámetro es true (por defecto), la búsqueda se hace de una forma insensible a mayúsculas y minúsculas.

<?php

use Phalcon\Helper\Str;

echo Str::endsWith('Hello', 'llo');        // true
echo Str::endsWith('Hello', 'LLO', false); // false
echo Str::endsWith('Hello', 'LLO');        // true

firstBetween

final public static function firstBetween(
    string $haystack,
    string $start,
    string $end
): string

Devuelve la primera cadena que hay entre las cadenas de los parámetros start y end. El método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa.

<?php

use Phalcon\Helper\Str;

$source   = 'This is a [custom] string with [other] stuff';

echo Str::firstBetween($source, '[', ']'); // custom

humanize

final public static function humanize(string $text): string

Transforma una frase separada con guiones bajos o medios legible para humanos

<?php

use Phalcon\Helper\Str;

echo Str::humanize('start-a-horse'); // 'start a horse'
echo Str::humanize('five_cats');     // 'five cats'

includes

final public static function includes(
    string $needle, 
    string $haystack
): bool

Comprueba si una cadena está incluida en otra. Devuelve true si está incluida, false en caso contrario. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa.

<?php

use Phalcon\Helper\Str;

echo Str::includes('start', 'start-a-horse'); // true
echo Str::includes('end', 'start-a-horse'); // false

increment

final public static function increment(
    string $text, 
    string $separator = '_'
): string

Añade un número a una cadena o lo incrementa si el número ya existe.

<?php

use Phalcon\Helper\Str;

echo Str::increment('a');   // 'a_1'
echo Str::increment('a_1'); // 'a_2'

isAnagram

final public static function isAnagram(
    string $first, 
    string $second
): bool

Compara dos cadenas y devuelve true si ambas cadenas son anagramas, false en caso contrario.

<?php

use Phalcon\Helper\Str;

echo Str::isAnagram('rail safety', 'fairy tales'); // true

isLower

final public static function isLower(
    string $text, 
    string $encoding = 'UTF-8'
):  bool

Devuelve true si la cadena dada está en minúsculas, false en caso contrario. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa. El último parámetro es la codificación que usarán los métodos mbstring. Por defecto UTF-8.

<?php

use Phalcon\Helper\Str;

echo Str::isLower('phalcon framework'); // true
echo Str::isLower('Phalcon Framework'); // false

isPalindrome

final public static function isPalindrome(string $text): bool

Devuelve true si la cadena dada es un palíndromo, false en caso contrario.

<?php

use Phalcon\Helper\Str;

echo Str::isPalindrome('racecar'); // true

isUpper

final public static function isUpper(
    string $text, 
    string $encoding = 'UTF-8'
):  bool

Devuelve true si la cadena dada está en mayúsculas, false en caso contrario. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa. El último parámetro es la codificación que usarán los métodos mbstring. Por defecto UTF-8.

<?php

use Phalcon\Helper\Str;

echo Str::isUpper('PHALCON FRAMEWORK'); // true
echo Str::isUpper('Phalcon Framework'); // false

lower

final public static function lower(
    string $text, 
    string $encoding = 'UTF-8'
): string

Convierte una cadena a minúscula. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa. El último parámetro es la codificación que usarán los métodos mbstring. Por defecto UTF-8.

<?php

use Phalcon\Helper\Str;

echo Str::lower('PHALCON FRAMEWORK'); // phalcon framework

random

final public static function random(
    int $type = 0, 
    long $length = 8
): string

Genera una cadena aleatoria basada en el tipo dado. El primer parámetro es una de las constantes RANDOM_*. El segundo parámetro especifica el tamaño de la cadena (por defecto 8).

Constante Descripción
RANDOM_ALNUM Sólo caracteres alfanuméricos [a-zA-Z0-9]
RANDOM_ALPHA Sólo caracteres alfabéticos [azAZ]
RANDOM_DISTINCT Sólo caracteres alfanuméricos en mayúsculas excluyen caracteres similares [2345679ACDEFHJKLMNPRSTUVWXYZ]
RANDOM_HEXDEC Sólo caracteres hexadecimales [0-9a-f]
RANDOM_NOZERO Sólo números sin 0 [1-9]
RANDOM_NUMERIC Sólo números [0-9]
<?php

use Phalcon\Helper\Str;

echo Str::random(Str::RANDOM_ALNUM); // 'aloiwkqz'

reduceSlashes

final public static function reduceSlashes(string $text): string

Reduce múltiples barras de una cadena a sólo una barra. Si está presente el esquema (https://, ftp:// no se cambiará)

<?php

use Phalcon\Helper\Str;

echo Str::reduceSlashes('foo//bar/baz');             // foo/bar/baz
echo Str::reduceSlashes('http://foo.bar///baz/buz'); // http://foo.bar/baz/buz
echo Str::reduceSlashes('//foo.bar///baz/buz');      // /foo.bar/baz/buz
echo Str::reduceSlashes('ftp://foo.bar///baz/buz');  // ftp://foo.bar/baz/buz
echo Str::reduceSlashes('ftp//foo.bar///baz/buz');   // ftp/foo.bar/baz/buz

startsWith

final public static function startsWith(
    string $text, 
    string $start, 
    bool $ignoreCase = true
): bool

Devuelve true si una cadena empieza por una cadena dada. Si el último parámetro es true (por defecto), la búsqueda se hace de una forma insensible a mayúsculas y minúsculas.

<?php

use Phalcon\Helper\Str;

echo Str::startsWith('Hello', 'He');        // true
echo Str::startsWith('Hello', 'he', false); // false
echo Str::startsWith('Hello', 'he');        // true

uncamelize

final public static function uncamelize(
    string $text,   
    mixed $delimiter = null
): string

Convierte en texto normal, cadenas de texto en estilo camelcase

<?php

use Phalcon\Helper\Str;

echo Str::uncamelize('CocoBongo');      // coco_bongo
echo Str::uncamelize('CocoBongo', '-'); // coco-bongo

underscore

final public static function underscore(string $text): string

Transforma una frase separada por guiones bajos en lugar de espacios.

<?php

use Phalcon\Helper\Str;

echo Str::underscore('look behind');     // 'look_behind'
echo Str::underscore('Awesome Phalcon'); // 'Awesome_Phalcon'

upper

final public static function upper(
    string $text, 
    string $encoding = 'UTF-8'
): string

Convierte una cadena a mayúscula. Este método intentará usar métodos proporcionados por la extensión mbstring y usar el equivalente PHP como alternativa. El último parámetro es la codificación que usarán los métodos mbstring. Por defecto UTF-8.

<?php

use Phalcon\Helper\Str;

echo Str::upper('phalcon framework'); // PHALCON FRAMEWORK