Các câu hỏi thường gặp

Các câu hỏi thường gặp

Chúng tôi cung cấp hai định dạng cơ sở dữ liệu khác nhau (CSV và BIN).

Định dạng cơ sở dữ liệu đầu tiên được gọi là Giá trị được phân tách bằng dấu phẩy (CSV). Nó là một tệp văn bản và tất cả các trường được phân tách bằng dấu phẩy với dấu ngoặc kép trong mỗi trường. Mỗi hàng riêng lẻ là một bản ghi cơ sở dữ liệu.

Định dạng cơ sở dữ liệu thứ hai được gọi là Binary (BIN). Nó là một tệp nhị phân với thông tin cơ sở dữ liệu. Nhà phát triển truy cập vào tệp BIN bằng IP2Location API có sẵn bằng nhiều ngôn ngữ.

Bạn có thể tự động hóa cơ sở dữ liệu IP2Location LITE bằng cách sử dụng download client hoặc các ứng dụng HTTP phổ biến như wget hoặc curl. Chúng tôi cập nhật cơ sở dữ liệu IP2Location vào ngày đầu tiên của tháng dương lịch. Vui lòng tải xuống cơ sở dữ liệu mỗi tháng một lần trong một ngày ngẫu nhiên từ tuần đầu tiên của tháng dương lịch để tránh tắc nghẽn mạng. Chúng tôi sẽ vô hiệu hóa bất kỳ tài khoản LITE nào nếu phát hiện thấy tài khoản chia sẻ hoặc tải xuống lớn.

./download.pl -package DB11LITE -token DOWNLOAD_TOKEN

Package Code Description
DB11LITE IP2Location LITE DB11 - IPV4 - CSV
DB11LITEBIN IP2Location LITE DB11 - IPV4 - BIN
DB11LITE IP2Location LITE DB11 - IPV6 - CSV
DB11LITEBINIPV6 IP2Location LITE DB11 - IPV6 - BIN

Địa chỉ IP (IPV4) được chia thành 4 khối con. Mỗi khối con có một số trọng lượng khác nhau, mỗi khối được cung cấp bởi 256. Số IP đang được sử dụng trong cơ sở dữ liệu vì nó hiệu quả hơn khi tìm kiếm giữa một loạt các số trong cơ sở dữ liệu.

Số IP bắt đầu và Số IP kết thúc được tính dựa trên công thức sau:

IP Number = 16777216*w + 65536*x + 256*y + z     (1)

where

IP Address = w.x.y.z


For example, if the IP address is "202.186.13.4", then its IP Number will be "3401190660", based on the formula (1).

IP Address = 202.186.13.4

So, w = 202, x = 186, y = 13 and z = 4

IP Number = 16777216*202 + 65536*186 + 256*13 + 4
		  = 3388997632 + 12189696 + 3328 + 4
		  = 3401190660

Mã mẫu trong các ngôn ngữ lập trình khác nhau

Function Dot2LongIP (ByVal DottedIP)
	Dim i, pos
	Dim PrevPos, num

	If DottedIP = "" Then
		Dot2LongIP = 0
	Else
		For i = 1 To 4
			pos = InStr(PrevPos + 1, DottedIP, ".", 1)

			If i = 4 Then
				pos = Len(DottedIP) + 1
			End If

			num = Int(Mid(DottedIP, PrevPos + 1, pos - PrevPos - 1))
			PrevPos = pos
			Dot2LongIP = ((num Mod 256) * (256 ^ (4 - i))) + Dot2LongIP
		Next
	End If
