我创建了一个“merge”函数，它消除了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;
    };
}

我可以类似地使用它，但我可以知道它不会影响任何我不想让它影响的范围。

用法:

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()});
}

有使用Delphi的经验，我会说使用with应该是最后的大小优化方法，可能由某种javascript最小化算法执行，并访问静态代码分析以验证其安全性。

随意使用with语句可能会遇到范围问题，这是一个非常痛苦的问题，我不希望任何人经历调试会话来弄清楚他…，却发现它捕获了一个对象成员或错误的局部变量，而不是您期望的全局变量或外部作用域变量。

VB的with语句更好，因为它需要点来消除范围的歧义，但Delphi的with语句是一把上膛的枪，带有一发之机，在我看来，javascript的with语句与之相似，足以保证同样的警告。

它很适合将在相对复杂的环境中运行的代码放入容器中:我使用它来为“窗口”创建本地绑定，从而运行用于web浏览器的代码。

实际上，我最近发现with语句非常有用。直到我开始了我目前的项目——一个用JavaScript编写的命令行控制台，我才真正意识到这个技术。我试图模拟Firebug/WebKit控制台api，其中特殊命令可以输入到控制台，但它们不会覆盖全局作用域中的任何变量。当我试图解决我在Shog9的精彩答案的评论中提到的一个问题时，我想到了这个。

为了达到这个效果，我使用了两个with语句将一个作用域“分层”到全局作用域后面:

with (consoleCommands) {
    with (window) {
        eval(expression); 
    }
}

这种技术的优点在于，除了性能方面的缺点外，它不会遭受with语句通常带来的恐惧，因为无论如何我们都是在全局作用域中求值——没有伪作用域之外的变量被修改的危险。

让我惊讶的是，当我设法找到在其他地方使用的相同技术时，我受到了启发，发布了这个答案——Chromium源代码!

InjectedScript._evaluateOn = function(evalFunction, object, expression) {
    InjectedScript._ensureCommandLineAPIInstalled();
    // Surround the expression in with statements to inject our command line API so that
    // the window object properties still take more precedent than our API functions.
    expression = "with (window._inspectorCommandLineAPI) { with (window) { " + expression + " } }";
    return evalFunction.call(object, expression);
}

编辑:刚刚检查了Firebug的源代码，它们将4条语句链接在一起，形成更多的层。疯了!

const evalScript = "with (__win__.__scope__.vars) { with (__win__.__scope__.api) { with (__win__.__scope__.userVars) { with (__win__) {" +
    "try {" +
        "__win__.__scope__.callback(eval(__win__.__scope__.expr));" +
    "} catch (exc) {" +
        "__win__.__scope__.callback(exc, true);" +
    "}" +
"}}}}";

我认为对象文字的使用很有趣，就像使用闭包的一个插入式替换

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，你可以确切地看到它将在代码中添加的上下文中。

我认为最明显的用途是作为捷径。例如，如果你初始化一个对象，你只需节省大量输入“ObjectName”。有点像lisp的“带槽”，让你可以写

(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”时，这是一个更明显的快捷方式。但是还是。