Début avec le développement de l'extension PHP via Zephir

Ce tutoriel expliquera comment créer une extension PHP à l'aide d'une nouvelle langue: Zephir, qui est similaire à C et Fortran. Vous pouvez télécharger le code source complet de GitHub. Nous avons déjà abordé le concept de Zephir, donc si vous êtes intéressé à obtenir un large aperçu, consultez nos articles précédents.

Zephir peut être considéré comme un langage hybride qui vous permet d'écrire du code qui ressemble à PHP, mais qui est ensuite compilé en C natif, ce qui signifie que vous pouvez en créer une extension et en repartir avec un code très efficace.

Les plats clés

• ZEPHIR permet aux développeurs de PHP d'écrire des extensions efficaces en utilisant une syntaxe similaire à PHP mais compilée à N native C pour des performances améliorées.
• Pour configurer un environnement de développement de Zephir, vous avez besoin d'outils spécifiques comme GCC, GNU Make, PHP Development En-têtes, RE2C et JSON-C, avec une recommandation pour un système basé sur Linux.
• Le processus de création d'une extension PHP dans Zephir implique d'initialiser un projet, d'écrire du code dans des fichiers .zep, de compiler le code et de configurer votre environnement PHP pour inclure la nouvelle extension.
• Zephir augmente non seulement les performances, mais offre également un moyen de protéger le code source, ce qui le rend adapté à la création d'applications PHP à source fermée.

Installation

Pour construire une extension PHP et utiliser Zephir, vous aurez besoin de ce qui suit:

• gcc> = 4.x / clang> = 3.x / vc 9
• GNU faire 3.81 ou ultérieure
• En-têtes et outils de développement PHP
• re2c 0,13 ou ultérieure
• JSON-C

Les instructions d'installation varient pour chaque plate-forme, donc j'espère que vous saurez comment les obtenir si vous lisez un article avec un sujet aussi avancé que celui-ci. Pour l'enregistrement - je recommande d'utiliser un système basé sur Linux pour développer des applications Zephir.

Une fois que vous avez obtenu tous les logiciels préalables, téléchargez la dernière version de Zephir à partir de Github, puis exécutez le programme d'installation de Zephir, comme ainsi:

<span>git clone https://github.com/phalcon/zephir
</span><span>cd zephir && ./install -c</span>

Il doit s'installer automatiquement - essayez de taper l'aide de Zephir. Si cela ne fonctionne pas, ajoutez le répertoire «bac» à votre variable d'environnement de chemin. Dans mon cas: / Home / Duythien / App / Zephir / Bin, comme ainsi:

vi $HOME/.bash_profile

Ajouter la commande d'exportation suivante:

export PATH=$PATH:/home/duythien/app/zephir/bin

Pour vérifier les nouveaux paramètres de chemin et tester l'installation, entrez:

echo $PATH
zephir help

Vous pouvez découvrir les bases et la syntaxe de Zephir, ainsi que son système de frappe et voir des scripts de démonstration sur leur site Web.

Programmation avec Zephir

Maintenant, nous utiliserons Zephir pour retravailler une équation mathématique que C et Fortran gèrent très bien. L'exemple est plutôt ésotérique et ne sera pas expliqué en détail, sauf pour démontrer la puissance de Zephir.

Équation de Schrodinger dépendant du temps résolu avec une différence finie

L'équation de Schrödinger dépendante du temps peut être résolue avec des méthodes implicites (grande matrice) et explicites (leaptrog). J'utiliserai la méthode explicite.

Tout d'abord, émettez la commande suivante pour créer le squelette de l'extension:

<span>git clone https://github.com/phalcon/zephir
</span><span>cd zephir && ./install -c</span>

À la fin de cette commande, un répertoire appelé «MyApp» est créé sur le répertoire de travail actuel. Cela ressemble à:

vi $HOME/.bash_profile

À l'intérieur du dossier "MyApp", créez un fichier appelé "quantum.ze" (qui nous donnera l'espace de noms MyAppquantum). Copiez Coller le code suivant à l'intérieur:

export PATH=$PATH:/home/duythien/app/zephir/bin

Nous avons utilisé de nombreuses fonctions PHP telles que fopen (), sin (), fprintf (), etc. - n'hésitez pas à étudier la syntaxe. Je vais également vous donner un autre exemple. Dans le processus de travail avec le cadre PHALCON PHP, la fonction PhalContag :: FriendlyTitle () est invalide si vous travaillez en vietnamien ou en allemand. Cet exemple, beaucoup plus simple que l'équation ci-dessus, crée le fichier normalisechars.zép. Insérez le code suivant dans le fichier:

echo $PATH
zephir help

Maintenant, nous devons dire à Zephir que notre projet doit être compilé et que l'extension générée:

zephir init myapp

La première fois, il est exécuté, un certain nombre de commandes internes sont exécutées en produisant le code et les configurations nécessaires pour exporter cette classe vers l'extension PHP. Si tout se passe bien, vous verrez le message suivant à la fin de la sortie:

Compilation…
Installation…
Extension installée!
Ajouter une extension = myApp.so à votre php.ini
N'oubliez pas de redémarrer votre serveur Web

Notez que puisque Zephir est à ses balbutiements, il est possible de rencontrer des bogues et des problèmes. La première fois que j'ai essayé de compiler cela, cela n'a pas fonctionné. J'ai essayé les commandes suivantes et j'ai finalement fait fonctionner:

myapp/
 |-----ext/
 |-----myapp/
 |-----config.json

La dernière commande installera le module dans le dossier d'extensions PHP (dans mon cas: / usr / lib / php5 / 20121212 /). La dernière étape consiste à ajouter cette extension à votre php.ini en ajoutant la ligne suivante:

namespace Myapp;
class Quantum{

    const PI = 3.14159265358979323846;
    const MAX = 751;

    public function Harmos(double x){
        int  i,j,n;
        var  psr, psi, p2, v,paramater,fp;
        double dt,dx,k0,item_psr,item_psi;

        let dx = 0.02,
            k0 = 3.0*Myapp\Quantum::PI,
            dt = dx*dx/4.0;
        let paramater =[dx,k0,dt,x];
        let i   = 0,
            psr = [],
            psi = [],
            p2  = [],
            v   = [],
            fp  = [];           

        let fp = fopen ("harmos.txt", "w");
            if (!fp) {
            return false;
            }
        while i <= Myapp\Quantum::MAX{
            let item_psi = sin(k0*x) / exp(x*x*2.0),
                item_psr = cos(k0*x) / exp(x*x*2.0);
            let psr[i] = [item_psr],
                psi[i] = [item_psi],
                v[i] = [5.0*x*x],   
                x = x + dx,
                i++;
        }
        var tmp; 
        let i =1, j=1,tmp=[2.0];
        for n in range(0, 20000){

            for i in range(1,Myapp\Quantum::MAX - 1 ){
                let psr[i][3] =psr[i][0] - paramater[2]*(psi[i+1][0] + psi[i - 1][0]
                            - tmp[0]*psi[i][0]) / (paramater[0]*paramater[0]) + paramater[2]*v[i][0]*psi[i][0],

                p2[i] = psr[i][0]*psr[i][4] + psi[i][0]*psi[i][0];
            }
            for j in range(1,Myapp\Quantum::MAX - 1 ) {
                let psr[0][5] = 0,
                    psr[Myapp\Quantum::MAX][6]= 0 ;
                let psi[j][7] = psi[j][0] + paramater[2]*(psr[j+1][8] + psr[j - 1][9]
                             - tmp[0]*psr[j][10]) / (paramater[0]*paramater[0]) - paramater[2]*v[j][0]*psr[j][11];
            }
        //output split
        if (n ==0 || n % 2000 == 0) {
            let i =1;
            while i < Myapp\Quantum::MAX - 1 {
            fprintf(fp, "%16.8lf %16.8lf %16.8lf \n",i*dx,n*dt,p2[i]);
                let i = i + 10;
            }
            fprintf(fp, "\n");
        }
        // change new->old
        let j = 1;
        while j <  Myapp\Quantum::MAX - 1 {
                let psi[j][0] = psi[j][12],
                    psr[j][0] = psr[j][13];
                let j++;
        }

    }
    return true;    

    }
}

