Question

玩一点Scala，似乎你无法从函数中提前返回。

我发现平坦的未缩进代码，易于遵循早期退货。我最初的尝试创建了一个大的嵌套结构。叫我挑剔，但我不喜欢看到以下内容：

    }
  }
}

在Scala中编写以下方法的最佳方法是什么？

是否有可能以这种方式编程以减少嵌套，或者我是否会全面反对Scala的功能设计理念？

@Nullable
public static <T extends PsiElement> T getParentOfType(@Nullable PsiElement element,
                                                       @NotNull Class<T> aClass,
                                                       boolean strict,
                                                       @NotNull Class<? extends PsiElement>... stopAt) {
  if (element == null) return null;
  if (strict) {
    element = element.getParent();
  }

  while (element != null && !aClass.isInstance(element)) {
    if (instanceOf(element, stopAt)) return null;
    if (element instanceof PsiFile) return null;
    element = element.getParent();
  }

  //noinspection unchecked
  return (T)element;
}

我的尝试：

def getParentOfType[T](element: PsiElement, aClass: Class, strict: Boolean): T[_ <: PsiElement] = {
  element match {
    case null => null
    case _ => {
      var el = if (strict) {
        element.getParent
      } else element
      while(el != null) {
        if (aClass isInstance el) {
          return el
        }
        if (el.isInstanceOf[PsiFile]) return null;
        el = el.getParent()
      }
    }
  }
}

此外，Scala世界中适当的论坛是什么问“在Scala中编写Java方法X的最佳方法是什么？”。我发现自己经常提出这个问题。

Answer 1

def getParentOfType[T](element: PsiElement, aClass: Class, strict: Boolean):
    T[_ <: PsiElement] = element match {
  case null => null
  case el if strict => getParentOfType(el.getParent, aClass, false)
  case el if aClass isInstance el => el
  case el if el.isInstanceOf[PsiFile] => null
  case el => getParentOfType(el.getParent, aClass, false)
}

（或类似）

Answer 2

使用null的scala很难。并且您无法使用while获得惯用的scala代码。

您有@Nullable和@NotNull - 在scala中Option[T]和T。您可以使用递归方法替换while。

例如，这是我尝试将您的方法转换为scala（未经测试）：

getParentOfType[T <: PsiElement](element: Option[PsiElement],
                                 aClass: Class[T],
                                 strict: Boolean,
                                 stopAt: Class[_ <: PsiElement]*): Option[T] = element flatMap { el =>
  @tailrec def loop(element: PsiElement): Option[PsiElement] {
    if (element == null || aClass.isInstance(element))
      Option(element)
    else if (instanceOf(element, stopAt) || element.isInstanceOf[PsiFile])
      None
    else
      loop(element.getParent())
  }

  loop(if (strict) el.getParent() else el).map{_.asInstanceOf[T]}
}

Answer 3

这是对问题的不同看法;可能不是我在这个特殊情况下使用的东西，但值得了解。

def getParentOfType[A >: Null <: PsiElement](
  element: PsiElement, aClass: Class[A],
  strict: Boolean, stopAt: Class[_ <: PsiElement]*
): A =
  Iterator.iterate(element)(_.getParent).
  takeWhile(_ != null).
  drop(if (strict) 1 else 0).
  takeWhile(e => !instanceOf(e, stopAt) && !e.isInstanceOf[PsiFile]).
  collectFirst{ case x if aClass isInstance x => x.asInstanceOf[A] }.
  orNull

在这里，您首先定义元素的父元素流，如果它为null则终止。如果您的严格标志为真，则删除第一个;如果您在stopAt或PsiFile中点击某些内容，也会停止搜索。在这些约束中，你得到（并转换）匹配的第一个东西，然后你返回那个，如果没有得到任何东西，则返回null。

通过一些练习，它实际上可以更容易遵循这种逻辑而不是循环，因为终止条件在循环中比这里更隐含。在这里，当您停止搜索（takeWhile）以及您追求的内容（collectFirst）时，您只需说清楚。

注意：我假设instanceOf被定义为

def instanceOf(a: AnyRef, cs: Seq[Class[_]]) = cs.exists(_ isInstance a)

如何在Scala中编写此方法，或者处理早期返回的最佳方法是什么

3 个答案: