Erste Schritte mit der PHP -Erweiterungsentwicklung über Zephir

Dieses Tutorial erklärt, wie eine PHP -Erweiterung mit einer neuen Sprache erstellt wird: Zephir, die C und Forran ähnelt. Sie können den vollständigen Quellcode von GitHub herunterladen. Wir haben das Konzept von Zephir schon einmal angesprochen. Wenn Sie also einen breiten Überblick erhalten möchten, sehen Sie uns unsere vorherigen Artikel an.

Zephir kann als eine hybride Sprache betrachtet werden, mit der Sie Code schreiben können, der wie PHP aussieht, aber dann mit nativem C zusammengestellt wird, was bedeutet, dass Sie eine Erweiterung daraus erstellen und mit sehr effizientem Code wegkommen können.

Key Takeaways

• Zephir ermöglicht es PHP -Entwicklern, effiziente Erweiterungen mit einer ähnlichen Syntax zu schreiben, die jedoch für eine verbesserte Leistung mit nativem C kompiliert wird.
• Um eine Zephir-Entwicklungsumgebung einzurichten, benötigen Sie spezifische Tools wie GCC, GNU MAKE, PHP-Entwicklungsheader, RE2C und JSON-C mit einer Empfehlung für ein Linux-basiertes System.
• Der Prozess des Erstellens einer PHP -Erweiterung in Zephir beinhaltet die Initialisierung eines Projekts, das Schreiben von Code in .zep -Dateien, das Kompilieren des Codes und die Konfiguration Ihrer PHP -Umgebung, um die neue Erweiterung einzuschließen.
• Zephir steigert nicht nur die Leistung, sondern bietet auch eine Möglichkeit, den Quellcode zu schützen, wodurch er zum Erstellen geschlossener Quell -PHP -Anwendungen geeignet ist.

Installation

, um eine PHP -Erweiterung zu erstellen und Zephir zu verwenden, benötigen Sie Folgendes:

• gcc> = 4.x/klang> = 3.x/vc 9
• gnu machen 3.81 oder später
• PHP -Entwicklungsheader und Tools
• re2c 0.13 oder später
• JSON-C

Die Installationsanweisungen variieren für jede Plattform. Ich vertraue daher, dass Sie wissen, wie Sie sie erhalten, wenn Sie einen Artikel mit einem so fortgeschrittenen Thema lesen. Für den Datensatz - ich empfehle die Verwendung eines Linux -basierten Systems zur Entwicklung von Zephir -Apps.

Sobald Sie die gesamte Voraussetzung erhalten haben

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

Es sollte automatisch installiert werden - versuchen Sie Zephir -Hilfe einzugeben. Wenn es nicht funktioniert, fügen Sie das Verzeichnis „Bin“ Ihrer Pfadumweltvariable hinzu. In meinem Fall:/home/duythien/App/Zephir/bin wie SO:

vi $HOME/.bash_profile

Anhängen des folgenden Exportbefehls:

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

Um die neuen Pfadeinstellungen zu überprüfen und die Installation zu testen, geben Sie ein:

echo $PATH
zephir help

Sie können sich über Zephir -Grundlagen und Syntax sowie über das Schreibsystem informieren und einige Demo -Skripte auf ihrer Website sehen.

Programmierung mit Zephir

Jetzt werden wir Zephir verwenden, um eine mathematische Gleichung zu überarbeiten, die C und Forran sehr gut verarbeiten. Das Beispiel ist eher esoterisch und wird nicht viel detailliert erklärt, außer um die Kraft von Zephir zu demonstrieren.

zeitabhängige Schrodinger-Gleichung mit endlicher Differenz

gelöst

Die zeitabhängige Schrödinger-Gleichung kann sowohl mit impliziten (großen Matrix-) als auch mit expliziten (LeaProg) -Methoden gelöst werden. Ich werde die explizite Methode verwenden.

Geben Sie zunächst den folgenden Befehl aus, um das Skelett der Erweiterung zu erstellen:

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

Wenn dieser Befehl abgeschlossen ist, wird im aktuellen Arbeitsverzeichnis ein Verzeichnis namens "MyApp" erstellt. Das sieht aus wie:

vi $HOME/.bash_profile

Erstellen Sie im Ordner "MyApp" eine Datei namens "quantum.zep" (die uns den MyAppquantum -Namespace gibt). Kopieren Sie den folgenden Code ein.

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

