Helper

Overview

Phalcon\Support\HelperFactory offers support methods that manipulate arrays, files, JSON, numbers and strings. The factory replaces the Phalcon\Text component, offering the same functionality and more.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

The methods are available either by calling newInstance() on the factory object with the relevant name of the helper class, or calling the helper class directly as a method on the helper factory. The factory acts as a service locator, caching the objects to be reused if need be, in the same request.

Available Classes

Type	Name	Class
Array	`blacklist`	`Phalcon\Support\Helper\Arr\Blacklist`
Array	`chunk`	`Phalcon\Support\Helper\Arr\Chunk`
Array	`filter`	`Phalcon\Support\Helper\Arr\Filter`
Array	`first`	`Phalcon\Support\Helper\Arr\First`
Array	`firstKey`	`Phalcon\Support\Helper\Arr\FirstKey`
Array	`flatten`	`Phalcon\Support\Helper\Arr\Flatten`
Array	`get`	`Phalcon\Support\Helper\Arr\Get`
Array	`group`	`Phalcon\Support\Helper\Arr\Group`
Array	`has`	`Phalcon\Support\Helper\Arr\Has`
Array	`isUnique`	`Phalcon\Support\Helper\Arr\IsUnique`
Array	`last`	`Phalcon\Support\Helper\Arr\Last`
Array	`lastKey`	`Phalcon\Support\Helper\Arr\LastKey`
Array	`order`	`Phalcon\Support\Helper\Arr\Order`
Array	`pluck`	`Phalcon\Support\Helper\Arr\Pluck`
Array	`set`	`Phalcon\Support\Helper\Arr\Set`
Array	`sliceLeft`	`Phalcon\Support\Helper\Arr\SliceLeft`
Array	`sliceRight`	`Phalcon\Support\Helper\Arr\SliceRight`
Array	`split`	`Phalcon\Support\Helper\Arr\Split`
Array	`toObject`	`Phalcon\Support\Helper\Arr\ToObject`
Array	`validateAll`	`Phalcon\Support\Helper\Arr\ValidateAll`
Array	`validateAny`	`Phalcon\Support\Helper\Arr\ValidateAny`
Array	`whitelist`	`Phalcon\Support\Helper\Arr\Whitelist`
File	`basename`	`Phalcon\Support\Helper\File\Basename`
JSON	`decode`	`Phalcon\Support\Helper\Json\Decode`
JSON	`encode`	`Phalcon\Support\Helper\Json\Encode`
Number	`isBetween`	`Phalcon\Support\Helper\Number\IsBetween`
String	`camelize`	`Phalcon\Support\Helper\Str\Camelize`
String	`concat`	`Phalcon\Support\Helper\Str\Concat`
String	`countVowels`	`Phalcon\Support\Helper\Str\CountVowels`
String	`decapitalize`	`Phalcon\Support\Helper\Str\Decapitalize`
String	`decrement`	`Phalcon\Support\Helper\Str\Decrement`
String	`dirFromFile`	`Phalcon\Support\Helper\Str\DirFromFile`
String	`dirSeparator`	`Phalcon\Support\Helper\Str\DirSeparator`
String	`dynamic`	`Phalcon\Support\Helper\Str\Dynamic`
String	`endsWith`	`Phalcon\Support\Helper\Str\EndsWith`
String	`firstBetween`	`Phalcon\Support\Helper\Str\FirstBetween`
String	`friendly`	`Phalcon\Support\Helper\Str\Friendly`
String	`humanize`	`Phalcon\Support\Helper\Str\Humanize`
String	`includes`	`Phalcon\Support\Helper\Str\Includes`
String	`increment`	`Phalcon\Support\Helper\Str\Increment`
String	`interpolate`	`Phalcon\Support\Helper\Str\Interpolate`
String	`isAnagram`	`Phalcon\Support\Helper\Str\IsAnagram`
String	`isLower`	`Phalcon\Support\Helper\Str\IsLower`
String	`isPalindrome`	`Phalcon\Support\Helper\Str\IsPalindrome`
String	`isUpper`	`Phalcon\Support\Helper\Str\IsUpper`
String	`kebabCase`	`Phalcon\Support\Helper\Str\KebabCase`
String	`len`	`Phalcon\Support\Helper\Str\Len`
String	`lower`	`Phalcon\Support\Helper\Str\Lower`
String	`pascalCase`	`Phalcon\Support\Helper\Str\PascalCase`
String	`prefix`	`Phalcon\Support\Helper\Str\Prefix`
String	`random`	`Phalcon\Support\Helper\Str\Random`
String	`reduceSlashes`	`Phalcon\Support\Helper\Str\ReduceSlashes`
String	`snakeCase`	`Phalcon\Support\Helper\Str\SnakeCase`
String	`startsWith`	`Phalcon\Support\Helper\Str\StartsWith`
String	`suffix`	`Phalcon\Support\Helper\Str\Suffix`
String	`ucwords`	`Phalcon\Support\Helper\Str\Ucwords`
String	`uncamelize`	`Phalcon\Support\Helper\Str\Uncamelize`
String	`underscore`	`Phalcon\Support\Helper\Str\Underscore`
String	`upper`	`Phalcon\Support\Helper\Str\Upper`

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$upper = $helper->newInstance('upper');

