& # 8220; Inteligente & # 8221; ¿Reparto de dos o dos cadenas de formato diferente?

Question

Estoy trabajando con una base de datos que tiene el límite de que el único tipo de datos (numérico) que puede almacenar es un doble . Lo que quiero hacer es elegir el número de una fila determinada y ponerlo en una solicitud HTTP. El problema gira en torno a que no puedo saber si este número debería tener o no decimales.

Por ejemplo, si el doble es una ID, no puedo tener ningún tipo de formato, ya que el sitio que recibe la solicitud HTTP se confundirá. Observe los siguientes ejemplos:

site.com/showid.php?id=12300000 // OK
site.com/showid.php?id=1.23E7 // Bad; scientific notation
site.com/showid.php?id=12300000.0 // Bad; trailing decimal

La solución a esto sería lanzarlo a un largo . Ignorando el problema de desbordar el largo, resuelve la notación científica y (obviamente) el decimal final. Esta podría ser una solución aceptable, pero sería bueno si el código no asumiera que se trata de identificaciones. ¿Qué pasaría si, por ejemplo, tuviera que consultar un sitio que muestra un mapa y el número son coordenadas, donde los decimales son muy importantes? Entonces un lanzamiento demasiado largo ya no es aceptable.

En resumen;

• Si el doble no tiene decimales, no agregue un decimal final.
• Si tiene decimales, consérvelos todos.
• Ninguno de los casos debe tener notación científica o miles de separadores.

Esta solución se transferirá a C # y Java, por lo que acepto las respuestas en ambos idiomas. (Ah, y no tenía idea de cómo llamar a esta pregunta, siéntase libre de cambiar el nombre si tiene algo mejor).

Answer 1

Aquí está mi propia conclusión:

• Compruebe si el doble tiene decimales.
• Dependiendo de eso, formatee la cadena en consecuencia.

• Y luego algo importante; sin especificar una cultura invariante, la coma en el caso de decimales puede ser un '', `` en lugar de un ". " que no es del agrado de las solicitudes HTTP. Por supuesto, este problema solo surge si su sistema operativo está configurado en una configuración regional que prefiere la coma.

  public static string DoubleToStringFormat(double dval)
  {
      long lval = (long)dval;
      if ((double)lval == dval)
      {
          // has no decimals: format as integer
          return dval.ToString("#.", CultureInfo.InvariantCulture);
      }
      else
      {
          // has decimals: keep them all
          return dval.ToString("0.##################", CultureInfo.InvariantCulture);
      }
  }
  

Answer 2

Para complementar la respuesta de gustafc (quien me ganó por 1 minuto), aquí está la línea de código relevante para C #:

MyDouble.ToString("0.################")

o

string.Format("{0:0.################}", MyDouble);

Answer 3

Dado que es seguro formatear el valor sin ceros al final si es integral (ya sea que represente una ID o una coordenada), ¿por qué no simplemente codificar la lógica que describe en sus viñetas? Por ejemplo (C #, pero debería traducirse fácilmente a Java):

// Could also use Math.Floor, etc., to determine if it is integral
long integralPart = (long)doubleValue;
if ((double)integralPart == doubleValue)
{
  // has no decimals: format it as an integer e.g. integralPart.ToString("D") in C#
}
else
{
  // has decimals: keep them all e.g. doubleValue.ToString("F17")
}

Answer 4

¿Qué tal encapsular el número en un tipo personalizado?

public class IntelligentNumber
{
    private readonly double number;

    public IntelligentNumber(double number)
    {
        this.number = number;
    }

    public override string ToString()
    {
        long integralPart = (long)this.number;
        if((double)integralPart == this.number)
        {
            return integralPart.ToString();
        }
        else
        {
            return this.number.ToString();
        }
    }
}

---

Consulte también la respuesta de Vilx para un algoritmo mejor que el anterior.

Answer 5

comprueba si num == round (num)

Answer 6

En Java, puede hacer esto con DecimalFormat .

static String format(double n) { 
    return new DecimalFormat("0.###########################").format(n); 
}

Los marcadores de posición # no aparecerán a menos que el número sea distinto de ceros para poner allí, y el punto decimal no se muestre a menos que haya algo detrás de él.