Есть ли способ получить что-то как следующее, чтобы работать в JavaScript?

var foo = {
    a: 5,
    b: 6,
    c: this.a   this.b  // Doesn't work
};

В текущей форме этот код явно выдает ошибку ссылки, поскольку this равно самому себе (foo. Но закрытие. Функция не должна Arrow в предложении JavaScript

Итак, как теперь выглядит последовательность событий и очередь?

var foo = {
  a: 5,
  b: 6,
  get c () {
    return this.a   this.b;
  }
};

foo.c; // 11

Это синтаксическое расширение, представленное в Спецификации ECMAScript 5-го издания, синтаксис поддерживается большинством современных браузеров (включая IE9).

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

var foo = {
   a: 5,
   b: 6,
   init: function() {
       this.c = this.a   this.b;
       return this;
   }
}.init();

Это будет своего рода однократная инициализация объекта.

запроса src для init() Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … foo, поэтому вы должны return this Глядя на вывод

Очевидный простой ответ отсутствует, поэтому для полноты:

но закрытие. Функция не должна Arrow в предложении JavaScript

Нет. Все решения здесь откладывают его до тех пор, пока объект не будет создан (различными способами), а затем присваивают третье свойство. вариантах для бесплатной проверки — 30 проб или использование , я просто хочу сделать это:

var foo = {
    a: 5,
    b: 6
};
foo.c = foo.a   foo.b;

don ‘ t «delete и быстрый несоответствующий ответ по влияет на ключ производительности последующих обращений к свойствам этого объекта.)

Если вам нужно, чтобы все они были в одном выражении, вы можете сделать это без временного свойства:

var foo = function(o) {
    o.c = o.a   o.b;
    return o;
}({a: 5, b: 6});

Или, конечно, если вам нужно сделать это более одного раза: { *} тогда, где вам нужно его использовать:

function buildFoo(a, b) {
    var o = {a: a, b: b};
    o.c = o.a   o.b;
    return o;
}

не работал в

var foo = buildFoo(5, 6);

Просто создайте экземпляр анонимной функции:

var foo = new function () {
    this.a = 5;
    this.b = 6;
    this.c = this.a   this.b;
};

Некоторое закрытие должно иметь дело с этим ;

var foo = function() {
    var a = 5;
    var b = 6;
    var c = a   b;

    return {
        a: a,
        b: b,
        c: c
    }
}();

со значением по умолчанию foo являются частными для foo, как и следовало ожидать от функции. Разница в том, что эта функция возвращает объект, который предоставляет приватные переменные и назначает этот объект this, который вызывает оценку всего объекта foo, всех переменных внутри экземпляра и возвращаемого объекта, добавляемого как свойства foo. Первый идиот фактически передаст длину массива, а второй идиот передаст удаленный элемент в качестве параметра. return {} Но спросите себя: «Стоит ли« отлаживать »код и обнаруживать, что результат ошибки вызван« крайним случаем »?» Я бы предпочел избегать неприятностей не только в большинстве случаев. время, но 100 % времени.

Затем функция выполняется в конце с помощью () Магия в добытчике. foo() Глядя на вывод

Теперь в ES6 вы можете создавать ленивые кэшированные свойства. При первом использовании свойство оценивается один раз, чтобы стать нормальным статическим свойством. Результат: во второй раз пропускаются служебные данные математической функции.

Также обратите внимание, что это функциональная операция, то есть она не изменяет исходный массив.

const foo = {
    a: 5,
    b: 6,
    get c() {
        delete this.c;
        return this.c = this.a   this.b
    }
};

Удаление определенного элемента / строки из массива может быть выполнено в одну строку: я все еще думаю, что это самая элегантная строка, которую вы можете получить для такого типа проблемы: this. Я думаю, что нет свойства для проверки целочисленной длины. Итак, что я сделал: Теперь в любом из дочерних узлов нужно только Глядя на вывод

foo     // {a: 5, b: 6}
foo.c   // 11
foo     // {a: 5, b: 6 , c: 11}  

, которые вы могли бы сделать это как

var a, b
var foo = {
    a: a = 5,
    b: b = 6,
    c: a   b
}

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

function createMyObject() {
    var count = 0, self
    return {
        a: self = {
            log: function() {
                console.log(count  )
                return self
            }
        }
    }
}

CoffeeScript

Используя метод self, вы гарантируете, что print всегда будет возвращать один и тот же объект независимо от контекста, в котором выполняется функция. Приведенный выше код будет работать нормально и будет записывать 0, 1, 2 и 3 при использовании собственной версии this как показано ниже

function createMyObject() {
    var count = 0
    return {
        a: {
            log: function() {
                console.log(count  )
                return this
            }
        }
    }
}

‘object’

var o = createMyObject()
var log = o.a.log
o.a.log().log() // this refers to the o.a object so the chaining works
log().log() // this refers to the window object so the chaining fails!

— элемент и createMyObject() Глядя на вывод

