progress-4gl
स्ट्रिंग्स

परिचय

टिप्पणियों

एक स्ट्रिंग को परिभाषित करना, परखना और प्रदर्शित करना

आम तौर पर आपको हमेशा सभी चर और मापदंडों को NO-UNDO रूप में परिभाषित करना चाहिए जब तक कि आपको वास्तव में आवश्यकता न हो।

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

DISPLAY cString.

सम्वेदनशील तार

+ ऑपरेटर का उपयोग करके आप आसानी से दो या अधिक तारों को समतल कर सकते हैं।

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

cString = cString + " " + "GOODBYE".

DISPLAY cString FORMAT "X(20)".

स्ट्रिंग हेरफेर

स्ट्रिंग के साथ काम करने के लिए कुछ उपयोगी जोड़े बनाए गए हैं। वर्णों की स्थिति के साथ काम करने वाले सभी फ़ंक्शन पहले वर्ण के रूप में अनुक्रमणिका 1 से शुरू होते हैं, न कि 0 के रूप में कई भाषाओं में आम है।

STRING - किसी मान को स्ट्रिंग में परिवर्तित करता है

यह उदाहरण पूर्णांक 2000 को स्ट्रिंग "2000" में कनवर्ट करता है।

DEFINE VARIABLE i AS INTEGER     NO-UNDO.
DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

i = 2000.

c = STRING(i).

DISPLAY c.

CHR और ASC - एससीआई से एकल वर्णों को परिवर्तित करता है।

CHR (पूर्णांक)

Ascii कोड पूर्णांक के लिए वर्ण प्रतिनिधित्व लौटाता है

एएससी (चरित्र)

चरित्र के लिए एससीआई पूर्णांक मान लौटाता है

DEFINE VARIABLE ix     AS INTEGER   NO-UNDO.
DEFINE VARIABLE letter AS CHARACTER NO-UNDO FORMAT "X(1)" EXTENT 26.

DO ix = 1 TO 26:
  letter[ix] = CHR((ASC("A")) - 1 + ix).
END.

DISPLAY SKIP(1) letter WITH 2 COLUMNS NO-LABELS
  TITLE "T H E  A L P H A B E T".

LENGTH - एक स्ट्रिंग की लंबाई लौटाता है

लंबाई (स्ट्रिंग)। // स्ट्रिंग की लंबाई के साथ एक पूर्णांक देता है।

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "HELLO".

MESSAGE "The string " cString " is " LENGTH(cString) " characters long" VIEW-AS ALERT-BOX. 

SUBSTRING - एक स्ट्रिंग का एक हिस्सा लौटाता है या असाइन करता है

• SUBSTRING (स्ट्रिंग, प्रारंभिक स्थिति, लंबाई)।

"स्ट्रिंग" से "लंबाई" अक्षर लौटाता है जो स्थिति "शुरुआती-स्थिति" पर शुरू होता है।

• SUBSTRING (स्ट्रिंग, प्रारंभिक स्थिति)।

"स्ट्रिंग" के बाकी हिस्सों को लौटाता है, स्थिति "शुरुआती-स्थिति" पर शुरू होता है

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".

DISPLAY SUBSTRING(cString, 4, 2). //Displays "DE" 
DISPLAY SUBSTRING(cString, 4). //Displays "DEFGH"

किसी स्ट्रिंग के एक भाग को अधिलेखित करने के लिए सबस्ट्रिंग का भी उपयोग किया जा सकता है। उसी सिंटैक्स का उपयोग करें लेकिन इसके बजाय उस विकल्प को निर्दिष्ट करें:

DEFINE VARIABLE cString AS CHARACTER   NO-UNDO.

cString = "ABCDEFGH".
 
SUBSTRING(cString, 4, 2) = "XY". //Replaces position 4 and 5 with "XY" 

DISPLAY cString.  

इसी तरह का एक समारोह भी है जिसे OVERLAY कहा जाता है, इस उदाहरण से प्रोग्रेस डॉक्यूमेंटेशन OVERLAY और SUBSTRING बीच के अंतर को कवर करता है:

/* This procedure illustrates the differences between the SUBSTRING and
   OVERLAY statements. */
DEFINE VARIABLE cOriginal  AS CHARACTER NO-UNDO INITIAL "OpenEdge".
DEFINE VARIABLE cSubstring AS CHARACTER NO-UNDO.
DEFINE VARIABLE cOverlay   AS CHARACTER NO-UNDO.
DEFINE VARIABLE cResults   AS CHARACTER NO-UNDO.