End Function
function Dot2LongIP($IPaddr)
{
	if ($IPaddr == "") {
		return 0;
	} else {
		$ips = explode(".", "$IPaddr");
		return ($ips[3] + $ips[2] * 256 + $ips[1] * 256 * 256 + $ips[0] * 256 * 256 * 256);
	}
}
long Dot2LongIP(String ipstring) {
	String[] ipAddressInArray = ipstring.split("\\.");
	long result = 0;
	long ip = 0;

	for (int x = 3; x >= 0; x--) {
		ip = Long.parseLong(ipAddressInArray[3 - x]);
		result |= ip << (x << 3);
	}
	return result;
}
function Dot2LongIP(ipAddress)
{
	if (arguments.ipAddress EQ "") {
		return 0;
	} else {
		ips = ListToArray( arguments.ipAddress, "." );
		return( ( 16777216 * ips[1] ) + ( 65536 * ips[2] ) + ( 256 * ips[3] ) + ips[4] );
	}
}
public double Dot2LongIP(string DottedIP)
{
	int i;
	string [] arrDec;
	double num = 0;

	if (DottedIP == "") {
		return 0;
	} else {
		arrDec = DottedIP.Split(".");
		for (i = arrDec.Length - 1; i >= 0 ; i --) {
			num += ((int.Parse(arrDec[i])%256) * Math.Pow(256 ,(3 - i )));
		}

		return num;
	}
}
Public Function Dot2LongIP(ByVal DottedIP As String) As Double
	Dim arrDec() As String
	Dim i As Integer
	Dim intResult As Long

	If DottedIP = "" then
		Dot2LongIP = 0
	Else
		arrDec = DottedIP.Split(".")

		For i = arrDec.Length - 1 To 0 Step -1
			intResult = intResult + ((Int(arrDec(i)) Mod 256) * Math.Pow(256, 3 -i))
		Next

		Dot2LongIP = intResult
	End If
End function
use Socket;

sub dot2LongIP {
	my $ip_address = shift(@_);
	return unpack("N",inet_aton($ip_address));
}
require 'ipaddr'

def dot2LongIP(ip)
ipnum = IPAddr.new(ip)
return ipnum.to_i
end
import ipaddress

def dot2LongIP(ip):
return int(ipaddress.IPv4Address(ip))
uint32_t Dot2LongIP(char* ipstring)
{
	uint32_t ip = inet_addr(ipstring);
	uint8_t *ptr = (uint8_t *) &ip;
	uint32_t a = 0;

	if (ipstring != NULL) {
		a =  (uint8_t)(ptr[3]);
		a += (uint8_t)(ptr[2]) * 256;
		a += (uint8_t)(ptr[1]) * 256 * 256;
		a += (uint8_t)(ptr[0]) * 256 * 256 * 256;
	}

	return a;
}
CREATE FUNCTION Dot2LongIP (ip text)
	RETURNS bigint
	BEGIN
	DECLARE ipnum bigint;
	SET ipnum = (SELECT INET_ATON(ip));
	RETURN ipnum;
END
CREATE FUNCTION [dbo].[Dot2LongIP]( @IP VarChar(15) )
RETURNS BigInt
AS
BEGIN
DECLARE @ipA BigInt,
	 @ipB BigInt,
	 @ipC BigInt,
	 @ipD BigInt,
	 @ipE BigInt
SELECT @ipA = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipA) - 1 )

SELECT @ipB = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipB) - 1 )

SELECT @ipC = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipC) - 1 )

SELECT @ipD = @ip
SELECT @ipE = ( @ipA * 256*256*256 ) + ( @ipB * 256*256 ) + ( @ipC * 256 ) + @ipD

RETURN @ipE
END
CREATE OR REPLACE FUNCTION Dot2LongIP(text) RETURNS BIGINT AS '
SELECT
	split_part($1,''.'',1)::int8*(256*256*256)+
	split_part($1,''.'',2)::int8*(256*256)+
	split_part($1,''.'',3)::int8*256+
	split_part($1,''.'',4)::int8;'
LANGUAGE SQL;
Convert IPv4 IP Address to IP Number in Decimal Integer (IPv4 IP Address is in cell A1):
=((VALUE(LEFT(A1, FIND(".", A1)-1)))*256^3)+((VALUE(MID(A1, FIND(".", A1)+1, FIND(".", A1, FIND(".", A1)+1)-FIND(".", A1)-1)))*256^2)+((VALUE(MID(A1, FIND(".", A1, FIND(".", A1)+1)+1, FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1)-FIND(".", A1, FIND(".", A1)+1)-1)))*256)+(VALUE(RIGHT(A1, LEN(A1)-FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1))))

IP Address = w.x.y.z

To reverse IP number to IP address,

w = int ( IP Number / 16777216 ) % 256
x = int ( IP Number / 65536    ) % 256
y = int ( IP Number / 256      ) % 256
z = int ( IP Number            ) % 256


