MiniLang
2.29
Cette bibliothèque est utilisée pour stocker la logique commerciale dans une définition simple et pourtant puissante.
Un mini-langage de script pour PHP. Il fait trois tâches simples.
Par exemple :
when var1>5 and var2>20 then var3=20 // when and then
init var5=20 when var1>5 and var2>20 then var3=var5 // init, when and then
init var5=20 when var1>5 and var2>20 then var3=var5 else var3=var20 // init, when, then and else
when var1>$abc then var3=var5 // $abc is a PHP variable.
Parfois, nous devons exécuter du code arbitraire dans la base de "Si une valeur est égale à, alors nous définissons ou exécutons un autre code".
En PHP, nous pourrions faire le code suivant.
if ( $ condition ) {
$ variable = 1 ;
}Cependant, ce code est exécuté lors de l'exécution. Et si nous devons exécuter ce code à un moment précis ?.
Nous pourrions faire le code suivant:
$ script = ' if($condition) {
$variable=1;
} ' ;
// and later..
eval ( $ script );Cette solution fonctionne (et elle s'exécute uniquement si nous appelons la commande EVAL). Mais c'est verbeux, sujet à l'erreur, et c'est dangereux.
Notre bibliothèque fait de même mais sûre et propre.
$ mini -> separate ( " when condition then variable=1 " );L'installation à l'aide du compositeur:
Le compositeur a besoin d'Eftec / Minilang
Créer un nouveau projet
use eftec minilang MiniLang ;
include " ../lib/MiniLang.php " ; // or the right path to MiniLang.php
$ mini = new MiniLang ();
$ mini -> separate ( " when field1=1 then field2=2 " ); // we set the logic of the language but we are not executed it yet.
$ mini -> separate ( " when field1=2 then field2=4 " ); // we set more logic.
$ result =[ ' field1 ' => 1 , ' field2 ' => 0 ]; // used for variables.
$ callback = new stdClass (); // used for callbacks if any
$ mini -> evalAllLogic ( $ callback , $ result );
var_dump ( $ result );Un autre exemple:
use eftec minilang MiniLang ;
include " ../lib/MiniLang.php " ;
$ result =[ ' var1 ' => ' hello ' ];
$ global1 = " hello " ;
$ mini = new MiniLang ( null , $ result );
$ mini -> throwError = false ; // if error then we store the errors in $mini->errorLog;
$ mini -> separate ( ' when var1="hello" then var2="world" ' ); // if var1 is equals "hello" then var2 is set "world"
$ mini -> separate ( ' when $global1="hello" then $global2="world" ' ); // we can also use php variables (global)
$ mini -> evalAllLogic ( false ); // false means it continues to evaluate more expressions if any
// (true means that it only evaluates the first expression where "when" is valid)
var_dump ( $ result ); // array(2) { ["var1"]=> string(5) "hello" ["var2"]=> string(5) "world" }
var_dump ( $ global2 ); // string(5) "world" __Construct (& $ appelant, & $ dict, array $ spécialcom = [], $ aaname = [], $ serviceclass = null)
Il réinitialise les définitions précédentes mais les variables, les services et les zones.
Définissez un objet de l'appelant. L'objet de l'appelant il pourrait être une classe de service avec une méthode qu'ils pourraient être appelés à l'intérieur du script.
Définissez un dictionnaire avec les variables utilisées par le système.
Il envoie une expression au Minilang, et il est décomposé dans ses parties. Le script n'est pas exécuté mais analysé.
Il évalue une logique. Il renvoie vrai ou faux.
Il définit une valeur ou des valeurs. Il ne considère pas si c'est vrai ou non.
Boolean.
Tableau de chaîne. Si $ throwerror est faux, chaque erreur est stockée ici.
Exemple:
$ this -> throwError = false ;
$ mini -> separate ( " when FIELDDOESNOTEXIST=1 then field2=2 " );
var_dump ( $ this -> errorLog );La syntaxe du code est séparée en quatre parties. Init, où (ou quand), set (ou ensuite) et sinon.
Exemple:
$ mini -> separate ( " when field1=1 then field2=2 " );Il dit que si Field1 = 1 alors nous définissons Field2 comme 2.
Une variable est définie par varname
Exemple: Exemples / ExempleVariable.php
$ mini = new MiniLang ();
$ mini -> separate ( " when field1>0 then field2=3 " ); // we prepare the language
$ variables =[ ' field1 ' => 1 ]; // we define regular variables
$ callback = new stdClass ();
$ mini -> evalAllLogic ( $ callback , $ variables ); // we set the variables and run the languageand run the language
var_dump ( $ variables ); // field1=1, field2=3Une variable pourrait héberger un objet PHP, et il est possible d'appeler et d'accéder aux champs à l'intérieur.
varname.field
Exemple d'exemples de code / exampleVariable2.php
class MyModel {
var $ id = 1 ;
var $ value = "" ;
public function __construct ( $ id = 0 , $ value = "" )
{
$ this -> id = $ id ;
$ this -> value = $ value ;
}
}
class ClassCaller {
public function Processcaller ( $ arg ) {
echo " Caller: setting the variable { $ arg -> id } <br> " ;
}
}
class ClassService {
public function ProcessService ( $ arg ) {
echo " Service: setting the variable { $ arg -> id } <br> " ;
}
}
$ mini = new MiniLang ([],[], new ClassService ());
$ mini -> separate ( " when field1.id>0 then
field2.value=3
and field3.processcaller
and processcaller(field3)
and processservice(field3) " ); // we prepare the language
$ variables =[ ' field1 ' => new MyModel ( 1 , " hi " )
, ' field2 ' => new MyModel ( 2 , '' )
, ' field3 ' => new MyModel ( 3 , '' )]; // we define regular variables
$ callback = new ClassCaller ();
$ mini -> evalAllLogic ( $ callback , $ variables , false ); // we set the variables and run the languageand run the language
var_dump ( $ variables );Une variable peut contenir un tableau associatif / index, et il est possible de lire et d'accéder aux éléments à l'intérieur.
Exemple:
$ mini = new MiniLang ( null ,
[
' vararray ' =>[ ' associindex ' => ' hi ' , 0 => ' a ' , 1 => ' b ' , 2 => ' c ' , 3 => ' d ' , 4 => ' last ' , ' a ' =>[ ' b ' =>[ ' c ' => ' nested ' ]]]
]
);vararray.associndex // vararray['associindex'] ('hi')
vararray. 4 // vararray[4] 'last'
vararray. 123 // it will throw an error (out of index)
vararray. param ( ' a.b.c ' )) // vararray['a']['b']['c'] ('nested')
param (vararray, ' a.b.c ' )) // vararray['a']['b']['c'] ('nested')
vararray._first // first element ('hi')
vararray._last // last element ('last')
vararray._count // returns the number of elements. (6)Exemple d'exemples de code / exampleVariable_arr.php
class ClassCaller {
public function Processcaller ( $ arg ) {
echo " Caller: setting the variable { $ arg [ ' id ' ]} <br> " ;
}
}
class ClassService {
public function ProcessService ( $ arg ) {
echo " Service: setting the variable { $ arg [ ' id ' ]} <br> " ;
}
}
$ mini = new MiniLang ([],[], new ClassService ());
$ mini -> separate ( " when field1.id>0 then
field2.value=3
and field3.processcaller
and processcaller(field3)
and processservice(field3) " );
$ variables =[ ' field1 ' =>[ ' id ' => 1 , ' value ' => 3 ]
, ' field2 ' =>[ ' id ' => 2 , ' value ' => '' ]
, ' field3 ' =>[ ' id ' => 3 , ' value ' => '' ]
];
$ callback = new ClassCaller ();
$ mini -> evalAllLogic ( $ callback , $ variables , false );
var_dump ( $ variables );Une variable globale prend les valeurs du PHP ($ global), il n'a donc pas besoin d'être défini ou défini dans la langue
Remarque: à des fins de sécurité. Les variables globales définies par PHP comme "$ _namevar" ne peuvent pas être lues ou modifiées. Donc, si vous souhaitez protéger une variable globale, vous pouvez le renommer avec un soulignement en tant que préfixe.
Exemple: Si vous essayez de lire la variable $ _Server, il renverra la valeur du serveur $ variable qu'il pourrait être défini ou non.
Une variable globale est définie par
$globalname
$ globalname .associndex // $globalname['associindex']
$ globalname . 4 // $globalname[4]
$ globalname . param ( ' a.b.c ' ) // $globalname['a']['b']['c']
param ( $ globalname , ' a.b.c ' ) // $globalname['a']['b']['c']Exemple:
$globalname=30
Exemple de code: exemples / exampleglobal.php
$ field1 = 1 ; // our global variable
$ mini = new MiniLang ();
$ mini -> separate ( ' when $field1>0 then $field1=3 ' ); // we prepare the language
$ variables =[]; // local variables
$ callback = new stdClass ();
$ mini -> evalAllLogic ( $ callback , $ variables ); // we set the variables and run the languageand run the language
var_dump ( $ field1 ); // returns 3 | Taper | Exemple |
|---|---|
| Nombre | 20 |
| chaîne | "Hello World", 'Hello World' |
| stringp | "Mon nom est {{var}}" |
| fonction | NameFunction (arg, arg) |
set var = 20 et var2 = "hello" et var3 = "Hello {{var}}" et var4 = fn ()
| Mot réservé | Explication |
|---|---|
| nul() | valeur nul |
| FAUX() | valeur fausse |
| vrai() | vraie valeur |
| sur() | 1 |
| param (var, 'l1.l2.l3') | Sépare un tableau (var) en var ['l1'] ['l2'] ['l3'] |
| désactivé() | 0 |
| undef () | -1 (pour non défini) |
| retourner() | (valeur spéciale). Il inverse une valeur sur <-> off Utilisé comme valeur = flip () |
| maintenant() | Renvoie l'horodatage actuel (entier) |
| minuteur() | Renvoie l'horodatage actuel (entier) |
| intervalle() | Renvoie l'intervalle (en secondes) entre le dernier changement et maintenant. Il utilise le champ DatelastChange ou la méthode DatelastChange () de la classe de rappel |
| fullInterval () | Renvoie l'intervalle (en secondes) entre le début du processus et maintenant. Il utilise le champ DateInit ou la méthode DateInit () de la classe de rappel |
| contient () / str_connains () | Renvoie True si le texte est contenu dans un autre texte. |
| str_starts_with (), startwith () | Renvoie vrai si le texte commence par un autre texte |
| str_ends_with (), endwith () | Renvoie True si le texte se termine par un autre texte. |
Exemple: exemples / examplerereserved.php
$ mini = new MiniLang ();
$ mini -> separate ( " when true=true then field1=timer() " ); // we prepare the language
$ variables =[ ' field1 ' => 1 ]; // we define regular variables
$ callback = new stdClass ();
$ mini -> evalAllLogic ( $ callback , $ variables ); // we set the variables and run the language
var_dump ( $ variables );Exemple de minuterie: Exemples / examplereserservedtimer.php
class ClassWithTimer {
var $ dateLastChange ;
public function dateInit () {
return time ();
}
public function __construct ()
{
$ this -> dateLastChange = time ();
}
}
$ mini = new MiniLang ();
$ mini -> separate ( " when true=true then field1=interval() and field2=fullinterval() " ); // we prepare the language
$ variables =[ ' field1 ' => 0 , ' field2 ' => 0 ]; // we define regular variables
$ callback = new ClassWithTimer ();
$ mini -> evalAllLogic ( $ callback , $ variables ); // we set the variables and run the language
var_dump ( $ variables );Cette partie de l'expression permet de définir une valeur. Cette expression est généralement facultative et pourrait être omise.
Il est similaire à Set, mais il est exécuté avant où et peu importe si c'est valide ou non.
Init Counter = 20 où variable1 = 20 set variable + compteur
$ mini -> separate ( " init tmp=50 when condition=1 then field1+10 " ); // set tmp to 50. If condition is 1 then it increases the field1 by 10. Cette partie de l'expression ajoute une condition à l'instruction.
Nous pouvons également utiliser "quand".
où l'expression
ou
Quand l'expression
Il est possible de comparer plus qu'une condition en même temps en se séparant par "et" ou "ou".
où v1 = 10 et v2 = 20 ou v3 <50
où variable1 = 20 et $ variable2 = variable3 ou fonction (20) = 40
où $ field = 20 et field2 <> 40 ou field3 = 40 // syntaxe sql
où $ field == 20 && field2! = 40 || Field3 = + 40 // Syntaxe PHP
où 1 // c'est toujours vrai
Cette partie de l'expression permet de définir la valeur d'une variable. Il est possible de définir plus d'une variable en même temps en se séparant par "," ou "et.
Nous pouvons également utiliser l'expression "set" ou "alors"
régler l'expression
ou
puis expression
Cette partie de l'expression n'est exécutée que si où est valide
Nous pourrions définir une variable en utilisant les expressions suivantes:
Cette bibliothèque ne permet pas d'instructions complexes telles que
set variable1 = 20 et $ variable2 = variable3 et fonction (20) = 40
$ mini -> separate ( " when condition=1 then field1+10 " ); // if condition is 1 then it increases the field1 by 10. Cette partie facultative de l'expression permet de définir la valeur d'une variable. Il est possible de définir plus d'une variable en même temps en se séparant par "," ou "et".
Ce code n'est évalué que si "où" renvoie faux si d'autre est appelé manuellement.
else variable1 = 20 et $ variable2 = variable3 et fonction (20) = 40
Il est possible de créer une boucle en utilisant la "boucle" de l'espace
Pour démarrer une boucle, vous devez écrire
$ this -> separate ( ' loop variableloop=variable_with_values ' );
// where variable_with_values is must contains an array of values
// variableloop._key will contain the key of the loop
// variableloop._value will contain the value of the loop Et pour mettre fin à la boucle, vous devez utiliser
$ this -> separate ( ' loop end ' );Vous pouvez échapper à la boucle à l'aide de l'opérateur "Break" dans le "set" ou "else".
$ this -> separate ( ' when condition set break else break ' );Remarque: les boucles ne sont évaluées que lorsque vous évaluez toute la logique. Cela ne fonctionne pas avec evallogic () et evallogic2 ()
Remarque: vous ne pouvez pas ajouter de condition à une boucle, mais vous pouvez sauter une boucle en affectant un tableau vide
Exemple:
$ this -> separate ( ' loop $row=variable ' );
$ this -> separate ( ' loop $row2=variable ' );
$ this -> separate ( ' where op=2 then cc=2 ' );
$ this -> separate ( ' where op=3 then break ' ); // ends of the first loop
$ this -> separate ( ' loop end ' );
$ this -> separate ( ' loop end ' )
$ obj -> evalAllLogic (); Il est possible de créer une classe avec la logique créée dans la langue. L'objectif est d'augmenter les performances du code.
Pour générer la classe, nous devons d'abord écrire la logique en utilisant la méthode séparée 2 () au lieu de séparer () . Il stockera la logique à l'intérieur d'un tableau de l'instance de la classe. Vous pouvez utiliser le code directement, ou vous pouvez enregistrer dans une classe comme suit:
// create an instance of MiniLang
$ mini = new MiniLang ( null );
// the logic goes here
$ mini -> separate2 ( ' when var1="hello" and comp.f=false() then var2="world" ' ); // if var1 is equals "hello" then var2 is set "world"
// and the generation of the class
$ r = $ mini -> generateClass ( ' ExampleBasicClass ' , ' nsexample ' , ' ExampleBasicClass.php ' );Il enregistrera un nouveau fichier appelé? ExempleBasicClass.php (vous pouvez vérifier l'exemple? Exemple / Genclass / 1.ExampleBasic.php)
Avec la classe générée, vous pouvez utiliser cette nouvelle classe au lieu de Minilang . Étant donné que cette classe est déjà compilée, elle flamboie rapidement. Cependant, si vous devez modifier la logique, vous devrez le compiler à nouveau. (Vous pouvez vérifier l'exemple? Exemple / Genclass / 2.ExampleBasic.php et? Exemple / Genclass / ExempleBasicClass.php)
$ result =[ ' var1 ' => ' hello ' ];
$ obj = new ExampleBasicClass ( null , $ result );
$ obj -> evalAllLogic ( true );La classe ressemblera à:
<?php
namespace ns example ;
use eftec minilang MiniLang ;
class ExampleBasicClass extends MiniLang {
public $ numCode = 2 ; // num of lines of code
public $ usingClass = true ; // if true then we are using a class (this class)
public function whereRun ( $ lineCode = 0 ) {
// ...
} // end function WhereRun
public function setRun ( $ lineCode = 0 ) {
// ...
} // end function SetRun
public function elseRun ( $ lineCode = 0 ) {
// ...
} // end function ElseRun
public function initRun ( $ lineCode = 0 ) {
// ...
} // end function InitRun
} // end classOù chaque méthode évalue une partie de l'expression.
Exemples / ExampleBenchmark.php
Nous appelons quelques opérations 1000 fois.
Création moyenne d'une nouvelle langue de script sur PHP
