PHP中更好/更快/更高效的是什么？
使用额外变量：
$dateStep = new DateInterval('P1D');
for($di = 0; $di <= $dateInterval; ++$di)
{
$theDate = ($di > 0) ? $startDate->add($dateStep) : $startDate;
...
}
每次需要时创建对象：
for($di = 0; $di <= $dateInterval; ++$di)
{
$theDate = ($di > 0) ? $startDate->add(new DateInterval('P1D')) : $startDate;
...
}
我投票给第一个选项，但我在PHP中的优化和性能方面的知识非常有限。
编辑：看来，我没有表达足够的内容，但我要专门针对这样的场景 - 当对象的创建返回静态值时，即在循环中一遍又一遍地使用。
答案 0 :(得分：2)
我将使用以下
$dateStep = new DateInterval('P1D');
for($di = 0; $di > $dateInterval; ++$di)
{
$theDate = ($di > 0) $startDate->add($dateStep);
...
}
除非确实需要，否则不建议在循环内反复创建对象。在上面的例子中，在循环之前创建了对象，并且传递了对象，节省了时间（用于创建另一个对象）和空间（通过不在内存中创建另一个对象）。
答案 1 :(得分：2)
两个版本在逻辑上都不同。
第一个版本多次传递相同的对象引用。这意味着如果您在循环后更改$dateStep，则更改引用的所有。
每次调用方法时，第二个版本都会对单个对象应用引用。
在使用DateTime::add()方法的示例中，$dateStep可视为不会更改的常量值。在这种情况下，第一个版本更快更好，因为它不需要每次调用构造函数，并且它需要更少的内存，因为对象只需要创建一次。
答案 2 :(得分：2)
从另一个角度看这个，让我们来看看脚本和操作码：
SCRIPT1：
<?php
$dateStep = new DateInterval('P1D');
$dateInterval = 5;
$startDate = new DateTime();
for($di = 0; $di <= $dateInterval; ++$di)
{
$theDate = ($di > 0) ? $startDate->add($dateStep) : $startDate;
//...
}
操作码：
number of ops: 26
compiled vars: !0 = $dateStep, !1 = $dateInterval, !2 = $startDate, !3 = $di, !4 = $theDate
line # * op fetch ext return operands
---------------------------------------------------------------------------------
3 0 > FETCH_CLASS 4 :0 'DateInterval'
1 NEW $1 :0
2 SEND_VAL 'P1D'
3 DO_FCALL_BY_NAME 1
4 ASSIGN !0, $1
4 5 ASSIGN !1, 5
5 6 FETCH_CLASS 4 :5 'DateTime'
7 NEW $6 :5
8 DO_FCALL_BY_NAME 0
9 ASSIGN !2, $6
7 10 ASSIGN !3, 0
11 > IS_SMALLER_OR_EQUAL ~10 !3, !1
12 > JMPZNZ F ~10, ->25
13 > PRE_INC !3
14 > JMP ->11
9 15 > IS_SMALLER ~12 0, !3
16 > JMPZ ~12, ->22
17 > INIT_METHOD_CALL !2, 'add'
18 SEND_VAR !0
19 DO_FCALL_BY_NAME 1 $14
20 QM_ASSIGN_VAR $15 $14
21 > JMP ->23
22 > QM_ASSIGN_VAR $15 !2
23 > ASSIGN !4, $15
12 24 > JMP ->13
25 > > RETURN 1
SCRIPT2：
<?php
$dateInterval = 5;
$startDate = new DateTime();
for($di = 0; $di <= $dateInterval; ++$di)
{
$theDate = ($di > 0) ? $startDate->add(new DateInterval('P1D')) : $startDate;
// ...
}
操作码：
number of ops: 25
compiled vars: !0 = $dateInterval, !1 = $startDate, !2 = $di, !3 = $theDate
line # * op fetch ext return operands
---------------------------------------------------------------------------------
4 0 > ASSIGN !0, 5
5 1 FETCH_CLASS 4 :1 'DateTime'
2 NEW $2 :1
3 DO_FCALL_BY_NAME 0
4 ASSIGN !1, $2
7 5 ASSIGN !2, 0
6 > IS_SMALLER_OR_EQUAL ~6 !2, !0
7 > JMPZNZ A ~6, ->24
8 > PRE_INC !2
9 > JMP ->6
9 10 > IS_SMALLER ~8 0, !2
11 > JMPZ ~8, ->21
12 > INIT_METHOD_CALL !1, 'add'
13 FETCH_CLASS 4 :10 'DateInterval'
14 NEW $11 :10
15 SEND_VAL 'P1D'
16 DO_FCALL_BY_NAME 1
17 SEND_VAR_NO_REF 0 $11
18 DO_FCALL_BY_NAME 1 $13
19 QM_ASSIGN_VAR $14 $13
20 > JMP ->22
21 > QM_ASSIGN_VAR $14 !1
22 > ASSIGN !3, $14
12 23 > JMP ->8
24 > > RETURN 1
现在您可以在第二个脚本的操作码中看到它每次迭代都会创建一个新的类实例，并且您创建一个巨大的开销，这似乎是您不需要的（在第二个操作码中查看# * 13 - 16 ），所以首先你要创建完全没必要的新实例，然后这会降低你的性能。
因此，只要您在每次迭代时都不需要一个全新的类，第一个脚本就更适合您，因为它只创建一次DateInterval对象并将其分配给变量。
还有一些额外的信息：
答案 3 :(得分：1)
绝对第一个更快。 IN类实例化比1变量声明更昂贵。