AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

几道无聊的php的比较运算题，有兴趣的玩一玩

2016-04-12 1401
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

趣题:
下面的几段代码分别输出true or false？

​第一个：


<?php
$key=1;
var_dump($key == " \t01ab");
?>

第二个： 


<?php
$key='1';
var_dump($key == " \t01ab");
?>

第三个： 


<?php
$key=0;
var_dump($key == " \t01ab");
?>

第四个： 


<?php
$key=0;
var_dump($key == " \t00ab");
?>

第五个： 


<?php
$key=0;
var_dump($key == " ab");
?>

第六个： 


<?php
$key='0';
var_dump($key == " ab");
?>

答案：
第一道：true

第二道：false

第三道：false

第四道：true

第五道：true

第六道：false

题解：
当比较的一方是数字时，字符串会转换成数字，然后再进行比较。

如果比较的两方全部为字符串时，当然就不存在转换，只是单纯的进行字符串比较了。

需要注意的是，字符串转换成数字时，如果字符串被视为十进制格式时，大概的转换规则如下：

1.过滤前面的一些字符。这些字符包括 空格，'\t' ，'\n' ， '\r' ，'\v' ， '\f' 和 0

2.把后面不是数字的字符和之后字符也过滤掉。如 123abc4 就会把a和之后的字符过滤掉。

思考题:
如果前面的== 改成 === 结果如何？
下面的代码输出true or false？


<?PHP
$a = 0;
if(in_array($a, array('index', 'post'))){
    echo "true";
}else{
    echo "false";
}
?>

进阶：
以上只是大概的转换规则，可能有说的不严谨的地方。具体的规则大家可以查看源码：

