verum php Download - verum php -Quellcode herunterladen

verum php

verum php ist eine serverseitige Validierungsbibliothek für PHP, mit der Sie Arrays (mit Dateiunterstützung) problemlos validieren können. Es enthält benutzerdefinierte Fehlermeldungen, Regeln, integrierte Übersetzungen und keine Abhängigkeiten.

Serverseitige Validierungsbibliothek für PHP

Arrays validieren (mit Dateiunterstützung)
Benutzerdefinierte Fehlermeldungen
Benutzerdefinierte Regeln
Integrierte Übersetzungen
Keine Abhängigkeiten

Inhaltsverzeichnis

Erste Schritte
Verwendung
Benutzerdefinierte Validierungen
Verfügbare Regeln
Mitwirken
Fragen
Lizenz

Erste Schritte

Installation

Installieren Sie verum php mit Composer

composer require sandromiguel/verum-php

Verwendung

Einfaches Anwendungsbeispiel

Bestätigen Sie ein einfaches Registrierungsformular (Name, E-Mail und Alter).

 use Verum  Validator ;

$ rules = [
    ' name ' => [
        ' rules ' => [
            ' required ' ,
        ],
    ],
    ' email ' => [
        ' rules ' => [
            ' required ' ,
            ' email ' ,
        ],
    ],
    ' age ' => [
        ' rules ' => [
            ' numeric ' ,
        ],
    ],
];

$ validator = new Validator ( $ _POST , $ rules );

echo json_encode (
    [
        ' valid '  => $ validator -> validate (),
        ' errors ' => $ validator -> getErrors (),
    ]
);

Beispiel für ein gültiges Formular

Eingang:

[
    'name' => 'John Doe',
    'email' => '[email protected]',
    'age' => '20',
]

Ausgabe:

{
    "valid" : true ,
    "errors" : []
}

Ungültiges Formularbeispiel

Eingang:

[
    'name' => '',
    'email' => 'some text',
    'age' => 'some text',
]

Ausgabe:

{
    "valid" : false ,
    "errors" : {
        "name" : {
            "label" : null ,
            "rules" : {
                "required" : " This field is required. "
            }
        },
        "email" : {
            "label" : null ,
            "rules" : {
                "email" : " This field must be a valid email address. "
            }
        },
        "age" : {
            "label" : null ,
            "rules" : {
                "numeric" : " This field must be numeric. "
            }
        }
    }
}

Verwenden Sie `RuleEnum` Klasse

Mit der RuleEnum -Klasse können Sie auf alle Regelnamen zugreifen.

 use Verum  Validator ;
use Verum  Enum  RuleEnum ;

$ rules = [
    ' name ' => [
        ' rules ' => [
            RuleEnum:: REQUIRED ,
        ],
    ],
    ...
];

Geben Sie die Feldbezeichnung an (Benennung der Eingaben).

 $ rules = [
    ' name ' => [
        ' label ' => ' Name ' ,
        ' rules ' => [
            RuleEnum:: REQUIRED ,
        ],
    ],
    ...
];

Ausgabe:

{
    ...
    "errors" : {
        "name" : {
            "label" : " Name " ,
            "rules" : {
                "required" : 'The "Name" field is required.'
            }
        },
        ...
    }
}

Geben Sie Feldbezeichnungen für jede Sprache an

 $ rules = [
    ' name ' => [
        ' label ' => [
            ' en ' => ' Name ' ,
            ' pt-pt ' => ' Nome ' ,
        ],
        ' rules ' => [
            RuleEnum:: REQUIRED ,
        ],
    ],
    ...
];

Ausgabe (pt-pt):

{
    ...
    "errors" : {
        "name" : {
            "label" : " Nome " ,
            "rules" : {
                "required" : 'O campo "Nome" é obrigatório.'
            }
        },
        ...
    }
}

Geben Sie die Sprache der Nachrichten an

Sie können einige integrierte Übersetzungen verwenden:

'en' -> Englisch (Standard)
'nl-nl' -> Niederländisch
'pt-pt' -> Portugiesisch-Portugal
'pt-br' -> Portugiesisch-Brasilien

 $ validator = new Validator ( $ _POST , $ rules , ' pt-pt ' );

Geben Sie die Nachrichtensprache mithilfe der `LangEnum` -Klasse an

 use Verum  Validator ;
