Conversión desde Javascript no da lo mismo

[odin_spain]

(Esta consulta la hice en el apartado dedicado a Javascript y me remitieron aquí)

Hola:

Tengo un codigo javascript que hace una serie de operaciones en el cliente (claculos a través de bucles), sin embargo a veces necesito que esas mismas operaciones las ejecute el servidor.

Como es normal no puedo ejecutar javascript en el server así que he replicado el codigo en PHP pero el resultado no es el mismo.

Imagino que la razón es que el Javascript ejecuta los bucles de forma diferente al PHP: mientras el primero ejecuta una funcion aunque la anterior no esté terminada en PHP va cosa por cosa a un tiempo.

Mi pregunta:

Existe una forma de ejecutar mi Javascript en el servidor? o como me han dicho en el foro de Javascript: se puede saltar esa diferencia de ejecución?

Gracias

[maycolalvarez]

el problema puede ser la forma en que haces la re-estructuración, obviamente php y js tienen ciertas diferencias en cuanto a estructuras de control.

lo del js en el servidor no cambia tu ambito, por ejemplo si bien puedes usar node.js para ejecutar un javascript en el server, no será el mismo ámbito que el js en el cliente, por lo que tendrías que pasarle las mismas variables desde js cliente al js server tal cual lo haces con PHP

[odin_spain]

En el foro de Javascrpt me aopnsejaron tambien el node.js pero no me ha parecido lo que busco.

He hecho el paso de PHP tal cual esta el codigo JS, mantengo la misma estructura y la misma forma de hacer las cosas, y es posible que como dices sea ese el problema.

El PHP se ejecuta perfectamente pero como dije la forma de funcionar de cada uno hace que el resultado vaya diferenciandose en cada vuelta del bucle hasta que no se parecen en nada.


Mi estructura es sencilla: la de un bucle para cada elemento y dentro otro bucle que mira todos los demás elementos para saber que hacer con él.

Como dije el problema es que el PHP no comienza un bucle mientras no termina con el que está y el Javascript no (sigue al siguiente sin terminarlo). Al cabo de unas 10 itineraciones para solo 20 elementos ya aparecen diferencias, al llevar 100 no se parece en casi nada.

¿Como estructuro el PHP o el Javascript para que se ejecuten de la misma forma?

Gracias

[GatorV]

Es muy raro lo que expones y si bien PHP no puede acceder a los elementos al mismo tiempo que Javascript, esto es por algo sencillo: PHP se ejecuta en el servidor y Javascript en el cliente.

Sin ver el contexto real de lo que haces, es difícil ver porque se generan los resultados de forma diferente, pero si bajas los datos a cadenas / enteros normales no tiene porque existir diferencias entre ambas implementaciones.

[odin_spain]

Expongo el caso concreto:

Se trata de unos objetos que se mueven en un entorno en 2D, donde cada uno tiene una (x,y)

El proceso:

bucle1 { determina cuantas veces se hace el proceso

bucle2 { se escoje cada objeto

bucle3 { se mira el resto de objetos respecto a mi, se evalua su posicion y se actua al respecto}


}

}

No hay problema en poner el codigo pero es un tocho.

La idea es que el PHP haga el proceso y al final me diga donde está cada objeto (x,y). Eso lo hace en el servidor.

Luego partiendo de los mismos datos iniciales y reglas el Javascript debería reproducir lo que ya ha pasado en PHP pero de forma visual.

El javascript efectivamente me reproduce siempre igual y el PHP tambien, pero ambos resultados no son identicos.


No uso redondeos en ninguno de los lenguajes ni por supuestos numeros aleatorios. Son siempre las mismas reglas y calculos sencillos (sumas, restas y multiplicaciones)., eso es lo que yo entiendo por datos normales.

Alguna idea?

[GatorV]

Mientras envies la misma información exacta que tiene javascript al momento de invocar la función, debe de darte los mismos resultados.

El problema que aquí veo es que los objetos se mueven continuamente, y como te digo PHP se procesa en el servidor, por lo que el contexto del movimiento queda fuera, y es por eso que te puede causar esas discrepancias en los calculos porque cuando PHP esta ejecuntando algo, los objetos en la pagina ya cambiaron su lugar.