Methods

The methods can be called directly from the helper factory.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'abcde';
$result = $helper->upper($source);

echo $result; // ABCDE

`blacklist`

blacklist(array $collection, array $blackList): array

Excludes elements of an array by the keys obtained from the elements of a blacklist

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'value-1',
    'key-2'   => 'value-2',
    'key-3'   => 'value-3',
    9         => 'value-4',
    12        => 'value-5',
    ' key-6 ' => 'value-6',
    99        => 'value-7',
    'key-8'   => 'value-8',
];

$blackList = [
    99,
    48,
    31,
    9,
    'key-45',
    null,
    -228,
    new stdClass(),
    [],
    3.501,
    false,
    'key-2',
    'key-3',
];

$result = $helper->blacklist($source, $blackList);

var_dump($result);
// [
//     'value-1',
//     12        => 'value-5',
//     ' key-6 ' => 'value-6',
//     'key-8'   => 'value-8',
// ]

`chunk`

chunk(array $collection, int $size, bool $preserveKeys = false): array

Chunks an array into smaller arrays of a specified size

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->chunk($source, 2, true);

var_dump($result);
// [
//     ['k1' => 1, 'k2' => 2],
//     ['k3' => 3, 'k4' => 4],
//     ['k5' => 5, 'k6' => 6],
// ]

`filter`

filter(array $collection, mixed $method = null): mixed

Filters a collection using array_filter and using the callable (if defined)

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    1  => 1,
    2  => 2,
    3  => 3,
    4  => 4,
    5  => 5,
    6  => 6,
    7  => 7,
    8  => 8,
    9  => 9,
    10 => 10,
];

$result = $helper->filter(
    $source,
    function ($element) {
        return $element & 1;
    }
);

var_dump($result);
// [
//     1 => 1,
//     3 => 3,
//     5 => 5,
//     7 => 7,
//     9 => 9,
// ]

`first`

first(array $collection, callable $method = null): mixed

Returns the first element of the collection. If a callable is passed, the element returned is the first that validates true

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
    'two' => 'Framework',
];

$result = $helper->first($source);

echo $result; // 'Phalcon'

`firstKey`

firstKey(array $collection, callable $method = null): mixed

Returns the key of the first element of the collection. If a callable is passed, the element returned is the first that validates true

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
    'two' => 'Framework',
];

$result = $helper->firstKey($source);

echo $result; // 'one'

`flatten`

flatten(array $collection, bool $deep = false): array