zend/zend_operators.c:1402行
这个方法说明了比较时，各种情况下比较规则。


ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
{
    int ret;
    int converted = 0;
    zval op1_copy, op2_copy;
    zval *op_free;
 
    while (1) {
        switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
            case TYPE_PAIR(IS_LONG, IS_LONG):
                ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
                return SUCCESS;
 
            case TYPE_PAIR(IS_DOUBLE, IS_LONG):
                Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2);
                ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
                return SUCCESS;
 
            case TYPE_PAIR(IS_LONG, IS_DOUBLE):
                Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2);
                ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
                return SUCCESS;
 
            case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
                if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) {
                    ZVAL_LONG(result, 0);
                } else {
                    Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
                    ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
                }
                return SUCCESS;
 
            case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
                zend_compare_arrays(result, op1, op2 TSRMLS_CC);
                return SUCCESS;
 
            case TYPE_PAIR(IS_NULL, IS_NULL):
                ZVAL_LONG(result, 0);
                return SUCCESS;
 
            case TYPE_PAIR(IS_NULL, IS_BOOL):
                ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
                return SUCCESS;
 
            case TYPE_PAIR(IS_BOOL, IS_NULL):
                ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
                return SUCCESS;
 
            case TYPE_PAIR(IS_BOOL, IS_BOOL):
                ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
                return SUCCESS;
 
            case TYPE_PAIR(IS_STRING, IS_STRING):
                zendi_smart_strcmp(result, op1, op2);
                return SUCCESS;
 
            case TYPE_PAIR(IS_NULL, IS_STRING):
                ZVAL_LONG(result, zend_binary_strcmp("", 0, Z_STRVAL_P(op2), Z_STRLEN_P(op2)));
                return SUCCESS;
 
            case TYPE_PAIR(IS_STRING, IS_NULL):
                ZVAL_LONG(result, zend_binary_strcmp(Z_STRVAL_P(op1), Z_STRLEN_P(op1), "", 0));
                return SUCCESS;
 
            case TYPE_PAIR(IS_OBJECT, IS_NULL):
                ZVAL_LONG(result, 1);
                return SUCCESS;
 
            case TYPE_PAIR(IS_NULL, IS_OBJECT):
                ZVAL_LONG(result, -1);
                return SUCCESS;
 
            case TYPE_PAIR(IS_OBJECT, IS_OBJECT):
                /* If both are objects sharing the same comparision handler then use is */
                if (Z_OBJ_HANDLER_P(op1,compare_objects) == Z_OBJ_HANDLER_P(op2,compare_objects)) {
                    if (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2)) {
                        /* object handles are identical, apparently this is the same object */
                        ZVAL_LONG(result, 0);
                        return SUCCESS;
                    }
                    ZVAL_LONG(result, Z_OBJ_HT_P(op1)->compare_objects(op1, op2 TSRMLS_CC));
                    return SUCCESS;
                }
                /* break missing intentionally */
 
            default:
                if (Z_TYPE_P(op1) == IS_OBJECT) {
                    if (Z_OBJ_HT_P(op1)->get) {
                        op_free = Z_OBJ_HT_P(op1)->get(op1 TSRMLS_CC);
                        ret = compare_function(result, op_free, op2 TSRMLS_CC);
                        zend_free_obj_get_result(op_free TSRMLS_CC);
                        return ret;
                    } else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
                        ALLOC_INIT_ZVAL(op_free);
                        if (Z_OBJ_HT_P(op1)->cast_object(op1, op_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) {
                            ZVAL_LONG(result, 1);
                            zend_free_obj_get_result(op_free TSRMLS_CC);
                            return SUCCESS;
                        }
                        ret = compare_function(result, op_free, op2 TSRMLS_CC);
                        zend_free_obj_get_result(op_free TSRMLS_CC);
                        return ret;
                    }
                }
                if (Z_TYPE_P(op2) == IS_OBJECT) {
                    if (Z_OBJ_HT_P(op2)->get) {
                        op_free = Z_OBJ_HT_P(op2)->get(op2 TSRMLS_CC);
                        ret = compare_function(result, op1, op_free TSRMLS_CC);
                        zend_free_obj_get_result(op_free TSRMLS_CC);
                        return ret;
                    } else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
                        ALLOC_INIT_ZVAL(op_free);
                        if (Z_OBJ_HT_P(op2)->cast_object(op2, op_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) {
                            ZVAL_LONG(result, -1);
                            zend_free_obj_get_result(op_free TSRMLS_CC);
                            return SUCCESS;
                        }
                        ret = compare_function(result, op1, op_free TSRMLS_CC);
                        zend_free_obj_get_result(op_free TSRMLS_CC);
                        return ret;
                    } else if (Z_TYPE_P(op1) == IS_OBJECT) {
                        ZVAL_LONG(result, 1);
                        return SUCCESS;
                    }
                }
                if (!converted) {
                    if (Z_TYPE_P(op1) == IS_NULL) {
                        zendi_convert_to_boolean(op2, op2_copy, result);
                        ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
                        return SUCCESS;
                    } else if (Z_TYPE_P(op2) == IS_NULL) {
                        zendi_convert_to_boolean(op1, op1_copy, result);
                        ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
                        return SUCCESS;
                    } else if (Z_TYPE_P(op1) == IS_BOOL) {
                        zendi_convert_to_boolean(op2, op2_copy, result);
                        ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
                        return SUCCESS;
                    } else if (Z_TYPE_P(op2) == IS_BOOL) {
                        zendi_convert_to_boolean(op1, op1_copy, result);
                        ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
                        return SUCCESS;
                    } else {
                        zendi_convert_scalar_to_number(op1, op1_copy, result);
                        zendi_convert_scalar_to_number(op2, op2_copy, result);
                        converted = 1;
                    }
                } else if (Z_TYPE_P(op1)==IS_ARRAY) {
                    ZVAL_LONG(result, 1);
                    return SUCCESS;
                } else if (Z_TYPE_P(op2)==IS_ARRAY) {
                    ZVAL_LONG(result, -1);
                    return SUCCESS;
                } else if (Z_TYPE_P(op1)==IS_OBJECT) {
                    ZVAL_LONG(result, 1);
                    return SUCCESS;
                } else if (Z_TYPE_P(op2)==IS_OBJECT) {
                    ZVAL_LONG(result, -1);
                    return SUCCESS;
                } else {
                    ZVAL_LONG(result, 0);
                    return FAILURE;
                }
        }
    }
}
/* }}} */