Definitivamente no vas a poder hacer lo que dices con PHP ya que todo depende ampliamente de el movimiento de los objetos.

[odin_spain]

No he explicado bien.

El php hace los movimientos que sean (bucle1 unas 200 veces) y da el resultado.

Luego el Javascript hace esos mismos 200 movimientos SIN que el usuario pueda intervenir en nada.

De modo que el resultado de esos 200 movimientos deberia ser identico, pero no lo es por que como digo (y creo) el javascript es capaz de ejecutar varios bucles a un tiempo mientras PHP no, y esa (creo) que lo que marca la diferencia.

Me equivoco? por que por mas que reviso las cuatro funciones el resultado me varia

[Triby]

No me quedo muy claro eso de ejecutar varios bucles a un tiempo, en esencia, PHP y Javascript son muy similares en sus estructuras de control, habria que ver como realizas esos ciclos en Javascript y como intentaste adaptarlos a PHP.

[GatorV]

Iniciado por Triby

No me quedo muy claro eso de ejecutar varios bucles a un tiempo, en esencia, PHP y Javascript son muy similares en sus estructuras de control, habria que ver como realizas esos ciclos en Javascript y como intentaste adaptarlos a PHP.

+1

Mientras les des los mismos datos de entrada, el proceso debe de ser similar y la salida también.

Es como si comentaras que un ciclo para listar del 1 al 10 en Javascript te da 10 y PHP 11.

[odin_spain]

Un ejemplo de que Javascript no trabaja igual es la tipica llamada por Ajax, es posible que esa funcion no haya terminado y siga con la siguiente y de error por que no ha traido aún los datos. Eso me ha pasado algunas veces y me dolío la cabeza en su momento hasta que lo descubrí.

La estructura en PHP y Javascript es identica, ambos con matrices y bucles como en el esuqema que expuse.

En los primeros movimientos clava los resultados, cuando lleva 20 ciclos se empiezan a desviar y al 40 el desvio es importante.

Por eso la unica respuesta que se me ocurre es la forma de ejecutarse el Javascript.

PD: no me basta con un resultado similar, por que una diferencia en cada ciclo al cabo de varios se acumula muchisimo.

[GatorV]

¿Usas números de punto flotante o algo por el estilo? Ya que puede ser por ahí el problema de las limitantes del tamaño de los puntos flotantes.

[Triby]

Tendre que insistir, sin ver tus codigos (js y PHP) sera como tratar de adivinar el numero de la loteria para esta semana.

[odin_spain]

Espero que quede muy lioso y sobretodo que sirva de algo, gracias anticipadas

Codigo JS (he quitado valores inciales y accesorios) Bucles:


function work(){ // bucle1
tiempo+=1;
var x;

for(x in pesti){ // el que miro
var r;
for(r in pesti){
if(r!=x ){ // el otro
if (pesti[r].vida<1) {pesti[r].bando=0;};

var dx=pesti[r].x-pesti[x].x;
var dy=pesti[r].y-pesti[x].y;
var d=Math.sqrt(dx*dx+dy*dy);


if (d>0 && pesti[x].bando!==0 && pesti[r].bando!==0) {

if(pesti[r].bando==pesti[x].bando){
if(d<40){
pesti[x].vx+=velpez*(-dx/(d*d));
pesti[x].vy+=velpez*(-dy/(d*d));
}else if(d<100){
pesti[x].vx+=0.07*(dx/d);
pesti[x].vy+=0.07*(dy/d);
}
}
else { //huye de los otros
if(d<60){
pesti[x].vx-=(velpez/3)*(-dx/(d*d));
pesti[x].vy-=(velpez/3)*(-dy/(d*d));
}
};

if(d<70 && pesti[x].bando!==pesti[r].bando && pesti[r].bando!==0 ){
pesti[r].vida-=5;
}



};

}
}
};



Y mismo en PHP:


$c=0;
while ($c<$tiempofinal){ // ciclo principal
$c++;
$x=-1;
while ($x<$cantipez-1){ // ciclo mi pez
++$x;
//echo "($c) $xy $xvida<br>";

if ($nave[$x][6]<1) {$nave[$r][5]=0;};

$r=-1;
while ($r<$cantipez-1){ // ciclo otro pez r
++$r;
//echo "y $r <br>";
if($r!==$x ){ // no soy yo

if ($nave[$r][6]<1) {$nave[$r][5]=0;};

$dx=$nave[$r][1]-$nave[$x][1];
$dy=$nave[$r][2]-$nave[$x][2];
$d=sqrt($dx*$dx+$dy*$dy);
//dist=50;
if ($d>0 and $nave[$x][5]!==0 and $nave[$r][5]!==0) {



if($nave[$x]5]==$nave[$r][5]){
if($d<40){
$nave[$x][3]+=$velpez*(-$dx/($d*$d));
$nave[$x][4]+=$velpez*(-$dy/($d*$d));
}elseif($d<100){
$nave[$x][3]+=0.07*($dx/$d);
$nave[$x][4]+=0.07*($dy/$d);
};

}
else { //huye de los otros
if($d<60){
$nave[$x][3]-=($velpez/3)*(-$dx/($d*$d));
$nave[$r][4]-=($velpez/3)*(-$dy/($d*$d));
};
}; //fin comport 2




if($d<70 and $nave[$x][5]!==$nave[$r][5] and $nave[$r][5]!==0 )
{

$nave[$r][6]=$nave[$r][6]-5;
};


};


}; // fin no soy yo mismo

}; //fin otros y

// pestisor move x
if($nave[$x][3]>$velmax) {$nave[$x][3]=$velmax;};
if($nave[$x][3]<-1*$velmax) {$nave[$x][3]=-1*$velmax;};
if($nave[$x][4]>$velmax) {$nave[$x][4]=$velmax;};
if($nave[$x][4]<-1*$velmax) {$nave[$x][4]=-1*$velmax;};


$nave[$x][1]+=$nave[$x][3];
$nave[$x][2]+=$nave[$x][4];
$nave[$x][3]=$nave[$x][3]*0.9;
$nave[$x][4]=$nave[$x][4]*0.9;

//tendenci to go towards center;)
$nave[$x][1]=($nave[$x][1]*500+500)/501;
$nave[$x][2]=($nave[$x][2]*500+300)/501;

// guardando sus valores
//echo "($c) $x ($xvx,$xvy) ($xx,$xy)<br>";

$vx=$nave[$x][3];
$vy=$nave[$x][4];
$cx=(int) ($nave[$x][1]);
$cy=(int) ($nave[$x][2]);
echo "<br>($c) $d ($cx,$cy)";

}; ///fin yo x


};

[GatorV]

Como veo que haces calculos de punto flotante, te recomendaría usar BC Math

[odin_spain]

entonces para simplificar bastaria con dedondear todo (JS y en PHP) a por ejemplo 2 decimales?

[GatorV]

Así es ya que como te digo los números de punto flotante son algo inexactos a tantas milesimas, por lo que si estas dividiendo como dices, las desviaciones terminan por ser grandes, y el problema creo es Javascript más que PHP.

Revisa estos links:
http://www.mredkj.com/javascript/nfbasic2.html
http://php.net/manual/en/language.types.float.php

Saludos.

[odin_spain]

Despues de tantas pruebas lo mejor que puedo hacer (y ya he probado) es que el PHP me genere todos los (x,y) y los meta en una matriz para que los lea el JS, es la mejor forma de evitar cualquier variación, aunque la matriz va ha ser larguiiiisima.

Gracias de todas formas, en cualquier caso lo limitaré a 2 decimales

[odin_spain]

Hhe hecho una prueba de rendimiento y me ha sorprendido, auqnue no necesito tanto se pueden manejar hasta 1000 cadenas de 100 pares de (x,y), a dos decimales (total 200.000 valores)

El javascript no puede con su alma pero lo lee y funciona, así que usaré este sistema, me ahorro aasí ademas de las variaciones los posibles errores y molestias de hacer dos veces el codigo.

Muchas gracias