The following options are supported for Zend_Validate_Barcode:

• adapter: Sets the barcode adapter which will be used. Supported are all above noted adapters. When using a self defined adapter, then you have to set the complete classname.

• checksum: TRUE when the barcode should contain a checksum. The default value depends on the used adapter. Note that some adapters don't allow to set this option.

• options: Defines optional options for a self written adapters.

To validate if a given string is a barcode you just need to know its type. See the following example for an EAN13 barcode:

$valid = new Zend_Validate_Barcode('EAN13');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Some barcodes can be provided with an optional checksum. These barcodes would be valid even without checksum. Still, when you provide a checksum, then you should also validate it. By default, these barcode types perform no checksum validation. By using the checksum option you can define if the checksum will be validated or ignored.

$valid = new Zend_Validate_Barcode(array(
    'adapter'  => 'EAN13',
    'checksum' => false,
));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

注意: Reduced security by disabling checksum validation

By switching off checksum validation you will also reduce the security of the used barcodes. Additionally you should note that you can also turn off the checksum validation for those barcode types which must contain a checksum value. Barcodes which would not be valid could then be returned as valid even if they are not.

You may write custom barcode validators for usage with Zend_Validate_Barcode; this is often necessary when dealing with proprietary barcode types. To write your own barcode validator, you need the following information.

• Length: The length your barcode must have. It can have one of the following values:

  • Integer: A value greater 0, which means that the barcode must have this length.

  • -1: There is no limitation for the length of this barcode.

  • "even": The length of this barcode must have a even amount of digits.

  • "odd": The length of this barcode must have a odd amount of digits.

  • array: An array of integer values. The length of this barcode must have one of the set array values.

• Characters: A string which contains all allowed characters for this barcode. Also the integer value 128 is allowed, which means the first 128 characters of the ASCII table.

• Checksum: A string which will be used as callback for a method which does the checksum validation.

Your custom barcode validator must extend Zend_Validate_Barcode_AdapterAbstract or implement Zend_Validate_Barcode_AdapterInterface.

As an example, let's create a validator that expects an even number of characters that include all digits and the letters 'ABCDE', and which requires a checksum.

class My_Barcode_MyBar extends Zend_Validate_Barcode_AdapterAbstract
{
    protected $_length     = 'even';
    protected $_characters = '0123456789ABCDE';
    protected $_checksum   = '_mod66';

    protected function _mod66($barcode)
    {
        // do some validations and return a boolean
    }
}

$valid = new Zend_Validate_Barcode('My_Barcode_MyBar');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

The following options are supported for Zend_Validate_Between:

• inclusive: Defines if the validation is inclusive the minimum and maximum border values or exclusive. It defaults to TRUE.

• max: Sets the maximum border for the validation.

• min: Sets the minimum border for the validation.

Per default this validator checks if a value is between min and max where both border values are allowed as value.

$valid  = new Zend_Validate_Between(array('min' => 0, 'max' => 10));
$value  = 10;
$result = $valid->isValid($value);
// returns true

In the above example the result is TRUE due to the reason that per default the search is inclusively the border values. This means in our case that any value from '0' to '10' is allowed. And values like '-1' and '11' will return FALSE.

Sometimes it is useful to validate a value by excluding the border values. See the following example:

$valid  = new Zend_Validate_Between(
    array(
        'min' => 0,
        'max' => 10,
        'inclusive' => false
    )
);
$value  = 10;
$result = $valid->isValid($value);
// returns false

The example is almost equal to our first example but we excluded the border value. Now the values '0' and '10' are no longer allowed and will return FALSE.

The following options are supported for Zend_Validate_Callback:

• callback: Sets the callback which will be called for the validation.

• options: Sets the additional options which will be given to the callback.

The simplest usecase is to have a single function and use it as a callback. Let's expect we have the following function.

function myMethod($value)
{
    // some validation
    return true;
}

To use it within Zend_Validate_Callback you just have to call it this way:

$valid = new Zend_Validate_Callback('myMethod');
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

PHP 5.3 introduces » closures, which are basically self-contained or anonymous functions. PHP considers closures another form of callback, and, as such, may be used with Zend_Validate_Callback. As an example:

$valid = new Zend_Validate_Callback(function($value){
    // some validation
    return true;
});

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Of course it's also possible to use a class method as callback. Let's expect we have the following class method:

class MyClass
{
    public function myMethod($value)
    {
        // some validation
        return true;
    }
}

The definition of the callback is in this case almost the same. You have just to create an instance of the class before the method and create an array describing the callback:

$object = new MyClass;
$valid = new Zend_Validate_Callback(array($object, 'myMethod'));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

You may also define a static method as a callback. Consider the following class definition and validator usage:

class MyClass
{
    public static function test($value)
    {
        // some validation
        return true;
    }
}

$valid = new Zend_Validate_Callback(array('MyClass', 'test'));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Finally, if you are using PHP 5.3, you may define the magic method __invoke() in your class. If you do so, simply providing an instance of the class as the callback will also work:

class MyClass
{
    public function __invoke($value)
    {
        // some validation
        return true;
    }
}

$object = new MyClass();
$valid = new Zend_Validate_Callback($object);
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Zend_Validate_Callback also allows the usage of options which are provided as additional arguments to the callback.

Consider the following class and method definition:

class MyClass
{
    function myMethod($value, $option)
    {
        // some validation
        return true;
    }
}

There are two ways to inform the validator of additional options: pass them in the constructor, or pass them to the setOptions() method.

To pass them to the constructor, you would need to pass an array containing two keys, "callback" and "options":

$valid = new Zend_Validate_Callback(array(
    'callback' => array('MyClass', 'myMethod'),
    'options'  => $option,
));

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

