네트워크 검색 도구는 입력에 대해 귀찮게 선택하기 때문에 부적절한 문자가 포함되어 있거나 형식이 올바르지 않은 IPv4 주소를 입력하면 즉시 충돌이 발생합니다.

IPv4 주소는 마침표로 구분 된 4 개의 숫자로 작성된 32 비트 숫자 주소 입니다. 각 숫자는 0에서 255까지 가능 합니다.

이러한 충돌을 피하기 위해 입력 을 사전 검증 하는 도구를 작성해야하며 특정 도구는 까다 롭습니다. 유효한 형식은 다음과 같습니다 a.b.c.d. a, b, c 및 d :

• 선행 00 이 없는 자연수이거나 자연수 일 수 있습니다 .
• 0-255 (포함) 사이 여야합니다.
• 해야 하지 같은 특수 기호를 포함 +, -, ,, 등을.
• 십진수 여야합니다 (base 10)

입력 : 문자열

출력 : Truthy 또는 Falsey 값 (임의의 값도 허용됨)

테스트 사례 :

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)

이것은 code-golf 이므로 가장 적은 바이트가 이길 것입니다!

사용자를위한 참고 사항 -테스트 사례를 더 추가하려면 편집 제안을 환영합니다. 그러나 테스트 사례가 반복되지 않도록하십시오! 감사

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. 주소 패밀리 ( AF_INET(ipv4), 2 또는 AF_INET6(ipv6), 10), ip 주소의 문자열 및 출력에 대한 포인터의 세 가지 인수가 필요 합니다. 성공하면 1을, 유효하지 않은 주소는 0을, 또는 주소 패밀리가 둘 중 AF_INET하나 가 아니 거나- AF_INET6상수를 전달하여 발생 하지 않을 경우 -1을 반환합니다 .

따라서 문자열을 두 번째 인수의 레지스터로 옮기고 첫 번째 레지스터를 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함수에 전달 해야하는 경우이 크기를 훨씬 작게 만들 수 있습니다.

자바 (JDK) , 63 바이트

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

온라인으로 사용해보십시오!

크레딧

• Kevin Cruijssen 덕분에 -1 바이트
• 이전에 실패한 사례를 보여주는 l4m2.1.1.1.1 .

자바 스크립트 (Node.js) , 43 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 46 바이트

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

온라인으로 사용해보십시오!

Arnauld의 일부를 사용함

자바 스크립트 (Node.js) , 54 53 51 바이트

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

온라인으로 사용해보십시오!

0+t<256패트릭 스테판 슨 ( Patrick Stephansen)에서 -1B , 입력을 피하기 위해 + 1B1.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_IPV4Benoit Esnard가 지적한 것처럼 PHP가 백그라운드에서 정확히 수행하는 진실 이기 때문에 이것은 충분 합니다.

여기에, filter_var그렇지 않은 경우는 유효한 IPv4 주소, 또는 false의 경우, 첫 번째 인수를 반환합니다. 로 +!!챌린지에 필요한 출력을 생성합니다.

PHP, 36 바이트

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

ip2long잘 알려진 내장 함수 입니다.

펄 6 , 22 21 20 바이트

Phil H 덕분에 -1 바이트

