Fix PHP Fatal Error Call to Undefined Function

What's Actually Happening

Your PHP script crashes with a fatal error indicating that you're calling a function that PHP doesn't recognize. This occurs when the function doesn't exist in the current scope, when required PHP extensions aren't installed or enabled, when the function name is misspelled or uses incorrect casing, when the function is in a namespace but called without proper qualification, when the file containing the function hasn't been included, or when conditional function declarations weren't triggered.

The error immediately terminates your script execution. This commonly happens with extension-provided functions like mysqli_connect, gd image functions, or curl functions, with functions from libraries that haven't been loaded, or with user-defined functions that haven't been properly included or namespaced.

The Error You'll See

``` Fatal error: Uncaught Error: Call to undefined function mysql_connect() in /var/www/html/db.php:23

Fatal error: Call to undefined function imagecreatefromjpeg() in /var/www/app/services/ImageProcessor.php:156

Fatal error: Uncaught Error: Call to undefined function App\Http\json_encode() in /var/www/api/Response.php:45

Fatal error: Call to undefined function formatPrice() in /var/www/templates/product.php:78

PHP Fatal error: Uncaught Error: Call to undefined function curl_init() in /var/www/lib/HttpClient.php:12

Fatal error: Call to undefined function mb_strlen() in /var/www/validators/StringValidator.php:34

Error: Call to undefined function App\Utils\str_replace()

Fatal error: Uncaught Error: Call to undefined function gd_info() in /var/www/image.php:5

[08-Apr-2026 17:15:45 UTC] PHP Fatal error: Call to undefined function openssl_encrypt() in /var/www/security/Encryption.php:89 Stack trace: #0 /var/www/app.php(45): encrypt() #1 {main} thrown ```

Why This Happens

1. 1.Missing PHP extension: The function is provided by an extension that isn't installed or enabled in your PHP configuration. Common culprits include mysqli, pdo_mysql, gd, curl, mbstring, openssl, xml, zip, and intl.
2. 2.Deprecated removed functions: Functions removed in newer PHP versions (mysql_* functions removed in PHP 7.0, each() removed in PHP 8.0, create_function removed in PHP 8.0).
3. 3.Typo in function name: Misspelling the function name, wrong casing (PHP function names are case-insensitive but good practice is to use correct casing), or missing underscores.
4. 4.Namespace qualification issue: The function is a global PHP function but called from within a namespace without the backslash prefix, causing PHP to look for it in the current namespace.
5. 5.File not included: User-defined function is in a file that hasn't been included or required, or was included conditionally and the condition wasn't met.
6. 6.Conditional declaration not triggered: The function was declared inside a condition that wasn't satisfied, so it doesn't exist when called.
7. 7.Function in different namespace: You're trying to call a function from another namespace without importing it or using the full qualified name.
8. 8.Library not loaded: Third-party library functions (like Carbon, Guzzle helpers) not available because the library wasn't installed or autoloaded.
9. 9.PHP version mismatch: Code written for newer PHP version running on older PHP, or using features/functions not available in current version.
10. 10.Build configuration: PHP was compiled without certain extensions (--disable-all or minimal build), so functions aren't available.

Step 1: Identify Missing Functions and Extensions

Diagnose which function is missing and why:

```bash # Check if specific extension is loaded php -m | grep -i mysqli php -m | grep -i gd php -m | grep -i curl php -m | grep -i mbstring

# List all loaded extensions php -m

# Check PHP configuration php -i | grep -i "configure command" php -i | grep -i "additional .ini files"

# Check specific function availability php -r "var_dump(function_exists('curl_init'));" php -r "var_dump(function_exists('imagecreate'));" php -r "var_dump(function_exists('mb_strlen'));"

# Check for disabled functions php -i | grep "disable_functions"

# Find which extension provides a function php -r " \$functions = [ 'curl_init' => 'curl', 'imagecreate' => 'gd', 'mysqli_connect' => 'mysqli', 'mb_strlen' => 'mbstring', 'openssl_encrypt' => 'openssl', 'zip_open' => 'zip', 'xml_parse' => 'xml', ]; foreach (\$functions as \$func => \$ext) { echo \$func . ': ' . (function_exists(\$func) ? 'available (' . \$ext . ')' : 'MISSING') . '\n'; } "

# Check PHP version for deprecated functions php -v

# See which functions were removed in your PHP version php -r "echo 'PHP Version: ' . PHP_VERSION . '\n';" ```

