硬核项目经理

硬核项目经理 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

硬核项目经理 发布了文章 · 今天 15:12

PHP的switch和ifelse谁更快?

对于多个if条件判断的情况下,我们使用switch来代替ifelse对于代码来说会更加的清晰明了,那么他们的效率对比呢?从PHP手册中发现有人已经对比过了,自己也用他的代码进行了实验:


$s = time();
for ($i = 0; $i < 1000000000; ++$i) {
    $x = $i % 10;
    if ($x == 1) {
        $y = $x * 1;
    } elseif ($x == 2) {
        $y = $x * 2;
    } elseif ($x == 3) {
        $y = $x * 3;
    } elseif ($x == 4) {
        $y = $x * 4;
    } elseif ($x == 5) {
        $y = $x * 5;
    } elseif ($x == 6) {
        $y = $x * 6;
    } elseif ($x == 7) {
        $y = $x * 7;
    } elseif ($x == 8) {
        $y = $x * 8;
    } elseif ($x == 9) {
        $y = $x * 9;
    } else {
        $y = $x * 10;
    }
}
print("if: " . (time() - $s) . "sec\n");

$s = time();
for ($i = 0; $i < 1000000000; ++$i) {
    $x = $i % 10;
    switch ($x) {
        case 1:
            $y = $x * 1;
            break;
        case 2:
            $y = $x * 2;
            break;
        case 3:
            $y = $x * 3;
            break;
        case 4:
            $y = $x * 4;
            break;
        case 5:
            $y = $x * 5;
            break;
        case 6:
            $y = $x * 6;
            break;
        case 7:
            $y = $x * 7;
            break;
        case 8:
            $y = $x * 8;
            break;
        case 9:
            $y = $x * 9;
            break;
        default:
            $y = $x * 10;
    }
}
print("switch: " . (time() - $s) . "sec\n");

通过1000000000次的循环并在每个判断条件中都加入了运算操作后,我们发现结果是switch的效率更高,运行速度更快,在我的电脑上的结果是:


// if: 301sec
// switch: 255sec

虽然switch的效率更高一些,但也有需要注意的地方,首先,判断值只能是数字、浮点数或者是字符串。其次,每个判断都是普通的==判断,也就是说,下面的判断结果并不一定是你相像的结果:


$string = "2string";

switch ($string) {
    case 1:
        echo "this is 1";
        break;
    case 2:
        echo "this is 2";
        break;
    case '2string':
        echo "this is a string";
        break;
}

// this is 2

没错,依然是==比较时的类型强转问题,string和int值比较时强转为了int类型,"2string"强转的结果正是2。因此,在使用switch的时候,应该保证比较值和每个case的类型一致,否则就可能出现不可预计的错误。

参考代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E7%9A%84switch%E5%92%8Cifelse%E8%B0%81%E6%9B%B4%E5%BF%AB%EF%BC%9F.php

参考手册:https://www.php.net/manual/zh/control-structures.switch.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月25日

PHP没有定时器?

确实,PHP没有类似于JS中的setInterval或者setTimeout这样的原生定时器相关的函数。但是我们可以通过其他方式来实现,比如使用declare。

先来看看是如何实现的,然后我们再好好学习一下declare表达式到底是个什么东西。


function do_tick($str = '')
{
    list($sec, $usec) = explode(' ', microtime());
    printf("[%.4f] Tick.%s\n", $sec + $usec, $str);
}
register_tick_function('do_tick');

do_tick('--start--');
declare (ticks = 1) {
    while (1) {
        sleep(1); // 这里,每执行一次就去调用一次do_tick()
    }
}

很简单的代码,运行起来以后将每秒输出当前的时间。

declare语法的定义如下:
declare (directive)
    statemaent;
  • declare 结构用来设定一段代码的执行指令
  • directive 部分允许设定 declare 代码段的行为。目前只认识两个指令:ticks以及 encoding
  • Tick(时钟周期)是一个在 declare 代码段中解释器每执行 N 条可计时的低级语句就会发生的事件。N 的值是在 declare 中的 directive 部分用 ticks=N 来指定的
  • 在每个 tick 中出现的事件是由 register_tick_function() 来指定的

这里,我们只研究ticks的使用。

上述代码中,我们使用register_tick_function()注册了do_tick()方法给ticks,declare指定了ticks=1,也就是每执行一次可计时的低级语句,就会去执行一次register_tick_function()中注册的方法。当declare代码块中的while每次循环时,都有一个sleep()停顿了一秒,而这个sleep()就是那个可计时的低级语句。

那么,while()不是可计时的低级语句嘛?当然不是,where、if等条件判断都不是这种可计时的低级语句。

不是所有语句都可计时。通常条件表达式和参数表达式都不可计时。

我们通过下面这个例子再来看看具体到一步步declare是怎样执行的:


function test_tick()
{
    static $i = 0;
    echo 'test_tick:' . $i++, PHP_EOL;
}
register_tick_function('test_tick');
test_tick(); // test_tick:0