Otherwise, you may pass them to the validator after instantiation:

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

When there are additional values given to isValid() then these values will be added immediately after $value.

$valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
$valid->setOptions($option);

if ($valid->isValid($input, $additional)) {
    // input appears to be valid
} else {
    // input is invalid
}

When making the call to the callback, the value to be validated will always be passed as the first argument to the callback followed by all other values given to isValid(); all other options will follow it. The amount and type of options which can be used is not limited.

The following options are supported for Zend_Validate_CreditCard:

• service: A callback to an online service which will additionally be used for the validation.

• type: The type of creditcard which will be validated. See the below list of institutes for details.

There are several credit card institutes which can be validated by Zend_Validate_CreditCard. Per default, all known institutes will be accepted. See the folowing example:

$valid = new Zend_Validate_CreditCard();
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

The above example would validate against all known credit card institutes.

Sometimes it is necessary to accept only defined credit card institutes instead of all; e.g., when you have a webshop which accepts only Visa and American Express cards. Zend_Validate_CreditCard allows you to do exactly this by limiting it to exactly these institutes.

To use a limitation you can either provide specific institutes at initiation, or afterwards by using setType(). Each can take several arguments.

You can provide a single institute:

$valid = new Zend_Validate_CreditCard(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS
);

When you want to allow multiple institutes, then you can provide them as array:

$valid = new Zend_Validate_CreditCard(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

And as with all validators, you can also pass an associative array of options or an instance of Zend_Config. In this case you have to provide the institutes with the type array key as simulated here:

$valid = new Zend_Validate_CreditCard(array(
    'type' => array(Zend_Validate_CreditCard::AMERICAN_EXPRESS)
));

You can also set or add institutes afterward instantiation by using the methods setType(), addType() and getType().

$valid = new Zend_Validate_CreditCard();
$valid->setType(array(
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
    Zend_Validate_CreditCard::VISA
));

注意: Default institute

When no institute is given at initiation then ALL will be used, which sets all institutes at once.

In this case the usage of addType() is useless because all institutes are already added.

As said before Zend_Validate_CreditCard will only validate the credit card number. Fortunately, some institutes provide online APIs which can validate a credit card number by using algorithms which are not available to the public. Most of these services are paid services. Therefore, this check is deactivated per default.

When you have access to such an API, then you can use it as an addon for Zend_Validate_CreditCard and increase the security of the validation.

To do so, you simply need to give a callback which will be called when the generic validation has passed. This prevents the API from being called for invalid numbers, which increases the performance of the application.

setService() sets a new service, and getService() returns the set service. As a configuration option, you can give the array key 'service' at initiation. For details about possible options take a look into Callback.

// Your service class
class CcService
{
    public function checkOnline($cardnumber, $types)
    {
        // some online validation
    }
}

// The validation
$service = new CcService();
$valid   = new Zend_Validate_CreditCard(Zend_Validate_CreditCard::VISA);
$valid->setService(array($service, 'checkOnline'));

As you can see the callback method will be called with the creditcard number as the first parameter, and the accepted types as the second parameter.

The following options are supported for Zend_Validate_Db_NoRecordExists and Zend_Validate_Db_RecordExists:

• adapter: The database adapter which will be used for the search.

• exclude: Sets records which will be excluded from the search.

• field: The database field within this table which will be searched for the record.

• schema: Sets the schema which will be used for the search.

• table: The table which will be searched for the record.

このバリデータの基本的な使用例です。

// メールアドレスがデータベース内に存在するかどうかを調べます
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => 'emailaddress'
    )
);
if ($validator->isValid($emailaddress)) {
    // メールアドレスは有効なようです
} else {
    // メールアドレスが無効なので、その理由を表示します
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

上の例は、指定したメールアドレスがデータベースのテーブル内に存在するかどうかを調べます。 指定したカラムの値が $emailaddress に一致するレコードがなければ、 エラーメッセージが表示されます。

// ユーザ名がデータベースに存在しないことを調べます
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table' => 'users',
        'field' => 'username'
    )
);
if ($validator->isValid($username)) {
    // ユーザ名は有効なようです
} else {
    // ユーザ名が無効なので、その理由を表示します
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

上の例は、指定したユーザ名がデータベースのテーブル上に存在しないことを確認します。 指定したカラムの値が $username に一致するレコードが見つかれば、 エラーメッセージが表示されます。

Zend_Validate_Db_RecordExists および Zend_Validate_Db_NoRecordExists には、 テーブルの一部を除外してその内容を調べる方法があります。 where 句を文字列で指定するか、あるいはキー "field" および "value" を含む配列を指定します。

除外条件を配列で指定すると、!= 演算子を使用します。 つまり、テーブル内の残りのレコードの内容を確認してからレコードを変更できるのです (たとえばユーザ情報のフォームなどで使用します)。

// そのユーザ名のユーザがほかにいないことを調べます
$user_id   = $user->getId();
$validator = new Zend_Validate_Db_NoRecordExists(
    array(
        'table' => 'users',
        'field' => 'username',
        'exclude' => array(
            'field' => 'id',
            'value' => $user_id
        )
    )
);

if ($validator->isValid($username)) {
    // ユーザ名は有効なようです
} else {
    // ユーザ名が無効なので、その理由を表示します
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

上の例は、id = $user_id であるレコードを除いてそのテーブル内に $username を含むレコードが存在しないことを調べます。

除外条件を文字列で指定することもできるので、 != 以外の演算子を指定することもできます。 これは、複合キーに対するチェックの際に便利です。

$post_id   = $post->getId();
$clause    = $db->quoteInto('post_id = ?', $category_id);
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'   => 'posts_categories',
        'field'   => 'post_id',
        'exclude' => $clause
    )
);

if ($validator->isValid($username)) {
    // ユーザ名は有効なようです
} else {
    // ユーザ名が無効なので、その理由を表示します
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

上の例は、posts_categories テーブル内に post_id の値が $category_id に一致するレコードがあることを調べます。

アダプタを指定することもできます。 複数のデータベースアダプタを使用している場合や デフォルトのアダプタを設定していない場合などにこれを使用します。 以下に例を示します。

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => 'id',
        'adapter' => $dbAdapter
    )
);

データベース内のスキーマを PostgreSQL や DB/2 のアダプタで指定するには、キー table および schema を持つ配列を次の例のように渡します。 below:

$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'  => 'users',
        'schema' => 'my',
        'field'  => 'id'
    )
);

There are no additional options for Zend_Validate_Digits:

To validate if a given value contains only digits and no other characters, simply call the validator like shown in this example:

$validator = new Zend_Validate_Digits();

$validator->isValid("1234567890"); // returns true
$validator->isValid(1234);         // returns true
$validator->isValid('1a234');      // returns false

注意: Validating numbers

When you want to validate numbers or numeric values, be aware that this validator only validates digits. This means that any other sign like a thousand separator or a comma will not pass this validator. In this case you should use Zend_Validate_Int or Zend_Validate_Float.

基本的な使用法は、以下のようになります。

$validator = new Zend_Validate_EmailAddress();
if ($validator->isValid($email)) {
    // メールアドレスは正しい形式のようです
} else {
    // 不正な形式なので、理由を表示します
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

これは、メールアドレス $email を検証し、失敗した場合は その原因を表す便利なエラーメッセージを $validator->getMessages() で取得します。

Zend_Validate_EmailAddressは、 開始時に関係するオプションを持つ配列を与えることによって、 または後で setOptions() を使って セットできるいくつかのオプションをサポートします。 下記のオプションがサポートされます。

• allow: ドメイン名のいずれのタイプを受付可能か定義します。 このオプションは、ホスト名バリデータをセットするために hostname オプションとともに使われます。 このオプションで可能な値について詳しくは、 ホスト名をご覧ください。 そして ALLOW* 定数が可能です。 既定値は ALLOW_DNS です。

• hostname: 検証される電子メール・アドレスのドメインパートで ホスト名バリデータをセットします。

• mx: サーバから MX レコードが検出されるべきかどうか定義します。 もしこのオプションが TRUE と定義されると、 サーバがメールを受け付けるかどうか検証するために MX レコードが使われます。 このオプションの既定値は FALSE です。

• deep: サーバの MX レコードを強度のチェックで検証するべきかどうか定義します。 このオプションが TRUE に設定されると、 サーバがメールを受け付けるかどうか検証するために、 MX レコードに加えて A , A6 及び AAAA レコードも使われます。 このオプションの既定値は FALSE です。

• domain: ドメインパートをチェックすべきかどうか定義します。 このオプションが FALSE に設定されると、 メールアドレスのローカルパートのみがチェックされます。 この場合、ホスト名バリデータは呼ばれません。 このオプションの既定値は TRUE です。

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => false));

Zend_Validate_EmailAddress は、メールアドレスの検証を RFC2822 にもとづいて行います。たとえば、妥当な形式のメールアドレスとしては bob@domain.com、bob+jones@domain.us、 "bob@jones"@domain.com および "bob jones"@domain.com などがあります。

かつて使われていたものの、現在は有効とはみなされないフォーマットもあります (たとえば、メールアドレスに改行文字や "\" を使用するなど)。

もしメールアドレスのローカルパートのみをチェックするために Zend_Validate_EmailAddress を必要として、 ホスト名の検証を無効にしたいなら、 domain オプションに FALSE を設定できます。 これにより、 Zend_Validate_EmailAddress が メールアドレスのホスト名部分を検証しないようにします。

$validator = new Zend_Validate_EmailAddress();
$validator->setOptions(array('domain' => FALSE));

メールアドレスのホスト名部分の検証は、 Zend_Validate_Hostname で行います。デフォルトでは、domain.com 形式の DNS ホスト名のみが有効となります。しかし、 IP アドレスやローカルホスト名も有効にしたいこともあるでしょう。

その場合は、Zend_Validate_EmailAddress のインスタンスを作成する際にパラメータを渡さなければなりません。 このパラメータで、認めたいホスト名の形式を指定します。 詳細は Zend_Validate_Hostname を参照ください。 たとえば DNS ホスト名およびローカルホスト名のどちらも許可するには、次のようにします。

$validator = new Zend_Validate_EmailAddress(
                    Zend_Validate_Hostname::ALLOW_DNS |
                    Zend_Validate_Hostname::ALLOW_LOCAL);
if ($validator->isValid($email)) {
    // メールアドレスは正しい形式のようです
} else {
    // 不正な形式なので、理由を表示します
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

ただ単にメールアドレスが正しい書式であるというだけでは、 そのアドレスが実際に存在するかどうかはわかりません。 この問題を解決するには、MX の検証を行います。 メールアドレスのホスト名に対応する DNS レコードに、MX (メール) のエントリが存在するかどうかを調べるのです。 これは、そのホストがメールを受け付けているかどうかを教えてはくれますが、 そのメールアドレス自体が正しいものであるかどうかを知ることはできません。

MX のチェックはデフォルトでは無効です。 MX のチェックを有効にするには、Zend_Validate_EmailAddress コンストラクタの 2 番目のパラメータを渡します。

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true
    )
);

注意: WindowsでのMX のチェック