zend/zend_operators.c:132行
字符串转换数字是，前面字符过滤规则 


static inline zend_uchar is_numeric_string_ex(const char *str, int length, long *lval, double *dval, int allow_errors, int *oflow_info)
{
    const char *ptr;
    int base = 10, digits = 0, dp_or_e = 0;
    double local_dval;
    zend_uchar type;
 
    if (!length) {
        return 0;
    }
 
    if (oflow_info != NULL) {
        *oflow_info = 0;
    }
 
    /* Skip any whitespace
     * This is much faster than the isspace() function */
    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)) {
        /* Handle hex numbers
         * str is used instead of ptr to disallow signs and keep old behavior */
        if (length > 2 && *str == '0' && (str[1] == 'x' || str[1] == 'X')) {
            base = 16;
            ptr += 2;
        }
 
        /* Skip any leading 0s */
        while (*ptr == '0') {
            ptr++;
        }
 
        /* Count the number of digits. If a decimal point/exponent is found,
         * it's a double. Otherwise, if there's a dval or no need to check for
         * a full match, stop when there are too many digits for a long */
        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 < 1) {
                    goto process_double;
                } else if ((*ptr == 'e' || *ptr == 'E') && dp_or_e < 2) {
                    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) {
                if (oflow_info != NULL) {
                    *oflow_info = *str == '-' ? -1 : 1;
                }
                dp_or_e = -1;
                goto process_double;
            }
        } else if (!(digits < SIZEOF_LONG * 2 || (digits == SIZEOF_LONG * 2 && ptr[-digits] <= '7'))) {
            if (dval) {
                local_dval = zend_hex_strtod(str, &ptr);
            }
            if (oflow_info != NULL) {
                *oflow_info = 1;
            }
            type = IS_DOUBLE;
        }
    } else if (*ptr == '.' && ZEND_IS_DIGIT(ptr[1])) {
process_double:
        type = IS_DOUBLE;
 
        /* If there's a dval, do the conversion; else continue checking
         * the digits if we need to check for a full match */
        if (dval) {
            local_dval = zend_strtod(str, &ptr);
        } else if (allow_errors != 1 && dp_or_e != -1) {
            dp_or_e = (*ptr++ == '.') ? 1 : 2;
            goto check_digits;
        }
    } else {
        return 0;
    }
 
    if (ptr != str + length) {
        if (!allow_errors) {
            return 0;
        }
        if (allow_errors == -1) {
            zend_error(E_NOTICE, "A non well formed numeric value encountered");
        }
    }
 
    if (type == IS_LONG) {
        if (digits == MAX_LENGTH_OF_LONG - 1) {
            int cmp = strcmp(&ptr[-digits], long_min_digits);
 
            if (!(cmp < 0 || (cmp == 0 && *str == '-'))) {
                if (dval) {
                    *dval = zend_strtod(str, NULL);
                }
                if (oflow_info != NULL) {
                    *oflow_info = *str == '-' ? -1 : 1;
                }
 
                return IS_DOUBLE;
            }
        }
 
        if (lval) {
            *lval = strtol(str, NULL, base);
        }
 
        return IS_LONG;
    } else {
        if (dval) {
            *dval = local_dval;
        }
 
        return IS_DOUBLE;
    }
}


