Erste Schritte mit der PHP-Erweiterungsentwicklung über PHP-CPP

In Ihren Geschäften mit PHP können Sie selbst eine PHP -Erweiterung selbst schreiben. Es gibt mehrere Gründe, warum ich mir vorstellen kann, dass ich mich dazu motiviert:

• Die PHP -Funktionalität für eine ganz bestimmte Verwendung (Mathematik, Statistik, geometrische usw.) erweitern.
• eine höhere Leistung und Effizienz im Vergleich zu einer reinen PHP -Implementierung
• , um die Schnelligkeit zu nutzen,

Wenn es darum geht, ein Tool zum Erstellen von PHP -Erweiterungen auszuwählen, sehen wir zwei verschiedene Ansätze:

Verwenden Sie mehr Pro-Php-Semantik wie Zephir.
Verwenden Sie mehr Pro-C/C-Semantik wie PHP-CPP, die in diesem Artikel behandelt wird.

Für mich ist der Hauptantrieb zur Auswahl des zweiten Ansatzes einfach: Ich habe mein Programmierhobby mit C/C gestartet, daher fühle ich mich immer noch wohler, diese Module auf niedrigerer Ebene in C/C zu schreiben. Die offizielle Website von PHP-CPP gibt einige andere Gründe dafür.

Key Takeaways

PHP-CPP ist eine Bibliothek zur Entwicklung von PHP-Erweiterungen, mit der C-Entwickler PHP-Erweiterungen schreiben können, ohne dass die Komplexität der direkten Arbeit direkt mit der Zend-API arbeitet. Es ist in C 11 geschrieben und bietet eine Sammlung gut dokumentierter und benutzerfreundlicher Klassen.
PHP-CPP entwickelt sich rasant und es wird empfohlen, Git für die neuesten Updates zu klonen, um das Repository zu klonen. Es unterstützt Einzel-Thread-PHP-Installationen und erfordert ein Upgrade auf den G-Compiler auf Version 4.8.x oder höher für die Kompatibilität.
PHP-CPP bietet ein Skeleton-Erweiterungsprojekt, das eine Main.cpp-Datei, eine Datei zum Kompilieren der Erweiterung und eine .ini-Datei für das Laden der Erweiterung enthält. Das Skelettprojekt kann an individuelle Bedürfnisse angepasst und mit dem Befehl "make && sudo make make install" zusammengestellt und installiert werden.
PHP-CPP unterstützt vier Arten von Funktionssignaturen, die von PHP aufgerufen werden sollen, und ermöglicht die Übergabe von Parametern in einem Array-Formular. Es ermöglicht auch Funktionenxport/Registrierung, Spezifikation der Funktionsparametertypen und die Erstellung von objektorientierten Erweiterungen.

Installation und Konfiguration

PHP-CPP entwickelt sich schnell. Zum Zeitpunkt des Schreibens dieses Artikels befindet es sich in Version 0.9.1 (mit 0,9.0, die etwa 2 Tage zuvor veröffentlicht wurden). Laut der Dokumentation "Dies ist eine Feature-Freeze-Version, die sich auf die bevorstehende V1.0-Version vorbereitet" sind wir zuversichtlich, dass wir die 1.0-Hauptveröffentlichung in Kürze sehen werden.

Es wird daher zumindest während dieser Zwischenzeit empfohlen, Git zu verwenden, um das Repository zu klonen und das neueste Update später über Git Pull zu erhalten.

Hinweis: Die PHP-CPP-Dokumentation zur Installation besagt, dass sie vorerst „nur Einzel-Thread-PHP-Installationen unterstützt“, da „die Zend-Engine intern ein sehr seltsames System verwendet, um die Gewindesicherheit zu gewährleisten“. Zukünftige Veröffentlichungen können Multi-Thread-PHP-Installationen unterstützen, aber denken wir vorerst im Auge und halten uns an seine aktuelle Einschränkung. Zum Glück sollte „Single-Threaded-PHP-Installationen“ für die meisten PHP-Installationen der Fall der Fall sein.

