您的网络扫描工具烦人地挑剔输入，如果您向它提供了包含不正确字符或格式不正确的IPv4地址，则会立即崩溃。

IPv4地址是一个32位数字地址，用四个数字隔开，每个数字用句点分隔。每个数字可以为零到255。

我们需要编写一个工具来对输入进行预验证以避免这些崩溃，并且我们的特定工具很挑剔：有效的格式如下所示：a.b.c.da，b，c和d：

• 可以是一个无前导零0的自然数。
• 应介于0-255（含）之间。
• 如果不包含特殊符号+，-，,，等。
• 应为小数（以开头10）

输入：字符串

输出：真值或假​​值（也可以接受任意值）

测试用例：

Input            |  Output  |  Reason
                 |          |
- 1.160.10.240   |  true    |
- 192.001.32.47  |  false   |  (leading zeros present)
- 1.2.3.         |  false   |  (only three digits)
- 1.2.3          |  false   |  (only three digits)
- 0.00.10.255    |  false   |  (leading zeros present)
- 1.2.$.4        |  false   |  (only three digits and a special symbol present)
- 255.160.0.34   |  true    |
- .1.1.1         |  false   |  (only three digits)
- 1..1.1.1       |  false   |  (more than three periods)
- 1.1.1.-0       |  false   |  (special symbol present)
- .1.1.+1        |  false   |  (special symbol present)
- 1 1 1 1        |  false   |  (no periods)
- 1              |  false   |  (only one digit)
- 10.300.4.0     |  false   |  (value over 255)
- 10.4F.10.99    |  false   |  (invalid characters)
- fruit loops    |  false   |  (umm...)
- 1.2.3.4.5      |  false   |  (too many periods/numbers)
- 0.0.0.0        |  true    |
- 0.0 0.0.       |  false   |  (periods misplaced)
- 1.23..4        |  false   |  (a typo of 1.2.3.4)
- 1:1:1:1:1:1:1:1|  false   |  (an IPv6 address, not IPv4)

这是代码高尔夫球，因此将赢得最少的字节！

给用户的提示 -如果您想添加更多的测试用例，欢迎您（建议进行修改）。但是，请确保测试用例不会重复！谢谢

X86_64机器码： 18岁 16字节

编辑：这个答案不太有效，因为

1. 我使用inet_pton的是标准C库，这意味着我需要extern。我没有在字节数中包括extern。
2. 我将红色区域用作实际地址的结果，但称为函数也可以使用红色区域。幸运的是，它不在我的计算机上，但是某些奇怪的标准库可能会使用它，这可能会导致未定义的行为。

是的，整个事情几乎都由一个已经编写的函数完成

无论如何，这就是我得到的： 48 89 fe 6a 02 5f 48 8d 54 24 80 e9 00 00 00 00

部件：

section .text
    extern inet_pton
    global ipIsValid

ipIsValid:
    mov rsi, rdi
    ;mov rdi, 2 ; change to 10 for ipv6
    push 2
    pop rdi ; thank you peter
    lea rdx, [rsp - 128]
    jmp inet_pton

说明：

看一看inet_pton(3)。它需要一个字符串IP地址，并将其放入可以与一起使用的缓冲区中struct sockaddr。它包含3个参数：地址族（AF_INET（ipv4），2或AF_INET6（ipv6），10），ip地址的字符串以及指向输出的指针。成功返回1，无效地址返回0，或者当地址族不为AF_INET或时返回-1 AF_INET6（这将永远不会发生，因为我将常量传递给它）。

所以我只是将字符串移到第二个参数的寄存器中，将第一个寄存器设置为2，然后将第三个寄存器设置为红色区域（堆栈指针下方的128个字节），因为我不在乎结果。然后，我可以简单地jmp将inet_pton其返回给呼叫者！

我启动了这个快速测试程序来测试您的案例：

#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/ip.h>

extern int ipIsValid(char *);

