Einführung
- Hauptmerkmale
- Beispiel
Installation
- Anforderungen
- Optionale Abhängigkeiten
Verwendung
Generatoren
Erweiterte Verwendung
Konfiguration
- Globale Konfigurationsmethoden
Support Richtlinien
- Community-gesteuerte Unterstützung
- Bugs und Priorisierung von Funktionen
Lizenz - MIT Lizenz

Einführung

Faker Storage ist ein leistungsstarkes PHP-Paket, das entwickelt wurde, um eine große Menge an gefälschten Daten-Dateien effizient zu generieren und zu speichern. Mit dem Fokus auf Nebenläufigkeit genutzt, verwendet es Swoole oder PCNTL, um Tausende von Dateien parallel zu generieren, was es ideal für Lasttests, Entwicklungsumgebungen und Benchmarking von Speichersystemen macht.

Das Paket bietet eine flüssige API zur Generierung verschiedener Dateitypen, darunter Bilder (PNG, JPG, GIF, BMP, WEBP, AVIF), Textdateien, CSV-Dateien, Binärdaten und RFC822-konforme E-Mails. Jeder Generator produziert deterministischen Output, wenn er gesät wird, was reproduzierbare Testdaten über verschiedene Umgebungen hinweg gewährleistet.

Hauptmerkmale

Hochleistungsnebenläufigkeit: Automatische Auswahl zwischen Swoole (Korpora) und PCNTL (Prozessforking) für parallele Dateigenerierung
Mehrere Datei-Generatoren: Eingebaute Unterstützung für Bilder, Text, CSV, Binär- und E-Mail-Dateien
Deterministische Ausgabe: Saat-basierte Generierung gewährleistet reproduzierbare Ergebnisse
Flexibler Speicher: Funktioniert mit jedem League Flysystem-Adapter (lokal, S3 usw.)
Anpassbare Dateinamensgebung: Closure-basierte Namensgenerierung mit voller Kontrolle
Bildunterstützung: Mehrere Formate mit konfigurierbaren Dimensionen 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;
 
// Generiere 1000 PNG-Bilder mit 10 parallelen 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();
 
// Generiere 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();
 
// Generiere 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

Installiere 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 Nebenläufigkeit)

Optionale Abhängigkeiten

Für optimale Leistung, installiere die Swoole-Erweiterung:

pecl install swoole

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

Verwendung

Grundworkflow

Alle Generatoren folgen demselben Muster:

Erstelle ein Faker-Instanz mit einem Generator
Konfiguriere den Generator (optional)
Setze das Speicherziel
Konfiguriere Nebenläufigkeit und Anzahl
Generiere 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)          // Generator-spezifische Konfiguration
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Dateien werden in /storage/documents/ gespeichert
    ->count(100)                 // Generiere 100 Dateien
    ->concurrency(4)             // Verwende 4 Arbeiter
    ->seed(123)                  // Für deterministische Ausgabe
    ->generate();

Speicher-Konfiguration

Verwendung von Flysystem

Faker Storage verwendet League Flysystem zur 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

Übergebe zusätzliche Optionen an den Dateisystemadapter:

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

Nebenläufigkeitskonfiguration

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

// Verwende 10 Arbeiter-Threads/-prozesse
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-spezifisch: Setze sowohl Threads als auch Korpora pro Thread
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 Arbeiter, jeweils 8 Korpora
    ->generate();

Dateinamensgebung

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
 
// Sequentielle Nummerierung
NameGenerator::setDefault('sequence'); // Generiert: 1.png, 2.png, 3.png, ...

Benutzerdefinierte Benennung

Stelle 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();

Saatgutt für Reproduzierbarkeit

Setze einen Seed, um die gleichen Dateien über mehrere Durchläufe zu erzeugen:

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

Jede Datei erhält einen einzigartigen deterministischen Seed, der aus dem Basisseed und dem Dateindex abgeleitet wird.

Generatoren

Bildgeneratoren