where
%
is the modulus operator and
int
returns the integer part of the division.

Mã mẫu trong các ngôn ngữ lập trình khác nhau

Function Modulus(Value1, Value2)
	Modulus = Value1 - (Int(Value1 / Value2) * Value2)
	End Function

	Function Long2DotIP (ByVal IPNum)
	Long2DotIP = Modulus(Int(IPNum / 16777216), 256) & "." & Modulus(Int(IPNum / 65536), 256) & "." & Modulus(Int(IPNum / 256), 256) & "." & Modulus(IPNum, 256)
End Function
function Long2DotIP ($IPNum)
{
	if ($IPNum == "") {
		return "0.0.0.0";
	} else {
		return (($IPNum / 16777216) % 256) . "." . (($IPNum / 65536) % 256) . "." . (($IPNum / 256) % 256) . "." . ($IPNum % 256);
	}
}
String Long2DotIP(long ipnum) {
	String result = "";
	result = ((ipnum / 16777216) % 256) + "." + ((ipnum / 65536) % 256) + "." + ((ipnum / 256) % 256) + "." + (ipnum % 256);
	return result;
}
function Modulus(value1, value2) {
	return arguments.value1 - (floor(arguments.value1 / arguments.value2) * arguments.value2);
}

function Long2DotIP(ipNum) {
	return (Modulus(floor(arguments.ipNum / 16777216), 256)) & "." & (Modulus(floor(arguments.ipNum / 65536), 256)) & "." & (Modulus(floor(arguments.ipNum / 256), 256)) & "." & (Modulus(floor(arguments.ipNum), 256));
}
public string Long2DotIP(long IPNum)
{
	string result = "";
	result = ((IPNum / 16777216) % 256) + "." + ((IPNum / 65536) % 256) + "." + ((IPNum / 256) % 256) + "." + (IPNum % 256);
	return result;
}
Public Function Long2DotIP(ByVal IPNum As Long) As String
	Dim result As String = ""
	result = (Int(IPNum / 16777216) Mod 256) & "." & (Int(IPNum / 65536) Mod 256) & "." & (Int(IPNum / 256) Mod 256) & "." & (IPNum Mod 256)
	Return result
End Function
use Socket;

sub long2DotIP {
	my $ip_number = shift(@_);
	return inet_ntoa(pack("N*", $ip_number));
}
def long2DotIP(ipnum)
	return ((ipnum / 16777216) % 256).to_s + "." + ((ipnum / 65536) % 256).to_s + "." + ((ipnum / 256) % 256).to_s + "." + (ipnum % 256).to_s
end
def long2DotIP(ipnum):
return str(int(ipnum / 16777216) % 256) + "." + str(int(ipnum / 65536) % 256) + "." + str(int(ipnum / 256) % 256) + "." + str(ipnum % 256)
char* Long2DotIP(uint32_t ipnum)
{
	uint8_t bytes[4];
	char* buf = malloc (sizeof (char) * 16);
	bytes[0] = (ipnum >> 24) & 0xFF;
	bytes[1] = (ipnum >> 16) & 0xFF;
	bytes[2] = (ipnum >> 8) & 0xFF;
	bytes[3] = ipnum & 0xFF;

	snprintf(buf, (sizeof (char) * 16), "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);

	return buf;
}
CREATE FUNCTION Long2DotIP (ipnum bigint)
	RETURNS text
	BEGIN
	DECLARE ip text;
	SET ip = (SELECT INET_NTOA(ipnum));
	RETURN ip;
END
CREATE FUNCTION [dbo].[Long2DotIP]( @IPNum BigInt )
	RETURNS VARCHAR(15)
	AS
	BEGIN
	RETURN CAST(((@IPNum / 16777216) % 256) AS VARCHAR(3)) +  + CAST(((@IPNum / 65536) % 256) AS VARCHAR(3)) +  + CAST(((@IPNum / 256) % 256) AS VARCHAR(3)) +  + CAST((@IPNum % 256) AS VARCHAR(3))
END
CREATE OR REPLACE FUNCTION Long2DotIP(BIGINT) RETURNS TEXT AS '
SELECT
CONCAT(($1 >> 24) % 256, ''.'', ($1 >> 16) % 256, ''.'', ($1 >> 8) % 256, ''.'', $1 % 256);'
LANGUAGE SQL;
Convert IP Number in Decimal Integer to IPv4 IP Address (Decimal Integer is in cell A1):
=IF(A1<>"", CONCATENATE(MOD(BITRSHIFT(A1, 24), 256), ".", MOD(BITRSHIFT(A1, 16), 256), ".", MOD(BITRSHIFT(A1, 8), 256), ".", MOD(A1, 256)), "")

Địa chỉ IP (IPv6) được chia thành 8 nhóm gồm bốn chữ số thập lục phân với dấu hai chấm làm dấu phân cách nhóm. Mỗi nhóm có một số trọng số khác nhau, mỗi số được cung cấp bởi 65536. Số IP đang được sử dụng trong cơ sở dữ liệu vì nó hiệu quả hơn khi tìm kiếm giữa một loạt các số trong cơ sở dữ liệu.

Làm cách nào để chuyển đổi Số IP thành Địa chỉ IPv6?

IP Number = (65536^7)*a + (65536^6)*b + (65536^5)*c + (65536^4)*d + (65536^3)*e + (65536^2)*f + 65536*g + h     (1)

where

IP Address = a:b:c:d:e:f:g:h


For example, if the IP address is "2001:0db8:0000:0042:0000:8a2e:0370:7334", then its IP Number will be "42540766411282594074389245746715063092", based on the formula (1).

IP Address (in hexadecimal) = 2001:0db8:0000:0042:0000:8a2e:0370:7334
IP Address (in decimal)     = 8193:3512:0:66:0:35374:880:29492

IP Number = (65536^7)*8193 + (65536^6)*3512 + (65536^5)*0 + (65536^4)*66 + (65536^3)*0 + (65536^2)*35374 + 65536*880 + 29492
          = 5192296858534827628530496329220096*8193 + 79228162514264337593543950336*3512 + 1208925819614629174706176*0 + 18446744073709551616*66 + 281474976710656*0 + 4294967296*35374 + 57671680 + 29492
          = 42540488161975842760550356425300246528 + 278249306750096353628526353580032 + 0 + 1217485108864830406656 + 0 + 151930173128704 + 57671680 + 29492
          = 42540766411282594074389245746715063092

Mã mẫu trong các ngôn ngữ lập trình khác nhau

function Dot2LongIP($ipv6) {
	return (string) gmp_import(inet_pton($ipv6));
}
java.math.BigInteger Dot2LongIP(String ipv6) {
	java.net.InetAddress ia = java.net.InetAddress.getByName(ipv6);
	byte byteArr[] = ia.getAddress();

	if (ia instanceof java.net.Inet6Address) {
		java.math.BigInteger ipnumber = new java.math.BigInteger(1, byteArr);
		return ipnumber;
	}
}
function Dot2LongIP(ipv6)
{
	if (arguments.ipv6 eq "") {
		return 0;
	} else {
		IPV6Long = CreateObject("java","java.math.BigInteger");
		IPV6NetAddress = CreateObject("java","java.net.InetAddress");
		newIp = IPV6NetAddress.getByName(arguments.ipv6);
		bytes = newIp.getAddress();
		bigInt = IPV6Long.init(1, bytes).toString();
		return bigInt;
	}
}
public System.Numerics.BigInteger Dot2LongIP(string ipv6)
{
	System.Net.IPAddress address;
	System.Numerics.BigInteger ipnum;

	if (System.Net.IPAddress.TryParse(ipv6, out address)) {
		byte[] addrBytes = address.GetAddressBytes();

		if (System.BitConverter.IsLittleEndian) {
			System.Collections.Generic.List<byte> byteList = new System.Collections.Generic.List<byte>(addrBytes);
			byteList.Reverse();
			addrBytes = byteList.ToArray();
		}

		if (addrBytes.Length > 8) {
			//IPv6
			ipnum = System.BitConverter.ToUInt64(addrBytes, 8);
			ipnum <<= 64;
			ipnum += System.BitConverter.ToUInt64(addrBytes, 0);
		} else {
			//IPv4
			ipnum = System.BitConverter.ToUInt32(addrBytes, 0);
		}
		return ipnum;
	}
}
Public Function Dot2LongIP(ByVal ipv6 As String) As System.Numerics.BigInteger
	Dim address As System.Net.IPAddress
	Dim ipnum As System.Numerics.BigInteger

	If System.Net.IPAddress.TryParse(ipv6, address) Then
		Dim addrBytes() As Byte = address.GetAddressBytes()

		If System.BitConverter.IsLittleEndian Then
			Dim byteList As New System.Collections.Generic.List(Of Byte)(addrBytes)
			byteList.Reverse()
			addrBytes = byteList.ToArray()
		End If

		If addrBytes.Length > 8 Then
			'IPv6
			ipnum = System.BitConverter.ToUInt64(addrBytes, 8)
			ipnum <<= 64
			ipnum += System.BitConverter.ToUInt64(addrBytes, 0)
		Else
			'IPv4
			ipnum = System.BitConverter.ToUInt32(addrBytes, 0)
		End If
	End If
	Dot2LongIP = ipnum
End Function
use NetAddr::IP;

sub dot2LongIP {
	my $ip_address = shift(@_);
	my $ip_number = NetAddr::IP->new($ip_address) or die;
	return $ip_number->bigint;
}
require 'ipaddr'

def dot2LongIP(ipv6)
	ipnum = IPAddr.new(ipv6)
	return ipnum.to_i
end
import ipaddress

def dot2LongIP(ipv6):
	return int(ipaddress.IPv6Address(ipv6))
#include <arpa/inet.h>
#include <inttypes.h>

typedef unsigned __int128 uint128_t;

uint128_t Dot2LongIP(const char* ipv6) {
	struct sockaddr_in6 sa;
	inet_pton(AF_INET6, ipv6, &(sa.sin6_addr));
	uint128_t ipnum = 0;
	uint128_t octet = 0;
	int i;
	for (i = 0; i < (sizeof(sa.sin6_addr.s6_addr) / sizeof(sa.sin6_addr.s6_addr[0])); i++) {
		octet = ((uint128_t)sa.sin6_addr.s6_addr[i] << ((uint128_t)(15 - i) * 8));
		ipnum = ipnum + octet;
	}
	return ipnum;
}

IP Address = a:b:c:d:e:f:g:h

To reverse IP number to IP address,

a = int ( IP Number / (65536^7) ) % 65536
b = int ( IP Number / (65536^6) ) % 65536
c = int ( IP Number / (65536^5) ) % 65536
d = int ( IP Number / (65536^4) ) % 65536
e = int ( IP Number / (65536^3) ) % 65536
f = int ( IP Number / (65536^2) ) % 65536
g = int ( IP Number / 65536 ) % 65536
h = IP Number % 65536


where
%
is the modulus operator and
int
returns the integer part of the division.

NOTE: All parts need to be converted into hexadecimal to be part of the IPv6 address.

Mã mẫu trong các ngôn ngữ lập trình khác nhau

function Long2DotIP($integer) {
	return inet_ntop(str_pad(gmp_export($integer), 16, "\0", STR_PAD_LEFT));
}
String Long2DotIP(String integer)
{
	String ipstr = new java.math.BigInteger(integer).toString(16);
	String padding = new String(new char[32 - ipstr.length()]).replace("\0", "0");
	String retval = padding + ipstr;
	retval = retval.replaceAll("(.{4})", "$1:").substring(0, 39);
	return retval;
}
function Long2DotIP(integer)
{
	if (arguments.integer eq "") {
		return 0;
	} else {
		retval = "";
		bigobj = CreateObject("java","java.math.BigInteger");
		intval = bigobj.init(integer).toString(16);
		padding = repeatstring("0", 32 - len(intval));
		retval = padding & intval;
		retval = rereplace(rereplace(retval, "(.{4})", "\1:", "ALL"), ":$", "");
		return retval;
	}
}
public string Long2DotIP(string bigint)
{
	string retval = "";
	System.Numerics.BigInteger intval = System.Numerics.BigInteger.Zero;

	if (System.Numerics.BigInteger.TryParse(bigint, out intval)) {
		retval = intval.ToString("x").PadLeft(32, '0');
		char[] trimme = new[] { ':' };
		retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme);
	}

	return retval;
}
Public Function Long2DotIP(ByVal bigint As String) As String
	Dim retval As String = ""
	Dim intval As System.Numerics.BigInteger = System.Numerics.BigInteger.Zero

	If System.Numerics.BigInteger.TryParse(bigint, intval) Then
		retval = intval.ToString("x").PadLeft(32, "0"c)
		Dim trimme As Char() = {":"c}
		retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme)
	End If

	Return retval
