CodeIgniter-Formularvalidierung: Von Anfang bis Ende

German (Deutsch) translation by Tatsiana Bochkareva (you can also view the original English article)

Als Entwickler von Webanwendungen ist die Formularvalidierung ein wesentlicher Bestandteil Ihrer Arbeit und sollte nicht unterschätzt werden, da sie zu Sicherheitslücken in Ihrer Anwendung führen könnte. Sie sollten es als ein Muss betrachten, wenn Sie bestrebt sind, ein professionelles Endbenutzererlebnis zu bieten.

In diesem Artikel werden wir die integrierte Formularvalidierungsbibliothek im CodeIgniter-Framework durchgehen.

Hier die Highlights des heutigen Artikels:

Grundlegende Formularvalidierung
Kaskadieren und Vorbereiten
Benutzerdefinierte Fehlermeldungen
Benutzerdefinierter Validierungsrückruf
Validierungskonfiguration

Gehen Sie die grundlegenden Validierungsregeln durch

In diesem Abschnitt gehen wir die grundlegenden Konzepte der Formularvalidierung in CodeIgniter durch.

Als Teil davon müssen wir Controller- und View-Dateien erstellen. Die Controller-Datei lädt die Validierungsbibliothek und führt Validierungsregeln für die übermittelten Formulardaten aus. Die View-Datei enthält den XHTML-Code des Formulars, und wir werden es für unsere Bedürfnisse einfach halten.

Lassen Sie uns fortfahren und diese beiden Dateien erstellen.

Erstellen Sie die Controller-Datei application/controllers/Validation.php mit folgendem Inhalt.

<?php
// application/controllers/Validation.php
defined('BASEPATH') OR exit('No direct script access allowed');

class Validation extends CI_Controller {
    public function __construct() 
    {
    	parent::__construct();
    
    	// load form and url helpers
    	$this->load->helper(array('form', 'url'));
    	
    	// load form_validation library
    	$this->load->library('form_validation');
    }
	