/* Default behavior without optional LENGTH. */
ASSIGN
 cSubstring              = cOriginal
 SUBSTRING(cSubstring,2) = "***"
 cOverlay                = cOriginal
 OVERLAY(cOverlay,2)     = "***"
 cResults                = "target = ~"OpenEdge~". ~n~n" 
  + "If you do not supply a length, SUBSTRING and OVERLAY default as follows:
  ~n~n" + "SUBSTRING(target,2) = ~"***~"  yields:  " + cSubstring + ". ~n" 
  + "OVERLAY(target,2)     = ~"***~"  yields:  " + cOverlay + ".".

/* Behavior with zero LENGTH. */
ASSIGN
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,0) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,0)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a zero length, SUBSTRING and OVERLAY behave as follows:  ~n~n" 
  + "SUBSTRING(target,2,0) = ~"***~"  yields:  " + cSubstring + ". ~n" 
  + "OVERLAY(target,2,0)     = ~"***~"  yields:  " + cOverlay + ".".

/* Behavior with LENGTH < replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,1) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,1)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length shorter than the replacement, SUBSTRING and OVERLAY behave
  as follows: ~n~n" + "SUBSTRING(target,2,1) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,1)     = ~"***~"  yields:  " 
  + cOverlay + ".".

/* Behavior with LENGTH = replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,3) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,3)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length equal to the replacement, SUBSTRING and OVERLAY behave as
  follows:  ~n~n" + "SUBSTRING(target,2,3) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,3)     = ~"***~"  yields:  " 
  + cOverlay + ".".

/* Behavior with LENGTH > replacement. */
ASSIGN 
 cSubstring                = cOriginal
 SUBSTRING(cSubstring,2,6) = "***"
 cOverlay                  = cOriginal
 OVERLAY(cOverlay,2,6)     = "***"
 cResults                  = cResults + "~n~n" 
  + "For a length greater than the replacement, SUBSTRING and OVERLAY behave
  as follows:  ~n~n" + "SUBSTRING(target,2,6) = ~"***~"  yields:  " 
  + cSubstring + ". ~n" + "OVERLAY(target,2,6)     = ~"***~"  yields:  " 
  + cOverlay + ".".

MESSAGE cResults VIEW-AS ALERT-BOX.

INDEX - एक स्ट्रिंग में स्थिति की वापसी।

R-INDEX एक ही चीज़ के लिए होगा, लेकिन दाईं ओर बाईं ओर खोजें।

INDEX (स्रोत, लक्ष्य)

स्रोत के भीतर खोज लक्ष्य (बाएं से दाएं) और यह स्थिति है। यदि यह 0 रिटर्न से गायब है।

INDEX (स्रोत, लक्ष्य, आरंभ-स्थिति)।

ऊपर के समान लेकिन शुरू-स्थिति में खोजना शुरू करें

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.

str = "ABCDEFGH".

DISPLAY INDEX(str, "cd") INDEX(str, "cd", 4). //Will display 3 and 0

उत्तर - स्ट्रिंग के भीतर एक स्ट्रिंग की जगह।

रिपोर्ट (स्ट्रिंग, स्ट्रिंग से, स्ट्रिंग)

स्ट्रिंग में स्ट्रिंग के साथ स्ट्रिंग से प्रतिस्थापित करता है। एक स्ट्रिंग की लंबाई से स्ट्रिंग और टू-स्ट्रिंग की आवश्यकता नहीं है, एक चरित्र को हटाने के लिए स्ट्रिंग भी कुछ नहीं ("") हो सकता है।

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

c = "ELLO".

DISPLAY REPLACE(c, "E", "HE"). // Displays "HELLO"

c = "ABABABA".

DISPLAY REPLACE(c, "B", ""). // Remove all Bs

TRIM - प्रमुख और अनुगामी व्हाट्सएप (या अन्य वर्ण) को हटाता है।

यह इंडेटा की सफाई करते समय उपयोगी हो सकता है।

TRIM (स्ट्रिंग)

सभी प्रमुख और अनुगामी रिक्त स्थान, टैब, लाइन फ़ीड, कैरिज रिटर्न निकालता है।

TRIM (स्ट्रिंग, चरित्र)।

सभी प्रमुख और अनुगामी "वर्ण" को निकालता है।

LEFT-TRIM और RIGHT-TRIM एक ही काम करता है लेकिन केवल अग्रणी या अनुगामी होता है।

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.

c = "__HELLO_WORLD_____".

DISPLAY TRIM(c, "_").
/*Displays HELLO_WORLD without all the leading and 
trailing underscores but leaves the one in the middle.
REPLACE would have removed that one as well */

SUBSTITUTE - एक स्ट्रिंग में पैरामेट्स को प्रतिस्थापित करता है।