Check what's available in your PHP installation:

```php <?php // check_extensions.php - Comprehensive extension check

$required = [ 'mysqli' => ['mysqli_connect', 'mysqli_query', 'mysqli_fetch_assoc'], 'pdo_mysql' => ['PDO', 'PDO::MYSQL_ATTR_INIT_COMMAND'], 'gd' => ['imagecreate', 'imagecreatetruecolor', 'imagejpeg'], 'curl' => ['curl_init', 'curl_exec', 'curl_close'], 'mbstring' => ['mb_strlen', 'mb_strpos', 'mb_substr'], 'openssl' => ['openssl_encrypt', 'openssl_decrypt', 'openssl_random_pseudo_bytes'], 'json' => ['json_encode', 'json_decode'], 'zip' => ['zip_open', 'zip_read'], 'xml' => ['xml_parse', 'xml_parser_create'], 'intl' => ['IntlDateFormatter', 'NumberFormatter'], 'redis' => ['Redis'], 'memcached' => ['Memcached'], ];

$results = [];

foreach ($required as $ext => $functions) { $loaded = extension_loaded($ext); $available = [];

foreach ($functions as $func) { $exists = function_exists($func) || class_exists($func); $available[$func] = $exists; }

$results[$ext] = [ 'loaded' => $loaded, 'functions' => $available ]; }

// Output results echo "Extension Status:\n"; echo str_repeat('-', 60) . "\n";

foreach ($results as $ext => $data) { $status = $data['loaded'] ? 'LOADED' : 'NOT LOADED'; echo "$ext: $status\n";

foreach ($data['functions'] as $func => $exists) { $mark = $exists ? '✓' : '✗'; echo " $mark $func\n"; } }

// Check disabled functions $disabled = ini_get('disable_functions'); if ($disabled) { echo "\nDisabled functions:\n"; echo $disabled . "\n"; }

// Check PHP version echo "\nPHP Version: " . PHP_VERSION . "\n"; echo "SAPI: " . php_sapi_name() . "\n";

// Common deprecated/removed functions $deprecated = [ 'mysql_connect' => 'Removed in PHP 7.0, use mysqli_connect or PDO', 'mysql_query' => 'Removed in PHP 7.0, use mysqli_query or PDO', 'each' => 'Removed in PHP 8.0, use foreach instead', 'create_function' => 'Removed in PHP 8.0, use anonymous functions', 'mcrypt_encrypt' => 'Removed in PHP 7.2, use openssl_encrypt', ];

echo "\nDeprecated/Removed functions check:\n"; foreach ($deprecated as $func => $note) { $exists = function_exists($func); echo ($exists ? 'EXISTS' : 'NOT EXISTS') . " $func - $note\n"; } ?> ```

Step 2: Install Missing PHP Extensions

Install the required extensions:

```bash # Ubuntu/Debian sudo apt-get update sudo apt-get install php8.2-mysql # mysqli, pdo_mysql sudo apt-get install php8.2-gd # image functions sudo apt-get install php8.2-curl # curl functions sudo apt-get install php8.2-mbstring # multibyte string functions sudo apt-get install php8.2-xml # xml functions sudo apt-get install php8.2-zip # zip functions sudo apt-get install php8.2-intl # internationalization sudo apt-get install php8.2-opcache # opcache sudo apt-get install php8.2-redis # redis sudo apt-get install php8.2-memcached # memcached

# Install multiple at once sudo apt-get install php8.2-{mysql,gd,curl,mbstring,xml,zip,intl,opcache}

# CentOS/RHEL sudo yum install php-mysqlnd sudo yum install php-gd sudo yum install php-curl sudo yum install php-mbstring sudo yum install php-xml sudo yum install php-zip sudo yum install php-intl

# Or using dnf (newer) sudo dnf install php-{mysqlnd,gd,curl,mbstring,xml,zip,intl}

# Enable extension (if installed but not enabled) sudo phpenmod mysqli sudo phpenmod gd sudo phpenmod curl

# Restart PHP-FPM sudo systemctl restart php8.2-fpm

# Restart Apache (if using mod_php) sudo systemctl restart apache2

# Verify installation php -m | grep mysqli php -r "echo 'mysqli loaded: ' . (extension_loaded('mysqli') ? 'yes' : 'no') . '\n';" ```