End Function
use Math::BigInt;

sub long2DotIP {
	my $ipnumstr = shift(@_);
	my $ipnum = Math::BigInt->new($ipnumstr);
	my $iphex = $ipnum->as_hex();
	$iphex =~ s/^0x//;
	my $ipv6 = ('0' x (32 - length($iphex))) . $iphex;
	$ipv6 =~ s/(.{4})/$1:/g;
	$ipv6 =~ s/:$//;

	return $ipv6;
}
def long2DotIP(integer)
	return integer.to_s(16).rjust(32, '0').gsub(/(.{4})/, "\1:").sub(/:$/, "")
end
import re

def long2DotIP(integer):
	retval = format(integer, 'x')
	retval = retval.zfill(32)
	retval = re.sub(r"(.{4})", r"\1:", retval)
	retval = re.sub(r":$", "", retval)
	return retval
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gmp.h>

char* Long2DotIP(char* ipnum)
{
	mpz_t bigint;
	char* buf = malloc (sizeof (char) * 33);
	char* buf2 = malloc (sizeof (char) * 40);
	int i = 0;
	int parts = 8;
	int partsize = 5;
	char **arr;
	arr = calloc(parts, sizeof *arr);

	for (i = 0; i < parts; i++)
	{
		arr[i] = calloc(partsize, sizeof *arr[i]);
	}
	mpz_init_set_str(bigint, ipnum, 10);
	gmp_snprintf(buf, (sizeof (char) * 33), "%032Zx", bigint);

	for (i = 0; i < parts; i++)
	{
		memcpy(arr[i], buf + (i * 4), 4);
	}

	snprintf(buf2, (sizeof (char) * 40), "%s:%s:%s:%s:%s:%s:%s:%s", arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7]);
	free(buf);
	free(arr);
	return buf2;
}

