Ubuntu-fr

samcelia

Fonctions et variable non reconnues dans le fichier ClassLoader.php

Bonsoir,

En vue de programmer en PHP un programme de type Modèle-vue-contrôleur, j'ai appris dans un premier temps à créer un dossier vendor. 
A l'intérieur de ce dossier, dans la classe ClassLoader, 2 méthodes (acpu_fetch et apcu_add) et une variable ($hit) ne sont pas reconnus
J'ai installé le paquet apcu avec succès. Ce paquet apparait avec php -m.
Voici mon fichier /etc/php/8.1/apache2/conf.d/20-xdebug.ini:

zend_extension=xdebug.so
xdebug.mode=develop,debug
xdebug.start_with_request=yes
extension=apcu.so

et voici une capture d'écran du fichier phpinfo.php: capture d'écran du fichier phpinfo.php

Je  travaille avec VSCodium.

Merci pour votre aide.

Dernière modification par samcelia (Le 26/01/2024, à 17:14)

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

J'ai retiré la ligne extension=apcu.so du fichier /etc/php/8.1/apache2/conf.d/20-xdebug.ini. Cette ligne était déjà présente dans le
fichier /etc/php/8.1/mods-available/apcu.ini.  D'après les noms des fichiers, cela parait plus logique.
Mais cela ne marche toujours pas.
Et je n'avais pas à installer de paquet php-apcu , car un paquet php8.1-acpu était déjà installé sur ma machine.

Dernière modification par samcelia (Le 26/01/2024, à 14:14)

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

Je teste ce programme avec VSCodium et VSCode,
lorsque je désactive l'extension "PHP Intelephense", les quatre erreurs disparaissent. Y'a-t-il un réglage à effectuer pour garder PHP Intelephense? Que vaut PHP IntelliSense par rapport PHP Intelephense?

krodelabestiole

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

quelles méthodes ? quelles variables ?
sans avoir accès ni au code ni aux messages d'erreur exact, on va pas pouvoir faire grand chose...

php -m indique ce qui est dispo en ligne de commande. ça ne l'est pas forcément pour le module d'apache (ceci dit d'après ton phpinfo c'est bon).

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents

bruno

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

D'après #3 c'est un problème spécifique à VSCodium. À discuter sur leurs forums donc.

Sinon cette directive :

extension=apcu.so

n' a rien à faire dans ce fichier  /etc/php/8.1/apache2/conf.d/20-xdebug.ini (et attention c'est un lien symbolique qui pointe vers /etc/php/8.1/mods-available/xdebug.ini). Elle est déjà présente dans le fichier apcu.ini !

P.S. : parfois on est bien plus productif avec un bon éditeur de code (gedit, kate, kdevelop, etc.) simple et efficace.

---

Attention, les bouteilles vendues par Nestlé Waters sont contaminées au monoxyde de dihydrogène.

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

quelles méthodes ? quelles variables ?
sans avoir accès ni au code ni aux messages d'erreur exact, on va pas pouvoir faire grand chose...

php -m indique ce qui est dispo en ligne de commande. ça ne l'est pas forcément pour le module d'apache (ceci dit d'après ton phpinfo c'est bon).

Deux méthodes acpu_fetch et apcu_add ne sont pas reconnus, ainsi qu'une variable $hits sous VSCodium.Par contre dès que je désinstalle l'extension.Intelephense
les erreurs disparaissent. Sous PhpStorm , ces fonctions et cette variables sont reconnus. Intelisense (sous VSCodium) ne relève pas non plus ces erreurs.
Cela vient donc de l'extension Intelephense.

Je t'envoie tout de même le code de la classe ClassLoader.php qui a été généré automatiquement et deux captures d'écran montrant les erreurs:

 <?php

