Inkrement ( ++ ) - operator in Scala

Gibt es einen Grund für Scala nicht die Unterstützung der ++ - operator inkrementiert werden primitive Typen standardmäßig?
Zum Beispiel, Sie können nicht schreiben:

var i=0
i++

Dank

  • einfach nur neugierig, können Sie die Ausgabe i += 1 in der Scala?
  • Ja, Sie können, aber nur wenn es ein var und nicht ein val. Wenn der Scala-compiler findet eine Methode Endung = aufgerufen var und die Klasse nicht haben, dass Methode (variable method= arg), weitet es auf variable = variable.method(arg).
  • Hier ist der original text von <Programmierung in scala 3.> 2016 : Note that Java's ++i and i++ don't work in Scala. To increment in Scala, you need to say either i = i + 1 or i += 1
InformationsquelleAutor adelarsq | 2010-10-21
  1. 34

    Meine Vermutung ist, dass diese weggelassen wurde, weil es würde nur Arbeit für die veränderlichen Variablen, und es würde keinen Sinn machen, für unveränderliche Werte. Vielleicht war es beschlossen, dass die ++ Betreiber nicht Schreien Zuordnung, so kann es zu Fehlern führen, die mit Bezug auf ob oder nicht Sie sind mutiert die variable.

    Ich das Gefühl, dass so etwas sicher zu machen (auf einer Linie):

    i++

    aber das wäre eine schlechte Praxis (in jeder Sprache):

    var x = i++

    Sie wollen nicht zu mischen, Zuweisungsanweisungen und Nebenwirkungen/mutation.

    • Ich denke, du bist nicht ein großer fan von C/C++, dann. Alle Arten von *(a++) = ++*(b++) Sachen gibt es....
    • Sie Ahnen richtig 🙂
    • Kerr : jetzt fühle ich mich gut, dass meine erste Programmiersprache war Java 🙂
    • Ich bin ein C++ lead-Entwickler: Es gibt keine von Unsinn in meinem codebase, wenn ich helfen kann.
    InformationsquelleAutor pkaeding
  2. 33

    Ich mag Craig's Antwort, aber ich denke, der Punkt muss sein, stärker aus.

    1. Gibt es keine "primitiven" -- wenn Int es tun können, dann kann so ein Benutzer-made Complex (zum Beispiel).

    2. Grundsätzliche Verwendung von ++ würde wie folgt Aussehen:

      var x = 1 //or Complex(1, 0)

      x++

    3. Wie setzen Sie ++ in der Klasse Complex? Unter der Annahme, dass, wie Int, das Objekt unveränderlich ist, dann ist die ++ Methode zurückgeben muss, ein neue - Objekt, aber das neue Objekt zugeordnet.

    Wäre es erforderlich, eine neue Sprache-Funktion. Zum Beispiel, sagen wir, wir erstellen eine assign Schlüsselwort. Der Typ Signatur benötigen würde, um geändert werden, als auch, um zu zeigen, dass ++ ist nicht Rückkehr eine Complex, aber zuweisen es zu was auch immer Bereich hält das gegenwärtige Objekt. In Scala Geist nicht eindringen in die Programmierer-namespace, lassen Sie uns sagen, wir tun das, indem die Art, mit @.

    Dann könnte es so sein:

    case class Complex(real: Double = 0, imaginary: Double = 0) {
  def ++: @Complex = {
    assign copy(real = real + 1)
    //instead of return copy(real = real + 1)
}

    Das nächste problem ist, dass postfix-Operatoren saugen mit Scala Regeln. Zum Beispiel:

    def inc(x: Int) = {
  x++
  x
}

    Weil der Scala-Regeln, das ist das gleiche wie:

    def inc(x: Int) = { x ++ x }

    War ja nicht die Absicht. Nun, Scala Privilegien eine fließende Stil: obj method param method param method param .... Dass mischt sich gut mit C++/Java traditionellen syntax object method parameter mit funktionalen Programmierung Konzept des pipelining eine Eingabe, über mehrere Funktionen, um die end-Ergebnis. Dieser Stil wurde vor kurzem als "fluent interfaces" als gut.

    Das problem ist, dass durch die Privilegierung, dass der Stil, der Krüppel postfix-Operatoren (und Präfix, aber Scala kaum hat Sie sowieso). Also, am Ende, Scala hätte um große Veränderungen, und es wäre in der Lage zu Messen, um die Eleganz von C/Java Inkrement-und Dekrement-Operatoren sowieso-es sei denn, es ist wirklich wich von der Art der Sache, die es hat unterstützen.

    • Nette Antwort Daniel, danke.
    InformationsquelleAutor Daniel C. Sobral
  3. 19

    In der Scala ++ ist eine gültige Methode und keine Methode impliziert die Zuordnung. Nur = tun kann.

    Längere Antwort ist, dass Programmiersprachen wie C++ und Java behandeln ++ speziell und Scala behandelt = speziell, und in einem inkonsistenten Weise.

    In der Scala, wenn Sie schreiben i += 1 der compiler sucht zunächst nach einer Methode namens += auf der Int. Es gibt ' s nicht so weiter, es funktioniert es ist Magie auf = und versucht zu kompilieren der Linie, als wenn es Lesen i = i + 1. Wenn Sie schreiben i++ dann Scala wird die Methode aufrufen ++ auf i und weisen Sie das Ergebnis... nichts. Denn nur = bedeutet Zuordnung. Sie schreiben konnte i ++= 1 aber diese Art von Niederlagen der Zweck.

    Die Tatsache, dass Scala unterstützt die Methode Namen wie += ist bereits umstritten, und einige Leute denken, es ist operator zu überladen. Sie könnte Hinzugefügt haben spezielle Verhalten für ++ aber dann wäre es nicht mehr eine gültige Methode name (wie =) und es wäre ein mehr Ding sich zu erinnern.

    InformationsquelleAutor Craig P. Motlin
  4. 12

    Denke ich, die Argumentation in Teil, ist, dass +=1 ist nur ein weiterer Charakter, und ++ verwendet wird, ziemlich stark in den Sammlungen code für die Verkettung. Also es hält den code sauberer.

    Auch, Scala unveränderbare Variablen und ++ ist in Wirklichkeit eine mutierend Betrieb. Wenn Sie benötigen += zumindest können Sie erzwingen, dass alle Ihre Mutationen zu gehen, durch eine gemeinsame Vergabe Verfahren (z.B. def a_=).

    • Ich Stimme zu - Sie brauchen nicht zu verwenden ++. Ich habe gerade entdeckt, nach 1,5 Jahren Erfahrung, dass dieser operator nicht zur Verfügung und es war nur, weil ich versucht hatte, Sie zu verschleiern, etwas auf die Nerven, meine peer.
    InformationsquelleAutor Rex Kerr
  5. 2

    Natürlich können Sie, dass in der Scala, wenn Sie wirklich wollen:

    import scalaz._
import Scalaz._

case class IncLens[S,N](lens: Lens[S,N], num : Numeric[N]) { 
  def ++ = lens.mods(num.plus(_, num.one))
}

implicit def incLens[S,N:Numeric](lens: Lens[S,N]) =
  IncLens[S,N](lens, implicitly[Numeric[N]])

val i = Lens[Int,Int](identity, (x, y) => y)

val imperativeProgram = for {
  _ <- i := 0;
  _ <- i++;
  _ <- i++;
  x <- i++
} yield x

def runProgram = imperativeProgram ! 0

    Und hier gehen Sie:

    scala> runProgram
runProgram: Int = 3
    • Vorsicht: wenn Sie zu beeindrucken, C-oder Java-Programmierer, Sie müssen versuchen, härter. In dieser Sequenz x Wert soll 2 sein, nicht 3, wie postfix ++ ist post-Inkrement. Die Herausforderung, um zu beeindrucken das Publikum ist: können Sie implementieren sowohl Präfix-und postfix-Formen verhält sich wie erwartet auf veränderlichen Numerik? 😉
    InformationsquelleAutor Apocalisp
  6. 2

    Der primäre Grund ist, dass es nicht die Notwendigkeit, in Scala, wie in C. in C sind Sie ständig:

    for(i = 0, i < 10; i++)
{
  //Do stuff
}

    C++ Hinzugefügt hat, die höhere Ebene, Methoden zur Vermeidung von für die explizite Schleifen, aber Scala hat viel weiter gegangen Bereitstellung von foreach, map, flatMap foldLeft etc. Auch wenn Sie eigentlich bedienen wollen, sich auf eine Sequenz von ganzen zahlen, anstatt einfach nur Radfahren obwohl eine Sammlung von nicht-integer-Objekten, die Sie verwenden können, Scala-Bereich.

    (1 to 5) map (_ * 3) //Vector(3, 6, 9, 12, 15)
(1 to 10 by 3) map (_ + 5)//Vector(6, 9, 12, 15)

    Da der ++ - operator wird verwendet, durch die Sammlung der Bibliothek, ich fühle es besser, vermeiden Sie den Einsatz in nicht-collection-Klassen. Ich verwendet, um zu verwenden ++ als Wert zurückgeben Methode in meinem Util-Paket-Paket-Objekt etwa so: 

    implicit class RichInt2(n: Int)
{      
  def isOdd: Boolean = if (n % 2 == 1) true else false
  def isEven: Boolean = if (n % 2 == 0) true else false
  def ++ : Int = n + 1
  def -- : Int = n - 1     
}

    Aber ich entfernt es. Die meisten der Zeit, wenn ich verwendet, ++ oder + 1 auf eine ganze Zahl, habe ich später einen besseren Weg gefunden, die doesn ' T erfordern es.

    InformationsquelleAutor Rich Oliver
  7. 2

    Es ist möglich, wenn Sie definieren Sie eine eigene Klasse, die simulieren können Sie die gewünschte Ausgabe-aber es kann ein Schmerz, wenn Sie möchten, verwenden Sie den normalen "Int" - Methoden so gut, da müsste man immer verwenden *()

    import scala.language.postfixOps //otherwise it will throw warning when trying to do num++

/*
 * my custom int class which can do ++ and --
 */
class int(value: Int) {

  var mValue = value

  //Post-increment
  def ++(): int = {

    val toReturn = new int(mValue)
    mValue += 1
    return toReturn 
  }

  //Post-decrement
  def --(): int = {

    val toReturn = new int(mValue)
    mValue -= 1
    return toReturn 
  }

  //a readable toString
  override def toString(): String = {
      return mValue.toString
  }
}

//Pre-increment
def ++(n: int): int = {
  n.mValue += 1
  return n;
}

//Pre-decrement
def --(n: int): int = {
  n.mValue -= 1
  return n;
}

//Something to get normal Int
def *(n: int): Int = {
  return n.mValue
}

    Einige mögliche Testfälle

    scala>var num = new int(4)
num: int = 4

scala>num++
res0: int = 4

scala>num
res1: int = 5 //it works although scala always makes new resources

scala>++(num) //parentheses are required
res2: int = 6

scala>num
res3: int = 6

scala>++(num)++ //complex function
res4: int = 7

scala>num
res5: int = 8

scala>*(num) + *(num) //testing operator_*
res6: Int = 16
    InformationsquelleAutor Dev_anon101
  8. 0

    Können definieren var: 

    var i = 0

    ++i ist schon kurz genug: 

    {i+=1;i}

    Nun i++ kann wie folgt Aussehen: 

    i(i+=1)

    Verwenden oben genannten syntax definieren, irgendwo in einem package-Objekt und dann importieren: 

    class IntPostOp(val i: Int) { def apply(op: Unit) = { op; i } } 
implicit def int2IntPostOp(i: Int): IntPostOp = new IntPostOp(i)

    Operatoren Verkettung ist auch möglich:

    i(i+=1)(i%=array.size)(i&=3)

    Obigen Beispiel ist ähnlich wie diese mit Java (C++?) code: 

    i=(i=i++ %array.length)&3;

    Stil verlassen konnte, natürlich.

    • Dies beantwortet nicht die Frage, noch bietet es einen guten Stil zu verwenden Scala. Bitte erwähnen Sie dies in Ihrer Antwort.
    • Operator-chaining scheint eine schöne Anwendung einer Scala Weg, denke ich. Wenn Sie eine genauere Angabe eine mögliche Falle ist, werde ich gerne aktualisieren meine Antwort.
    InformationsquelleAutor idonnie
  9. -1

    Nicht enthalten ist, weil Scala Entwickler Gedanken machen, die Spezifikation komplexer, während das erreichen nur äußerst geringe Vorteile und weil Scala keine Operatoren an allen.

    Könnten Sie schreiben Ihre eigenen einer wie dieser:

    class PlusPlusInt(i: Int){
  def ++ = i+1
  }

implicit def int2PlusPlusInt(i: Int) = new PlusPlusInt(i)

val a = 5++
//a is 6

    Aber ich bin sicher, Sie werden in ein paar Probleme mit der Rangfolge nicht so funktioniert, wie Sie erwarten. Außerdem, wenn ich++ aufgestockt würde, würden die Leute Fragen, für ++auch ich, die nicht wirklich fit in Scala syntax.

    • Ich nehme an, man könnte hinzufügen, ein ++: Methode zur Unterstützung der Präfix-Operatoren, wie val a = ++:5. Aber ich denke, dass sieht ein wenig seltsam.
    • Schlechte Idee. Das funktioniert so nicht der übliche Weg, dass i++ funktionieren soll--i++ soll äquivalent sein zu { val temp = i; i += 1; temp }.
    • Ich sage nicht, es war eine gute Idee! Meiner bescheidenen Meinung nach die design-Sprache von Scala ist ziemlich perfekt (****-ups wie die automatische Umwandlung von fester-zahlen floating point zahlen ausgeschlossen) und in der Praxis mit += ist sehr viel besser lesbar.
    • Kerr: Aber das ist nur ein kleines problem. Die Hauptsache ist, man kann nicht var a = 5; a++; assert(a == 6) weil a sich eigentlich nicht ändern.
    • Ich dachte, meine Antwort, dass abgedeckt. Ich denke, es war zu undurchsichtig, denn es gab mehr als eine Sache falsch.
    InformationsquelleAutor soc
Schreibe einen Kommentar