PHP-CPP ist in C 11 geschrieben. Somit unterstützt die in meinem Ubuntu 12.04 LTS installierte ältere Version G nicht. Wir müssen unseren G -Compiler oben auf Version 4.8.x upgraden. Es gibt einen Artikel, in dem die Schritte zum Aufrüsten beschrieben werden. Bitte befolgen Sie die dort aufgeführten Anweisungen.

Außerdem verwendet die PHP-CPP-Kompilierung die Php.h-Header-Datei. Diese Datei fehlt normalerweise in einem Ubuntu-Box, es sei denn, Php-Dev wurde installiert. Wir können PHP5 -verwandte Entwicklungsdateien installieren, indem wir diesen Befehl ausgeben:

<span>sudo apt-get install php5-dev</span>

Nach dem Aktualisieren von G und der Installation der erforderlichen Header-Dateien können wir den folgenden Befehl zum Kompilieren und Installieren der PHP-CPP-Bibliotheksdatei (libPHPCPP.SO) ausstellen:

<span>make && sudo make install</span>

Die Zusammenstellung wird ziemlich schnell sein. Nach der Installation wird die Datei libPHPCPP.SO in/usr/lib und alle PHP-CPP-Header-Dateien in/usr/include und/usr/include/phpcpp kopiert.

.

Die Installation von PHP-CPP LIB ist jetzt vollständig. Es ist ziemlich einfach und wir können jetzt zum Programmierteil übergehen.

Bevor wir das tun, werden wir einige wichtige Konzepte und Terminologien diskutieren, die in PHP-CPP verwendet werden. Die vollständige Dokumentation finden Sie auf seiner offiziellen Website, und jeder wird ermutigt, sie vor dem Durchführen eines wirklichen Programms durchzulesen.

Skelett (leer) Erweiterungsprojektdateien

PHP-CPP bietet ein Skeleton-Erweiterungsprojekt mit den folgenden 3 Dateien:

main.cpp: Die Haupt -CPP -Datei mit einer Get_Module -Funktion (wird später ausführlicher besprochen)
Makefile: Die Beispiel -Datei machen Sie die Erweiterung
• zum Kompilieren

yourextesion.ini: Enthält nur eine Zeile für die Verlängerung des Ladens

Makefile

Wenn Sie mit *Nix -Entwicklung vertraut sind, sind Sie mit diesem Makefile vertraut. Es müssen einige geringfügige Änderungen vorgenommen werden, um diese Datei an unsere Anforderungen anzupassen:
• ändere name = yourextesion zu einem sinnvolleren wie name = skeletton.

ändern ini_dir = /etc/php5/conf.d, um die Konfiguration Ihres Systems zu entsprechen. In meinem Fall ist es ini_dir = /etc/php5/cli/conf.d. Ich habe den INI -Pfad geändert, um zuerst die Erweiterung für die CLI -Umgebung von PHP zu aktivieren.

Dies sind alle Änderungen, die ich vorgenommen habe. Der Rest des Makefile kann so aufbewahrt werden, wie er ist.

yourextesion.ini

Ich habe diese Datei in Skeletton.ini umbenannt und die einzige Zeile in dieser Datei wie folgt geändert:

<span>sudo apt-get install php5-dev</span>

main.cpp

In dem von PHP-CPP bereitgestellten leeren Projekt enthält diese Datei nur eine Funktion: get_module (), das unten auszugteil ist:

<span>make && sudo make install</span>

ändern wir vorerst diese Zeile so, dass sie mit dem Erweiterungsnamen übereinstimmen, den wir erstellen möchten:

<span>extension=skeleton.so</span>

get_module () wird von PHP aufgerufen, wenn letztere versucht, eine erforderliche Bibliothek zu laden. Es wird als Einstiegspunkt für eine LIB angesehen. Es wird unter Verwendung des externen "C" -Modifikators deklariert, um die Funktion von Get_Module () der PHP LIB -Anforderung zu erfüllen. Es verwendet auch ein Makro -PHPCPP_EXPORT, das sicherstellt