use Verum  Enum  LangEnum ;

. . .

$ validator = new Validator ( $ _POST , $ rules , LangEnum:: PT_PT );

Geben Sie eine benutzerdefinierte Fehlermeldung an

Nützlich, um die Standardfehlermeldung zu überschreiben.
Nützlich für die Lokalisierung.

 . . .
$ validator = new Validator ( $ _POST , $ rules );
$ validator -> addSimpleCustomMessage ( ' min_length ' , ' Min Length rule custom error message ' );
. . .

Ausgabebeispiel:

{
    ...
    "errors" : {
        "name" : {
            "label" : " Name " ,
            "rules" : {
                "min_length" : " Min Length rule custom error message "
            }
        },
        ...
    }
}

Geben Sie eine benutzerdefinierte Fehlermeldung mit Platzhaltern an

 . . .
$ validator = new Validator ( $ _POST , $ rules );
$ validator -> addSimpleCustomMessage ( ' min_length ' , ' Number of characters detected: {param:1}. Field name: "{param:2}". ' );
. . .

Ausgabebeispiel:

{
    ...
    "errors" : {
        "name" : {
            "label" : " Name " ,
            "rules" : {
                "min_length" : 'Number of characters detected: 5. Field name: "Name".'
            }
        },
        ...
    }
}

Geben Sie eine benutzerdefinierte Fehlermeldung für Felder mit und ohne Beschriftung an

 . . .
$ validator = new Validator ( $ _POST , $ rules );
$ validator -> addCustomMessage (
    ' required ' ,
    ' Custom error message with label for required rule. Label: {param:1}. ' ,
    ' Custom error message without label for required rule. '
);
. . .

Ausgabe – Feld mit Beschriftung:

{
    ...
    "errors" : {
        "name" : {
            "label" : " Name " ,
            "rules" : {
                "required" : 'Custom error message with label for required rule. Label: Name.'
            }
        },
        ...
    }
}

Ausgabe - Feld ohne Beschriftung:

{
    ...
    "errors" : {
        "name" : {
            "label" : null ,
            "rules" : {
                "required" : " Custom error message without label for required rule. "
            }
        },
        ...
    }
}

Geben Sie mehrere benutzerdefinierte Fehlermeldungen gleichzeitig an

 . . .
$ validator = new Validator ( $ _POST , $ rules );
$ validator -> addCustomMessages (
    [
        ' min_length ' => ' Custom message for the "min_length" rule. ' ,
        ' required ' => ' Custom message for the "required" rule. ' ,
        // other messages ...
    ]
);
. . .

Geben Sie mehrere benutzerdefinierte Fehlermeldungen gleichzeitig für Felder mit und ohne Beschriftung an

 . . .
$ validator = new Validator ( $ _POST , $ rules );
$ validator -> addCustomMessages (
    [
        ' numeric ' => [
            ' withLabel ' => ' Custom message with label for "numeric" rule. Label: {param:1}. ' ,
            ' withoutLabel ' => ' Custom message without label for "numeric" rule. ' ,
        ],
        ' min_length ' => [
            ' withLabel ' => ' Custom message with label for "min_length" rule. Label: {param:2}, value: {param:1}. ' ,
            ' withoutLabel ' => ' Custom message without label for "min_length" rule. Value: {param:1}. ' ,
        ],
        // other messages ...
    ]
);
. . .

Umgang mit Feldern mit mehreren Namen

Mit verum php können Sie Felder mit mehreren Namen effektiver verarbeiten. Hierbei handelt es sich um Felder, die Sprachkennungen oder andere Variationen in ihren Namen enthalten. Wenn Sie beispielsweise Felder wie title.en , title.pt , description.en “ und description.pt haben, können Sie mithilfe von Platzhaltern Regeln für diese festlegen.

 $ rules = [
    ' title.* ' => [
        ' rules ' => [
            RuleEnum:: REQUIRED ,
        ],
    ],
    ' description.* ' => [
        ' rules ' => [
            RuleEnum:: REQUIRED ,
            RuleEnum:: MIN_LENGTH => 10 ,
        ],
    ],
];

$ validator = new Validator ( $ _POST , $ rules );
// ...

Ausgabebeispiel:

{
    "valid" : false ,
    "errors" : {
        "title.en" : {
            "label" : null ,
            "rules" : {
                "required" : " This field is required. "
            }
        },
        "title.pt" : {
            "label" : null ,
            "rules" : {
                "required" : " This field is required. "
            }
        },
        "description.en" : {
            "label" : null ,
            "rules" : {
                "required" : " This field is required. " ,
                "min_length" : " This field must be at least 10 characters long. "
            }
        },
        "description.pt" : {
            "label" : null ,
            "rules" : {
                "required" : " This field is required. " ,
                "min_length" : " This field must be at least 10 characters long. "
            }
        }
    }
}

Benutzerdefinierte Validierungen

Sie können Ihre benutzerdefinierten Validierungen verwenden und die Fehlermeldung einfügen.

 if ( $ myCustomValidationFail ) {
    $ validator -> addError (
        ' someFieldName ' ,
        ' Some field name ' ,
        [ ' no_duplicate ' => ' A user already exists with that username ' )]
    );
    // ...
}

Verfügbare Regeln

Alpha
alpha_numerisch
zwischen
between_length
boolescher_Wert
enthält
Datum
E-Mail
gleicht
file_max_size
file_mime_type
float_number
image_max_height
image_max_width
image_min_height
image_min_width
ganze Zahl
IP
IPv4
IPv6
max
max_length
min
min_länge
numerisch
Regex
erforderlich
Schnecke
URL

Alpha

Prüft, ob der Wert nur alphabetische Zeichen enthält.

 $ rules = [
    ' nickname ' => [
        ' label ' => ' Nickname ' ,
        ' rules ' => [
            RuleEnum:: ALPHA ,
        ],
    ],
];

Wert	Alpha	Alpha + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`	✔️	✔️
`'text with spaces'`

alpha_numerisch

Prüft, ob der Wert nur alphanumerische Zeichen enthält.

 $ rules = [
    ' nickname ' => [
        ' label ' => ' Nickname ' ,
        ' rules ' => [
            RuleEnum:: ALPHA_NUMERIC ,
        ],
    ],
];

Wert	alpha_numerisch	alpha_numerisch + erforderlich
`null`	✔️
`''`	✔️
`'0'`	✔️	✔️
`0`	✔️	✔️
`false`
`[]`
`-1`
`1`	✔️	✔️
`true`
`'text'`	✔️	✔️
`'text with spaces'`

zwischen

Prüft, ob der Wert zwischen zwei Werten liegt.

 $ rules = [
    ' age ' => [
        ' label ' => ' Age ' ,
        ' rules ' => [
            RuleEnum:: BETWEEN => [ 12 , 29 ],
        ],
    ],
];

Wert	zwischen [1, 10]	zwischen [1, 10] + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`	✔️	✔️
`true`
`'some text'`

between_length

Überprüft, ob die Anzahl der Zeichen des Werts zwischen den Mindest- und Höchstwerten liegt.

 $ rules = [
    ' nickname ' => [
        ' label ' => ' Nickname ' ,
        ' rules ' => [
            RuleEnum:: BETWEEN_LENGTH => [ 3 , 15 ],
        ],
    ],
];

Wert	between_length [5,25]	between_length [5,25] + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`12345`	✔️	✔️
`true`
`'text'`
`'text with 23 characters'`	✔️	✔️

boolescher_Wert

Prüft, ob der Wert ein boolescher Wert ist. Gibt true für 1/0, '1'/'0', 'on'/'off', 'yes'/'no', true/false zurück.

 $ rules = [
    ' light ' => [
        ' label ' => ' Light ' ,
        ' rules ' => [
            RuleEnum:: BOOLEAN_VALUE ,
        ],
    ],
];

Wert	boolescher_Wert	boolean_value + erforderlich
`null`	✔️
`''`	✔️
`'0'`	✔️	✔️
`0`	✔️	✔️
`false`	✔️	✔️
`[]`
`-1`
`'1'`	✔️	✔️
`1`	✔️	✔️
`true`	✔️	✔️
`'text'`
`'on'`	✔️	✔️
`'off'`	✔️	✔️
`'yes'`	✔️	✔️
`'no'`	✔️	✔️

enthält