Windows 環境の範囲内では、 MX のチェックは PHP 5.3 かそれ以上を使う場合のみ可能です。 PHP 5.3 未満では MX のチェックはオプションで有効にされたとしても、 使われません。

あるいは、TRUE または FALSE を $validator->setValidateMx() に渡すことで、 MX の検証を有効あるいは無効にすることもできます。

この設定を有効にすると、ネットワーク関数を用いて メールアドレスのホスト名部に対する MX レコードの存在チェックをします。 これにより、スクリプトの処理速度が低下することに気をつけてください。

しばしば MX レコードの検証は、メールが受け付けられたとしても false を返します。 この振る舞いの背後にある理由は、サーバが MX レコードを提供しなくてもサーバはメールを受付できることです。 この場合、サーバは A, A6 または AAAA レコードを提供します。 それらのほかのレコードでも Zend_Validate_EmailAddress がチェックできるようにするためには、 強度の MX 検証を設定する必要があります。 これは開始時に deep オプションを設定するか、 または setOptions() を使って行ないます。

$validator = new Zend_Validate_EmailAddress(
    array(
        'allow' => Zend_Validate_Hostname::ALLOW_DNS,
        'mx'    => true,
        'deep'  => true
    )
);

注意: 許可されないIPアドレス

MX 検証は外部のサーバでのみ受け付けられることを注意すべきです。 強度の MX 検証が有効なとき、 192.168.* や 169.254.* のような ローカル IP アドレスは受け付けません。

Zend_Validate_EmailAddress は、ドメインの中に国際文字が使われている場合も処理できます。 このようなドメインは、国際化ドメイン名 (International Domain Name: IDN) と呼ばれています。これはデフォルトで有効になっていますが、無効にすることも可能です。 無効にするには、Zend_Validate_EmailAddress が内部で保持している Zend_Validate_Hostname オブジェクトの設定を変更します。

$validator->getHostnameValidator()->setValidateIdn(false);

setValidateIdn() の詳細な使用法は、 Zend_Validate_Hostname のドキュメントを参照ください。

IDN の検証は、DNS ホスト名の検証を有効にしている場合にのみ行われることに注意しましょう。

デフォルトでは、ホスト名の検証は既知の TLD の一覧に基づいて行われます。 これはデフォルトで有効になっていますが、無効にすることもできます。無効にするには、 無効にするには、Zend_Validate_EmailAddress が内部で保持している Zend_Validate_Hostname オブジェクトの設定を変更します。

$validator->getHostnameValidator()->setValidateTld(false);

setValidateTld() の詳細な使用法は、 Zend_Validate_Hostname のドキュメントを参照ください。

TLD の検証は、DNS ホスト名の検証を有効にしている場合にのみ行われることに注意しましょう。

Zend_Validate_EmailAddress は、 Zend_Validate_Hostname を使用してメールアドレスのホスト名部分をチェックします。 Zend Framework 1.10 以降、 Zend_Validate_Hostname 用のメッセージを Zend_Validate_EmailAddress から設定できるようになります。

$validator = new Zend_Validate_EmailAddress();
$validator->setMessages(
    array(
        Zend_Validate_Hostname::UNKNOWN_TLD => 'I don't know the TLD you gave'
    )
);

Zend Framework 1.10 より前のバージョンでは、まず Zend_Validate_Hostname にメッセージをアタッチしてからそれを Zend_Validate_EmailAddress に設定しないと独自のメッセージを返せませんでした。

The following options are supported for Zend_Validate_GreaterThan:

• min: Sets the minimum allowed value.

To validate if a given value is greater than a defined border simply use the following example.

$valid  = new Zend_Validate_GreaterThan(array('min' => 10));
$value  = 10;
$return = $valid->isValid($value);
// returns true

The above example returns TRUE for all values which are equal to 10 or greater than 10.

There are no additional options for Zend_Validate_Hex:

The following options are supported for Zend_Validate_Hostname:

• allow: Defines the sort of hostname which is allowed to be used. See Hostname types for details.

• idn: Defines if IDN domains are allowed or not. This option defaults to TRUE.

• ip: Allows to define a own IP validator. This option defaults to a new instance of Zend_Validate_Ip.

• tld: Defines if TLDs are validated. This option defaults to TRUE.

基本的な使用法は、以下のようになります。

$validator = new Zend_Validate_Hostname();
if ($validator->isValid($hostname)) {
    // ホスト名は正しい形式のようです
} else {
    // 不正な形式なので、理由を表示します
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

これは、ホスト名 $hostname を検証し、失敗した場合は その原因を表す便利なエラーメッセージを $validator->getMessages() で取得します。

IP アドレスやローカルホスト名、あるいはその両方を正しいホスト名として認めたいこともあるでしょう。 その場合は、Zend_Validate_Hostname のインスタンスを作成する際にパラメータを渡します。 このパラメータには、どの形式のホスト名を許可するのかを表す整数値を指定しなければなりません。 できるだけ、Zend_Validate_Hostname の定数を使用するようにしましょう。

Zend_Validate_Hostname の定数は次のとおりです。ALLOW_DNS は DNS ホスト名のみを許可し、 ALLOW_IP は IP アドレスを許可します。また ALLOW_LOCAL はローカルネットワーク名を許可し、ALLOW_ALL はこれら三種類をすべて許可します。 IP アドレスだけをチェックするには、以下の例のようにします。

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
if ($validator->isValid($hostname)) {
    // ホスト名は正しい形式のようです
} else {
    // 不正な形式なので、理由を表示します
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

ALLOW_ALL を使用してすべての形式を許可するほかに、 これらの形式を組み合わせることもできます。 たとえば、 DNS およびローカルホスト名を許可するには、 Zend_Validate_Hostname のインスタンスを次のように作成します。

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS | Zend_Validate_Hostname::ALLOW_IP);

国別コードトップレベルドメイン (Country Code Top Level Domains: ccTLDs) の一部、たとえば 'de' (ドイツ) などでは、ドメイン名の中に国際化文字の使用をサポートしています。 これは、国際化ドメイン名 (International Domain Names: IDN) といわれるものです。 これらのドメインについても、Zend_Validate_Hostname の検証プロセスで使用する文字を拡張することで検証できます。

注意: IDN ドメイン

これまでに、50以上の ccTLD が IDN ドメインをサポートします。

IDN ドメインに対するマッチングを行う方法は、通常のホスト名の場合とまったく同じです。 というのも、 IDN のマッチングはデフォルトで有効になっているからです。 IDN の検証を無効にしたい場合は、Zend_Validate_Hostname のコンストラクタにパラメータを渡すか、あるいは setValidateIdn() メソッドを使用します。

IDN の検証を無効にするには、Zend_Validate_Hostname のコンストラクタに二番目のパラメータを次のように渡します。

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => false
        )
    );