Просто сделайте: { *} Менее широко поддерживается, чем при использовании

class Foo {
  constructor(){
    this.a = 5;
    this.b = 6;
    this.c = this.a   this.b;
  }  
}

const foo = new Foo();

Есть несколько способов сделать это ;, вот что я бы использовал:

function Obj() {
 this.a = 5;
 this.b = this.a   1;
 // return this; // commented out because this happens automatically
}

var o = new Obj();
o.b; // === 6

есть и лучшие ответы выше

var foo = function() {
  var that = {};

  that.a = 7;
  that.b = 6;

  that.c = function() {
    return that.a   that.b;
  }

  return that;
};
var fooObject = foo();
fooObject.c(); //13

С помощью этого шаблона вы можете создавать несколько объектов foo в соответствии с вашими потребностями.

http://jsfiddle.net/jPNxY/1/

ОБНОВЛЕНИЕ:

var foo = {
    a: function(){return 5}(),
    b: function(){return 6}(),
    c: function(){return this.a   this.b}
}

console.log(foo.c())

Вы не можете ссылаться на одноуровневое свойство во время инициализации литерала объекта. 2013 / August / 9

Internet Explorer 9

var foo = {
    get a(){return 5},
    get b(){return 6},
    get c(){return this.a   this.b}
}
// console.log(foo.c);

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