Đầu tiên, chuyển đổi địa chỉ IP sang định dạng số IP. Tìm kiếm Cơ sở dữ liệu IP-Quốc gia bằng cách sử dụng số IP để khớp một bản ghi có Số IP giữa Số IP bắt đầu và Số IP kết thúc.

Ví dụ: Địa chỉ IP "72.77.138.60" là "1213041212" trong Số IP. Nó khớp với tập bản ghi sau trong cơ sở dữ liệu.

"1213041208","1213041215","US","UNITED STATES"

IP2Location sẽ hiển thị trường quốc gia "-" khi dải địa chỉ IP vẫn chưa được phân bổ cho bất kỳ quốc gia nào. Nó còn được gọi là dải địa chỉ IP dành riêng.

Đầu tiên, nhập cơ sở dữ liệu này vào MSSQL, MS-ACCESS, PL / SQL, MYSQL hoặc RDMS khác của bạn. Sử dụng truy vấn SQL để lấy tập bản ghi phù hợp.

Ví dụ về Truy vấn SQL (MSSQL)

SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE [SEARCH IP NO] BETWEEN [IP FROM COLUMN] AND [IP TO COLUMN]

Ví dụ về Truy vấn SQL (MYSQL)

SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE ([IP FROM COLUMN] <= [SEARCH IP NO]) AND ([IP TO COLUMN] >= [SEARCH IP NO])

ASP không phát hiện Proxy

<%
ipaddress = Request.ServerVariables("REMOTE_ADDR")
%>

ASP với phát hiện Proxy

<%
ipaddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
if ipaddress = "" then
	ipaddress = Request.ServerVariables("REMOTE_ADDR")
end if
%>

PHP không có Proxy phát hiện

<?
$ipaddress = getenv('REMOTE_ADDR');
?>

PHP với phát hiện proxy

<?
if (getenv('HTTP_X_FORWARDED_FOR')) {
	$ipaddress = getenv('HTTP_X_FORWARDED_FOR');
} else {
	$ipaddress = getenv('REMOTE_ADDR');
}
?>

