scala布尔变量需要动态更改

我有一个方法，我需要根据这些布尔值计算表达式：

var Ma, Co, Ar, Le, St, Ri: Boolean = false
def Logic: Boolean =
  (Ma  &  (!Ma  |  Co)  &  (!Ma  |  Ar)  &  (!Co  |  Ma)  &  
      (!Ar  |  Ma)  &  (!Ar  |  Le  |  St |  Ri))

在

main（）

方法中，我有：

def main(args: Array[String]) {   
  val ls: List[String] = List("Ma", "Co", "Ar")
  //now I need to change the value of Ma, Co and Ar variables to "true"??
}

---

是否有一种通用方法可以帮助将列表中的布尔变量的值更改为

true

。但是，如果在映射中保留名称->值映射，则可以执行以下操作：

val v =  scala.collection.mutable.Map[String, Boolean]("Ma" -> false, "Co"-> false, "Ar" -> false, "Le" -> false, "St" -> false, "Ri" -> false)
    //> v  : scala.collection.mutable.Map[String,Boolean] = Map(Ar -> false, Le -> f
    //| alse, Co -> false, Ma -> false, St -> false, Ri -> false)
def Logic:Boolean = (v("Ma")  &  (!v("Ma")  | v("Co"))  &  (!v("Ma")  |  v("Ar"))  &  (!v("Co")  | v("Ma"))  &
        (!v("Ar")  |  v("Ma"))  &  (!v("Ar")  |  v("Le")  |  v("St") |  v("Ri")))
    //> Logic: => Boolean

val ls: List[String] = List("Ma", "Co", "Ar")     //> ls  : List[String] = List(Ma, Co, Ar)
v("Ma")                                           //> res0: Boolean = false
ls.foreach(v(_) = true)
v("Ma")                                           //> res1: Boolean = true
Logic                                             //> res2: Boolean = false

---

我想，不是没有深思熟虑。但是，如果在映射中保留名称->值映射，则可以执行以下操作：

val v =  scala.collection.mutable.Map[String, Boolean]("Ma" -> false, "Co"-> false, "Ar" -> false, "Le" -> false, "St" -> false, "Ri" -> false)
    //> v  : scala.collection.mutable.Map[String,Boolean] = Map(Ar -> false, Le -> f
    //| alse, Co -> false, Ma -> false, St -> false, Ri -> false)
def Logic:Boolean = (v("Ma")  &  (!v("Ma")  | v("Co"))  &  (!v("Ma")  |  v("Ar"))  &  (!v("Co")  | v("Ma"))  &
        (!v("Ar")  |  v("Ma"))  &  (!v("Ar")  |  v("Le")  |  v("St") |  v("Ri")))
    //> Logic: => Boolean

val ls: List[String] = List("Ma", "Co", "Ar")     //> ls  : List[String] = List(Ma, Co, Ar)
v("Ma")                                           //> res0: Boolean = false
ls.foreach(v(_) = true)
v("Ma")                                           //> res1: Boolean = true
Logic                                             //> res2: Boolean = false

---

其中一种方法是：

def Logic(params:List[String]) = {
 val p = params.map(par => (par, true)).toMap.withDefaultValue(false)
 (
    p("Ma")  &  (
        !p("Ma")  |  p("Co")
    )  &  (
        !p("Ma")  |  p("Ar")
    )  &  (
        !p("Co")  |  p("Ma")
    )  & (
        !p("Ar")  |  p("Ma")
    )  &  (
        !p("Ar")  |  p("Le")  |  p("St") |  p("Ri")
    )
  )
}

scala> Logic(List("Ma","Co","Ar"))
res0: Boolean = false
scala> Logic(List("Ma","Co","Ar","Le"))
res1: Boolean = true

---

其中一种方法是：

def Logic(params:List[String]) = {
 val p = params.map(par => (par, true)).toMap.withDefaultValue(false)
 (
    p("Ma")  &  (
        !p("Ma")  |  p("Co")
    )  &  (
        !p("Ma")  |  p("Ar")
    )  &  (
        !p("Co")  |  p("Ma")
    )  & (
        !p("Ar")  |  p("Ma")
    )  &  (
        !p("Ar")  |  p("Le")  |  p("St") |  p("Ri")
    )
  )
}

scala> Logic(List("Ma","Co","Ar"))
res0: Boolean = false
scala> Logic(List("Ma","Co","Ar","Le"))
res1: Boolean = true

您可以使用，并使用其

ValueSet

来存储真实值，而不是单个

var

s。这允许您通过

String

name引用它们：

对象MyBoolValue扩展枚举{
键入MyBoolValue=Value
val-Ma、Co、Ar、Le、St、Ri=值
}
类MyBoolValueContext{
var trueValues=MyBoolValue.ValueSet.empty
def isTrue（v:MyBoolValue）=trueValues包含v
def apply（v:MyBoolValue）=isTrue（v）
}