For Windows, edit php.ini:

```ini ; Uncomment the extension lines in php.ini extension=mysqli extension=gd extension=curl extension=mbstring extension=openssl extension=xml extension=zip extension=intl

; For some extensions, specify the path extension_dir = "C:\php\ext\" ```

# After editing php.ini, restart web server
# IIS: iisreset
# Apache: httpd -k restart
# Or restart via services

Check if extension needs additional configuration:

```bash # Some extensions need configuration in php.ini # Check ini files ls -la /etc/php/8.2/mods-available/ ls -la /etc/php/8.2/fpm/conf.d/

# GD extension might need freetype support php -r "var_dump(function_exists('imagefttext'));"

# Check if gd was compiled with freetype php -i | grep -A 5 "gd"

# Reinstall with specific options if needed sudo apt-get install php8.2-gd # Check supported formats php -r "print_r(gd_info());" ```

Step 3: Fix Namespace Function Calls

Correct function calls within namespaces:

```php <?php // PROBLEM: Calling global function from namespace namespace App\Utils;

function processText($text) { // This looks for App\Utils\strlen, not global strlen $length = strlen($text); // Error if no App\Utils\strlen

// This also fails $json = json_encode(['text' => $text]); // Looks for App\Utils\json_encode

return $length; }

// SOLUTION 1: Use backslash prefix for global functions namespace App\Utils;

function processText($text) { $length = \strlen($text); // Explicitly global $json = \json_encode(['text' => $text]); // Explicitly global

return $length; }

// SOLUTION 2: Import functions with use function namespace App\Utils;

use function strlen; use function json_encode; use function array_map;

function processText($text) { $length = strlen($text); // Now resolves correctly $json = json_encode(['text' => $text]);

return $length; }

// SOLUTION 3: Use fully qualified names consistently namespace App\Services;

class TextService { public function countWords($text) { // Use global functions explicitly return \str_word_count(\strip_tags($text)); }

public function formatJson($data) { return \json_encode($data, \JSON_PRETTY_PRINT); } }

// Common functions that need backslash in namespaces // String functions: strlen, substr, strpos, str_replace, trim, strtolower, strtoupper // Array functions: count, array_map, array_filter, array_merge, in_array // JSON functions: json_encode, json_decode // File functions: file_get_contents, file_put_contents, file_exists // URL functions: urlencode, urldecode, parse_url // Date functions: date, time, strtotime

// Safe function caller function safeCall($function, ...$args) { // Ensure we're calling global function if (strpos($function, '\\') !== 0) { $function = '\\' . $function; }

if (!function_exists($function)) { throw new RuntimeException("Function $function does not exist"); }

return $function(...$args); }

// Usage in namespace namespace App\Utils;

$text = safeCall('trim', $input); $length = safeCall('strlen', $text); $json = safeCall('json_encode', ['data' => $text]);

// Define local wrapper functions if used frequently namespace App\Utils;

function global_strlen($string) { return \strlen($string); }

function global_json_encode($data, $flags = 0) { return \json_encode($data, $flags); } ?> ```

Step 4: Fix Function Name Typos and Casing

Correct misspelled or incorrectly cased function names:

```php <?php // Common typos

// WRONG $len = strln($text); // Should be strlen $pos = strpost($text, 'a'); // Should be strpos $replaced = str_repace($text, 'a', 'b'); // Should be str_replace $json = jsn_encode($data); // Should be json_encode $connection = mysqliconnect(); // Should be mysqli_connect

// RIGHT $len = strlen($text); $pos = strpos($text, 'a'); $replaced = str_replace('a', 'b', $text); $json = json_encode($data); $connection = mysqli_connect($host, $user, $pass);

// Case sensitivity (PHP function names are case-insensitive but...) // These all work but are inconsistent: $len = STRLEN($text); $len = StrLen($text); $len = sTrLeN($text);

// Best practice - use lowercase $len = strlen($text);

// Auto-correct common typos with wrapper function safeFunctionCall($func, ...$args) { // Map common typos to correct names $typos = [ 'strln' => 'strlen', 'strpost' => 'strpos', 'str_repace' => 'str_replace', 'jsn_encode' => 'json_encode', 'jsn_decode' => 'json_decode', 'arry_merge' => 'array_merge', 'aray_map' => 'array_map', ];

$func = strtolower($func);

if (isset($typos[$func])) { $correctFunc = $typos[$func]; trigger_error("Typo detected: $func should be $correctFunc", E_USER_WARNING); $func = $correctFunc; }

if (!function_exists($func)) { throw new BadFunctionCallException("Function $func does not exist"); }

return $func(...$args); }

// Script to find typos in codebase function findPotentialTypos($directory) { $builtInFunctions = get_defined_functions()['internal']; $potentialTypos = [];

$iterator = new RecursiveIteratorIterator( new RecursiveDirectoryIterator($directory) );

foreach ($iterator as $file) { if ($file->getExtension() !== 'php') continue;

$content = file_get_contents($file->getPathname());

// Find function calls preg_match_all('/\b([a-z_][a-z0-9_]*)\s*\(/i', $content, $matches);

foreach ($matches[1] as $funcName) { $lowerFunc = strtolower($funcName);

// Check if it exists if (!function_exists($funcName) && !function_exists($lowerFunc)) { // Find similar function names $similar = []; foreach ($builtInFunctions as $builtIn) { similar_text($lowerFunc, $builtIn, $percent); if ($percent > 70) { $similar[$builtIn] = $percent; } }

if (!empty($similar)) { arsort($similar); $potentialTypos[$funcName] = [ 'file' => $file->getPathname(), 'similar' => array_keys($similar) ]; } } } }

return $potentialTypos; }

$typos = findPotentialTypos('src/'); foreach ($typos as $typo => $info) { echo "Potential typo: $typo\n"; echo " Similar to: " . implode(', ', $info['similar']) . "\n"; echo " In: {$info['file']}\n\n"; } ?> ```

Step 5: Include Files with Function Definitions

Ensure function definition files are loaded:

```php <?php // PROBLEM: Function defined in file that's not included // helpers.php function formatDate($timestamp) { return date('Y-m-d H:i:s', $timestamp); }

// app.php echo formatDate(time()); // Error: undefined function formatDate

// SOLUTION 1: Include the file require_once 'helpers.php'; echo formatDate(time());

// SOLUTION 2: Use autoload for functions // composer.json { "autoload": { "files": [ "app/helpers.php", "app/functions.php" ] } }

// Then regenerate autoload // composer dump-autoload

// SOLUTION 3: Load conditionally with check if (!function_exists('formatDate')) { require_once __DIR__ . '/helpers.php'; }

// SOLUTION 4: Class-based helpers namespace App\Helpers;

class DateHelper { public static function format($timestamp) { return date('Y-m-d H:i:s', $timestamp); } }

// Usage use App\Helpers\DateHelper; echo DateHelper::format(time());

// Create a function loader class FunctionLoader { private static $loaded = [];

public static function load($name) { if (isset(self::$loaded[$name])) { return true; }

$map = [ 'formatDate' => 'helpers/date.php', 'formatCurrency' => 'helpers/currency.php', 'sanitize_input' => 'helpers/sanitize.php', ];

if (!isset($map[$name])) { return false; }

$file = __DIR__ . '/' . $map[$name];

if (!file_exists($file)) { throw new RuntimeException("Function file not found: $file"); }

require_once $file; self::$loaded[$name] = true;

return function_exists($name); } }

// Usage if (!function_exists('formatDate')) { FunctionLoader::load('formatDate'); }

echo formatDate(time());

// Check if function exists before defining // helpers.php if (!function_exists('formatDate')) { function formatDate($timestamp) { return date('Y-m-d H:i:s', $timestamp); } } ?> ```