redémarrer Apache, et nous avons terminé.

Testez le code

Maintenant, créez un nouveau fichier appelé zephir.php:

namespace Myapp;

class NormalizeChars{
    public function trans(var s)
    {
            var replace;
        let replace = [
            "ế" : "e",
            "ề" : "e",
            "ể" : "e",
            "ễ" : "e",
            "ệ" : "e",
            //--------------------------------E^
            "Ế" : "e",
            "Ề" : "e",
            "Ể" : "e",
            "Ễ" : "e",
            "Ệ" : "e",
            //--------------------------------e
            "é" : "e",
            "è" : "e",
            "ẻ" : "e",
            "ẽ" : "e",
            "ẹ" : "e",
            "ê" : "e",
            //--------------------------------E
            "É" : "e",
            "È" : "e",
            "Ẻ" : "e",
            "Ẽ" : "e",
            "Ẹ" : "e",
            "Ê" : "e",
            //--------------------------------i
            "í" : "i",
            "ì" : "i",
            "ỉ"  : "i",
            "ĩ" : "i",
            "ị" : "i",
            //--------------------------------I
            "Í" : "i",
            "Ì" : "i",
            "Ỉ"  : "i",
            "Ĩ" : "i",
            "Ị" : "i",
            //--------------------------------o^
            "ố" : "o",
            "ồ" : "o",
            "ổ" : "o",
            "ỗ" : "o",
            "ộ" : "o",
            //--------------------------------O^
            "Ố"  : "o",
            "Ồ" : "o",
            "Ổ"  : "o",
            "Ô" : "o",
            "Ộ"  : "o",
            //--------------------------------o*
            "ớ"  : "o",
            "ờ" : "o",
            "ở"  : "o",
            "ỡ" : "o",
            "ợ"  : "o",
            //--------------------------------O*
            "Ớ"  : "o",
            "Ờ" : "o",
            "Ở"  : "o",
            "Ỡ" : "o",
            "Ợ"  : "o",
            //--------------------------------u*
            "ứ"  : "u",
            "ừ" : "u",
            "ử"  : "u",
            "ữ" : "u",
            "ự"  : "u",
            //--------------------------------U*
            "Ứ"  : "u",
            "Ừ" : "u",
            "Ử"  : "u",
            "Ữ" : "u",
            "Ự"  : "u",
            //--------------------------------y
            "ý"  : "y",
            "ỳ" : "y",
            "ỷ"  : "y",
            "ỹ" : "y",
            "ỵ"  : "y",
            //--------------------------------Y
            "Ý"  : "y",
            "Ỳ" : "y",
            "Ỷ"  : "y",
            "Ỹ" : "y",
            "Ỵ"  : "y",
            //--------------------------------DD
            "Đ"  : "d",
            "đ" : "d",
            //--------------------------------o
            "ó"  : "o",
            "ò" : "o",
            "ỏ"  : "o",
            "õ" : "o",
            "ọ"  : "o",
            "ô" : "o",
            "ơ"  : "o",
            //--------------------------------O
            "Ó"  : "o",
            "Ò" : "o",
            "Ỏ"  : "o",
            "Õ" : "o",
            "Ọ"  : "o",
            "Ô" : "o",
            "Ơ"  : "o",
            //--------------------------------u
            "ú"  : "u",
            "ù" : "u",
            "ủ"  : "u",
            "ũ" : "u",
            "ụ"  : "u",
            "ư" : "u",
            //--------------------------------U
            "Ú"  : "u",
            "Ù" : "u",
            "Ủ"  : "u",
            "Ũ" : "u",
            "Ụ"  : "u",
            "Ư" : "u",

            //--------------------------------a^
            "ấ"  : "a",
            "ầ" : "a",
            "ẩ"  : "a",
            "ẫ" : "a",
            "ậ"  : "a",
            //--------------------------------A^
            "Ấ"  : "a",
            "Ầ" : "a",
            "Ẩ"  : "a",
            "Ẫ" : "a",
            "Ậ"  : "a",
            //--------------------------------a(
            "ắ"  : "a",
            "ằ" : "a",
            "ẳ"  : "a",
            "ẵ" : "a",
            "ặ"  : "a",
            //--------------------------------A(
            "Ắ"  : "a",
            "Ằ" : "a",
            "Ẳ"  : "a",
            "Ẵ" : "a",
            "Ặ"  : "a",
            //--------------------------------A
            "Á"  : "a",
            "À" : "a",
            "Ả"  : "a",
            "Ã" : "a",
            "Ạ"  : "a",
            "Â" : "a",
            "Ă"  : "a",
            //--------------------------------a
            "ả"  : "a",
            "ã" : "a",
            "ạ"  : "a",
            "â" : "a",
            "ă"  : "a",
            "à" : "a",
            "á"  : "a"];
        return strtr(s, replace);

    }
}