int main(){
    char *addresses[] = {
        "1.160.10.240",
        "192.001.32.47",
        "1.2.3.",
        "1.2.3",
        "0.00.10.255",
        "1.2.$.4",
        "255.160.0.34",
        ".1.1.1",
        "1..1.1.1",
        "1.1.1.-0",
        ".1.1.+1",
        "1 1 1 1",
        "1",
        "10.300.4.0",
        "10.4F.10.99",
        "fruit loops",
        "1.2.3.4.5",
        NULL
    };

    for(size_t i = 0; addresses[i] != NULL; ++i){
        printf("Address %s:\t%s\n", addresses[i],
            ipIsValid(addresses[i]) ? "true" : "false");
    }
    return 0;
}

使用进行nasm -felf64 assembly.asm编译gcc -no-pie test.c assembly.o，使用进行编译，您将获得：

Address 1.160.10.240:   true
Address 192.001.32.47:  false
Address 1.2.3.: false
Address 1.2.3:  false
Address 0.00.10.255:    false
Address 1.2.$.4:    false
Address 255.160.0.34:   true
Address .1.1.1: false
Address 1..1.1.1:   false
Address 1.1.1.-0:   false
Address .1.1.+1:    false
Address 1 1 1 1:    false
Address 1:  false
Address 10.300.4.0: false
Address 10.4F.10.99:    false
Address fruit loops:    false
Address 1.2.3.4.5:  false

如果调用者应该传递AF_INET或传递AF_INET6给函数，则可以将其缩小很多

Java（JDK），63个字节

s->("."+s).matches("(\\.(25[0-5]|(2[0-4]|1\\d|[1-9])?\\d)){4}")

在线尝试！

学分

• -1字节感谢Kevin Cruijssen
• l4m2用于显示先前失败的情况.1.1.1.1。

JavaScript（Node.js），43字节

x=>x.split`.`.map(t=>[t&255]==t&&[])==`,,,`

在线尝试！

JavaScript（Node.js），46字节

x=>x.split`.`.every(t=>k--&&[t&255]==t,k=4)*!k

在线尝试！

二手的Arnauld零件

JavaScript（Node.js），54 53 51字节

x=>x.split`.`.every(t=>k--*0+t<256&[~~t]==t,k=4)*!k

在线尝试！

-2B为 0+t<256，来自Patrick Stephansen的-1B，+ 1B以避免输入1.1.1.1e-80

RegExp解决方案58 54字节

s=>/^((2(?!5?[6-9])|1|(?!0\d))\d\d?\.?\b){4}$/.test(s)

感谢Deadcode 3个字节

PHP，39 36字节

<?=+!!filter_var($argv[1],275,5**9);

在线尝试！

275像常数 FILTER_VALIDATE_IP

使用5 ** 9而不是常量FILTER_FLAG_IPV4。这足够了，因为5**9 & FILTER_FLAG_IPV4正如Benoit Esnard指出的那样是真实的，这正是PHP在后台执行的操作。

在这里，filter_var返回第一个参数（如果它是有效的IPv4地址），否则返回false。使用+!!，我们可以产生挑战所需的输出。

PHP，36字节

echo(ip2long($argv[1])===false?0:1);

ip2long是众所周知的内置函数。

Perl 6的，22个 21 20字节

-1个字节，感谢PhilH。

{?/^@(^256)**4%\.$/}

在线尝试！

说明

{                  }  # Anonymous Block
  /               /   # Regex match
   ^             $    # Anchor to start/end
    @(    )           # Interpolate
      ^256            #   range 0..255,
                      #   effectively like (0|1|2|...|255)
           **4        # Repeated four times
              %\.     # Separated by dot
 ?                    # Convert match result to Bool

05AB1E，26 24 23 22 23 字节

'.¡©g4Q₅Ý®å`®1šDïþJsJQP

-1个字节感谢@Emigna。
+1字节用于1.1.1.1E1错误修正测试用例，错误地返回真实结果。

在线尝试或验证所有测试用例。

说明：