あるいは、 TRUE または FALSE を setValidateIdn() に渡すことで、 IDN の検証を有効あるいは無効にすることもできます。 現在サポートされていない IDN ホスト名に対するマッチングを行おうとすると、 国際化文字が含まれている場合に検証に失敗します。 追加の文字を指定した ccTLD ファイルが Zend/Validate/Hostname に存在しない場合は、通常のホスト名の検証を行います。

注意: IDN 検証

IDN の検証は、 DNS ホスト名の検証を有効にしている場合にのみ行われることに注意しましょう。

デフォルトでは、ホスト名の検証は既知の TLD の一覧に基づいて行われます。 この機能が不要な場合は、 IDN サポートを無効にするのと同じ方法で無効にできます。 TLD の検証を無効にするには、Zend_Validate_Hostname のコンストラクタに三番目のパラメータを渡します。 以下の例では、 IDN の検証は二番目のパラメータで有効にしています。

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => true,
            'tld'   => false
        )
    );

あるいは、 TRUE または FALSE を setValidateIdn() に渡すことで、 TLD の検証を有効あるいは無効にすることもできます。

注意: TLD 検証

TLD の検証は、 DNS ホスト名の検証を有効にしている場合にのみ行われることに注意しましょう。

The following options are supported for Zend_Validate_Iban:

• locale: Sets the locale which is used to get the IBAN format for validation.

IBAN numbers are always related to a country. This means that different countries use different formats for their IBAN numbers. This is the reason why IBAN numbers always need a locale. By knowing this we already know how to use Zend_Validate_Iban.

// within bootstrap
Zend_Registry::set('Zend_Locale', new Zend_Locale('de_AT'));

// within the module
$validator = new Zend_Validate_Iban();

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

$validator = new Zend_Validate_Iban(array('locale' => false));
// Note: you can also set a FALSE as single parameter

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

$validator = new Zend_Validate_Iban(array('locale' => 'de_AT'));

if ($validator->isValid('AT611904300234573201')) {
    // IBAN appears to be valid
} else {
    // IBAN is not valid
}

The following options are supported for Zend_Validate_Identical:

• strict: Defines if the validation should be done strict. The default value is TRUE.

• token: Sets the token with which the input will be validated against.

To validate if two values are identical you need to set the origin value as haystack. See the following example which validates two strings.

$valid = new Zend_Validate_Identical('origin');
if ($valid->isValid($value) {
    return true;
}

The validation will only then return TRUE when both values are 100% identical. In our example, when $value is 'origin'.

You can set the wished token also afterwards by using the method setToken() and getToken() to get the actual set token.

Of course Zend_Validate_Identical can not only validate strings, but also any other variable type like Boolean, Integer, Float, Array or even Objects. As already noted Haystack and Value must be identical.

$valid = new Zend_Validate_Identical(123);
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

注意: Type comparison

You should be aware that also the type of a variable is used for validation. This means that the string '3' is not identical with the integer 3. When you want such a non strict validation you must set the strict option.

Zend_Validate_Identical supports also the comparison of form elements. This can be done by using the element's name as token. See the following example:

$form->addElement('password', 'elementOne');
$form->addElement('password', 'elementTwo', array(
    'validators' => array(
        array('identical', false, array('token' => 'elementOne'))
    )
));

By using the elements name from the first element as token for the second element, the validator validates if the second element is equal with the first element. In the case your user does not enter two identical values, you will get an validation error.

As mentioned before Zend_Validate_Identical validates tokens strict. You can change this behaviour by using the strict option. The default value for this property is TRUE.

$valid = new Zend_Validate_Identical(array('token' => 123, 'strict' => FALSE));
$input = '123';
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

The difference to the previous example is that the validation returns in this case TRUE, even if you compare a integer with string value as long as the content is identical but not the type.

For convinience you can also use setStrict() and getStrict().

As all other validators also Zend_Validate_Identical supports the usage of configuration settings as input parameter. This means that you can configure this validator with an Zend_Config object.

But this adds one case which you have to be aware. When you are using an array as haystack then you should wrap it within an 'token' key when it could contain only one element.

$valid = new Zend_Validate_Identical(array('token' => 123));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

The above example validates the integer 123. The reason for this special case is, that you can configure the token which has to be used by giving the 'token' key.

So, when your haystack contains one element and this element is named 'token' then you have to wrap it like shown in the example below.

$valid = new Zend_Validate_Identical(array('token' => array('token' => 123)));
if ($valid->isValid($input)) {
    // input appears to be valid
} else {
    // input is invalid
}

The following options are supported for Zend_Validate_InArray:

• haystack: Sets the haystack for the validation.

• recursive: Defines if the validation should be done recursive. This option defaults to FALSE.

• strict: Defines if the validation should be done strict. This option defaults to FALSE.

最も単純な方法は、初期化の際に検索される配列を与えることがまさにそうです。

$validator = new Zend_Validate_InArray(array('key' => 'value',
                                             'otherkey' => 'othervalue'));
if ($validator->isValid('value')) {
    // 値が見つかりました
} else {
    // 値が見つかりません
}

これは、ちょうどPHPの in_array() メソッドのようにふるまいます

注意:

デフォルトでは、この検証は厳格ではありませんし、 それは多次元配列を検証することができません。

もちろん、 setHaystack()メソッドを用いてその後また、 検証する配列を与えることができます。 getHaystack() は、実際に設定されている配列を返します。

$validator = new Zend_Validate_InArray();
$validator->setHaystack(array('key' => 'value', 'otherkey' => 'othervalue'));

if ($validator->isValid('value')) {
    // 値が見つかりました
} else {
    // 値が見つかりません
}

上述のように、配列の中で厳密な検証をすることもできます。 デフォルトでは、整数値0と文字列"0"の違いがありません。 厳密な検証をするときは、この違いも検証されます。そして、同じ型だけが受け入れられます。

厳密な検証は、異なる２つの方法を用いて行なうこともできます。 初期化で、及びメソッドを用いて。 初期化では、以下の構造で配列を与えなければなりません。

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array('key' => 'value', 'otherkey' => 'othervalue'),
        'strict'   => true
    )
);

