Доступ к переменной javascript в модуле dojo

Question

Я создаю модуль с dojo. Этот модуль касается конфигурации.

define(["geometry/Point"], function (Point) { 
     var sp = new Point(122, -142); 
     return {    
      startPoint: new Point(122, -142), 
      globalOptions: { 
       logo: false, 
       center: sp 
      }, 

     }; 
    }) 

В этом модуле, если я использую зр varible как центр, код работает. Но если я использую центр в качестве начальной точки, центр приближается к нулю. Как следующего

define(["geometry/Point"], function (Point) { 
     return {    
      startPoint: new Point(122, -142), 
      globalOptions: { 
       logo: false, 
       center: this.startPoint 
      }, 

     }; 
    }) 

Я удалил varible зра и использовал this.startPoint но центр приходит нуль.

Answer 1

Это потому, что вы ссылаетесь на неправильный объект. Если вы используете в собственности center, вы на самом деле больше не ссылаетесь на свой модуль. Поскольку вы создаете новый объект, он будет фактически ссылаться на глобальный объект, который есть (если вы используете браузер) window.

Ваше первое решение работает, потому что sp имеет область действия, позволяющую получить доступ к вашему модулю, а также к вашему globalOptions.

---

EDIT (по запросу из комментариев):

Чтобы объявить модуль доступа к его функциям следует использовать:

define(["dojo/_base/declare", "dojo/_base/lang", "dojo/_base/array"], function(declare, lang, array) { 
    return declare(null, { 
     param: ["a", "b", "c"], 
     action: function() { 
      this.otherAction(); // Call other action 
     }, 
     otherAction: function() { 
      array.forEach(this.param, lang.hitch(this, "lastFunction")); 
     }, 
     lastFunction: function(item, idx) { 
      console.log(idx + " " + item); 
     } 
    }); 
}); 

Этот пример показывает некоторые основы в додзё. Чтобы создать модуль, вы должны использовать dojo/_base/declare. Первым параметром null является определение списка наследуемых модулей, в этом случае ни одного.

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

Если вы потеряли контекст this, вы можете использовать lang.hitch(). Он фактически вызывает функцию, но сохраняет контекст. Это то, что я делаю с lang.hitch(this, "lastFunction").

Я могу объяснить это еще больше, но я думаю, было бы полезно прочитать this tutorial.

Answer 2

Ваш первый подход был правильным, но было немного дублирования, что вы не нуждаетесь в startPoint определения:

function test() { 

    var startPoint = "x,y" 

    return {    
     startPoint: startPoint,    
     globalOptions: { 
      logo: false, 
      center: startPoint 
     } 
    }; 
} 

console.log(test().startPoint) 
console.log(test().globalOptions) 

испытание в JSBIN: http://jsbin.com/IxENEkA/1/edit

Answer 3

Вы пытаетесь делать Somthing как это,

define(["geometry/Point"], function (Point) { 
     return {    
      startPoint: new Point(122, -142), 
      globalOptions: {}, 

      postCreate: function() { 
      this.globalOptions = { 
      logo: false, 
      center: this.startPoint 
      } 

      }  
     }; 
    }) 

эта проблема возникает из-за рамки этого ..

надеюсь, что это вам поможет ..

Answer 4

Модули

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

define(
    module_id /*optional*/, 
    [dependencies] /*optional*/, 
    definition function /*function for instantiating the module or object*/ 
    ); 

Как вы можете сказать по инлайн комментариев MODULE_ID является необязательным аргументом, который, как правило, требуется только когда не-AMD конкатенации используются инструменты (могут быть и другие граничные случаи, где это тоже полезно). Когда этот аргумент опущен, мы вызываем анонимный модуль.

При работе с анонимными модулями идея идентичности модуля DRY делает его тривиальным, чтобы избежать дублирования имен файлов и кода. Поскольку код более переносимый, его можно легко перемещать в другие места (или вокруг файловой системы) без необходимости изменять сам код или изменять его идентификатор. Модуль_id эквивалентен путям папок в простых пакетах и ​​не используется в пакетах. Разработчики также могут запускать один и тот же код в нескольких средах, просто используя оптимизатор AMD, который работает с средой CommonJS, такой как r.js.

Назад к определению подписи, аргумент зависимостей представляет собой массив зависимостей, которые требуются определяемым модулем, а третий аргумент (функция определения) - это функция, выполняемая для создания экземпляра вашего модуля. Модуль Barebone может быть определен следующим образом:

// A module_id (myModule) is used here for demonstration purposes only 

define('myModule', 
['foo', 'bar'], 
// module definition function 
// dependencies (foo and bar) are mapped to function parameters 
function (foo, bar) { 
// return a value that defines the module export 
// (i.e the functionality we want to expose for consumption) 
// create your module here 
var myModule = { 
doStuff:function(){ 
console.log('Yay! Stuff'); 
} 
} 

return myModule; 
}); 

// An alternative example could be.. 
define('myModule', 
['math', 'graph'], 
function (math, graph) { 

// Note that this is a slightly different pattern 
// With AMD, it's possible to define modules in a few 
// different ways due as it's relatively flexible with 
// certain aspects of the syntax 
return { 
plot: function(x, y){ 
return graph.drawPie(math.randomGrid(x,y)); 
} 
} 
}; 
}); 

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

// Consider 'foo' and 'bar' are two external modules 
// In this example, the 'exports' from the two modules loaded are passed as 
// function arguments to the callback (foo and bar) 
// so that they can similarly be accessed 

require(['foo', 'bar'], function (foo, bar) { 
// rest of your code here 
foo.doSomething(); 
}); 

надеюсь, что это полезно для вас ...