PHP date string comparison example

There is a function in the project that compares whether members have expired. I reviewed my colleague’s code and found that the writing method was rather strange, but there were no bugs online.

Achievement:

$expireTime = "2014-05-01 00:00:00";
$currentTime = date('Y-m-d H:i:s', time());

if($currentTime  return false;
} else {
 return true;
}

If two times need to be compared, it is usually converted to a unix timestamp, using two int numbers. Compare. This implementation specifically expresses time as a string, and then performs a comparison operation on the two strings.

Writing aside, I am very curious about how comparison is performed internally in PHP.

Without further ado, let’s start tracking from the source code.

Compilation period Syntax similar to the following can be found in zend_language_parse.y: =expr === Expr {Zend_do_binary_op (ZEND_IS_IDENTICAL, & $ 1, & $ 3 TSRMLS_CC); Identical, & $ $, & $ 1, & $ 3 TSRMLS_CC ); }

expr == expr { zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }

expr != expr { zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 TSRMLS_CC); }

expr expr expr > expr { zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 TSRMLS_CC); }

expr >= expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 TSRMLS_CC); }

Copy code

Obviously, zend_do_binary_op is used to compile opcode here.

void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */

{

zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC );

 opline->result.u.var = get_temporary_variable(CG(active_op_array));
 opline->op1 = *op1;
 opline->op2 = *op2;
 *result = opline->result;
}



Copy code


This function does not do any special processing, it just simply saves the opcode and operands 1 and operand 2.

static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)

{

zend_op *opline = EX(opline);

 compare_function( result,
 &opline->op1.u.constant,
 &opline->op2.u.constant TSRMLS_CC);
 ZVAL_BOOL(result, (Z_LVAL_P(result)

 ZEND_VM_NEXT_OPCODE();
 }



Copy the code


Notice that the comparison of two zvals is handled by compare_function.

ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */

{

int ret;

 while (1) {
 switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
 case TYPE_PAIR(IS_LONG, IS_LONG):
 ...
 case TYPE_PAIR(IS_DOUBLE, IS_LONG):
 ...
 case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
 ...
 ...
 // Compare two strings
 case TYPE_PAIR(IS_STRING, IS_STRING):
 zendi_smart_strcmp(result, op1, op2);
 return SUCCESS;
 ...
 }
 }
}



Copy code


This function exemplifies several situations. According to the case in this article, enter zendi_smart_strcmp to get a closer look:
 

ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */
{
 int ret1, ret2;
 long lval1, lval2;
 double dval1, dval2;

 // Try to convert the string to a numeric type
 if ((ret1=is_numeric_string(Z_STRVAL_P(s1), Z_STRLEN_P(s1), &lval1, &dval1, 0)) &&
 (ret2=is_numeric_string(Z_STRVAL_P(s2), Z_STRLEN_P( s2), &lval2, &dval2, 0))) {
 // Compare numbers
 ...
 } else {
 // All cannot be converted into numbers
 // Then call zend_binary_zval_strcmp
 // Essentially memcmp One layer of encapsulation
 Z_LVAL_P(result) = zend_binary_zval_strcmp(s1, s2);
 ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result)));
 }
}
 Then "2014-05-01 Can 00:00:00" be converted into a number? 
You still have to look at the implementation rules of is_numeric_string.
 

