& # 8220; Intelligent & # 8221; Cast de double à deux chaînes formatées différemment?

Question

Je travaille avec une base de données dans laquelle le seul type de données (numérique) qu'il peut stocker est un double . Ce que je veux faire, c'est choisir le numéro d'une rangée donnée et le placer dans une requête HTTP. Le problème tourne autour de ce que je ne peux pas savoir si ce nombre devrait ou non avoir des décimales.

Par exemple, si le double est un identifiant, je ne peux effectuer aucune mise en forme, car le site qui reçoit la requête HTTP sera confus. Observez les exemples suivants:

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 solution à ce problème consisterait à définir un long . Ignorant le problème du débordement du long, il résout la notation scientifique et décimale (évidemment). Cela pourrait être une solution acceptable, mais ce serait bien si le code ne supposait pas qu'il s'agissait d'identifiants auxquels nous avions affaire. Et si, par exemple, je consultais un site qui affiche une carte et dont le nombre correspond à des coordonnées, où les décimales sont très importantes? Un casting trop long n'est plus acceptable.

En bref;

• Si le double n'a pas de décimale, n'ajoutez pas de décimale de fin.
• S'il contient des décimales, conservez-les tous.
• Les deux cas ne doivent pas avoir de notation scientifique ni de milliers de séparateurs.

Cette solution sera portée à la fois en C # et en Java, j'accepte donc les réponses dans les deux langues. (Oh, et je ne savais pas comment appeler cette question, n'hésitez pas à le renommer si vous avez quelque chose de mieux.)

Answer 1

Voici ma propre conclusion:

• Vérifiez si le double a des décimales.
• En fonction de cela, formatez la chaîne en conséquence.

• Et puis quelque chose d'important; sans spécifier une culture invariante, la virgule dans le cas des nombres décimaux peut être un "," au lieu de ". " qui n'est pas aimé par les requêtes HTTP. Bien entendu, ce problème ne se présente que si votre système d'exploitation est défini sur une langue qui préfère la virgule.

  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

Pour compléter la réponse de gustafc (qui m'a battu d'une minute), voici la ligne de code appropriée pour C #:

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

ou

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

Answer 3

Comme il est prudent de formater la valeur sans les zéros de fin si elle est intégrale (qu’elle représente un ID ou une coordonnée), pourquoi ne pas simplement codifier la logique que vous décrivez dans vos puces? Par exemple (C #, mais devrait traduire facilement en 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

Pourquoi ne pas encapsuler le nombre dans un type personnalisé?

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();
        }
    }
}

Voir aussi la réponse de Vilx- pour un meilleur algorithme que celui ci-dessus.

Answer 5

vérifie si num == round (num)

Answer 6

En Java, vous pouvez le faire avec DecimalFormat .

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

Les espaces réservés # n'apparaissent que si le nombre indiqué est autre que des zéros, et le point décimal n'apparaît que s'il est suivi d'un élément.