    public function basic()
    {
        // basic required field
        $this->form_validation->set_rules('text_field', 'Text Field One', 'required');
        
        // basic required field with minimum length
        $this->form_validation->set_rules('min_text_field', 'Text Field Two', 'required|min_length[8]');
        
        // basic required field with maximum length
        $this->form_validation->set_rules('max_text_field', 'Text Field Three', 'required|max_length[20]');
        
        // basic required field with exact length
        $this->form_validation->set_rules('exact_text_field', 'Text Field Four', 'required|exact_length[12]');
        
        // basic required field but alphabets only
        $this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required|alpha');
        
        // basic required field but alphanumeric only
        $this->form_validation->set_rules('alphanumeric_text_field', 'Text Field Six', 'required|alpha_numeric');
        
        // basic email field with email validation
        $this->form_validation->set_rules('valid_email_field', 'Email Field', 'required|valid_email');
        
        // password field with confirmation field matching
        $this->form_validation->set_rules('password_field', 'Password One', 'required');
        $this->form_validation->set_rules('password_confirmation_field', 'Password Confirmation Field', 'required|matches[password_field]');
        
        // basic required field with IPv4 validation
        $this->form_validation->set_rules('valid_ip_field', 'Valid IP Field', 'required|valid_ip[ipv4]');
        
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
	
    public function cascade()
    {
        // basic required field with cascaded rules
        $this->form_validation->set_rules('text_field', 'Text Field One', 'required|alpha|min_length[8]|max_length[20]');
         
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
	
    public function prep()
    {
        // basic required field with trim prepping applied
        $this->form_validation->set_rules('min_text_field', 'Text Field Two', 'trim|required|min_length[8]');
        
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
	
    public function custom_message()
    {
        // basic required field with trim prepping applied
        $this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required|alpha',
        	array('required'=>'Please enter Text Field Five!','alpha'=>'Only alphabets please!'));
        
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
	
    public function custom_rule()
    {
        // basic required field with trim prepping applied
        $this->form_validation->set_rules('text_field', 'Text Field Five', 'callback_custom_validation');
        
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
    
    public function custom_validation($field_value) 
    {
        if ($field_value == '' || $field_value == 'demo')
        {
        	$this->form_validation->set_message('custom_validation', "Come on, don't act like spammer!");
        	return FALSE;
        }
        else
        {
        	return TRUE;
        }
    }
    
    public function configuration()
    {
        // if you pass group id, only elements in that group will be validated
        // $this->form_validation->run('group_one')
        if ($this->form_validation->run() == FALSE)
        {
        	$this->load->view('validate_form');
        }
        else
        {
        	// load success template...
        	echo "It's all Good!";
        }
    }
}

Danach erstellen Sie die Ansichtsdatei application/views/validate_form.php ,wie unten gezeigt.

<html>
    <head>
	<title>Form Validation Example</title>
	<style>
	.field_title{font-size: 13px;font-family:Arial;width: 300px;margin-top: 10px}
	.form_error{font-size: 13px;font-family:Arial;color:red;font-style:italic}
	</style>
	</head>
	
	<body>
		<div class="form_error">
		  <?php echo validation_errors(); ?>
		</div>
		
		<?php echo form_open(); ?>
		
			<h2>Form Validation Example</h2>
		
			<div>
				<div class="field_title">Text Field One (Required)</div>
				<input type="text" name="text_field" value="<?php echo set_value('text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Text Field Two (Minimum length)</div>
				<input type="text" name="min_text_field" value="<?php echo set_value('min_text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Text Field Three (Maximum length)</div>
				<input type="text" name="max_text_field" value="<?php echo set_value('max_text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Text Field Four (Exact length)</div>
				<input type="text" name="exact_text_field" value="<?php echo set_value('exact_text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Text Field Five (Alphabets only)</div>
				<input type="text" name="alphabets_text_field" value="<?php echo set_value('alphabets_text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Text Field Six (Alphanumeric only)</div>
				<input type="text" name="alphanumeric_text_field" value="<?php echo set_value('alphanumeric_text_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Email Field</div>
				<input type="text" name="valid_email_field" value="<?php echo set_value('valid_email_field'); ?>" size="30" />
			</div>
			
			<div>
				<div class="field_title">Password Field</div>
				<input type="password" name="password_field" value="" size="30" />
			</div>
			
			<div>
				<div class="field_title">Password Confirmation Field</div>
				<input type="password" name="password_confirmation_field" value="" size="30" />
			</div>
			
			<div>
				<div class="field_title">IP Field</div>
				<input type="text" name="valid_ip_field" value="<?php echo set_value('valid_ip_field'); ?>" size="30" />
			</div>
			
			<div class="field_title">
				<input type="submit" value="Submit" />
			</div>
		
		</form>
	</body>
</html>

Bei diesem Setup sollten Sie ein Formular sehen, wenn Sie http://your-codeigniter-site/validation/basic in Ihrem Browser ausführen. Versuchen Sie, es abzusenden, ohne eines der Formularfelder auszufüllen, und Sie sehen die Liste der Fehlermeldungen! Machen Sie sich keine Sorgen, wenn Sie nicht verstehen, wie es funktioniert, denn wir werden jeden Code im Detail durchgehen.

Die Geschichte beginnt mit der Methode __construct.

public function __construct() 
{
    parent::__construct();
    
    // load form and url helpers
    $this->load->helper(array('form', 'url'));
      
    // load form_validation library
    $this->load->library('form_validation');
}

Ich bevorzuge es immer, gängige Bibliotheken und Helfer in den Konstruktor des Controllers selbst zu laden, da es eine nette Angewohnheit ist, Codeduplizierung an anderer Stelle in Controller-Methoden zu vermeiden. Genau das haben wir oben getan – wir laden die form und url-Hilfsprogramme, damit wir die von diesen Hilfsprogrammen bereitgestellten Dienstprogrammmethoden für den Rest der Anwendung verwenden können.

Dann laden wir die Formularvalidierungsbibliothek, damit wir unsere Formularvalidierungsregeln an Formularelemente binden können, wie wir im nächsten Abschnitt sehen werden.

Gehen wir den Code der basic-Methode durch. Was macht diese Methode? Wenn Sie es mit der GET-Methode aufrufen, zeigt es das Formular an, und wenn es mit der POST-Methode aufgerufen wurde, wendet es Validierungsregeln auf die übermittelten Daten an und zeigt eventuelle Fehlermeldungen zusammen mit dem Formular an.

public function basic()
{
	// basic required field
	$this->form_validation->set_rules('text_field', 'Text Field One', 'required');
	
	// basic required field with minimum length
	$this->form_validation->set_rules('min_text_field', 'Text Field Two', 'required|min_length[8]');
	
	// basic required field with maximum length
	$this->form_validation->set_rules('max_text_field', 'Text Field Three', 'required|max_length[20]');
	
	// basic required field with exact length
	$this->form_validation->set_rules('exact_text_field', 'Text Field Four', 'required|exact_length[12]');
	
	// basic required field but alphabets only
	$this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required|alpha');
	
	// basic required field but alphanumeric only
	$this->form_validation->set_rules('alphanumeric_text_field', 'Text Field Six', 'required|alpha_numeric');
	
	// basic email field with email validation
	$this->form_validation->set_rules('valid_email_field', 'Email Field', 'required|valid_email');
	
	// password field with confirmation field matching
	$this->form_validation->set_rules('password_field', 'Password One', 'required');
	$this->form_validation->set_rules('password_confirmation_field', 'Password Confirmation Field', 'required|matches[password_field]');
	
	// basic required field with IPv4 validation
	$this->form_validation->set_rules('valid_ip_field', 'Valid IP Field', 'required|valid_ip[ipv4]');
	
	if ($this->form_validation->run() == FALSE)
	{
		$this->load->view('validate_form');
	}
	else
	{
		// load success template...
		echo "It's all Good!";
	}
}

Da wir die Formularvalidierungsbibliothek bereits im Konstruktor geladen haben, können Sie mit der Konvention $this->form_validation darauf zugreifen.

Die Methode set_rules wird verwendet, um eine Validierungsregel an ein Formularfeld zu binden. Im Allgemeinen braucht es drei Argumente:

Das erste Argument ist der Name eines Formularfelds.
Das zweite Argument ist ein Label, das verwendet wird, um auf ein Formularfeld zu verweisen, während die Fehlermeldung für dieses Feld angezeigt wird.
Das dritte Argument ist die Regel, die Sie auf ein Formularfeld anwenden möchten. Die Formularvalidierungsbibliothek enthält viele integrierte Regeln, die Sie bereits verwenden können.

Lassen Sie uns einige dieser Regeln durchgehen, wie wir sie in der Grundmethode verwendet haben.

Eine der am häufigsten verwendeten Regeln ist die required-Regel, die ein Formularfeld obligatorisch macht.

1	// basic required field
2	$this->form_validation->set_rules('text_field', 'Text Field One', 'required');

Wenn Sie dann ein Formularfeld mit einer bestimmten Länge erstellen möchten, können Sie die Regeln min_length und max_length verwenden.

// basic required field with minimum length
$this->form_validation->set_rules('min_text_field', 'Text Field Two', 'required|min_length[8]');
      
// basic required field with maximum length
$this->form_validation->set_rules('max_text_field', 'Text Field Three', 'required|max_length[20]');

Die erste stellt sicher, dass das Formularfeld min_text_field ein Pflichtfeld ist und der Benutzer darin mindestens acht Zeichen eingeben muss. Die zweite schränkt die maximale Anzahl von Zeichen ein, die in das Textfeld max_text_field eingegeben werden können, und macht es zusätzlich zu einem Pflichtfeld.

Sie haben vielleicht bemerkt, dass wir das | Operator, um mehrere Regeln gleichzeitig anzuwenden. Es heißt Kaskadierung, und wir werden später darauf zurückkommen.

Wenn Sie andererseits ein Formularfeld mit einer genauen Länge erstellen möchten, können Sie die Regel exact_length verwenden.

1	// basic required field with exact length
2	$this->form_validation->set_rules('exact_text_field', 'Text Field Four', 'required\|exact_length[12]');

Was ist, wenn Sie ein Formularfeld nur mit Alphabeten oder alphanumerischen Zeichen validieren möchten?

// basic required field but alphabets only
$this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required|alpha');
      
// basic required field but alphanumeric only
$this->form_validation->set_rules('alphanumeric_text_field', 'Text Field Six', 'required|alpha_numeric');

Der nächste Kandidat ist die E-Mail-Validierung.

1	// basic email field with email validation
2	$this->form_validation->set_rules('valid_email_field', 'Email Field', 'required\|valid_email');

Weiter können Sie mit der matches-Regel den Wert eines Formularfelds mit dem Wert eines anderen Formularfelds vergleichen. Das beste Beispiel dafür ist das Passwortfeld, das beim Absenden des Formulars mit dem Passwortbestätigungsfeld übereinstimmen muss.

// password field with confirmation field matching rule

$this->form_validation->set_rules('password_field', 'Password One', 'required');

$this->form_validation->set_rules('password_confirmation_field', 'Password Confirmation Field', 'required|matches[password_field]');

Das letzte Beispiel in unserer Basismethode befasst sich mit der Überprüfung der IP-Adresse.

Die valid_ip-Regel überprüft die IP-Adresse anhand des ersten übergebenen Arguments. Im folgenden Beispiel suchen wir nur nach IPv4-IP-Adressen!

1	// basic required field with IPv4 validation
2	$this->form_validation->set_rules('valid_ip_field', 'Valid IP Field', 'required\|valid_ip[ipv4]');

Soweit die grundlegende Validierung in CodeIgniter.

Wie man Kaskadieren und Vorbereiten funktioniert

In diesem Abschnitt untersuchen wir Kaskadierung und Vorbereitung, mit denen Sie mehrere Validierungsregeln auf einmal kombinieren können.

Tatsächlich würde ich sagen, dass wir in unseren früheren Beispielen die Kaskadierung gründlich genutzt haben. Erinnern Sie sich an den Pipe-Operator, der verwendet wurde, um mehrere Regeln zu kombinieren – und ja, die sogenannten kaskadierenden Validierungsregeln.

Holen Sie sich den Code der cascade-Methode.

public function cascade()
{
	// basic required field with cascaded rules
	$this->form_validation->set_rules('text_field', 'Text Field One', 'required|alpha|min_length[8]|max_length[20]');
	 
	if ($this->form_validation->run() == FALSE)
	{
		$this->load->view('validate_form');
	}
	else
	{
		// load success template...
		echo "It's all Good!";
	}
}

Wie im obigen Beispiel gezeigt, haben wir vier Validierungsregeln angewendet, die durch | getrennt sind -Operator in das Textfeld text_field. Es muss also jede einzelne Regel durchlaufen, damit die Formularvalidierung in diesem Fall erfolgreich ist!

Probieren Sie es aus und sehen Sie, wie es funktioniert!

Dann gibt es eine Vorbereitung, mit der Sie bestimmte Vorgänge auf die gesendeten Daten anwenden können. In den meisten Fällen möchten Sie führende und nachgestellte Leerzeichen in den vom Benutzer übermittelten Daten entfernen. Das erste, was Ihnen in diesem Fall wahrscheinlich in den Sinn kommt, ist die Trimmfunktion, und die gute Nachricht ist, dass Sie sie verwenden können!

Genau das macht unsere prep-Methode.

public function prep()
{
	// basic required field with trim prepping applied
	$this->form_validation->set_rules('min_text_field', 'Text Field Two', 'trim|required|min_length[8]');

	if ($this->form_validation->run() == FALSE)
	{
		$this->load->view('validate_form');
	}
	else
	{
		// load success template...
		echo "It's all Good!";
	}
}

Wie Sie sehen, haben wir zusätzlich zu den Validierungsregeln das Wort trim verwendet. Die Daten werden also zuerst getrimmt und durchlaufen dann die anderen Validierungsregeln. Tatsächlich können Sie jede PHP-Funktion verwenden, die gemäß der CodeIgniter-Dokumentation ein einzelnes Argument akzeptiert.

Versuchen Sie, unser Beispiel auszuführen, indem Sie einige nachgestellte Leerzeichen hinzufügen, und sehen Sie, wie es funktioniert.

Anpassen von Fehlermeldungen

Wenn Sie die obigen Beispiele ausführen konnten, ist Ihnen vielleicht aufgefallen, dass die dem Benutzer angezeigten Fehlermeldungen ziemlich systematisch und maschinell generiert werden. Vielleicht möchten Sie kreativer sein und sie in bestimmten Fällen ändern.

Sehen wir uns an, wie Sie die Fehlermeldung für jede Validierungsregel ändern können. Ziehen Sie den Code der Methode custom_message ein.

public function custom_message()
{
    // field with custom error message
	$this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required|alpha',
	  array('required'=>'Please enter Text Field Five!','alpha'=>'Only alphabets please!'));

	if ($this->form_validation->run() == FALSE)
	{
		$this->load->view('validate_form');
	}
	else
	{
		// load success template...
		echo "It's all Good!";
	}
}

Beachten Sie das vierte Argument, das der Methode set_rules übergeben wird. Es enthält ein Array von benutzerdefinierten Validierungsnachrichten für jede Validierungsregel, und der Schlüssel jedes Array-Elements ist die Validierungsregel selbst.

1	array(
2	'required'=>'Please enter Text Field Five!',
3	'alpha'=>'Only alphabets please!'
4	)

Probieren Sie es aus und Sie sollten unsere benutzerdefinierten Fehlermeldungen sehen! Ziemlich cool, oder?

Benutzerdefinierte Validierungsrückrufe

Obwohl die integrierte Validierungsbibliothek bereits eine Handvoll Validierungsregeln bereitstellt, müssen Sie in Ihrer täglichen Entwicklungsarbeit immer eine benutzerdefinierte erstellen. Genau das werden wir in diesem Abschnitt besprechen.

Um dies zu demonstrieren, erstellen wir einen benutzerdefinierten Validierungsrückruf, und später werden wir sehen, wie er zusammen mit der set_rules-Methode verwendet wird.

Werfen wir zunächst einen kurzen Blick auf die Methode custom_rule.

public function custom_rule()
{
    // field with custom validation callback passed
	$this->form_validation->set_rules('text_field', 'Text Field Five', 'callback_custom_validation');

	if ($this->form_validation->run() == FALSE)
	{
		$this->load->view('validate_form');
	}
	else
	{
		// load success template...
		echo "It's all Good!";
	}
}

Es unterscheidet sich nicht vom üblichen Methodenaufruf set_rules, außer dass wir den benutzerdefinierten Validierungsrückruf custom_validation anstelle einer Kernvalidierungsregel bereitgestellt haben. Wichtig ist hier, dass Sie dem benutzerdefinierten Validierungsrückruf callback_ voranstellen müssen, wenn Sie ihn als Argument übergeben.

Als Nächstes implementieren wir den benutzerdefinierten Validierungsrückruf.

public function custom_validation($field_value) 
{
	if ($field_value == '' || $field_value == 'demo')
	{
		$this->form_validation->set_message('custom_validation', "Come on, don't act like spammer!");
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}

Wenn Ihr benutzerdefinierter Validierungsrückruf aufgerufen wird, wird der vom Benutzer eingegebene Wert als erstes Argument übergeben. Der $field_value enthält also einen von einem Benutzer eingegebenen Wert, gegen den Sie Ihre benutzerdefinierte Validierungslogik implementieren können.

Im obigen Beispiel sollten Sie die Fehlermeldung sehen, wenn Sie entweder einen leeren Wert oder eine demo in das Textfeld Text Field Five eingeben. Beachten Sie, dass beim Festlegen der Fehlermeldung mit der Methode set_message das erste Argument der Name der benutzerdefinierten Rückrufmethode für die Validierung selbst ist.

Und das ist die Geschichte von Rückrufen zur benutzerdefinierten Validierung.

Last but not least verdient die Validierungskonfiguration einige Aufmerksamkeit, wenn wir uns dem Abschluss dieses Artikels nähern.

Validierungskonfiguration

Als CodeIgniter-Entwickler sollten Sie bereits mit dem config-Verzeichnis vertraut sein, mit dem Sie verschiedene Aspekte Ihrer CodeIgniter-Anwendung konfigurieren können.

Mit database.php können Sie beispielsweise die datenbankbezogenen Einstellungen definieren, während Sie mit autoload.php die Komponenten definieren können, die beim Bootstrapping einer Anwendung automatisch geladen werden sollen.

Auf die gleiche Weise könnten Sie die Datei form_validation.php im Verzeichnis config erstellen und diese Datei verwenden, um Validierungsregeln auf Anwendungsebene zu definieren, die global verwendet werden können. Wenn Ihnen das fremd vorkommt, gibt es keinen besseren Weg, es zu verstehen, als sich ein praktisches Beispiel anzusehen.

Erstellen Sie die Datei application/config/form_validation.php mit dem folgenden Inhalt.

<?php
$config = array(
    array(
        'field' => 'text_field',
        'label' => 'Text Field One',
        'rules' => 'required'
    ),
    array(
        'field' => 'min_text_field',
        'label' => 'Text Field Two',
        'rules' => 'required|min_length[8]'
    ),
    array(
        'field' => 'max_text_field',
        'label' => 'Text Field Three',
        'rules' => 'required|max_length[20]'
    )
);

Sehen wir uns nun kurz an, wie unsere configuration-Methode aussieht.

public function configuration()
{
    // if you pass group id, only elements in that group will be validated
    // $this->form_validation->run('group_one')
    if ($this->form_validation->run() == FALSE)
    {
    	$this->load->view('validate_form');
    }
    else
    {
    	// load success template...
    	echo "It's all Good!";
    }
}

Versuchen Sie, http://your-codigniter-site/validation/configuration auszuführen und senden Sie ein leeres Formular. Sie sehen Fehlermeldungen für drei Formularfelder! Aber warten Sie, woher kommen sie, da wir in unserer Konfigurationsmethode überhaupt keine Validierungsregeln eingerichtet haben?

Benutzer mit scharfen Augen hätten bemerkt, dass es automatisch aus der Validierungskonfigurationsdatei entnommen wird, die unter application/config/form_validation.php definiert ist. Ist das nicht erstaunlich? Es ermöglicht Ihnen, die Regeln an einem Ort zu zentralisieren und die Codeduplizierung in Aktionsmethoden zu reduzieren.

Tatsächlich können Sie die Regeln gruppieren und die Validierung nur auf die Felder einer bestimmten Gruppe anwenden. Mal sehen, wie das geht.

Ersetzen Sie den Code in application/config/form_validation.php durch den folgenden.

<?php
$config = array(
    'group_one' => array(
        array(
            'field' => 'text_field',
            'label' => 'Text Field One',
            'rules' => 'required'
        )
    ),
    'group_two' => array(
        array(
            'field' => 'min_text_field',
            'label' => 'Text Field Two',
            'rules' => 'required|min_length[8]'
        ),
        array(
            'field' => 'max_text_field',
            'label' => 'Text Field Three',
            'rules' => 'required|max_length[20]'
        )
    )
);

Suchen Sie in Ihrer configuration-Methode die folgende Zeile:

1	if ($this->form_validation->run() == FALSE)

Und ersetzen Sie es durch:

1	if ($this->form_validation->run('group_one') == FALSE)

Versuchen Sie nun, ein leeres Formular zu senden, und es wird nur für Text Field One ein Fehler angezeigt. Das liegt daran, dass wir group_one als Gruppen-ID übergeben haben, sodass nur die Elemente in dieser Gruppe validiert werden.

Lassen Sie uns abschließend einen Blick auf die Art der Konfiguration werfen, mit der Sie Regeln basierend auf der URL definieren können.

Ersetzen Sie den Code in application/config/form_validation.php durch den folgenden Code.

$config = array(
    'validation/configuration' => array(
        array(
            'field' => 'max_text_field',
            'label' => 'Text Field Three',
            'rules' => 'required|max_length[20]'
        )
    )
);

Bei dieser Art der Konfiguration müssen Sie eine Kombination aus dem Controllernamen und dem Methodennamen verwenden, getrennt durch das Zeichen /. Auf diese Weise können Sie Regeln für mehrere Aktionsmethoden gleichzeitig definieren.

Jetzt sollten Sie die Fehlermeldung für Text Field Three sehen, wenn Sie versuchen, ein leeres Formular unter http://your-codeigniter-site/validation/configuration einzureichen.

Und damit endet die Geschichte der Validierungskonfiguration und auch dieser Artikel!

Abschluss

In diesem Artikel haben wir die Formularvalidierung in CodeIgniter ausführlich besprochen.

Wir begannen unsere Reise mit den grundlegenden Validierungsregeln und wechselten dann zu fortgeschritteneren Themen wie Kaskadierung, Vorbereitung und Konfigurationsvalidierung.

Ich hoffe, Ihnen hat dieser Artikel gefallen und Sie können Ihre wertvollen Ansichten über den folgenden Feed teilen!

1	<?php
2	// application/controllers/Validation.php
3	defined('BASEPATH') OR exit('No direct script access allowed');
4
5	class Validation extends CI_Controller {
6	public function __construct()
7	{
8	parent::__construct();
9
10	// load form and url helpers
11	$this->load->helper(array('form', 'url'));
12
13	// load form_validation library
14	$this->load->library('form_validation');
15	}
16
17	public function basic()
18	{
19	// basic required field
20	$this->form_validation->set_rules('text_field', 'Text Field One', 'required');
21
22	// basic required field with minimum length
23	$this->form_validation->set_rules('min_text_field', 'Text Field Two', 'required\|min_length[8]');
24
25	// basic required field with maximum length
26	$this->form_validation->set_rules('max_text_field', 'Text Field Three', 'required\|max_length[20]');
27
28	// basic required field with exact length
29	$this->form_validation->set_rules('exact_text_field', 'Text Field Four', 'required\|exact_length[12]');
30
31	// basic required field but alphabets only
32	$this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required\|alpha');
33
34	// basic required field but alphanumeric only
35	$this->form_validation->set_rules('alphanumeric_text_field', 'Text Field Six', 'required\|alpha_numeric');
36
37	// basic email field with email validation
38	$this->form_validation->set_rules('valid_email_field', 'Email Field', 'required\|valid_email');
39
40	// password field with confirmation field matching
41	$this->form_validation->set_rules('password_field', 'Password One', 'required');
42	$this->form_validation->set_rules('password_confirmation_field', 'Password Confirmation Field', 'required\|matches[password_field]');
43
44	// basic required field with IPv4 validation
45	$this->form_validation->set_rules('valid_ip_field', 'Valid IP Field', 'required\|valid_ip[ipv4]');
46
47	if ($this->form_validation->run() == FALSE)
48	{
49	$this->load->view('validate_form');
50	}
51	else
52	{
53	// load success template...
54	echo "It's all Good!";
55	}
56	}
57
58	public function cascade()
59	{
60	// basic required field with cascaded rules
61	$this->form_validation->set_rules('text_field', 'Text Field One', 'required\|alpha\|min_length[8]\|max_length[20]');
62
63	if ($this->form_validation->run() == FALSE)
64	{
65	$this->load->view('validate_form');
66	}
67	else
68	{
69	// load success template...
70	echo "It's all Good!";
71	}
72	}
73
74	public function prep()
75	{
76	// basic required field with trim prepping applied
77	$this->form_validation->set_rules('min_text_field', 'Text Field Two', 'trim\|required\|min_length[8]');
78
79	if ($this->form_validation->run() == FALSE)
80	{
81	$this->load->view('validate_form');
82	}
83	else
84	{
85	// load success template...
86	echo "It's all Good!";
87	}
88	}
89
90	public function custom_message()
91	{
92	// basic required field with trim prepping applied
93	$this->form_validation->set_rules('alphabets_text_field', 'Text Field Five', 'required\|alpha',
94	array('required'=>'Please enter Text Field Five!','alpha'=>'Only alphabets please!'));
95
96	if ($this->form_validation->run() == FALSE)
97	{
98	$this->load->view('validate_form');
99	}
100	else
101	{
102	// load success template...
103	echo "It's all Good!";
104	}
105	}
106
107	public function custom_rule()
108	{
109	// basic required field with trim prepping applied
110	$this->form_validation->set_rules('text_field', 'Text Field Five', 'callback_custom_validation');
111
112	if ($this->form_validation->run() == FALSE)
113	{
114	$this->load->view('validate_form');
115	}
116	else
117	{
118	// load success template...
119	echo "It's all Good!";
120	}
121	}
122
123	public function custom_validation($field_value)
124	{
125	if ($field_value == '' \|\| $field_value == 'demo')
126	{
127	$this->form_validation->set_message('custom_validation', "Come on, don't act like spammer!");
128	return FALSE;
129	}
130	else
131	{
132	return TRUE;
133	}
134	}
135
136	public function configuration()
137	{
138	// if you pass group id, only elements in that group will be validated
139	// $this->form_validation->run('group_one')
140	if ($this->form_validation->run() == FALSE)
141	{
142	$this->load->view('validate_form');
143	}
144	else
145	{
146	// load success template...
147	echo "It's all Good!";
148	}
149	}
150	}