Wir haben viele PHP -Funktionen wie fopen (), sin (), fprintf () usw. verwendet - zögern Sie nicht, die Syntax zu untersuchen. Ich werde Ihnen auch noch ein Beispiel geben. Bei der Arbeit mit dem PHP -Rahmen von Phalcon ist die Funktion Phalcontag :: FriendlyTitle () ungültig, wenn Sie in Vietnamesisch oder Deutsch arbeiten. Dieses Beispiel, das weitaus einfacher als die obige Gleichung, erstellt die Datei Normalizechars.zep. Fügen Sie den folgenden Code in die Datei ein:

echo $PATH
zephir help

Jetzt müssen wir Zephir mitteilen, dass unser Projekt zusammengestellt werden muss und die Erweiterung erzeugt wird:

zephir init myapp

Zum ersten Mal wird eine Reihe interner Befehle ausgeführt, um den erforderlichen Code und Konfigurationen zu erstellen, um diese Klasse in die PHP -Erweiterung zu exportieren. Wenn alles gut läuft, sehen Sie die folgende Nachricht am Ende der Ausgabe:

kompilieren…

Installieren…
Erweiterung installiert!
Erweiterung = myapp.so zu Ihrem php.ini
hinzufügen Vergessen Sie nicht, Ihren Webserver
neu zu starten

Beachten Sie, dass Zephir in den Kinderschuhen in den Kinderschuhen möglich ist, auf Fehler und Probleme zu stoßen. Als ich das erste Mal versuchte, dies zu kompilieren, funktionierte es nicht. Ich habe die folgenden Befehle ausprobiert und schließlich zum Laufen gebracht:

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

Der letzte Befehl installiert das Modul im Ordner PHP -Erweiterungen (in meinem Fall:/usr/lib/php5/20121212/). Der letzte Schritt besteht darin, diese Erweiterung Ihrem Php.ini hinzuzufügen, indem Sie die folgende Zeile hinzufügen:

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;    

    }
}

starten Sie Apache neu, und wir sind fertig.

testen Sie den Code

Erstellen Sie nun eine neue Datei namens 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);

    }
}

Beenden Sie Ihre Zephir.php -Seite. Es sollte der folgenden Ausgabe ähnlich aussehen:

Wenn Sie mathematisch verbindlich sind, installieren Sie Gnuplot und führen Sie ihn mit der .txtausgabe aus, die wir aus unserer Zephir -Erweiterung erhalten haben:

cd myapp
zephir build

Dieser Befehl zeichnet das Bild mit der Datendatei harmos.txt, die so aussieht und beweist, dass unsere Gleichung ordnungsgemäß berechnet wurde.

geschützter Code

In einigen Fällen verbessert die Zusammenstellung die Leistung nicht signifikant, möglicherweise aufgrund eines Engpasses, der sich in der I/A -Grenze der Anwendung (sehr wahrscheinlich) und nicht aufgrund von Grenzen der Berechnung oder des Speichers befindet. Das Kompilierungscode könnte jedoch auch einen gewissen Schutz in intellektuellem Schutz in Ihrer Bewerbung bringen. Wenn Sie native Binärdateien mit Zephir produzieren, können Sie den Code auch vor Benutzern oder Kunden ausblenden - Zephir können Sie mit geschlossenen Quellen -PHP -Anwendungen schreiben.

Schlussfolgerung

Dieser Artikel gab eine grundlegende Anleitung zum Erstellen von Erweiterungen in Zephir. Denken Sie daran, Zephir wurde nicht zum Ersetzen von PHP oder C erstellt, sondern als Ergänzung zu ihnen, sodass Entwickler sich in die Codekompilierung und die statische Typisierung wagen können. Zephir ist ein Versuch, sich den besten Dingen aus den C- und PHP -Welten anzuschließen und die Anwendungen schneller laufen zu lassen, und konkurriert als solche eher direkt mit HHVM und Hack.

Weitere Informationen zu Zephir finden Sie in der Online -Dokumentation. Hat Ihnen dieser Artikel gefallen? Lass es mich in den Kommentaren wissen!

häufig gestellte Fragen zur Entwicklung der PHP -Erweiterung über Zephir

