PHPackages atlcom/helper - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Utility & Helpers](/categories/utility) 4. / 5. atlcom/helper ActiveLibrary[Utility & Helpers](/categories/utility) atlcom/helper ============= Atlcom Helper library v1.25.5(7mo ago)11.4k↓70%1MITPHPPHP ^8.1 Since Mar 19Pushed 7mo ago1 watchersCompare [ Source](https://github.com/atlcomgit/helper)[ Packagist](https://packagist.org/packages/atlcom/helper)[ Fund](https://yoomoney.ru/to/4100110213116546)[ RSS](/packages/atlcom-helper/feed)WikiDiscussions master Synced 2d ago READMEChangelog (10)Dependencies (3)Versions (55)Used By (1) Helper ====== [](#helper) Класс помощник для работы со строками, числами, массивами. --- История изменений ----------------- [](#история-изменений) [Открыть историю](CHANGELOG.md) Установка --------- [](#установка) ``` composer require atlcom/helper ``` Описание методов ---------------- [](#описание-методов) --- ### Array [](#array) Работа с массивами --- ##### [arrayDeleteKeys($value, ...$searches): array](./tests/HelperArrayTrait/HelperArrayDeleteKeysTest.php) [](#arraydeletekeysvalue-searches-array) Возвращает массив с удаленными ключами ``` $array = Helper::arrayDeleteKeys(['a' => 1, 'b' => 2], 'a'); // $array = ['b' => 2] ``` --- ##### [arrayDeleteValues($value, ...$searches): array](./tests/HelperArrayTrait/HelperArrayDeleteValuesTest.php) [](#arraydeletevaluesvalue-searches-array) Возвращает массив с удаленными значениями ``` $array = Helper::arrayDeleteValues(['a', 'b'], 'a'); // $array = [1 => 'b'] ``` --- ##### [arrayDot($value): array](./tests/HelperArrayTrait/HelperArrayDotTest.php) [](#arraydotvalue-array) Возвращает одномерный массив из многомерного ``` $array = Helper::arrayDot(['a' => ['b' => 2, 'c' => 3]]); // $array = ['a.b' => 2, 'a.c' => 3] ``` --- ##### [arrayExcludeTraceVendor($value, $basePath): array](./tests/HelperArrayTrait/HelperArrayExcludeTraceVendorTest.php) [](#arrayexcludetracevendorvalue-basepath-array) Исключает из массива трассировки пакетные ошибки ``` $array = Helper::arrayExcludeTraceVendor(debug_backtrace()); // $array = [] ``` --- ##### [arrayFirst($value, $key): mixed](./tests/HelperArrayTrait/HelperArrayFirstTest.php) [](#arrayfirstvalue-key-mixed) Возвращает значение первого элемента массива ``` $mixed = Helper::arrayFirst(['a', 'b']); // $mixed === 'a' $mixed = Helper::arrayFirst(['a' => 1, 'b' => 2]); // $mixed === 1 ``` --- ##### [arrayFlip($value): array](./tests/HelperArrayTrait/HelperArrayFlipTest.php) [](#arrayflipvalue-array) Возвращает массив с заменой местами ключей и значений ``` $array = Helper::arrayFlip(['a' => 'b']); // $array === ['b' => 'a'] ``` --- ##### [arrayGet($value, $key): mixed](./tests/HelperArrayTrait/HelperArrayGetTest.php) [](#arraygetvalue-key-mixed) Возвращает значение из массива по имению ключа ``` $mixed = Helper::arrayGet(['a', 'b'], 0); // $mixed === 'a' $mixed = Helper::arrayGet(['a' => ['b' => 2, 'c' => 3], 'b' => 4], 'a.b'); // $mixed === 2 $mixed = Helper::arrayGet(['a.b' => 1, 'b' => 2], 'a.b'); // $mixed === 1 ``` --- ##### [arrayIsAssociative($value): bool](./tests/HelperArrayTrait/HelperArrayIsAssociativeTest.php) [](#arrayisassociativevalue-bool) Проверяет является ли массив ассоциативным ``` $boolean = Helper::arrayIsAssociative(['a', 'b']); // $boolean === false $boolean = Helper::arrayIsAssociative(['a' => 1, 'b' => 2]); // $boolean === true ``` --- ##### [arrayLast($value, $key): mixed](./tests/HelperArrayTrait/HelperArrayLastTest.php) [](#arraylastvalue-key-mixed) Возвращает значение последнего элемента массива ``` $mixed = Helper::arrayLast(['a', 'b']); // $mixed === 'b' $mixed = Helper::arrayLast(['a' => 1, 'b' => 2]); // $mixed === 2 ``` --- ##### [arrayMappingKeys($value, $from, $to): array](./tests/HelperArrayTrait/HelperArrayMappingKeysTest.php) [](#arraymappingkeysvalue-from-to-array) Возвращает массив с маппингом ключей ``` $array = Helper::arrayMappingKeys(['a' => 1, 'b' => 2], 'a', 'c'); // $array = ['c' => 1, 'b' => 2] $array = Helper::arrayMappingKeys([['a' => 1], ['a' => 2]], ['a' => 'c']); // $array = [['c' => 1], ['c' => 2]] ``` --- ##### [arraySearchKeys($value, ...$searches): array](./tests/HelperArrayTrait/HelperArraySearchKeysTest.php) [](#arraysearchkeysvalue-searches-array) Возвращает массив найденных ключей в искомом массиве ``` $array = Helper::arraySearchKeys(['a' => 1, 'b' => 2], 'a'); // $array = ['a' => 1] $array = Helper::arraySearchKeys(['a' => ['b' => 2, 'c' => 3]], '*.b'); // $array = ['a.b' => 2] ``` --- ##### [arraySearchKeysAndValues($value, ...$keys, ...$values): array](./tests/HelperArrayTrait/HelperArraySearchKeysAndValuesTest.php) [](#arraysearchkeysandvaluesvalue-keys-values-array) Возвращает массив найденных ключей в искомом массиве ``` $array = Helper::arraySearchKeys(['a' => 1, 'b' => 2], 'a'); // $array = ['a' => 1] $array = Helper::arraySearchKeys(['a' => ['b' => 2, 'c' => 3]], '*.b'); // $array = ['a.b' => 2] ``` --- ##### [arraySearchValues($value, ...$searches): array](./tests/HelperArrayTrait/HelperArraySearchValuesTest.php) [](#arraysearchvaluesvalue-searches-array) Возвращает массив найденных ключей в искомом массиве ``` $array = Helper::arraySearchValues(['a', 'b'], 'a'); // $array = ['a'] $array = Helper::arraySearchValues(['abc', 'def'], ['a*', '*f']); // $array = ['abc', 'def'] ``` --- ##### [arrayTrimValues($value, $trims): array](./tests/HelperArrayTrait/HelperArrayTrimValuesTest.php) [](#arraytrimvaluesvalue-trims-array) Возвращает массив с применением trim для каждого значения ``` $array = Helper::arrayTrimValues([' a ', ',b.,:;']); // $array = ['a', 'b'] ``` --- ##### [arrayTruncateStringValues($value, $size): array](./tests/HelperArrayTrait/HelperArrayTruncateStringValuesTest.php) [](#arraytruncatestringvaluesvalue-size-array) Усекает длинные строки в массиве ``` $array = Helper::arrayTruncateStringValues([' a ' => '123'], 2); // $array = ['a' => '12'] ``` --- ##### [arrayUnDot($value): array](./tests/HelperArrayTrait/HelperArrayUnDotTest.php) [](#arrayundotvalue-array) Возвращает многомерный массив из одномерного ``` $array = Helper::arrayUnDot(['a.b' => 2, 'a.c' => 3]); // $array = ['a' => ['b' => 2, 'c' => 3]] ``` --- ### Bracket [](#bracket) Работа со скобками/тегами --- ##### [bracketChange($value, $left, $right, $index): string](./tests/HelperBracketTrait/HelperBracketChangeTest.php) [](#bracketchangevalue-left-right-index-string) Возвращает строку с заменой содержимого внутри блока скобок под индексом index на строку change ``` $string = Helper::bracketChange('(a)(b)', '(', ')', 0, 'c'); // $string = '(c)(b)' ``` --- ##### [bracketCopy($value, $left, $right, $index): string](./tests/HelperBracketTrait/HelperBracketCopyTest.php) [](#bracketcopyvalue-left-right-index-string) Возвращает содержимое внутри блока скобок под индексом index ``` $string = Helper::bracketCopy('(a)(b)', '(', ')', 0); // $string = 'a' ``` --- ##### [bracketCount($value, $left, $right): int](./tests/HelperBracketTrait/HelperBracketCountTest.php) [](#bracketcountvalue-left-right-int) Возвращает количество блоков скобок ``` $integer = Helper::bracketCount('(a)(b)', '(', ')'); // $integer = 2 ``` --- ##### [bracketDelete($value, $left, $right, $index): string](./tests/HelperBracketTrait/HelperBracketDeleteTest.php) [](#bracketdeletevalue-left-right-index-string) Возвращает строку с удалением блока скобок под индексом index ``` $string = Helper::bracketDelete('(a)(b)', '(', ')', 0); // $string = '(b)' ``` --- ##### [bracketReplace($value, $left, $right, $index, $replace): string](./tests/HelperBracketTrait/HelperBracketReplaceTest.php) [](#bracketreplacevalue-left-right-index-replace-string) Возвращает строку с заменой блока скобок под индексом index на строку replace ``` $string = Helper::bracketReplace('(a)(b)', '(', ')', 0, '(c)'); // $string = '(c)(b)' ``` --- ##### [bracketSearch($value, $left, $right, $index, ...$searches): array](./tests/HelperBracketTrait/HelperBracketSearchTest.php) [](#bracketsearchvalue-left-right-index-searches-array) Возвращает массив найденных строк с индексами блоков скобок ``` $array = Helper::bracketSearch('(a)(b)', '(', ')', 'a'); // $array = ['a' => [0]] ``` --- ### Cache [](#cache) Работа с кешем --- ##### [cacheRuntime($key, $callback, $cacheEnabled): mixed](./tests/HelperCacheTrait/HelperCacheRuntimeTest.php) [](#cacheruntimekey-callback-cacheenabled-mixed) Сохраняет значение value в кеше по ключу key или возвращает значение при его наличии Если cacheEnabled выключен, то кеш не используется ``` $mixed = Helper::cacheRuntime('key', fn () => 1); // $mixed = 1 $mixed = Helper::cacheRuntimeGet('key'); // $mixed = 1 ``` --- ##### [cacheRuntimeClear(): void](./tests/HelperCacheTrait/HelperCacheRuntimeClearTest.php) [](#cacheruntimeclear-void) Очищает весь кеш ``` Helper::cacheRuntimeClear(); // ``` --- ##### [cacheRuntimeDelete($key): void](./tests/HelperCacheTrait/HelperCacheRuntimeDeleteTest.php) [](#cacheruntimedeletekey-void) Удаляет значение из кеша по ключу key ``` Helper::cacheRuntimeDelete('key'); // ``` --- ##### [cacheRuntimeExists($key): bool](./tests/HelperCacheTrait/HelperCacheRuntimeExistsTest.php) [](#cacheruntimeexistskey-bool) Проверяет существование ключа в кеше и возвращает true/false ``` $boolean = Helper::cacheRuntimeExists('key'); // $boolean = false ``` --- ##### [cacheRuntimeGet($key, $default): mixed](./tests/HelperCacheTrait/HelperCacheRuntimeGetTest.php) [](#cacheruntimegetkey-default-mixed) Возвращает значение из кеша по ключу key или возвращает значение по умолчанию default ``` $mixed = Helper::cacheRuntimeGet('key', 'value'); // $mixed = 'value' ``` --- ##### [cacheRuntimeSet($key, $value): mixed](./tests/HelperCacheTrait/HelperCacheRuntimeSetTest.php) [](#cacheruntimesetkey-value-mixed) Сохраняет значение value в кеше по ключу key ``` $mixed = Helper::cacheRuntimeSet('key', 'value'); // $mixed = 'value' ``` --- ### Case [](#case) Работа со стилем --- ##### [caseCamel($value): string](./tests/HelperCaseTrait/HelperCaseCamelTest.php) [](#casecamelvalue-string) Возвращает строку в стиле camelCase ``` $string = Helper::caseCamel('abc-def'); // $string = 'abcDef' ``` --- ##### [caseKebab($value): string](./tests/HelperCaseTrait/HelperCaseKebabTest.php) [](#casekebabvalue-string) Возвращает строку в стиле kebab-case ``` $string = Helper::caseKebab('abcDef'); // $string = 'abc-Def' ``` --- ##### [casePascal($value): string](./tests/HelperCaseTrait/HelperCasePascalTest.php) [](#casepascalvalue-string) Возвращает строку в стиле PascalCase ``` $string = Helper::casePascal('abc-def'); // $string = 'AbcDef' ``` --- ##### [caseSnake($value): string](./tests/HelperCaseTrait/HelperCaseSnakeTest.php) [](#casesnakevalue-string) Возвращает строку в стиле snake\_case ``` $string = Helper::caseSnake('abcDef'); // $string = 'abc_Def' ``` --- ### Cast [](#cast) Работа с типами --- ##### [castToArray($value): ?array](./tests/HelperCastTrait/HelperCastToArrayTest.php) [](#casttoarrayvalue-array) Возвращает преобразование значения к массиву или null ``` $array = Helper::castToArray(1); // $array = [1] ``` --- ##### [castToBool($value): ?bool](./tests/HelperCastTrait/HelperCastToBoolTest.php) [](#casttoboolvalue-bool) Возвращает преобразование значения к логическому типу или null ``` $boolean = Helper::castToBool(1); // $boolean = true ``` --- ##### [castToCallable($value): ?callable](./tests/HelperCastTrait/HelperCastToCallableTest.php) [](#casttocallablevalue-callable) Возвращает преобразование значения к статичной функции с результатом самого значения или null ``` $callable = Helper::castToCallable(1); // $callable() = 1 ``` --- ##### [castToCarbon($value): ?Carbon](./tests/HelperCastTrait/HelperCastToCarbonTest.php) [](#casttocarbonvalue-carbon) Возвращает преобразование значения к типу Carbon или null ``` $date = Helper::castToCarbon('2025-08-08'); // $date->format('Y-m-d') = '2025-08-08' $date = Helper::castToCarbon(1733376000); // $date->format('Y-m-d') = '2024-12-05' (пример) ``` --- ##### [castToFloat($value): ?float](./tests/HelperCastTrait/HelperCastToFloatTest.php) [](#casttofloatvalue-float) Возвращает преобразование значения к вещественному типу или null ``` $float = Helper::castToFloat(1); // $float = 1.0 ``` --- ##### [castToJson($value): ?string](./tests/HelperCastTrait/HelperCastToJsonTest.php) [](#casttojsonvalue-string) Возвращает преобразование значения к строке json или null ``` $json = Helper::castToJson(1); // $json = '"1"' ``` --- ##### [castToInt($value): ?int](./tests/HelperCastTrait/HelperCastToIntTest.php) [](#casttointvalue-int) Возвращает преобразование значения к целочисленному типу или null ``` $integer = Helper::castToInt('1'); // $integer = 1 ``` --- ##### [castToObject($value): ?object](./tests/HelperCastTrait/HelperCastToObjectTest.php) [](#casttoobjectvalue-object) Возвращает преобразование значения к объекту или null ``` $object = Helper::castToObject(1); // $object = (object)[1] ``` --- ##### [castToString($value): ?string](./tests/HelperCastTrait/HelperCastToStringTest.php) [](#casttostringvalue-string) Возвращает преобразование значения к строковому типу или null ``` $string = Helper::castToString(1); // $string = '1' ``` --- ### Cipher [](#cipher) Работа с безопасным шифрованием --- ##### [cipherDecode($value, $password): mixed](./tests/HelperCipherTrait/HelperCipherDecodeTest.php) [](#cipherdecodevalue-password-mixed) Дешифрует base58 строку, зашифрованную новым алгоритмом с использованием пароля ``` $mixed = Helper::cipherDecode('Ndm4LnGDc3We5yFWXG1U3P5Ws7Z3aFyL677WptDeoBXkAD', 'password'); // $mixed = 'abc' ``` --- ##### [cipherEncode($value, $password): string](./tests/HelperCipherTrait/HelperCipherEncodeTest.php) [](#cipherencodevalue-password-string) Шифрует значение в компактную base58 строку с использованием пароля ``` $string = Helper::cipherEncode('abc', 'password'); // $string = 'Ndm4LnGDc3We5yFWXG1U3P5Ws7Z3aFyL677WptDeoBXkAD' ``` --- ### Color [](#color) Работа с цветами --- ##### [colorHexToRgb($value): array](./tests/HelperColorTrait/HelperColorHexToRgbTest.php) [](#colorhextorgbvalue-array) Возвращает массив с RGB цветом из цвета HEX строки ``` $array = Helper::colorHexToRgb('#000'); // $array = ['r' => 0, 'g' => 0, 'b' => 0, 'a' => null] $array = Helper::colorHexToRgb('#000000'); // $array = ['r' => 0, 'g' => 0, 'b' => 0, 'a' => null] $array = Helper::colorHexToRgb('#00000000'); // $array = ['r' => 0, 'g' => 0, 'b' => 0, 'a' => 0] ``` --- ##### [colorRgbToHex($red, $green, $blue, $alpha): string](./tests/HelperColorTrait/HelperColorRgbToHexTest.php) [](#colorrgbtohexred-green-blue-alpha-string) Возвращает HEX строку из RGB цвета ``` $string = Helper::colorRgbToHex(0, 0, 0); // $string = '#000000' $string = Helper::colorRgbToHex(0, 0, 0, 0); // $string = '#00000000' ``` --- ##### [colorRandomHex(): string](./tests/HelperColorTrait/HelperColorRandomHexTest.php) [](#colorrandomhex-string) Возвращает случайный HEX цвет в формате #rrggbb ``` $string = Helper::colorRandomHex(); // $string = '#1a2b3c' ``` --- ##### [colorRandomRgb(): array](./tests/HelperColorTrait/HelperColorRandomRgbTest.php) [](#colorrandomrgb-array) Возвращает случайный RGB цвет в формате массива ``` $array = Helper::colorRandomRgb(); // $array = ['r' => 26, 'g' => 43, 'b' => 60, 'a' => null] ``` --- ### Crypt [](#crypt) Работа с шифрованием --- ##### [cryptArrayDecode($value, $password): array](./tests/HelperCryptTrait/HelperCryptArrayDecodeTest.php) [](#cryptarraydecodevalue-password-array) Дешифрует все значения элементов массива вида 'hash:crypt' ``` $array = Helper::cryptArrayDecode(['a' => 'hash:crypt']); // $array = ['a' => 1] ``` --- ##### [cryptArrayEncode($value, $password, $random)](./tests/HelperCryptTrait/HelperCryptArrayEncodeTest.php) [](#cryptarrayencodevalue-password-random) Шифрует все значения элементов массива с добавлением хеша значения 'hash:crypt' ``` $array = Helper::cryptArrayDecode(['a' => 1]); // $array = ['a' => 'hash:crypt'] ``` --- ##### [cryptDecode($value, $password): string](./tests/HelperCryptTrait/HelperCryptDecodeTest.php) [](#cryptdecodevalue-password-string) Дешифрует строку с паролем ``` $string = Helper::cryptDecode('nh93432NibR3td26', 'password'); // $string = 'abc' ``` --- ##### [cryptEncode($value, $password, $random): string](./tests/HelperCryptTrait/HelperCryptEncodeTest.php) [](#cryptencodevalue-password-random-string) Шифрует строку с паролем ``` $string = Helper::cryptEncode('abc', 'password'); // $string = 'nh93432NibR3td26' ``` --- ### Date [](#date) Работа с датами --- ##### [dateDayName($value): string](./tests/HelperDateTrait/HelperDateDayNameTest.php) [](#datedaynamevalue-string) Возвращает название дня недели переданного значения ``` $string = Helper::dateDayName('31.12.2025'); // $string = 'среда' ``` --- ##### [dateFromString($value): ?Carbon](./tests/HelperDateTrait/HelperDateFromStringTest.php) [](#datefromstringvalue-carbon) Возвращает объект Carbon с распознанной датой или null ``` $date = Helper::dateFromString('в следующий понедельник'); // $date->format('d.m.Y') = 'XX.XX.XXXX' $date = Helper::dateFromString('через 2 месяца'); // $date->format('d.m.Y') = 'XX.XX.XXXX' ``` --- ##### [dateToString($value, $declension): ?Carbon](./tests/HelperDateTrait/HelperDateToStringTest.php) [](#datetostringvalue-declension-carbon) Возвращает дату прописью на русском языке с учетом склонения по падежу ``` $string = Helper::dateToString(Carbon::parse('01.02.2025')); // $string = 'первое февраля две тысячи двадцать пятый год' ``` --- ### Enum [](#enum) Работа с перечислениями --- ##### [enumDefault(): mixed](./tests/HelperEnumTrait/HelperEnumDefaultTest.php) [](#enumdefault-mixed) Возвращает вариант enum по умолчанию ``` value = MyEnum::enumDefault(); // $value = null ``` --- ##### [enumExists($value): bool](./tests/HelperEnumTrait/HelperEnumExistsTest.php) [](#enumexistsvalue-bool) Проверяет на существование перечисления по значению и возвращает true/false ``` $boolean = MyEnum::enumExists('Name1'); // $boolean = true/false ``` --- ##### [enumFirst(): ?BackedEnum](./tests/HelperEnumTrait/HelperEnumFirstTest.php) [](#enumfirst-backedenum) Возвращает первое перечисление ``` $enum = MyEnum::enumFirst(); // $enum = MyEnum::Name1 ``` --- ##### [enumFrom($value): ?BackedEnum](./tests/HelperEnumTrait/HelperEnumFromTest.php) [](#enumfromvalue-backedenum) Возвращает найденное перечисление по имени, по значению или по перечислению ``` $enum = MyEnum::enumFrom('Name1'); // $enum = MyEnum::Name1 ``` --- ##### [enumLabel($value): ?string](./tests/HelperEnumTrait/HelperEnumLabelTest.php) [](#enumlabelvalue-string) Возвращает описание перечисления (необходимо реализовать метод enumLabel) ``` $string = MyEnum::enumLabel(MyEnum::Name1); // $string = 'Name1 (value1)' ``` --- ##### [enumLabels($value, $label): array](./tests/HelperEnumTrait/HelperEnumLabelsTest.php) [](#enumlabelsvalue-label-array) Возвращает список перечислений для ресурса ``` $array = MyEnum::enumLabels(); // $array = [['value' => 'value1', 'label' => 'Описание 1']] ``` --- ##### [enumLast(): ?BackedEnum](./tests/HelperEnumTrait/HelperEnumLastTest.php) [](#enumlast-backedenum) Возвращает последнее перечисление ``` $enum = MyEnum::enumLast(); // $enum = MyEnum::Name2 ``` --- ##### [enumName($value): ?string](./tests/HelperEnumTrait/HelperEnumNameTest.php) [](#enumnamevalue-string) Возвращает ключ перечисления ``` $string = Helper::enumName(MyEnum::Name1); // $string = 'Name1' ``` --- ##### [enumNames($value): array](./tests/HelperEnumTrait/HelperEnumNamesTest.php) [](#enumnamesvalue-array) Возвращает имена ключей перечисления enum ``` $array = MyEnum::enumNames(); // $array = ['Name1'] ``` --- ##### [enumRandom($value = null): ?BackedEnum](./tests/HelperEnumTrait/HelperEnumRandomTest.php) [](#enumrandomvalue--null-backedenum) Возвращает случайное перечисление ``` $enum = Helper::enumRandom(MyEnum::class); // $enum = MyEnum::Name1 ``` --- ##### [enumToArray($value): array](./tests/HelperEnumTrait/HelperEnumToArrayTest.php) [](#enumtoarrayvalue-array) Возвращает массив ключей и значений enum ``` $array = MyEnum::enumToArray(); // $array = ['Name1' => 'value1'] ``` --- ##### [enumValue($value): mixed](./tests/HelperEnumTrait/HelperEnumValueTest.php) [](#enumvaluevalue-mixed) Возвращает значение перечисления ``` $mixed = Helper::enumValue(HelperEnumValueEnum::Name1); // $mixed = 'value1' ``` --- ##### [enumValues($value = null): array](./tests/HelperEnumTrait/HelperEnumValuesTest.php) [](#enumvaluesvalue--null-array) Возвращает значения ключей перечисления enum ``` $array = MyEnum::enumValues(); // $array = ['value1'] ``` --- ### Env [](#env) Работа с окружением --- ##### [envDev(): bool](./tests/HelperEnvTrait/HelperEnvDevTest.php) [](#envdev-bool) Проверяет окружение приложения на разработку и возвращает true/false ``` $$boolean = Helper::envDev(); // $boolean = true/false ``` --- ##### [envGet($value, $file): mixed](./tests/HelperEnvTrait/HelperEnvGetTest.php) [](#envgetvalue-file-mixed) Возвращает значение ключа из файла .env ``` $mixed = Helper::envDev('APP_ENV', '.env.example'); // $mixed = mixed ``` --- ##### [envLocal(): bool](./tests/HelperEnvTrait/HelperEnvLocalTest.php) [](#envlocal-bool) Проверяет окружение приложения на локальное и возвращает true/false ``` $boolean = Helper::envLocal(); // $boolean = true/false ``` --- ##### [envProd(): bool](./tests/HelperEnvTrait/HelperEnvProdTest.php) [](#envprod-bool) Проверяет окружение приложения на боевое и возвращает true/false ``` $boolean = Helper::envProd(); // $boolean = true/false ``` --- ##### [envStage(): bool](./tests/HelperEnvTrait/HelperEnvStageTest.php) [](#envstage-bool) Проверяет окружение приложения на пред боевое и возвращает true/false ``` $boolean = Helper::envStage(); // $boolean = true/false ``` --- ##### [envTest(): bool](./tests/HelperEnvTrait/HelperEnvTestTest.php) [](#envtest-bool) Проверяет окружение приложения на тестовое и возвращает true/false ``` $boolean = Helper::envTest(); // $boolean = true/false ``` --- ##### [envTesting(): bool](./tests/HelperEnvTrait/HelperEnvTestingTest.php) [](#envtesting-bool) Проверяет окружение приложения на авто-тестирование и возвращает true/false ``` $boolean = Helper::envTesting(); // $boolean = true/false ``` --- ### Exception [](#exception) Работа с исключениями --- ##### [exceptionToArray($value): array](./tests/HelperExceptionTrait/HelperExceptionToArrayTest.php) [](#exceptiontoarrayvalue-array) Возвращает исключение в виде массива ``` $array = Helper::exceptionToArray(new Exception('Exception message', 400)); // $array = ['code': 400, ...] ``` --- ##### [exceptionToString($value): string](./tests/HelperExceptionTrait/HelperExceptionToStringTest.php) [](#exceptiontostringvalue-string) Возвращает исключение в виде строки json ``` $string = Helper::exceptionToString(new Exception('message', 400)); // $string = '{"code": 400, ...}' ``` --- ### Fake [](#fake) Работа с генерацией данных --- ##### [fakeEmail(): string](./tests/HelperFakeTrait/HelperFakeEmailTest.php) [](#fakeemail-string) Возвращает случайно сгенерированный email ``` $string = Helper::fakeEmail(); // $string = 'abc@asd.ru' ``` --- ##### [fakeIp4(): string](./tests/HelperFakeTrait/HelperFakeIp4Test.php) [](#fakeip4-string) Возвращает случайно сгенерированный ip адрес v4 ``` $string = Helper::fakeIp4(); // $string = '111.222.33.44' ``` --- ##### [fakeIp6(): string](./tests/HelperFakeTrait/HelperFakeIp6Test.php) [](#fakeip6-string) Возвращает случайно сгенерированный ip адрес v6 ``` $string = Helper::fakeIp6(); // $string = '2001:0db8:0058:0074:1c60:2c18:1025:2b5f' ``` --- ##### [fakeName($locale, $surnames, $firstNames, $patronymics): string](./tests/HelperFakeTrait/HelperFakeNameTest.php) [](#fakenamelocale-surnames-firstnames-patronymics-string) Возвращает случайно сгенерированное ФИО ``` $string = Helper::fakeName(); // $string = 'Иванов Иван Иванович' ``` --- ##### [fakePassword(): string](./tests/HelperFakeTrait/HelperFakePasswordTest.php) [](#fakepassword-string) Возвращает случайно сгенерированный пароль ``` $string = Helper::fakePassword(); // $string = 'af3usn5f' ``` --- ##### [fakePhone(): string](./tests/HelperFakeTrait/HelperFakePhoneTest.php) [](#fakephone-string) Возвращает случайно сгенерированный номер телефона с/без кодом страны ``` $string = Helper::fakePhone(); // $string = '79645831465' ``` --- ##### [fakeUrl($protocols, $domainNames, $domainZones, $paths, $queries, $anchors): string](./tests/HelperFakeTrait/HelperFakeUrlTest.php) [](#fakeurlprotocols-domainnames-domainzones-paths-queries-anchors-string) Возвращает случайно сгенерированный url ``` $string = Helper::fakeUrl(); // $string = 'http://abc.com/def?a=b#xyz' ``` --- ##### [fakeUuid4(): string](./tests/HelperFakeTrait/HelperFakeUuid4Test.php) [](#fakeuuid4-string) Возвращает случайно сгенерированный UUID v4 ``` $string = Helper::fakeUuid4(); // $string = 'f1f27725-7a51-4581-a6b8-45f236e50d81' ``` --- ##### [fakeUuid7(): string](./tests/HelperFakeTrait/HelperFakeUuid7Test.php) [](#fakeuuid7-string) Возвращает случайно сгенерированный UUID v7 ``` $string = Helper::fakeUuid7(); // $string = '019668c4-7b6c-7333-9563-d10b583c4046' ``` --- ### File [](#file) Работа с файлами --- ##### [fileChangePath($value, $newPath): string](./tests/HelperFileTrait/FileChangePathTest.php) [](#filechangepathvalue-newpath-string) Меняет путь к файлу ``` $string = Helper::fileChangePath('/var/www/html/test.php', '/home/user'); // $string = '/home/user/test.php' $string = Helper::fileChangePath('test.php', '/var/www'); // $string = '/var/www/test.php' $string = Helper::fileChangePath('/var/www/html/test.php', ''); // $string = 'test.php' ``` --- ##### [fileChangeExtension($value, $newExtension): string](./tests/HelperFileTrait/FileChangeExtensionTest.php) [](#filechangeextensionvalue-newextension-string) Меняет расширение файла без точки ``` $string = Helper::fileChangeExtension('/var/www/html/test.php', 'txt'); // $string = '/var/www/html/test.txt' $string = Helper::fileChangeExtension('document.pdf', 'docx'); // $string = 'document.docx' $string = Helper::fileChangeExtension('/var/www/html/test.php', ''); // $string = '/var/www/html/test' $string = Helper::fileChangeExtension('/home/user/README', 'md'); // $string = '/home/user/README.md' ``` --- ##### [fileChangeName($value, $newName): string](./tests/HelperFileTrait/FileChangeNameTest.php) [](#filechangenamevalue-newname-string) Меняет имя файла с расширением ``` $string = Helper::fileChangeName('/var/www/html/test.php', 'newfile.php'); // $string = '/var/www/html/newfile.php' $string = Helper::fileChangeName('test.php', 'renamed.txt'); // $string = 'renamed.txt' $string = Helper::fileChangeName('/var/www/html/test.php', ''); // $string = '/var/www/html/test.php' ``` --- ##### [fileExtension($value): string](./tests/HelperFileTrait/FileExtensionTest.php) [](#fileextensionvalue-string) Возвращает только расширение файла без точки ``` $string = Helper::fileExtension('/var/www/html/test.php'); // $string = 'php' $string = Helper::fileExtension('document.PDF'); // $string = 'PDF' $string = Helper::fileExtension('/home/user/README'); // $string = '' $string = Helper::fileExtension('/path/to/file.name.tar.gz'); // $string = 'gz' ``` --- ##### [fileName($value): string](./tests/HelperFileTrait/FileNameTest.php) [](#filenamevalue-string) Возвращает имя файла с расширением ``` $string = Helper::fileName('/var/www/html/test.php'); // $string = 'test.php' $string = Helper::fileName('folder/subfolder/file.txt'); // $string = 'file.txt' $string = Helper::fileName('document.pdf'); // $string = 'document.pdf' $string = Helper::fileName('/home/user/README'); // $string = 'README' ``` --- ##### [filePath($value): string](./tests/HelperFileTrait/FilePathTest.php) [](#filepathvalue-string) Возвращает путь из строки ``` $string = Helper::filePath('/var/www/html/test.php'); // $string = '/var/www/html' $string = Helper::filePath('folder/subfolder/file.txt'); // $string = 'folder/subfolder' $string = Helper::filePath('file.txt'); // $string = '' $string = Helper::filePath('/etc/.bashrc'); // $string = '/etc' ``` --- ### Hash [](#hash) Работа с хешами --- ##### [hashIdDecode($token, $password): ?int](./tests/HelperHashTrait/HelperHashIdDecodeTest.php) [](#hashiddecodetoken-password-int) Декодирует короткий токен обратно в идентификатор с учетом пароля и встроенных метаданных токена (поддерживаются маски алфавита вида `0-9`, `a-z`, `A-Z`) ``` $integer = Helper::hashIdDecode('FL6H'); // $integer = 12345 $integer = Helper::hashIdDecode('PB3U', 'secret'); // $integer = 12345 $integer = Helper::hashIdDecode('FL6Hlh'); // $integer = 12345 $integer = Helper::hashIdDecode('12f1ba', 'secret', 0, '0123456789abcdef'); // $integer = 12345 $integer = Helper::hashIdDecode('eb6', '', 3, '0-9'); // $integer = 123 ``` --- ##### [hashIdEncode($value, $password, $minLength, $alphabet): string](./tests/HelperHashTrait/HelperHashIdEncodeTest.php) [](#hashidencodevalue-password-minlength-alphabet-string) Кодирует неотрицательный идентификатор в короткий токен по указанному паролю с настройками длины и алфавита (поддерживаются маски алфавита вида `0-9`, `a-z`, `A-Z`) ``` $string = Helper::hashIdEncode(12345); // $string = 'FL6H' $string = Helper::hashIdEncode(12345, 'secret'); // $string = 'PB3U' $string = Helper::hashIdEncode(12345, null, 6); // $string = 'FL6Hlh' $string = Helper::hashIdEncode(12345, 'secret', 0, '0123456789abcdef'); // $string = '12f1ba' $string = Helper::hashIdEncode(123, null, 3, '0-9'); // $string = 'eb6' ``` ##### [hashXxh128($value): string](./tests/HelperHashTrait/HelperHashXxh128Test.php) [](#hashxxh128value-string) Возвращает xxh128 хеш значения ``` $string = Helper::hashXxh128('abc'); // $string = '06b05ab6733a618578af5f94892f3950' ``` --- ### Interval [](#interval) Работа с интервалами --- ##### [intervalAround($value, $min, $max): int](./tests/HelperIntervalTrait/HelperIntervalAroundTest.php) [](#intervalaroundvalue-min-max-int) Возвращает число со смещением по кругу в заданном интервале ``` $integer = Helper::intervalAround(3 + 1, 1, 3); // $integer = 1 $integer = Helper::intervalAround(1 - 1, 1, 3); // $integer = 3 ``` --- ##### [intervalBetween($value, ...$intervals): array](./tests/HelperIntervalTrait/HelperIntervalBetweenTest.php) [](#intervalbetweenvalue-intervals-array) Проверяет значение на вхождение в интервал(ы) ``` $bool = (bool)Helper::intervalBetween(2, [1, 10]); // $bool = true $bool = (bool)Helper::intervalBetween(12, '1..10, 13..20'); // $bool = false $bool = (bool)Helper::intervalBetween('2025.01.02', '2025.01.01, 2025.01.03..2025.01.04'); // $bool = false $bool = (bool)Helper::intervalBetween('2025.01.02', ['2025.01.01', '2025.01.03']); // $bool = true ``` --- ##### [intervalCollection(...$intervals): array](./tests/HelperIntervalTrait/HelperIntervalCollectionTest.php) [](#intervalcollectionintervals-array) Возвращает число со смещением по кругу в заданном интервале ``` $array = Helper::intervalCollection(1, 3); // $array = [['equal' => 1], ['equal' => 3]] $array = Helper::intervalCollection('1..3'); // $array = [['min' => '1', 'max' => '3']] $array = Helper::intervalCollection([1, 3], 5); // $array = [['min' => 1, 'max' => 3], ['equal' => 5]] ``` --- ##### [intervalOverlap(...$intervals): array](./tests/HelperIntervalTrait/HelperIntervalOverlapTest.php) [](#intervaloverlapintervals-array) Проверяет пересечение интервалов ``` $bool = (bool)Helper::intervalOverlap([1, 3], [2, 4]); // $bool = true $bool = (bool)Helper::intervalOverlap('1..3', '2..4'); // $bool = false ``` --- ### Ip [](#ip) Работа с ip адресами --- ##### [ipInRange($value, ...$masks): array](./tests/HelperIpTrait/HelperIpInRangeTest.php) [](#ipinrangevalue-masks-array) Возвращает массив найденных масок подсетей, в которые входит ip адрес ``` $array = Helper::ipInRange('192.168.1.1', '192.168.1.0/24'); // $array = ['192.168.1.0/24'] ``` --- ### Json [](#json) Работа с json строками --- ##### [jsonFlags(): int](./tests/HelperJsonTrait/HelperJsonFlagsTest.php) [](#jsonflags-int) Возвращает флаг для формирования json строки ``` $integer = Helper::jsonFlags(); // $integer = 3146048 ``` --- ### Jwt [](#jwt) Работа с jwt токенами --- ##### [jwtDecode($value, ...$masks): array](./tests/HelperJwtTrait/HelperJwtDecodeTest.php) [](#jwtdecodevalue-masks-array) Возвращает массив с данными из декодированного jwt токена ``` $array = Helper::jwtDecode('eyJhbGciOiJTSEE1MTIiLCJ0eXAiOiJKV1QifQ.eyJpZCI6MX0.l8fbKNjJWSsZLjVfE5aUOpEhIqbMAxIcon8nZ8NYyPikf_AtjrrN0Y3cPTy1A0U3etLMCbZ6RE00FqFYLZBc7A'); // $array = ['header' => ['alg' => 'SHA512', 'typ' => 'JWT'], 'body' => ['id' => 1]] ``` --- ##### [jwtEncode($value, ...$masks): array](./tests/HelperJwtTrait/HelperJwtEncodeTest.php) [](#jwtencodevalue-masks-array) Возвращает строку с jwt токеном из закодированных данных ``` $string = Helper::jwtEncode(['id' => 1]); // $string = 'eyJhbGciOiJTSEE1MTIiLCJ0eXAiOiJKV1QifQ.eyJpZCI6MX0.l8fbKNjJWSsZLjVfE5aUOpEhIqbMAxIcon8nZ8NYyPikf_AtjrrN0Y3cPTy1A0U3etLMCbZ6RE00FqFYLZBc7A' ``` --- ### Number [](#number) Работа с числами --- ##### [numberCalculate($value, $precision): string](./tests/HelperNumberTrait/HelperNumberCalculateTest.php) [](#numbercalculatevalue-precision-string) Возвращает строку с результатом калькуляции больших числовых значений в строке ``` $string = Helper::numberCalculate('1 + 2'); // $string = '3' ``` --- ##### [numberDecimalDigits($value): int](./tests/HelperNumberTrait/HelperNumberDecimalDigitsTest.php) [](#numberdecimaldigitsvalue-int) Возвращает количество знаков дробной части числа ``` $integer = Helper::numberDecimalDigits(1.123); // $integer = 3 ``` --- ##### [numberFormat($value, $decimals, $separator): string](./tests/HelperNumberTrait/HelperNumberFormatTest.php) [](#numberformatvalue-decimals-separator-string) Возвращает число в виде строки с форматированием ``` $string = Helper::numberFormat(1000.123); // $string = '1 000,123' ``` --- ##### [numberFromString($value): int|float](./tests/HelperNumberTrait/HelperNumberFromStringTest.php) [](#numberfromstringvalue-intfloat) Возвращает число из строки с числом прописью на русском языке ``` $integer = Helper::numberFromString('сто двадцать три'); // $integer = 123 ``` --- ##### [numberToString($value, $declension, $gender, $enumeration): string](./tests/HelperNumberTrait/HelperNumberToStringTest.php) [](#numbertostringvalue-declension-gender-enumeration-string) Возвращает число прописью на русском языке с учетом склонения по падежу, роду и числительному перечислению ``` $string = Helper::numberToString(123.456); // $string = 'сто двадцать три' ``` --- ### Object [](#object) Работа с объектами --- ##### [objectToArrayRecursive($value): ?array](./tests/HelperObjectTrait/HelperObjectToArrayRecursiveTest.php) [](#objecttoarrayrecursivevalue-array) Возвращает преобразованный объект в массив рекурсивно или null ``` $array = Helper::objectToArrayRecursive((object)['a' => 1, 'b' => (object)['c' => 2], 'd' => (object)[3]]); // $array = ['a' => 1, 'b' => ['c' => 2], 'd' => [3]] ``` --- ### Path [](#path) Работа с путями --- ##### [pathClassName($value): string](./tests/HelperPathTrait/HelperPathClassNameTest.php) [](#pathclassnamevalue-string) Возвращает имя класса без namespace ``` $string = Helper::pathClassName('/test/Test.php'); // $string = 'Test' ``` --- ##### [pathRoot($value = null): string](./tests/HelperPathTrait/HelperPathRootTest.php) [](#pathrootvalue--null-string) Возвращает путь домашней папки ``` $string = Helper::pathRoot(); // $string = '/home/path' ``` --- ### Phone [](#phone) Работа с телефонами --- ##### [phoneFormat($value, $countryNumber, $format): string](./tests/HelperPhoneTrait/HelperPhoneFormatTest.php) [](#phoneformatvalue-countrynumber-format-string) Возвращает отформатированный номер телефона ``` $string = Helper::phoneFormat('79001112233'); // $string = '+7 (900) 111-22-33' ``` --- ##### [phoneNumber($value, $countryNumber): string](./tests/HelperPhoneTrait/HelperPhoneNumberTest.php) [](#phonenumbervalue-countrynumber-string) Возвращает только цифры номера телефона ``` $string = Helper::phoneNumber('+7 (900) 111-22-33'); // $string = '79001112233' ``` --- ### Reflection [](#reflection) Работа с валидацией --- ##### [reflectionArgumentAttributes($class, $method, $argument): array](./tests/HelperReflectionTrait/HelperReflectionArgumentAttributesTest.php) [](#reflectionargumentattributesclass-method-argument-array) Возвращает массив аттрибутов у аргументов метода класса ``` class Example {public function methodName(#[ExampleAttribute] $paramName)} $array = Helper::reflectionArgumentAttributes(Example::class, 'methodName', 'paramName'); // $array = [['attribute' => [...], 'arguments' => [...], 'instance' => {...}]] ``` --- ##### [reflectionClassAttributes($class): array](./tests/HelperReflectionTrait/HelperReflectionClassAttributesTest.php) [](#reflectionclassattributesclass-array) Возвращает массив аттрибутов у класса ``` #[ExampleAttribute] class Example {} $array = Helper::reflectionClassAttributes(Example::class); // $array = [['attribute' => [...], 'arguments' => [...], 'instance' => {...}]] ``` --- ##### [reflectionMethodAttributes($class, $method): array](./tests/HelperReflectionTrait/HelperReflectionMethodAttributesTest.php) [](#reflectionmethodattributesclass-method-array) Возвращает массив аттрибутов у методов класса ``` #[ExampleAttribute] class Example {#[ExampleAttribute] public function methodName($param)} $array = Helper::reflectionMethodAttributes(Example::class, 'methodName'); // $array = [['attribute' => [...], 'arguments' => [...], 'instance' => {...}]] ``` --- ##### [reflectionPhpDoc($class): array](./tests/HelperReflectionTrait/HelperReflectionPhpDocTest.php) [](#reflectionphpdocclass-array) Возвращает массив с разложенными параметрами из всех phpdoc блоков класса ``` /** description class*/ class Example { /** @var string */ public string $propertyName /** description method */ public function methodName() {} } $array = Helper::reflectionPhpDoc(Example::class); // $array = [...] ``` --- ##### [reflectionPropertyAttributes($class, $property): array](./tests/HelperReflectionTrait/HelperReflectionPropertyAttributesTest.php) [](#reflectionpropertyattributesclass-property-array) Возвращает массив аттрибутов у свойств класса ``` class Example {#[ExampleAttribute] public string $propertyName} $array = Helper::reflectionPropertyAttributes(Example::class, 'propertyName'); // $array = [['attribute' => [...], 'arguments' => [...], 'instance' => {...}]] ``` --- ### Regexp [](#regexp) Работа с валидацией --- ##### [regexpValidateAscii($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateAsciiTest.php) [](#regexpvalidateasciivalue-bool) Проверяет значение строки на формат ascii (латинский алфавита и цифры) ``` $boolean = Helper::regexpValidateAscii('0-9 AZ az'); // $boolean = true ``` --- ##### [regexpValidateDate($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateDateTest.php) [](#regexpvalidatedatevalue-bool) Проверяет значение строки на формат даты ``` $boolean = Helper::regexpValidateDate('01.01.2025'); // $boolean = true ``` --- ##### [regexpValidateEmail($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateEmailTest.php) [](#regexpvalidateemailvalue-bool) Проверяет значение строки на формат электронной почты ``` $boolean = Helper::regexpValidateEmail('Test.example_1@domain.com'); // $boolean = true ``` --- ##### [regexpValidateIp4($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateIp4Test.php) [](#regexpvalidateip4value-bool) Проверяет значение строки на формат ip адреса v4 ``` $boolean = Helper::regexpValidateIp4('111.222.33.44'); // $boolean = true ``` --- ##### [regexpValidateIp6($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateIp6Test.php) [](#regexpvalidateip6value-bool) Проверяет значение строки на формат ip адреса v6 ``` $boolean = Helper::regexpValidateIp6('2001:0db8:0058:0074:1c60:2c18:1025:2b5f'); // $boolean = true ``` --- ##### [regexpValidateJson($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateJsonTest.php) [](#regexpvalidatejsonvalue-bool) Проверяет значение строки на формат json ``` Helper::regexpValidateJson('{"a":1}'); // $boolean = true ``` --- ##### [regexpValidatePattern($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidatePatternTest.php) [](#regexpvalidatepatternvalue-bool) Проверяет значение строки на формат регулярного выражения ``` $boolean = Helper::regexpValidatePattern('/test/'); // $boolean = true ``` --- ##### [regexpValidatePhone($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidatePhoneTest.php) [](#regexpvalidatephonevalue-bool) Проверяет значение строки на формат номера телефона ``` $boolean = Helper::regexpValidatePhone('+79001234567'); // $boolean = true ``` --- ##### [regexpValidateUnicode($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateUnicodeTest.php) [](#regexpvalidateunicodevalue-bool) Проверяет значение строки на формат юникода ``` $boolean = Helper::regexpValidateUnicode('01 AZ az АЯ ая 😀'); // $boolean = true ``` --- ##### [regexpValidateUrl($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateUrlTest.php) [](#regexpvalidateurlvalue-bool) Проверяет значение строки на формат url ``` $boolean = Helper::regexpValidateUrl('http://abc.com/def?klm#xyz'); // $boolean = true ``` --- ##### [regexpValidateUuid($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateUuidTest.php) [](#regexpvalidateuuidvalue-bool) Проверяет значение строки на формат идентификатора uuid v4/v7 ``` $boolean = Helper::regexpValidateUuid('04d19f50-2fab-417a-815d-306b6a6f67ec'); // $boolean = true ``` --- ##### [regexpValidateUuid4($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateUuid4Test.php) [](#regexpvalidateuuid4value-bool) Проверяет значение строки на формат идентификатора uuid v4 ``` $boolean = Helper::regexpValidateUuid4('04d19f50-2fab-417a-815d-306b6a6f67ec'); // $boolean = true ``` --- ##### [regexpValidateUuid7($value): bool](./tests/HelperRegexpTrait/HelperRegexpValidateUuid7Test.php) [](#regexpvalidateuuid7value-bool) Проверяет значение строки на формат идентификатора uuid v7 ``` $boolean = Helper::regexpValidateUuid7('019668a4-02a1-7f64-9d90-52760464b9ce'); // $boolean = true ``` --- ### Size [](#size) Работа с размерами --- ##### [sizeBytesToString($value): string](./tests/HelperSizeTrait/HelperSizeBytesToStringTest.php) [](#sizebytestostringvalue-string) Возвращает размер в байтах как строку ``` $string = Helper::sizeBytesToString(1000); // $string = '1 Кб' ``` --- ##### [sizeStringToBytes($value): string](./tests/HelperSizeTrait/HelperSizeStringToBytesTest.php) [](#sizestringtobytesvalue-string) Возвращает размер в байтах из строки размера ``` $integer = Helper::sizeStringToBytes('1 Килобайт'); // $integer = 1000 ``` --- ### Sql [](#sql) Работа с sql запросами --- ##### [sqlBindings($value, $bindings): string](./tests/HelperSqlTrait/HelperSqlBindingsTest.php) [](#sqlbindingsvalue-bindings-string) Подставляет значения из массива $bindings вместо плейсхолдеров ? в запросе ``` $string = Helper::sqlBindings('SELECT * FROM t WHERE a = ?', [1]); // $string = 'SELECT * FROM t WHERE a = 1' ``` --- ##### [sqlExtractNames($value, $sort): array](./tests/HelperSqlTrait/HelperSqlExtractNamesTest.php) [](#sqlextractnamesvalue-sort-array) Возвращает массив разобранного запроса на используемые названия баз данных, таблиц, полей ``` $array = Helper::sqlExtractNames('SELECT name FROM users', [1]); // $array = ['databases' => ['' => ['tables' => ['users' => ['fields' => ['name']]]]]] ``` --- ##### [sqlFields($value, $sort): array](./tests/HelperSqlTrait/HelperSqlFieldsTest.php) [](#sqlfieldsvalue-sort-array) Возвращает массив используемых названий полей в запросе ``` $array = Helper::sqlFields('SELECT * FROM users WHERE id = 1 AND active = 0'); // $array = ['users.*', 'users.active', 'users.id'] ``` --- ##### [sqlFieldsInsert($value): array](./tests/HelperSqlTrait/HelperSqlFieldsInsertTest.php) [](#sqlfieldsinsertvalue-array) Возвращает массив затрагиваемых полей при операции INSERT ``` $array = Helper::sqlFieldsInsert('insert into tests (name, id) values (?, ?)'); // $array = ['name', 'id'] ``` --- ##### [sqlFieldsUpdate($value): array](./tests/HelperSqlTrait/HelperSqlFieldsUpdateTest.php) [](#sqlfieldsupdatevalue-array) Возвращает массив затрагиваемых полей при операции UPDATE ``` $array = Helper::sqlFieldsInsert('update `tests` set `name`= ?, id= ?'); // $array = ['name', 'id'] ``` --- ##### [sqlHasWrite($value): bool](./tests/HelperSqlTrait/HelperSqlHasWriteTest.php) [](#sqlhaswritevalue-bool) Проверяет запрос на наличие операторов изменения INSERT, UPDATE, DELETE, TRUNCATE ``` $boolean = Helper::sqlHasWrite('SELECT * FROM users'); // $boolean = false ``` --- ##### [sqlSafeValue($value): mixed](./tests/HelperSqlTrait/HelperSqlSafeValueTest.php) [](#sqlsafevaluevalue-mixed) Удаляет опасные конструкции из значения перед использованием в sql запросе ``` $string = Helper::sqlSafeValue('John; DROP TABLE users;'); // $string = 'John' ``` --- ##### [sqlTables($value): array](./tests/HelperSqlTrait/HelperSqlTablesTest.php) [](#sqltablesvalue-array) Возвращает массив используемых таблиц в запросе ``` $array = Helper::sqlTables('SELECT * FROM users;'); // $array = ['users'] ``` --- ### String [](#string) Работа со строками --- ##### [stringBreakByLength($value, $breakType, $partLengthMax, $firstPartLength): array](./tests/HelperStringTrait/HelperStringBreakByLengthTest.php) [](#stringbreakbylengthvalue-breaktype-partlengthmax-firstpartlength-array) Разбивает текст на части указанной длины по словам или строкам и возвращает массив строк ``` $array = Helper::stringBreakByLength('Иванов Иван Иванович', HelperStringBreakTypeEnum::Word, 10); // $array = ['Иванов', 'Иван', 'Иванович'] ``` --- ##### [stringChange(&$value, $change, $start): string](./tests/HelperStringTrait/HelperStringChangeTest.php) [](#stringchangevalue-change-start-string) Заменяет на подстроку в строке с позиции start ``` $string = Helper::stringChange('abc', 'd', 2); // $string = 'abd' $string = Helper::stringChange('abcefg', 'xyz', -1); // $string = 'abcefxyz' ``` --- ##### [stringConcat($delimiter, ...$values): string](./tests/HelperStringTrait/HelperStringConcatTest.php) [](#stringconcatdelimiter-values-string) Соединяет значения values через разделитель delimiter ``` $string = Helper::stringConcat(' ', 'Иванов', 'Иван', 'Иванович'); // $string = 'Иванов Иван Иванович' $string = Helper::stringConcat(' ', ['Иванов', 'Иван', 'Иванович']); // $string = 'Иванов Иван Иванович' ``` --- ##### [stringCopy($value, $start, $length): string](./tests/HelperStringTrait/HelperStringCopyTest.php) [](#stringcopyvalue-start-length-string) Копирует подстроку из строки с позиции start длиной length ``` $string = Helper::stringCopy('abc', 1, 1); // $string = 'b' $string = Helper::stringCopy('abc', -2); // $string = 'bc' ``` --- ##### [stringCount($value, ...$searches): string](./tests/HelperStringTrait/HelperStringCountTest.php) [](#stringcountvalue-searches-string) Возвращает количество найденных вхождений подстрок в строке ``` $integer = Helper::stringCount('abc', 'a'); // $integer = 1 $integer = Helper::stringCount('abc', ['a', 'b']); // $integer = 2 ``` --- ##### [stringCut(&$value, $start, $length): string](./tests/HelperStringTrait/HelperStringCutTest.php) [](#stringcutvalue-start-length-string) Вырезает подстроку из строки с позиции start длиной length ``` $source = 'abc'; $string = Helper::stringCut($source, 1, 1); // $source = 'ac', $string = 'b' ``` --- ##### [stringDelete($value, $start, $length): string](./tests/HelperStringTrait/HelperStringDeleteTest.php) [](#stringdeletevalue-start-length-string) Удаляет из строки с позиции start длиной length ``` $string = Helper::stringDelete('abc', 1, 1); // $string = 'ac' $string = Helper::stringDelete('abc', -2); // $string = 'a' ``` --- ##### [stringDeleteMultiples($value, ...$multiples): string](./tests/HelperStringTrait/HelperStringDeleteMultiplesTest.php) [](#stringdeletemultiplesvalue-multiples-string) Возвращает строку значения удаляя последовательные повторы подстрок ``` $string = Helper::stringDeleteMultiples('abcabc', 'abc'); // $string = 'abc' $string = Helper::stringDeleteMultiples('a--bb', ['-', 'b']); // $string = 'a-b' ``` --- ##### [stringEnds($value, ...$searches): string](./tests/HelperStringTrait/HelperStringEndsTest.php) [](#stringendsvalue-searches-string) Проверяет конец строки на совпадение подстрок и возвращает найденную подстроку или null ``` $string = Helper::stringEnds('abc', 'c'); // $string = 'c' ``` --- ##### [stringLength($value): int](./tests/HelperStringTrait/HelperStringLengthTest.php) [](#stringlengthvalue-int) Возвращает длину строки ``` $integer = Helper::stringLength('123'); // $integer = 3 ``` --- ##### [stringLower($value): string](./tests/HelperStringTrait/HelperStringLowerTest.php) [](#stringlowervalue-string) Переводит строку в нижний регистр ``` $string = Helper::stringLower('ABC'); // $string = 'abc' ``` --- ##### [stringLowerFirst($value): string](./tests/HelperStringTrait/HelperStringLowerFirstTest.php) [](#stringlowerfirstvalue-string) Возвращает строку с первый символом в нижнем регистре ``` $string = Helper::stringLowerFirst('Abc'); // $string = 'abc' ``` --- ##### [stringLowerFirstAll($value): string](./tests/HelperStringTrait/HelperStringLowerFirstAllTest.php) [](#stringlowerfirstallvalue-string) Возвращает строку со всеми словами в нижнем регистре ``` $string = Helper::stringLowerFirstAll('Abc def Ghi-Jkl_Mno'); // $string = 'abc def ghi-jkl_mno' ``` --- ##### [stringMerge(...$values): string](./tests/HelperStringTrait/HelperStringMergeTest.php) [](#stringmergevalues-string) Объединяет значения в одну строку с заменой предыдущих символов ``` $string = Helper::stringMerge('abc', 'de'); // $string = 'dec' ``` --- ##### [stringPadPrefix($value, $prefix, $condition): string](./tests/HelperStringTrait/HelperstringPadPrefixTest.php) [](#stringpadprefixvalue-prefix-condition-string) Добавляет в начало строки префикс при выполнении условия condition ``` $string = Helper::stringPadPrefix('def', 'abc', true); // $string = 'abcdef' ``` --- ##### [stringPadSuffix($value, $suffix, $condition): string](./tests/HelperStringTrait/HelperstringPadSuffixTest.php) [](#stringpadsuffixvalue-suffix-condition-string) Добавляет в конец строки суффикс при выполнении условия condition ``` $string = Helper::stringPadSuffix('abc', 'def', true); // $string = 'abcdef' ``` --- ##### [stringPaste(&$value, $paste, $start): string](./tests/HelperStringTrait/HelperStringPasteTest.php) [](#stringpastevalue-paste-start-string) Вставляет подстроку в строку с позиции start ``` $string = Helper::stringPaste('abc', 'd', 2); // $string = 'abdc' ``` --- ##### [stringPlural($value, $plurals, $includeValue): string](./tests/HelperStringTrait/HelperStringPluralTest.php) [](#stringpluralvalue-plurals-includevalue-string) Возвращает число с числительным названием из массива с тремя вариантами для \[0|5..9, 1, 2..4\] ``` $string = Helper::stringPlural(1, ['штук', 'штука', 'штуки']); // $string = '1 штука' ``` --- ##### [stringPosAll($value, ...$searches): array](./tests/HelperStringTrait/HelperStringPosAllTest.php) [](#stringposallvalue-searches-array) Возвращает массив всех позиций искомых подстрок найденных в строке ``` $array = Helper::stringPosAll('abcd', 'bc', 'd'); // $array = ['bc' => [1], 'd' => [3]] ``` --- ##### [stringPosAny($value, ...$searches): array](./tests/HelperStringTrait/HelperStringPosAnyTest.php) [](#stringposanyvalue-searches-array) Возвращает массив позиции первой искомой подстроки найденной в строке ``` $array = Helper::stringPosAny('abcd', ['f', 'b', 'c']); // $array = ['b' => 1] ``` --- ##### [stringRandom($pattern): string](./tests/HelperStringTrait/HelperStringRandomTest.php) [](#stringrandompattern-string) Возвращает случайную строку по шаблону регулярного выражения ``` $string = Helper::stringRandom('/[a-z]{10}/'); // $string = 'sfosdjocsh' ``` --- ##### [stringRepeat($value, $count): string](./tests/HelperStringTrait/HelperStringRepeatTest.php) [](#stringrepeatvalue-count-string) Возвращает повторяющуюся строку значения указанное количество раз ``` $string = Helper::stringRepeat('a', 3); // $string = 'aaa' $string = Helper::stringRepeat(1, 3); // $string = '111' ``` --- ##### [stringReplace($value, $searches, $replaces): string](./tests/HelperStringTrait/HelperStringReplaceTest.php) [](#stringreplacevalue-searches-replaces-string) Заменяет подстроки в строке ``` $string = Helper::stringReplace('abcd', 'd', 'x'); // $string = 'abcx' $string = Helper::stringReplace('abcd', ['d' => 'x']); // $string = 'abcx' ``` --- ##### [stringReverse($value): string](./tests/HelperStringTrait/HelperStringReverseTest.php) [](#stringreversevalue-string) Возвращает реверсивную строку значения ``` $string = Helper::stringReverse('abc'); // $string = 'cba' $string = Helper::stringReverse(123); // $string = '321' ``` --- ##### [stringSearchAll($value, ...$searches): array](./tests/HelperStringTrait/HelperStringSearchAllTest.php) [](#stringsearchallvalue-searches-array) Возвращает массив всех искомых подстрок найденных в строке ``` $array = Helper::stringSearchAll('abcd', 'bc', 'd'); // $array = ['bc', 'd'] $array = Helper::stringSearchAll('Иванов Иван Иванович', ['*Иван*']); // $array = ['*Иван*'] ``` --- ##### [stringSearchAny($value, ...$searches): array](./tests/HelperStringTrait/HelperStringSearchAnyTest.php) [](#stringsearchanyvalue-searches-array) Возвращает массив первой искомой подстроки найденной в строке ``` $string = Helper::stringSearchAny('abcd', 'bc'); // $string = ['bc'] $string = Helper::stringSearchAny('abcd', ['ab', 'bc']); // $string = ['ab'] $string = Helper::stringSearchAny('Иванов Иван Иванович', '*Иван*'); // $string = ['*Иван*'] ``` --- ##### [stringSegment($value): string](./tests/HelperStringTrait/HelperStringSegmentTest.php) [](#stringsegmentvalue-string) Возвращает строку с разбиением слитных слов и цифр ``` $string = Helper::stringSegment('abc2defXyz'); // $string = 'abc 2 def Xyz' ``` --- ##### [stringSplit($value, $delimiters, $index, $cacheEnabled): array](./tests/HelperStringTrait/HelperStringSplitTest.php) [](#stringsplitvalue-delimiters-index-cacheenabled-array) Возвращает массив подстрок разбитых на части между разделителем в строке ``` $array = Helper::stringSplit('abc,,def/xyz', [',', '/']); // $array = ['abc', '', 'def', 'xyz'] ``` --- ##### [stringSplitRange($value, $delimiters, $indexFrom, $indexTo, $cacheEnabled): array](./tests/HelperStringTrait/HelperStringSplitRangeTest.php) [](#stringsplitrangevalue-delimiters-indexfrom-indexto-cacheenabled-array) Возвращает массив подстрок разбитых на части между разделителем в строке ``` $string = Helper::stringSplitRange('abc,def,xyz', ',', 1, 1); // $string = 'def' ``` --- ##### [stringSplitSearch($value, $delimiters, ...$searches): array](./tests/HelperStringTrait/HelperStringSplitRangeTest.php) [](#stringsplitsearchvalue-delimiters-searches-array) Возвращает массив индексов частей между $delimiters, в которых найдены строки $searches ``` $array = Helper::stringSplitSearch('abc,def', ',', 'a'); // $array = ['a' => [0]] ``` --- ##### [stringStarts($value, ...$searches): string](./tests/HelperStringTrait/HelperStringStartsTest.php) [](#stringstartsvalue-searches-string) Проверяет начало строки на совпадение подстрок и возвращает найденную подстроку ``` $string = Helper::stringStarts('abc', 'a'); // $string = 'a' ``` --- ##### [stringTruncateBetweenQuotes($value, ...$size$): string](./tests/HelperStringTrait/HelperStringTruncateBetweenQuotesTest.php) [](#stringtruncatebetweenquotesvalue-size-string) Возвращает строку с усечением данных между кавычками ``` $string = Helper::stringTruncateBetweenQuotes('{"a":"abcdef"}', 5); // $string = '{"a":"abcd…"}' ``` --- ##### [stringUpper($value): string](./tests/HelperStringTrait/HelperStringUpperTest.php) [](#stringuppervalue-string) Переводит строку в верхний регистр ``` $string = Helper::stringUpper('abc'); // $string = 'ABC' ``` --- ##### [stringUpperFirst($value): string](./tests/HelperStringTrait/HelperStringUpperFirstTest.php) [](#stringupperfirstvalue-string) Возвращает строку с первый символом в верхнем регистре ``` $string = Helper::stringUpperFirst('abc'); // $string = 'Abc' ``` --- ##### [stringUpperFirstAll($value): string](./tests/HelperStringTrait/HelperStringUpperFirstAllTest.php) [](#stringupperfirstallvalue-string) Возвращает строку со всеми словами в верхнем регистре ``` $string = Helper::stringUpperFirstAll('abc Def ghi-jkl_mno'); // $string = 'Abc Def Ghi-Jkl_Mno' ``` --- ### Telegram [](#telegram) Работа с сообщениями телеграм --- ##### [telegramBreakMessage($value, $hasAttach): array](./tests/HelperTelegramTrait/HelperTelegramBreakMessageTest.php) [](#telegrambreakmessagevalue-hasattach-array) Разбивает текст сообщения на части для отправки в телеграм ``` $array = Helper::telegramBreakMessage('Иванов Иван Иванович', false); // $array = ['Иванов Иван Иванович'] ``` --- ### Time [](#time) Работа со временем --- ##### [timeBetweenDatesToArray($dateFrom, $dateTo): array](./tests/HelperTimeTrait/HelperTimeBetweenDatesToArrayTest.php) [](#timebetweendatestoarraydatefrom-dateto-array) Возвращает массив периодов между датами ``` $array = Helper::timeBetweenDatesToArray('01.01.2025 00:00:00', '02.02.2026 01:02:03'); // $array = ['years' => 1, 'months' => 1, 'days' => 1, 'hours' => 1, 'minutes' => 2, 'seconds' => 3] ``` --- ##### [timeBetweenDatesToString($dateFrom, $dateTo, $withTime, $time24): array](./tests/HelperTimeTrait/HelperTimeBetweenDatesToStringTest.php) [](#timebetweendatestostringdatefrom-dateto-withtime-time24-array) Возвращает массив периодов между датами ``` $string = Helper::timeBetweenDatesToString('01.01.2025 00:00:00', '02.02.2026 01:02:03', true); // $string = '1 год 1 месяц 1 день 1 час 2 минуты 3 секунды' ``` --- ##### [timeFromSeconds($value): string](./tests/HelperTimeTrait/HelperTimeFromSecondsTest.php) [](#timefromsecondsvalue-string) Возвращает строку вида ##:##:## из переданного количества секунд ``` $string = Helper::timeFromSeconds(3661); // $string = '01:01:01' ``` --- ##### [timeSecondsToArray($value): array](./tests/HelperTimeTrait/HelperTimeSecondsToArrayTest.php) [](#timesecondstoarrayvalue-array) Возвращает массив периодов из количества секунд ``` $array = Helper::timeSecondsToArray(1); // $array = ['years' => 0, 'days' => 0, 'hours' => 0, 'minutes' => 0, 'seconds' => 1, 'milliseconds' => 0] ``` --- ##### [timeSecondsToString($value, $withZero, $withMilliseconds, $pluralNames): array](./tests/HelperTimeTrait/HelperTimeSecondsToStringTest.php) [](#timesecondstostringvalue-withzero-withmilliseconds-pluralnames-array) Возвращает период из количества секунд в виде строки YDHM ``` $string = Helper::timeSecondsToString(123); // $string = '2 минуты 3 секунды' ``` --- ### Transform [](#transform) Работа с трансформацией --- ##### [transformToArray($value): array](./tests/HelperTransformTrait/HelperTransformToArrayTest.php) [](#transformtoarrayvalue-array) Возвращает массив из значения ``` $array = Helper::transformToArray(['a', 'b']); // $array = ['a', 'b'] $array = Helper::transformToArray('a'); // $array = ['a'] ``` --- ### Translit [](#translit) Работа с транслитерацией --- ##### [translitFromSlug($value, $slugSeparator = '\_'): string](./tests/HelperTranslitTrait/HelperTransformToArrayTest.php) [](#translitfromslugvalue-slugseparator--_-string) Возвращает строку из slug ``` $string = Helper::translitFromSlug('abv_gde_123'); // $string = 'абв где 123' ``` --- ##### [translitString($value, $direction): string](./tests/HelperTranslitTrait/HelperTranslitStringTest.php) [](#translitstringvalue-direction-string) Возвращает транслитерацию строки ``` $string = Helper::translitString('абвгд'); // $string = 'abvgd' ``` --- ##### [translitToSlug($value, $slugSeparator = '\_'): string](./tests/HelperTranslitTrait/HelperTranslitToSlugTest.php) [](#translittoslugvalue-slugseparator--_-string) Возвращает транслитерацию строки ``` $string = Helper::translitToSlug('абв Где!.123'); // $string = 'abv_gde_123' ``` --- ### Url [](#url) Работа с url адресом --- ##### [try($callable): HelperTry](./tests/HelperTryTrait/HelperTryTest.php) [](#trycallable-helpertry) Возвращает объект для работы с цепочкой try catch finally ``` $result = Helper::try(static fn () => 1)->catch()->success()->finally(); // $result = 1 ``` --- ### Url [](#url-1) Работа с url адресом --- ##### [urlCreate($scheme, $host, $path, $query): array](./tests/HelperUrlTrait/HelperUrlCreateTest.php) [](#urlcreatescheme-host-path-query-array) Возвращает строку адреса url ``` $string = Helper::urlCreate(scheme: 'https', host: 'a.com', path: 'b', query: ['c' => 1]); // $string = 'https://a.com/b?c=1' ``` --- ##### [urlDomainDecode($value): string](./tests/HelperUrlTrait/HelperUrlDomainDecodeTest.php) [](#urldomaindecodevalue-string) Возвращает декодированный русский домен вида xn-- ``` $string = Helper::urlDomainDecode('xn--e1afmkfd.xn--p1ai'); // $string = 'пример.рф' ``` --- ##### [urlDomainEncode($value): string](./tests/HelperUrlTrait/HelperUrlDomainEncodeTest.php) [](#urldomainencodevalue-string) Возвращает кодированный русский домен в виде xn-- ``` $string = Helper::urlDomainEncode('пример.рф'); // $string = 'xn--e1afmkfd.xn--p1ai' ``` --- ##### [urlParse($value): array](./tests/HelperUrlTrait/HelperUrlParseTest.php) [](#urlparsevalue-array) Возвращает массив частей адреса url ``` $array = Helper::urlParse('http://a.com/d/?e=f'); // $array = ['scheme' => 'http', 'host' => 'a.com', 'path' => '/d', 'query' => ['e' => 'f']] ``` --- ### Var [](#var) Работа с переменными --- ##### [numberSwap($value1, $value2): void](./tests/HelperNumberTrait/HelperNumberSwapTest.php) [](#numberswapvalue1-value2-void) Меняет местами значения value1 и value2 ``` $integer1 = 1; $integer2 = 2; Helper::numberSwap($integer1, $integer2); // $integer1 = 2, $integer2 = 1 ``` --- ### Health Score 41 — FairBetter than 87% of packages Maintenance64 Regular maintenance activity Popularity19 Limited adoption so far Community11 Small or concentrated contributor base Maturity60 Established project with proven stability Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~4 days Total 54 Last Release 219d ago PHP version history (2 changes)v1.00PHP ^8.0 v1.01PHP ^8.1 ### Community Maintainers ![](https://www.gravatar.com/avatar/5e3fe1bcb1aa65d23ffb4ea65ee05450a9d952367bcd4c7157b9b7b3da07befe?d=identicon)[atlcomgit](/maintainers/atlcomgit) --- Top Contributors [![atlcomgit](https://avatars.githubusercontent.com/u/35184369?v=4)](https://github.com/atlcomgit "atlcomgit (103 commits)") ### Code Quality TestsPHPUnit ### Embed Badge ![Health badge](/badges/atlcom-helper/health.svg) ``` [![Health](https://phpackages.com/badges/atlcom-helper/health.svg)](https://phpackages.com/packages/atlcom-helper) ``` ### Alternatives [illuminate/support The Illuminate Support package. 630113.0M41.3k](/packages/illuminate-support)[spatie/holidays Calculate public holidays 402860.1k2](/packages/spatie-holidays)[craftcms/feed-me Import content from XML, RSS, CSV or JSON feeds into entries, categories, Craft Commerce products, and more. 293952.6k33](/packages/craftcms-feed-me)[solspace/craft-freeform The most flexible and user-friendly form building plugin! 54681.3k19](/packages/solspace-craft-freeform)[pimcore/data-importer Adds a comprehensive import functionality to Pimcore Datahub 46855.5k5](/packages/pimcore-data-importer)[flarum/core Delightfully simple forum software. 201.4M2.3k](/packages/flarum-core) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)