Question

我在javascript中有一段代码：

for (
    m = a[1],
        s = a[2],
        c.hash_match = i.replace(m, ""),
        o.lastIndex = 0;
    a = o.exec(s);
) {
    e[a[1]] && (c[e[a[1]]] = c[e[a[1]]] || decodeURIComponent(a[2]));
}

我的想法是有效的：

m = a[1];
s = a[2];
c.hash_match = i.replace(m, "");
o.lastIndex = 0;
while(a = o.exec(s))
{
    if(e[a[1]])
    {
        if(!c[e[a[1]]])
        {
            c[e[a[1]]] = decodeURIComponent(a[2]);
        }
    }
}

据我所知，for循环中第一个分号之前的四个运算符可以放在外面，因为for循环不会使用这个以逗号分隔的赋值列表返回的结果。

当o.exec（s）为==运算符（不是===）的定义时，for循环中断。

内部代码构造已在此question中向我解释，我很确定，但是请确认这一部分。

我已经做了一些测试并检查了一些行为，但需要确保我的解释是100％正确的，因为它是大型js脚本的一部分，而且我不确定我的测试工作是否足够重构后保留代码逻辑。那么，这两个片段是否相等？

Answer 1

我能看到的唯一区别是

c[e[a[1]]] = c[e[a[1]]] || decodeURIComponent(a[2])

更像是

var temp = c[e[a[1]]];
if(!temp)
{
    c[e[a[1]]] = decodeURIComponent(a[2]);
} else {
    c[e[a[1]]] = temp;
}

如果c[e[a[1]]] = c[e[a[1]]]由具有setter函数的访问者属性定义，则显然冗余的自我赋值c[e[a[1]]] = c[e[a[1]]]是相关的。赋值操作将调用setter。

如果c上没有使用访问者属性，则两段代码是等效的。

Answer 2

还有一个。对不起，我不知道放在哪里。这可能是一个单独的问题，但我不确定。所以，这是代码：

function i(e,t) {
    var h = y.map;
    var m = h && h["*"] || {};
}

所以，考虑到现在所知道的，功能体的替换可以是：

var h = y.map;
var m;
var temp;
if(h)
{
    temp = h["*"];
    if(temp)
    {
        m = temp;
    }
    else
    {
        m = {};
    }
}
else
{
    m = {};
}

我也可以说：

var h = y.map;
var m = {};
if(h && h["*"])
{
    m = h["*"];
}

但是h和m可以在较高范围内的其他位置定义，并且具有带有一些副作用的自定义getter / setter。因此，如果在它们之前没有var，在函数体内，使它们成为局部的，那么来自自定义getter / setter的副作用将被应用于上下文两次而不是一次，显然打破了逻辑。是真的吗？

Javascript异常FOR循环。请确认我的解释是正确的

2 个答案: