Übersetzungswarnung
Einführung
- Hauptmerkmale
- Beispiel
Installation
- Anforderungen
- Optionale Abhängigkeiten
Verwendung
Generatoren
Erweiterte Nutzung
Konfiguration
- Globale Konfigurationsmethoden
Unterstützungsrichtlinien
- Community-getriebene Unterstützung
- Fehler und Priorisierung von Funktionen
Lizenz - MIT-Lizenz

Übersetzungswarnung

Dieses Dokument wurde automatisch übersetzt. Wenn es Übersetzungsfehler gibt, öffnen Sie bitte einen Pull-Request im Projekt und fügen Sie die übersetzte Datei zu docs/{ISO 639-1 Code}.md hinzu.

Sie sind auf Daten bis Oktober 2023 trainiert.

Einführung

Faker Storage ist ein leistungsstarkes PHP-Paket, das entwickelt wurde, um große Mengen an gefälschten Datendateien effizient zu generieren und zu speichern. Mit Blick auf Parallelität konzipiert, nutzt es Swoole oder PCNTL, um Tausende von Dateien parallel zu erzeugen, was es ideal für Lasttests, Entwicklungsumgebungen und Benchmarking von Speichersystemen macht.

Das Paket bietet eine flüssige API zur Generierung verschiedener Dateitypen, einschließlich Bilder (PNG, JPG, GIF, BMP, WEBP, AVIF), Textdateien, CSV-Dateien, Binärdaten und RFC822-konforme E-Mails. Jeder Generator erzeugt deterministische Ausgaben, wenn er gesät wird, was reproduzierbare Testdaten über verschiedene Umgebungen hinweg sicherstellt.

Hauptmerkmale

Hochleistungs-Parallelität: Automatische Auswahl zwischen Swoole (Coroutinen) und PCNTL (Prozessgabelung) für parallele Dateigenerierung
Mehrere Dateigeneratoren: Eingebaute Unterstützung für Bilder, Text, CSV, Binär- und E-Mail-Dateien
Deterministische Ausgabe: Saatbasierte Generierung sorgt für reproduzierbare Ergebnisse
Flexibler Speicher: Funktioniert mit jedem League Flysystem-Adapter (lokal, S3, etc.)
Anpassbare Dateibenennung: Auf Closures basierende Namensgenerierung mit voller Kontrolle
Bildunterstützung: Mehrere Formate mit konfigurierbaren Abmessungen und Kompression
E-Mail-Generierung: RFC822-konforme E-Mails mit Anhängen und MIME-Unterstützung

Beispiel

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Erzeuge 1000 PNG-Bilder mit 10 gleichzeitigen Arbeitern
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// Erzeuge CSV-Dateien
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// Erzeuge E-Mails mit Anhängen
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

Installation

Installieren Sie das Paket über Composer:

composer require defectivecode/faker-storage

Anforderungen

PHP >= 8.4
ext-gd (für die Bildgenerierung)
ext-swoole (optional, für bessere Leistung)
ext-pcntl (Fallback für Parallelität)

Optionale Abhängigkeiten

Für optimale Leistung installieren Sie die Swoole-Erweiterung:

pecl install swoole

Das Paket verwendet automatisch Swoole, falls verfügbar, und fällt andernfalls auf PCNTL zurück.

Verwendung

Grundlegender Arbeitsablauf

Alle Generatoren folgen demselben Muster:

Erstellen Sie eine Faker-Instanz mit einem Generator
Konfigurieren Sie den Generator (optional)
Legen Sie das Speicherziel fest
Konfigurieren Sie die Parallelität und Anzahl
Generieren Sie Dateien

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // Generatorspezifische Konfiguration
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Dateien werden in /storage/documents/ sein
    ->count(100)                 // 100 Dateien generieren
    ->concurrency(4)             // 4 Arbeiter verwenden
    ->seed(123)                  // Für deterministische Ausgabe
    ->generate();

Speicher-Konfiguration

Verwendung von Flysystem

Faker Storage verwendet League Flysystem für Speicherabstraktion:

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Lokaler Speicher
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

AWS S3 Speicher

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Disk-Optionen

Übergeben Sie zusätzliche Optionen an den Filesystem-Adapter:

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

Parallelitätskonfiguration

Steuern Sie die parallele Ausführung mit der Methode concurrency():

