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

Upgrade Instructions

Traducir en Crowdin

General

Introducción

Notas de la Versión

Actualizar

Patrocinadores

Contribuciones

Resumen

Pull Requests

NFR (Solicitud de Nuevas Características)

Generación de Backtrace

Pruebas Reproducibles

Entorno de prueba

Estándar de codificación

Cómo Empezar

Instalación

Configuración de Servidor Web

Entornos

Devilbox

Nanobox

Herramientas de Desarrollo

DevTools

Depuración

Migraciones

Pruebas Unitarias

Tutoriales

Básico

Invo

REST

Vokuro

Casos de uso

Rendimiento

Núcleo

Índice del API

Application

Micro

CLI

Contenedor DI

MVC

Espacios de nombres

Servicios

Cache

Configuración

Escaper

Loader

Logger

Base de Datos

Capa

PHQL

ODM

Modelos

Comportamientos

Cache

Eventos

Metadatos

Relaciones

Transacciones

Validadores

Paginación

Migraciones

Front End

Recursos Activos

Mensajes Flash

Formularios

Imagen

Tag

Vistas

Volt

Lógica de Negocio

Listas de Control de Acceso

Anotaciones

Controladores

Dispatcher

Gestor de Eventos

Filtros

Ruteo

Sesiones

Url

Validación

HTTP

Consulta

Respuesta

Seguridad

Crypto

Seguridad

JWT

PSR

PSR-3 Logger

PSR-0, PSR-4 Cargador

PSR-7 Petición HTTP

PSR-7 Respuesta HTTP

PSR-7 Petición Servidor HTTP

PSR-7 Flujo HTTP

PSR-7 Fichero Subido HTTP

PSR-7 Uri HTTP

PSR-11 Contenedor

PSR-13 Enlaces HTML

PSR-17 Fábricas HTTP

i18n

Internacionalización

Traducciones

Utilidad

Coleccion

Dominio

HTML

Ayudantes (Helpers)

Registro