title: EasySwoole Verifier meta:

  • name: description content: EasySwoole Validator|swoole Parameter validator
  • name: keywords content: swoole|swoole extension|swoole framework|EasySwoole Validator|swoole Parameter validator

Validate

EasySwoole provides a built-in validation class. By default, there is a validate method in the controller. If you want to use other methods or tools to do the verification, you can override this method in the subclass controller to implement other methods. Tool for verification

::: warning Validator class: EasySwoole\Validate\Validate :::

Basic use

  1. <?php
  2. use EasySwoole\Validate\Validate;
  4. $data = [
  5.     'name' => 'blank',
  6.     'age'  => 25
  7. ];
  9. $valitor = new Validate();
  10. $valitor->addColumn('name', 'The name is not empty')->required('The name is not empty')->lengthMin(10,'Minimum length is not less than 10 digits');
  11. $bool = $valitor->validate($data);
  12. var_dump($bool?"true":$valitor->getError()->__toString());
  14. /* result:
  15.      String(26) "Minimum length is not less than 10 digits"
  16. */

Package use in the controller

  1. namespace App\HttpController;
  2. use EasySwoole\Http\Message\Status;
  3. use EasySwoole\Validate\Validate;
  4. use EasySwoole\Http\AbstractInterface\Controller;
  6. class BaseController extends Controller
  7. {
  9.     protected function onRequest(?string $action): ?bool
  10.     {
  11.         $ret =  parent::onRequest($action);
  12.         if($ret === false){
  13.             return false;
  14.         }
  15.         $v = $this->validateRule($action);
  16.         if($v){
  17.             $ret = $this->validate($v);
  18.             if($ret == false){
  19.                 $this->writeJson(Status::CODE_BAD_REQUEST,null,"{$v->getError()->getField()}@{$v->getError()->getFieldAlias()}:{$v->getError()->getErrorRuleMsg()}");
  20.                 return false;
  21.             }
  22.         }   
  23.         return true;
  24.     }
  26.     protected function validateRule(?string $action):?Validate
  27.     {
  29.     }
  30. }

::: warning We define a base controller with the validateRule method.。 :::

  1. namespace App\HttpController;
  4. use App\HttpController\Api\BaseController;
  5. use EasySwoole\Validate\Validate;
  7. class Common extends BaseController
  8. {
  10.     function sms()
  11.     {
  12.         $phone = $this->request()->getRequestParam('phone');
  14.     }
  16.     protected function validateRule(?string $action): ?Validate
  17.     {
  18.         $v = new Validate();
  19.         switch ($action){
  20.             case 'sms':{
  21.                 $v->addColumn('phone','phone number')->required('Can not be empty')->length(11,'Wrong length');
  22.                 $v->addColumn('verifyCode','Verification code')->required('Can not be empty')->length(4,'Wrong length');
  23.                 break;
  24.             }
  25.         }
  26.         return $v;
  27.     }
  28. }

::: warning In the controller method that needs to be verified, we can add the corresponding verification rule to the corresponding action, so that the automatic verification can be realized, so that the controller method can realize the logic with peace of mind. :::

Method list

Get Error:

  1. function getError():?EasySwoole\Validate\Error

Add a rule to the field:

Version 1.1.9 to the present

  • string name field key
  • string alias alias
  • string reset reset rule
  1. public function addColumn(string $name, ?string $alias = null,bool $reset = false):EasySwoole\Validate\Rule

Version 1.1.0 to 1.1.8

  • string name field key
  • string alias alias
  1. public function addColumn(string $name, ?string $alias = null):EasySwoole\Validate\Rule

Version 1.0.1

  • string name field key
  • string errorMsg error message
  • string alias alias
  1. public function addColumn(string $name,?string $errorMsg = null,?string $alias = null):EasySwoole\Validate\Rule

Version 1.0.0

  • string name field key
  • string alias alias
  • string errorMsg error message
  1. public function addColumn(string $name,?string $alias = null,?string $errorMsg = null):EasySwoole\Validate\Rule

Return a Rule object to add a custom rule.

data verification:

  • array data data
  1. Function validate(array $data)

Validation rule class

