функциях языка. Существуют ли допустимые варианты использования оператора «with» в JavaScript?

Сегодня мне пришло в голову другое использование, поэтому я взволнованно искал в Интернете и обнаружил существующее упоминание об этом: Определение переменных внутри блочной области Глядя на вывод

Фон PHP

JavaScript, несмотря на его внешнее сходство с C и C, не делает Переменные области видимости для блока, в котором они определены:

var name = "Joe";
if ( true )
{
   var name = "Jack";
}
// name now contains "Jack"

Объявление замыкания в цикле — обычная задача, в которой это может привести к ошибкам:

for (var i=0; i<3;   i)
{
   var num = i;
   setTimeout(function() { alert(num); }, 10);
}

Поскольку цикл for не вводит новую область видимости, то же самое num — со значением 2 — будет использоваться всеми тремя функциями.

Новая область: let и with

С введением оператора let в ES6 , при необходимости можно легко ввести новую область видимости, чтобы избежать следующих проблем:

// variables introduced in this statement 
// are scoped to each iteration of the loop
for (let i=0; i<3;   i)
{
   setTimeout(function() { alert(i); }, 10);
}

Или даже:

for (var i=0; i<3;   i)
{
   // variables introduced in this statement 
   // are scoped to the block containing it.
   let num = i;
   setTimeout(function() { alert(num); }, 10);
}

До тех пор, пока ES6 не станет универсально доступным, это использование будет ограничено новейшими браузерами и разработчиками, желающими использовать транспортеры. Тем не менее, мы можем легко смоделировать это поведение, используя with:

for (var i=0; i<3;   i)
{
   // object members introduced in this statement 
   // are scoped to the block following it.
   with ({num: i})
   {
      setTimeout(function() { alert(num); }, 10);
   }
}

Цикл теперь работает так, как задумано, создавая три отдельные переменные со значениями от 0 до 2. Обратите внимание, что переменные, объявленные в блоке, не ограничиваются этим, в отличие поведение блоков в C (в C переменные должны быть объявлены в начале блока, поэтому в некотором роде это похоже). Это поведение на самом деле очень похоже на let блочный синтаксис , представленный в более ранних версиях браузеров Mozilla, но не получивший широкого распространения в других местах.

Я использовал оператор with как простую форму импорта по областям. Допустим, у вас есть какой-то компоновщик разметки. Вместо того, чтобы писать:

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

Вы могли бы вместо этого написать:

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

Для этого варианта использования я не делаю никаких назначений, поэтому у меня нет проблемы неоднозначности, связанной с этим.

Как указывалось в моих предыдущих комментариях, я не думаю, что вы можете безопасно использовать with, независимо от того, насколько заманчивым оно может быть в любой конкретной ситуации. Поскольку проблема здесь не рассматривается напрямую, я повторю это. Рассмотрим следующий код

user = {};
someFunctionThatDoesStuffToUser(user);
someOtherFunction(user);

with(user){
    name = 'Bob';
    age  = 20;
}

Без тщательного изучения этих вызовов функций невозможно определить состояние вашей программы после выполнения этого кода. Если user.name уже был установлен, теперь он будет Bob. Если он не был установлен, глобальный name будет инициализирован или изменен на Bob, но я не знаю, изменили ли они его. user объект останется без свойства name.

Ошибки случаются. Если вы используете 2 — это число цифр, до которого мы хотим округлить это число. вы в конечном итоге сделаете это и увеличите вероятность того, что ваша программа потерпит неудачу. Хуже того, вы можете столкнуться с рабочим кодом, который устанавливает глобал в блоке with, либо намеренно, либо через автора, не знающего об этой особенности конструкции. Это очень похоже на столкновение с провалом на переключателе, вы не представляете, задумал ли автор это, и нет способа узнать, приведет ли «исправление» кода к регрессии.

Современные языки программирования переполнены возможностями. Некоторые функции, после многих лет использования, оказались плохими, и их следует избегать. Javascript with является одним из них.

Я на самом деле нашел заявление with невероятно полезным в последнее время. Эта техника никогда не приходила мне в голову, пока я не начал свой текущий проект — консоль командной строки, написанную на JavaScript. Я пытался эмулировать API-интерфейсы консоли Firebug / WebKit, где в консоль можно вводить специальные команды, но они не переопределяют никакие переменные в глобальной области видимости. Я думал об этом, пытаясь преодолеть проблему, о которой упоминал в комментариях к отличному ответу Shog9 Глядя на вывод