Step 6: Replace Deprecated and Removed Functions

Update code that uses deprecated/removed functions:

```php <?php // mysql_* functions (removed in PHP 7.0)

// OLD $connection = mysql_connect('localhost', 'user', 'pass'); mysql_select_db('database', $connection); $result = mysql_query('SELECT * FROM users', $connection); while ($row = mysql_fetch_assoc($result)) { // ... } mysql_close($connection);

// NEW - Using mysqli $connection = mysqli_connect('localhost', 'user', 'pass', 'database'); $result = mysqli_query($connection, 'SELECT * FROM users'); while ($row = mysqli_fetch_assoc($result)) { // ... } mysqli_close($connection);

// NEW - Using PDO $pdo = new PDO('mysql:host=localhost;dbname=database', 'user', 'pass'); $stmt = $pdo->query('SELECT * FROM users'); while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) { // ... }

// each() function (removed in PHP 8.0)

// OLD $array = ['a' => 1, 'b' => 2, 'c' => 3]; reset($array); while (list($key, $value) = each($array)) { echo "$key => $value\n"; }

// NEW - Using foreach foreach ($array as $key => $value) { echo "$key => $value\n"; }

// create_function (removed in PHP 8.0)

// OLD $callback = create_function('$x', 'return $x * 2;'); $result = array_map($callback, [1, 2, 3]);

// NEW - Using anonymous function $callback = function($x) { return $x * 2; }; $result = array_map($callback, [1, 2, 3]);

// NEW - Using arrow function (PHP 7.4+) $result = array_map(fn($x) => $x * 2, [1, 2, 3]);

// mcrypt_* functions (removed in PHP 7.2)

// OLD $encrypted = mcrypt_encrypt(MCRYPT_RIJNDAEL_128, $key, $data, MCRYPT_MODE_CBC, $iv);

// NEW - Using openssl $encrypted = openssl_encrypt($data, 'AES-128-CBC', $key, OPENSSL_RAW_DATA, $iv);

// ereg/eregi (removed in PHP 7.0)

// OLD if (ereg('[0-9]+', $string, $matches)) { // ... }

// NEW - Using preg_match if (preg_match('/[0-9]+/', $string, $matches)) { // ... }

// split (removed in PHP 7.0)

// OLD $parts = split(',', $string);

// NEW - Using explode $parts = explode(',', $string);

// Or preg_split for regex $parts = preg_split('/,/', $string);

// Compatibility layer for migration class LegacyCompatibility { public static function mysql_connect($host, $user, $pass) { return mysqli_connect($host, $user, $pass); }

public static function mysql_select_db($db, $link = null) { return mysqli_select_db($link, $db); }

public static function mysql_query($query, $link = null) { return mysqli_query($link, $query); }

public static function mysql_fetch_assoc($result) { return mysqli_fetch_assoc($result); }

public static function mysql_close($link) { return mysqli_close($link); } }

// Usage during migration $connection = LegacyCompatibility::mysql_connect('localhost', 'user', 'pass'); ?> ```

Step 7: Handle Conditional Function Declarations

Fix issues with conditionally defined functions:

```php <?php // PROBLEM: Function defined conditionally if ($useAdvancedFormatting) { function formatDate($timestamp) { return date('F j, Y H:i:s', $timestamp); } } else { function formatDate($timestamp) { return date('Y-m-d H:i:s', $timestamp); } }

// Later echo formatDate(time()); // May fail if condition changes

// SOLUTION 1: Use class-based approach interface DateFormatterInterface { public function format($timestamp); }

class AdvancedFormatter implements DateFormatterInterface { public function format($timestamp) { return date('F j, Y H:i:s', $timestamp); } }

class SimpleFormatter implements DateFormatterInterface { public function format($timestamp) { return date('Y-m-d H:i:s', $timestamp); } }

class DateFormatter { private static $formatter;

public static function setFormatter(DateFormatterInterface $formatter) { self::$formatter = $formatter; }

public static function format($timestamp) { return self::$formatter->format($timestamp); } }

// Configure at runtime DateFormatter::setFormatter( $useAdvancedFormatting ? new AdvancedFormatter() : new SimpleFormatter() );

echo DateFormatter::format(time());

// SOLUTION 2: Use closure instead of function $formatDate = $useAdvancedFormatting ? fn($ts) => date('F j, Y H:i:s', $ts) : fn($ts) => date('Y-m-d H:i:s', $ts);

echo $formatDate(time());

// SOLUTION 3: Use static method with configuration class DateHelper { private static $advanced = false;

public static function setAdvanced($advanced) { self::$advanced = $advanced; }

public static function format($timestamp) { if (self::$advanced) { return date('F j, Y H:i:s', $timestamp); } return date('Y-m-d H:i:s', $timestamp); } }

DateHelper::setAdvanced(true); echo DateHelper::format(time());

// PROBLEM: Function defined in autoloader callback spl_autoload_register(function($class) { // Some autoloader if ($class === 'Helper') { function formatDate($ts) { // Defined only when Helper is loaded return date('Y-m-d', $ts); } } });

// SOLUTION: Don't define functions in autoloaders // Define in separate file loaded by composer autoload.files // composer.json: { "autoload": { "files": ["app/helpers.php"] } }

// helpers.php function formatDate($timestamp) { return date('Y-m-d', $timestamp); } ?> ```

Step 8: Debug Function Existence

Create debugging tools:

```php <?php class FunctionDebugger { public static function diagnose($functionName) { $info = [ 'name' => $functionName, 'exists' => function_exists($functionName), 'defined' => null, 'extension' => null, 'file' => null, 'line' => null, ];

if ($info['exists']) { try { $reflection = new ReflectionFunction($functionName); $info['defined'] = true; $info['file'] = $reflection->getFileName(); $info['line'] = $reflection->getStartLine(); $info['extension'] = $reflection->getExtensionName(); } catch (ReflectionException $e) { // Internal function $info['defined'] = 'internal'; } }

// Check if it's a namespace issue if (!$info['exists'] && strpos($functionName, '\\') === false) { // Try global namespace $globalName = '\\' . $functionName; if (function_exists($globalName)) { $info['namespace_issue'] = true; $info['suggestion'] = "Function exists globally. Use \\$functionName or import with 'use function $functionName;'"; } }

// Check for similar function names $similar = self::findSimilar($functionName); if (!empty($similar)) { $info['similar'] = $similar; }

// Check if extension is loaded but function missing $extMap = [ 'mysqli_connect' => 'mysqli', 'curl_init' => 'curl', 'imagecreate' => 'gd', 'mb_strlen' => 'mbstring', 'openssl_encrypt' => 'openssl', 'zip_open' => 'zip', 'xml_parse' => 'xml', ];

if (isset($extMap[$functionName])) { $ext = $extMap[$functionName]; $info['required_extension'] = $ext; $info['extension_loaded'] = extension_loaded($ext); }

return $info; }

private static function findSimilar($name) { $allFunctions = get_defined_functions(); $candidates = array_merge( $allFunctions['internal'], $allFunctions['user'] ?? [] );

$similar = []; $nameLower = strtolower($name);

foreach ($candidates as $func) { similar_text($nameLower, strtolower($func), $percent); if ($percent > 70) { $similar[$func] = round($percent, 1); } }

arsort($similar); return array_slice($similar, 0, 5, true); }

public static function printDiagnosis($functionName) { $info = self::diagnose($functionName);

echo "Function Diagnosis: $functionName\n"; echo str_repeat('-', 50) . "\n";

echo "Exists: " . ($info['exists'] ? 'Yes' : 'No') . "\n";

if ($info['exists']) { if ($info['defined'] === 'internal') { echo "Type: Internal/Extension\n"; if ($info['extension']) { echo "Extension: {$info['extension']}\n"; } } else { echo "Type: User-defined\n"; echo "File: {$info['file']}\n"; echo "Line: {$info['line']}\n"; } } else { if (isset($info['namespace_issue'])) { echo "Issue: Namespace qualification\n"; echo "Suggestion: {$info['suggestion']}\n"; }

if (isset($info['required_extension'])) { echo "Required Extension: {$info['required_extension']}\n"; echo "Extension Loaded: " . ($info['extension_loaded'] ? 'Yes' : 'No') . "\n";

if (!$info['extension_loaded']) { echo "Install: sudo apt-get install php-{$info['required_extension']}\n"; } }

if (isset($info['similar']) && !empty($info['similar'])) { echo "Similar functions:\n"; foreach ($info['similar'] as $func => $similarity) { echo " - $func ({$similarity}% similar)\n"; } } } } }

// Usage FunctionDebugger::printDiagnosis('curl_init'); FunctionDebugger::printDiagnosis('strln'); // Typo FunctionDebugger::printDiagnosis('formatDate');

// In error handler set_error_handler(function($errno, $errstr, $errfile, $errline) { if (strpos($errstr, 'undefined function') !== false) { preg_match("/Call to undefined function ([^\(]+)/", $errstr, $matches); if ($matches) { $funcName = $matches[1]; FunctionDebugger::printDiagnosis($funcName); } }

return false; // Continue with default handler }); ?> ```