или более поздней версии (

var x = { a: 1, b: 2, c: a   b } // not defined 
var y = { a: 1, b: 2, c: y.a   y.b } // not defined 

Далее следует простейшее решение для вычисляемых свойств (без кучи, без функций, без конструктора):

var x = { a: 1, b: 2 };

x.c = x.a   x.b; // apply computed property

Это проверит, если элемент полностью виден в текущем окне просмотра: выражение scope Глядя на вывод

Вам нужно инкапсулировать «родительский» (родительский объект) свойства, которое вы хотите определить как его собственный экземплярный объект, а затем вы можете делать ссылки на свойства-братья, используя ключевое слово this

Это очень, очень Важно помнить, что если вы обращаетесь к this сначала без этого, тогда this будет ссылаться на внешнюю область видимости … которая будет window объект.

var x = 9   //this is really window.x
var bar = {
  x: 1,
  y: 2,
  foo: new function(){
    this.a = 5, //assign value
    this.b = 6,
    this.c = this.a   this.b;  // 11
  },
  z: this.x   // 9 (not 1 as you might expect, b/c *this* refers `window` object)
};

и существуют только до тех пор, пока закрывающая скобка не убьет их.

  • Устанавливает значение в Синтаксис
  • Didn ‘ Требуется любой тип init() или кода вне литерала объекта
  • выбранного объекта, который включает в себя поиск другой хеш-таблицы в выбранном объекте, чтобы найти метод и вызвать его.
  • , не должно влиять на производительность (кроме как при инициализации)

Самоисполняющиеся анонимные функции и хранилище окон

var foo = {
    bar:(function(){
        window.temp = "qwert";
        return window.temp;
    })(),
    baz: window.temp
};

Порядок гарантировано (bar перед baz).

Это загрязняет window, конечно, но я не могу представить, чтобы кто-то писал сценарий, который требует window.temp быть стойким. Может быть, tempMyApp если вы параноик.

Atomics.wait

И, конечно, сухо.

если ваш объект написан как функция, которая возвращает объект, И вы используете объектный атрибут ES6 ‘методы’, то это возможно:

const module = (state) => ({
  a: 1,
  oneThing() {
    state.b = state.b   this.a
  },
  anotherThing() {
    this.oneThing();
    state.c = state.b   this.a
  },
});

const store = {b: 10};
const root = module(store);

root.oneThing();
console.log(store);

root.anotherThing();
console.log(store);

console.log(root, Object.keys(root), root.prototype);

проверяется на наличие любых пробелов 1/0 или более перед этой подстрокой.

var foo = (o => ({
    ...o,
    c: o.a   o.b
  }))({
    a: 5,
    b: 6
  });
  
console.log(foo);

Я использую его, чтобы сделать что-то вроде этого:

const constants = Object.freeze(
  (_ => ({
    ..._,
    flag_data: {
      [_.a_flag]: 'foo',
      [_.b_flag]: 'bar',
      [_.c_flag]: 'oof'
    }
  }))({
    a_flag: 5,
    b_flag: 6,
    c_flag: 7,
  })
);

console.log(constants.flag_data[constants.b_flag]);

Как насчет этого решения, это будет работать и с вложенными объектами с массивом

      Object.prototype.assignOwnProVal
     = function (to,from){ 
            function compose(obj,string){ 
                var parts = string.split('.'); 
                var newObj = obj[parts[0]]; 
                if(parts[1]){ 
                    parts.splice(0,1);
                    var newString = parts.join('.'); 
                    return compose(newObj,newString); 
                } 
                return newObj; 
            } 
            this[to] = compose(this,from);
     } 
     var obj = { name : 'Gaurav', temp : 
                  {id : [10,20], city:
                        {street:'Brunswick'}} } 
     obj.assignOwnProVal('street','temp.city.street'); 
     obj.assignOwnProVal('myid','temp.id.1');

Я использую следующий код в качестве альтернативы, и он работает. И переменная тоже может быть массивом. (@ Fausto R.)

var foo = {
  a: 5,
  b: 6,
  c: function() {
    return this.a   this.b;
  },

  d: [10,20,30],
  e: function(x) {
    this.d.push(x);
    return this.d;
  }
};
foo.c(); // 11
foo.e(40); // foo.d = [10,20,30,40]

Вбрасывание опции, так как я не видел этого точного сценария. Если у вас не { *} Еще один ответ, для меня, чем проще, тем лучше, и поскольку мы находимся в 2018 году (около 2019 года), я даю вам этот (около) один вкладыш, чтобы ответить на первоначальный вопрос: Если из вашего контроллера вы хотите, чтобы получить objectC в вашей области, было бы ошибкой сказать: c, тогда ES6 IIFE работает хорошо. a или b Свойство, я сначала вычисляю это значение и передаю его как параметр в IIFE.

var foo = ((a,b) => ({
    a,
    b,
    c: a   b
}))(a,b);

Для моих нужд у меня есть объект, который относится к массиву, который в конечном итоге будет использоваться в цикле, поэтому я хочу вычислить только некоторые общие настроить один раз, так что это то, что у меня есть:

  let processingState = ((indexOfSelectedTier) => ({
      selectedTier,
      indexOfSelectedTier,
      hasUpperTierSelection: tiers.slice(0,indexOfSelectedTier)
                             .some(t => pendingSelectedFiltersState[t.name]),
  }))(tiers.indexOf(selectedTier));

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

javascript — наиболее эффективный метод группирования по массиву объектов Наиболее полное решение, которое будет работать в подавляющем большинстве случаев, — это использование . В вашем вопросе не указывалось, являются ли порядковые или отдельные значения требование. Распространение Глядя на вывод

Итак:

Object

var foo = {
    a: 5,
    b: 6,
};

Если вы хотите сохранить имя свойств объекта в качестве значений. Пример:

var foo2 = {
    c: foo.a   foo.b
};

Это решение будет принимать массив входных данных и будет искать во входных данных значение, которое нужно удалить. Это будет проходить по всему входному массиву, и результатом будут целые числа второго массива, у которых был удален определенный индекс. Затем массив целых чисел копируется обратно во входной массив.

Object.assign(foo, foo2);

или

foo = {...foo, ...foo2};

Result из foo:

{ 
  "a":5,
  "b":6,
  "c":11
}

Я написал библиотеку npm, названную

операция. Первая

Но если вы предпочитаете писать объекты, ссылающиеся на себя, например:

{ 
  a: ...,
  b: "${this.a   this.a}",
}

Удаление значения с помощью index и splice! 14 мая 15 в 18:35 , который поддерживает этот синтаксис и возвращает родной объект.

Примечание: , что звучит как раз для вас. В настоящее время только Opera поддерживает его изначально, но есть функция

class asd {
    def = new class {
        ads= 'asd';
        qwe= this.ads   '123';
    };

    // this method is just to check/test this solution 
    check(){
        console.log(this.def.qwe);
    }
}

// these two lines are just to check
let instance = new asd();
instance.check();

— Событие для этого, эмуляция, если она недоступна.

Как жаль, что у вас есть массив целых чисел, а не объект, ключи которого являются строковыми эквивалентами этих чисел.

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

представима

class asd {
    def = new class {
        ads= 'asd';
        qwe= this.ads   '123';
    };

Решение, если бы объектных литералов было бы достаточно.

var asd = {
    def : {
        ads:'asd',
        qwe: this.ads   '123';, //ILLEGAL CODE; just to show ideal scenario
    }
}

рассмотреть возможность использования

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

class CONSTANT {
    static readonly PATH = new class {
        /** private visibility because these relative paths don't make sense for direct access, they're only useful to path class
         *
         */
        private readonly RELATIVE = new class {
            readonly AFTER_EFFECTS_TEMPLATE_BINARY_VERSION: fs.PathLike = '\assets\aep-template\src\video-template.aep';
            readonly AFTER_EFFECTS_TEMPLATE_XML_VERSION: fs.PathLike = '\assets\aep-template\intermediates\video-template.aepx';
            readonly RELATIVE_PATH_TO_AFTER_EFFECTS: fs.PathLike = '\Adobe\Adobe After Effects CC 2018\Support Files\AfterFX.exe';
            readonly OUTPUT_DIRECTORY_NAME: fs.PathLike = '\output';
            readonly INPUT_DIRECTORY_NAME: fs.PathLike = '\input';
            readonly ASSETS_DIRECTORY_NAME: fs.PathLike = '\assets';
        };
    }
}