{?/^@(^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

@Emigna 덕분에 -1 바이트 .
버그 수정 테스트 사례의 경우 +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경우 반환objectobjectobject.toString() )
• $false그렇지 않으면 반환

PowerShell, 59 56 54 바이트, '.NET lib를 사용하지 마십시오'대안

-3 바이트 true또는 false작성자가 허용

멋진 regexp를위한 @ Deadcode 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

원래 정규식에 대해 @ Olivier Grégoire 에게 감사드립니다 .

C (gcc) / POSIX, 26 바이트

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

온라인으로 사용해보십시오!

TIO에서는 64 비트 코드로 작동하지만 sizeof(int) == sizeof(char*)다른 플랫폼 에서는 64 비트 코드로 작동해야합니다 .

PHP 7 이상 37 35 32 바이트

이것은 내장 함수를 사용 filter_var하는, 그 IPv4 주소임을 확인 .

작동하려면 iGET 요청을 통해 키를 전달해야합니다 .

<?=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 = 필터 _FLAG_IPV4
• 5 ** 9 = 1953125 (1048576의 경우 필요한 비트가 "1"임)

1 바이트를 절약 한이 팁에 대해 Benoit Esnard 에게 감사합니다 !

도전의 변화를 상기시켜 준 Titus 에게 감사합니다 .

함수 사용을 살펴 보았지만 ip2long완전하지 않은 IP 주소로 작동합니다.

이 과제에서는 완전하지 않은 IPv4 주소가 유효하지 않은 것으로 간주됩니다.

그들이 허용된다면, 이것은 최종 코드가 될 것입니다 (PHP 5.2.10에만 해당) :

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

현재는 최신 PHP 버전에서 불완전한 IP를 통과했을 때 작동이 중지된다는 문서에 명시되어 있지 않습니다.

테스트 후, 그 경우임을 확인했습니다.

팁을위한 nwellnhof 에 감사합니다 !

파이썬 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모듈 대신 list comprehension을 사용하여 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이 언급했듯이 실제로 선행 0에서는 실패합니다. 따라서 61 바이트는 작동하지 않습니다.

파이썬 2 , 85 82 81 바이트

Kevin Cruijssen 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

실패한 113 바이트 응답 이 삭제되었습니다.1.1.1.1e-80

apt, 17 15 바이트

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

시도 해봐 하거나 모든 테스트 사례를 실행 하거나 챌린지 의견에서 추가 테스트 사례를 확인하십시오.

설명

에 배열로 분할하고 해당 배열 .의 길이가 4AND인지 확인하고 범위의 모든 요소 ["0","255"]가 제거 될 때의 길이 가 거짓인지 확인합니다 ( 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

수학, 39 31 바이트

원본 버전 :

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

수정 된 버전 (Misha Lavrov 덕분에)

 AtomQ@*Interpreter["IPAddress"]

True입력이 유효한 IP 주소 인 경우 반환 합니다 ( 시도해보십시오 ).

가져 1오고 0대신 주장 하면 추가 7 바이트가 필요합니다.

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

자바 스크립트 (ES6), 49 바이트

부울 값을 반환합니다.

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

온라인으로 사용해보십시오!

파이썬 2, 93 89 67 53 바이트

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

온라인으로 사용해보십시오!

다른 면 도용 데니스에게 감사내부 비교 및 ​​종료 코드에서 14 바이트 .

22 바이트를 면도하고 로직을 수정 한 Jonathan Allan에게 특별한 감사를드립니다! 성가신 시도 / 제외!

원시 바이트 대신 올바른 형식의 문자열을 사용하면 Jo King 덕분에 4 바이트가 줄어 듭니다.

sfk , 176 바이트

* 원래 Bash + SFK 였지만 TIO는 적절한 SFK 래퍼를 추가했습니다.

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

온라인으로 사용해보십시오!

Python3 배쉬 * 60

* 다른 껍질도 있습니다. 하는 모든 일 truthy / falsy 테스트 프로그램 종료 코드에 전달

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

설명

순수한 파이썬 솔루션의 문제점은 프로그램 충돌이 불확실한 것으로 간주된다는 것입니다. "많은 코드"를 사용하여 예외를 적절한 진실 / 거짓 값으로 변환 할 수 있습니다. 그러나 어느 시점에서 파이썬 인터프리터는이 포착되지 않은 예외를 처리하고 0이 아닌 종료 코드를 리턴합니다. 저렴한 Unix 쉘로 언어를 변경하는 비용을 낮추기 위해, 우리는 상당히 많은 코드를 절약 할 수 있습니다!

물론 이것은 주입 공격에 취약합니다 ... 같은 입력 1.1.1.1'); print('Doing Something Evil은 완화되지 않은 위협입니다!

ECMAScript 순수 정규식, 41 바이트

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

온라인으로 사용해보십시오!
regex101에서 사용해보십시오

나는이 정규 표현식의 논리가 스스로를 말한다고 생각합니다.

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

이것은 다음 다른 답변에서 2 바이트를 면도하는 데 사용할 수 있습니다.

• 올리비에 그레고르 (Java (JDK))
• l4m2 (자바 스크립트 (Node.js))
• 매지 (PowerShell)
• 케빈 크루이 센 (레티 나)

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().