Was ist Zephir und warum wird es in der PHP-Erweiterungsentwicklung verwendet? Es wird in der PHP -Erweiterungsentwicklung verwendet, da es eine ähnliche Syntax wie PHP bietet, wodurch es den PHP -Entwicklern erleichtert wird, Erweiterungen zu schreiben, ohne die Komplexität von C zu lernen, die Sprache, die normalerweise für PHP -Erweiterungen verwendet wird. Zephir bietet auch Speichersicherheits- und Leistungsoptimierung, wodurch die resultierenden Erweiterungen zuverlässiger und schneller werden.

Wie installiere ich Zephir? Ihre lokale Maschine. Navigieren Sie nach dem Klonen zum geklonten Verzeichnis und führen Sie den Befehl Install aus. Es ist wichtig zu beachten, dass Zephir bestimmte Abhängigkeiten wie PHP -Entwicklungsheader und C -Compiler benötigt. Stellen Sie sicher, dass diese vor dem Start des Installationsprozesses installiert sind.

Wie erstelle ich eine PHP -Erweiterung mit Zephir? Zunächst müssen Sie ein Zephir -Projekt mit dem Init -Befehl initialisieren. Dies schafft eine Verzeichnisstruktur für Ihre Erweiterung. Als nächstes schreiben Sie Ihren Erweiterungscode in .zep -Dateien. Sobald Ihr Code fertig ist, können Sie ihn mit dem Befehl Compile in eine PHP -Erweiterung zusammenstellen. Schließlich müssen Sie die Erweiterung Ihrer Php.ini -Datei hinzufügen, um sie zu aktivieren.

Was sind die Vorteile der Verwendung von Zephir über C für die Entwicklung von PHP -Erweiterung? Zephir hingegen bietet eine einfachere, vertrautere Syntax für PHP -Entwickler. Es wird auch automatisch die Speicherverwaltung behandelt und das Risiko von Speicherlecks verringert. Darüber hinaus enthält Zephir Leistungsoptimierungen, mit denen die resultierenden Erweiterungen schneller laufen können. . Die Entwickler haben jedoch Interesse daran bekundet, in Zukunft andere Sprachen zu unterstützen. Wenn Sie Erweiterungen für andere Sprachen erstellen möchten, müssen Sie ein anderes Tool oder eine andere Sprache verwenden.

Wie kann ich eine Zephir -Erweiterung debuggen? mit einer Vielzahl von Werkzeugen erledigt. Eine gemeinsame Methode besteht darin, die Zephir -Parser -Erweiterung zu verwenden, die detaillierte Fehlermeldungen liefert und Ihnen dabei helfen kann, Probleme in Ihrem Code zu identifizieren. Sie können auch Standard-PHP-Debugging-Tools wie Xdebug verwenden, obwohl diese möglicherweise nicht so viele Details für zephirspezifische Probleme enthalten. ist so konzipiert, dass sie hocheffizient ist, und in vielen Fällen können Erweiterungen, die in Zephir geschrieben wurden, schneller sein als der äquivalente PHP -Code. Dies liegt daran, dass Zephir zu C kompiliert, eine Sprache auf niedrigerer Ebene, die schneller vom Computer ausgeführt werden kann. Der genaue Leistungsunterschied kann jedoch je nach dem spezifischen Code und der Art und Weise variieren.

Kann ich zum Zephir-Projekt beitragen? Aus der Community sind willkommen. Wenn Sie einen Beitrag leisten möchten, können Sie das Projekt auf GitHub überprüfen, um festzustellen, welche Probleme derzeit geöffnet sind und welche Hilfe benötigt wird. sind mehrere Ressourcen für das Erlernen von Zephir zur Verfügung. Die offizielle Zephir -Dokumentation ist ein guter Ausgangspunkt und bietet einen umfassenden Leitfaden für die Funktionen und die Verwendung der Sprache. Es gibt auch mehrere Tutorials und Blog -Beiträge online verfügbar, die zusätzliche Erkenntnisse und Beispiele liefern können.

Was sind einige gemeinsame Anwendungsfälle für Zephir? kritischer Teil einer PHP -Anwendung für die Leistung. Es wird auch verwendet, wenn es erforderlich ist, mit einer C -Bibliothek eine Schnittstelle zu haben, da Zephir als Brücke zwischen PHP und C dienen kann Code.

Das obige ist der detaillierte Inhalt vonErste Schritte mit der PHP -Erweiterungsentwicklung über Zephir. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!