json machine
1.2.0
Sehr einfach zu verwendender und speichereffizienter Drop-In-Ersatz für die ineffiziente Iteration großer JSON-Dateien oder Streams für PHP >=7.2. Siehe TL;DR. Keine Abhängigkeiten in der Produktion außer optional ext-json . README synchron mit dem Code
NEU in Version 1.2.0 – Rekursive Iteration
<?php
use JsonMachineItems;
// this often causes Allowed Memory Size Exhausted,
// because it loads all the items in the JSON into memory
- $users = json_decode(file_get_contents('500MB-users.json'));
// this has very small memory footprint no matter the file size
// because it loads items into memory one by one
+ $users = Items::fromFile('500MB-users.json');
foreach ($users as $id => $user) {
// just process $user as usual
var_dump($user->name);
} Ein wahlfreier Zugriff wie bei $users[42] ist noch nicht möglich. Verwenden Sie das oben genannte foreach und suchen Sie das Element oder verwenden Sie den JSON-Zeiger.
Zählen Sie die Elemente über iterator_count($users) . Denken Sie daran, dass das Ganze immer noch intern iteriert werden muss, um die Anzahl zu ermitteln, und dass es daher etwa genauso lange dauert wie das Iterieren und Zählen von Hand.
Erfordert ext-json , wenn es standardmäßig verwendet wird, nicht jedoch, wenn ein benutzerdefinierter Decoder verwendet wird. Siehe Decoder.
Folgen Sie CHANGELOG.
JSON Machine ist ein effizienter, benutzerfreundlicher und schneller JSON-Stream/Pull/Inkremental/Lazy-Parser (wie auch immer Sie ihn nennen) basierend auf Generatoren, die für unvorhersehbar lange JSON-Streams oder -Dokumente entwickelt wurden. Hauptmerkmale sind:
foreach . Keine Veranstaltungen und Rückrufe.json_decode , um JSON-Dokumentelemente zu dekodieren. Siehe Decoder. Nehmen wir an, dass fruits.json dieses riesige JSON-Dokument enthält:
// fruits.json
{
"apple" : {
"color" : " red "
},
"pear" : {
"color" : " yellow "
}
}Es kann folgendermaßen analysiert werden:
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruits.json ' );
foreach ( $ fruits as $ name => $ data ) {
// 1st iteration: $name === "apple" and $data->color === "red"
// 2nd iteration: $name === "pear" and $data->color === "yellow"
}Das Parsen eines JSON-Arrays anstelle eines JSON-Objekts folgt derselben Logik. Der Schlüssel in einem foreach ist ein numerischer Index eines Elements.
Wenn Sie es vorziehen, dass JSON Machine Arrays anstelle von Objekten zurückgibt, verwenden Sie new ExtJsonDecoder(true) als Decoder.
<?php
use JsonMachine JsonDecoder ExtJsonDecoder ;
use JsonMachine Items ;
$ objects = Items:: fromFile ( ' path/to.json ' , [ ' decoder ' => new ExtJsonDecoder ( true )]); Wenn Sie nur den Teilbaum results in dieser fruits.json iterieren möchten:
// fruits.json
{
"results" : {
"apple" : {
"color" : " red "
},
"pear" : {
"color" : " yellow "
}
}
} Verwenden Sie den JSON-Zeiger /results als pointer :
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruits.json ' , [ ' pointer ' => ' /results ' ]);
foreach ( $ fruits as $ name => $ data ) {
// The same as above, which means:
// 1st iteration: $name === "apple" and $data->color === "red"
// 2nd iteration: $name === "pear" and $data->color === "yellow"
}Notiz:
Der
resultswird nicht auf einmal in den Speicher geladen, sondern jeweils nur ein Element inresults. Es befindet sich immer jeweils ein Element im Speicher auf der Ebene/Unterstruktur, die Sie gerade durchlaufen. Somit ist der Speicherverbrauch konstant.
Die JSON-Pointer-Spezifikation ermöglicht auch die Verwendung eines Bindestrichs ( - ) anstelle eines bestimmten Array-Index. JSON Machine interpretiert es als Platzhalter, der mit jedem Array-Index (nicht mit jedem Objektschlüssel) übereinstimmt. Dadurch können Sie verschachtelte Werte in Arrays iterieren, ohne das gesamte Element zu laden.
Beispiel:
// fruitsArray.json
{
"results" : [
{
"name" : " apple " ,
"color" : " red "
},
{
"name" : " pear " ,
"color" : " yellow "
}
]
} Um alle Farben der Früchte zu durchlaufen, verwenden Sie den JSON-Zeiger "/results/-/color" .
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruitsArray.json ' , [ ' pointer ' => ' /results/-/color ' ]);
foreach ( $ fruits as $ key => $ value ) {
// 1st iteration:
$ key == ' color ' ;
$ value == ' red ' ;
$ fruits -> getMatchedJsonPointer () == ' /results/-/color ' ;
$ fruits -> getCurrentJsonPointer () == ' /results/0/color ' ;
// 2nd iteration:
$ key == ' color ' ;
$ value == ' yellow ' ;
$ fruits -> getMatchedJsonPointer () == ' /results/-/color ' ;
$ fruits -> getCurrentJsonPointer () == ' /results/1/color ' ;
}Sie können einen einzelnen Skalarwert an einer beliebigen Stelle im Dokument auf die gleiche Weise wie eine Sammlung analysieren. Betrachten Sie dieses Beispiel:
// fruits.json
{
"lastModified" : " 2012-12-12 " ,
"apple" : {
"color" : " red "
},
"pear" : {
"color" : " yellow "
},
// ... gigabytes follow ...
} Rufen Sie den Skalarwert des lastModified -Schlüssels wie folgt ab:
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruits.json ' , [ ' pointer ' => ' /lastModified ' ]);
foreach ( $ fruits as $ key => $ value ) {
// 1st and final iteration:
// $key === 'lastModified'
// $value === '2012-12-12'
}Wenn der Parser den Wert findet und an Sie weitergibt, stoppt er die Analyse. Wenn sich also ein einzelner Skalarwert am Anfang einer Gigabyte-großen Datei oder eines Streams befindet, erhält er in kürzester Zeit und nahezu ohne Speicherverbrauch den Wert vom Anfang.
Die offensichtliche Abkürzung ist:
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruits.json ' , [ ' pointer ' => ' /lastModified ' ]);
$ lastModified = iterator_to_array ( $ fruits )[ ' lastModified ' ];Der Zugriff auf einzelne Skalarwerte unterstützt auch Array-Indizes im JSON-Zeiger.
Es ist auch möglich, mehrere Teilbäume mithilfe mehrerer JSON-Zeiger zu analysieren. Betrachten Sie dieses Beispiel:
// fruits.json
{
"lastModified" : " 2012-12-12 " ,
"berries" : [
{
"name" : " strawberry " , // not a berry, but whatever ...
"color" : " red "
},
{
"name" : " raspberry " , // the same ...
"color" : " red "
}
],
"citruses" : [
{
"name" : " orange " ,
"color" : " orange "
},
{
"name" : " lime " ,
"color" : " green "
}
]
} Um alle Beeren und Zitrusfrüchte zu durchlaufen, verwenden Sie die JSON-Zeiger ["/berries", "/citrus"] . Die Reihenfolge der Zeiger spielt keine Rolle. Die Elemente werden in der Reihenfolge ihres Erscheinens im Dokument iteriert.
<?php
use JsonMachine Items ;
$ fruits = Items:: fromFile ( ' fruits.json ' , [
' pointer ' => [ ' /berries ' , ' /citruses ' ]
]);
foreach ( $ fruits as $ key => $ value ) {
// 1st iteration:
$ value == [ " name " => " strawberry " , " color " => " red " ];
$ fruits -> getCurrentJsonPointer () == ' /berries ' ;
// 2nd iteration:
$ value == [ " name " => " raspberry " , " color " => " red " ];
$ fruits -> getCurrentJsonPointer () == ' /berries ' ;
// 3rd iteration:
$ value == [ " name " => " orange " , " color " => " orange " ];
$ fruits -> getCurrentJsonPointer () == ' /citruses ' ;
// 4th iteration:
$ value == [ " name " => " lime " , " color " => " green " ];
$ fruits -> getCurrentJsonPointer () == ' /citruses ' ;
} Verwenden Sie RecursiveItems anstelle von Items , wenn die JSON-Struktur mit Items und JSON-Zeigern nur schwer oder gar nicht zu handhaben ist oder die einzelnen Elemente, die Sie iterieren, zu groß für die Handhabung sind. Andererseits ist es deutlich langsamer als Items , also bedenken Sie das.
Wenn RecursiveItems im JSON auf eine Liste oder ein Diktat trifft, gibt es eine neue Instanz von sich selbst zurück, über die dann iteriert werden kann und der Zyklus wiederholt wird. Daher wird niemals ein PHP-Array oder -Objekt zurückgegeben, sondern nur entweder Skalarwerte oder RecursiveItems . Kein JSON-Dikt und keine JSON-Liste werden jemals vollständig auf einmal in den Speicher geladen.
Sehen wir uns ein Beispiel mit vielen, vielen Benutzern und vielen, vielen Freunden an:
// users.json
[
{
"username" : " user " ,
"e-mail" : " [email protected] " ,
"friends" : [
{
"username" : " friend1 " ,
"e-mail" : " [email protected] "
},
{
"username" : " friend2 " ,
"e-mail" : " [email protected] "
}
]
}
] <?php
use JsonMachine RecursiveItems
$ users = RecursiveItems:: fromFile ( ' users.json ' );
foreach ( $ users as $ user ) {
/** @var $user RecursiveItems */
foreach ( $ user as $ field => $ value ) {
if ( $ field === ' friends ' ) {
/** @var $value RecursiveItems */
foreach ( $ value as $ friend ) {
/** @var $friend RecursiveItems */
foreach ( $ friend as $ friendField => $ friendValue ) {
$ friendField == ' username ' ;
$ friendValue == ' friend1 ' ;
}
}
}
}
}Wenn Sie eine Iteration einer solchen faulen tieferen Ebene unterbrechen (d. h. Sie überspringen einige
"friends"überbreak) und zu einem nächsten Wert (d. h. nextuser) fortfahren, können Sie sie später nicht mehr iterieren. Die JSON-Maschine muss es im Hintergrund iterieren, um den nächsten Wert lesen zu können. Ein solcher Versuch führt zu einer geschlossenen Generatorausnahme.
RecursiveItems toArray(): array Wenn Sie sicher sind, dass eine bestimmte Instanz von RecursiveItems auf eine speicherverwaltbare Datenstruktur zeigt (z. B. $friend), können Sie $friend->toArray() aufrufen und das Element wird in a materialisiert einfaches PHP-Array.
advanceToKey(int|string $key): scalar|RecursiveItems Wenn Sie nach einem bestimmten Schlüssel in einer Sammlung suchen (z. B. 'friends' in $user ), müssen Sie keine Schleife und keine Bedingung verwenden, um danach zu suchen. Stattdessen können Sie einfach $user->advanceToKey("friends") aufrufen. Es wird für Sie iterieren und den Wert an diesem Schlüssel zurückgeben. Anrufe können verkettet werden. Es unterstützt auch eine Array-ähnliche Syntax zum Vorrücken und Abrufen folgender Indizes. $user['friends'] wäre also ein Alias für $user->advanceToKey('friends') . Anrufe können verkettet werden. Beachten Sie, dass es sich nur um einen Alias handelt. Sie können nicht wahlfrei auf frühere Indizes zugreifen, nachdem Sie dies direkt für RecursiveItems verwendet haben. Es ist nur ein Syntaxzucker. Verwenden Sie toArray() wenn Sie wahlfreien Zugriff auf Indizes für einen Datensatz/ein Element benötigen.
Das vorherige Beispiel könnte somit wie folgt vereinfacht werden:
<?php
use JsonMachine RecursiveItems
$ users = RecursiveItems:: fromFile ( ' users.json ' );
foreach ( $ users as $ user ) {
/** @var $user RecursiveItems */
foreach ( $ user [ ' friends ' ] as $ friend ) { // or $user->advanceToKey('friends')
/** @var $friend RecursiveItems */
$ friendArray = $ friend -> toArray ();
$ friendArray [ ' username ' ] === ' friend1 ' ;
}
}Durch die Verkettung können Sie Folgendes tun:
<?php
use JsonMachine RecursiveItems
$ users = RecursiveItems:: fromFile ( ' users.json ' );
$ users [ 0 ][ ' friends ' ][ 1 ][ ' username ' ] === ' friend2 ' ;RecursiveItems implements RecursiveIterator So können Sie beispielsweise die in PHP integrierten Tools verwenden, um mit RecursiveIterator zu arbeiten, wie zum Beispiel:
Dies ist eine Möglichkeit, ein Element in einem JSON-Dokument anzusprechen. Sehen Sie sich den JSON-Zeiger RFC 6901 an. Dies ist sehr praktisch, da die JSON-Struktur manchmal tiefer geht und Sie einen Unterbaum und nicht die Hauptebene iterieren möchten. Sie geben also einfach den Zeiger auf das JSON-Array oder -Objekt (oder sogar auf einen Skalarwert) an, das Sie iterieren möchten, und schon kann es losgehen. Wenn der Parser auf die von Ihnen angegebene Sammlung trifft, beginnt die Iteration. Sie können es als pointer in allen Items::from* -Funktionen übergeben. Wenn Sie einen Zeiger auf eine nicht vorhandene Position im Dokument angeben, wird eine Ausnahme ausgelöst. Es kann auch für den Zugriff auf Skalarwerte verwendet werden. Der JSON-Zeiger selbst muss eine gültige JSON-Zeichenfolge sein . Der wörtliche Vergleich von Referenztokens (den Teilen zwischen Schrägstrichen) wird mit den JSON-Dokumentschlüsseln/Mitgliedsnamen durchgeführt.
Einige Beispiele:
| JSON-Zeigerwert | Werde es durchlaufen |
|---|---|
| (leerer String – Standard) | ["this", "array"] oder {"a": "this", "b": "object"} wird iteriert (Hauptebene) |
/result/items | {"result": {"items": ["this", "array", "will", "be", "iterated"]}} |
/0/items | [{"items": ["this", "array", "will", "be", "iterated"]}] (unterstützt Array-Indizes) |
/results/-/status | {"results": [{"status": "iterated"}, {"status": "also iterated"}]} (ein Bindestrich als Array-Index-Platzhalter) |
/ (Gotcha! – ein Schrägstrich gefolgt von einer leeren Zeichenfolge, siehe Spezifikation) | {"":["this","array","will","be","iterated"]} |
/quotes" | {"quotes"": ["this", "array", "will", "be", "iterated"]} |
Optionen können die Art und Weise ändern, wie ein JSON analysiert wird. Das Optionsfeld ist der zweite Parameter aller Items::from* -Funktionen. Verfügbare Optionen sind:
pointer – Eine JSON-Zeigerzeichenfolge, die angibt, welchen Teil des Dokuments Sie iterieren möchten.decoder – Eine Instanz der ItemDecoder Schnittstelle.debug – true oder false um den Debug-Modus zu aktivieren oder zu deaktivieren. Wenn der Debug-Modus aktiviert ist, stehen Daten wie Zeile, Spalte und Position im Dokument beim Parsen oder in Ausnahmen zur Verfügung. Das Deaktivieren des Debuggens bringt einen leichten Leistungsvorteil mit sich. Eine Stream-API-Antwort oder ein anderer JSON-Stream wird genauso analysiert wie eine Datei. Der einzige Unterschied besteht darin, dass Sie dafür Items::fromStream($streamResource) verwenden, wobei $streamResource die Stream-Ressource mit dem JSON-Dokument ist. Der Rest ist der gleiche wie beim Parsen von Dateien. Hier sind einige Beispiele beliebter HTTP-Clients, die Streaming-Antworten unterstützen:
Guzzle verwendet seine eigenen Streams, diese können jedoch durch Aufruf von GuzzleHttpPsr7StreamWrapper::getResource() wieder in PHP-Streams konvertiert werden. Übergeben Sie das Ergebnis dieser Funktion an die Funktion Items::fromStream , und schon sind Sie fertig. Siehe funktionierendes GuzzleHttp-Beispiel.
Als Iterator fungiert eine Stream-Antwort von Symfony HttpClient. Und da JSON Machine auf Iteratoren basiert, ist die Integration mit Symfony HttpClient sehr einfach. Siehe HttpClient-Beispiel.
debug ) Das Parsen großer Dokumente kann eine Weile dauern. Rufen Sie Items::getPosition() in Ihrem foreach auf, um die aktuelle Anzahl der verarbeiteten Bytes vom Anfang an zu erhalten. Der Prozentsatz lässt sich dann leicht als position / total * 100 berechnen. Um die Gesamtgröße Ihres Dokuments in Bytes herauszufinden, können Sie Folgendes überprüfen:
strlen($document) wenn Sie eine Zeichenfolge analysierenfilesize($file) wenn Sie eine Datei analysierenContent-Length HTTP-Header, wenn Sie eine HTTP-Stream-Antwort analysieren Wenn debug deaktiviert ist, gibt getPosition() immer 0 zurück.
<?php
use JsonMachine Items ;
$ fileSize = filesize ( ' fruits.json ' );
$ fruits = Items:: fromFile ( ' fruits.json ' , [ ' debug ' => true ]);
foreach ( $ fruits as $ name => $ data ) {
echo ' Progress: ' . intval ( $ fruits -> getPosition () / $ fileSize * 100 ) . ' % ' ;
} Items::from* -Funktionen akzeptieren auch decoder -Option. Es muss eine Instanz von JsonMachineJsonDecoderItemDecoder sein. Wenn keine angegeben ist, wird standardmäßig ExtJsonDecoder verwendet. Da json_decode verwendet wird, muss die PHP-Erweiterung ext-json vorhanden sein. Wenn json_decode nicht das tut, was Sie wollen, implementieren Sie JsonMachineJsonDecoderItemDecoder und erstellen Sie Ihr eigenes.
ExtJsonDecoder – Standard. Verwendet json_decode um Schlüssel und Werte zu dekodieren. Der Konstruktor hat die gleichen Parameter wie json_decode .
PassThruDecoder – Führt keine Dekodierung durch. Sowohl Schlüssel als auch Werte werden als reine JSON-Strings erzeugt. Nützlich, wenn Sie ein JSON-Element mit etwas anderem direkt in foreach analysieren und JsonMachineJsonDecoderItemDecoder nicht implementieren möchten. Seit 1.0.0 wird json_decode nicht verwendet.
Beispiel:
<?php
use JsonMachine JsonDecoder PassThruDecoder ;
use JsonMachine Items ;
$ items = Items:: fromFile ( ' path/to.json ' , [ ' decoder ' => new PassThruDecoder ]);ErrorWrappingDecoder – Ein Dekorator, der Dekodierungsfehler in DecodingError -Objekt einschließt und es Ihnen so ermöglicht, fehlerhafte Elemente zu überspringen, anstatt bei SyntaxError Ausnahme abzusterben. Beispiel: <?php
use JsonMachine Items ;
use JsonMachine JsonDecoder DecodingError ;
use JsonMachine JsonDecoder ErrorWrappingDecoder ;
use JsonMachine JsonDecoder ExtJsonDecoder ;
$ items = Items:: fromFile ( ' path/to.json ' , [ ' decoder ' => new ErrorWrappingDecoder ( new ExtJsonDecoder ())]);
foreach ( $ items as $ key => $ item ) {
if ( $ key instanceof DecodingError || $ item instanceof DecodingError) {
// handle error of this malformed json item
continue ;
}
var_dump ( $ key , $ item );
} Seit 0.4.0 erweitert jede Ausnahme JsonMachineException , sodass Sie diese abfangen können, um Fehler aus der JSON Machine-Bibliothek zu filtern.
Wenn irgendwo in einem JSON-Stream ein Fehler auftritt, wird SyntaxError Ausnahme ausgelöst. Das ist sehr unpraktisch, denn wenn in einem JSON-Element ein Fehler auftritt, können Sie den Rest des Dokuments aufgrund eines fehlerhaften Elements nicht analysieren. ErrorWrappingDecoder ist ein Decoder-Dekorator, der Ihnen dabei helfen kann. Wickeln Sie einen Decoder damit ein, und alle fehlerhaften Elemente, die Sie iterieren, werden Ihnen im foreach über DecodingError übergeben. Auf diese Weise können Sie diese überspringen und mit dem Dokument fortfahren. Siehe Beispiel in Verfügbare Decoder. Syntaxfehler in der Struktur eines JSON-Streams zwischen den iterierten Elementen lösen jedoch weiterhin SyntaxError Ausnahme aus.
Die Zeitkomplexität ist immer O(n)
TL;DR: Die Speicherkomplexität beträgt O(2)
JSON Machine liest jeweils 1 JSON-Element eines Streams (oder einer Datei) und generiert jeweils 1 entsprechendes PHP-Element. Dies ist die effizienteste Methode, denn wenn Sie beispielsweise 10.000 Benutzer in einer JSON-Datei hätten und diese mit json_decode(file_get_contents('big.json')) analysieren möchten, hätten Sie neben allen 10.000 auch die gesamte Zeichenfolge im Speicher PHP-Strukturen. Die folgende Tabelle zeigt den Unterschied:
| String-Elemente im Speicher gleichzeitig aufzeichnen | PHP-Elemente jeweils im Speicher dekodieren | Gesamt | |
|---|---|---|---|
json_decode() | 10000 | 10000 | 20000 |
Items::from*() | 1 | 1 | 2 |
Dies bedeutet, dass JSON Machine für jede Größe des verarbeiteten JSON konstant effizient ist. 100 GB kein Problem.
TL;DR: Die Speicherkomplexität beträgt O(n+1)
Es gibt auch eine Methode Items::fromString() . Wenn Sie gezwungen sind, eine große Zeichenfolge zu analysieren, und der Stream nicht verfügbar ist, ist JSON Machine möglicherweise besser als json_decode . Der Grund dafür ist, dass JSON Machine im Gegensatz zu json_decode immer noch die JSON-Zeichenfolge einzeln durchläuft und nicht alle resultierenden PHP-Strukturen auf einmal in den Speicher lädt.
Fahren wir mit dem Beispiel mit 10.000 Benutzern fort. Dieses Mal sind sie alle in einer Reihe in Erinnerung. Beim Dekodieren dieser Zeichenfolge mit json_decode werden 10.000 Arrays (Objekte) im Speicher erstellt und dann das Ergebnis zurückgegeben. JSON Machine hingegen erstellt eine einzelne Struktur für jedes gefundene Element in der Zeichenfolge und gibt sie an Sie zurück. Wenn Sie dieses Element verarbeiten und zum nächsten iterieren, wird eine weitere einzelne Struktur erstellt. Dies ist das gleiche Verhalten wie bei Streams/Dateien. Die folgende Tabelle relativiert das Konzept:
| String-Elemente im Speicher gleichzeitig aufzeichnen | PHP-Elemente jeweils im Speicher dekodieren | Gesamt | |
|---|---|---|---|
json_decode() | 10000 | 10000 | 20000 |
Items::fromString() | 10000 | 1 | 10001 |
Die Realität ist sogar noch besser. Items::fromString verbraucht etwa 5x weniger Speicher als json_decode . Der Grund dafür ist, dass eine PHP-Struktur viel mehr Speicher benötigt als ihre entsprechende JSON-Darstellung.
Einer der Gründe kann sein, dass die Elemente, die Sie durchlaufen möchten, in einem Unterschlüssel wie "results" enthalten sind, Sie aber vergessen haben, einen JSON-Zeiger anzugeben. Siehe Analysieren eines Teilbaums.
Der andere Grund kann sein, dass eines der von Ihnen iterierten Elemente selbst so groß ist, dass es nicht auf einmal entschlüsselt werden kann. Sie iterieren beispielsweise über Benutzer und einer von ihnen enthält Tausende von „Freund“-Objekten. Die effizienteste Lösung ist die Verwendung der rekursiven Iteration.
Dies bedeutet wahrscheinlich, dass eine einzelne JSON-Skalarzeichenfolge selbst zu groß ist, um in den Speicher zu passen. Zum Beispiel eine sehr große Base64-codierte Datei. In diesem Fall werden Sie wahrscheinlich immer noch Pech haben, bis JSON Machine die Ausgabe von Skalarwerten als PHP-Streams unterstützt.
composer require halaxa/json-machineKlonen Sie dieses Repository oder laden Sie es herunter und fügen Sie Folgendes zu Ihrer Bootstrap-Datei hinzu:
spl_autoload_register ( require ' /path/to/json-machine/src/autoloader.php ' );Klonen Sie dieses Repository. Diese Bibliothek unterstützt zwei Entwicklungsansätze:
Führen Sie composer run -l im Projektverzeichnis aus, um verfügbare Entwicklungsskripte anzuzeigen. Auf diese Weise können Sie einige Schritte des Build-Prozesses ausführen, beispielsweise Tests.
Installieren Sie Docker und führen Sie make im Projektverzeichnis auf Ihrem Hostcomputer aus, um verfügbare Entwicklungstools/-befehle anzuzeigen. Sie können alle Schritte des Build-Prozesses einzeln sowie den gesamten Build-Prozess auf einmal ausführen. Make führt grundsätzlich Composer-Entwicklungsskripte in Containern im Hintergrund aus.
make build : Führt den vollständigen Build aus. Der gleiche Befehl wird über GitHub Actions CI ausgeführt.
Gefällt Ihnen diese Bibliothek? Markieren Sie es, teilen Sie es, zeigen Sie es :) Probleme und Pull-Requests sind sehr willkommen.
Apache 2.0
Zahnradelement: Icons von TutsPlus von www.flaticon.com sind lizenziert von CC 3.0 BY
Inhaltsverzeichnis generiert mit markdown-toc
