javascript - Definición de objetos cuando se usa Jaxer

oop aptana

Question

He estado jugando con Jaxer y, aunque el concepto es genial, no puedo entender cómo definir los objetos disponibles tanto en el cliente como en el servidor. Ninguno de los ejemplos que puedo encontrar definen objetos en absoluto.

Me gustaría poder definir un objeto y especificar qué métodos estarán disponibles en el servidor, que estarán disponibles en el cliente, y que estarán disponibles en el cliente pero se ejecutarán en el servidor (servidor-proxy). ¿Se puede hacer esto sin utilizar tres etiquetas <script > separadas con diferentes atributos de runat ? Me gustaría poder definir todos mis métodos en el mismo archivo js si es posible, y no es práctico definir mis objetos en línea en el html con tres etiquetas separadas ...

Básicamente me gustaría poder hacer esto en un archivo js:

function Person(name) {
this.name = name || ''default'';
}
Person.runat = ''both'';
Person.clientStaticMethod = function () {
log(''client static method'');
}
Person.clientStaticMethod.runat = ''client'';
Person.serverStaticMethod = function() {
log(''server static method'');
}
Person.serverStaticMethod.runat = ''server'';
Person.proxyStaticMethod = function() {
log(''proxy static method'');
}
Person.proxyStaticMethod.runat = ''server-proxy'';
Person.prototype.clientMethod = function() {
log(''client method'');
};
Person.prototype.clientMethod.runat = ''client'';
Person.prototype.serverMethod = function() {
log(''server method'');
};
Person.prototype.serverMethod.runat = ''server'';
Person.prototype.proxyMethod = function() {
log(''proxy method'');
}
Person.prototype.proxyMethod.runat = ''server-proxy'';

Además, suponiendo que pudiera hacer eso, ¿cómo lo incluiría en las páginas html correctamente?

Answer 1

Encontré una publicación en los foros de Aptana (que ya no existe en la web) que indica que solo se pueden usar funciones globales ... Bummer.

Sin embargo, he estado jugando y puedes controlar qué métodos estarán disponibles en el cliente y el servidor colocando tu código en un archivo de inclusión y usando etiquetas <script> con atributos runat .

Por ejemplo, puedo crear este archivo llamado Person.js.inc :

<script runat="both">
function Person(name) {
this.name = name || ''default'';
}
</script>
<script runat="server">
Person.prototype.serverMethod = function() {
return ''server method ('' + this.name + '')'';
};
Person.serverStaticMethod = function(person) {
return ''server static method ('' + person.name + '')'';
}
// This is a proxied function. It will be available on the server and
// a proxy function will be set up on the client. Note that it must be
// declared globally.
function SavePerson(person) {
return ''proxied method ('' + person.name + '')'';
}
SavePerson.proxy = true;
</script>
<script runat="client">
Person.prototype.clientMethod = function() {
return ''client method ('' + this.name + '')'';
};
Person.clientStaticMethod = function (person) {
return ''client static method ('' + person.name + '')'';
}
</script>

Y puedo incluirlo en una página usando:

<jaxer:include src="People.js.inc"></jaxer:include>

Lamentablemente, con este método pierdo la ventaja del almacenamiento en caché del navegador para scripts del lado del cliente porque todos los scripts se ingresan. La única técnica que puedo encontrar para evitar ese problema es dividir los métodos del cliente, los métodos del servidor y los métodos compartidos en sus propios archivos js:

<script src="Person.shared.js" runat="both" autoload="true"></script>
<script src="Person.server.js" runat="server" autoload="true"></script>
<script src="Person.client.js" runat="client"></script>

Y, en ese punto, también podría dividir las funciones de proxy en su propio archivo también ...

<script src="Person.proxies.js" runat="server-proxy"></script>

Tenga en cuenta que utilicé autoload="true" en los scripts compartidos y del servidor para que estuvieran disponibles para las funciones de proxy.