$j = 0; 
declare (ticks = 1) {
    $j++; // test_tick:1

    $j++; // test_tick: 2
    
    sleep(1); //  停1秒后,test_tick:3

    $j++; // test_tick:4

    if ($j == 3) { // 条件表达式,不会执行ticks

        echo "aa", PHP_EOL; // test_tick:5 \n   test_tick:6,PHP_EOL会计一次ticks
    }
}

// declare使用花括号后面所有代码无效果,作用域限定在花括号以内
echo "bbb"; // 
echo "ccc"; // 
echo "ddd"; // 

注释很详细了,我们就不用一一说明了。下面我们来看将ticks定为2,并且declare下面的statemaent不用花括号的结果:


function test_tick1() 
{
    static $i = 0;
    echo 'test_tick1:' . $i++, PHP_EOL;
}
register_tick_function('test_tick1');

$j = 0; // 此处不计时
declare (ticks = 2); 
$j++; // test_tick1:0 

$j++; 

sleep(1); //  停1秒后 test_tick1:1

$j++; 

$j++; // test_tick1:2

if ($j == 4) { // 条件表达式,不会执行ticks
    // echo "aa", PHP_EOL;
    echo "aa"; // test_tick:10,test_tick1不执行,没有跳两步,如果用了,PHP_EOL,那么算两步,会输出test_tick1:3
}

//  declare没有使用花括号将对后面所有代码起效果,如果是require或者include将不会对父页面后续内容进行处理
echo "bbb"; // test_tick1:3
echo "ccc";
echo "ddd"; // test_tick1:4

可以看出,我们declare对其定义后续的代码都产生了作用,但需要注意的是如果有页面嵌套,对父页面的后续代码是没有效果的。而定义了ticks=2之后,将在两个低级可计时代码后执行一次register_tick_function()注册的函数代码。

测试代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E6%B2%A1%E6%9C%89%E5%AE%9A%E6%97%B6%E5%99%A8%EF%BC%9F.php

参考文档:https://www.php.net/manual/zh/control-structures.declare.php

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月23日

PHP方法的返回值

不仅是PHP,大部分编程语言的函数或者叫方法,都可以用return来定义方法的返回值。从函数这个叫法来看,本身它就是一个计算操作,因此,计算总会有个结果,如果你在方法体中处理了结果,比如进行了持久化保存,那么这个函数就不用返回任何内容。而计算的结果是要给外部使用的,这时候就要将计算结果进行返回了。

 

return关键字

function testA($a, $b)
{
    echo $a + $b;
}

var_dump(testA(1, 2)); // NULL

function testB($a, $b)
{
    return $a + $b;
}

var_dump(testB(1, 2)); // 3

function testC($a, $b)
{
    return;
    echo $a + $b; // 后面不会执行了
}

var_dump(testC(1, 2)); // NULL

不用return或者直接return;都会返回NULL,return会阻断方法体中后续代码的执行。如果要返回多个值,只能使用数组组装数据。


function testD($a, $b)
{
    return [
        $a + $b,
        $a * $b,
    ];
}

var_dump(testD(1, 2)); // [3, 2]

 

返回值类型声明

关于返回值这一块还是比较好理解的。下面才是重头戏,在PHP7的新特性中,返回值声明是非常亮眼的一道风景。


function testE($a, $b) : bool
{
    if($a+$b == 3){
        return TRUE;
    }else{
        return NULL;
    }
}

var_dump(testE(1, 2)); // true
var_dump(testE(1.1, 2.2)); //TypeError: Return value of testE() must be of the type bool, null returned

如上例所示,如果返回值不是bool类型,那么将直接报TypeError的错误。

那么定义了返回值类型声明有什么好处呢?我们在PHP方法参数的那点事儿有介绍过类型声明的好处,这里就不过多赘述了,不管是参数类型声明还是返回值类型声明,都是一样的。


function testF($a, $b): array
{
    return [
        $a + $b,
        $a * $b,
    ];
}
var_dump(testF(1, 2)); // [3, 2]

interface iA{

}
class A implements iA
{}
class B extends A
{
    public $b = 'call me B!';
}

function testG(): A
{
    return new B();
}

function testH(): B
{
    return new B();
}

function testI(): iA
{
    return new B();
}

var_dump(testG()); // B的实例
var_dump(testH()); // B的实例
var_dump(testI()); // B的实例

同样,数组和类类型都是可以声明定义的。不过除此之外,返回值声明还可以定义void。它的作用其实就是声明返回值为NULL,不能直接写:NULL,而只能用:void来进行声明。


function testJ(): void
{
    echo "testJ";
    // return 1;
}
var_dump(testJ());

这时,如果尝试进行任何的return返回,都会直接报错:Fatal error: A void function must not return a value。

 

总结