Prüft, ob sich der Wert in einem Array befindet.

 $ rules = [
    ' priority ' => [
        ' label ' => ' Priority ' ,
        ' rules ' => [
            RuleEnum:: CONTAINS => [ ' low ' , ' high ' ],
        ],
    ],
];

Wert	enthält ['niedrig','hoch']	enthält ['low','high'] + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'low'`	✔️	✔️
`'high'`	✔️	✔️

Datum

Überprüft, ob der Wert ein gültiges Datum (Ymd) oder ein benutzerdefiniertes Format ist.

Standardformat (Ymd)

 $ rules = [
    ' dob ' => [
        ' label ' => ' Date of birth ' ,
        ' rules ' => [
            RuleEnum:: DATE ,
        ],
    ],
];

Benutzerdefiniertes Format (egdmY)

 $ rules = [
    ' dob ' => [
        ' label ' => ' Date of birth ' ,
        ' rules ' => [
            RuleEnum:: DATE => [ ' d.m.Y ' ],
        ],
    ],
];

Wert	Datum [Ymd]	Datum [Ymd] + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'2020-09-30'`	✔️	✔️

E-Mail

Überprüft, ob der Wert ein gültiges E-Mail-Format hat.

 $ rules = [
    ' email ' => [
        ' label ' => ' Email ' ,
        ' rules ' => [
            RuleEnum:: EMAIL ,
        ],
    ],
];

Wert	E-Mail	E-Mail + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'[email protected]'`	✔️	✔️

gleicht

Überprüft, ob der Wert einem anderen entspricht.

 $ rules = [
    ' repeat_password ' => [
        ' label ' => ' Repeat Password ' ,
        ' rules ' => [
            RuleEnum:: EQUALS => [ ' password ' ],
        ],
    ],
];

Vergleich mit 'text'

Wert	gleicht	gleich + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`	✔️	✔️
`'another text'`

file_max_size

Prüft, ob die Dateigröße einen bestimmten Wert nicht überschreitet.

Geben Sie einen Wert in Bytes ein.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: FILE_MAX_SIZE => [ 102400 ],
        ],
    ],
];

Vergleich mit 102400 Bytes

Wert	file_max_size	file_max_size + erforderlich
`null`	✔️
`50000`	✔️	✔️
`150000`

file_mime_type

Prüft, ob der Dateityp zulässig ist.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: FILE_MIME_TYPE => [ ' image/png ' , ' image/jpeg ' ],
        ],
    ],
];

Wert	file_mime_type	file_mime_type + erforderlich
`null`	✔️
`image/png`	✔️	✔️
`text/plain`

float_number

Prüft, ob der Wert eine Gleitkommazahl ist.

 $ rules = [
    ' price ' => [
        ' label ' => ' Price ' ,
        ' rules ' => [
            RuleEnum:: FLOAT_NUMBER ,
        ],
    ],
];

Wert	float_number	float_number + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`12345`
`123.45`	✔️	✔️
`true`
`'text'`
`'text with spaces'`

image_max_height

Überprüft, ob die Bildhöhe einen bestimmten Wert nicht überschreitet.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: IMAGE_MAX_HEIGHT => [ 600 ],
        ],
    ],
];

Wert	image_max_height	image_max_height + erforderlich
`null`	✔️
500px	✔️	✔️
1000px

image_max_width

Prüft, ob die Bildbreite einen vorgegebenen Wert nicht überschreitet.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: IMAGE_MAX_WIDTH => [ 1000 ],
        ],
    ],
];

Wert	image_max_width	image_max_width + erforderlich
`null`	✔️
500px	✔️	✔️
1500px

image_min_height

Prüft, ob die Bildhöhe nicht kleiner als ein vorgegebener Wert ist.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: IMAGE_MIN_HEIGHT => [ 300 ],
        ],
    ],
];

Wert	image_min_height	image_min_height + erforderlich
`null`	✔️
100px
500px	✔️	✔️

image_min_width

Überprüft, ob die Bildbreite nicht kleiner als ein vorgegebener Wert ist.

 $ rules = [
    ' profile_photo ' => [
        ' label ' => ' Profile Photo ' ,
        ' rules ' => [
            RuleEnum:: IMAGE_MIN_WIDTH => [ 500 ],
        ],
    ],
];