Bisher haben wir einige Änderungen am leeren Projekt vorgenommen, um unseren Bedürfnissen entspricht. Wir können dieses Projekt jetzt kompilieren und installieren und die Erweiterung installieren:

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

Als nächstes müssen wir die erforderlichen Dateien in die entsprechenden Ordner kopieren:

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

Wir müssen nur sicherstellen, dass das Skelett.so lib an den richtigen Ort der PHP -Erweiterungen kopiert wird (in meinem Ubuntu -Setup sollte es sein, wie oben gezeigt/usr/lib/php5/20121212).

Wir können dann überprüfen, ob die Erweiterung in CLI von Php -i | geladen ist Grep Skelett und das Terminal muss so etwas zeigen:

(erinnern Sie sich, dass das Skeletton.ini die oben geänderte Datei ist, die die Erweiterung = Skeletton.so Line enthält.)

Wir haben bisher unsere erste PHP-Erweiterung mit PHP-CPP zusammengestellt und installiert. Natürlich tut diese Erweiterung noch nichts. Wir werden nun unsere ersten Funktionen erstellen, um den Prozess des Erstellens von PHP -Erweiterungen weiter zu verstehen.

"Hallo, Taylor" -Funktion

Die erste Funktion, die wir erstellen, ist eine leicht modifizierte Version von „Hallo, Welt“. Sehen wir uns zuerst den vollständigen Code von main.cpp an:

<span>make && sudo make install</span>

Gemäß der PHP-CPP-Dokumentation zu „Native Funktionen registrieren“ unterstützt es vier Arten von Funktionssignaturen, die von PHP aufgerufen werden sollen:

<span>cp -f skeleton.so /usr/lib/php5/20121212
</span><span>cp -f skeleton.ini /etc/php5/cli/conf.d</span>

In diesem Fall verwende ich die zweite Signatur und die Parameter werden in einem Array -Formular (PHP -Funktion) nach Wert übergeben.

In HelloWorld haben wir jedoch speziell C -Typ STD :: String verwendet, um den ersten Parameter zu erfassen. Wir haben auch C std lib verwendet, um eine einladende Nachricht auszugeben.

In der Funktion get_module () fügen wir nach der Deklaration der Erweiterungsvariablen die Funktion hinzu, die wir exportieren möchten (HelloWorld ()) und dem PHP -Skript (HelloWorld) einen Namen zuweisen.

Lassen Sie uns nun die Erweiterung kompilieren und installieren. Wenn alles reibungslos verläuft, wird die neue Skeleton.SO -Datei in das Erweiterungsverzeichnis kopiert.

Wir können ein einfaches Skript schreiben, um die gerade erstellte Funktion zu testen:

<span><span>#include <phpcpp.h></span>
</span><span><span>#include <iostream></span>
</span>
<span>void helloWorld (Php::Parameters &params)
</span><span>{
</span>    std<span>::string name=params[0];
</span>    std<span>::cout<<"Hello "<<name<<"!"<<std::endl;
</span>
<span>}
</span>
<span>extern "C" {
</span>
    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>static Php::Extension extension("skeleton", "1.0");
</span>        extension<span>.add("helloWorld", helloWorld);
</span>
        <span>return extension;
</span>    <span>}
</span><span>}</span>

Nehmen Sie sich etwas Zeit, um sich die Ausgabe anzusehen:

Wir werden zu dem zurückkehren, was wir hier später beobachtet haben.

Funktionsparameter durch Referenz

Als nächstes werden wir eine andere Funktion sehen, die die Parameter durch Referenz, eine SWAP () -Funktion, übergibt. In dieser Funktion werden wir auch versuchen, die Anzahl der Parameter und deren Typ anzugeben.

In main.cpp fügen wir noch einen weiteren Funktionswap () hinzu:

<span>sudo apt-get install php5-dev</span>