那么你可以做：

导入MyBoolValue_
val c=新的MyBoolValueContext
c（硕士）
c、 真值+=Le
c、 真值-=St
定义逻辑：布尔=（c（Ma）&
（！c（Ma）| c（Co））&
（！c（Ma）| c（Ar））&
（！c（Co）| c（Ma））&
（！c（Ar）| c（Ma））&
（！c（Ar）| c（Le）| c（St）| c（Ri）））

您可以使用

with name

来处理

字符串

输入：

c.trueValues++=List（“Ar”、“Le”、“St”）.map（MyBoolValue.withName）

通过使上下文隐式化，您可以获得一点想象力：

隐式case类ResolveMyBoolValue（self:MyBoolValue）扩展了AnyVal{
def get（隐式上下文：MyBoolValueContext）：Boolean=context.isTrue（self）
}
隐式val上下文=新的MyBoolValueContext
val result=Ar.get |！圣吉

或者使用隐式转换，但如果使用不当，可能会造成一些混乱：

隐式定义resolveMyBoolValue（v:MyBoolValue）
（隐式上下文：MyBoolValueContext）={
背景信息（五）
}
val结果：布尔值=Le

您可以使用，并使用其

值集

来存储真实值，而不是单个

var

s。这允许您通过

String

name来引用它们：

对象MyBoolValue扩展枚举{
键入MyBoolValue=Value
val-Ma、Co、Ar、Le、St、Ri=值
}
类MyBoolValueContext{
var trueValues=MyBoolValue.ValueSet.empty
def isTrue（v:MyBoolValue）=trueValues包含v
def apply（v:MyBoolValue）=isTrue（v）
}

那么你可以做：

导入MyBoolValue_
val c=新的MyBoolValueContext
c（硕士）
c、 真值+=Le
c、 真值-=St
def逻辑：布尔=（c（Ma）&
（！c（Ma）| c（Co））&
（！c（Ma）| c（Ar））&
（！c（Co）| c（Ma））&
（！c（Ar）| c（Ma））&
（！c（Ar）| c（Le）| c（St）| c（Ri）））

您可以使用

with name

来处理

字符串

输入：

c.trueValues++=List（“Ar”、“Le”、“St”）.map（MyBoolValue.withName）

通过使上下文隐式化，您可以获得一点想象力：

隐式case类ResolveMyBoolValue（self:MyBoolValue）扩展了AnyVal{
def get（隐式上下文：MyBoolValueContext）：Boolean=context.isTrue（self）
}
隐式val上下文=新的MyBoolValueContext
val result=Ar.get |！圣吉

或者使用隐式转换，但如果使用不当，可能会造成一些混乱：

隐式定义resolveMyBoolValue（v:MyBoolValue）
（隐式上下文：MyBoolValueContext）={
背景信息（五）
}
val结果：布尔值=Le

我已经在使用你的建议，还有@Ashalynd的建议。它们看起来很实用，但我现在必须理解

v（…）

的意思，我不知道什么时候使用它：（v只是一个映射，并持有字符串键和相应的布尔值。

v（foo）

是

v.apply（foo）的缩写）

，并获取字符串foo，查找相应的值，然后返回它@Ashalynd的解决方案扩展了这一思想，使映射的默认值为

false

，因此您只需将特定名称设置为true。虽然很方便，但我不喜欢这样，因为这意味着如果您拼写错误参数名称，当您查看I时，它将返回falset up，这可能很难追踪。在我的版本中，使用未知名称将是一个（运行时）错误。我已经在使用您的建议和@Ashalynd的建议。它们看起来很实用，但我现在必须理解

v（…）

的意思，我不知道何时使用它：（v只是一个映射，并保存字符串键和相应的布尔值。

v（foo）

是

v.apply（foo）的缩写）

，并获取字符串foo，查找相应的值，然后返回它@Ashalynd的解决方案扩展了这一思想，使映射的默认值为

false

，因此您只需将特定名称设置为true。虽然很方便，但我不喜欢这样，因为这意味着如果您拼写错误参数名称，当您查看I时，它将返回falset up，这可能很难追踪。在我的版本中，使用未知名称会是一个（运行时）错误。我个人认为这一个有点过火，但它很整洁，所以无论如何+1。它似乎很接近实现您自己的布尔类型（或“布尔集”类型）我真的很感谢你的回复@Dan Getz…但对我来说，作为Scala的初学者，这是一个“高水平”：）我个人认为这一个有点过火，但它很简洁，所以不管怎样+1。它似乎很接近实现你自己的布尔类型（或“布尔集”类型）非常感谢您的回复@Dan Getz…但对我来说，作为Scala的初学者，这是一种“高水平”：