Currently the rules supported by the validator are as follows

  1. namespace EasySwoole\Validate;
  3. /**
  4.  * Verification rule
  5.  * Please sort the verification method in alphabetical order for post maintenance
  6.  * Class Rule
  7.  * @package EasySwoole\Validate
  8.  */
  9. class Rule
  10. {
  11.     protected $ruleMap = [];
  13.     function getRuleMap(): array
  14.     {
  15.         return $this->ruleMap;
  16.     }
  18.     /**
  19.      * Whether the given URL can communicate successfully
  20.      * @param null|string $msg
  21.      * @return $this
  22.      */
  23.     function activeUrl($msg = null)
  24.     {
  25.         $this->ruleMap['activeUrl'] = [
  26.             'arg' => null,
  27.             'msg' => $msg
  28.         ];
  29.         return $this;
  30.     }
  32.     /**
  33.      * Whether the given parameter is a letter, ie [a-zA-Z]
  34.      * @param null|string $msg
  35.      * @return $this
  36.      */
  37.     function alpha($msg = null)
  38.     {
  39.         $this->ruleMap['alpha'] = [
  40.             'arg' => null,
  41.             'msg' => $msg
  42.         ];
  43.         return $this;
  44.     }
  46.     function alphaNum($msg = null)
  47.     {
  48.         $this->ruleMap['alphaNum'] = [
  49.             'arg' => null,
  50.             'msg' => $msg
  51.         ];
  52.         return $this;
  53.     }
  55.     function alphaDash($msg = null)
  56.     {
  57.         $this->ruleMap['alphaDash'] = [
  58.             'arg' => null,
  59.             'msg' => $msg
  60.         ];
  61.         return $this;
  62.     }
  64.     /**
  65.      * Whether the given parameter is between $min $max
  66.      * @param integer $min minimum does not contain this value
  67.      * @param integer $max maximum does not contain this value
  68.      * @param null|string $msg
  69.      * @return $this
  70.      */
  71.     function between($min, $max, $msg = null)
  72.     {
  73.         $this->ruleMap['between'] = [
  74.             'msg' => $msg,
  75.             'arg' => [
  76.                 $min, $max
  77.             ]
  78.         ];
  79.         return $this;
  80.     }
  82.     /**
  83.      * Whether the given parameter is a boolean
  84.      * @param null|string $msg
  85.      * @return $this
  86.      */
  87.     function bool($msg = null)
  88.     {
  89.         $this->ruleMap['bool'] = [
  90.             'msg' => $msg,
  91.             'arg' => null
  92.         ];
  93.         return $this;
  94.     }
  96.     /**
  97.      * Whether the given parameter is in decimal format
  98.      * @param null|integer $precision specifies the number of decimal places null is not specified
  99.      * @param null $msg
  100.      * @return $this
  101.      */
  102.     function decimal(?int $precision = null, $msg = null)
  103.     {
  104.         $this->ruleMap['decimal'] = [
  105.             'msg' => $msg,
  106.             'arg' => $precision
  107.         ];
  108.         return $this;
  109.     }
  111.     /**
  112.      * Whether the given parameter is before a certain date
  113.      * @param null|string $date
  114.      * @param null|string $msg
  115.      * @return $this
  116.      */
  117.     function dateBefore(?string $date = null, $msg = null)
  118.     {
  119.         $this->ruleMap['dateBefore'] = [
  120.             'msg' => $msg,
  121.             'arg' => $date
  122.         ];
  123.         return $this;
  124.     }
  126.     /**
  127.      * Whether the given parameter is after a certain date
  128.      * @param null|string $date
  129.      * @param null|string $msg
  130.      * @return $this
  131.      */
  132.     function dateAfter(?string $date = null, $msg = null)
  133.     {
  134.         $this->ruleMap['dateAfter'] = [
  135.             'msg' => $msg,
  136.             'arg' => $date
  137.         ];
  138.         return $this;
  139.     }
  141.     /**
  142.      * Verify that the values are equal
  143.      * @param $compare
  144.      * @param null|string $msg
  145.      * @return $this
  146.      */
  147.     function equal($compare, $msg = null)
  148.     {
  149.         $this->ruleMap['equal'] = [
  150.             'msg' => $msg,
  151.             'arg' => $compare
  152.         ];
  153.         return $this;
  154.     }
  156.     /**
  157.      * Verify that the value is a floating point number
  158.      * @param null|string $msg
  159.      * @return $this
  160.      */
  161.     function float($msg = null)
  162.     {
  163.         $this->ruleMap['float'] = [
  164.             'arg' => null,
  165.             'msg' => $msg
  166.         ];
  167.         return $this;
  168.     }
  170.     /**
  171.      * Call custom closure validation
  172.      * @param callable $func
  173.      * @param null|string $msg
  174.      * @return $this
  175.      */
  176.     function func(callable $func, $msg = null)
  177.     {
  178.         $this->ruleMap['func'] = [
  179.             'arg' => $func,
  180.             'msg' => $msg
  181.         ];
  182.         return $this;
  183.     }
  185.     /**
  186.      * Whether the value is in the array
  187.      * @param array $array
  188.      * @param bool $isStrict
  189.      * @param null|string $msg
  190.      * @return $this
  191.      */
  192.     function inArray(array $array, $isStrict = false, $msg = null)
  193.     {
  194.         $this->ruleMap['inArray'] = [
  195.             'arg' => [ $array, $isStrict ],
  196.             'msg' => $msg
  197.         ];
  198.         return $this;
  199.     }
  201.     /**
  202.      * Is it an integer value
  203.      * @param null|string $msg
  204.      * @return $this
  205.      */
  206.     function integer($msg = null)
  207.     {
  208.         $this->ruleMap['integer'] = [
  209.             'arg' => null,
  210.             'msg' => $msg
  211.         ];
  212.         return $this;
  213.     }
  215.     /**
  216.      * Is it a valid IP?
  217.      * @param array $array
  218.      * @param null $msg
  219.      * @return $this
  220.      */
  221.     function isIp($msg = null)
  222.     {
  223.         $this->ruleMap['isIp'] = [
  224.             'arg' => null,
  225.             'msg' => $msg
  226.         ];
  227.         return $this;
  228.     }
  230.     /**
  231.      * Is it not empty
  232.      * @param null $msg
  233.      * @return $this
  234.      */
  235.     function notEmpty($msg = null)
  236.     {
  237.         $this->ruleMap['notEmpty'] = [
  238.             'arg' => null,
  239.             'msg' => $msg
  240.         ];
  241.         return $this;
  242.     }
  244.     /**
  245.      * Whether a numeric value
  246.      * @param null $msg
  247.      * @return $this
  248.      */
  249.     function numeric($msg = null)
  250.     {
  251.         $this->ruleMap['numeric'] = [
  252.             'arg' => null,
  253.             'msg' => $msg
  254.         ];
  255.         return $this;
  256.     }
  258.     /**
  259.      * Not in the array
  260.      * @param array $array
  261.      * @param bool $isStrict
  262.      * @param null $msg
  263.      * @return $this
  264.      */
  265.     function notInArray(array $array, $isStrict = false, $msg = null)
  266.     {
  267.         $this->ruleMap['notInArray'] = [
  268.             'arg' => [ $array, $isStrict ],
  269.             'msg' => $msg
  270.         ];
  271.         return $this;
  272.     }
  274.     /**
  275.      * Verify the length of an array or string
  276.      * @param int $len
  277.      * @param null $msg
  278.      * @return $this
  279.      */
  280.     function length(int $len, $msg = null)
  281.     {
  282.         $this->ruleMap['length'] = [
  283.             'msg' => $msg,
  284.             'arg' => $len
  285.         ];
  286.         return $this;
  287.     }
  289.     /**
  290.      * Verify the length of an array or string...
  291.      * @param int $lengthMax
  292.      * @param null $msg
  293.      * @return $this
  294.      */
  295.     function lengthMax(int $lengthMax, $msg = null)
  296.     {
  297.         $this->ruleMap['lengthMax'] = [
  298.             'msg' => $msg,
  299.             'arg' => $lengthMax
  300.         ];
  301.         return $this;
  302.     }
  304.     /**
  305.      * Verify that the length of the array or string is reached
  306.      * @param int $lengthMin
  307.      * @param null $msg
  308.      * @return $this
  309.      */
  310.     function lengthMin(int $lengthMin, $msg = null)
  311.     {
  312.         $this->ruleMap['lengthMin'] = [
  313.             'msg' => $msg,
  314.             'arg' => $lengthMin
  315.         ];
  316.         return $this;
  317.     }
  319.     /**
  320.      * Verify that the length of the array or string is within a range
  321.      * @param null $msg
  322.      * @return $this
  323.      */
  324.     function betweenLen(int $min, int $max, $msg = null)
  325.     {
  326.         $this->ruleMap['betweenLen'] = [
  327.             'msg' => $msg,
  328.             'arg' => [
  329.                 $min,
  330.                 $max
  331.             ]
  332.         ];
  333.         return $this;
  334.     }
  336.     /**
  337.      * Verification value is not greater than (equal is considered not passed)
  338.      * @param int $max
  339.      * @param null|string $msg
  340.      * @return Rule
  341.      */
  342.     function max(int $max, ?string $msg = null): Rule
  343.     {
  344.         $this->ruleMap['max'] = [
  345.             'arg' => $max,
  346.             'msg' => $msg
  347.         ];
  348.         return $this;
  349.     }
  351.     /**
  352.      * The verification value is not less than (equal is considered not passed)
  353.      * @param int $min
  354.      * @param null|string $msg
  355.      * @return Rule
  356.      */
  357.     function min(int $min, ?string $msg = null): Rule
  358.     {
  359.         $this->ruleMap['min'] = [
  360.             'arg' => $min,
  361.             'msg' => $msg
  362.         ];
  363.         return $this;
  364.     }
  366.     /**
  367.      * The verification value is a legal amount
  368.      * 100 | 100.1 | 100.01
  369.      * @param integer|null $precision Decimal point
  370.      * @param string|null  $msg
  371.      * @return Rule
  372.      */
  373.     function money(?int $precision = null, string $msg = null): Rule
  374.     {
  375.         $this->ruleMap['money'] = [
  376.             'arg' => $precision,
  377.             'msg' => $msg
  378.         ];
  379.         return $this;
  380.     }
  382.     /**
  383.      * Setting value is optional
  384.      * @return $this
  385.      */
  386.     function optional()
  387.     {
  388.         $this->ruleMap['optional'] = [
  389.             'arg' => null,
  390.             'msg' => null
  391.         ];
  392.         return $this;
  393.     }
  395.     /**
  396.      * Regular expression verification
  397.      * @param $reg
  398.      * @param null $msg
  399.      * @return $this
  400.      */
  401.     function regex($reg, $msg = null)
  402.     {
  403.         $this->ruleMap['regex'] = [
  404.             'arg' => $reg,
  405.             'msg' => $msg
  406.         ];
  407.         return $this;
  408.     }
  410.     /**
  411.      * Must have a value
  412.      * @param null $msg
  413.      * @return $this
  414.      */
  415.     function required($msg = null)
  416.     {
  417.         $this->ruleMap['required'] = [
  418.             'arg' => null,
  419.             'msg' => $msg
  420.         ];
  421.         return $this;
  422.     }
  424.     /**
  425.      * Value is a legal timestamp
  426.      * @param null $msg
  427.      * @return $this
  428.      */
  429.     function timestamp($msg = null)
  430.     {
  431.         $this->ruleMap['timestamp'] = [
  432.             'arg' => null,
  433.             'msg' => $msg
  434.         ];
  435.         return $this;
  436.     }
  438.     /**
  439.      * Timestamp before a specified date
  440.      * @param string $date Pass in any string that can be parsed by strtotime
  441.      * @param null $msg
  442.      * @return $this
  443.      */
  444.     function timestampBeforeDate($date, $msg = null)
  445.     {
  446.         $this->ruleMap['timestampBeforeDate'] = [
  447.             'arg' => $date,
  448.             'msg' => $msg
  449.         ];
  450.         return $this;
  451.     }
  453.     /**
  454.      * Timestamp after a specified date
  455.      * @param string $date Pass in any string that can be parsed by strtotime
  456.      * @param null $msg
  457.      * @return $this
  458.      */
  459.     function timestampAfterDate($date, $msg = null)
  460.     {
  461.         $this->ruleMap['timestampAfterDate'] = [
  462.             'arg' => $date,
  463.             'msg' => $msg
  464.         ];
  465.         return $this;
  466.     }
  468.     /**
  469.      * Specify a timestamp before a timestamp
  470.      * @param string|integer $beforeTimestamp before this timestamp
  471.      * @param null $msg
  472.      * @return $this
  473.      */
  474.     function timestampBefore($beforeTimestamp, $msg = null)
  475.     {
  476.         $this->ruleMap['timestampBefore'] = [
  477.             'arg' => $beforeTimestamp,
  478.             'msg' => $msg
  479.         ];
  480.         return $this;
  481.     }
  483.     /**
  484.      * Specify the timestamp after a timestamp
  485.      * @param string|integer $afterTimestamp after this timestamp
  486.      * @param null $msg
  487.      * @return $this
  488.      */
  489.     function timestampAfter($afterTimestamp, $msg = null)
  490.     {
  491.         $this->ruleMap['timestampAfter'] = [
  492.             'arg' => $afterTimestamp,
  493.             'msg' => $msg
  494.         ];
  495.         return $this;
  496.     }
  498.     /**
  499.      * Value is a legal link
  500.      * @param null $msg
  501.      * @return $this
  502.      */
  503.     function url($msg = null)
  504.     {
  505.         $this->ruleMap['url'] = [
  506.             'arg' => null,
  507.             'msg' => $msg
  508.         ];
  509.         return $this;
  510.     }
  512.     /**
  513.      * Value is a legal link
  514.      * @param null $msg
  515.      * @return $this
  516.      */
  517.     function allDigital($msg = null)
  518.     {
  519.         $this->ruleMap['allDigital'] = [
  520.             'arg' => null,
  521.             'msg' => $msg
  522.         ];
  523.         return $this;
  524.     }
  525. }