Можно определить небольшую функцию помощника для предоставления преимуществ with без неоднозначности:

var with_ = function (obj, func) { func (obj); };

with_ (object_name_here, function (_)
{
    _.a = "foo";
    _.b = "bar";
});

Да, да и да. Есть вполне законное использование. Смотрите:

with (document.getElementById("blah").style) {
    background = "black";
    color = "blue";
    border = "1px solid green";
}

По сути, любые другие хуки DOM или CSS отлично подходят для использования с. Это не похоже на то, что "CloneNode" будет неопределенным и вернется в глобальную область видимости, если только вы не сделали все возможное и не решили сделать это возможным.

Крокфорд жалуется на скорость, что новый контекст создается с помощью. Контексты обычно дороги. Я согласен. Но если вы только что создали div и у вас нет под рукой какой-либо инфраструктуры для настройки CSS и вам нужно настроить 15 или около того свойств CSS вручную, то создание контекста, вероятно, будет дешевле, чем создание переменных и 15 разыменований:

var element = document.createElement("div"),
    elementStyle = element.style;

elementStyle.fontWeight = "bold";
elementStyle.fontSize = "1.5em";
elementStyle.color = "#55d";
elementStyle.marginLeft = "2px";

и т. д.

I have been using the with statement as a simple form of scoped import. Let's say you have a markup builder of some sort. Rather than writing:

markupbuilder.div(
  markupbuilder.p('Hi! I am a paragraph!',
    markupbuilder.span('I am a span inside a paragraph')
  )
)

You could instead write:

with(markupbuilder){
  div(
    p('Hi! I am a paragraph!',
      span('I am a span inside a paragraph')
    )
  )
}

For this use case, I am not doing any assignment, so I don't have the ambiguity problem associated with that.

Я никогда не использую, не вижу причин и не рекомендую это.

Проблема с с в том, что это предотвращает многочисленные лексические оптимизации , которые может выполнить реализация ECMAScript. Учитывая рост быстрых движков на основе JIT, эта проблема, вероятно, станет еще более важной в ближайшем будущем.

Может показаться, что с допускают более чистые конструкции (когда, скажем, вводя новую область видимости) вместо обычной оболочки анонимной функции или замены подробного псевдонима), но это действительно того не стоит . Помимо снижения производительности, всегда существует опасность присвоения свойству неправильного объекта (когда свойство не найдено для объекта во внедренной области видимости) и, возможно, ошибочного введения глобальных переменных. IIRC,

Оператор 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 очень полезен, если вы хотите изменить область видимости, что необходимо для вашей собственной глобальной области видимости, которая вы можете манипулировать во время выполнения. Вы можете добавить к нему константы или некоторые часто используемые вспомогательные функции, например, «toUpper», «toLower» или «isNumber», «clipNumber» aso ..

О плохой производительности я часто читал: определение области действия функции не будет иметь никакого влияния на производительность, фактически в моем 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 не оказывает отрицательного влияния на производительность, но является хорошим, поскольку уменьшает размер кода, что влияет на использование памяти на мобильных устройствах.

Это хорошо для помещения кода, который выполняется в относительно сложная среда в контейнере: я использую его, чтобы сделать локальную привязку для «окна» и тому подобное, чтобы запустить код, предназначенный для веб-браузера.

Я думаю, что буквальное использование объекта интересно, например, прямая замена для использования замыкания

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» может сделать ваш код более сухим.

Рассмотрим следующий код:

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, выберут второй.

Я создал функцию «слияния», которая устраняет часть этой двусмысленности с помощью оператора с :

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