und exportieren Sie die Funktion auch, indem Sie die Anzahl der Parameter und deren Typ angeben:

<span>make && sudo make install</span>

wir sagen ausdrücklich, dass:

• Es wird zwei Parameter (a und b);
geben
• Sie sollten mit Referenz übergeben werden (anstelle von Wert);
• Sie sollten vom Typ numerisch sein.

Lassen Sie uns die aktualisierte Erweiterung erneut kompilieren und installieren und einige Code -Snippets schreiben, um zu sehen, wie diese neuen Funktionen funktionieren:

<span>extension=skeleton.so</span>

Swap ($ A) fällt aus. Dies wird erwartet und unerwartet. Der erwartete Teil ist, dass wir zwei Parameter benötigen und nur einer gegeben ist. Aber sollte dieser Fehler nicht von PHP erfasst werden, wenn Sie den Funktionswechsel aufrufen und uns so etwas wie nicht genug Parameter veranlassen?

Der erste Anruf (Swap ($ A, $ b)) zeigt das erwartete Ergebnis: 20 | 10. Die Funktion tauscht die beiden übergebenen Zahlen aus.

Der zweite Anruf ist irgendwie unerwartet: Wir haben PHP mitgeteilt, dass wir zwei Zahlen austauschen sollen! Aber es ignoriert nur die Tatsache, dass der zweite Parameter eine Zeichenfolge ist und trotzdem der Austausch!

In gewisser Weise wird es immer noch erwartet. PHP unterscheidet einen Zahlentyp und einen String -Typ nicht wirklich. Dieses Verhalten entspricht dem PHP -Standard. Aufgrund dieses Verhaltens haben wir auch nicht C -Typen für die in der Funktion (TEMP) verwendete temporäre Variable nicht verwenden, aber php ::wert als variabler Typ verwendet.

Der dritte Anruf funktioniert. Der erste var_dump zeigt das DateTime -Objekt an und der zweite zeigt die Ganzzahl an. Dies ist irgendwie sehr unerwartet (zumindest für mich). Schließlich unterscheidet sich ein Objekt ganz anders als eine Zahl/eine Zeichenfolge. Nachdem dieses "Swap" -Verhalten in PHP auch machbar ist, passt es in die Kuriositäten von PHP.

Bedeutet dies, dass die Spezifikation "Typ" keine Auswirkungen hat? Nicht wirklich. Um dies weiter auszuarbeiten, erstellen wir eine dritte Funktion:

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

Und wir registrieren diese Funktion wie folgt:

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

Der Testcode ist wie folgt:

<span>make && sudo make install</span>

Der erste Aufruf von SwapObject () funktioniert, wie wir am richtigen Klassentyp (SampleClass) bestanden haben. Der zweite wird fehlschlagen und zeigt „PHP Catchable Fatal ERROR: Argument 1 an SwapObject () übergeben muss eine Instanz der Stichprobenklasse, Instanz einer anderen Klasse, die ...“.

Das obige Codesegment veranschaulicht einen wichtigen Aspekt bei der Typeinschränkung: Die Erklärung der Skalartypen wird nicht wirklich implementiert. PHP und damit PHP-CPP erzwingen nur die Erklärung vom Typ Objekt. Auch die Anzahl der Parameter wird auf der PHP -Seite nicht wirklich erzwungen.

Schlussfolgerung

In diesem Artikel haben wir die Schritte zur Vorbereitung von PHP-CPP für unsere PHP-Umgebung veranschaulicht. Wir haben auch einige grundlegende Schritte besprochen, um eine PHP-Erweiterung mit PHP-CPP (und C-Semantik) zu erstellen.

Wir haben die Erweiterungsprojektdateien, Funktionssignaturen, Funktionsexport/Registrierung und die Funktionsparametertypen abgedeckt.

In unserem nächsten Artikel werden wir einige wichtige Funktionen in PHP-CPP weiter ausarbeiten und einen realen Anwendungsfall bereitstellen, der die Verwendung von C-Klasse- und Namespace-Implementierungen unter Verwendung von PHP-CPP zeigt.