/*
 * This file is part of Composer.
 *
 * (c) Nils Adermann <naderman@naderman.de>
 *     Jordi Boggiano <j.boggiano@seld.be>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Composer\Autoload;

/**
 * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
 *
 *     $loader = new \Composer\Autoload\ClassLoader();
 *
 *     // register classes with namespaces
 *     $loader->add('Symfony\Component', __DIR__.'/component');
 *     $loader->add('Symfony',           __DIR__.'/framework');
 *
 *     // activate the autoloader
 *     $loader->register();
 *
 *     // to enable searching the include path (eg. for PEAR packages)
 *     $loader->setUseIncludePath(true);
 *
 * In this example, if you try to use a class in the Symfony\Component
 * namespace or one of its children (Symfony\Component\Console for instance),
 * the autoloader will first look for the class under the component/
 * directory, and it will then fallback to the framework/ directory if not
 * found before giving up.
 *
 * This class is loosely based on the Symfony UniversalClassLoader.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Jordi Boggiano <j.boggiano@seld.be>
 * @see    https://www.php-fig.org/psr/psr-0/
 * @see    https://www.php-fig.org/psr/psr-4/
 */
class ClassLoader
{
    /** @var ?string */
    private $vendorDir;

    // PSR-4
    /**
     * @var array[]
     * @psalm-var array<string, array<string, int>>
     */
    private $prefixLengthsPsr4 = array();
    /**
     * @var array[]
     * @psalm-var array<string, array<int, string>>
     */
    private $prefixDirsPsr4 = array();
    /**
     * @var array[]
     * @psalm-var array<string, string>
     */
    private $fallbackDirsPsr4 = array();

    // PSR-0
    /**
     * @var array[]
     * @psalm-var array<string, array<string, string[]>>
     */
    private $prefixesPsr0 = array();
    /**
     * @var array[]
     * @psalm-var array<string, string>
     */
    private $fallbackDirsPsr0 = array();

    /** @var bool */
    private $useIncludePath = false;

    /**
     * @var string[]
     * @psalm-var array<string, string>
     */
    private $classMap = array();

    /** @var bool */
    private $classMapAuthoritative = false;

    /**
     * @var bool[]
     * @psalm-var array<string, bool>
     */
    private $missingClasses = array();

    /** @var ?string */
    private $apcuPrefix;

    /**
     * @var self[]
     */
    private static $registeredLoaders = array();

    /**
     * @param ?string $vendorDir
     */
    public function __construct($vendorDir = null)
    {
        $this->vendorDir = $vendorDir;
    }

    /**
     * @return string[]
     */
    public function getPrefixes()
    {
        if (!empty($this->prefixesPsr0)) {
            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
        }

        return array();
    }

    /**
     * @return array[]
     * @psalm-return array<string, array<int, string>>
     */
    public function getPrefixesPsr4()
    {
        return $this->prefixDirsPsr4;
    }

    /**
     * @return array[]
     * @psalm-return array<string, string>
     */
    public function getFallbackDirs()
    {
        return $this->fallbackDirsPsr0;
    }

    /**
     * @return array[]
     * @psalm-return array<string, string>
     */
    public function getFallbackDirsPsr4()
    {
        return $this->fallbackDirsPsr4;
    }

    /**
     * @return string[] Array of classname => path
     * @psalm-return array<string, string>
     */
    public function getClassMap()
    {
        return $this->classMap;
    }

    /**
     * @param string[] $classMap Class to filename map
     * @psalm-param array<string, string> $classMap
     *
     * @return void
     */
    public function addClassMap(array $classMap)
    {
        if ($this->classMap) {
            $this->classMap = array_merge($this->classMap, $classMap);
        } else {
            $this->classMap = $classMap;
        }
    }

    /**
     * Registers a set of PSR-0 directories for a given prefix, either
     * appending or prepending to the ones previously set for this prefix.
     *
     * @param string          $prefix  The prefix
     * @param string[]|string $paths   The PSR-0 root directories
     * @param bool            $prepend Whether to prepend the directories
     *
     * @return void
     */
    public function add($prefix, $paths, $prepend = false)
    {
        if (!$prefix) {
            if ($prepend) {
                $this->fallbackDirsPsr0 = array_merge(
                    (array) $paths,
                    $this->fallbackDirsPsr0
                );
            } else {
                $this->fallbackDirsPsr0 = array_merge(
                    $this->fallbackDirsPsr0,
                    (array) $paths
                );
            }

            return;
        }

        $first = $prefix[0];
        if (!isset($this->prefixesPsr0[$first][$prefix])) {
            $this->prefixesPsr0[$first][$prefix] = (array) $paths;

            return;
        }
        if ($prepend) {
            $this->prefixesPsr0[$first][$prefix] = array_merge(
                (array) $paths,
                $this->prefixesPsr0[$first][$prefix]
            );
        } else {
            $this->prefixesPsr0[$first][$prefix] = array_merge(
                $this->prefixesPsr0[$first][$prefix],
                (array) $paths
            );
        }
    }

    /**
     * Registers a set of PSR-4 directories for a given namespace, either
     * appending or prepending to the ones previously set for this namespace.
     *
     * @param string          $prefix  The prefix/namespace, with trailing '\\'
     * @param string[]|string $paths   The PSR-4 base directories
     * @param bool            $prepend Whether to prepend the directories
     *
     * @throws \InvalidArgumentException
     *
     * @return void
     */
    public function addPsr4($prefix, $paths, $prepend = false)
    {
        if (!$prefix) {
            // Register directories for the root namespace.
            if ($prepend) {
                $this->fallbackDirsPsr4 = array_merge(
                    (array) $paths,
                    $this->fallbackDirsPsr4
                );
            } else {
                $this->fallbackDirsPsr4 = array_merge(
                    $this->fallbackDirsPsr4,
                    (array) $paths
                );
            }
        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
            // Register directories for a new namespace.
            $length = strlen($prefix);
            if ('\\' !== $prefix[$length - 1]) {
                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
            }
            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
            $this->prefixDirsPsr4[$prefix] = (array) $paths;
        } elseif ($prepend) {
            // Prepend directories for an already registered namespace.
            $this->prefixDirsPsr4[$prefix] = array_merge(
                (array) $paths,
                $this->prefixDirsPsr4[$prefix]
            );
        } else {
            // Append directories for an already registered namespace.
            $this->prefixDirsPsr4[$prefix] = array_merge(
                $this->prefixDirsPsr4[$prefix],
                (array) $paths
            );
        }
    }

    /**
     * Registers a set of PSR-0 directories for a given prefix,
     * replacing any others previously set for this prefix.
     *
     * @param string          $prefix The prefix
     * @param string[]|string $paths  The PSR-0 base directories
     *
     * @return void
     */
    public function set($prefix, $paths)
    {
        if (!$prefix) {
            $this->fallbackDirsPsr0 = (array) $paths;
        } else {
            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
        }
    }

    /**
     * Registers a set of PSR-4 directories for a given namespace,
     * replacing any others previously set for this namespace.
     *
     * @param string          $prefix The prefix/namespace, with trailing '\\'
     * @param string[]|string $paths  The PSR-4 base directories
     *
     * @throws \InvalidArgumentException
     *
     * @return void
     */
    public function setPsr4($prefix, $paths)
    {
        if (!$prefix) {
            $this->fallbackDirsPsr4 = (array) $paths;
        } else {
            $length = strlen($prefix);
            if ('\\' !== $prefix[$length - 1]) {
                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
            }
            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
            $this->prefixDirsPsr4[$prefix] = (array) $paths;
        }
    }

    /**
     * Turns on searching the include path for class files.
     *
     * @param bool $useIncludePath
     *
     * @return void
     */
    public function setUseIncludePath($useIncludePath)
    {
        $this->useIncludePath = $useIncludePath;
    }