Wert	image_min_width	image_min_width + erforderlich
`null`	✔️
400px
600px	✔️	✔️

ganze Zahl

Überprüft, ob der Wert eine Ganzzahl ist.

 $ rules = [
    ' distance ' => [
        ' label ' => ' Distance ' ,
        ' rules ' => [
            RuleEnum:: INTEGER ,
        ],
    ],
];

Wert	numerisch	numerisch + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`	✔️	✔️
`false`
`[]`
`-1`	✔️	✔️
`1`	✔️	✔️
`true`
`'text'`

IP

Prüft, ob der Wert eine gültige IP-Adresse ist.

 $ rules = [
    ' ip ' => [
        ' label ' => ' IP ' ,
        ' rules ' => [
            RuleEnum:: IP ,
        ],
    ],
];

Wert	IP	IP + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'10.10.10.10'`	✔️	✔️
`'2607:f0d0:1002:51::4'`	✔️	✔️

IPv4

Überprüft, ob der Wert eine gültige IPv4-Adresse ist.

 $ rules = [
    ' ipv4 ' => [
        ' label ' => ' IPv4 ' ,
        ' rules ' => [
            RuleEnum:: IPV4 ,
        ],
    ],
];

Wert	IPv4	IPv4 + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'10.10.10.10'`	✔️	✔️
`'2607:f0d0:1002:51::4'`

IPv6

Überprüft, ob der Wert eine gültige IPv6-Adresse ist.

 $ rules = [
    ' ipv6 ' => [
        ' label ' => ' IPv6 ' ,
        ' rules ' => [
            RuleEnum:: IPV6 ,
        ],
    ],
];

Wert	IPv6	IPv6 + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'10.10.10.10'`
`'2607:f0d0:1002:51::4'`	✔️	✔️

max

Prüft, ob der Wert einen vorgegebenen Wert nicht überschreitet.

 $ rules = [
    ' people ' => [
        ' label ' => ' People ' ,
        ' rules ' => [
            RuleEnum:: MAX => [ 5 ],
        ],
    ],
];

Wert	max	max. + erforderlich
`null`	✔️
`''`	✔️
`'0'`	✔️	✔️
`0`	✔️	✔️
`false`
`[]`
`-1`	✔️	✔️
`1`	✔️	✔️
`true`
`'text'`
`12345`
`'12345'`

max_length

Prüft, ob die Anzahl der Zeichen des Werts einen vorgegebenen Wert nicht überschreitet.

 $ rules = [
    ' nickname ' => [
        ' label ' => ' Nickname ' ,
        ' rules ' => [
            RuleEnum:: MAX_LENGTH => [ 2 ],
        ],
    ],
];

Wert	max_length	max_length + erforderlich
`null`	✔️
`''`	✔️
`'0'`	✔️	✔️
`0`	✔️	✔️
`false`	✔️	✔️
`[]`
`-1`	✔️	✔️
`1`	✔️	✔️
`true`	✔️	✔️
`'text'`
`12345`
`'12345'`

min

Prüft, ob der Wert nicht kleiner als ein vorgegebener Wert ist.

 $ rules = [
    ' people ' => [
        ' label ' => ' People ' ,
        ' rules ' => [
            RuleEnum:: MIN => [ 2 ],
        ],
    ],
];

Wert	min	min + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`12345`	✔️	✔️
`'12345'`	✔️	✔️

min_länge

Prüft, ob die Anzahl der Zeichen des Werts nicht kleiner als ein angegebener Wert ist.

 $ rules = [
    ' nickname ' => [
        ' label ' => ' Nickname ' ,
        ' rules ' => [
            RuleEnum:: MIN_LENGTH => [ 2 ],
        ],
    ],
];

Wert	max_length	max_length + erforderlich
`null`	✔️
`''`
`'0'`
`0`
`false`
`[]`
`-1`	✔️	✔️
`1`
`true`
`'text'`	✔️	✔️
`12345`	✔️	✔️
`'12345'`	✔️	✔️

numerisch

Prüft, ob der Wert numerisch ist.

 $ rules = [
    ' age ' => [
        ' label ' => ' Age ' ,
        ' rules ' => [
            RuleEnum:: NUMERIC ,
        ],
    ],
];