if ($validator->isValid('value')) {
    // 値が見つかりました
} else {
    // 値が見つかりません
}

haystackキーは、検証する配列を含みます。 そしてstrictキーをTRUEに設定することにより、 検証は厳密な型チェックを用いてなされます。

もちろん、その後この設定値を変えるために、 setStrict()メソッドを使うこともできます。 また、 getStrict() で実際に設定されている内容を取得することもできます。

注意:

strict設定は、 デフォルトではFALSEであることに注意してください。

PHPの in_array()メソッド に加えて、このバリデータは、多次元配列を検証するために使うこともできます。

多次元配列を検証するためには、 recursiveオプションを設定しなければなりません。

$validator = new Zend_Validate_InArray(
    array(
        'haystack' => array(
            'firstDimension' => array('key' => 'value',
                                      'otherkey' => 'othervalue'),
            'secondDimension' => array('some' => 'real',
                                       'different' => 'key')),
        'recursive' => true
    )
);

if ($validator->isValid('value')) {
    // 値が見つかりました
} else {
    // 値が見つかりません
}

それにより、任意の値が含まれるかどうか配列が再帰的に検証されます。 さらに、 setRecursive() を使って後からこのオプションを設定したり getRecursive() で設定を取得したりすることもできます。

$validator = new Zend_Validate_InArray(
    array(
        'firstDimension' => array('key' => 'value',
                                  'otherkey' => 'othervalue'),
        'secondDimension' => array('some' => 'real',
                                   'different' => 'key')
    )
);
$validator->setRecursive(true);

if ($validator->isValid('value')) {
    // 値が見つかりました
} else {
    // 値が見つかりません
}

注意: 再帰的な検証のデフォルト設定

デフォルトでは再帰的な検証は無効となります。

注意: 配列内でのオプションキー

'haystack' や 'strict'、'recursive' といったキーを配列内で使う場合は、haystack キーをラップしなければなりません。

The following options are supported for Zend_Validate_Int:

• locale: Sets the locale which will be used to validate localized integers.

The simplest way to validate an integer is by using the system settings. When no option is used, the environment locale is used for validation:

$validator = new Zend_Validate_Int();

$validator->isValid(1234);   // returns true
$validator->isValid(1234.5); // returns false
$validator->isValid('1,234'); // returns true

In the above example we expected that our environment is set to "en" as locale. As you can see in the third example also grouping is recognised.

Often it's useful to be able to validate also localized values. Integer values are often written different in other countries. For example using english you can write "1234" or "1,234". Both are integer values but the grouping is optional. In german for example you may write "1.234" and in french "1 234".

Zend_Validate_Int is able to validate such notations. But it is limited to the locale you set. This means that it not simply strips off the separator, it validates if the correct separator is used. See the following code:

$validator = new Zend_Validate_Int(array('locale' => 'de'));

$validator->isValid(1234); // returns true
$validator->isValid("1,234"); // returns false
$validator->isValid("1.234"); // returns true

As you can see, by using a locale, your input is validated localized. Using the english notation you get a FALSE when the locale forces a different notation.

The locale can also be set afterwards by using setLocale() and retrieved by using getLocale().

The following options are supported for Zend_Validate_Ip:

• allowipv4: Defines if the validator allows IPv4 adresses. This option defaults to TRUE.

• allowipv6: Defines if the validator allows IPv6 adresses. This option defaults to TRUE.

基本的な使用法は、以下のようになります。

$validator = new Zend_Validate_Ip();
if ($validator->isValid($ip)) {
    // ip は正しい形式のようです
} else {
    // ip が不正なので、理由を表示します
}

注意: IP アドレスの検証

Zend_Validate_Ip は IP アドレスだけを検証することを記憶にとどめてください。 'mydomain.com' や '192.168.50.1/index.html' のようなアドレスは、有効な IP アドレスではありません。 それらは IP アドレスではなく、 hostname または 有効な URL です。

注意: IPv6 の検証

Zend_Validate_Ip は正規表現で IPv6 アドレスを検証します。 それは、 PHP 自身のフィルターやメソッドが RFC に準拠していないからです。 他の多くの利用可能なクラスもまた、それに準拠しません。