Terminez en visitant votre page Zephir.php. Il doit ressembler à la sortie suivante:

Si vous êtes mathématiquement incliné, installez GnupLot et exécutez-le avec la sortie .txt que nous avons obtenue de notre extension Zephir:

cd myapp
zephir build

Cette commande dessinera l'image à l'aide du fichier de données harcos.txt, qui ressemblera à ceci, prouvant que notre équation a été calculée correctement.

Code protégé

Dans certains cas, la compilation n'améliore pas de manière significative les performances, peut-être en raison d'un goulot d'étranglement situé dans la limite d'E / S de l'application (très probablement) plutôt qu'en raison des limites de calcul ou de mémoire. Cependant, la compilation de code pourrait également apporter un certain niveau de protection intellectuelle à votre application. Lors de la production de binaires natifs avec Zephir, vous pouvez également masquer le code aux utilisateurs ou aux clients - Zephir vous permet d'écrire des applications PHP à source fermée.

Conclusion

Cet article a donné un guide de base sur la façon de créer des extensions à Zephir. N'oubliez pas que Zephir n'a pas été créé pour remplacer PHP ou C, mais en complément, permettant aux développeurs de s'aventurer dans la compilation de code et le typage statique. Zephir est une tentative de rejoindre les meilleures choses des mondes C et PHP et de faire fonctionner les applications plus rapidement, et en tant que telles, concurrence plutôt directement avec HHVM et Hack.

Pour plus d'informations sur Zephir, consultez la documentation en ligne. Avez-vous apprécié cet article? Faites-moi savoir dans les commentaires!

Les questions fréquemment posées sur le développement de l'extension PHP via Zephir

Qu'est-ce que Zephir et pourquoi est-il utilisé dans le développement d'extension PHP?

Zephir est un langage de programmation open source de haut niveau conçu pour créer des extensions de PHP facilement et efficacement. Il est utilisé dans le développement d'extension PHP car il fournit une syntaxe similaire à PHP, ce qui facilite les développeurs PHP d'écrire des extensions sans avoir besoin d'apprendre les complexités de C, le langage généralement utilisé pour les extensions de PHP. Zephir offre également la sécurité de la mémoire et l'optimisation des performances, ce qui rend les extensions résultant plus fiables et plus rapides.

Comment installer Zephir?