häufig gestellte Fragen (FAQs) zur Entwicklung der PHP -Erweiterung

Was ist PHP-CPP und wie unterscheidet es sich von PHP?

PHP-CPP ist eine Bibliothek zur Entwicklung von PHP-Erweiterungen. Es bietet eine Sammlung gut dokumentierter und benutzerfreundlicher Klassen, sodass C-Entwickler PHP-Erweiterungen schreiben können, ohne die Komplexität der direkten Arbeit mit der Zend-API zu schreiben. Im Gegensatz zu PHP, bei dem es sich um eine interpretierte Sprache handelt, können Sie mit PHP-CPP Code in C, eine kompilierte Sprache, schreiben. Dies kann zu Leistungsverbesserungen führen, da kompilierter Code im Allgemeinen schneller als interpretierter Code ausgeführt wird.

Wie installiere ich PHP-CPP auf meinem System? Muss das PHP-CPP-Repository aus GitHub klonen. Navigieren Sie nach dem Klonen zum Verzeichnis und führen Sie den Befehl "make" aus. Sobald der Build -Vorgang abgeschlossen ist, installieren Sie die Bibliothek mit dem Befehl "Installation erstellen". Denken Sie daran, Sie müssen Root-Berechtigungen haben, um die Bibliothek zu installieren. Zunächst müssen Sie ein Verzeichnis für Ihre Erweiterung erstellen und dazu navigieren. Erstellen Sie dann eine "Makefile" und eine C -Quelldatei für Ihre Erweiterung. Das „Makefile“ enthält Anweisungen zum Erstellen Ihrer Erweiterung, während die C -Quelldatei den tatsächlichen Code für Ihre Erweiterung enthält. Nachdem Sie Ihren Code geschrieben haben, können Sie Ihre Erweiterung mit dem Befehl 'make' erstellen.

Wie kann ich meine PHP -Erweiterung debuggen? Ich habe mich mit einer kompilierten Sprache um. Sie können jedoch Tools wie GDB (GNU -Debugger) verwenden, um Ihre Erweiterung zu debuggen. Mit GDB können Sie Breakpoints festlegen, Ihren Code durchlaufen und Variablen inspizieren. Dies kann sehr hilfreich sein, wenn Sie versuchen, Fehler aufzuspüren.

Ja, PHP-CPP ist mit Php 7 kompatibel. Sie müssen jedoch sicherstellen

Wie kann ich mit Ausnahmen in PHP-CPP umgehen? Diese Ausnahmen können dann in Ihrem PHP -Code gefangen und behandelt werden, genau wie jede andere PHP -Ausnahme.

Kann ich PHP-CPP verwenden, um objektorientierte Erweiterungen zu erstellen? Sie können Klassen in Ihrem C -Code definieren, und diese Klassen können dann in Ihrem PHP -Code verwendet werden. Auf diese Weise können Sie sauberen, modularen Code schreiben, der leicht zu warten ist.

Wie kann ich PHP-Funktionen aus meinem C-Code aufrufen? Sie können PHP -Funktionen aus Ihrem C -Code aufrufen. Auf diese Weise können Sie die Leistung der integrierten Funktionen von PHP in Ihrer Erweiterung nutzen.

Kann ich PHP-CPP verwenden, um Erweiterungen zu erstellen, die mit Datenbanken interagieren? CPP zum Erstellen von Erweiterungen, die mit Datenbanken interagieren. Sie müssen jedoch eine C-Datenbankbibliothek verwenden, da PHP-CPP keine integrierte Datenbankfunktionalität bereitstellt.

Wie kann ich meine PHP-Erweiterung verteilen? Wenn Sie Ihre PHP -Erweiterung erstellt haben, können Sie sie verteilen, indem Sie sie als PECL -Paket verpacken. PECL ist ein Repository für PHP -Erweiterungen und bietet eine Standardmethode zum Verteilen und Installieren von Erweiterungen.

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