Ciao a tutti.

Ordinando delle matrici (sì, non ho passatempi migliori ) ho notato delle discrepanze nei risultati per quanto riguarda i valori doppi, tra IE 6 e FF 2.0.
Il funzionamento corretto sembra quello di IE. VVoVe:

Le specifiche dicono che se la funzione di confronto ritorna 0, allora gli elementi non verranno scambiati e il loro ordine mantenuto:
JavaScript uses a stable sort: the index partial order of a and b does not change if a and b are equal.
Ho scritto un codice di esempio, dove ordino un array 10x2 in maniera crescente in base al contenuto del primo campo. L'array ha degli elementi doppi nel primo campo, proprio per verificare se tali elementi non vengono scambiati come dovrebbero.
Sul click del bottone viene ordinato il vettore e rivisualizzato.
Provando su IE ottengo il funzionamento atteso, l'array visualizzato è sempre lo stesso, perché l'ordinamento ha sempre lo stesso criterio e visto che l'odine degli elementi doppi non viene ma ivariato (return 0 della funzione di controllo in caso di valori uguali).
Su FF invece l'esito è diverso ad ogni ordinamento. L'ordine della prima "colonna" (quella da ordinare) è mantenuto, ma in caso di valori doppi nella prima colonna variano ogni volta i valori della seconda.
Mamma mia come l'ho scritto , più facile da provare che da spiegare:
codice:
<html>
  <head>
    <style type="text/css">
      #Risultato div
        {
          float:left;
          margin-right:20px;
        {
    </style>
    <script type="text/javascript">
      vettore =
        new Array
         (
           new Array(1,3),
           new Array(2,1),
           new Array(3,1),
           new Array(7,6),
           new Array(4,4),
           new Array(3,3),
           new Array(2,9),
           new Array(7,1),
           new Array(7,3),
           new Array(4,0)
         )

      function Confronto(a, b) {
        // Il valore di ritorno di questa funzione
        // determina l'ordine dei due elementi:
        // <0 : a, b
        //  0 : ordine invariato
        // >0 : b, a
        return a[0] - b[0];
      }

      function OrdinaVisualizza() {
        vettore.sort(Confronto);
        document.getElementById("Risultato").innerHTML += "<div>" + vettore.join("
") + "</div>";
      }
    </script>
  </head>
  <body>
    <input type="button" onclick="OrdinaVisualizza();" value="Ordina e Visualizza"/>
    <div id="Risultato"></div>
  </body>
</html>
La stessa cosa la si può notare anche con un array a una dimensione. Mettendo return 0; come istruzione della funzione di controllo, ci si aspetta che il vettore originale non venga mai modificato.
Beh, su IE è così, mentre su FF vengono effettuati degli scambi.



Dal lato pratico il mio problema è nell'ordinamento di una tabella, cliccando sulle intestazioni ordino (in senso ascendente al primo click, discendente al secondo e così via) le righe in base alla colonna cliccata.
Effettuando ordinamenti in successione su colonne diverse vorrei che gli elementi doppi della colonna ordinata siano ordinati in base all'ordinamento effettuato in precedenza.
Cosa che con questo codice, per i motivi citati, mi esce solo su IE:
codice:
<html>
  <head>
    <style type="text/css">
      body
      {
        margin:10px;
      }
      th
      {
          cursor:pointer;
          background-color:yellow;
      }
      table, td, th
      {
        border:1px solid black;
      }
      td, th
      {
        height:28px;
        padding:2px;
      }
    </style>

    <script type="text/javascript">
      var SortIndex;
      var SortAscending = true;

      function Ordina(colonna) {
        var arr = new Array();

        //metto il contenuto della tabella in un array
        var t1 = document.getElementById("t1")
        for (var i=1; i<t1.rows.length; i++) {
          arr[i-1] = new Array();
          for (var j=0; j<t1.rows[i].cells.length; j++)
            arr[i-1][j] = t1.rows[i].cells[j].innerHTML;
        }
        //alert(arr.join("\n"));

        if (SortIndex == colonna)
          SortAscending = !(SortAscending) // se si clicca più volte sulla stessa colonna si cambia verso di ordinamento
        else
          SortAscending = true; // altrimenti ordinamento ascendente

        SortIndex = colonna;
        arr.sort(confronto); //ordinamento per la colonna scelta
        //alert(arr.join("\n"));

        //metto il contenuto dell'array ordinato nella tabella
        for (var i=1; i<t1.rows.length; i++)
          for (var j=0; j<t1.rows[i].cells.length; j++)
            t1.rows[i].cells[j].innerHTML = arr[i-1][j];

      }

      function confronto(a, b) {
          // Il valore di ritorno di questa funzione
          // determina l'ordine degli elementi nell'array:
          // <0 : a, b
          //  0 : ordine invariato
          // >0 : b, a
        if (SortAscending)
          return a[SortIndex] - b[SortIndex]; //Si scambiano solo se a>b
        else
          return b[SortIndex] - a[SortIndex]; //Si scambiano solo se a<b
      }
    </script>
  </head>

  <body>
    <table border="1" id="t1" cellspacing="1">
      <tr>
        <th onclick="Ordina(0)">col1</th>
        <th onclick="Ordina(1)">col2</th>
        <th onclick="Ordina(2)">col3</th>
        <th onclick="Ordina(3)">col4</th>
      </tr>
      <tr><td>1</td><td>1</td><td>4</td><td>4</td></tr>
      <tr><td>4</td><td>7</td><td>5</td><td>2</td></tr>
      <tr><td>6</td><td>0</td><td>6</td><td>8</td></tr>
      <tr><td>8</td><td>4</td><td>8</td><td>7</td></tr>
      <tr><td>0</td><td>4</td><td>1</td><td>1</td></tr>
      <tr><td>3</td><td>7</td><td>0</td><td>0</td></tr>
      <tr><td>8</td><td>9</td><td>4</td><td>7</td></tr>
      <tr><td>9</td><td>1</td><td>9</td><td>4</td></tr>
      <tr><td>2</td><td>1</td><td>7</td><td>2</td></tr>
      <tr><td>7</td><td>5</td><td>4</td><td>3</td></tr>
      <tr><td>9</td><td>2</td><td>8</td><td>6</td></tr>
      <tr><td>4</td><td>4</td><td>1</td><td>0</td></tr>
      <tr><td>6</td><td>9</td><td>5</td><td>8</td></tr>
    </table>
  </body>
</html>
Ora, che cacchio ho aperto a fare la discussione?
Beh, per prima cosa è uno spunto di riflessione per chiunque voglia unirsi o per chiunque abbia già affrontato il problema. C'è qualcosa che non va nei miei ragionamenti? Ho scritto qualche vaccata? Illuminatemi!
Nel caso in cui la situazione dell'ordinamento fosse quella da me capita, l'unica mia via di uscita è ordinare manualmente l'array, scrivendo un bel bubble sort?

Resto in fremente attesa delle vostre opinioni.