static inline zend_uchar is_numeric_string(const char *str, int length, long *lval, double *dval, int allow_errors)
{
 const char *ptr;
 int base = 10, digits = 0, dp_or_e = 0;
 double local_dval;
 zend_uchar type;

 if (!length) {
 return 0;
 }

 /* trim out the blank part at the beginning of the string*/
 while (*str == ' ' || * str == 't' || *str == 'n' || *str == 'r' || *str == 'v' || *str == 'f') {
 str++;
 length- -;
 }
 ptr = str;

 if (*ptr == '-' || *ptr == '+') {
 ptr++;
 }

 if (ZEND_IS_DIGIT(*ptr)) {
 /* Determine whether it is hexadecimal */
 if (length > 2 && *str == '0' && (str[1] == 'x' || str[1] == 'X')) {
 base = 16;
 ptr += 2;
 }

 /* Ignore the following 0s */
 while (*ptr == '0') {
 ptr++;
 }

 /* Calculate the number of digits in the number, and Determine whether it is integer or floating point*/
 for (type = IS_LONG; !(digits >= MAX_LENGTH_OF_LONG && (dval || allow_errors == 1)); digits++, ptr++) {
check_digits:
 if (ZEND_IS_DIGIT(*ptr ) || (base == 16 && ZEND_IS_XDIGIT(*ptr))) {
 continue;
 } else if (base == 10) {
 if (*ptr == '.' && dp_or_e  goto process_double;
 } else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e  const char *e = ptr + 1;

 if (*e == '-' || *e == '+') {
 ptr = e++;
 }
 if (ZEND_IS_DIGIT(*e)) {
 goto process_double;
 }
 }
 }

 break;
 }

 if (base == 10) {
 if (digits >= MAX_LENGTH_OF_LONG) {
 dp_or_e = -1;
 goto process_double;
 }
 } else if (!(digits  if (dval) {
 local_dval = zend_hex_strtod(str, (char **)&ptr);
 }
 type = IS_DOUBLE;
 }
 } else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
 // Process floating point numbers
 } else {
 return 0;
 }

 // If fault tolerance is not allowed, exit with an error
 if ( ptr != str + length) {
 if (!allow_errors) {
 return 0;
 }
 if (allow_errors == -1) {
 zend_error(E_NOTICE, "A non well formed numeric value encountered");
 }
 }

 // To allow fault tolerance, try to convert str into numbers
 if (type == IS_LONG) {
 if (digits == MAX_LENGTH_OF_LONG - 1) {
 int cmp = strcmp(&ptr[-digits], long_min_digits);

 if (!(cmp  if (dval) {
 *dval = zend_strtod(str, NULL);
 }

 return IS_DOUBLE;
 }
 }

 if (lval) {
 *lval = strtol(str, NULL, base);
 }

 return IS_LONG;
 } else {
 if (dval) {
 *dval = local_dval;
 }

 return IS_DOUBLE;
 }
}

The code is relatively long, but if you read it carefully, the rules for converting str to num are still very clear. 
Pay special attention to the allow_errors parameter, which directly determines that "2014-05-01 00:00:00" cannot be converted into a number in this example. 
So in the end, the operation of "2014-04-17 00:00:00" 

Since it is memcmp, it is not difficult to understand why the writing method mentioned at the beginning of the article can also run correctly. 
Fault-tolerant conversion
When is allow_errors true? An excellent example is zend_parse_parameters. The implementation of zend_parse_parameters will not be described in detail. Interested readers can study it by themselves. When calling is_numeric_string, allow_errors is set to -1. 
For example:
 

static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
{
 char *format;
 int format_len;
 long ts;
 char *string;

 // The expected second parameter is timestamp, which is long
 // Assuming that the string is mistakenly passed in when the upper layer is called, zend_parse_parameters will still try to parse the string into long as much as possible
 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &ts) = = FAILURE) {
 RETURN_FALSE;
 }
 if (ZEND_NUM_ARGS() == 1) {
 ts = time(NULL);
 }

 string = php_format_date(format, format_len, ts, localtime TSRMLS_CC);

 RETVAL_STRING( string, 0);
}

This is the internal implementation of PHP's date function. 
When calling date, if the second parameter is passed into string, the effect is as follows:
 

echo date('Y-m-d', '0-1-2');

// Output
PHP Notice: A non well formed numeric value encountered in Command line code on line 1
1970- 01-01

Although a notice level error was reported, '0-1-2' was still successfully converted to 0