Casting-String zu Int mit scala-Abzieher

Ich versuche zu werfen String zu Int mit Abzieher. Mein code sieht wie folgt aus.

object Apply {
  def unapply(s: String): Option[Int] = try {
    Some(s.toInt)
  } catch {
    case _: java.lang.Exception => None
  }
}

object App {
  def toT[T](s: AnyRef): Option[T] = s match {
    case v: T => Some(v)
    case _ => None
  }
  def foo(param: String): Int = {
    //reads a Map[String,String] m at runtime
    toT[Int](m("offset")).getOrElse(0)
  }
}

Bekomme ich ein runtime error: java.lang.String cannot be cast to java.lang.Integer. Es scheint, die Dunstabzugshaube ist nicht überhaupt verwendet. Was soll ich tun?

Edit: Mein Anwendungsfall ist wie folgt. Ich bin mit spielen, und ich will der parse den query-string an die url übergeben. Ich möchte die query-string-Wert (Zeichenfolge) und verwenden Sie es als ein Int, Double etc. Zum Beispiel,

val offset = getQueryStringAs[Int]("offset").getOrElse(0)

Warum erwarten Sie es verwendet werden?
Sie hat die Frage mit "implizite Konvertierung", es gibt keine implizite Konvertierung gehen auf Ihrem code.
toT[T] ... case v:T funktioniert nicht, T ist verloren, in die Löschung.
Es ist grundsätzlich unmöglich, cast ein String zu einer anderen Art (außer für AnyRef oder Any).
Oh, ich habe versucht, eine implizite def aber das hat nicht funktioniert.
Ich habe meine use-case.
Wenn Sie spielen 2.1.0 (mit scala 2.10) können Sie festlegen, "extension" Methoden" auf String: implicit class StringConversionOps(val str: String) extends AnyVal { def parseInt = try { Some(str.toInt) } catch { case _ => None } }. Können Sie Methoden hinzufügen, dass die Klasse als notwendig. Dann, vorausgesetzt es ist in Reichweite können Sie tun m("offset").parseInt.getOrElse(0).

InformationsquelleAutor vikraman | 2013-02-09

4

Ich denke, das größte problem hier ist, dass Sie scheinen zu verwechseln, casting und Konvertierung. Sie haben eine Map[String, String] und daher Sie kann nicht wirken, die Werte zu Int. Sie haben zu konvertieren. Zum Glück Scala fügt die toInt - Methode, um Zeichenfolgen durch implizite Konvertierung zu StringOps.

Sollte diese Arbeit für Sie:
```
m("offset").toInt
```
Beachten Sie, dass toInt werfen wird java.lang.NumberFormatException wenn die Zeichenfolge kann nicht konvertiert werden zu einem integer.

Bearbeiten:

Was Sie wollen, werden afaik nur die Arbeit mit typeclasses.

Hier ist ein Beispiel:
```
trait StringConverter[A] {
  def convert(x: String): A
}

implicit object StringToInt extends StringConverter[Int] {
  def convert(x: String): Int = x.toInt
}

implicit object StringToDouble extends StringConverter[Double] {
  def convert(x: String): Double = x.toDouble
}

implicit def string2StringConversion(x: String) = new {
  def toT[A](implicit ev: StringConverter[A]) = ev.convert(x)
}
```
Verwendung:
```
scala> "0.".toT[Double]
res6: Double = 0.0
```
- Das ist in Ordnung, aber was ich will ist ein toT - [T] - Methode, die funktioniert allgemein.
- meinen Beitrag aktualisiert
- Ok danke, das ist der einzige Weg, wie es getan werden könnte? Warum sollte es nicht eine Art Spiel arbeiten?
- Weil 1) deine Werte sind vom Typ string und 2) T gelöscht wird und nicht zur Laufzeit verfügbar (dies kann tatsächlich behoben werden mit Manifest/TypeTag, aber noch immer haben Sie Zeichenfolgen, die Sie haben zu konvertieren).
- Ok, ich werde es verwenden typeclasses dann, mit Option auf[Ein] Rückgabetyp für konvertieren
- Warum ist das passiert? scala> "0"ein.toT[Int] res1: Option[Int] = Some(0) scala> def foo[T](s: String): Option[T] = s an.toT[T] <Konsole>:10: error: could not find implicit value for parameter ev: StringConverter[T] def foo[T](s: String): Option[T] = s an.toT [- T -] ^
- Um zu klären, was ich tun kann "0"sein.toT[Int] aber, ich kann nicht erstellen Sie eine Funktion foo[A], die fordert, toT[A] und foo[Int] heißt woanders
- Weil es keine Instanz für StringConverter[T]. Versuchen def foo[A : StringConverter] ist, so nennt man eine Art gebunden und fügt einen impliziten Parameter vom Typ StringConverter[A] zu deiner Methode, die dann für den Aufruf toT[A].
InformationsquelleAutor drexin

Gibt es ein problem in Ihrem code, für die Sie erhalten haben sollten compiler-Warnungen:

def toT[T](s: AnyRef): Option[T] = s match {
  case v: T => Some(v) //this doesn't work, because T is erased
  case _ => None
}

Nun... wo soll Apply verwendet wurden? Ich sehe es erklärt, aber ich sehe es nicht überall eingesetzt.

BEARBEITEN

Über die Warnung, Blick auf die Diskussionen rund um type erasure auf Stack Overflow. Zum Beispiel, diese Antwort schrieb ich auf, wie man sich es-obwohl es jetzt veraltet Scala 2.10.0.

Um Ihr problem zu lösen würde ich die Verwendung von type-classes. Zum Beispiel:

abstract class Converter[T] {
  def convert(s: String): T
}

object Converter {
  def toConverter[T](converter: String => T): Converter[T] = new Converter[T] {
    override def convert(s: String): T = converter(s)
  }

  implicit val intConverter = toConverter(_.toInt)
  implicit val doubleConverter = toConverter(_.toDouble)
}

Dann Sie können schreiben Sie Ihre Methode so:

val map = Map("offset" -> "10", "price" -> "9.99")

def getQueryStringAs[T : Converter](key: String): Option[T] = {
  val converter = implicitly[Converter[T]]
  try {
    Some(converter convert map(key))
  } catch {
    case ex: Exception => None
  }
}

Im Einsatz:

scala> getQueryStringAs[Int]("offset")
res1: Option[Int] = Some(10)

scala> getQueryStringAs[Double]("price")
res2: Option[Double] = Some(9.99)

Einfach gesagt 😛
Ich habe diese Warnung ignoriert es sowieso. Also, wie soll ich es tun? Im Idealfall sollte ich in der Lage zu rufen, toT[Int], toT[Double] etc, und Sie sollten die entsprechenden änderungen zurücknehmen.

InformationsquelleAutor Daniel C. Sobral

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.