Voyons comment utiliser l'extension runkit en PHP

Cet article expliquera comment utiliser l'extension runkit en PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Cette fois, nous vous proposons une autre extension amusante. Nous savons que lorsque PHP est en cours d'exécution, c'est-à-dire une fois le déploiement terminé, nous ne pouvons pas modifier les valeurs des constantes, ni l'implémentation dans le corps de la méthode. En d’autres termes, une fois le codage terminé, nous téléchargeons le code sur le serveur. À ce stade, nous ne pouvons pas modifier la valeur d’une constante sans modifier le code. La constante elle-même ne peut pas être modifiée. Cependant, l'extension runkit peut nous aider à accomplir cette fonction.

Modification dynamique des constantes

define('A', 'TestA');

runkit_constant_redefine('A', 'NewTestA');

echo A; // NewTestA

N'est-ce pas étonnant ? Cette extension runkit est une extension fonctionnelle qui nous permet de modifier dynamiquement certaines constantes, corps de méthodes et classes au moment de l'exécution. Bien entendu, du point de vue de la sécurité du système, cette extension n’est pas fortement recommandée. La signification d’une constante étant une quantité immuable, elle ne doit pas être modifiée. De la même manière, la modification dynamique du contenu d'un corps de fonction ou d'une définition de classe au moment de l'exécution peut affecter d'autres codes qui appellent ces fonctions ou classes. Par conséquent, cette extension est une extension dangereuse.

En plus de modifier dynamiquement les constantes, nous pouvons également utiliser les fonctions runkit_constant_add() et runkit_constant_remove() pour ajouter ou supprimer dynamiquement des constantes.

Installation

Pour installer l'extension runkit, vous devez la télécharger depuis github puis compiler l'extension normalement. Le téléchargement pecl est obsolète.

PHP5 : http://github.com/zenovich/runkit

PHP7 : https://github.com/runkit7/runkit7.git

Cloner après succès Juste suivez les étapes normales de compilation et d’installation de l’extension.

phpize
./configure
make
make install

Différentes versions de PHP doivent installer différentes versions d'extensions. En même temps, runkit7 est toujours en cours de développement et certaines fonctions ne sont pas encore prises en charge, telles que :

• runkit_class_adopt.
• runkit_class_emancipate
• runkit_import
• runkit_lint_file
• runkit_lint
• runkit_sandbox_output_handler
• runkit_return_value_used
• Runkit_Sandbox
• Runkit_Sandbox_Parent

Lors de l'écriture du code de test pour cet article, les fonctions ou classes ci-dessus ne sont pas prises en charge. Vous pouvez utiliser l'environnement PHP5 pour tester si les extensions d'origine peuvent être utilisées normalement.

Afficher les clés de variables superglobales

print_r(runkit_superglobals());
//Array
//(
//    [0] => GLOBALS
//    [1] => _GET
//    [2] => _POST
//    [3] => _COOKIE
//    [4] => _SERVER
//    [5] => _ENV
//    [6] => _REQUEST
//    [7] => _FILES
//    [8] => _SESSION
//)

Cette fonction vérifie en fait tous les noms de clés de variables superglobales dans l'environnement d'exécution actuel. Ce sont quelques-unes de nos variables superglobales couramment utilisées, je ne les expliquerai donc pas une par une.

Opérations liées aux méthodes

Les opérations sur les méthodes sont les mêmes que les opérations constantes. Nous pouvons ajouter, modifier, supprimer et renommer dynamiquement diverses méthodes. Tout d’abord, examinons ce qui nous préoccupe le plus lors de la modification du code logique dans le corps de la méthode pendant l’exécution dynamique.

function testme() {
  echo "Original Testme Implementation\n";
}
testme(); // Original Testme Implementation
runkit_function_redefine('testme','','echo "New Testme Implementation\n";');
testme(); // New Testme Implementation

définit une méthode testme(), puis modifie son implémentation via runkit_function_redefine() Enfin, lorsque testme() est à nouveau appelé, la sortie est l'implémentation nouvellement modifiée. Alors, pouvons-nous modifier les méthodes fournies avec PHP ?

// php.ini runkit.internal_override=1
runkit_function_redefine('str_replace', '', 'echo "str_replace changed!\n";');
str_replace(); // str_replace changed!

runkit_function_rename ('implode', 'joinArr' );
var_dump(joinArr(",", ['a', 'b', 'c'])); 
// string(5) "a,b,c"


array_map(function($v){
   echo $v,PHP_EOL;
},[1,2,3]);
// 1
// 2
// 3
runkit_function_remove ('array_map');

// array_map(function($v){
//   echo $v;
// },[1,2,3]);
// PHP Fatal error:  Uncaught Error: Call to undefined function array_map()

Les commentaires dans le code le montrent très clairement. Il suffit de définir runkit.internal_override=1 dans php.ini pour modifier dynamiquement les méthodes et fonctions fournies avec PHP. Par exemple, dans le premier paragraphe, nous avons modifié la méthode str_replace() afin qu'elle puisse afficher directement un paragraphe de texte. Ensuite, nous renommons implode() en joinArr() afin que nous puissions utiliser ce joinArr() tout comme implode(). Enfin, nous avons supprimé la méthode array_map(). Si cette méthode est à nouveau appelée, une erreur sera signalée.

Opérations liées à la méthode de classe

Le fonctionnement de la fonction de méthode interne de la classe est similaire au fonctionnement de la méthode variable ci-dessus, mais nous ne pouvons pas modifier les classes qui venir avec l'opération PHP. Vous pouvez essayer vous-même.

//runkit_method_add('PDO', 'testAddPdo', '', 'echo "This is PDO new Func!\n";');
//PDO::testAddPdo();
// PHP Warning:  runkit_method_add(): class PDO is not a user-defined class

Comme le montre le message d'erreur, la classe PDO n'est pas une classe définie par l'utilisateur, donc la fonction runkit ne peut pas être utilisée pour les opérations associées. Voyons ensuite comment nos classes personnalisées utilisent runkit pour effectuer des opérations dynamiques.

class Example{
}

runkit_method_add('Example', 'func1', '', 'echo "This is Func1!\n";');
runkit_method_add('Example', 'func2', function(){
    echo "This is Func2!\n";
});
$e = new Example;
$e->func1(); // This is Func1!
$e->func2(); // This is Func2!

runkit_method_redefine('Example', 'func1', function(){
    echo "New Func1!\n";
});
$e->func1(); // New Func1!

runkit_method_rename('Example', 'func2', 'func22');
$e->func22(); // This is Func2!

runkit_method_remove('Example', 'func1');
//$e->func1();
// PHP Fatal error:  Uncaught Error: Call to undefined method Example::func1()

Nous avons défini une classe vide, puis y avons ajouté dynamiquement deux méthodes, puis modifié la méthode 1, renommée la méthode 2 et enfin supprimé la méthode 1. La série d'opérations est en fait la même que ci-dessus Le fonctionnement du la méthode ordinaire est fondamentalement la même.

Résumé

Comme mentionné ci-dessus, cette extension est dangereuse, surtout si runkit.internal_override est activé, nous pouvons également la modifier avec les fonctions natives PHP. Mais si vous devez l’utiliser, ses fonctions sont très utiles. Tout comme le modèle de visiteur, "la plupart du temps, vous n'avez pas besoin du modèle de visiteur, mais lorsque vous avez besoin du modèle de visiteur, vous en avez vraiment besoin". La même chose est vraie pour cet ensemble d'extensions runkit.

Code de test :

github.com/zhangyue050…

Apprentissage recommandé : "Tutoriel vidéo PHP"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!