しばしば、サポートされる形式のうちの１つだけを検証するために役立ちます。 たとえば、ネットワークが IPv4 だけをサポートするときです。 この場合、このバリデータ内で IPv6 を受け付けることは無駄でしょう。

Zend_Validate_Ip をプロトコル１つに制限するために、 オプション allowipv4 または allowipv6 を FALSE に設定できます。 これは、コンストラクタにオプションを与えることによって、 または、その後 setOptions() を用いて行なえます。

$validator = new Zend_Validate_Ip(array('allowipv6' => false);
if ($validator->isValid($ip)) {
    // ip は正しい ip4v アドレスのようです
} else {
    // ip は ipv4 アドレスではありません
}

注意: 既定の動作

Zend_Validate_Ip が従う既定の動作は 両方の標準を受け付ける、です。

The following options are supported for Zend_Validate_Isbn:

• separator: Defines the allowed separator for the ISBN number. It defaults to an empty string.

• type: Defines the allowed type of ISBN numbers. It defaults to Zend_Validate_Isbn::AUTO. For details take a look at this section.

A basic example of usage is below:

$validator = new Zend_Validate_Isbn();
if ($validator->isValid($isbn)) {
    // isbn is valid
} else {
    // isbn is not valid
}

This will validate any ISBN-10 and ISBN-13 without separator.

An example of an ISBN type restriction is below:

$validator = new Zend_Validate_Isbn();
$validator->setType(Zend_Validate_Isbn::ISBN13);
// OR
$validator = new Zend_Validate_Isbn(array(
    'type' => Zend_Validate_Isbn::ISBN13,
));

if ($validator->isValid($isbn)) {
    // this is a valid ISBN-13 value
} else {
    // this is an invalid ISBN-13 value
}

The above will validate only ISBN-13 values.

Valid types include:

• Zend_Validate_Isbn::AUTO (default)

• Zend_Validate_Isbn::ISBN10

• Zend_Validate_Isbn::ISBN13

An example of separator restriction is below:

$validator = new Zend_Validate_Isbn();
$validator->setSeparator('-');
// OR
$validator = new Zend_Validate_Isbn(array(
    'separator' => '-',
));

if ($validator->isValid($isbn)) {
    // this is a valid ISBN with separator
} else {
    // this is an invalid ISBN with separator
}

注意: Values without separator

This will return FALSE if $isbn doesn't contain a separator or if it's an invalid ISBN value.

Valid separators include:

• "" (empty) (default)

• "-" (hyphen)

• " " (space)

The following options are supported for Zend_Validate_LessThan:

• max: Sets the maximum allowed value.

To validate if a given value is less than a defined border simply use the following example.

$valid  = new Zend_Validate_LessThan(array('max' => 10));
$value  = 10;
$return = $valid->isValid($value);
// returns true

The above example returns TRUE for all values which are equal to 10 or lower than 10.

The following options are supported for Zend_Validate_NotEmpty:

• type: Sets the type of validation which will be processed. For details take a look into this section.

By default, this validator works differently than you would expect when you've worked with PHP's empty() function. In particular, this validator will evaluate both the integer 0 and string '0' as empty.

$valid = new Zend_Validate_NotEmpty();
$value  = '';
$result = $valid->isValid($value);
// returns false

注意: Default behaviour differs from PHP

Without providing configuration, Zend_Validate_NotEmpty's behaviour differs from PHP.

Some projects have differing opinions of what is considered an "empty" value: a string with only whitespace might be considered empty, or 0 may be considered non-empty (particularly for boolean sequences). To accomodate differing needs, Zend_Validate_NotEmpty allows you to configure which types should be validated as empty and which not.

The following types can be handled:

• boolean: Returns FALSE when the boolean value is FALSE.

• integer: Returns FALSE when an integer 0 value is given. Per default this validation is not activated and returns TRUE on any integer values.

• float: Returns FALSE when an float 0.0 value is given. Per default this validation is not activated and returns TRUE on any float values.

• string: Returns FALSE when an empty string '' is given.

• zero: Returns FALSE when the single character zero ('0') is given.

• empty_array: Returns FALSE when an empty array is given.

• null: Returns FALSE when an NULL value is given.

• php: Returns FALSE on the same reasons where PHP method empty() would return TRUE.

• space: Returns FALSE when an string is given which contains only whitespaces.

• object: Returns TRUE. FALSE will be returned when object is not allowed but an object is given.

• object_string: Returns FALSE when an object is given and it's __toString() method returns an empty string.

• object_count: Returns FALSE when an object is given, it has an Countable interface and it's count is 0.

• all: Returns FALSE on all above types.

All other given values will return TRUE per default.

There are several ways to select which of the above types are validated. You can give one or multiple types and add them, you can give an array, you can use constants, or you can give a textual string. See the following examples:

// Returns false on 0
$validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(
    Zend_Validate_NotEmpty::INTEGER + Zend_NotEmpty::ZERO
);

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(array(
    Zend_Validate_NotEmpty::INTEGER,
    Zend_Validate_NotEmpty::ZERO
));

// Returns false on 0 or '0'
$validator = new Zend_Validate_NotEmpty(array(
    'integer',
    'zero',
));

You can also provide an instance of Zend_Config to set the desired types. To set types after instantiation, use the setType() method.

At it's most basic, you may pass either a Zend_Locale object or a string representing a fully qualified locale to the constructor of Zend_Validate_PostCode.

$validator = new Zend_Validate_PostCode('de_AT');
$validator = new Zend_Validate_PostCode($locale);

Additionally, you may pass either an array or a Zend_Config object to the constructor. When you do so, you must include either the key "locale" or "format"; these will be used to set the appropriate values in the validator object.

$validator = new Zend_Validate_PostCode(array(
    'locale' => 'de_AT',
    'format' => 'AT_\d+'
));

The following options are supported for Zend_Validate_PostCode:

• format: Sets a postcode format which will be used for validation of the input.

• locale: Sets a locale from which the postcode will be taken from.

The following options are supported for Zend_Validate_Regex:

• pattern: Sets the regular expression pattern for this validator.

Validation with regular expressions allows to have complicated validations being done without writing a own validator. The usage of regular expression is quite common and simple. Let's look at some examples:

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns true
$validator->isValid("Pest"); // returns false

As you can see, the pattern has to be given using the same syntax as for preg_match(). For details about regular expressions take a look into » PHP's manual about PCRE pattern syntax.

It is also possible to set a different pattern afterwards by using setPattern() and to get the actual set pattern with getPattern().

$validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');
$validator->setPattern('ing$/');

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true
$validator->isValid("Pest"); // returns false

文字列がサイトマップ XML 文書で 'changefreq' 要素として 使用できるかどうか検証します。 有効値は、 'always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly' または 'never' です。

値が文字列で、上記で指定される頻度のうちの1つと等しい場合に限り、 TRUEを返します。

文字列がサイトマップ XML 文書で 'lastmod' 要素として 使用できるかどうか検証します。 lastmod要素は W3C 日付文字列を含まなければなりません。 そして、任意で時間についての情報を無効にします。

値が文字列で、プロトコルに従って妥当な場合に限り、 TRUEを返します。

$validator = new Zend_Validate_Sitemap_Lastmod();

$validator->isValid('1999-11-11T22:23:52-02:00'); // true
$validator->isValid('2008-05-12T00:42:52+02:00'); // true
$validator->isValid('1999-11-11'); // true
$validator->isValid('2008-05-12'); // true

$validator->isValid('1999-11-11t22:23:52-02:00'); // false
$validator->isValid('2008-05-12T00:42:60+02:00'); // false
$validator->isValid('1999-13-11'); // false
$validator->isValid('2008-05-32'); // false
$validator->isValid('yesterday'); // false

文字列がサイトマップ XML 文書で 'loc' 要素として 使用できるかどうか検証します。 これは内部的に Zend_Form::check()を使います。 詳しくはURI の検証を読んでください。

文字列がサイトマップ XML 文書で 'priority' 要素として 使用できるかどうか検証します。 値は、0.0と1.0の間の小数でなければなりません。 このバリデータは、数値と文字列値の両方を受け入れます。

$validator = new Zend_Validate_Sitemap_Priority();

$validator->isValid('0.1'); // true
$validator->isValid('0.789'); // true
$validator->isValid(0.8); // true
$validator->isValid(1.0); // true

$validator->isValid('1.1'); // false
$validator->isValid('-0.4'); // false
$validator->isValid(1.00001); // false
$validator->isValid(0xFF); // false
$validator->isValid('foo'); // false

サイトマップ・バリデータのいずれもサポートするオプションはありません。

The following options are supported for Zend_Validate_StringLength:

• encoding: Sets the ICONV encoding which has to be used for this string.

• min: Sets the minimum allowed length for a string.

• max: Sets the maximum allowed length for a string.

Per default this validator checks if a value is between min and max. But for min the default value is 0 and for max it is NULL which means unlimited.

So per default, without giving any options, this validator only checks if the input is a string.

To limit the maximum allowed length of a string you need to set the max property. It accepts an integer value as input.

$validator = new Zend_Validate_StringLength(array('max' => 6));

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns false

You can set the maximum allowed length also afterwards by using the setMax() method. And getMax() to retrieve the actual maximum border.

$validator = new Zend_Validate_StringLength();
$validator->setMax(6);

$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns false

To limit the minimal required length of a string you need to set the min property. It accepts also an integer value as input.

$validator = new Zend_Validate_StringLength(array('min' => 5));

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true

You can set the minimal requested length also afterwards by using the setMin() method. And getMin() to retrieve the actual minimum border.

$validator = new Zend_Validate_StringLength();
$validator->setMin(5);

$validator->isValid("Test"); // returns false
$validator->isValid("Testing"); // returns true

Sometimes it is required to get a string which has a maximal defined length but which is also minimal chars long. For example when you have a textbox where a user can enter his name, then you may want to limit the name to maximum 30 chars but want to get sure that he entered his name. So you limit the mimimum required length to 3 chars. See the following example:

$validator = new Zend_Validate_StringLength(array('min' => 3, 'max' => 30));

$validator->isValid("."); // returns false
$validator->isValid("Test"); // returns true
$validator->isValid("Testing"); // returns true

注意: Setting a lower maximum border than the minimum border

When you try to set a lower maximum value as the actual minimum value, or a higher minimum value as the actual maximum value, then an exception will be raised.

Strings are always using a encoding. Even when you don't set the encoding explicit, PHP uses one. When your application is using a different encoding than PHP itself then you should set an encoding yourself.

You can set your own encoding at initiation with the encoding option, or by using the setEncoding() method. We assume that your installation uses ISO and your application it set to ISO. In this case you will see the below behaviour.

$validator = new Zend_Validate_StringLength(
    array('min' => 6)
);
$validator->isValid("Ärger"); // returns false

$validator->setEncoding("UTF-8");
$validator->isValid("Ärger"); // returns true

$validator2 = new Zend_Validate_StringLength(
    array('min' => 6, 'encoding' => 'UTF-8')
);
$validator2->isValid("Ärger"); // returns true

So when your installation and your application are using different encodings, then you should always set an encoding yourself.