我们可以看到,PHP在不断的发展中一直在吸取其他语言中的优秀特性。很明显,添加这些类型声明的目的就是为了将来的编译器做准备的。这也是PHP8的一个重要特性,让我们拭目以待吧!

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E6%96%B9%E6%B3%95%E7%9A%84%E8%BF%94%E5%9B%9E%E5%80%BC.php

参考文档:
https://www.php.net/manual/zh...

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月22日

PHP方法参数的那点事儿

在所有的编程语言中,方法或者函数,都可以传递一些参数进来进行业务逻辑的处理或者计算。这没什么可说的,但是在PHP中,方法的参数还有许多非常有意思的能力,下面我们就来说说这方面的内容。

引用参数

涉及到值传递和引用传递的问题。在正常情况下,我们使用值传递的时候,变量是进行了拷贝,方法内外的变量不会共享内存。也就是说,在方法体中修改了变量的值,方法外部的变量不会产生变化。而引用传递则是传递的变量的内存地值。方法内外的变量可以看做是同一个变量,比如:


$a = 1;
function test(&$arg){
    $arg++;
}
test($a);
echo $a; // 2

为参数加上&标识,就表明这个参数是引用传递的参数。如果没有加这个标识,则所有的基本类型参数都会以值的方式进行传递。为什么要强调基本类型呢?下面我们用类当参数来测试一下:


class A
{
    public $a = 1;
}
function testA($obj)
{
    $obj->a++;
}

$o = new A();
testA($o);
echo $o->a; // 2

在这个例子中,我们并没有使用&标识来表明参数$obj是引用类型的,但如果传递的参数是对象的话,那么它默认就是进行的引用传递。如果想让对象也是值传递呢?抱歉,在方法参数中是没办法实现的,只能在方法体中使用clone方式对对象参数进行克隆。


class A
{
    public $a = 1;
}
function testA($obj)
{
    $o = clone $obj;
    $o->a++;
}
$o = new A();
testA($o);
echo $o->a; // 1

关于值和引用的问题,可以参考设计模式中原型模式的讲解:
PHP设计模式之原型模式

默认参数

参数是可以有默认值的,这个我想大家都应该很清楚了。但是在使用的时候也需要注意,那就是默认参数不要放在前面,否则很容易出错,比如:


function testArgsA($a = 1, $b){
    echo $a+$b;
}

testArgs(); // error

function testArgsB($a = 1, $b = 2){
    echo $a+$b;
}

testArgsB(); // 3

function testArgsC($a, $b = 2){
    echo $a+$b;
}

testArgsC(1); // 3

在复杂的函数或者紧急的业务开发中,很有可能一个不小心就会漏写参数,这时候testArgsA就会返回错误了。当然,这种粗心类的错误是我们应该尽量避免的。

当指定默认值的时候,我们应该根据参数的类型进行指定,比如字符串就指定为'',数字就指定为数字类型。当不确定参数是什么类型时,建议使用NULL做为默认参数。


function testArgsD($a = NULL)
{
    if ($a) {
        echo $a;
    }
}

testArgsD(1);
testArgsD('a');
类型声明

类型声明是在PHP5之后添加的功能,就像java一样,参数前面加上参数的类型,比如:


function testAssignA(int $a = 0)
{
    echo $a;
}

testAssignA(1);
testAssignA("a"); // error

如果参数的类型不对,直接就会报错。在PHP7以前,只支持类、数组和匿名方法的类型声明。在PHP7之后,支持所有的普通类型,但是这里要注意的是,只支持普通类型的固定写法。

  • Class/interface name
  • self
  • array
  • callable
  • bool
  • float
  • int
  • string

固定写法是什么意思呢?


function testAssignB(integer $a = 0) // error
{
    echo $a;
}

也就是说,int只能写int,不能使用integer,bool也不能使用boolean。只能是上面列出的类型关键字。

类型声明的好处是什么呢?其实就是Java这种静态语言和PHP这种动态语言之间的差别。动态类型语言的好处就是变量灵活,不用指定类型,方便快速开发迭代。但问题也在于灵活,为了灵活,动态语言往往会在比较或者计算时对变量进行自动类型转换。如果你对变量类型转换的理解不清晰的话,很容易就会出现各种类型的BUG。同时,静态类型的语言一般都会有编译打包,而动态类型则是在执行时确定变量类型,所以很少会进行编译打包,相对来说运行效率也就不如Java之类的编译后语言了。

关于PHP的类型转换问题,可以参考此前的文章:
PHP中的强制类型转换

Tips一个小技巧,如果声明了参数类型,是不能传递NULL值的,比如:


function testAssignC(string $a = '')
{
    if ($a) {
        echo __FUNCTION__ . ':' . $a;
    }
}

testAssignC(NULL); // TypeError

这时有两种方式可以解决,一是指定默认值=NULL,二是使用?操作符:



function testAssignD(string $a = NULL)
{
    if ($a == NULL) {
        echo 'null';
    }
}

testAssignD(NULL); // null


function testAssignE(?string $a)
{
    if ($a == NULL) {
        echo 'null';
    }
}
testAssignE(NULL); // null
可变数量参数

