web-dev-qa-db-fra.com

Comment utiliser Java.String.format dans Scala?

J'essaie d'utiliser une méthode .format d'une chaîne. Mais si je place% 1,% 2, etc. dans la chaîne, une exception Java.util.UnknownFormatConversionException est renvoyée et pointe vers un élément source de confusion source 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));
    }
}

De là, je comprends que % car est interdit. Si oui, alors que devrais-je utiliser pour les espaces réservés d'arguments?

J'utilise Scala 2.8.

javastringscalaformat
320
Ivan

Bien que toutes les réponses précédentes soient correctes, elles sont toutes en Java. Voici un exemple Scala:

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

J'ai aussi un article de blog sur rendant format comme l'opérateur % de Python qui pourrait être utile.

301
pr1001

Vous n'avez pas besoin d'utiliser des chiffres pour indiquer le positionnement. Par défaut, la position de l'argument est simplement l'ordre dans lequel il apparaît dans la chaîne.

Voici un exemple d'utilisation appropriée:

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

Vous utiliserez toujours un % suivi de quelques autres caractères pour indiquer à la méthode comment afficher la chaîne. %s est probablement le plus commun, et cela signifie simplement que l'argument doit être traité comme une chaîne.

Je ne vais pas énumérer toutes les options, mais je donnerai quelques exemples simplement pour vous donner une idée:

// 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 utilise simplement un Java.util.Formatter, donc pour une description complète des options, vous pouvez voir le Formatter javadocs .

Et, comme BalusC le mentionne, vous verrez dans la documentation qu'il est possible de modifier l'ordre des arguments par défaut si vous en avez besoin. Cependant, la seule fois où vous auriez besoin de/voudriez faire cela, c'est si vous utilisez le même argument plusieurs fois.

298
TM.

Au lieu de regarder le code source, vous devriez lire le javadoc String.format () et syntaxe de Formatter .

Vous spécifiez le format de la valeur après le%. Par exemple, pour l'entier décimal, il s'agit de d, et pour String, de s:

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

Sortie:

Hello, world on line 20

Pour faire ce que vous avez essayé (utilisez un argument index), vous utilisez: *n*$,

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

Sortie:

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

Vous pouvez utiliser ceci;

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

Sortie:

a b b c

70
Engin Ardıç

Notez également que Scala rallonge String avec un certain nombre de méthodes (par conversion implicite en un WrappedString importé par Predef) afin que vous puissiez également effectuer les opérations suivantes:

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

La référence officielle est la classe Formatter .

11
Alberto Segura

Dans Scala 2.10

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

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

Voici une liste de ce que String.format peut faire. Il en va de même pour 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

Voici une liste des formateurs utilisés avec String.format ()

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

2
NixRam

Bien que @Londo ait mentionné l'interpolateur de chaîne "s" de Scala, je pense que l'interpolateur de chaîne "f" est plus pertinent pour la question initiale. L'exemple utilisé quelques fois dans d'autres réponses pourrait également être écrit (depuis Scala 2.10) de cette façon:

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?

Le lien avec la question initiale est de savoir que:

  • formatted est défini avec une chaîne préfixée par la lettre "f". C'est l'interpolateur de chaîne "f" (formatage).
  • L'interpolateur de chaîne "f" utilise Java.util.Formatter
  • Java.lang.String.format utilise le même Java.util.Formatter

Ce qui est bien avec l’interpolation de chaîne, c’est qu’elle vous permet de voir quelle variable est substituée directement dans la chaîne au lieu de la faire correspondre aux arguments de la méthode String.format.

1
Reid Spencer

Dans scala, pour l'interpolation de chaîne, nous avons $, qui sauve la journée et rend notre vie beaucoup plus facile:

Par exemple: Vous voulez définir une fonction qui prend le nom d'entrée et l'âge et dit Bonjour avec le nom et dit son âge. Cela peut être écrit comme ceci:

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

Par conséquent, lorsque vous appelez cette fonction: comme ceci:

funcStringInterpolationDemo("Shivansh",22)

Sa sortie serait:

Hey ! my name is Shivansh and my age is 22

Vous pouvez écrire le code pour le changer dans la même ligne, comme si vous vouliez ajouter 10 ans à l'âge!

alors la fonction pourrait être:

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

Et maintenant, le résultat serait:

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