Чтобы добиться этого эффекта, я использовал два выражения с «слоем» области действия за глобальной областью действия:

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

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

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

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

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

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

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

Вы можете определить небольшую вспомогательную функцию, чтобы обеспечить преимущества

без двусмысленности: with Вряд ли это того стоит, так как вы можете делать следующее:

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

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

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

var o = incrediblyLongObjectNameThatNoOneWouldUse;
o.name = "Bob";
o.age = "50";

заключается в том, что

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

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

. Один из наиболее распространенных способов, которыми я пользуюсь, — это быстро установить ряд свойств. Вместо: With я могу написать:

someObject.Foo = ''
someObject.Bar = ''
someObject.Baz = ''

Это не просто вопрос лени. Это также делает для более читабельного кода. И в отличие от JavaScript, он не страдает от двусмысленности, так как все, на что влияет оператор, ставят перед собой

With someObject
    .Foo = ''
    .Bar = ''
    .Baz = ''
End With

(точка). Итак, следующие два четко различаются: . Первый —

With someObject
    .Foo = ''
End With

Против.

With someObject
    Foo = ''
End With

;, последний — someObject.Foo в области видимости.Foo в области normal someObject Глядя на вывод

Я считаю, что отсутствие различий в JavaScript делает его гораздо менее полезным, чем вариант Visual Basic, так как риск неоднозначности слишком высок. Кроме этого, 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, выберут второй.

Я думаю, что очевидное использование — это ярлык. Если вы, например, инициализируя объект, вы просто сохраняете набрав много «ObjectName». Вроде как «with-slots» в 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.foo», но все же.

Имея опыт работы с Delphi, я бы сказал, что использование 2 — это число цифр, до которого мы хотим округлить это число. должно быть последней мерой оптимизации размера, возможно, выполняемой неким алгоритмом минимизации JavaScript, имеющим доступ к статическому анализу кода для проверки его безопасности.

Проблемы с областями видимости, с которыми вы можете столкнуться при свободном использовании 2 — это число цифр, до которого мы хотим округлить это число. Кроме того, может быть неудобно вспоминать, какие функции являются создателями синхронных действий, такими как { *} Чтобы ответить на комментированный вопрос о «двойном огне» и остаться в пределах удобства использования jQuery:

Оператор VB 2 — это число цифр, до которого мы хотим округлить это число. / 2 — это число цифр, до которого мы хотим округлить это число. представляет собой заряженный пистолет с hairtrigger, и мне кажется, что javascript достаточно похож, чтобы оправдать то же предупреждение.

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

О плохой производительности, которую я часто читал: определение области действия не влияет на производительность, на самом деле в моей области видимости FF Функция работает быстрее, чем unscoped:

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

Использование with также делает ваш код более медленным во многих реализациях, так как теперь все упаковано в дополнительную область для поиска. Там нет законных оснований для использования с в JavaScript.

Думаю, оператор with может пригодиться при конвертации языка шаблонов в JavaScript. Например, JST в base2 , но я видел это чаще.

Я согласен, что это можно запрограммировать без оператора 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, вы можете точно видеть, что это будет в добавленном контексте в коде.

Я создал функцию «слияния», которая устраняет некоторую эту двусмысленность с помощью 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()});
}

Для некоторых коротких фрагментов кода я хотел бы использовать тригонометрические функции, такие как sin, cos и т. д. в градусном режиме, а не в лучистом режиме. Для этой цели я использую AngularDegree object:

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

var sHeader = object.data.header.toString();
var sContent = object.data.content.toString();
var sFooter = object.data.footer.toString();

, вы можете утверждать, что with улучшит читабельность кода, выполнив следующее:

var sHeader = null, sContent = null, sFooter = null;
with(object.data) {
    sHeader = header.toString();
    sContent = content.toString();
    sFooter = content.toString();
}

И наоборот, можно утверждать, что вы нарушаете Закон Деметры , но, опять же, возможно, нет. Я отвлекся =).

Прежде всего, знайте, что Дуглас Крокфорд рекомендует не using with. Я призываю вас проверить его пост в блоге о with и его альтернативах говорится, что Глядя на вывод

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

