
# IP解析函数
本文介绍IP解析函数的语法规则，包括参数解释、函数示例等。
| 函数                                                                                                                                          | 说明                                  |
|:---|:---|
| [geo_parse]       | 根据IP地址解析出所属国家、省份和市信息                |
| [ip_cidrmatch] | 判断IP地址是否属于CIDR地址块                   |
| [ip_version]     | 判断IP地址为IPv4还是IPv6                   |
| [ip_type]      | 判断IP地址为私有地址还是公有地址                   |
| [ip_makenet]    | 将单个IP地址转换为CIDR地址块                   |
| [ip_makenet]    | 将输入的CIDR地址块按照Prefixlen或者Netmask格式输出 |
| [ip_overlaps]    | 判断两个网段是否存在重叠                        |
| [ip2long]        | 将字符串格式的IP地址转换成长整型数据                 |
| [long2ip]        | 将长整型数据转换成字符串格式的IP地址                 |
   
 #### geo_parse
根据IP地址解析出所属国家、省份和城市等信息。
- **函数格式**
  ```
  geo_parse(ip, keep_fields=None, ip_sep=None)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  |---|---|---|---|
  | ip          | String   | 是        | IP地址，表示解析该IP地址所属国家、省份和市信息。如果包含多个IP地址，可通过ip_sep参数指定分割符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
  | keep_fields | Tuple    | 否        | 返回结果中包含的key信息。支持的key如下列表： - city：城市名称。  - province：省份名称。  - country：国家名称。  - isp：所属网络运营商名称。  - lat：IP地址所在位置的纬度。  - lon：IP地址所在位置的经度。   例如keep_fields=("city","country")表示仅输出city和country字段信息。 此外keep_fields也支持重命名。例如(("city","cty"),("country","state"))表示以cty和state形式输出。 注意：keep_fields参数为tuple类型，如果只有一个参数，需要添加逗号，例如("city",)或者(("city","cty"),) |
  | ip_sep      | String   | 否        | IP地址分隔符，用于将包含多个IP地址的字符串分割为多个IP地址，解析结果通过JSON格式返回。默认值为None，表示不进行分隔。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
     
  
- **返回结果**
  返回字典形式数据。
  
- **函数示例**
  1. 单个IP查询。
     - 测试数据
       ```
       {
         "ip": "192.168.0.1"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("geo_parse", geo_parse("192.168.0.1"))
       ```
       
     
     - 加工结果（私网地址结果为空，使用公网地址可解析出内容）
       ```
       ip: 192.168.0.1
       geo_parse: {"city": "", "province": "", "country": "", "isp": "", "lat": "", "lon": ""}
       ```
       
      
  
  2. 多个IP查询。
     - 测试数据
       ```
       {
         "ip": "192.168.0.1"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("geo_parse", geo_parse("192.168.0.1,192.168.0.2", ip_sep=","))
       ```
       
     
     - 加工结果（私网地址结果为空，使用公网地址可解析出内容）
       ```
       geo_parse: {"192.168.0.1": {"province": "", "country": "", "lat": "", "lon": ""}, "192.168.0.2": {"city": "", "province": "", "country": "", "isp": "", "lat": "", "lon": ""}}
       ip: 192.168.0.1
       ```
       
      
   
 
 #### ip_cidrmatch
IP地址是否属于CIDR地址块。
- **函数格式**
  ```
  ip_cidrmatch(cidr_subnet, ip, default="")
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |          **说明**           |
  |---|---|---|---|
  | cidr_subnet | String   | 是        | CIDR地址块                   |
  | ip          | String   | 是        | IP地址。                     |
  | default     | String   | 否        | 如果IP地址与CIDR地址块无法匹配时，返回该值。 |
     
  
- **返回结果**
  当IP地址属于CIDR地址块时，返回true，否则返回false。
  
- **函数示例**
  1. ipv4地址与CIDR地址块匹配。
     - 测试数据
       ```
       {
         "subnet": "192.168.1.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_cidrmatch(v("subnet"),"192.168.1.11"))
       ```
       
     
     - 加工结果
       ```
       subnet: 192.168.1.0/24
       result:    true
       ```
       
      
  
  2. ip地址与CIDR地址块无法匹配。
     - 测试数据
       ```
       {
         "subnet": "192.168.1.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_cidrmatch(v("subnet"),"192.168.100.10", default="error"))
       ```
       
     
     - 加工结果
       ```
       subnet: 192.168.1.0/24
       result:    error
       ```
       
      
   
 
 #### ip_version
判断IP地址为IPv4还是IPv6。
- **函数格式**
  ```
  ip_version(ip, default="")
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |      **说明**       |
  |---|---|---|---|
  | ip       | String   | 是        | 输入IP地址。           |
  | default  | String   | 否        | 无法判断IP地址版本时，返回该值。 |
     
  
- **返回结果**
  IPv4或IPv6。
  
- **函数示例**
  1. Ipv4地址。
     - 测试数据
       ```
       {
         "ip": "10.21.115.10"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("version",ip_version(v("ip")))
       ```
       
     
     - 加工结果
       ```
       ip: 10.21.115.10
       version: IPv4
       ```
       
      
  
  2. Ipv6地址。
     - 测试数据
       ```
       {
         "ip": "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("version",ip_version(v("ip")))
       ```
       
     
     - 加工结果
       ```
       ip: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
       version: IPv6
       ```
       
      
   
 
 #### ip_type
判断IP地址是私有地址还是公有地址。
- **函数格式**
  ```
  ip_type(ip, default="")
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |      **说明**       |
  |---|---|---|---|
  | ip       | String   | 是        | IP地址。             |
  | default  | String   | 否        | 无法判断IP地址类型时，返回该值。 |
     
  
- **返回结果**
  IP类型private、reserved、loopback、public和allocated ripe ncc。
  
- **函数示例**
  1. 私有地址。
     - 测试数据
       ```
       {
         "ip": "10.1.2.3"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_type(v("ip")))
       ```
       
     
     - 加工结果
       ```
       ip: 10.1.2.3
       result: private
       ```
       
      
  
  2. Ipv6地址。
     - 测试数据
       ```
       {
         "ip": "127.0.0.1"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_type(v("ip")))
       ```
       
     
     - 加工结果
       ```
       ip: 127.0.0.1
       result: loopback
       ```
       
      
   
 
 #### ip_makenet
将单个IP地址转换为CIDR地址块。
- **函数格式**
  ```
  ip_makenet(ip, subnet_mask=None, default="")
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |             **说明**             |
  |---|---|---|---|
  | ip          | String   | 是        | IP地址                           |
  | subnet_mask | String   | 是        | 子网掩码， 如果ip中输入的是IP网段，则子网掩码可以为空。 |
  | default     | String   | 否        | 无法将IP地址转成CIDR地址块时，返回该值。        |
     
  
- **返回结果**
  CIDR地址块。
  
- **函数示例**
  1. ip地址范围转为CIDR地址块。
     - 测试数据
       ```
       {
         "ip": "192.168.10.0-192.168.10.255"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_makenet(v("ip")))
       ```
       
     
     - 加工结果
       ```
       ip： 192.168.10.0-192.168.10.255
       result: 192.168.10.0/24
       ```
       
      
  
  2. ip地址转为CIDR地址块。
     - 测试数据
       ```
       {
         "ip": "192.168.10.0"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_makenet(v("ip"),"255.255.255.0"))
       ```
       
     
     - 加工结果
       ```
       ip： 192.168.10.0
       result: 192.168.10.0/24
       ```
       
      
   
 
#### ip_to_format
将输入的CIDR地址块按照Prefixlen或者Netmask格式输出。
- **函数格式**
  ```
  ip_to_format(cidr_subnet, want_prefix_len=0, default="")
  ```
  
- **参数说明**
  
  |    **参数名称**     | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  |---|---|---|---|
  | cidr_subnet     | String   | 是        | 输入CIDR地址块，例如：192.168.10.0/24                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | want_prefix_len | Int      | 否        | 设置返回格式，默认为0。 - 0：无格式返回。  - 1：prefix格式返回。  - 2：netmask格式返回。  - 3：IP网段格式返回。   |
  | default         | String   | 否        | 无法将输入的CIDR地址块按照格式输出时，返回该值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
     
  
- **返回结果**
  特定格式的IP地址。
  
- **函数示例**
  1. 按照IP地址网段格式输出。
     - 测试数据
       ```
       {
         "ip": "192.168.11.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_to_format(v("ip"),3))
       ```
       
     
     - 加工结果
       ```
       ip: 192.168.11.0/24
       result: 192.168.11.0-192.168.11.255
       ```
       
      
  
  2. 按照netmask格式输出。
     - 测试数据
       ```
       {
         "ip": "192.168.11.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_to_format(v("ip"),2))
       ```
       
     
     - 加工结果
       ```
       ip: 192.168.11.0/24
       result: 192.168.11.0/255.255.255.0
       ```
       
      
  
  3. 按照prefix格式输出。
     - 测试数据
       ```
       {
         "ip": "192.168.11.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_to_format(v("ip"),1))
       ```
       
     
     - 加工结果
       ```
       ip: 192.168.11.0/24
       result: 192.168.11.0/24
       ```
       
      
   
 
 #### ip_overlaps
两个网段是否存在重叠。
- **函数格式**
  ```
  ip_overlaps(cidr_subnet, cidr_subnet2, default="")
  ```
  
- **参数说明**
  
  |   **参数名称**   | **参数类型** | **是否必填** |          **说明**          |
  |---|---|---|---|
  | cidr_subnet  | String   | 是        | 输入CIDR地址块1。              |
  | cidr_subnet2 | String   | 是        | 输入CIDR地址块2。              |
  | default      | String   | 否        | 无法判断两个CIDR地址块是否重叠时，返回该值。 |
     
  
- **返回结果**
  0： 两个CIDR地址块不重叠
  1： 两个CIDR地址块重叠在结束位置
  -1： 两个CIDR地址块重叠在开始位置
  
- **函数示例**
  1. 示例1：两个CIDR地址块不重叠。
     - 测试数据
       ```
       {
        "a": "192.168.0.0/24",
        "b": "192.168.1.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_overlaps(v("a"),v("b")))
       ```
       
     
     - 加工结果
       ```
       a: 192.168.0.0/24
       b: 192.168.1.0/24
       result: 0
       ```
       
      
  
  2. 示例2：两个CIDR地址在开始位置重叠。
     - 测试数据
       ```
       {
        "a": "192.168.1.0/24",
        "b": "192.168.0.0/23"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_overlaps(v("a"),v("b")))
       ```
       
     
     - 加工结果
       ```
       a: 192.168.1.0/24
       b: 192.168.0.0/23
       result: -1
       ```
       
      
  
  3. 示例3：两个CIDR地址在结尾位置重叠。
     - 测试数据
       ```
       {
        "a": "192.168.0.0/23",
        "b": "192.168.1.0/24"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip_overlaps(v("a"),v("b")))
       ```
       
     
     - 加工结果
       ```
       a: 192.168.0.0/23
       b: 192.168.1.0/24
       result: 1
       ```
       
      
   
 
 #### ip2long
将字符串格式的IP地址转换成长整型数据。
- **函数格式**
  ```
  ip2long(value,default=0)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |      **说明**       |
  |---|---|---|---|
  | value    | String   | 是        | 需要被转换的值。          |
  | default  | String   | 否        | 某个不合法的IP地址被转换成的值。 |
     
  
- **返回结果**
  转换后的长整型数据。
  
- **函数示例**
  1. 正常解析。
     - 测试数据
       ```
       {
        "ip": "116.209.192.0"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip2long(v("ip")))
       ```
       
     
     - 加工结果
       ```
       result: 1959903232
       ip: 116.209.192.0
       ```
       
      
  
  2. 非法解析。
     - 测试数据
       ```
       {
        "ip": "116.209.abc.xxx"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result",ip2long(v("ip"), "error"))
       ```
       
     
     - 加工结果
       ```
       result: error
       ip: 116.209.abc.xxx
       ```
       
      
   
 
 #### long2ip
将长整型数据转换成字符串格式的IP地址。
- **函数格式**
  ```
  long2ip(value,default="")
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |       **说明**        |
  |---|---|---|---|
  | value    | String   | 是        | 需要被转换的值。            |
  | default  | String   | 否        | 表示将不合法的长整型数据转成空字符串。 |
     
  
- **返回结果**
  长整型转换成功后的IP地址。
  
- **函数示例**
  1. 正确的转换。
     - 测试数据
       ```
       {
        "data": "1959903232"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("ip",long2ip(v("data")))
       ```
       
     
     - 加工结果
       ```
       data: 1959903232
       ip: 116.209.192.0
       ```
       
      
  
  2. 转换失败后自定义的错误处理。
     - 测试数据
       ```
       {
        "data": "4294967296"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("ip",long2ip(v("data"), default="error"))
       ```
       
     
     - 加工结果
       ```
       data: 4294967296
       ip: error
       ```
       
      
   
 