Wert	numerisch	numerisch + erforderlich
`null`	✔️
`''`	✔️
`'0'`	✔️	✔️
`0`	✔️	✔️
`false`
`[]`
`-1`	✔️	✔️
`1`	✔️	✔️
`true`
`'text'`

Regex

Überprüft, ob der Wert mit einem bestimmten regulären Ausdruck übereinstimmt.

 $ rules = [
    ' path ' => [
        ' label ' => ' Path ' ,
        ' rules ' => [
            RuleEnum:: REGEX => [ ' //client/[0-9a-f]+$/ ' ],
        ],
    ],
];

Validierung mit dem Muster '//client/[0-9a-f]+$/'

Wert	Regex	Regex + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'/client/77c9e105d1f548b29958f0512967de87'`	✔️	✔️
`'/client/invalid-uuid'`

erforderlich

Prüft, ob der Wert nicht leer ist.

 $ rules = [
    ' name ' => [
        ' label ' => ' Name ' ,
        ' rules ' => [
            RuleEnum:: REQUIRED ,
        ],
    ],
];

Wert	erforderlich
`null`
`''`
`'0'`	✔️
`0`	✔️
`false`	✔️
`[]`
`-1`	✔️
`1`	✔️
`true`	✔️
`'some text'`	✔️

Schnecke

Überprüft, ob der Wert ein gültiger Slug ist (z. B. hello-world_123).

 $ rules = [
    ' slug ' => [
        ' label ' => ' Slug ' ,
        ' rules ' => [
            RuleEnum:: SLUG ,
        ],
    ],
];

Wert	Schnecke	Schnecke + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`	✔️	✔️
`'text with spaces'`
`'hello-world_123'`	✔️	✔️

URL

Prüft, ob der Wert eine gültige URL ist.

 $ rules = [
    ' url ' => [
        ' label ' => ' URL ' ,
        ' rules ' => [
            RuleEnum:: URL ,
        ],
    ],
];

Wert	URL	URL + erforderlich
`null`	✔️
`''`	✔️
`'0'`
`0`
`false`
`[]`
`-1`
`1`
`true`
`'text'`
`'http://www.some-domain.com'`	✔️	✔️

Mitwirken

Möchten Sie einen Beitrag leisten? Alle Beiträge sind willkommen. Lesen Sie den beitragenden Leitfaden.

Fragen

Wenn Sie Fragen haben, twittern Sie mich an @sandro_m_m oder eröffnen Sie ein Problem.

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der LIZENZ-Datei

**~ Teilen macht Spaß ~**

Expandieren

verum php

verum php

Inhaltsverzeichnis

Erste Schritte

Installation

Verwendung

Einfaches Anwendungsbeispiel

Beispiel für ein gültiges Formular

Ungültiges Formularbeispiel

Verwenden Sie RuleEnum Klasse

Geben Sie die Feldbezeichnung an (Benennung der Eingaben).

Geben Sie Feldbezeichnungen für jede Sprache an

Geben Sie die Sprache der Nachrichten an

Geben Sie die Nachrichtensprache mithilfe der LangEnum -Klasse an

Geben Sie eine benutzerdefinierte Fehlermeldung an

Geben Sie eine benutzerdefinierte Fehlermeldung mit Platzhaltern an

Geben Sie eine benutzerdefinierte Fehlermeldung für Felder mit und ohne Beschriftung an

Geben Sie mehrere benutzerdefinierte Fehlermeldungen gleichzeitig an

Geben Sie mehrere benutzerdefinierte Fehlermeldungen gleichzeitig für Felder mit und ohne Beschriftung an

Umgang mit Feldern mit mehreren Namen

Benutzerdefinierte Validierungen

Verfügbare Regeln

Alpha

alpha_numerisch

zwischen

between_length

boolescher_Wert

enthält

Datum

Standardformat (Ymd)

Benutzerdefiniertes Format (egdmY)

E-Mail

gleicht

file_max_size

file_mime_type

float_number

image_max_height

image_max_width

image_min_height

image_min_width

ganze Zahl

IP

IPv4

IPv6

max

max_length

min

min_länge

numerisch

Regex

erforderlich

Schnecke

URL

Mitwirken

Fragen

Lizenz

Verwenden Sie `RuleEnum` Klasse

Geben Sie die Nachrichtensprache mithilfe der `LangEnum` -Klasse an