php中的方法可以接收可变数量的参数,比如:


function testMultiArgsA($a)
{
    var_dump(func_get_arg(2));
    var_dump(func_get_args());
    var_dump(func_num_args());
    echo $a;
}

testMultiArgsA(1, 2, 3, 4);

我们只定义了一个参数$a,但是传进去了四个参数,这时我们可以使用三个方法来获取所有的参数:

  • func_get_arg(int $arg_num),获取参数列表中的某个指定位置的参数
  • func_get_args(),获取参数列表
  • func_num_args(),获取参数数量

此外,php还提供了...操作符,用于将可变长度的参数定义到一个参数变量中,如:


function testMultiArgsB($a, ...$b)
{
    var_dump(func_get_arg(2));
    var_dump(func_get_args());
    var_dump(func_num_args());
    echo $a;
    var_dump($b); // 除$a以外的
}

testMultiArgsB(1, 2, 3, 4);

和参数默认值一样,有多个参数的情况下,...$b也不要放在前面,这样后面的参数并不会有值,所有的参数都会在$b中。不过PHP默认已经帮我们解决了这个问题,如果...参数后面还有参数的话,会直接报错。

利用这个操作符,我们还可以很方便的解包一些数组或可迭代的对象给方法参数,例如:


function testMultiArgsC($a, $b){
    echo $a, $b;
}

testMultiArgsC(...[1, 2]);

是不是很有意思,那么我们利用这个特性来合并一个数组会是什么效果呢?


$array1 = [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];

$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
print_r($result);
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
print_r($result);
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
print_r($result);

和方法声明参数时一样,在外部使用...操作符给方法传递参数时,也不能在...后面再有其他参数,所以array_merge(...$array1, $array2)的操作会报错。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E6%96%B9%E6%B3%95%E5%8F%82%E6%95%B0%E7%9A%84%E9%82%A3%E7%82%B9%E4%BA%8B%E5%84%BF.php

参考文档:
https://www.php.net/manual/zh/functions.arguments.php
https://www.php.net/manual/zh/functions.arguments.php#121579

https://www.php.net/manual/zh/functions.arguments.php#120580

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月21日

PHP中用+号连接数组的结果是?

我们在开发中,有时候会将两个数组合并连接起来,这个时候要注意了,千万不要偷懒直接使用+号哦,为什么呢?我们看看以下代码:


$a = [1, 2];
$b = [4, 5, 6];

$c = $a + $b;
print_r($c);

请用第一直接告诉我它的结果是什么?或许我这么问你应该能猜到,它的结果是:


Array
(
    [0] => 1
    [1] => 2
    [2] => 6
)

看出来了吧,用+号操作符连接的数组,结果取的是并集。也就是根据键,相同键的不会覆盖,没有键加入进来形成一个新数组。并不是将两个数组真的加起来。

如果我们用$b+$a呢?那么结果就是$b的内容。


$c = $b + $a;
print_r($c);

Array
(
    [0] => 4
    [1] => 5
    [2] => 6
)

那么我们要获得1,2,4,5,6这样一个数组要怎么办呢?没错,使用array_merge()函数,请注意数组Key的位置:


$c = array_merge($a, $b);
print_r($c);

Array
(
    [0] => 1
    [1] => 2
    [2] => 4
    [3] => 5
    [4] => 6
)

$c = array_merge($b, $a);
print_r($c);

Array
(
    [0] => 4
    [1] => 5
    [2] => 6
    [3] => 1
    [4] => 2
)

如果是key/value形式的Hash数组呢?结果也是一样的,$a中没有键将合并过来,相同的键将不处理。


$a = ['a' => 1, 'b' => 2];
$b = ['a' => 4, 'b' => 5, 'c' => 6];

print_r($a+$b);

Array
(
    [a] => 1
    [b] => 2
    [c] => 6
)

$c = array_merge($a, $b);
print_r($c);

$c = array_merge($b, $a);
print_r($c);

Array
(
    [a] => 1
    [b] => 2
    [c] => 6
)
Array
(
    [a] => 4
    [b] => 5
    [c] => 6
)
Array
(
    [a] => 1
    [b] => 2
    [c] => 6
)

上述Hash数组,使用array_merge()函数的结果和使用+号的结果是一样的,这是因为他们还是进行了键的对比。所以合并后的数组不会增加内容,如果是未定义下标的则会直接以数字下标添加进去。

最后,我们再试试.操作符的连接:


$c = $a . $b;
print_r($c);

ArrayArray

好吧,强转成string类型的字符串再拼接起来了,并无特别的意义。

测试代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E4%B8%AD%E7%94%A8%2B%E5%8F%B7%E8%BF%9E%E6%8E%A5%E6%95%B0%E7%BB%84%E7%9A%84%E7%BB%93%E6%9E%9C%E6%98%AF%EF%BC%9F.php

参考文档:https://www.php.net/manual/zh/language.operators.array.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月20日

