~~ vs parseInt? [duplicate]

Question

Possible Duplicate:
What is the “double tilde” (~~) operator in JavaScript?

The D3 tutorial gives a function that produces a random sequence:

var t = 1297110663, // start time (seconds since epoch)
    v = 70, // start value (subscribers)
    data = d3.range(33).map(next); // starting dataset

function next() {
  return {
    time: ++t,
    value: v = ~~Math.max(10, Math.min(90, v + 10 * (Math.random() - .5)))
  };
}

Note the ~~ (tilda tilda) in:

    value: v = ~~Math.max(10, Math.min(90, v + 10 * (Math.random() - .5)))

From playing around in the javascript terminal, I see:

~~1
1
~~-1
-1
~~-1.3
-1
parseInt(5)
5
parseInt(-5)
-5
parseInt(-5.3)
-5
parseInt(5.3)
5

Since ~~ and parseInt seem to be equivalent, whats the rationale for using parseInt?

Answer 1

They are not equivalent.

• parseInt() turns strings into numbers, reading up to and ignoring the first non-integer character, and also possibly performing base conversion (e.g. interpreting a string as octal, or hexadecimal).

console.log(



  parseInt(011)           +'\n'+ // 9
  parseInt('011')         +'\n'+ // 11
  parseInt('42 cats')     +'\n'+ // 42
  parseInt('0xcafebabe')  +'\n'+ // 3405691582
  parseInt('deadbeef',16) +'\n'+ // 3735928559
  parseInt('deadbeef',36) +'\n'  // 1049836114599



);

• var x = ~~y; is a 'trick'—similar to var x = y << 0;—that (ab)uses the unary bitwise NOT operator to force the result to be in the range of a signed 32-bit integer, discarding any non-integer portion.

console.log(



  parseInt(011)                +'\n'+// 9
  parseInt('011')              +'\n'+// 11
  parseInt('42 cats')          +'\n'+// 42
  parseInt('0xcafebabe')       +'\n'+// 3405691582
  parseInt('deadbeef',16)      +'\n'+// 3735928559
  parseInt('deadbeef',36)      +'\n' // 1049836114599



);

Using ~~x is often done because:

1. It's usually faster than calling a method.
2. It's faster to type than anything else.
3. It makes power users feel cool because it's sort of inscrutable and also sort of justifiable. :)

As seen in the cafebabe test, numbers above 2^{31  -}1 (  2,147,483,647  ) or below  ^-2³¹
(  −2,147,483,648  ) will "wrap around" due to the limits of a signed 32-bit integer.

Answer 2

parseInt isn't limited to signed 32 bit numbers.

   // Top range for a bitwise operator provides a valid result
~~((Math.pow(2,32)/2)-1); // 2147483647

   // Beyond the top range provides undesired result
~~(Math.pow(2,32)/2); // -2147483648

Also, with parseInt you can specify the radix.