Alle Bildgeneratoren unterstützen Dimensionierungs- 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 ein 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 ein 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 ein 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 ein 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 ein 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 ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

Zufälliges Bild

Generiert ein Bild im zufälligen Format:

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

Textgenerator

Generiere 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

Generiere 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(',')            // Spaltentrenner
    ->enclosure('"')            // Feldabschluss
    ->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

Generiere zufällige Binärdaten:

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

E-Mail-Generator

Generiere RFC822-konforme E-Mail-Dateien:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Absätze im E-Mail-Inhalt
    ->sentences(2, 4)           // Sätze pro Absatz
    ->withAttachment(Png::class, 1, 3)  // Füge 1-3 PNG-Anhänge hinzu
    ->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 dem Seed

E-Mail mit Anhängen

Hänge Dateien unter Verwendung von Generator-Klassennamen oder Instanzen an:

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();
 
// Anhängung mit einer konfigurierten 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: Wichtige Besprechung 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 Verwendung

Benutzerdefinierte Generatoren

Erstelle deine eigenen Generatoren, indem du die Generator-Schnittstelle implementierst:

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
    {
        // Deine Generierungslogik hier
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Verwende deinen benutzerdefinierten Generator
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

Konfiguration Klassen

Jeder Generator verwendet eine Konfigurationsklasse, die von Config erweitert wird:

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

Leistungstipps

Verwende Swoole: Installiere die Swoole-Erweiterung für die beste Leistung
Optimiere die Nebenläufigkeit: Passe die Anzahl der Threads an die CPU-Kerne für optimalen Durchsatz an
Batch-Betrieb: Generiere große Batches statt mehrere kleine Durchläufe
Speicherort: Verwende schnellen Speicher (SSD, lokale Festplatte) für temporäre Dateien vor dem Hochladen
Netzwerk I/O: Erhöhe bei der Verwendung von S3 die Nebenläufigkeit, um die Bandbreitenausnutzung zu maximieren

Konfiguration

Globale Konfigurationsmethoden

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

`make(string $generator): Faker`

Erstelle eine neue Faker-Instanz mit dem angegebenen Generator:

Faker::make(Png::class)

`toDisk(Filesystem $filesystem): Faker`

Setze das Speicherziel (erforderlich):

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

`basePath(string $basePath): Faker`

Setze den Basis-Pfad innerhalb des Dateisystems:

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

`count(int $count): Faker`

Setze die Anzahl der zu generierenden Dateien:

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

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

Konfiguriere die parallele Ausführung:

// Grundsätzliche Nebenläufigkeit
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-spezifisch: Threads und Korpora
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

`seed(int $seed): Faker`

Setze den Seed für deterministische Generierung:

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

`nameGenerator(Closure $generator): Faker`

Passe die Dateinamensgebung an:

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

`diskOptions(array $diskOptions): Faker`

Übergebe Optionen an den Dateisystemadapter:

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

`generate(): void`

Führe die Dateigenerierung aus:

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

Support Richtlinien

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

Community-gesteuerte Unterstützung

Unser Open-Source-Projekt wird von unserer großartigen Community unterstützt. Wenn Sie Fragen haben oder Hilfe benötigen, sind StackOverflow und andere Online-Ressourcen Ihre besten Optionen.

Bugs und Priorisierung von Funktionen

Die Realität des Managements eines Open-Source-Projekts bedeutet, dass wir nicht sofort jeden gemeldeten Fehler oder jede Funktionsanfrage angehen können. Wir priorisieren Probleme in der folgenden Reihenfolge:

1. Bugs, die unsere kostenpflichtigen Produkte betreffen

Bugs, die unsere kostenpflichtigen Produkte beeinträchtigen, haben immer die höchste Priorität. In einigen Fällen behandeln wir möglicherweise nur Bugs, die uns direkt betreffen.

2. Community Pull Requests

Wenn Sie einen Bug 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-gesteuerten Fehlerbehebungen die nächsthöchste Priorität. Sobald Ihr Lösungsvorschlag geprüft und genehmigt wurde, werden wir Ihre Lösung zusammenführen und Ihre Beiträge anerkennen.

3. Finanzielle Unterstützung

Für Probleme außerhalb der genannten Kategorien können Sie sich entscheiden, deren Lösung zu finanzieren. 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 Bugs beheben, ziehen Sie in Betracht, durch Codeverbesserungen, Dokumentationsaktualisierungen, Tutorials oder durch Unterstützung anderer in Community-Kanälen einen Beitrag zu leisten. Wir ermutigen alle, als Community zusammenzuarbeiten, um die Arbeit im Bereich Open Source zu unterstützen.

Nocht einmal: DefectiveCode wird Bugs priorisieren, basierend darauf, wie sie unsere kostenpflichtigen Produkte, Community-Pull-Requests und die finanzielle Unterstützung für Probleme beeinträchtigen.

Lizenz - MIT Lizenz

Hiermit wird jedermann, der eine Kopie dieser Software und der dazugehörigen Dokumentationsdateien (die "Software") erhält, kostenlos die Erlaubnis erteilt, die Software ohne Einschränkung zu nutzen, einschließlich, aber nicht beschränkt auf das Recht, die Software zu verwenden, zu kopieren, zu modifizieren, zusammenzuführen, zu veröffentlichen, zu vertreiben, Unterlizenzen zu erteilen und/oder Kopien der Software zu verkaufen, sowie Personen, denen die Software bereitgestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:

Die obige Urheberrechtshinweis und diese Erlaubnismitteilung sind in allen Kopien oder wesentlichen Teilen der Software enthalten.

DIE SOFTWARE WIRD "WIE BESEHEN" BEREITGESTELLT, OHNE GARANTIE IRGENDWELCHER ART, WEDER AUSDRÜCKLICH NOCH STILLSCHWEIGEND, EINSCHLIESSLICH, ABER NICHT BEGRENZT AUF DIE GARANTIEN DER MARKTFÄHIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR IRGENDEINEN ANSPRUCH, SCHÄDEN ODER ANDERE HAFTUNGEN HAFTBAR, OB IN EINER KLAUSEL FÜR VERTRAG, DELIKT ODER ANDERS, DIE AUS DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GEHEIMNISSEN IN DER SOFTWARE ENTSTEHEN.

🔗Einführung

🔗Hauptmerkmale

🔗Beispiel

🔗Installation

🔗Anforderungen

🔗Optionale Abhängigkeiten

🔗Verwendung

🔗Grundworkflow

🔗Speicher-Konfiguration

Verwendung von Flysystem

AWS S3 Speicher

Disk-Optionen

🔗Nebenläufigkeitskonfiguration

🔗Dateinamensgebung

Standardbenennung

Eingebaute Namensgeneratoren

Benutzerdefinierte Benennung

🔗Saatgutt 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 Verwendung

🔗Benutzerdefinierte Generatoren

🔗Konfiguration Klassen

🔗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

🔗Support Richtlinien

🔗Community-gesteuerte Unterstützung

🔗Bugs und Priorisierung von Funktionen

1. Bugs, die unsere kostenpflichtigen Produkte betreffen

2. Community Pull Requests

3. Finanzielle Unterstützung

Community-Beiträge

🔗Lizenz - MIT Lizenz

Einführung

Hauptmerkmale

Beispiel

Installation

Anforderungen

Optionale Abhängigkeiten

Verwendung

Grundworkflow

Speicher-Konfiguration

Nebenläufigkeitskonfiguration

Dateinamensgebung

Saatgutt für Reproduzierbarkeit

Generatoren

Bildgeneratoren

Textgenerator

CSV-Generator

Binärgenerator

E-Mail-Generator

Erweiterte Verwendung

Benutzerdefinierte Generatoren

Konfiguration Klassen

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`

Support Richtlinien

Community-gesteuerte Unterstützung

Bugs und Priorisierung von Funktionen

Lizenz - MIT Lizenz