PHP中使用if的时候为什么建议将常量放在前面?

在某些框架或者高手写的代码中,我们会发现有不少人喜欢在进行条件判断的时候将常量写在前面,比如:


if(1 == $a){
    echo 111;
}

这样做有什么好处呢?我们假设一个不小心的粗心大意,少写了一个=号,会有什么结果。


$a = 'a';
if($a = 'b'){
    echo 111;
}
echo $a;

没错,111输出了,$a的值也变成了b。少了一个等号,就变成了赋值操作,这样的操作会先给$a赋值,然后根据$a的值进行判断。如果$a = '',就不会输出111,但是$a的值还是会变成''。

划重点:这样的写法php是不会报错的,这也是有可能造成BUG的情况。

那么反过来呢?


$a = 'a';
if('b' = $a){
    echo 111;
}

首先,大部分的IDE都会报语法错误,也就是直接划红线了。常量是不能被赋值修改的,不管是数字、字符串还是系统或者我们自己已经定义了的常量。

其次,这种情况下你要是还发现不了这里有问题的话也没关系,运行起来也会报错的,代码是无法继续向下运行的。

当然,这只是一个小技巧,而且最主要的目的是为了应对粗心带来的问题。所以并不是强制的规范,有些公司可能会在代码审计或者规范文档中强调这样写法,当然,最好的还是我们要杜绝这种粗心带来的错误。

测试代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/PHP%E4%B8%AD%E4%BD%BF%E7%94%A8if%E7%9A%84%E6%97%B6%E5%80%99%E4%B8%BA%E4%BB%80%E4%B9%88%E5%BB%BA%E8%AE%AE%E5%B0%86%E5%B8%B8%E9%87%8F%E6%94%BE%E5%9C%A8%E5%89%8D%E9%9D%A2%EF%BC%9F.php

===========

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月19日

goto语法在PHP中的使用

在C++、Java及很多语言中,都存在着一个神奇的语法,就是goto。顾名思义,它的使用是直接去到某个地方。从来代码的角度来说,也就是直接跳转到指定的地方。我们的PHP中也有这个功能,我们先来看看它是如何使用的:

goto a;
echo "1"; // 不会输出

a:
echo '2'; // 2

代码运行到goto位置时,就跳转到了a:所在的代码行并继续执行下去。感觉很好玩吧,这个功能对于复杂的嵌套if或者在一些循环中进行跳出很有用,特别是针对某些异常或者错误情况的处理,比如:

for ($i = 0, $j = 50; $i < 100; $i++) {
    while ($j--) {
        if ($j == 17) { // 假设$j==17是一种异常情况
            goto end; // 直接跳走了,循环结束的结果也不输出了
        }

    }
}
echo "i = $i";
end:
echo 'j hit 17'; // 直接到这里输出或者处理异常情况了

感觉还不错是吧,不过goto语法也有一些限制情况:

  • 目标位置只能位于同一个文件和作用域,也就是说无法跳出一个函数或类方法,也无法跳入到另一个函数
  • 无法跳入到任何循环或者 switch 结构中
  • 跳出循环或者 switch,通常的用法是用 goto 代替多层的 break

比如以下的代码都是无效的:

$a = 1;
goto switchgo;
switch ($a){
    case 1:
        echo 'bb';
    break;
    case 2:
        echo 'cc';
        switchgo:
            echo "bb";
    break;
}

goto whilego;
while($a < 10){
    $a++;
    whilego:
        echo $a;
}


// Fatal error: 'goto' to undefined label 'ifgo' 

它们都会报同样的错误,因为作用域的关系无法找到定义的goto标签。另外还需要注意的,使用goto可能引起死循环,如下所示:

b:
    echo 'b';

goto b;

代码执行到goto时,跳回了之前的b标签行,然后继续向下执行,又到goto了,成为了一个死循环。有点像while(true)的感觉了。但是,在这个goto循环里是没有break的,只能在goto出去到别的地方。

所以,goto这个语法的使用非常少,因为它会扰乱你的代码逻辑流程,但喜欢它的人又会感觉到可以让代码非常地灵活多变。这就要仁者见仁智者见智的进行选择了,目前大多数语言的文档中都并不是很提倡使用这个语法,包括PHP。我的建议是,如果不是非常特殊的情况或者是为了炫技,尽量不要使用goto语法,当项目代码复杂起来后,很容易让别人或者自己看懵。

测试代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/goto%E8%AF%AD%E6%B3%95%E5%9C%A8PHP%E4%B8%AD%E7%9A%84%E4%BD%BF%E7%94%A8.md

参考文档:https://www.php.net/manual/zh/control-structures.goto.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月18日

还不知道PHP有闭包?那你真OUT了

做过一段时间的Web开发,我们都知道或者了解JavaScript中有个非常强大的语法,那就是闭包。其实,在PHP中也早就有了闭包函数的功能。早在5.3版本的PHP中,闭包函数就已经出现了。到了7以及后来的现代框架中,闭包函数的使用更是无处不在。在这里,我们就先从基础来了解PHP中闭包的使用吧!