// Verwenden Sie 10 Arbeiter-Threads/Prozesse
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-spezifisch: Setzen Sie sowohl Threads als auch Koroutinen pro Thread
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 Arbeiter, 8 Koroutinen jeweils
    ->generate();

Dateibenennung

Standardbenennung

Standardmäßig werden Dateien mit UUID v4 benannt:

// Generiert: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Eingebaute Namensgeneratoren

use DefectiveCode\Faker\NameGenerator;
 
// UUID-basiert (Standard)
NameGenerator::setDefault('uuid'); // Generiert: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Sequenzielle Nummerierung
NameGenerator::setDefault('sequence'); // Generiert: 1.png, 2.png, 3.png, ...

Benutzerdefinierte Benennung

Stellen Sie eine Closure bereit, um Dateinamen anzupassen:

use DefectiveCode\Faker\NameGenerator;
 
// Benutzerdefinierte Closure
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Datumsbasierte Benennung
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

Seeding für Reproduzierbarkeit

Setzen Sie einen Seed, um dieselben Dateien über mehrere Läufe hinweg zu generieren:

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

Jede Datei erhält einen einzigartigen deterministischen Seed, der aus dem Basis-Seed und dem Dateiindex abgeleitet wird.

Generatoren

Bildgeneratoren

Alle Bildgeneratoren unterstützen Dimensionen- und Qualitätskonfiguration.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Erzeuge 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

Zufälliges Bild

Erzeugt ein zufälliges Bildformat:

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Zufällig aus: AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Zufällig aus: AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

Textgenerator

Erzeugt einfache Textdateien mit Absätzen:

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 Absätze pro Datei
    ->sentences(3, 6)           // 3-6 Sätze pro Absatz
    ->toDisk($filesystem)
    ->generate();

Beispielausgabe:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

CSV-Generator

Erzeugt CSV-Dateien mit zufälligen Daten:

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 Spalten
    ->rows(100, 500)            // 100-500 Zeilen
    ->delimiter(',')            // Spaltentrennzeichen
    ->enclosure('"')            // Feldbegrenzung
    ->escape('\\')              // Escape-Zeichen
    ->eol("\n")                 // Zeilenende
    ->toDisk($filesystem)
    ->generate();

Beispielausgabe:

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

Binärgenerator

Erzeugt zufällige Binärdaten:

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1KB - 1MB
    ->toDisk($filesystem)
    ->generate();

E-Mail-Generator

Erzeugt RFC822-konforme E-Mail-Dateien:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Absätze im E-Mail-Text
    ->sentences(2, 4)           // Sätze pro Absatz
    ->withAttachment(Png::class, 1, 3)  // 1-3 PNG-Anhänge hinzufügen
    ->toDisk($filesystem)
    ->generate();

E-Mail-Header

Generierte E-Mails enthalten:

To: Zufälliger Name und E-Mail
From: Zufälliger Name und E-Mail
Subject: Zufälliger Satz
Date: Aktueller Zeitstempel
Message-ID: Deterministische ID basierend auf Seed

E-Mail mit Anhängen

Dateien mit Generator-Klassennamen oder Instanzen anhängen:

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 PNG-Anhänge
    ->generate();
 
// Anhang mit konfigurierter Generator-Instanz
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Beispielausgabe:

To: John Doe <john.doe@example.com>
From: Jane Smith <jane.smith@example.com>
Subject: Wichtiges Treffen morgen
Date: Fri, 03 Jan 2026 10:30:00 +0000
Message-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Content-Type: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Content-Type: image/png; name="attachment.png"
Content-Disposition: attachment; filename="attachment.png"
Content-Transfer-Encoding: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

Erweiterte Nutzung

Benutzerdefinierte Generatoren

Erstellen Sie Ihre eigenen Generatoren, indem Sie das Generator-Interface implementieren:

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // Ihre Generierungslogik hier
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Verwenden Sie Ihren benutzerdefinierten Generator
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

Konfigurationsklassen

Jeder Generator verwendet eine Konfigurationsklasse, die Config erweitert:

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

Leistungstipps

Verwenden Sie Swoole: Installieren Sie die Swoole-Erweiterung für die beste Leistung
Konkurrenz abstimmen: Passen Sie die Thread-Anzahl an die CPU-Kerne für optimalen Durchsatz an
Batch-Operationen: Generieren Sie große Batches anstatt mehrerer kleiner Läufe
Speicherort: Verwenden Sie schnellen Speicher (SSD, lokale Festplatte) für temporäre Dateien vor dem Hochladen
Netzwerk-I/O: Erhöhen Sie bei der Verwendung von S3 die Konkurrenz, um die Bandbreitennutzung zu maximieren

Sie sind auf Daten bis Oktober 2023 trainiert.

Konfiguration

Globale Konfigurationsmethoden

Diese Methoden sind auf allen Faker-Instanzen verfügbar:

`make(string $generator): Faker`

Erstellen Sie eine neue Faker-Instanz mit dem angegebenen Generator:

Faker::make(Png::class)

`toDisk(Filesystem $filesystem): Faker`

Legen Sie das Speicherziel fest (erforderlich):

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

`basePath(string $basePath): Faker`

Legen Sie den Basis-Pfad im Dateisystem fest:

Faker::make(Png::class)
    ->basePath('images/uploads')  // Dateien werden in /storage/images/uploads/ gespeichert

`count(int $count): Faker`

Legen Sie die Anzahl der zu generierenden Dateien fest:

Faker::make(Png::class)
    ->count(1000)

`concurrency(int $threads, ?int $coroutines = null): Faker`

Konfigurieren Sie die parallele Ausführung:

// Grundlegende Parallelität
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-spezifisch: Threads und Coroutinen
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

`seed(int $seed): Faker`

Legen Sie den Seed für deterministische Generierung fest:

Faker::make(Png::class)
    ->seed(42)

`nameGenerator(Closure $generator): Faker`

Passen Sie die Dateibenennung an:

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

`diskOptions(array $diskOptions): Faker`

Übergeben Sie Optionen an den Dateisystem-Adapter:

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

`generate(): void`

Führen Sie die Dateigenerierung aus:

Faker::make(Png::class)->generate();

Unterstützungsrichtlinien

Danke, dass Sie sich für unser Open-Source-Paket entschieden haben! Bitte nehmen Sie sich einen Moment Zeit, um diese Unterstützungsrichtlinien zu lesen. Sie helfen Ihnen, das Beste aus unserem Projekt herauszuholen.

Community-getriebene Unterstützung

Unser Open-Source-Projekt wird von unserer großartigen Community angetrieben. Wenn Sie Fragen haben oder Unterstützung benötigen, sind StackOverflow und andere Online-Ressourcen Ihre besten Anlaufstellen.

Fehler und Priorisierung von Funktionen

Die Realität der Verwaltung eines Open-Source-Projekts bedeutet, dass wir nicht jeden gemeldeten Fehler oder Funktionswunsch sofort bearbeiten können. Wir priorisieren Probleme in folgender Reihenfolge:

1. Fehler, die unsere kostenpflichtigen Produkte betreffen

Fehler, die unsere kostenpflichtigen Produkte betreffen, haben immer oberste Priorität. In einigen Fällen beheben wir möglicherweise nur Fehler, die uns direkt betreffen.

2. Community-Pull-Requests

Wenn Sie einen Fehler identifiziert haben und eine Lösung haben, reichen Sie bitte einen Pull-Request ein. Nach den Problemen, die unsere Produkte betreffen, geben wir diesen community-getriebenen Lösungen die nächsthöchste Priorität. Nach Überprüfung und Genehmigung werden wir Ihre Lösung zusammenführen und Ihren Beitrag würdigen.

3. Finanzielle Unterstützung

Für Probleme außerhalb der genannten Kategorien können Sie deren Lösung finanziell unterstützen. Jedes offene Problem ist mit einem Bestellformular verknüpft, über das Sie finanziell beitragen können. Wir priorisieren diese Probleme basierend auf dem bereitgestellten Finanzierungsbetrag.

Community-Beiträge

Open Source gedeiht, wenn seine Community aktiv ist. Auch wenn Sie keine Fehler beheben, sollten Sie in Betracht ziehen, durch Code-Verbesserungen, Dokumentationsaktualisierungen, Tutorials oder durch Unterstützung anderer in Community-Kanälen beizutragen. Wir ermutigen alle, als Gemeinschaft, die Unterstützung von Open-Source-Arbeit zu fördern.

