JavaScript的“with”语句有合法用途吗？

我认为显而易见的用途是作为快捷方式。比如，如果您正在初始化一个对象，您只需省略很多“ObjectName.”的输入。有点像Lisp的“with-slots”，它可以让您编写

(with-slots (foo bar) objectname
   "some code that accesses foo and bar"

这与编写以下内容相同

"some code that accesses (slot-value objectname 'foo) and (slot-value objectname 'bar)""

这是一个快捷方式，当您的语言允许“Objectname.foo”时，这一点更加明显。

使用 "with" 可以使你的代码更加简洁。
考虑下面的代码：

var photo = document.getElementById('photo');
photo.style.position = 'absolute';
photo.style.left = '10px';
photo.style.top = '10px';

您可以将其干燥为以下内容：

with(document.getElementById('photo').style) {
  position = 'absolute';
  left = '10px';
  top = '10px';
}

我想这取决于你是更注重易读性还是表达性。

第一个例子更易读，对于大多数代码来说可能更推荐。但是大多数代码本身就很平淡无奇。第二个例子有点更加晦涩，但是利用了语言的表达性质量来减少代码大小和不必要的变量。

我想喜欢Java或C#的人会选择第一种方式（object.member），而喜欢Ruby或Python的人则会选择后者。

有使用Delphi的经验，我认为使用with应该是一种最后的优化手段，可能由某种具有静态代码分析功能的javascript缩小器算法执行以验证其安全性。
如果大量使用with语句，你可能会遇到作用域问题，这可能会让你痛苦不堪，我不希望任何人在调试会话中找出代码中发生了什么事情，只是发现它捕获了一个对象成员或错误的本地变量，而不是你想要的全局或外部作用域变量。
VB with语句更好，因为它需要点来消除歧义，但是Delphi with语句就像是一把带有发射扳机的危险武器，对我来说，看起来javascript的with语句也足够相似，需要同样的警告。

不建议使用with，并且在ECMAScript 5严格模式下是禁止的。推荐的替代方法是将你想要访问其属性的对象分配给一个临时变量。

来源：Mozilla.org

with语句可用于减少代码大小或私有类成员，例如：

// demo class framework
var Class= function(name, o) {
   var c=function(){};
   if( o.hasOwnProperty("constructor") ) {
       c= o.constructor;
   }
   delete o["constructor"];
   delete o["prototype"];
   c.prototype= {};
   for( var k in o ) c.prototype[k]= o[k];
   c.scope= Class.scope;
   c.scope.Class= c;
   c.Name= name;
   return c;
}
Class.newScope= function() {
    Class.scope= {};
    Class.scope.Scope= Class.scope;
    return Class.scope;
}

// create a new class
with( Class.newScope() ) {
   window.Foo= Class("Foo",{
      test: function() {
          alert( Class.Name );
      }
   });
}
(new Foo()).test();

with语句在IT技术中非常有用，如果您想修改作用域，那么这是必要的，因为您可以在运行时操纵自己的全局作用域。您可以将常量放在其中，或者某些常用的辅助函数，例如“toUpper”、“toLower”、“isNumber”、“clipNumber”等。
关于性能问题，我经常看到这样的说法：对函数进行作用域限制不会影响性能，事实上，在我的FF中，具有作用域限制的函数运行速度比没有作用域限制的函数更快。

var o={x: 5},r, fnRAW= function(a,b){ return a*b; }, fnScoped, s, e, i;
with( o ) {
    fnScoped= function(a,b){ return a*b; };
}

s= Date.now();
r= 0;
for( i=0; i < 1000000; i++ ) {
    r+= fnRAW(i,i);
}
e= Date.now();
console.log( (e-s)+"ms" );

s= Date.now();
r= 0;
for( i=0; i < 1000000; i++ ) {
    r+= fnScoped(i,i);
}
e= Date.now();
console.log( (e-s)+"ms" );

因此，在上述提到的使用with语句的方式中，它对性能没有负面影响，反而有好处，因为它可以减小代码大小，从而影响移动设备的内存使用。

对于一些短代码片段，我想使用三角函数，如sin，cos等，以度数模式而不是弧度模式。为此，我使用一个AngularDegree对象：

AngularDegree = new function() {
this.CONV = Math.PI / 180;
this.sin = function(x) { return Math.sin( x * this.CONV ) };
this.cos = function(x) { return Math.cos( x * this.CONV ) };
this.tan = function(x) { return Math.tan( x * this.CONV ) };
this.asin = function(x) { return Math.asin( x ) / this.CONV };
this.acos = function(x) { return Math.acos( x ) / this.CONV };
this.atan = function(x) { return Math.atan( x ) / this.CONV };
this.atan2 = function(x,y) { return Math.atan2(x,y) / this.CONV };
};

然后我可以在with块中使用角度模式的三角函数而不需要更多的语言噪音：

function getAzimut(pol,pos) {
  ...
  var d = pos.lon - pol.lon;
  with(AngularDegree) {
    var z = atan2( sin(d), cos(pol.lat)*tan(pos.lat) - sin(pol.lat)*cos(d) );
    return z;
    }
  }

这意味着：我使用一个对象作为函数的集合，我在有限的代码区域内启用它们以进行直接访问。我认为这很有用。

我创建了一个“合并”函数，使用with语句可以消除某些不确定性：

if (typeof Object.merge !== 'function') {
    Object.merge = function (o1, o2) { // Function to merge all of the properties from one object into another
        for(var i in o2) { o1[i] = o2[i]; }
        return o1;
    };
}

我可以像使用with一样使用它，但我知道它不会影响我不想影响的任何范围。

用法：

var eDiv = document.createElement("div");
var eHeader = Object.merge(eDiv.cloneNode(false), {className: "header", onclick: function(){ alert("Click!"); }});
function NewObj() {
    Object.merge(this, {size: 4096, initDate: new Date()});
}

我认为对象字面量的使用很有趣，就像使用闭包的替代品。

for(var i = nodes.length; i--;)
{
       // info is namespaced in a closure the click handler can access!
       (function(info)
       {           
            nodes[i].onclick = function(){ showStuff(info) };
       })(data[i]);
}

使用闭包的with语句等效方式

for(var i = nodes.length; i--;)
{
       // info is namespaced in a closure the click handler can access!
       with({info: data[i]})
       {           
            nodes[i].onclick = function(){ showStuff(info) };
       }        
}

我认为真正的风险是意外操纵不属于with语句的变量，这就是为什么我喜欢通过传入对象字面量到with语句来添加上下文信息，你可以清楚地看到代码中添加上下文信息后的结果。

将在相对复杂的环境中运行的代码放入容器中是一个不错的选择：我使用它来创建本地绑定，使得“window”等可以运行面向Web浏览器的代码。

使用with在许多实现中会使你的代码变慢，因为所有内容现在都包装在一个额外的范围内进行查找。在JavaScript中没有合法使用with的理由。