文章标签：
PHP
关键词：
PHP运算
exinnet
目录
相关文章
卡尔特斯
|
PHP
PHP - Laravel 三元运算
PHP - Laravel 三元运算
卡尔特斯
84 0
chengfengpolang
|
PHP
PHP为什么需要字符串运算？底层原理是什么？
PHP为什么需要字符串运算？底层原理是什么？
chengfengpolang
119 0
码农技术君
|
JavaScript Java PHP
Python/Java/PHP/JS三目运算表达式
Python/Java/PHP/JS三目运算表达式
码农技术君
122 0
技术小胖子
|
PHP
php新手入门之PHP常用特殊运算符号
技术小胖子
1224 0
玄学酱
|
PHP Perl Linux
PHP 中「自增、自减」运算引发的奇怪问题
玄学酱
1218 0
王伟wayne
|
存储 PHP
为什么php的浮点数运算不准确
例子： //例子 $a = 10.601; $b = 10.6009; echo $a- $b; // 结果如下 0.00010000000000154 结果错误，why? why 根本原因， 在某些情况下， 2 进制无法精确表示 10 进制的小数部分。
王伟wayne
1657 0
航空母舰
|
JavaScript Java PHP
JS/PHP 浮点数精确运算
航空母舰
3080 0
萝卜带泥
|
1月前
|
前端开发 关系型数据库 MySQL
PHP与MySQL动态网站开发实战指南####
【10月更文挑战第21天】 本文将深入浅出地探讨如何使用PHP与MySQL构建一个动态网站，从环境搭建到项目部署，全程实战演示。无论你是编程新手还是希望巩固Web开发技能的老手，都能在这篇文章中找到实用的技巧和启发。我们将一起探索如何通过PHP处理用户请求，利用MySQL存储数据，并最终呈现动态内容给用户，打造属于自己的在线平台。 ####
萝卜带泥
42 0
游客762btuqu5wybw666
|
23天前
|
存储 关系型数据库 MySQL
PHP与MySQL动态网站开发：从基础到实践####
本文将深入探讨PHP与MySQL的结合使用，展示如何构建一个动态网站。通过一系列实例和代码片段，我们将逐步了解数据库连接、数据操作、用户输入处理及安全防护等关键技术点。无论您是初学者还是有经验的开发者，都能从中获益匪浅。 ####
游客762btuqu5wybw666
36 6
游客762btuqu5wybw666
|
26天前
|
安全 关系型数据库 MySQL
PHP与MySQL动态网站开发实战指南####
——深入探索LAMP栈下的高效数据交互与处理技巧 ####
游客762btuqu5wybw666
30 9

热门文章

最新文章

  • 1
    linux安装php出现的错误
  • 2
    在Mac OS X 10.8中配置Apache ＋ PHP ＋ MySQL
  • 3
    让PHP 5.3支持MSSQL连接
  • 4
    php加密总结
  • 5
    PHP函数前面的@。
  • 6
    PHP-FPM小故障解决记录
  • 7
    安装php扩展
  • 8
    Nginx防盗链、Nginx访问控制、Nginx解析php相关配置、Nginx代理
  • 9
    PHP中空字符串介绍0、null、empty和false之间的关系
  • 10
    微信公众平台开发接口PHP SDK完整版
  • 1
    深入理解PHP7中的返回类型声明
    51
  • 2
    深入理解PHP的命名空间与自动加载机制
    63
  • 3
    PHP 7.4中新增特性的探索与实践
    49
  • 4
    深入理解PHP7的返回类型声明
    60
  • 5
    android通过http上传文件，服务器端用php写(原创)
    69
  • 6
    PHP医院安全不良事件管理系统源码（AEMS）前端vue2+element+后端laravel8不良事件上报与闭环管理
    86
  • 7
    深入理解PHP的命名空间与自动加载机制
    61
  • 8
    深入理解PHP的命名空间和自动加载机制
    45
  • 9
    网安之PHP基础练习
    49
  • 10
    1688快速获取整店铺列表 采集接口php Python
    59

    • 相关课程

    更多
  • PHP进阶教程 - 由浅入深掌握面向对象开发 - 第二阶段
  • PHP完全自学手册文档教程
  • 你的第一门C语言课

    • 相关电子书

    更多
  • 阿里云栖开发者沙龙PHP技术专场-直面PHP微服务架构挑战-高驰涛
  • PHP安全开发:从白帽角度做安全
  • PHP 2017.北京 全球开发者大会——高可用的PHP

    • 相关实验场景

    更多
  • 1分钟SAE部署PHP商城小程序
  • 10分钟Serverless部署PHP商城
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS