无，一些和有条件的治疗

Question

我想完成这个：

名为 abc 的变量必须为 None，除非复杂处理的结果为真。 我写了一个开头和答案，但它不起作用：

def abc={
None
copie.getRoot().asInstanceOf[DefaultMutableTreeNode].children() foreach ({
    site => <...more things after...>
} 

在 中，您可以找到结果，例如一些（网站）

但是编译器不接受这个命令，我的意思是“无”后跟一些条件最终由 Some(xxx) 完成。如果我在条件后面加上“无”，结果当然总是“无”，这不是预期的。

你能告诉我它是否可以这样工作，以及如何工作？ 否则我该如何继续？

---

@Robin：你没看错：我认为 if 在 java 中：结果应该是 None 或 Some(xxx)，但令人惊讶的是，如果我将“None”放在块的开头并在“None”之后条件语句，它最终返回 Some(xxx)，eclipse 的编译器不接受我的代码。 所以第一个问题可能是：这个顺序（无，然后是一些条件处理最终返回 Some(xxx) 对吗？ 示例：

def abc():Option[DefaultMutableTreeNode]={
    None
    MyTree.getRoot().children() foreach{site=>
        if (site.toBeImported()) Some(site)
            else site.children() foreach {type=>
                if (type.toBeImported()) Some(type)
        }
    }
}  

这里这个函数返回 None，如果一个站点是“toBeImported”（如果有很多，将返回最后一个），或者 Some(type) 如果一个类型是“toBeImported”（最后一个） ）。 这不是我的程序中的内容，但它很好地总结了这个想法。

Answer 1

我不确定这是不是你的意思，但这是我的尝试：

object CondSO extends App {
  def condition(site: String): Boolean = site.contains("flow")

  def complexCalc(db: List[String]) = db.filter(condition)

  // abc is not a variable (as addressed in original Q), but rather a method
  def abc(db: List[String]): Option[String] =
  // orig. Q was a bit confusing what result is - boolean or something else?
  // so, here it's returning a list of results
    complexCalc(db).headOption

  // second version - the "for" approach
  def abc2(db: List[String]): Option[String] = (
    for (site <- db if condition(site)) yield site
    ).headOption

  // third version - using return
  // probably fastest option. IMO other options could be
  // similarly fast if they would be rewritten to use stream
  // (they construct auxiliary list with all matching sites, not only first one)
  def abc3(db: List[String]): Option[String] = {
    for (site <- db if condition(site)) return Some(site)
    None
  }

  // last version - custom foreach
  implicit class IterablePimps[A](val i: Iterable[A]) {
    def foreachWithReturn[B](f: A => Option[B]): Option[B] = {
      while (i.iterator.hasNext)
        f(i.iterator.next()) match {
          case a: Some[B] => return a
          case _ =>
        }
      None
    }
  }

  def abc4(db: List[String]): Option[String] =
    db.foreachWithReturn(s => if (condition(s)) Some(s) else None)

  // testing section
  val dbs = Map[String, List[String]](
    "empty  " -> List(),
    "present" -> List("google.com", "stackoverflow.com"),
    "absent " -> List("root.cz", "abclinuxu.cz")
  )

  val funcs = Map[String, (List[String]) => Option[String]](
    "filter" -> abc,
    "for   " -> abc2,
    "return" -> abc3,
    "pimp  " -> abc4
  )

  for {
    db <- dbs
    f <- funcs
  } println(s"Applying ${f._1} on list ${db._1}: ${f._2(db._2)}")
}

输出：

Applying filter on list empty  : None
Applying for    on list empty  : None
Applying return on list empty  : None
Applying pimp   on list empty  : None
Applying filter on list present: Some(stackoverflow.com)
Applying for    on list present: Some(stackoverflow.com)
Applying return on list present: Some(stackoverflow.com)
Applying pimp   on list present: Some(stackoverflow.com)
Applying filter on list absent : None
Applying for    on list absent : None
Applying return on list absent : None
Applying pimp   on list absent : None

编辑：修改方法以返回一个结果，而不是选项中的列表。添加了更多可能的解决方案（基于提问者的新信息）