Step 9: Handle PHP Version Differences

Deal with functions that vary by PHP version:

```php <?php // Check PHP version before using version-specific functions

// PHP 8.0+ str_contains if (!function_exists('str_contains')) { function str_contains($haystack, $needle) { return strpos($haystack, $needle) !== false; } }

// PHP 8.0+ str_starts_with if (!function_exists('str_starts_with')) { function str_starts_with($haystack, $needle) { return strncmp($haystack, $needle, strlen($needle)) === 0; } }

// PHP 8.0+ str_ends_with if (!function_exists('str_ends_with')) { function str_ends_with($haystack, $needle) { $length = strlen($needle); if ($length === 0) return true; return substr($haystack, -$length) === $needle; } }

// PHP 8.1+ array_is_list if (!function_exists('array_is_list')) { function array_is_list($array) { if (!is_array($array) || $array === []) { return false; } $i = 0; foreach ($array as $k => $v) { if ($k !== $i++) { return false; } } return true; } }

// PHP 8.3+ json_validate if (!function_exists('json_validate')) { function json_validate($json) { json_decode($json); return json_last_error() === JSON_ERROR_NONE; } }

// Compatibility helper class PHPCompatibility { public static function ensureFunction($name, callable $implementation) { if (!function_exists($name)) { // Create function dynamically $code = "function $name() { return call_user_func_array('$name', func_get_args()); }"; eval($code); // Store implementation $GLOBALS['__polyfill_' . $name] = $implementation; } } }

// Version check helper function requiresPHP($version, $message = null) { if (version_compare(PHP_VERSION, $version, '<')) { throw new RuntimeException( $message ?: "This code requires PHP $version or higher. Current: " . PHP_VERSION ); } }

// Usage requiresPHP('8.0', 'This feature requires PHP 8.0+');

// Check version before using if (version_compare(PHP_VERSION, '8.0.0', '>=')) { // Use PHP 8+ features $result = str_contains($text, 'search'); } else { // Fallback $result = strpos($text, 'search') !== false; } ?> ```

Step 10: Implement Graceful Function Handling

Create robust function calling patterns:

```php <?php // Safe function caller function safeFunctionExists($name) { return function_exists($name); }

function callFunctionSafely($name, ...$args) { // Handle namespace issues $globalName = '\\' . ltrim($name, '\\');

if (!function_exists($globalName)) { throw new BadFunctionCallException( "Function $name does not exist. " . self::getFunctionSuggestion($name) ); }

return $globalName(...$args); }

// Optional dependency handling class OptionalExtension { public static function call($function, ...$args) { if (!function_exists($function)) { return null; // or throw exception } return $function(...$args); }

public static function isAvailable($extension) { return extension_loaded($extension); } }

// Usage $hash = OptionalExtension::call('hash', 'sha256', $data); if ($hash === null) { // Extension not available, use alternative $hash = md5($data); // Fallback }

// Feature detection pattern class ImageProcessor { private $gdAvailable;

public function __construct() { $this->gdAvailable = extension_loaded('gd'); }

public function resize($image, $width, $height) { if ($this->gdAvailable) { return $this->resizeWithGd($image, $width, $height); }

// Try Imagick if (extension_loaded('imagick')) { return $this->resizeWithImagick($image, $width, $height); }

throw new RuntimeException('No image processing extension available'); }

private function resizeWithGd($image, $width, $height) { // GD implementation }

private function resizeWithImagick($image, $width, $height) { // Imagick implementation } }

// Application bootstrap check function checkRequiredFunctions($functions) { $missing = [];

foreach ($functions as $func => $description) { if (!function_exists($func)) { $missing[$func] = $description; } }

if (!empty($missing)) { $message = "Missing required functions:\n"; foreach ($missing as $func => $desc) { $message .= " - $func: $desc\n"; } throw new RuntimeException($message); }

return true; }

// Usage in bootstrap checkRequiredFunctions([ 'curl_init' => 'Required for API calls', 'json_encode' => 'Required for JSON handling', 'openssl_encrypt' => 'Required for encryption', 'mb_strlen' => 'Required for multibyte string handling', ]); ?> ```

Checklist

Verify the Fix

1. 1.Test extension functions:
2. 2.```php
3. 3.<?php
4. 4.$tests = [
5. 5.'mysqli_connect' => extension_loaded('mysqli'),
6. 6.'curl_init' => extension_loaded('curl'),
7. 7.'imagecreate' => extension_loaded('gd'),
8. 8.'mb_strlen' => extension_loaded('mbstring'),
9. 9.];

foreach ($tests as $func => $loaded) { echo "$func: " . (function_exists($func) ? 'Available' : 'Missing') . "\n"; echo " Extension: " . ($loaded ? 'Loaded' : 'Not loaded') . "\n"; } ?> ```

1. 1.Check specific function availability:
2. 2.```bash
3. 3.php -r "var_dump(function_exists('curl_init'));"
4. 4.php -r "var_dump(function_exists('imagecreate'));"
5. 5.php -m | grep -i gd
6. 6.`
7. 7.Test namespaced functions:
8. 8.```php
9. 9.<?php
10. 10.namespace App\Test;

// Should work with backslash echo \strlen('test') . "\n";

// Should work with import use function strlen; echo strlen('test') . "\n"; ?> ```

1. 1.Run extension check script:
2. 2.```bash
3. 3.php check_extensions.php
4. 4.`
5. 5.Test version-specific functions:
6. 6.```bash
7. 7.php -r "echo PHP_VERSION . ': ' . (function_exists('str_contains') ? 'has str_contains' : 'needs polyfill') . '\n';"
8. 8.`
9. 9.Monitor in production:
10. 10.```bash
11. 11.tail -f /var/log/php-fpm/error.log | grep "undefined function"
12. 12.grep -c "Call to undefined function" /var/log/php-fpm/error.log
13. 13.`

Related Issues

• [Fix PHP Class Not Found Autoload](/articles/fix-php-class-not-found-autoload)
• [Fix PHP Undefined Index Offset Error](/articles/fix-php-undefined-index-offset-error)
• [Fix PHP Composer Dependency Conflict](/articles/fix-php-composer-dependency-conflict)
• [Fix Laravel Function Not Found](/articles/fix-laravel-function-not-found)
• [Fix WordPress Missing Function Error](/articles/fix-wordpress-missing-function-error)
• [Fix PHP Extension Not Loaded](/articles/fix-php-extension-not-loaded)
• [Fix PHP GD Library Missing](/articles/fix-php-gd-library-missing)
• [Fix PHP mbstring Extension Missing](/articles/fix-php-mbstring-missing)
• [Fix PHP MySQL Extension Deprecated](/articles/fix-php-mysql-extension-deprecated)
• [Fix PHP mcrypt Replacement](/articles/fix-php-mcrypt-replacement)