Question

我想做到这一点：

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

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

＆lt;更多事情＆gt;你可以找到结果，例如一些（站点）

但是编译器不接受这个命令，我的意思是“无”，其次是一些条件最终由Some（xxx）完成。如果我在条件之后加上“无”，结果当然总是“无”，并且它不是预期的。

你能告诉我它是否能以这种方式运作，以及如何运作？或者我该怎么办？

@Robin：你看对了：我觉得如果是在java中：结果应该是None或Some（xxx），但令人惊讶的是如果我在块的开头和“None”之后放置“None”条件语句，偶然返回一些（xxx），eclipse的编译器不接受我的代码。所以第一个问题可能是：这个顺序是什么（没有一个条件处理，最后返回一些（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，Some（site）如果一个站点是“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

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

无，有些和有条件的治疗

1 个答案: