Java Language
कमांड लाइन तर्क प्रसंस्करण

वाक्य - विन्यास

• सार्वजनिक स्थैतिक शून्य main (String [] args)

पैरामीटर

टिप्पणियों

GWT टूलबेस का उपयोग करते हुए तर्क प्रसंस्करण

यदि आप अधिक जटिल कमांड-लाइन तर्कों को पार्स करना चाहते हैं, जैसे कि वैकल्पिक मापदंडों के साथ, तो Google के GWT दृष्टिकोण का उपयोग करना सबसे अच्छा है। सभी कक्षाएं सार्वजनिक रूप से उपलब्ध हैं:

https://gwt.googlesource.com/gwt/+/2.8.0-beta1/dev/core/src/com/google/gwt/util/tools/ToolBase.java

कमांड-लाइन myprogram -dir "~/Documents" -port 8888 को संभालने के लिए एक उदाहरण है:

public class MyProgramHandler extends ToolBase {
   protected File dir;
   protected int port;
   // getters for dir and port
   ...

   public MyProgramHandler() {
       this.registerHandler(new ArgHandlerDir() {
            @Override
            public void setDir(File dir) {
                this.dir = dir;
            }
       });
       this.registerHandler(new ArgHandlerInt() {
            @Override
            public String[] getTagArgs() {
               return new String[]{"port"};
            }
            @Override
            public void setInt(int value) {
               this.port = value;
            }
       });
   }
   public static void main(String[] args) {
      MyProgramHandler myShell = new MyProgramHandler();
      if (myShell.processArgs(args)) {
         // main program operation
         System.out.println(String.format("port: %d; dir: %s",
            myShell.getPort(), myShell.getDir()));
      }
      System.exit(1);
   }
}

ArgHandler में एक विधि भी है। isRequired() जो यह कहने के लिए अधिलेखित किया जा सकता है कि कमांड-लाइन तर्क की आवश्यकता है (डिफ़ॉल्ट रिटर्न false ताकि तर्क वैकल्पिक हो।

प्रसंस्करण तर्क हाथ से

जब किसी एप्लिकेशन के लिए कमांड-लाइन सिंटैक्स सरल होता है, तो कमांड तर्क प्रसंस्करण पूरी तरह से कस्टम कोड में करना उचित है।

इस उदाहरण में, हम सरल केस स्टडीज की एक श्रृंखला प्रस्तुत करेंगे। प्रत्येक मामले में, कोड त्रुटि संदेश उत्पन्न करेगा यदि तर्क अस्वीकार्य हैं, और फिर कमांड को विफल करने वाले शेल को बताने के लिए System.exit(1) को कॉल करें। (हम प्रत्येक मामले में मान लेंगे कि जावा कोड एक रैपर का उपयोग करके लागू किया गया है जिसका नाम "myapp" है।)

एक तर्क जिसके पास कोई तर्क नहीं है

इस केस-स्टडी में, कमांड को किसी तर्क की आवश्यकता नहीं है। कोड बताता है कि args.length हमें कमांड लाइन तर्कों की संख्या देती है।

public class Main {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.err.println("usage: myapp");
            System.exit(1);
        }
        // Run the application
        System.out.println("It worked");
    }
}

दो तर्कों वाली एक कमान

इस केस-स्टडी में, कमांड को ठीक दो तर्कों की आवश्यकता होती है।

public class Main {
    public static void main(String[] args) {
        if (args.length != 2) {
            System.err.println("usage: myapp <arg1> <arg2>");
            System.exit(1);
        }
        // Run the application
        System.out.println("It worked: " + args[0] + ", " + args[1]);
    }
}

ध्यान दें कि अगर हमने args.length जांच करने के लिए उपेक्षा की है, तो कमांड क्रैश हो जाएगा यदि उपयोगकर्ता इसे बहुत कम कमांड-लाइन तर्कों के साथ चलाता है।

"ध्वज" विकल्पों के साथ एक कमांड और कम से कम एक तर्क

इस केस-स्टडी में, कमांड में कुछ (वैकल्पिक) ध्वज विकल्प होते हैं, और विकल्पों के बाद कम से कम एक तर्क की आवश्यकता होती है।

package tommy;
public class Main {
    public static void main(String[] args) {
        boolean feelMe = false;
        boolean seeMe = false;
        int index;
        loop: for (index = 0; index < args.length; index++) {
            String opt = args[index];
            switch (opt) {
            case "-c":
               seeMe = true;
               break;
            case "-f":
               feelMe = true;
               break;
            default:
               if (!opts.isEmpty() && opts.charAt(0) == '-') {
                   error("Unknown option: '" + opt + "');
               }
               break loop;
            }
        }
        if (index >= args.length) {
            error("Missing argument(s)");
        }      
        
        // Run the application
        // ...
    }

    private static void error(String message) {
        if (message != null) {
            System.err.println(message);
        }
        System.err.println("usage: myapp [-f] [-c] [ <arg> ...]");
        System.exit(1);
   }
}

जैसा कि आप देख सकते हैं, कमांड सिंटैक्स जटिल होने पर तर्कों और विकल्पों को संसाधित करना बोझिल हो जाता है। "कमांड लाइन पार्सिंग" लाइब्रेरी का उपयोग करना उचित है; अन्य उदाहरण देखें।