这是一种仅在this._hasUI解析为true时才执行函数的方法。
试试这个：

true && (console.log(1), console.log(2));

还有这个

false && (console.log(1), console.log(2));

您将看到只有第一行将运行console.log()函数。
这是因为布尔AND运算符（&&）的计算是惰性的，如果运算符的左边解析为false，解释器就不会计算右边的运算符，因为运算永远不会产生true，这意味着右边的函数只有在左边是truthy value时才会执行。

让我们把它放在一个对象中，为了可读性，我用括号把函数括起来：

var myObj = {
    _hasUI : true,
    _markSelected : function(arg){some logic}
    _refreshUI: function() {
                 this._hasUI &&  
                 (
                      // Strat evaluation from the left to right
                                 (g.empty(this.flowContainer), 
                                 (f.forEach(...)                ), 
                                 (g.create(args)                ), 
                                 (this._markSelected(arg)   )
                     // End evaluation and return
                     // the result of this._markSelected(arg)
                 )
}

基本上，这意味着如果._hasUI为真继续执行您找到的内容。在这种情况下，执行/评估第一个函数，然后是第二个函数..直到最后一个函数，它将只返回最后一个函数的结果。您可以找到其他内容，而不仅仅是函数，您可以找到比较变量，任何表达式...
看看同样的整数代码：

var secondExempleObj = {
    _hasUI : true, // change it to false and see the difference
    _refreshUI: function () {
        return ( this._hasUI && (1,false,3,4) )
    }
}
console.log('result : ' + secongExempleObj ._refreshUI());
// if _hasUI == true then the resutl will be 4
// if _hasUI  == false you will get false
// _hasUI  will work just like light switch if true -> continue to evaluate the rest of expressions else get out of there so we can replace it like so

var thirdObj  = {
    numbers : [1,87,30],
    sumFunction : function(n1,n2,n3){ console.log(n1+n2+n3) },
    _hasUI : true,
    _refreshUI: function () {
        if(this._hasUI == true){          
            return (1,false,this.sumFunction(...this.numbers),4)
       }else{
           return false;
       }
   }
}
console.log('result  : ' + thirdObj._refreshUI());
// it will console log 118 then 4 
// if you switch _hasUI to false it will logout false

希望你能理解