Scala में java.String.format का उपयोग कैसे करें?

Question

मैं .formatएक स्ट्रिंग की एक विधि का उपयोग करने की कोशिश कर रहा हूं । लेकिन अगर मैं स्ट्रिंग में% 1,% 2 इत्यादि रखता हूं, तो java.util.UnognFormatConversionException एक भ्रमित जावा स्रोत कोड टुकड़े की ओर इशारा करते हुए फेंक दिया जाता है:

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));
    }
}

इससे मैं समझता हूं कि %चारित्र वर्जित है। यदि ऐसा है, तो मुझे तर्क प्लेसहोल्डर्स के लिए क्या उपयोग करना चाहिए?

मैं स्काला 2.8 का उपयोग करता हूं ।

Answer 1

जबकि पिछली सभी प्रतिक्रियाएँ सही हैं, वे सभी जावा में हैं। यहाँ एक स्काला उदाहरण दिया गया है:

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

मेरे पास पाइथन के ऑपरेटर की तरह बनाने केformat% बारे में भी एक ब्लॉग पोस्ट है जो उपयोगी हो सकता है।

Comments

JDK प्रलेखन में बहुत सारे उदाहरण: docs.oracle.com/javase/7/docs/api/java/util/…

— angelcervera

आप formatसीधे स्ट्रिंग शाब्दिक पर आवेदन करके सरल कर सकते हैं :"Hello %s, isn't %s cool?".format("Ivan", "Scala")

— sotrh

Answer 2

आपको स्थिति को इंगित करने के लिए संख्याओं का उपयोग करने की आवश्यकता नहीं है। डिफ़ॉल्ट रूप से, तर्क की स्थिति बस क्रम है जिसमें यह स्ट्रिंग में प्रकट होता है।

यहाँ इसका उपयोग करने के उचित तरीके का एक उदाहरण दिया गया है:

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

आप हमेशा %कुछ अन्य अक्षरों का उपयोग करेंगे ताकि यह पता चले कि विधि को स्ट्रिंग को कैसे प्रदर्शित करना चाहिए। %sशायद सबसे आम है, और इसका मतलब है कि तर्क को एक स्ट्रिंग के रूप में माना जाना चाहिए।

मैं हर विकल्प को सूचीबद्ध नहीं करूंगा, लेकिन मैं आपको एक उदाहरण देने के लिए कुछ उदाहरण दूंगा:

// 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सिर्फ एक का उपयोग करता है java.util.Formatter, इसलिए विकल्पों के पूर्ण विवरण के लिए आप फॉर्मैटर के javadocs देख सकते हैं ।

और, जैसा कि BalusC उल्लेख करता है, आप दस्तावेज़ में देखेंगे कि यदि आवश्यक हो तो डिफ़ॉल्ट तर्क आदेश को बदलना संभव है। हालाँकि, शायद आपको केवल एक ही समय में एक से अधिक बार तर्क का उपयोग करने की आवश्यकता होगी।

Answer 3

स्रोत कोड को देखने के बजाय, आपको javadoc String.format () और फ़ॉर्मेटर सिंटैक्स पढ़ना चाहिए ।

आप% के बाद मूल्य का प्रारूप निर्दिष्ट करते हैं। उदाहरण के लिए दशमलव पूर्णांक यह है d, और स्ट्रिंग के लिए यह है s:

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

आउटपुट:

Hello, world on line 20

क्या आप (एक तर्क इंडेक्स का उपयोग करके) की कोशिश की करने के लिए, आप का उपयोग करें: *n*$,

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

आउटपुट:

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

Answer 4

आप इसका उपयोग कर सकते हैं;

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

आउटपुट:

abbc

Comments

मैंने इस तरह का उपयोग कभी नहीं देखा है, यह बहुत उपयोगी है जब दोहराए जाने वाले स्ट्रिंग, महान!

— डोमी.झेंग

+1 यह अधिक पसंद है जो आप C # डेवलपर के रूप में उपयोग करते हैं। वहां, हम उपयोग करते हैं {0}और {1}इसके बजाय %1$और %2$।

— ashes999

@ ashes999 मैं c # भूमि aswell से हूं। मैं गिने हुए कोष्ठकों का उपयोग कर रहा हूँ, मुझे क्षमा करना होगा कि चीजों को करने का मानक तरीका नहीं था। प्रतिशत के संकेतों को देखकर यह सब वापस लाता है, हालांकि!