'.¡              '# Split the (implicit) input by "."
   ©              # Save it in the register (without popping)
    g4Q           # Check that there are exactly 4 numbers
    ₅Ý®å          # Check for each of the numbers that they are in the range [0,255],
        `         # and push the result for each number separated onto the stack
    ®1šDïþJsJQ    # Check that each number does NOT start with a "0" (excluding 0s itself),
                  # and that they consist of digits only
              P   # Check if all values on the stack are truthy (and output implicitly)

PowerShell，59 51 49字节

-8个字节，谢谢@AdmBorkBork

-2个字节，true或false作者允许

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

测试脚本：

$f = {

try{"$args"-eq[IPAddress]::Parse($args)}catch{!1}

}

@(
    ,("1.160.10.240" , $true)
    ,("192.001.32.47" , $false)
    ,("1.2.3." , $false)
    ,("1.2.3" , $false)
    ,("0.00.10.255" , $false)
    ,("192.168.1.1" , $true)
    ,("1.2.$.4" , $false)
    ,("255.160.0.34" , $true)
    ,(".1.1.1" , $false)
    ,("1..1.1.1" , $false)
    ,("1.1.1.-0" , $false)
    ,("1.1.1.+1" , $false)
    ,("1 1 1 1" , $false)
    ,("1"            ,$false)
    ,("10.300.4.0"   ,$false)
    ,("10.4F.10.99"  ,$false)
    ,("fruit loops"  ,$false)
    ,("1.2.3.4.5"    ,$false)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

输出：

True: True : 1.160.10.240
True: False : 192.001.32.47
True: False : 1.2.3.
True: False : 1.2.3
True: False : 0.00.10.255
True: True : 192.168.1.1
True: False : 1.2.$.4
True: True : 255.160.0.34
True: False : .1.1.1
True: False : 1..1.1.1
True: False : 1.1.1.-0
True: False : 1.1.1.+1
True: False : 1 1 1 1
True: False : 1
True: False : 10.300.4.0
True: False : 10.4F.10.99
True: False : fruit loops
True: False : 1.2.3.4.5

说明：

该脚本尝试解析参数字符串，以构造一个.NET对象IPAddress。

• 返回$true如果object创建和参数字符串等于的字符串表示object由（归地址object.toString()）
• $false否则返回

PowerShell，59 56 54字节，“不使用.NET lib”替代

-3个字节，true或false作者允许的

-2个字节，感谢@ Deadcode提供了出色的正则表达式。

".$args"-match'^(\.(2(?!5?[6-9])|1|(?!0\B))\d\d?){4}$'

在线尝试！

感谢@ OlivierGrégoire的原始正则表达式。

C（gcc） / POSIX，26个字节

f(s){s=inet_pton(2,s,&s);}

在线尝试！

在TIO上作为64位代码工作，但sizeof(int) == sizeof(char*)在其他平台上可能需要。

PHP 7+， 37 35 32字节

这使用内置函数filter_var来确认它是IPv4地址。

为了使其正常工作，您需要将密钥传递i给GET请求。

<?=filter_var($_GET[i],275,5**9);

根据falsy结果，什么都不输出（结果）或IP（truthy结果）。

您可以尝试以下方法： http://sandbox.onlinephpfunctions.com/code/639c22281ea3ba753cf7431281486d8e6e66f68e http://sandbox.onlinephpfunctions.com/code/ff6aaeb2b2d0e0ac43f48125de0549320bc071b4

这将直接使用以下值：

• 275 = FILTER_VALIDATE_IP
• 1 << 20 = 1048576 = FILTER_FLAG_IPV4
• 5 ** 9 = 1953125（对于1048576，其要求的位为“ 1”）

感谢Benoit Esnard的这篇技巧为我节省了1个字节！

感谢Titus提醒我挑战的变化。

我已经研究过使用该功能ip2long，但它可用于不完整的IP地址。

在此挑战中，不完整的IPv4地址被视为无效。

如果允许，这将是最终代码（仅适用于PHP 5.2.10）：

<?=ip2long($_GET[i]);

当前，在文档中没有明确指出这将在较新的PHP版本中停止工作（如果传递了不完整的ip）。

经过测试，确认确实如此。

感谢nwellnhof的小费！

Python 3：81 78 70 69 66字节

['%d.%d.%d.%d'%(*x.to_bytes(4,'big'),)for x in range(16**8)].count

循环访问所有可能的IPv4地址，获取字符串表示形式并将其与输入进行比较。嗯...需要一段时间才能运行。

编辑：通过从完整程序切换到匿名功能删除了3个字节。

EDIT2：在xnor的帮助下删除了8个字节

EDIT3：通过使用解压缩的映射而不是列表理解来删除1个字节

EDIT4：通过使用列表理解而不是ipaddress模块删除了3个字节

C＃（Visual C＃交互式编译器），84 79 65字节

s=>s.Split('.').Sum(t=>byte.TryParse(t,out var b)&t==b+""?1:5)==4

在线尝试！

感谢@dana，节省了-5和-14个字节！

＃C＃（Visual C＃交互式编译器），61字节

s=>s.Count(c=>c==46)==3&IPAddress.TryParse(s,out IPAddress i)

在线尝试！

这是一项正在进行的工作。代码使用System.Net（如果计数，则为+17字节）。如果您想知道为什么我要计数和解析：

IPAddress.TryParse方法的局限性在于它验证是否可以将字符串转换为IP地址，因此，如果提供的字符串值为“ 5”，它将视为“ 0.0.0.5”。

资源

正如@milk在评论中所说，它的确会导致前导零失败。因此，这61个字节不起作用。

Python 2中，85个82 81字节

-1字节感谢Kevin Cruijssen

from ipaddress import*
I=input()
try:r=I==str(IPv4Address(I))
except:r=0
print~~r

在线尝试！

113字节答案被删除，因为它失败了1.1.1.1e-80

Japt，17 15字节

q.
ʶ4«Uk#ÿòs)Ê

尝试或运行所有测试用例，或从挑战注释中验证其他测试用例

说明

我们拆分为一个数组 .，检查该的长度等于4AND并且["0","255"]从该范围中删除所有范围中的元素的长度为false（0）。

                 :Implicit input of string U
q.               :Split on "."
\n               :Reassign resulting array to U
Ê                :Length of U
 ¶4              :Equals 4?
   «             :&&!
    Uk           :Remove from U
      #ÿ         :  255
        ò        :  Range [0,255]
         s       :  Convert each to a string
          )      :End removal
           Ê     :Length of resulting array

Mathematica，39 31字节

原始版本：

¬FailureQ[Interpreter["IPAddress"][#]]&

修改后的版本（感谢Misha Lavrov）

 AtomQ@*Interpreter["IPAddress"]

True如果输入的是有效IP地址，则返回该值（请尝试）。

如果你坚持要1和0代替，再追加7个字节是必要的：

Boole/@AtomQ@*Interpreter["IPAddress"]

JavaScript（ES6），49个字节

返回一个布尔值。

s=>[0,1,2,3].map(i=>s.split`.`[i]&255).join`.`==s

在线尝试！

Python 2，93 89 67 53字节

[i==`int(i)&255`for i in input().split('.')]!=[1]*4>_

在线尝试！

感谢丹尼斯剃须另一在内部比较和退出代码上 14个字节。

特别感谢Jonathan Allan节省了22个字节并修复了逻辑问题！讨厌的尝试/除非死神！

感谢乔·金（Jo King），采用格式正确的字符串而不是原始字节可以减少4个字节。

sfk, 176 bytes

* was originally Bash + SFK but TIO has since added a proper SFK wrapper

xex -i "_[lstart][1.3 digits].[1.3 digits].[1.3 digits].[1.3 digits][lend]_[part2]\n[part4]\n[part6]\n[part8]_" +xed _[lstart]0[digit]_999_ +hex +linelen +filt -+1 -+2 +linelen

Try it online!

Python3 Bash* 60

*Also other shells. Any one for which the truthy/falsy test passes on a program exit code

read I
python3 -c "from ipaddress import*;IPv4Address('$I')"

Explanation

The trouble with a pure Python solutions is that a program crashing is considered indeterminate. We could use a "lot" of code to convert an exception into a proper truthy/fasly value. However, at some point the Python interpreter handles this uncaught exception and returns a non-zero exit code. For the low-low cost of changing languages to your favourite Unix shell, we can save quite a bit of code!

Of course, this is vulnerable to injection attacks... Inputs such as 1.1.1.1'); print('Doing Something Evil are an unmitigated threat!

ECMAScript pure regex, 41 bytes

^((2(?!5?[6-9])|1|(?!0\B))\d\d?\.?\b){4}$

Try it online!
Try it on regex101

I think the logic in this regex speaks for itself, so I will merely pretty-print but not comment it:

^
(
    (
        2(?!5?[6-9])
    |
        1
    |
        (?!0\B)
    )
    \d\d?
    \.?\b
){4}
$

This can be used to shave 2 bytes off the following other answers:

• Olivier Grégoire (Java (JDK))
• l4m2 (JavaScript (Node.js))
• mazzy (PowerShell)
• Kevin Cruijssen (Retina)

Here is an alternative version that allows leading zeros, but does so consistently (octets may be represented by a maximum of 3 decimal digits):

^((2(?!5?[6-9])|1|0?)\d\d?\.?\b){4}$

Or allow any number of leading zeros:

^(0*(2(?!5?[6-9])|1?)\d\d?\.?\b){4}$

Red, 106 bytes

func[s][if error? try[t: load s][return off]if 4 <> length? t[return off]s =
form as-ipv4 t/1 t/2 t/3 t/4]

Try it online!

Returnd true or false

Explanation:

f: func [ s ] [
    if error? try [                  ; checks if the execution of the next block result in an error
        t: load s                    ; loading a string separated by '.' gives a tuple   
    ] [                              ; each part of which must be in the range 0..255
        return off                   ; if there's an error, return 'false' 
    ]
    if 4 <> length? t [              ; if the tuple doesn't have exactly 4 parts
        return off                   ; return 'false'  
    ]
    s = form as-ipv4 t/1 t/2 t/3 t/4 ; is the input equal to its parts converted to an IP adress
]

Stax, 14 bytes

∞n·Θ3ª&JH‼∙*~Γ

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

VB      constant 256
r       [0 .. 255]
'|*     coerce and string-join with "|"; i.e. "0|1|2|3 ... 254|255"
:{      parenthesize to "(0|1|2|3 ... 254|255)"
]4*     make 4-length array of number pattern
.\.*    string join with "\\."; this forms the complete regex
|Q      is the input a complete match for the regex?

Run this one

Python 3, 109 93 bytes

import re
lambda x:bool(re.match(r'^((25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(\.(?!$)|$)){4}$',x))

Explanation

Each octet can be 0 - 255 :

• starts with 25 and having 0-5 as last digit
• start with 2, has 0-4 as second digit and any digit at the end
• starts with 1, and 00 - 99 as rest digits
• has only 2 digits - 1-9 being the first one and any digit thereafter
• or just a single digit

An octet can end with a (.) or just end, with the condition that it cannot do both , the negative lookahead (?!$) takes care of this case

Thanks @Zachary for making me realize I can discard spaces (since it is code golf)
Thanks @DLosc for the improvements and making me realize my mistake, its been corrected now.

Bash, 30 bytes

ipcalc -c `cat`;echo $(($?^1))

Try it online!

Charcoal, 45 21 bytes

Ｉ∧⁼№θ.³¬Φ⪪θ.¬№Ｅ²⁵⁶Ｉλι

Try it online! Link is to verbose version of code. Edit: Saved 24 bytes by porting @Shaggy's Japt answer. Explanation:

    θ                   Input string
   №                    Count occurrences of
     .                  Literal `.`
  ⁼                     Equal to
      ³                 Literal 3
 ∧                      Logical And
       ¬                Logical Not
          θ             Input string
         ⪪              Split on
           .            Literal `.`
        Φ               Filter by
            ¬           Logical Not
               ²⁵⁶      Literal 256
              Ｅ         Map over implicit range
                   λ    Map value
                  Ｉ     Cast to string
             №          Count occurrences of
                    ι   Filter value
Ｉ                       Cast to string
                        Implicitly print

Retina, 46 44 bytes

^
.
^(\.(25[0-5]|(2[0-4]|1\d|[1-9])?\d)){4}$

Port of @OlivierGrégoire's Java answer, so make sure to upvote him!
-2 bytes thanks to @Neil.

Try it online.

Explanation:

^
.                           # Prepend a dot "." before the (implicit) input
^...$                       # Check if the entire string matches the following regex
                            # exactly, resulting in 1/0 as truthy/falsey:
 (                          #  Open a capture group
  \.                        #   A dot "."
    (25[0-5]                #   Followed by a number in the range [250,255]
    |(2[0-4]|         ) \d) #   or by a number in the range [200,249]
    |(      |1\d|     ) \d) #   or by a number in the range [100,199]
    |(          |[1-9]) \d) #   or by a number in the range [10,99]
    |(                )?\d) #   or by a number in the range [0,9]
 )                          #  Close capture group
  {4}                       #  This capture group should match 4 times after each other

Jelly, 11 bytes

⁹ḶṾ€ṗ4j€”.ċ

A monadic link accepting a list of characters which yields $1$ if it's a valid address and $0$ otherwise. Builds a list of all $256^4=4294967296$ addresses and then counts the number of occurrences of the input therein.

Here's similar @ Try it online! that uses $16$ (⁴) rather than $256$ (⁹), since the method is so inefficient!

How?

⁹ḶṾ€ṗ4j€”.ċ - Link: list of characters, S
⁹           - literal 256
 Ḷ          - lowered range = [0,1,2,...,254,255]
  Ṿ€        - unevaluate €ach = ['0','1',...,['2','5','4'],['2','5','5']]
    ṗ4      - 4th Cartesian power = ALL 256^4 lists of 4 of them
            -               (e.g.: ['0',['2','5','5'],'9',['1','0']])
        ”.  - literal '.' character
      j€    - join for €ach (e.g. ['0','.','2','5','5','.','9','.','1','0'] = "0.255.9.10")
          ċ - count occurrences of right (S) in left (that big list)

Retina, 42 41 bytes

~(K`