SUBSTITUTE is a limited function for replacing up to nine preformatted parameters in a string.

SUBSTITUTE (स्ट्रिंग, परम 1, परम 2, ..., परम 9)।

पैरामीटर प्रारूप में &1 से &9 तक होना चाहिए।

यदि आप स्ट्रिंग में एक एम्परसेंड का उपयोग करना चाहते हैं (और इसे एक पैरामीटर के रूप में उपयोग नहीं करते हैं) तो इसे किसी अन्य एम्परसेंड से बचकर रखें: && ।

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
                                      
str = "&1 made &2 goals in &3 games playing for &4".

MESSAGE SUBSTITUTE(str, "Zlatan Ibrahimovic", 113, 122, "Paris Saint-Germain") VIEW-AS ALERT-BOX.
MESSAGE SUBSTITUTE(str, "Mats Sundin", 555, 1305, "Toronto Maple Leafs") VIEW-AS ALERT-BOX.

एक पैरामीटर एक स्ट्रिंग में एक से अधिक बार दिखाई दे सकता है, सभी को बदल दिया जाएगा:

MESSAGE SUBSTITUTE("&1 &2 or not &1 &2", "To", "Be") VIEW-AS ALERT-BOX.

मामला-संवेदनशील तार

प्रगति एबीएल के सभी तार संवेदनशील हैं, जब तक कि अन्यथा निर्दिष्ट न हो।

यह उदाहरण एक संदेश बॉक्स प्रदर्शित करेगा जिसमें कहा गया है कि तार समान हैं।

DEFINE VARIABLE str1 AS CHARACTER   NO-UNDO.
DEFINE VARIABLE str2 AS CHARACTER   NO-UNDO.

str1 = "abc".
str2 = "ABC".

IF str1 = str2 THEN 
    MESSAGE "The strings are identical" VIEW-AS ALERT-BOX.

एक स्ट्रिंग केस को संवेदनशील घोषित करने के लिए आप केवल विशेषता CASE-SENSITIVE जोड़ें

DEFINE VARIABLE str1 AS CHARACTER   NO-UNDO CASE-SENSITIVE.
DEFINE VARIABLE str2 AS CHARACTER   NO-UNDO.

str1 = "abc".
str2 = "ABC".

IF str1 = str2 THEN 
    MESSAGE "The strings are identical" VIEW-AS ALERT-BOX.
ELSE 
    MESSAGE "There's a difference" VIEW-AS ALERT-BOX.

(यह पर्याप्त है कि तार में से एक इस मामले में है)।

BEGINS और सामग्री

BEGINS - एक स्ट्रिंग दूसरे स्ट्रिंग से शुरू होने पर TRUE लौटाती है।

string1 BEGINS string2

अगर string1 BEGINS के साथ (या बराबर है) string2 यह सच वापस आ जाएगा। नहीं तो झूठे लौटेंगे। यदि स्ट्रिंग दो खाली है ("") तो यह हमेशा सही होगा।

BEGINS उन प्रश्नों में बहुत उपयोगी है, जहाँ आप किसी नाम की शुरुआत की खोज करना चाहते हैं, उदाहरण के लिए। लेकिन यह मूल रूप से तार पर काम करने वाला एक फ़ंक्शन है।

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
DEFINE VARIABLE beg AS CHARACTER   NO-UNDO.

str = "HELLO".
beg = "HELLO".
DISPLAY str BEGINS beg. // yes

str = "HELLO".
beg = "H".
DISPLAY str BEGINS beg. // yes

str = "HELLO".
beg = "".
DISPLAY str BEGINS beg. // yes


str = "HELLO".
beg = "HELLO WORLD".
DISPLAY str BEGINS beg. // no

कुछ वाइल्डकार्ड क्रिटेरिया को एक स्ट्रिंग में मिलने पर MATCHES सही हो जाता है।

string1 MATCHES अभिव्यक्ति

यह सच है कि अगर string1 वाइल्डकार्ड अभिव्यक्ति से मेल खाता है:

* (तारांकन) = 0 से n अक्षर (मूल रूप से किसी भी लम्बाई के तार)

। (अवधि) = वाइल्डकार्ड किसी भी वर्ण के लिए (शून्य को छोड़कर)

DEFINE VARIABLE str AS CHARACTER   NO-UNDO.
DEFINE VARIABLE beg AS CHARACTER   NO-UNDO.

str = "HELLO".
beg = "HELLO".
DISPLAY str MATCHES beg. // yes

str = "HELLO".
beg = "H*".
DISPLAY str MATCHES beg. // yes