Flattens an array up to the one level depth, unless $deep is set to `true

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [1, [2], [[3], 4], 5];

$result = $helper->flatten($source);

var_dump($result);
// [1, 2, [3], 4, 5]

`get`

get(array $collection, mixed $index, mixed $defaultValue = null, string $cast = null): mixed

Gets an array element by key and if it does not exist returns the default. It also allows for casting the returned value to a specific type using settype internally

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
    'two' => '1',
];

echo $helper->get($source, 1);               // 'Phalcon'
echo $helper->get($source, 3, 'Unknown');    // 'Unknown'
echo $helper->get($source, 2, null, 'int');  // 1

`group`

group(array $collection, mixed $method): array

Groups the elements of an array based on the passed callable

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->group($source, 'age');

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

`has`

has(array $collection, mixed $index): bool

Checks an array if it has an element with a specific key and returns true/false accordingly

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    1     => 'Phalcon',
    'two' => 'Framework',
];

echo $helper->has($source, 1);         // true
echo $helper->get($source, 'two');     // true
echo $helper->get($source, 'unknown'); // false

`isUnique`

isUnique(array $collection): bool

Checks an array for duplicate values. Returns true if all values are unique, false otherwise.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

echo $helper->isUnique($source); // true

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

echo $helper->isUnique($source); // false

`last`

last(array $collection, callable $method = null): mixed

Returns the last element of the collection. If a callable is passed, the element returned is the first that validates true

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
    'two' => 'Framework',
];

$result = $helper->last($source);

echo $result; // 'Framework'

`lastKey`

lastKey(array $collection, callable $method = null): mixed

Returns the key of the first element of the collection. If a callable is passed, the element returned is the first that validates true

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
    'two' => 'Framework',
];

$result = $helper->lastKey($source);

echo $result; // 'two'

`order`

order(array $collection, mixed $attribute, string $order = 'asc'): array

Sorts a collection of arrays or objects by an attribute of the object. It supports ascending/descending sorts but also flags that are identical to the ones used by ksort and krsort

<?php

use Phalcon\Support\Helper\Arr\Order;
use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    [
        'id'   => 2,
        'name' => 'Paul',
    ],
    [
        'id'   => 3,
        'name' => 'Peter',
    ],
    [
        'id'   => 1,
        'name' => 'John',
    ],
];

$result = $helper->order($source, 'id');

var_dump($result);
// [
//     [
//         'id'   => 1,
//         'name' => 'John',
//     ],
//     [
//         'id'   => 2,
//         'name' => 'Paul',
//     ],
//     [
//         'id'   => 3,
//         'name' => 'Peter',
//     ],
// ]

$result = $helper->order($source, 'id', Order::ORDER_DESC);

var_dump($result);
// [
//     [
//         'id'   => 3,
//         'name' => 'Peter',
//     ],
//     [
//         'id'   => 2,
//         'name' => 'Paul',
//     ],
//     [
//         'id'   => 1,
//         'name' => 'John',
//     ],
// ]

$source = [
    (object) [
        'id'   => 2,
        'name' => 'Paul',
    ],
    (object) [
        'id'   => 3,
        'name' => 'Peter',
    ],
    (object) [
        'id'   => 1,
        'name' => 'John',
    ],
];

$result = $helper->order($source, 'id');

var_dump($result);
// [
//     (object) [
//         'id'   => 1,
//         'name' => 'John',
//     ],
//     (object) [
//         'id'   => 2,
//         'name' => 'Paul',
//     ],
//     (object) [
//         'id'   => 3,
//         'name' => 'Peter',
//     ],
// ]

`pluck`

pluck(array $collection, string $element): array

Returns a subset of the collection based on the collection values

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->pluck($source, 'name');

var_dump($result);
// [
//     'Desk',
//     'Chair',
// ]

$source = [
    (object) ['product_id' => 'prod-100', 'name' => 'Desk'],
    (object) ['product_id' => 'prod-200', 'name' => 'Chair'],
];

$result = $helper->pluck($source, 'name');

var_dump($result);
// [
//     'Desk',
//     'Chair',
// ]

`set`

set(array $collection, mixed $value, mixed $index = null): array

Sets an array element with an optional key

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one' => 'Phalcon',
];

$result = $helper->set($source, 'Framework');

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

$result = $helper->set($source, 'abcde', 'suffix');

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

`sliceLeft`

sliceLeft(array $collection, int $elements = 1): array

Returns a new array with n elements removed from the left.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->sliceLeft($source);

var_dump($result);
// [
//     'Phalcon',
// ]

$result = $helper->sliceLeft($source, 3);

var_dump($result);
// [
//     'Phalcon',
//     'Framework',
//     'for',
// ]

`sliceRight`

sliceRight(array $collection, int $elements = 1): array

Returns a new array with n elements removed from the right.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->sliceRight($source);

var_dump($result);
// [
//     'PHP',
// ]

$result = $helper->sliceRight($source, 3);

var_dump($result);
// [
//     'Framework',
//     'for',
//     'PHP',
// ]

`split`

split(array $collection): array

Returns a new array with keys of the collection as one element and values as another

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->split($source);

var_dump($result);
// [
//     [1, 3],
//     ['Phalcon', 'Framework'],
// ];

`toObject`

toObject(array $collection): object

Returns the passed array as an object

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [
    'one'   => 'two',
    'three' => 'four',
];

$result = $helper->toObject($source);

var_dump($result);
// class stdClass#1 (2) {
//   public $one =>
//   string(3) "two"
//   public $three =>
//   string(4) "four"
// }

`validateAll`

validateAll(array $collection, callable $method): bool

Returns true if the provided function returns true for all elements of the collection, false otherwise.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [2, 3, 4, 5];

$result = $helper->validateAll(
    $source,
    function ($element) {
        return $element > 1;
    }
);

echo $result; // true        

`validateAny`

validateAny(array $collection, callable $method): bool

Returns true if the provided function returns true for at least one element of the collection, false otherwise.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = [1, 2, 3, 4, 5];

$result = $helper->validateAny(
    $collection,
    function ($element) {
        return $element < 2;
    }
);

echo $result; // true

`whitelist`

whitelist(array $collection, array $whiteList): array

Includes elements of an array by the keys obtained from the elements of a whitelist

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source  = [
    'value-1',
    ' key '  => 'value-2',
    5        => 'value-3',
    6        => 'value-4',
    7        => 'value-5',
    ' key-2' => 'value-6',
    'key-3 ' => 'value-7',
    'key-4'  => 'value-8',
];

$whiteList = [
    7,
    5,
    0,
    'key-3 ',
    null,
    -13,
    new stdClass(),
    [],
    3.1415,
];

$result = $helper->whitelist($source, $blackList);

var_dump($result);
// [
//     0        => 'value-1',
//     5        => 'value-3',
//     7        => 'value-5',
//     'key-3 ' => 'value-7',
// ];

`basename`

basename(string $uri, string $suffix = null): string

Gets the filename from a given path, Same as PHP’s basename() but has non-ASCII support. PHP’s basename() does not properly support streams or filenames beginning with a non-US-ASCII character.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = '/etc/sudoers.d';

$result = $helper->basename($source);

echo $result; // .d

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

$result = $helper->basename($source);

echo $result; // 'ελληνικά.txt'

`decode`

decode(string $data, bool $associative = false, int $depth = 512, int $options = 0): string

Decodes a string using json_decode and throws an exception if the JSON data cannot be decoded

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->decode($source);

var_dump($result);
// [
//     'one' => 'two',
//     'three',
// ];

`encode`

encode($data, int $options = 0, int $depth = 512): string

Encodes a string using json_encode and throws an exception if the JSON data cannot be encoded

The following options are used if none specified for json_encode

JSON_HEX_TAG
JSON_HEX_APOS
JSON_HEX_AMP
JSON_HEX_QUOT
JSON_UNESCAPED_SLASHES
JSON_THROW_ON_ERROR

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->encode($source);

echo $result; // '{"one":"two","0":"three"}'

`isBetween`

isBetween(int $value, int $start, int $end): bool

Checks if a number is within a range

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$result = $helper->isBetween(5, 1, 10);

echo $result; // true

`camelize`

camelize(string $text, string $delimiters = null, bool $lowerFirst = false): string

Convert strings to upperCamelCase or lowerCamelCase

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'came-li-ze';

$result = $helper->camelize($source);

echo $result; // CameLiZe

`concat`

concat(string $delimiter, string $first, string $second, string ...$arguments): string

Concatenate strings using the separator, only once, without duplication

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$result = $helper->concat(
    '.',
    '@test.',
    '.test2.',
    '.test',
    '.34'
);

$result = $helper->concat($source);

echo $result; // '@test.test2.test.34'

`countVowels`

countVowels(string $text): int

Returns number of vowels in provided string. Uses a regular expression to count the number of vowels (A, E, I, O, U) in a string

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->countVowels($source);

echo $result; // 9

`decapitalize`

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

Decapitalizes the first letter of the string and then adds it with rest of the string. Omit the upperRest parameter to keep the rest of the string intact, or set it to true to convert to uppercase.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'BeetleJuice';

$result = $helper->decapitalize($source);

echo $result; // 'beetleJuice'

`decrement`

decrement(string $text, string $separator = '_'): string

Removes a number from the end of a string or decrements that number if it is already defined

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'file_2';

$result = $helper->decrement($source);

echo $result; // 'file_1'

`dirFromFile`

dirFromFile(string $file): string

Accepts a file name (without extension) and returns a calculated directory structure with the filename in the end

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'abcdef12345.jpg';

$result = $helper->dirFromFile($source);

echo $result; // 'ab/cd/ef/12/3/'

`dirSeparator`

dirSeparator(string $directory): string

Accepts a directory name and ensures that it ends with DIRECTORY_SEPARATOR

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = '/home/phalcon//';

$result = $helper->dirSeparator($source);

echo $result; // '/home/phalcon/'

`dynamic`

dynamic(string $text, string $leftDelimiter = "{", string $rightDelimiter = "}", string $separator = "|"): string

Generates random text in accordance with the template. The template is defined by the left and right delimiter, and it can contain values separated by the separator

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = '{Hi|Hello}, my name is Bob!';

$result = $helper->dynamic($source);

echo $result; // 'Hi, my name is Bob!'

$result = $helper->dynamic($source);

echo $result; // 'Hello, my name is Bob!'

`endsWith`

endsWith(string $haystack, string $needle, bool $ignoreCase = true): bool

Returns true if a string ends with a given string, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'abcdef';

$result = $helper->endsWith($source, 'ef');

echo $result; // true

`firstBetween`

firstBetween(string $text, string $start, string $end): string

Returns the first string there is between the strings from the parameter start and end.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

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

$result = $helper->firstBetween($source, '[', ']');

echo $result; // 'custom'

`friendly`

friendly(string $text, string $separator = '-', bool $lowercase = true, mixed $replace = null): string

Changes a text to a URL friendly one. Replaces commonly known accented characters with their Latin equivalents. If a replace string or array is passed, it will also be used to replace those characters with a space.

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'This is a Test';

$result = $helper->friendly($source);

echo $result; // 'this-is-a-test'

`humanize`

humanize(string $text): string

Changes a text with underscores or dashes to human-readable

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'kittens-are_cats';

$result = $helper->friendly($source);

echo $result; // 'kittens are cats'

`includes`

includes(string $haystack, string $needle): bool

Determines whether a string includes another string or not

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Phalcon Framework';

$result = $helper->includes($source, 'Framework');

echo $result; // true

`increment`

increment(string $text, string $separator = '_'): string

Adds a number to the end of a string or increments that number if it is already defined

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'file_1';

$result = $helper->increment($source);

echo $result; // 'file_2'

`interpolate`

interpolate(string $message, array $context = [], string $leftToken = "%", string $rightToken = "%"): string

Interpolates context values into the message placeholders. By default, the right and left tokens are %

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = '%date% (YYYY-MM-DD) %level% (0-9)';
$data   = [
    'date'  => '2020-09-09',
    'level' => 'CRITICAL',
];

$result = $helper->interpolate($source, $data);

echo $result; // '2020-09-09 (YYYY-MM-DD) CRITICAL (0-9)'

`isAnagram`

isAnagram(string $first, string $second): bool

Compares two strings and returns true if both strings are anagram, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'rail safety';
$target = 'fairy tales';

$result = $helper->isAnagram($source, $target);

echo $result; // true

`isLower`

isLower(string $text, string $encoding = 'UTF-8'): bool

Returns true if the given string is in lower case, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'phalcon framework';

$result = $helper->isLower($source);

echo $result; // true

`isPalindrome`

isPalindrome(string $text): bool

Returns true if the given string is a palindrome, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'racecar';

$result = $helper->isPalindrome($source);

echo $result; // true

`isUpper`

isUpper(string $text, string $encoding = 'UTF-8'): bool

Returns true if the given string is in upper case, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'PHALCON FRAMEWORK';

$result = $helper->isUpper($source);

echo $result; // true

`kebabCase`

kebabCase(string $text, string $delimiters = null): string

Convert strings to kebab-case style

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'customer_session';

$result = $helper->kebabCase($source);

echo $result; // 'customer-session'

`len`

len(string $text, string $encoding = 'UTF-8'): int

Calculates the length of the string using mb_strlen

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'abcdef';

$result = $helper->len($source);

echo $result; // 6

`lower`

lower(string $text, string $encoding = 'UTF-8'): string

Converts a string to lowercase using mbstring

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Phalcon Framework';

$result = $helper->lower($source);

echo $result; // 'phalcon framework'

`pascalCase`

pascalCase(string $text, string $delimiters = null): string

Convert strings to PascalCase style

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'customer-session';

$result = $helper->pascalCase($source);

echo $result; // 'CustomerSession'

`prefix`

prefix($text, string $prefix): string

Prefixes the text with the supplied prefix

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Framework';

$result = $helper->prefix($source, 'Phalcon');

echo $result; // 'PhalconFramework'

`random`

random(int $type = 0, int $length = 8): string

Generates a random string based on the given type. Type is one of:

Constant	Description
`RANDOM_ALNUM`	Only alphanumeric characters [a-zA-Z0-9]
`RANDOM_ALPHA`	Only alphabetical characters [azAZ]
`RANDOM_DISTINCT`	Only alphanumeric uppercase characters exclude similar characters [2345679ACDEFHJKLMNPRSTUVWXYZ]
`RANDOM_HEXDEC`	Only hexadecimal characters [0-9a-f]
`RANDOM_NOZERO`	Only numbers without 0 [1-9]
`RANDOM_NUMERIC`	Only numbers [0-9]

<?php

use Phalcon\Support\Helper\Str\Random;
use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

echo $helper->random(Random::RANDOM_ALNUM); // 4
echo $helper->random(Random::RANDOM_ALNUM); // 2
echo $helper->random(Random::RANDOM_ALNUM); // 1
echo $helper->random(Random::RANDOM_ALNUM); // 3

`reduceSlashes`

reduceSlashes(string $text): string

Reduces multiple slashes in a string to single slashes

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'app/controllers//IndexController';

$result = $helper->reduceSlashes($source);

echo $result; // 'app/controllers/IndexController'

`snakeCase`

snakeCase(string $text, string $delimiters = null): string

Convert strings to snake_case style

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'customer-session';

$result = $helper->snakeCase($source);

echo $result; // 'customer_session'

`startsWith`

startsWith(string $haystack, string $needle, bool $ignoreCase = true): bool

Returns true if a string starts with a given string, false otherwise

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'abcdef';

$result = $helper->startsWith($source, 'ab');

echo $result; // true

`suffix`

suffix($text, string $suffix): string

Suffixes the text with the supplied suffix

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Phalcon';

$result = $helper->suffix($source, 'Framework');

echo $result; // 'PhalconFramework'

`ucwords`

ucwords(string $text, string $encoding = 'UTF-8'): string

Capitalizes the first letter of each word

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'phalcon framework';

$result = $helper->ucwords($source);

echo $result; // 'Phalcon Framework'

`uncamelize`

uncamelize(string $text, string $delimiters = '_'): string

Convert strings to non camelized style

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'CameLiZe';

$result = $helper->uncamelize($source);

echo $result; // came-li-ze

`underscore`

underscore(string $text): string

Converts spaces to underscores

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Phalcon Framework';

$result = $helper->underscore($source);

echo $result; // 'Phalcon_Framework'

`upper`

upper(string $text, string $encoding = 'UTF-8'): string

Converts a string to uppercase using mbstring

<?php

use Phalcon\Support\HelperFactory;

$helper = new HelperFactory();

$source = 'Phalcon Framework';

$result = $helper->upper($source);

echo $result; // 'PHALCON FRAMEWORK'

Translate on Crowdin

General

Introduction

Release Notes

Upgrade