255*
["^(("|'|]")\.?\b){4}$"L$`
$.`

Try it online! Based on a previous version of @nwellnhof's Perl 6 answer, but 1 byte saved by stealing the \.?\b trick from @Deadcode's answer. Explanation:

K`

Clear the work area.

255*

Insert 255 characters.

["^(("|'|]")\.?\b){4}$"L$`
$.`

Generate the range 0..255 separated with |s, prefixed with ^((, and suffixed with )\.?\b){4}$, thus building the regular expression ^((0|1|...255)\.?\b){4}$.

~(

Evaluate that on the original input.

Pip, 25 16 bytes

a~=X,256RL4J"\."

Takes the candidate IP address as a command-line argument. Try it online! or Verify all test cases

Explanation

Regex solution, essentially a port of recursive's Stax answer.

                  a is 1st cmdline arg (implicit)
    ,256          Range(256), i.e. [0 1 2 ... 255]
   X              To regex: creates a regex that matches any item from that list
                  i.e. essentially `(0|1|2|...|255)`
        RL4       Create a list with 4 copies of that regex
           J"\."  Join on this string
 ~=               Regex full-match
a                 against the input

JavaScript, 89 bytes

(_,r=`(${[...Array(256).keys()].join`|`})`)=>RegExp(`^${(r+'\\.').repeat(3)+r}$`).test(_)

Try it online!

Create RegExp capture groups from indexes of an array having length 256 for range 0-255 joined with | and followed by escaped . character (^(0|1...|255)\.(0|1...|255)\.(0|1...|255)\.(0|1...|255)$) repeated 3 times closing with joined array followed by $ to match end of string, return true or false result of input passed to RegExp.prototype.test().