it-swarm.com.de

Wie verwende ich Java.String.format in Scala?

Ich versuche, eine .format -Methode einer Zeichenfolge zu verwenden. Wenn ich jedoch% 1,% 2 usw. in die Zeichenfolge einfüge, wird Java.util.UnknownFormatConversionException ausgelöst und verweist auf einen verwirrenden Quelltextabschnitt Java:

private void checkText(String s) {

    int idx;

    // If there are any '%' in the given string, we got a bad format
    // specifier.
    if ((idx = s.indexOf('%')) != -1) {
        char c = (idx > s.length() - 2 ? '%' : s.charAt(idx + 1));
        throw new UnknownFormatConversionException(String.valueOf(c));
    }
}

Daraus verstehe ich, dass % char verboten ist. Wenn ja, was soll ich dann für Argumentplatzhalter verwenden?

Ich benutze Scala 2.8.

320
Ivan

Alle vorherigen Antworten sind korrekt, sie sind jedoch alle in Java. Hier ist ein Scala Beispiel:

val placeholder = "Hello %s, isn't %s cool?"
val formatted = placeholder.format("Ivan", "Scala")

Ich habe auch einen Blog-Beitrag über format wie Pythons % -Operator , der nützlich sein könnte.

301
pr1001

Sie müssen keine Zahlen verwenden, um die Positionierung anzugeben. Standardmäßig ist die Position des Arguments einfach die Reihenfolge, in der es in der Zeichenfolge angezeigt wird.

Hier ist ein Beispiel für die richtige Verwendung:

String result = String.format("The format method is %s!", "great");
// result now equals  "The format method is great!".

Sie werden immer einen % gefolgt von einigen anderen Zeichen verwenden, um der Methode mitzuteilen, wie die Zeichenfolge angezeigt werden soll. %s ist wahrscheinlich der häufigste und bedeutet nur, dass das Argument als Zeichenfolge behandelt werden sollte.

Ich werde nicht jede Option auflisten, aber ich werde ein paar Beispiele geben, um Ihnen eine Idee zu geben:

// we can specify the # of decimals we want to show for a floating point:
String result = String.format("10 / 3 = %.2f", 10.0 / 3.0);
// result now equals  "10 / 3 = 3.33"

// we can add commas to long numbers:
result = String.format("Today we processed %,d transactions.", 1000000);
// result now equals  "Today we processed 1,000,000 transactions."

String.format verwendet nur einen Java.util.Formatter. Eine vollständige Beschreibung der Optionen finden Sie in den Formatter-Javadocs .

Und wie BalusC erwähnt, werden Sie in der Dokumentation sehen, dass es möglich ist, die Standardargumentreihenfolge zu ändern, wenn Sie dies benötigen. Dies ist jedoch wahrscheinlich das einzige Mal, wenn Sie dasselbe Argument mehr als einmal verwenden.

298
TM.

Anstatt sich den Quellcode anzusehen, sollten Sie javadoc String.format () und Formatter-Syntax lesen.

Sie geben das Format des Werts nach dem% an. Zum Beispiel für Dezimalzahl ist es d, und für Zeichenfolge ist es s:

String aString = "world";
int aInt = 20;
String.format("Hello, %s on line %d",  aString, aInt );

Ausgabe:

Hello, world on line 20

Um das zu tun, was Sie versucht haben (verwenden Sie einen Argumentindex), verwenden Sie: *n*$,

String.format("Line:%2$d. Value:%1$s. Result: Hello %1$s at line %2$d", aString, aInt );

Ausgabe:

Line:20. Value:world. Result: Hello world at line 20
127
OscarRyz

Sie können dies verwenden;

String.format("%1$s %2$s %2$s %3$s", "a", "b", "c");

Ausgabe:

a b b c

70
Engin Ardıç

Beachten Sie auch, dass Scala String um eine Reihe von Methoden erweitert (durch implizite Konvertierung in einen WrappedString, der von Predef eingeführt wurde), sodass Sie auch Folgendes tun können:

val formattedString = "Hello %s, isn't %s cool?".format("Ivan", "Scala")
13
denis phillips

Die offizielle Referenz ist die Klasse Formatter .

11
Alberto Segura

In Scala 2.10

val name = "Ivan"
val weather = "sunny"

s"Hello $name, it's $weather today!"
10
Londo

Dies ist eine Liste der Möglichkeiten von String.format. Gleiches gilt für printf