    /**
     * Can be used to check if the autoloader uses the include path to check
     * for classes.
     *
     * @return bool
     */
    public function getUseIncludePath()
    {
        return $this->useIncludePath;
    }

    /**
     * Turns off searching the prefix and fallback directories for classes
     * that have not been registered with the class map.
     *
     * @param bool $classMapAuthoritative
     *
     * @return void
     */
    public function setClassMapAuthoritative($classMapAuthoritative)
    {
        $this->classMapAuthoritative = $classMapAuthoritative;
    }

    /**
     * Should class lookup fail if not found in the current class map?
     *
     * @return bool
     */
    public function isClassMapAuthoritative()
    {
        return $this->classMapAuthoritative;
    }

    /**
     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
     *
     * @param string|null $apcuPrefix
     *
     * @return void
     */
    public function setApcuPrefix($apcuPrefix)
    {
        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
    }

    /**
     * The APCu prefix in use, or null if APCu caching is not enabled.
     *
     * @return string|null
     */
    public function getApcuPrefix()
    {
        return $this->apcuPrefix;
    }

    /**
     * Registers this instance as an autoloader.
     *
     * @param bool $prepend Whether to prepend the autoloader or not
     *
     * @return void
     */
    public function register($prepend = false)
    {
        spl_autoload_register(array($this, 'loadClass'), true, $prepend);

        if (null === $this->vendorDir) {
            return;
        }

        if ($prepend) {
            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
        } else {
            unset(self::$registeredLoaders[$this->vendorDir]);
            self::$registeredLoaders[$this->vendorDir] = $this;
        }
    }

    /**
     * Unregisters this instance as an autoloader.
     *
     * @return void
     */
    public function unregister()
    {
        spl_autoload_unregister(array($this, 'loadClass'));

        if (null !== $this->vendorDir) {
            unset(self::$registeredLoaders[$this->vendorDir]);
        }
    }

    /**
     * Loads the given class or interface.
     *
     * @param  string    $class The name of the class
     * @return true|null True if loaded, null otherwise
     */
    public function loadClass($class)
    {
        if ($file = $this->findFile($class)) {
            includeFile($file);

            return true;
        }

        return null;
    }

    /**
     * Finds the path to the file where the class is defined.
     *
     * @param string $class The name of the class
     *
     * @return string|false The path if found, false otherwise
     */
    public function findFile($class)
    {
        // class map lookup
        if (isset($this->classMap[$class])) {
            return $this->classMap[$class];
        }
        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
            return false;
        }
        if (null !== $this->apcuPrefix) {
            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
            if ($hit) {
                return $file;
            }
        }

        $file = $this->findFileWithExtension($class, '.php');

        // Search for Hack files if we are running on HHVM
        if (false === $file && defined('HHVM_VERSION')) {
            $file = $this->findFileWithExtension($class, '.hh');
        }

        if (null !== $this->apcuPrefix) {
            apcu_add($this->apcuPrefix.$class, $file);
        }

        if (false === $file) {
            // Remember that this class does not exist.
            $this->missingClasses[$class] = true;
        }

        return $file;
    }

    /**
     * Returns the currently registered loaders indexed by their corresponding vendor directories.
     *
     * @return self[]
     */
    public static function getRegisteredLoaders()
    {
        return self::$registeredLoaders;
    }

    /**
     * @param  string       $class
     * @param  string       $ext
     * @return string|false
     */
    private function findFileWithExtension($class, $ext)
    {
        // PSR-4 lookup
        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;

        $first = $class[0];
        if (isset($this->prefixLengthsPsr4[$first])) {
            $subPath = $class;
            while (false !== $lastPos = strrpos($subPath, '\\')) {
                $subPath = substr($subPath, 0, $lastPos);
                $search = $subPath . '\\';
                if (isset($this->prefixDirsPsr4[$search])) {
                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
                        if (file_exists($file = $dir . $pathEnd)) {
                            return $file;
                        }
                    }
                }
            }
        }

        // PSR-4 fallback dirs
        foreach ($this->fallbackDirsPsr4 as $dir) {
            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
                return $file;
            }
        }

        // PSR-0 lookup
        if (false !== $pos = strrpos($class, '\\')) {
            // namespaced class name
            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
        } else {
            // PEAR-like class name
            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
        }

        if (isset($this->prefixesPsr0[$first])) {
            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
                if (0 === strpos($class, $prefix)) {
                    foreach ($dirs as $dir) {
                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
                            return $file;
                        }
                    }
                }
            }
        }

        // PSR-0 fallback dirs
        foreach ($this->fallbackDirsPsr0 as $dir) {
            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
                return $file;
            }
        }

        // PSR-0 include paths.
        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
            return $file;
        }

        return false;
    }
}