— जॉनीराया

Answer 5

यह भी ध्यान दें कि स्काला स्ट्रिंग को कई तरीकों से बढ़ाता है (पूर्वनिर्धारित द्वारा लाए गए WrappedString में अंतर्निहित रूपांतरण के माध्यम से) ताकि आप निम्न कार्य भी कर सकें:

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

Answer 6

आधिकारिक संदर्भ वर्ग है Formatter।

Answer 7

स्कला 2.10 में

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

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

Comments

मैं इसे लेता हूं कि यह केवल स्ट्रिंग संयोजन का एक विशेष वाक्यविन्यास है (जिसका अर्थ है कि $ नाम और $ मौसम पहले परिभाषित चर के कठिन संदर्भ हैं)। String.Format हालांकि टेम्पलेट को एक पैरामीटर के रूप में लेता है और इस प्रकार यह उदाहरण के लिए गुण फ़ाइल और इस तरह से टेम्पलेट को फिर से बनाना संभव बनाता है। - क्या उपरोक्त सिंटैक्स के साथ यह संभव है?

— चिकोडोरो

इसे स्ट्रिंग इंटरपोलेशन कहते हैं, स्केला के भीतर दो प्रकार होते हैं: "" और f "", 's' सरल स्ट्रिंग है और 'f' के समान है printf, आप अपने स्वयं के प्रक्षेप को भी परिभाषित कर सकते हैं (मैंने नहीं किया है) प्रयत्न)। इसका $nameमतलब है कि इसे चर के मूल्य के साथ बदलने की आवश्यकता है name, आप प्रक्षेप में ऑपरेशन भी कर सकते हैं, उदाहरण के लिएs"Hello ${name.toUpperCase}, it's $weather today!"

— लोंडो

Answer 8

यह क्या String.formatकर सकता है की एक सूची है। उसके लिए भी यही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

Answer 9

यहां String.format () के साथ उपयोग किए जाने वाले फ़ॉर्मेटर्स की एक सूची दी गई है

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html

Answer 10

हालांकि @ लोंडो ने स्काला के "एस" स्ट्रिंग प्रक्षेपक का उल्लेख किया है, मुझे लगता है कि स्काला का "एफ" स्ट्रिंग प्रक्षेपक मूल प्रश्न से अधिक प्रासंगिक है। अन्य प्रतिक्रियाओं में कुछ समय के लिए इस्तेमाल किए जाने वाले उदाहरण को भी लिखा जा सकता है (स्केल 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?

मूल प्रश्न का संबंध इस बात से है कि:

• formattedको एक स्ट्रिंग के साथ परिभाषित किया गया है जो "f" अक्षर के साथ उपसर्ग करता है। यह "एफ" (स्वरूपण) स्ट्रिंग इंटरपोलर है।
• "F" स्ट्रिंग इंटरपोलर का उपयोग करता है java.util.Formatter
• java.lang.String.format उसी का उपयोग करता है java.util.Formatter

स्ट्रिंग प्रक्षेप के बारे में अच्छी बात यह है कि यह आपको यह देखने देता है कि किस चर को String.formatविधि के तर्कों के साथ मिलान करने के बजाय सीधे स्ट्रिंग में प्रतिस्थापित किया जा रहा है ।

Answer 11

स्केला में, स्ट्रिंग इंटरपोलेशन के लिए हमारे पास $ है जो दिन बचाता है और हमारे जीवन को बहुत आसान बनाता है:

उदाहरण के लिए: आप एक फ़ंक्शन को परिभाषित करना चाहते हैं जो इनपुट नाम और आयु लेता है और नाम के साथ हैलो कहता है और इसकी आयु कहता है। इस तरह लिखा जा सकता है:

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

इसलिए, जब आप इस फ़ंक्शन को कॉल करते हैं: इस तरह:

funcStringInterpolationDemo("Shivansh",22)

इसका आउटपुट होगा:

Hey ! my name is Shivansh and my age is 22

आप इसे उसी लाइन में बदलने के लिए कोड लिख सकते हैं, जैसे कि आप 10 साल की उम्र में जोड़ना चाहते हैं!

तब कार्य हो सकता है:

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

और अब आउटपुट होगा:

Hey ! my name is Shivansh and my age is 32