int i = 123;
o.printf( "|%d|%d|%n" ,       i, -i );      // |123|-123|
o.printf( "|%5d|%5d|%n" ,     i, -i );      // |  123| –123|
o.printf( "|%-5d|%-5d|%n" ,   i, -i );      // |123  |-123 |
o.printf( "|%+-5d|%+-5d|%n" , i, -i );      // |+123 |-123 |
o.printf( "|%05d|%05d|%n%n",  i, -i );      // |00123|-0123|

o.printf( "|%X|%x|%n", 0xabc, 0xabc );      // |ABC|abc|
o.printf( "|%04x|%#x|%n%n", 0xabc, 0xabc ); // |0abc|0xabc|

double d = 12345.678;
o.printf( "|%f|%f|%n" ,         d, -d );    // |12345,678000|     |-12345,678000|
o.printf( "|%+f|%+f|%n" ,       d, -d );    // |+12345,678000| |-12345,678000|
o.printf( "|% f|% f|%n" ,       d, -d );    // | 12345,678000| |-12345,678000|
o.printf( "|%.2f|%.2f|%n" ,     d, -d );    // |12345,68| |-12345,68|
o.printf( "|%,.2f|%,.2f|%n" ,   d, -d );    // |12.345,68| |-12.345,68|
o.printf( "|%.2f|%(.2f|%n",     d, -d );    // |12345,68| |(12345,68)|
o.printf( "|%10.2f|%10.2f|%n" , d, -d );    // |  12345,68| | –12345,68|
o.printf( "|%010.2f|%010.2f|%n",d, -d );    // |0012345,68| |-012345,68|

String s = "Monsterbacke";
o.printf( "%n|%s|%n", s );                  // |Monsterbacke|
o.printf( "|%S|%n", s );                    // |MONSTERBACKE|
o.printf( "|%20s|%n", s );                  // |        Monsterbacke|
o.printf( "|%-20s|%n", s );                 // |Monsterbacke        |
o.printf( "|%7s|%n", s );                   // |Monsterbacke|
o.printf( "|%.7s|%n", s );                  // |Monster|
o.printf( "|%20.7s|%n", s );                // |             Monster|

Date t = new Date();
o.printf( "%tT%n", t );                     // 11:01:39
o.printf( "%tD%n", t );                     // 04/18/08
o.printf( "%1$te. %1$tb%n", t );            // 18. Apr
3
PRO_gramista

Hier ist eine Liste der mit String.format () verwendeten Formatierer.

http://docs.Oracle.com/javase/1.5.0/docs/api/Java/util/Formatter.html

2
NixRam

Obwohl @Londo den String-Interpolator von Scala erwähnt hat, denke ich, dass Scalas "f" -String-Interpolator für die ursprüngliche Frage relevanter ist. Das Beispiel, das ein paar Mal in anderen Antworten verwendet wurde, könnte auch folgendermaßen geschrieben werden (seit Scala 2.10):

scala> val name = "Ivan"
name: String = Ivan
scala> val thing = "Scala"
thing: String = Scala
scala> val formatted = f"Hello $name%s, isn't $thing%s cool?"
formatted: String = Hello Ivan, isn't Scala cool?

Der Zusammenhang mit der ursprünglichen Frage ist zu beachten, dass:

  • formatted wird mit einem String definiert, dem der Buchstabe "f" vorangestellt ist. Dies ist der String-Interpolator "f" (Formatierung).
  • Der String-Interpolator "f" verwendet Java.util.Formatter
  • Java.lang.String.format verwendet denselben Java.util.Formatter

Das Schöne an der String-Interpolation ist, dass Sie sehen können, welche Variable direkt in den String eingesetzt wird, anstatt sie mit den Argumenten der String.format -Methode abgleichen zu müssen.

1
Reid Spencer

In scala haben wir für die String-Interpolation $, das spart den Tag und macht unser Leben viel einfacher:

Zum Beispiel: Sie möchten eine Funktion definieren, die den eingegebenen Namen und das Alter verwendet und Hallo sagt. Mit dem Namen und dem Alter. Das kann so geschrieben werden:

def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is $age"

Daher, wenn Sie diese Funktion aufrufen: wie folgt:

funcStringInterpolationDemo("Shivansh",22)

Seine Ausgabe wäre:

Hey ! my name is Shivansh and my age is 22

Sie können den Code schreiben, um ihn in der gleichen Zeile zu ändern, zum Beispiel, wenn Sie das Alter um 10 Jahre erhöhen möchten!

dann könnte die Funktion sein:

def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is ${age+10}"

Und jetzt wäre die Ausgabe:

Hey ! my name is Shivansh and my age is 32
0
Shiv4nsh