Die IP-Adressen gespeichert als int-Ergebnisse im überlauf?

Ich Schreibe ein chat-server in node.js und ich will, speichern die angeschlossenen Benutzer IP-Adressen in einer mysql-Datenbank als (unsigned) Ganzzahlen.
Ich habe geschrieben eine javascript-Methode zum konvertieren einer ip-Adresse als string in eine Ganzzahl. Ich bekomme einige seltsame Ergebnisse jedoch.

Hier ist mein code:

function ipToInt(ip) {
    var parts = ip.split(".");
    var res = 0;

    res += parseInt(parts[0], 10) << 24;
    res += parseInt(parts[1], 10) << 16;
    res += parseInt(parts[2], 10) << 8;
    res += parseInt(parts[3], 10);

    return res;
}

Wenn ich rufen Sie die Methode als ipToInt("192.168.2.44"); den Ergebnissen, die ich bekomme, ist -1062731220.
Es scheint wie ein überlauf aufgetreten ist, das ist seltsam, weil die erwartete Ausgabe (3232236076) im inneren ist die Zahl, die in javascript (2^52).

Wenn ich überprüfen -1062731220 in binärer form, ich kann sehen, dass die 3232236076 erhalten bleibt, aber gefüllt mit den führenden 1.

Ich bin mir nicht sicher, aber ich denke, dass das problem mit signed vs. unsigned Integer.

Können Sie sich erklären, was Los ist?
Und möglicherweise, wie zu analysieren -1062731220 wieder zu einem string ip?

InformationsquelleAutor der Frage JPuge | 2011-11-12

javascript

Warum ist der umgewandelten IP-negative?

Es NICHT zu einem überlauf. Der erste Teil der IP-Adresse 192 wandelt, 11000000 in Binär. Sie dann, dass die Schicht den ganzen Weg auf der linken Seite. Wenn es eine 1 in die linke position eines 32-bit-Zahl, es ist negativ.

Wie wollen Sie konvertieren wieder zu einem string?

Tun die gleiche Sache, die Sie getan haben, um die Konvertierung von string, aber in umgekehrter Richtung. Verschiebung nach rechts (und Maske)!

function intToIP(int) {
    var part1 = int & 255;
    var part2 = ((int >> 8) & 255);
    var part3 = ((int >> 16) & 255);
    var part4 = ((int >> 24) & 255);

    return part4 + "." + part3 + "." + part2 + "." + part1;
}

Warum das Rad neu erfinden? Aus Google:

ODER Sie verwenden können, welche ich hier gefunden:

http://javascript.about.com/library/blipconvert.htm

function dot2num(dot) 
{
    var d = dot.split('.');
    return ((((((+d[0])*256)+(+d[1]))*256)+(+d[2]))*256)+(+d[3]);
}

function num2dot(num) 
{
    var d = num%256;
    for (var i = 3; i > 0; i--) 
    { 
        num = Math.floor(num/256);
        d = num%256 + '.' + d;
    }
    return d;
}

InformationsquelleAutor der Antwort evan

5

Das Ergebnis von "<<" - operator ist immer eine signierte 32-bit-Ganzzahl, als pro spec.

Wenn Sie die Verschiebung zurück, verwenden Sie ">>>", um eine vorzeichenlose rechts-shift.

InformationsquelleAutor der Antwort Pointy
3

Vielleicht finden Sie auch dieses nützliche Muster:
```
ip.toLong = function toInt(ip){
  var ipl=0;
  ip.split('.').forEach(function( octet ) {
      ipl<<=8;
      ipl+=parseInt(octet);
  });
  return(ipl >>>0);
};

ip.fromLong = function fromInt(ipl){
  return ( (ipl>>>24) +'.' +
      (ipl>>16 & 255) +'.' +
      (ipl>>8 & 255) +'.' +
      (ipl & 255) );
};
```
Wenn Sie mit so etwas wie node.js wo können Sie Funktionen hinzufügen, die durch so etwas wie Npm, dann können Sie einfach tun:
```
npm install ip
```
Zu bekommen, dass die Funktionalität von der Quelle, die hier aus:

https://github.com/indutny/node-ip/blob/master/lib/ip.js

Erhalten Sie auch eine Reihe von anderen IP utility-Funktionen mit.

InformationsquelleAutor der Antwort Guy
1

Du nach Links verschoben, um die ursprüngliche Zahl, die nur 4 Sätze von bits unabhängig vom Vorzeichen.

Verschiebung nach rechts, um wieder zu der IP. Egal, was das Zeichen ist.

InformationsquelleAutor der Antwort Mike
0

IP-Adressen in der V4 Platz sind vorzeichenlose 32 bit-zahlen, also die IP-Adresse des FF.FF.FF.FF ist 2^32 sein und nicht größer als diese Zahl. Siehe:

Diese stack-überlauf Artikel über das gleiche Thema

Zu drehen, dass die Nummer wieder in eine IP-Adresse müssen Sie brechen die Reihe nach unten, in seine 4 Teile, da jedes byte ist ein Oktett von der Adresse, damit konvertieren Sie die Zahl in hex und dann analysieren jedes paar. Sie können oder möglicherweise nicht haben, um eine führende null für das erste Oktett.

Zusätzlich kann zu tun haben, die mit byte-Reihenfolge von integer ( endien Probleme ), aber da die meisten Systeme sind intel-basierte in diesen Tagen, die Sie vielleicht nicht haben, um damit umzugehen.

InformationsquelleAutor der Antwort FlyingGuy

var aaa = Number("0b"+ "192.168.2.44".split(".").map(
  function(dec){
    return ("00000000" + Number(dec).toString(2)).slice(-8); 
  }).join(""));

aaa.toString(2).match(/.{1,8}/g).map(
  function(bin){
    return Number("0b"+bin); 
  }).join(".");

InformationsquelleAutor der Antwort user2321638

Überarbeitete ich Evan ' s Letzte Antwort ein wenig, besonders dot2num. Es hat die gleiche Funktion könnte aber besser lesbar und ist geringfügig langsamer.

function ip2num(ip) {
    var parts = ip.split('.');

    var num = 0;
    num += d[0] * Math.pow(2, 24);
    num += d[1] * Math.pow(2, 16);
    num += d[2] * Math.pow(2, 8);
    num += d[3];

    return num;
}

function num2ip(num) {
    var ip = num % 256;

    for (var i=3; i > 0; i--) { 
        num = Math.floor(num / 256);
        ip = num % 256 + '.' + ip;
    }

    return ip;
}

InformationsquelleAutor der Antwort George Crowson

Versuchen, diese Lösung, es könnte helfen:

function IpToInteger(ipAddr)
{
    var parts = ipAddr.split('.');
    return (((parts[0] ? parts[0] << 24 : 0) |
             (parts[1] ? parts[1] << 16 : 0) |
             (parts[2] ? parts[2] << 8  : 0) |
             (parts[3])) >>> 0);
}

InformationsquelleAutor der Antwort TCK

function IpAddressToLong(ip){
  return ip.split('.').map((octet, index, array) => {
      return parseInt(octet) * Math.pow(256, (array.length - index - 1));
    }).reduce((prev, curr) => {
      return prev + curr;
  });
}

Entnommen repo

InformationsquelleAutor der Antwort Davit Tvildiani

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.