Scala中IP地址的验证

我想在scala中验证IP地址。我已经实现了这个方法，但是我看到了一些错误

任何人都可以调查一下，并建议他们是否有更好的解决方案。我并没有试图在功能上实现

 def validIPAddress(IP: String): String = {

       var isValidIP = true
       if(IP.contains(":")) {  
            var numbers= IP.split(":")   //create an array
            if (numbers.length!=8) return "Neither"        
            for (n <- numbers) {
                if(n.length = 0 or n.length > 4) return "Neither"    
                else {
                    for (m <- n) { 
                        if(!m in "0123456789abcdefABCDEF") return "Neither"
                    }
                }
            }
            return "IPv6"
       }
       else if(IP.contains(".") {     //192.168.1.1
              nums = IP.split(".")
              if(nums.length!=4) isValidIP = false  //Array.length
              else {
                for (a <- nums) {
                  println(a)
                  try {
                    var intA = a.toInt
                    if(intA <=0 || IntA > 255) {
                      isValid = false
                    } 

                  } catch (NumberFormatException e)  {
                    case e: Exception => None
                  }
                }

                if(isValid == true) {
                  println("Valid IP")
                } else {
                  println("Invalid IP") 
                }


              }
       } return "IPv4"

       else {
         return "neither"
       }

       }

def validIPAddress（IP:String）：String={
var isValidIP=true
如果（IP.contains（“：”）{
var numbers=IP.split（：“”//创建一个数组
如果（number.length！=8）返回“都不”
对于（n4）返回“均不”
否则{
对于（m您可能不打算实现函数，但在您的示例中根本不需要命令式代码，
return
s和
var
s在读取代码意图时会导致一些严重问题

我会把代码重写成这样

sealed trait IP extends Product with Serializable
object IP {
  final case class V4(a: Int, b: Int, c: Int, d: Int) extends IP
  final case class V6(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int, g: Int, h: Int) extends IP
}

val ipV4 = """(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})""".r
val ipV6 = """([0-9a-fA-F]+):""".r

def validIPAddress(ip: String): Either[String, IP] = {
  def parseV4(s: String) = {
    val i = Integer.parseInt(s)
    if (0 <= i && i <= 255) Right(i) else Left(s"$i is not a valid IPv4 number")
  }
  def parseV6(s: String) = Integer.parseInt(s, 16)

  ip match {
    case ipV4(a, b, c, d) =>
      for {
        a1 <- parseV4(a)
        b1 <- parseV4(b)
        c1 <- parseV4(c)
        d1 <- parseV4(d)
      } yield IP.V4(a1, b1, c1, d1)
    case ipV6(a, b, c, d, e, f, g, h) =>
      // technically speaking this isn't exhausting all possible IPv6 addresses...
      // as this regexp would ignore e.g. ::1 or ::
      Right(IP.V6(parseV6(a), parseV6(b), parseV6(c), parseV6(d), parseV6(e), parseV6(f), parseV6(g), parseV6(h)))
    case _ =>
      Left(s"$ip is neither V4 nor V6 format")
  }
}

它处理了更多正确的情况，但还远远没有准备好。因此，如果可以，请避免自己执行，并使用库。
您可能不打算实现函数，但在您的示例中根本不需要命令式代码，
return
s和
var
s会在读取命令时导致一些严重的问题这是守则的一部分

我会把代码重写成这样

sealed trait IP extends Product with Serializable
object IP {
  final case class V4(a: Int, b: Int, c: Int, d: Int) extends IP
  final case class V6(a: Int, b: Int, c: Int, d: Int, e: Int, f: Int, g: Int, h: Int) extends IP
}

val ipV4 = """(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})""".r
val ipV6 = """([0-9a-fA-F]+):""".r

def validIPAddress(ip: String): Either[String, IP] = {
  def parseV4(s: String) = {
    val i = Integer.parseInt(s)
    if (0 <= i && i <= 255) Right(i) else Left(s"$i is not a valid IPv4 number")
  }
  def parseV6(s: String) = Integer.parseInt(s, 16)

  ip match {
    case ipV4(a, b, c, d) =>
      for {
        a1 <- parseV4(a)
        b1 <- parseV4(b)
        c1 <- parseV4(c)
        d1 <- parseV4(d)
      } yield IP.V4(a1, b1, c1, d1)
    case ipV6(a, b, c, d, e, f, g, h) =>
      // technically speaking this isn't exhausting all possible IPv6 addresses...
      // as this regexp would ignore e.g. ::1 or ::
      Right(IP.V6(parseV6(a), parseV6(b), parseV6(c), parseV6(d), parseV6(e), parseV6(f), parseV6(g), parseV6(h)))
    case _ =>
      Left(s"$ip is neither V4 nor V6 format")
  }
}

它处理了更多正确的案例，但还远远没有准备好。因此，如果可以的话，请避免自己做，使用库。
这是否回答了您的问题？您可以尝试：绝对：regexps、no
var
s、no
return
s，以及一些合理的流控制和错误报告逻辑（括号后的这些
返回值
乍一看几乎肯定是错的）。你已经回答了。如果答案不够好，无法被接受，请解释原因。（就此而言，你的问题都没有一个被接受的答案。如果你不喜欢这里提供的帮助，你为什么总是回来？）这是否回答了您的问题？您可以尝试：当然：regexps、no
var
s、no
return
s，以及一些合理的流控制和错误报告逻辑（括号后的这些
return
s乍一看几乎肯定是错误的）。你有。如果答案不够好，无法被接受，请解释原因。（就此而言，你的问题都没有一个被接受的答案。如果你不喜欢这里提供的帮助，为什么总是回来？）