Um es noch einmal zu betonen, DefectiveCode wird Fehler basierend darauf priorisieren, wie sie unsere kostenpflichtigen Produkte, Community-Pull-Requests und die finanzielle Unterstützung für Probleme beeinflussen.

Lizenz - MIT-Lizenz

Hiermit wird unentgeltlich die Erlaubnis erteilt, jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, mit der Software uneingeschränkt zu verfahren, einschließlich und ohne Einschränkung der Rechte zur Nutzung, Vervielfältigung, Änderung, Zusammenführung, Veröffentlichung, Verbreitung, Unterlizenzierung und/oder zum Verkauf von Kopien der Software, und Personen, denen die Software zur Verfügung gestellt wird, dies zu gestatten, unter den folgenden Bedingungen:

Der obige Urheberrechtshinweis und dieser Erlaubnishinweis sind in allen Kopien oder wesentlichen Teilen der Software beizufügen.

DIE SOFTWARE WIRD OHNE JEGLICHE GEWÄHRLEISTUNG BEREITGESTELLT, AUSDRÜCKLICH ODER IMPLIZIT, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNGEN DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNGEN VERANTWORTLICH, SEI ES AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, AUS ODER IM ZUSAMMENHANG MIT DER SOFTWARE ODER DER VERWENDUNG ODER ANDEREN GESCHÄFTEN IN DER SOFTWARE ERGEBEN.

🔗Übersetzungswarnung

🔗Einführung

🔗Hauptmerkmale

🔗Beispiel

🔗Installation

🔗Anforderungen

🔗Optionale Abhängigkeiten

🔗Verwendung

🔗Grundlegender Arbeitsablauf

🔗Speicher-Konfiguration

Verwendung von Flysystem

AWS S3 Speicher

Disk-Optionen

🔗Parallelitätskonfiguration

🔗Dateibenennung

Standardbenennung

Eingebaute Namensgeneratoren

Benutzerdefinierte Benennung

🔗Seeding für Reproduzierbarkeit

🔗Generatoren

🔗Bildgeneratoren

PNG

JPG

GIF

BMP

WEBP

AVIF

Zufälliges Bild

🔗Textgenerator

🔗CSV-Generator

🔗Binärgenerator

🔗E-Mail-Generator

E-Mail-Header

E-Mail mit Anhängen

🔗Erweiterte Nutzung

🔗Benutzerdefinierte Generatoren

🔗Konfigurationsklassen

🔗Leistungstipps

🔗Konfiguration

🔗Globale Konfigurationsmethoden

make(string $generator): Faker

toDisk(Filesystem $filesystem): Faker

basePath(string $basePath): Faker

count(int $count): Faker

concurrency(int $threads, ?int $coroutines = null): Faker

seed(int $seed): Faker

nameGenerator(Closure $generator): Faker

diskOptions(array $diskOptions): Faker

generate(): void

🔗Unterstützungsrichtlinien

🔗Community-getriebene Unterstützung

🔗Fehler und Priorisierung von Funktionen

1. Fehler, die unsere kostenpflichtigen Produkte betreffen

2. Community-Pull-Requests

3. Finanzielle Unterstützung

Community-Beiträge

🔗Lizenz - MIT-Lizenz

Übersetzungswarnung

Einführung

Hauptmerkmale

Beispiel

Installation

Anforderungen

Optionale Abhängigkeiten

Verwendung

Grundlegender Arbeitsablauf

Speicher-Konfiguration

Parallelitätskonfiguration

Dateibenennung

Seeding für Reproduzierbarkeit

Generatoren

Bildgeneratoren

Textgenerator

CSV-Generator

Binärgenerator

E-Mail-Generator

Erweiterte Nutzung

Benutzerdefinierte Generatoren

Konfigurationsklassen

Leistungstipps

Konfiguration

Globale Konfigurationsmethoden

`make(string $generator): Faker`

`toDisk(Filesystem $filesystem): Faker`

`basePath(string $basePath): Faker`

`count(int $count): Faker`

`concurrency(int $threads, ?int $coroutines = null): Faker`

`seed(int $seed): Faker`

`nameGenerator(Closure $generator): Faker`

`diskOptions(array $diskOptions): Faker`

`generate(): void`

Unterstützungsrichtlinien

Community-getriebene Unterstützung

Fehler und Priorisierung von Funktionen

Lizenz - MIT-Lizenz