/**
 * Scope isolated include.
 *
 * Prevents access to $this/self from included files.
 *
 * @param  string $file
 * @return void
 * @private
 */
function includeFile($file)
{
    include $file;
}

Erreurs-VSCode1
Erreurs-VSCodium2

Dernière modification par samcelia (Le 27/01/2024, à 13:23)

krodelabestiole

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

P.S. : parfois on est bien plus productif avec un bon éditeur de code (gedit, kate, kdevelop, etc.) simple et efficace.

vscodium est un bon éditeur, simple et efficace, mais en plus il est très modulaire. on peut choisir une par une les extensions qui nous intéresse.
pour un projet de ce type (créer un framework mvc) - on sera quand même ultra limité avec gedit... à la limite geany est très chouette et mieux intégré à GNOME que vscodium.

Cela vient donc de l'extension Intelephense.

tu as essayé de faire interpréter le code par Apache ? (c'est surtout ça qui détermine si c'est une erreur de l'IDE)
... je vais regarder comment se configure Intelephense...

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

tu as essayé de faire interpréter le code par Apache ? (c'est surtout ça qui détermine si c'est une erreur de l'IDE)
... je vais regarder comment se configure Intelephense...

Je suis en cours de formation, et je suis donc un novice. Le premier programme que l'on a fait a été de visualiser  dans http://localhost:8080/, le var_dump d'un objet.
Et cela a marché. Apache doit donc fonctionner. Merci pour tes recherches.

Dernière modification par samcelia (Le 27/01/2024, à 14:41)

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

Bonjour,

je viens d'obtenir une erreur avec VSCode lorsque Intelephense est activée:
- getName est soulignée et déclarée "Undefined dans l'expression "$paramType = $param->getType()->getName();"

 /**
     * Resolve a build method's parameters
     *
     * @param string $controller
     * @param string $method
     * @return array
     * @throws \ReflectionException
     */
    private function getMethetodParams(string $controller, string $method): array
    {
        $methodInfos = new ReflectionMethod($controller . '::' . $method);
        $methodParameters = $methodInfos->getParameters();

        $params = [];
        foreach ($methodParameters as $param) {
            $paramName = $param->getName();
            $paramType = $param->getType()->getName();


            if (array_key_exists($paramType, $this->services)) {
                $params[$paramName] = $this->services[$paramType];
            }
        }
        return $params;
    }
}

Le code fonctionne avec VSCode (sans Intelephense) et avec PhpStorm.

PS: C'est mon formateur qui a écrit le programme.  Ce programme est en perpétuelle évolution au cours de la formation. Pas évident à suivre. Mais je comprends qu'un programme MVC ne soit pas facile à enseigner.
Merci de votre aide.

Dernière modification par samcelia (Le 03/02/2024, à 12:27)

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

J'ai refait des essais, ce matin . J'ai juste rechargé Intelephense, et le programme fonctionne à nouveau. Par contre, getName() est toujours souligné.

soshy

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

Probablement parce que bien que le code fonctionne, il est potentiellement faux.

Prenons les choses dans l'ordre :
$methodInfo est de type ReflectionMethod
$methodParameters est de type array
$param est de type ReflectionParameter (d'après la doc)
Le retour de la fonction getType de la classe ReflectionParameter est de type ReflectionType. Pour ce type, aucune méthode getName n'est définie.

Mais alors, pourquoi ça fonctionne ?...
ReflectionType a 3 sous types possibles (ReflectionNamedType, ReflectionUnionType et ReflectionIntersectionType), dont un seul implémente la méthode getName : ReflectionNamedType.

Mon avis est que c'est "un coup de chance" et que tous les éléments de $methodParameters sont des ReflectionParameter type ReflectionNamedType.

Dans les vrais langages de programmation typés (donc pas en php), pour ce genre de choses il faudrait faire un truc du genre

if ($param->getType() == ReflectionNamedType) {
    $paramType = ((ReflectionNamedType) $param->getType())->getName() // nom du type du paramètre
}

Sur la 2nd ligne, ça s'appel un cast. On dit au programme "je sais que le retour de $param->getType() est type ReflectionNamedType , alors tu me le convertie et ensuite appelle la méthode getName() dessus. J'ai levé l’ambiguïté sur le type et donc tout va bien.

Dernière modification par soshy (Le 05/02/2024, à 17:34)

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

Bonjour,

Merci soshy pour tes recherches et tes explications.
Un autre formateur m' a soufflé l'idée d'annoter au dessus de la boucle for, $params.

     /** 
        * @var ReflectionParameter $param 
        */
        foreach ($methodParameters as $param) {
            $paramName = $param->getName();
            $paramType = $param->getType()->getName();

            if (array_key_exists($paramType, $this->services)) {
                $params[$paramName] = $this->services[$paramType];
            }
        }

Le soulignement de getName à disparu. le programme fonctionne.

Dernière modification par samcelia (Le 07/02/2024, à 13:35)

soshy

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

C'est bien sur cette ligne que tu avais l'erreur qui disparait avec l'annotation

$param->getType()->getName();

?
Si oui, ça me surprend un peu. Ça m'aurai paru logique si ça concernait la ligne

$paramName = $param->getName();

Après il y a peut être une subtilité qui m'échappe, php c'est pas vraiment mon langage de prédilection

Quoi qu'il en soit, il fait un peu l'équivalent de ce que j'avais indiqué. Il dit à l'analyseur de code "je sais mieux que toi, ça serai un objet de tel type". Et il est obligé de le faire dans les commentaires parce que php c'est pas un "vrai langage typé".

samcelia

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

C'est bien sur cette ligne que tu avais l'erreur qui disparait avec l'annotation

oui.

Quoi qu'il en soit, il fait un peu l'équivalent de ce que j'avais indiqué. Il dit à l'analyseur de code "je sais mieux que toi, ça serai un objet de tel type". Et il est obligé de le faire dans les commentaires parce que php c'est pas un "vrai langage typé".

Oui, Php a tout de même fait des efforts en proposant d'indiquer le type des paramètres (string ci-dessous) et le type du retour de la fonction(array ci-dessous)

 private function getMethetodParams(string $controller, string $method): [array]

Dernière modification par samcelia (Le 07/02/2024, à 16:42)

krodelabestiole

Re : Fonctions et variable non reconnues dans le fichier ClassLoader.php

Le soulignement de getName à disparu.

les soulignements indiqués par intelephense (et un peu tous les assistants, comme JSLint) peuvent signifier pas mal de choses différentes. ça peut entre autre être un problème mineur dans la fonction appelée, comme l'utilisation d'une fonction dépréciée.
pour en savoir plus il faut survoler le nom de la fonction soulignée.
Ctrl + clic permet aussi de prévisualiser la fonction appelée, et on peut cliquer sur le nom du fichier (en haut de la prévisualisation) pour ouvrir la déclaration de la fonction dans le fichier concerné.

---

nouveau forum ubuntu-fr on en parle là : refonte du site / nouveau design
profil - sujets récurrents