Как сказал lassevk, я определенно вижу, что использование with будет более подвержено ошибкам, чем простое использование очень явного синтаксиса «object.member».

В Node.js 8 вы можете

Вы должны увидеть подтверждение формы в javascript в W3schools http://www.w3schools.com/js/js_form_validation.asp , где форма объекта «сканируется», чтобы найти входные данные с именем ’email’

Но я изменил его, чтобы получить из ЛЮБОЙ формы, все поля проверяются как не пустые, независимо от имени или количества полей в форме. Ну, я проверял только текстовые поля.

Но с помощью with () все стало проще. Вот код:

function validate_required(field)
{
with (field)
  {
  if (value==null||value=="")
    {
    alert('All fields are mandtory');return false;
    }
  else
    {
    return true;
    }
  }
}

function validate_form(thisform)
{
with (thisform)
  {
    for(fiie in elements){
        if (validate_required(elements[fiie])==false){
            elements[fiie].focus();
            elements[fiie].style.border='1px solid red';
            return false;
        } else {elements[fiie].style.border='1px solid #7F9DB9';}
    }

  }
  return false;
}

Вилка CoffeeScript Coco имеет ключевое слово with, но она просто устанавливает this (также можно записать как @ в CoffeeScript / Coco) для целевого объекта в блоке. Это устраняет неоднозначность и обеспечивает строгое соблюдение режима ES5:

with long.object.reference
  @a = 'foo'
  bar = @b

Вот хорошее применение для with: добавление новых элементов в литерал объекта на основе значений, хранящихся в этом объекте. Вот пример, который я только что использовал сегодня:

. У меня был набор возможных плиток (с отверстиями вверху, внизу, слева или справа), которые можно было использовать, и я хотел быстрый способ добавления списка тайлов, которые будут всегда размещаться и блокироваться в начале игры. Я не хотел продолжать набирать types.tbr для каждого типа в списке, поэтому я просто использовал with Глядя на вывод

Tile.types = (function(t,l,b,r) {
  function j(a) { return a.join(' '); }
  // all possible types
  var types = { 
    br:  j(  [b,r]),
    lbr: j([l,b,r]),
    lb:  j([l,b]  ),  
    tbr: j([t,b,r]),
    tbl: j([t,b,l]),
    tlr: j([t,l,r]),
    tr:  j([t,r]  ),  
    tl:  j([t,l]  ),  
    locked: []
  };  
  // store starting (base/locked) tiles in types.locked
  with( types ) { locked = [ 
    br,  lbr, lbr, lb, 
    tbr, tbr, lbr, tbl,
    tbr, tlr, tbl, tbl,
    tr,  tlr, tlr, tl
  ] } 
  return types;
})("top","left","bottom","right");

. Вы можете использовать с ним, чтобы избежать необходимости явно управлять arity при использовании require.js:

var modules = requirejs.declare([{
    'App' : 'app/app'
}]);

require(modules.paths(), function() { with (modules.resolve(arguments)) {
    App.run();
}});

Реализация requirejs.declare :

requirejs.declare = function(dependencyPairs) {
    var pair;
    var dependencyKeys = [];
    var dependencyValues = [];

    for (var i=0, n=dependencyPairs.length; i<n; i  ) {
        pair = dependencyPairs[i];
        for (var key in dependencyPairs[i]) {
            dependencyKeys.push(key);
            dependencyValues.push(pair[key]);
            break;
        }
    };

    return {
        paths : function() {
            return dependencyValues;
        },

        resolve : function(args) {
            var modules = {};
            for (var i=0, n=args.length; i<n; i  ) {
                modules[dependencyKeys[i]] = args[i];
            }
            return modules;
        }
    }   
}

Как отметил Энди Э. в комментариях к ответу Shog9, это потенциально неожиданное поведение возникает при использовании with с литералом объекта:

for (var i = 0; i < 3; i  ) {
  function toString() {
    return 'a';
  }
  with ({num: i}) {
    setTimeout(function() { console.log(num); }, 10);
    console.log(toString()); // prints "[object Object]"
  }
}

Не то неожиданное поведение не было уже отличительной чертой with Глядя на вывод

Если вы все еще хотите использовать эту технику, по крайней мере, используйте объект с нулевым прототипом.

function scope(o) {
  var ret = Object.create(null);
  if (typeof o !== 'object') return ret;
  Object.keys(o).forEach(function (key) {
    ret[key] = o[key];
  });
  return ret;
}

