title: Why does toPrecision return a String?
body: <p>View this code:</p>
  
  <pre><code>function testprecision(){
      var isNotNumber = parseFloat('1.3').toPrecision(6);
      alert(typeof isNotNumber); //=&gt; string
  }
  </code></pre>
  
  <p>I would have expected a number. If 'isNotNumber' should be a real number, recasting is the solution:</p>
  
  <pre><code>alert(typeof parseFloat(isNotNumber)) //=&gt; number
  </code></pre>
  
  <p>[Edit]
  thanks for your answers. Precision is not so precise a term I conclude. It can represent the <em>total number of digits</em> of a number, or the <em>number of fractional digits</em>. Most people in the Netherlands (where I come from) think of precision in the 'number of fractional digits'-way. The javascript toPrecision method concerns the first representation, so this is confusing. Anyway, the method makes it possible to introduce 'false precision', am I right? For the second meaning we have toFixed, the same goes for that (returns string, possibility of false precision). </p>
  
  <p>Anyway, having made reinventing the wheel my main hobby, I played around to construct a javascript float object, using the knowledge I gathered here. Maybe it's usefull for someone out there, or maybe one of you have better ideas?</p>
  
  <pre><code>function Float(f,nDec) {
    var Base = this,val;
    setPrecision( nDec || 2 );      
    set( f || 0, nDec || Base.precision );
    Base.set    = set;
    Base.ndec   = setPrecision;
    /** public setprecision 
     *  sets a value for the number of fractional
     *  digits (decimals) you would like getf to 
     *  return. NB: can't be more than 20.
     *  Returns the Float object, so allows method 
     *  chaining
     *  @param {Number} iPrecision
     */
    function setPrecision(iPrecision) {
        var ix = parseInt(iPrecision,10) || 2;
         Base.precision = ix &gt;= 21 ? 20 : ix;
         return Base;
    }
    /** public set
     *  sets the 'internal' value of the object. Returns
     *  the Float object, so allows method chaining
     *  @param {Number} f
     *  @param {Number} ndec
     */
    function set(f,ndec) {
         val =  parseFloat(f) || 0;
         if (ndec) { setPrecision(ndec); }
         Base.val = val;
         return Base;
    }
    /** public get: 
     * return number value (as a float)
     */
    Base.get = function(){
        var ndec = Math.pow(10,Base.precision),
            ival = parseInt(val*ndec,10)/ndec;
        Base.val = ival;
        return Base.val;
    };
    /** public getf 
     *  returns formatted string with precision
     *  (see Base.setPrecision)
     *  if [hx] is supplied, it returns
     *  the float as hexadecimal, otherwise
     *  @param {Boolean} hx
     */
    Base.getf = function(hx){
        var v = Base.val.toFixed(Base.precision);
        return hx ? v.toString(16) : v;
    };
    /** public add
     * adds [f] to the current value (if [f] is a
     * Float, otherwise returns current value)
     * optionally sets a new number of decimals
     * from parameter [ndec]
     * @param {Number} f
     * @param {Number} ndec
     */
    Base.add = function(f,ndec){
        if ( parseFloat(f) || val===0) {
             set(Base.val+parseFloat(f));
             if (ndec) { setPrecision(ndec);}
        }
       return Base.get();
    };
    /** toString 
     *  returns the internal value of the Float object
     *  functions like a getter (supposedly)
     */
    Base.toString = Base.get;
  }
  </code></pre>
  
  <p>usage/example:</p>
  
  <pre><code>var xf = new Float(); //=&gt; value now 0.0
  xf.set(0.86/0.8765,17).add(3.459);
  alert(xf+'|'+xf.getf()); //=&gt; 4.440175128351398|4.44017512835139800
  </code></pre>