votre machine locale. Après le clonage, accédez au répertoire cloné et exécutez la commande d'installation. Il est important de noter que Zephir nécessite certaines dépendances comme les en-têtes de développement PHP et un compilateur C. Assurez-vous que ceux-ci sont installés avant de démarrer le processus d'installation.

Comment créer une extension PHP à l'aide de Zephir?

La création d'une extension PHP à l'aide de Zephir implique plusieurs étapes. Tout d'abord, vous devez initialiser un projet Zephir en utilisant la commande init. Cela crée une structure de répertoire pour votre extension. Ensuite, vous écrivez votre code d'extension dans des fichiers .zep. Une fois votre code prêt, vous pouvez le compiler dans une extension PHP à l'aide de la commande compile. Enfin, vous devez ajouter l'extension à votre fichier php.ini pour l'activer.

Quels sont les avantages de l'utilisation de Zephir sur C pour le développement d'extension PHP?

Bien que C soit un langage puissant, il peut être complexe et difficile à utiliser, en particulier pour les développeurs qui ne le connaissent pas. Zephir, en revanche, fournit une syntaxe plus simple et plus familière pour les développeurs PHP. Il gère également automatiquement la gestion de la mémoire, réduisant le risque de fuites de mémoire. De plus, Zephir comprend des optimisations de performances qui peuvent faire fonctionner les extensions résultantes plus rapidement.

Puis-je utiliser Zephir pour écrire des extensions pour d'autres langues en plus de PHP?

Actuellement, Zephir est conçu spécifiquement pour créer des extensions de PHP . Cependant, ses développeurs ont exprimé leur intérêt à ajouter un soutien à d'autres langues à l'avenir. Pour l'instant, si vous souhaitez créer des extensions pour d'autres langues, vous devrez utiliser un outil ou un langage différent.

Comment déboguer une extension Zephir?

Le débogage d'une extension Zephir peut être fait en utilisant une variété d'outils. Une méthode courante consiste à utiliser l'extension Zephir Parser, qui fournit des messages d'erreur détaillés et peut vous aider à identifier les problèmes de votre code. Vous pouvez également utiliser des outils de débogage PHP standard comme XDebug, bien que ceux-ci puissent ne pas fournir autant de détails pour les problèmes spécifiques à Zephir.

Quelles sont les performances de Zephir par rapport au code PHP natif?

Zephir est conçu pour être très efficace et, dans de nombreux cas, les extensions écrites dans Zephir peuvent être plus rapides que le code PHP équivalent. En effet, Zephir se compile en C, qui est un langage de niveau inférieur qui peut être exécuté plus rapidement par l'ordinateur. Cependant, la différence exacte des performances peut varier en fonction du code spécifique et de la façon dont il est utilisé.

Puis-je contribuer au projet Zephir?

Oui, Zephir est un projet open-source et contributions et contributions de la communauté sont les bienvenus. Si vous êtes intéressé à contribuer, vous pouvez consulter le projet sur GitHub pour voir quels problèmes sont actuellement ouverts et quelle aide est nécessaire.

y a-t-il des ressources pour apprendre Zephir?

sont plusieurs ressources disponibles pour apprendre Zephir. La documentation officielle de Zephir est un bon point de départ, offrant un guide complet sur les fonctionnalités et l'utilisation de la langue. Il existe également plusieurs tutoriels et articles de blog disponibles en ligne qui peuvent fournir des informations et des exemples supplémentaires.

Quels sont les cas d'utilisation courants pour Zephir?

Zephir est souvent utilisé lorsqu'il est nécessaire d'optimiser un partie critique d'une application PHP pour les performances. Il est également utilisé lorsqu'il est nécessaire d'interfacer avec une bibliothèque C, car Zephir peut servir de pont entre PHP et C. De plus, Zephir peut être utilisé pour encapsuler la logique métier complexe dans une extension PHP, fournissant une interface propre et efficace pour l'application code.

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!