str = "HELLO".
beg = "*O".
DISPLAY str MATCHES beg. // yes

str = "HELLO WORLD".
beg = "HELLO.WORLD".
DISPLAY str MATCHES beg. // yes

str = "HELLO WORLD".
beg = "*WORL..".
DISPLAY str MATCHES beg. // no

str = "*HELLO WORLD".
beg = "WOR*LD".
DISPLAY str MATCHES beg. // no

ऊपरी और निचले मामले को परिवर्तित करना

जैसा कि उल्लेख किया गया है कि स्ट्रिंग्स सामान्य रूप से असंवेदनशील हैं लेकिन यह केवल स्ट्रिंग्स की तुलना का संबंध है। मामले बदलने के लिए कार्यों में बनाया गया है।

CAPS (स्ट्रिंग)

स्ट्रिंग अपर केस बनाता है

नियंत्रण रेखा (स्ट्रिंग)

स्ट्रिंग लोअर केस बनाता है

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "Hello".
d = "World".

DISPLAY CAPS(c) LC(d). // HELLO world

याद रखें कि तार सामान्य रूप से असंवेदनशील होते हैं

DEFINE VARIABLE c AS CHARACTER   NO-UNDO.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "hello".
d = "hello".

DISPLAY CAPS(c) = LC(d). // yes

जब तक CASE-SENSITIVE रूप में विशिष्ट न हो

DEFINE VARIABLE c AS CHARACTER   NO-UNDO CASE-SENSITIVE.
DEFINE VARIABLE d AS CHARACTER   NO-UNDO.

c = "hello".
d = "hello".

DISPLAY CAPS(c) = LC(d). // no

सूचियाँ

प्रगति 4GL में अल्पविराम (या अन्य वर्ण) से अलग सूची के साथ काम करने के लिए कई कार्य और विधियाँ हैं।

NUM-ENTRIES किसी सूची में प्रविष्टियों की संख्या लौटाता है। आप वैकल्पिक रूप से सीमांकक निर्दिष्ट कर सकते हैं, अल्पविराम डिफ़ॉल्ट है

NUM-ENTRIES (स्ट्रिंग [, सीमांकक])

अल्पविराम का उपयोग करते हुए, डिफ़ॉल्ट सीमांकक:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY NUM-ENTRIES(cList). //3

एक और सीमांकक का उपयोग, अर्धविराम:

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye;cruel;world!".

DISPLAY NUM-ENTRIES(cList, ";"). //3

ENTRY - फ़ंक्शन - एक सूची में एक निर्दिष्ट प्रविष्टि देता है

हमेशा की तरह शुरुआती स्थिति 1 है, 0 नहीं!

प्रवेश (प्रवेश, सूची [, सीमांकक])।

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

DISPLAY ENTRY(2, cList). //cruel

ENTRY - विधि - किसी सूची में निर्दिष्ट प्रविष्टि का मान निर्दिष्ट करना

प्रवेश (प्रविष्टि, सूची [, सीमांकक]) = मान

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Goodbye,cruel,world!".

ENTRY(1, cList) = "Hello".
ENTRY(2, cList) = "nice".

MESSAGE REPLACE(cList, ",", " ") VIEW-AS ALERT-BOX. //Hello nice world!

LOOKUP - एक विशिष्ट प्रविष्टि के लिए एक सूची की जाँच करें। लौटाता है प्रवेश।

यदि स्ट्रिंग सूची में मौजूद नहीं है तो लुकअप 0 वापस आ जाएगा

LOOKUP (स्ट्रिंग, सूची [, सीमांकक])

DEFINE VARIABLE cList AS CHARACTER   NO-UNDO.

cList = "Hello,nice,world!".

MESSAGE LOOKUP("nice", cList) VIEW-AS ALERT-BOX. //2
MESSAGE LOOKUP("cruel", cList) VIEW-AS ALERT-BOX. //0

विशेष वर्ण (और भागने)

प्रगति 4GL में एक विशेष चरित्र लिखने का सामान्य तरीका यह है कि इसे टिल्ड चरित्र (~) के साथ आगे बढ़ाया जाए।

ये डिफ़ॉल्ट विशेष वर्ण हैं

यदि आप बिल्कुल भी प्रदर्शित करना चाहते हैं तो बच जाना चाहिए!

MESSAGE "A single tilde: ~~" VIEW-AS ALERT-BOX.

MESSAGE "At sign: ~100" SKIP
        "Tab~tseparated~twords!" SKIP
        "A linefeed:~n"
        "Escaping a quote sign: ~"This is a quote!~"" SKIP VIEW-AS ALERT-BOX.