JSP không phát hiện Proxy

<%
String ipaddress = request.getRemoteAddr();
%>

JSP với phát hiện Proxy

<%
if (request.getHeader("X_FORWARDED_FOR") == null) {
	String ipaddress = request.getRemoteAddr();
} else {
	String ipaddress = request.getHeader("X_FORWARDED_FOR");
}
%>

ColdFusion không phát hiện Proxy

<CFCOMPONENT>
<CFSET ipaddress="#CGI.Remote_Addr#">
</CFCOMPONENT>

ColdFusion với phát hiện Proxy

<CFCOMPONENT>
<CFIF #CGI.HTTP_X_Forwarded_For# EQ "">
<CFSET ipaddress="#CGI.Remote_Addr#">
<CFELSE>
<CFSET ipaddress="#CGI.HTTP_X_Forwarded_For#">
</CFIF>
</CFCOMPONENT>

ASP.NET (C #) với tính năng phát hiện Proxy

public string IpAddress()
{
	string strIp;
	strIp = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

	if (strIp == null) {
		strIp = Request.ServerVariables["REMOTE_ADDR"];
	}
	return strIp;
}

ASP.NET (VB.NET) không phát hiện Proxy

Public Function IpAddress()
	IpAddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
End Function

ASP.NET (VB.NET) với tính năng phát hiện Proxy

Public Function IpAddress()
	Dim strIp As String
	strIp = Request.ServerVariables("HTTP_X_FORWARDED_FOR")

	If strIp = "" Then
		strIp = Request.ServerVariables("REMOTE_ADDR")
	End If

	IpAddress = strIp
End Function

Có, chúng tôi sẽ gửi thông báo qua email khi có bản cập nhật trong khu vực tải xuống.

Vui lòng truy cập So sánh các tính năng để biết thêm chi tiết.

Quyền sở hữu địa chỉ IP đôi khi thay đổi. Do đó, một tỷ lệ nhỏ các khối địa chỉ IP cần được cập nhật hàng năm. Cơ sở dữ liệu phiên bản đầy đủ của chúng tôi được cập nhật hàng tháng để đảm bảo nó luôn chính xác.

Bạn có thể truy cập ip2location.com và thực hiện mua hàng. Ngoài ra, bạn cũng có thể nâng cấp từ phiên bản LITE trong khu vực tài khoản. Chúng tôi sẽ tạo thông tin đăng nhập / mật khẩu duy nhất để cho phép bạn tải xuống cơ sở dữ liệu trong một năm sau khi chúng tôi xử lý đơn đặt hàng của bạn.

Bạn sẽ nhận được thông tin đăng nhập và mật khẩu của mình qua email ngay sau khi thanh toán được ủy quyền. Bạn có thể sử dụng thông tin đăng nhập của mình để tải xuống cơ sở dữ liệu từ trang web của chúng tôi bất cứ lúc nào. Cơ sở dữ liệu ở định dạng nén ZIP để tiết kiệm băng thông và thời gian tải xuống của bạn.

Bạn có thể phân phối lại một bản sao của cơ sở dữ liệu LITE với ứng dụng của mình với sự phân bổ. Tuy nhiên, bạn cần thông báo cho tất cả người dùng đăng ký giấy phép cá nhân trong https: //lite.ip2location.com để tải xuống các bản cập nhật hàng tháng. Kho lưu trữ cơ sở dữ liệu của bên thứ ba không được phép.

LocaProxy.com. Nó cung cấp proxy HTTP đa vị trí để giúp các doanh nghiệp thử nghiệm các ứng dụng định vị địa lý. Giải pháp này làm giảm tổng chi phí thử nghiệm bằng cách cung cấp Cơ sở hạ tầng phân tán dưới dạng Dịch vụ.

IP2Location không cung cấp hỗ trợ khách hàng cho cơ sở dữ liệu IP2Location LITE miễn phí. Nếu bạn có câu hỏi liên quan đến lập trình về cách sử dụng những cơ sở dữ liệu này mà không được trả lời trong Câu hỏi thường gặp, chúng tôi khuyên bạn nên hỏi trên Stack Overflow.