闭包函数(closures)在PHP中都会转换为 Closure 类的实例。在定义时如果是赋值给变量,在结尾的花括号需要添加;分号。闭包函数从父作用域中继承变量,任何此类变量都应该用 use 语言结构传递进去。 PHP 7.1 起,不能传入此类变量:superglobals、 $this 或者和参数重名。

基础语法

闭包的使用非常简单,和JavaScript也非常相似。因为他们都有另外一个别名,叫做匿名函数。


$a = function () {
    echo "this is testA";
};
$a(); // this is testA


function testA ($a) {
    var_dump($a); 
}
testA($a); // class Closure#1 (0) {}

$b = function ($name) {
    echo 'this is ' . $name;
};

$b('Bob'); // this is Bob

我们将$a和$b两个变量直接赋值为两个函数。这样我们就可以使用变量()的形式调用这两个函数了。通过testA()方法,我们可以看出闭包函数是可以当做普通参数传递的,因为它自动转换成为了 Closure 类的实例。


$age = 16;
$c = function ($name) {
    echo 'this is ' . $name . ', Age is ' . $age;
};

$c('Charles'); // this is Charles, Age is

$c = function ($name) use ($age) {
    echo 'this is ' . $name . ', Age is ' . $age;
};

$c('Charles'); // this is Charles, Age is 16

如果我们需要调用外部的变量,需要使用use关键字来引用外部的变量。这一点和普通函数不一样,因为闭包有着严格的作用域问题。对于全局变量来说,我们可以使用use,也可以使用global。但是对于局部变量(函数中的变量)时,只能使用use。这一点我们后面再说。

作用域

function testD(){
    global $testOutVar;
    echo $testOutVar;
}
$d = function () use ($testOutVar) {
    echo $testOutVar;
};
$dd = function () {
    global $testOutVar;
    echo $testOutVar;
};
$testOutVar = 'this is d';
$d(); // NULL
testD(); // this is d
$dd(); // this is d

$testOutVar = 'this is e';
$e = function () use ($testOutVar) {
    echo $testOutVar;
};
$e(); // this is e

$testOutVar = 'this is ee';
$e(); // this is e

$testOutVar = 'this is f';
$f = function () use (&$testOutVar) {
    echo $testOutVar;
};
$f(); // this is f

$testOutVar = 'this is ff';
$f(); // this is ff

在作用域中,use传递的变量必须是在函数定义前定义好的,从上述例子中可以看出。如果闭包($d)是在变量($testOutVar)之前定义的,那么$d中use传递进来的变量是空的。同样,我们使用global来测试,不管是普通函数(testD())或者是闭包函数($dd),都是可以正常使用$testOutVar的。

在$e函数中的变量,在函数定义之后进行修改也不会对$e闭包内的变量产生影响。这时候,必须要使用引用传递($f)进行修改才可以让闭包里面的变量产生变化。这里和普通函数的引用传递与值传递的概念是相同的。

除了变量的use问题,其他方面闭包函数和普通函数基本没什么区别,比如进行类的实例化:


class G
{}
$g = function () {
    global $age;
    echo $age; // 16
    $gClass = new G();
    var_dump($gClass); // G info
};
$g();
类中作用域

关于全局作用域,闭包函数和普通函数的区别不大,主要的区别体现在use作为桥梁进行变量传递时的状态。在类方法中,有没有什么不一样的地方呢?


$age = 18;
class A
{
    private $name = 'A Class';
    public function testA()
    {
        $insName = 'test A function';
        $instrinsic = function () {
            var_dump($this); // this info
            echo $this->name; // A Class
            echo $age; // NULL
            echo $insName; // null
        };
        $instrinsic();

        $instrinsic1 = function () {
            global $age, $insName;
            echo $age; // 18
            echo $insName; // NULL
        };
        $instrinsic1();

        global $age;
        $instrinsic2 = function () use ($age, $insName) {
            echo $age; // 18
            echo $insName; // test A function
        };
        $instrinsic2();

    }
}

$aClass = new A();
$aClass->testA();
  • A::testA()方法中的$insName变量,我们只能通过use来拿到。
  • 闭包函数中的$this是调用它的环境的上下文,在这里就是A类本身。闭包的父作用域是定义该闭包的函数(不一定是调用它的函数)。静态闭包函数无法获得$this。
  • 全局变量依然可以使用global获得。
小技巧

了解了闭包的这些特性后,我们可以来看几个小技巧:


$arr1 = [
    ['name' => 'Asia'],
    ['name' => 'Europe'],
    ['name' => 'America'],
];

$arr1Params = ' is good!';
// foreach($arr1 as $k=>$a){
//     $arr1[$k] = $a . $arr1Params;
// }
// print_r($arr1);

array_walk($arr1, function (&$v) use ($arr1Params) {
    $v .= ' is good!';
});
print_r($arr1);

干掉foreach:很多数组类函数,比如array_map、array_walk等,都需要使用闭包函数来处理。上例中我们就是使用array_walk来对数组中的内容进行处理。是不是很有函数式编程的感觉,而且非常清晰明了。


function testH()
{
    return function ($name) {
        echo "this is " . $name;
    };
}
testH()("testH's closure!"); // this is testH's closure!

看到这样的代码也不要懵圈了。PHP7支持立即执行语法,也就是JavaScript中的IIFE(Immediately-invoked function expression)。

我们再来一个计算斐波那契数列的:


$fib = function ($n) use (&$fib) {
    if ($n == 0 || $n == 1) {
        return 1;
    }

    return $fib($n - 1) + $fib($n - 2);
};

echo $fib(10);

同样的还是使用递归来实现。这里直接换成了闭包递归来实现。最后有一点要注意的是,use中传递的变量名不能是带下标的数组项:


$fruits = ['apples', 'oranges'];
$example = function () use ($fruits[0]) { // Parse error: syntax error, unexpected '[', expecting ',' or ')'
    echo $fruits[0]; 
};
$example();

这样写直接就是语法错误,无法成功运行的。

彩蛋

Laravel中的IoC服务容器中,大量使用了闭包能力,我们模拟一个便于大家理解。当然,更好的方案是自己去翻翻Laravel的源码。

class B
{}
class C
{}
class D
{}
class Ioc
{
    public $objs = [];
    public $containers = [];

    public function __construct()
    {
        $this->objs['b'] = function () {
            return new B();
        };
        $this->objs['c'] = function () {
            return new C();
        };
        $this->objs['d'] = function () {
            return new D();
        };
    }
    public function bind($name)
    {
        if (!isset($this->containers[$name])) {
            if (isset($this->objs[$name])) {
                $this->containers[$name] = $this->objs[$name]();
            } else {
                return null;
            }
        }
        return $this->containers[$name];
    }
}

$ioc = new Ioc();
$bClass = $ioc->bind('b');
$cClass = $ioc->bind('c');
$dClass = $ioc->bind('d');
$eClass = $ioc->bind('e');

var_dump($bClass); // B
var_dump($cClass); // C
var_dump($dClass); // D
var_dump($eClass); // NULL
总结

闭包特性经常出现的地方是事件回调类的功能中,另外就是像彩蛋中的IoC的实现。因为闭包有一个很强大的能力就是可以延迟加载。IoC的例子我们的闭包中返回的是新new出来的对象。当我们的程序运行的时候,如果没有调用$ioc->bind('b'),那么这个B对象是不会创建的,也就是说这时它还不会占用资源占用内存。而当我们需要的时候,从服务容器中拿出来的时候才利用闭包真正的去创建对象。同理,事件的回调也是一样的概念。事件发生时在我们需要处理的时候才去执行回调里面的代码。如果没有闭包的概念,那么$objs容器就这么写了:


$this->objs['b'] = new B();
$this->objs['c'] = new C();
$this->objs['d'] = new D();

容器在实例化的时候就把所有的类都必须实例化了。这样对于程序来说很多用不上的对象就都被创建了,带来非常大的资源浪费。

基于闭包的这种强大能力,现在闭包函数已经在Laravel、TP6等框架中无处不在了。学习无止尽,掌握原理再去学习框架往往更能事半功倍。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/201911/source/%E8%BF%98%E4%B8%8D%E7%9F%A5%E9%81%93PHP%E6%9C%89%E9%97%AD%E5%8C%85%EF%BC%9F%E9%82%A3%E4%BD%A0%E7%9C%9FOUT%E4%BA%86.php

参考文档:
https://www.php.net/manual/zh/functions.anonymous.php
https://www.php.net/manual/zh/functions.anonymous.php#100545

https://www.php.net/manual/zh/functions.anonymous.php#119388

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月16日

注意!PHP中字符串与数字的比较

在日常开发过程中,==运算符是我们每天都会接触到的。这个运算符中其实埋了非常多的坑,今天我们就来看下字符串和数字用==比较需要注意的问题。

首先来看看这些代码:


echo '"1234" == " 1234" is ' . ('1234' == ' 1234'), PHP_EOL;
echo '"1234" == "\n1234" is ' . ('1234' == "\n1234"), PHP_EOL;
echo '"1234" == "1234" is ' . ('1234' == '1234'), PHP_EOL;
echo '"1234" == "1234 " is ' . ('1234' == '1234 '), PHP_EOL;
echo '"1234" == "1234\n" is ' . ('1234' == "1234\n"), PHP_EOL;

都是字符串的==操作,它们的结果会是什么呢?


"1234" == " 1234" is 1
"1234" == "\n1234" is 1
"1234" == "1234" is 1
"1234" == "1234 " is 
"1234" == "1234\n" is 

没错,空格或者制表符号在前的会忽略掉这些符号,也就是说,这些字符串在对比的时候进行了类型转换,都被强转成了int型。而特殊字符在后的,则会按照字符串类型进行比对,那么,纯字符类型呢?


echo '"aa" == " aa" is ' . ('aa' == ' aa'), PHP_EOL;
echo '"aa" == "\naa" is ' . ('a' == '\naa'), PHP_EOL;
echo '"aa" == "aa" is ' . ('aa' == 'aa'), PHP_EOL;
echo '"aa" == "aa " is ' . ('aa' == 'aa '), PHP_EOL;
echo '"aa" == "aa\n" is ' . ('aa' == "aa\n"), PHP_EOL;

这时候的结果就符合我们的预期了,他们本身就是字符串的比对,不会进行任何类型的转换:


"aa" == " aa" is 
"aa" == "\naa" is 
"aa" == "aa" is 1
"aa" == "aa " is 
"aa" == "aa\n" is 

综上实验结果得知,当字符串的内容都是int数据时,字符串的==比较会忽略在字符串前面出现的空格或者制表符号将它们强制转换成int类型。而只要字符串中包含文本或者特殊符号在数字的后面,就会以文本方式进行比较,如纯文本或者混合文本("11aa"、"11n"、"aa11 ")。

测试代码:https://github.com/zhangyue0503/dev-blog/blob/master/php/201910/source/%E6%B3%A8%E6%84%8F%EF%BC%81PHP%E4%B8%AD%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%8E%E6%95%B0%E5%AD%97%E7%9A%84%E6%AF%94%E8%BE%83.php

参考链接:https://www.php.net/manual/zh/language.operators.comparison.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 0 收藏 0 评论 0

硬核项目经理 发布了文章 · 1月15日

关于PHP数组Key的强制类型转换

PHP是弱类型语言,就像JavaScript一样,在定义变量时,不需要强制指定变量的类型。同时,PHP又有着强大的数组功能,数组的Key即可以是普通的数字类型下标,也可以是字符串类型的Hash键值,那么,当一个数组的Key同时拥有字符串和数字时,会产生什么情况呢?

首先来看下面这样一段代码:


$arr = [
    "1" => "a",
    "01" => "b",
    1 => "aa",
    1.1 => "aaa",
    "0.1" => "bb",
];

var_dump($arr);

// array(3) {
//     [1] =>
//     string(3) "aaa"
//     '01' =>
//     string(1) "b"
//     '0.1' =>
//     string(2) "bb"
// }

咦?我们定义的"1"、1下标的值都变成了1.1的"aaa"了?

没错,PHP中的数组Key值只接受数字和字符串类型,当Key是字符串时,会强强制转换为数字类型,遵守类型强制转换的规则。浮点数也是同样的道理,直接转换成了向下取整的整型。

那么"0.1"和"01"为什么还在?首先,"01"不是标准的十进制数值,无法转换成整型,所以"01"还是一个字符串下标,那"0.1"呢?它当然也不是一个标准的十进制数值。这里是违背了字符串转型数字的强制类型转换原则的,在变量的强制转换中,这两种字符串都会被转换为0,但在数组中则不会,这里会是一个坑,也是需要注意的地方。

在PHP官方文档中给出的Key值转换说明如下:

  • 包含有合法整型值的字符串会被转换为整型。例如键名 "8" 实际会被储存为 8。但是 "08" 则不会强制转换,因为其不是一个合法的十进制数值。
  • 浮点数也会被转换为整型,意味着其小数部分会被舍去。例如键名 8.7 实际会被储存为 8。
  • 布尔值也会被转换成整型。即键名 true 实际会被储存为 1 而键名 false 会被储存为 0。
  • Null 会被转换为空字符串,即键名 null 实际会被储存为 ""。
  • 数组和对象不能被用为键名。坚持这么做会导致警告:Illegal offset type。

接下来,是笔者曾经做过的一道面试题,和这个类型转换有着非常大的关系,代码如下:


$a      = ['a'];
$a[2]   = 'b';
$a[]    = 'c';
$a['1'] = 'd';

// 以下循环的输出结果是?
foreach ($a as $v) {
    echo $v, ',';
}

// 以下循环的输出结果是?
for ($i = 0; $i < count($a); ++$i) {
    echo $a[$i], '  ,';
}

大家先不要运行,直接看代码看看能不能看出这两段代码的输出结果会是什么,然后运行一下,看看结果和你想像的是不是一样。

测试代码:
https://github.com/zhangyue0503/dev-blog/blob/master/php/201910/source/%E5%85%B3%E4%BA%8EPHP%E6%95%B0%E7%BB%84Key%E7%9A%84%E5%BC%BA%E5%88%B6%E8%BD%AC%E6%8D%A2.php

参考资料:

https://www.php.net/manual/zh/language.types.array.php

各自媒体平台均可搜索【硬核项目经理】

查看原文

赞 1 收藏 0 评论 0

认证与成就

  • 获得 4 次点赞
  • 获得 0 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 0 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-09-21
个人主页被 989 人浏览