for (var i = 0; i < 3; i  ) {
  function toString() {
    return 'a';
  }
  with (scope({num: i})) {
    setTimeout(function() { console.log(num); }, 10);
    console.log(toString()); // prints "a"
  }
}

Но это будет работать только в ES5. Также не используйте with Глядя на вывод

Я работаю над проектом, который позволит пользователям загружать код для изменения поведения частей приложения. В этом сценарии я использовал предложение with, чтобы не дать их коду изменить что-либо вне области, с которой я хочу, чтобы они возились. (Упрощенная) часть кода, которую я использую для этого:

// this code is only executed once
var localScope = {
    build: undefined,

    // this is where all of the values I want to hide go; the list is rather long
    window: undefined,
    console: undefined,
    ...
};
with(localScope) {
    build = function(userCode) {
        eval('var builtFunction = function(options) {'   userCode   '}');
        return builtFunction;
    }
}
var build = localScope.build;
delete localScope.build;

// this is how I use the build method
var userCode = 'return "Hello, World!";';
var userFunction = build(userCode);

Этот код (в некоторой степени) гарантирует, что пользовательский код не имеет доступа ни к объектам глобальной области видимости, таким как window, ни к любым из моих локальных переменных через закрытие.

Точно так же, как слово для мудрых, я все еще должен выполнить статические проверки кода для пользовательского кода, чтобы убедиться, что они не используют другие хитрые способы доступа к глобальной области видимости. Например, следующий определяемый пользователем код захватывает прямой доступ к window:

test = function() {
     return this.window
};
return test();

my

switch(e.type) {
    case gapi.drive.realtime.ErrorType.TOKEN_REFRESH_REQUIRED: blah
    case gapi.drive.realtime.ErrorType.CLIENT_ERROR: blah
    case gapi.drive.realtime.ErrorType.NOT_FOUND: blah
}

сводится к

with(gapi.drive.realtime.ErrorType) {switch(e.type) {
    case TOKEN_REFRESH_REQUIRED: blah
    case CLIENT_ERROR: blah
    case NOT_FOUND: blah
}}

Можете ли вы доверять так низкокачественный код? Нет, мы видим, что это было сделано абсолютно нечитаемым. Этот пример неоспоримо доказывает, что нет никакой необходимости с-заявления, если я беру читаемость право ;)

, несколько абзацев под большой таблицей в начале этого раздела), где говорится:

Просто хотел бы добавить, вы можете получить «с ()» функциональностью с довольно синтаксисом и не неоднозначностями с вашим собственный умный метод …

     //utility function
  function _with(context){
           var ctx=context;
           this.set=function(obj){
             for(x in obj){
                //should add hasOwnProperty(x) here
                ctx[x]=obj[x];
             }
       } 

       return this.set;          
 }

 //how calling it would look in code...

  _with(Hemisphere.Continent.Nation.Language.Dialect.Alphabet)({

      a:"letter a",
      b:"letter b",
      c:"letter c",
      d:"letter a",
      e:"letter b",
      f:"letter c",
     // continue through whole alphabet...

  });//look how readable I am!!!!

.. или если вы действительно хотите использовать «with ()» без двусмысленности и без специального метода, оберните его в анонимную функцию и используйте .call

//imagine a deeply nested object 
//Hemisphere.Continent.Nation.Language.Dialect.Alphabet
(function(){
     with(Hemisphere.Continent.Nation.Language.Dialect.Alphabet){ 
         this.a="letter a";
         this.b="letter b";
         this.c="letter c";
         this.d="letter a";
         this.e="letter b";
         this.f="letter c";
         // continue through whole alphabet...
     }
}).call(Hemisphere.Continent.Nation.Language.Dialect.Alphabet)

как уже отмечали другие, это несколько бессмысленно, поскольку вы можете сделать …

 //imagine a deeply nested object Hemisphere.Continent.Nation.Language.Dialect.Alphabet
     var ltr=Hemisphere.Continent.Nation.Language.Dialect.Alphabet 
     ltr.a="letter a";
     ltr.b="letter b";
     ltr.c="letter c";
     ltr.d="letter a";
     ltr.e="letter b";
     ltr.f="letter c";
     // continue through whole alphabet...
Понравилась статья? Поделиться с друзьями:
JavaScript & TypeScript
Adblock
detector