શબ્દમાળાઓ સાથે કામ. શબ્દમાળા વર્ગ. વર્ગ કન્સ્ટ્રક્ટર. કાર્યો અસાઇન() , એપેન્ડ() , ઇન્સર્ટ() , રિપ્લેસ () , ઇરેઝ() , ફાઇન્ડ() , rfind() , compare() , c_str() . ઉદાહરણો
1. C++ પ્રોગ્રામ્સમાં સ્ટ્રિંગ ક્લાસનો હેતુ શું છે?
સ્ટ્રિંગ ક્લાસ ચાર* સ્ટ્રિંગ્સ સાથે કામ કરવા માટે રચાયેલ છે, જે નલ-ટર્મિનેટેડ સ્ટ્રિંગ્સ છે. શબ્દમાળા વર્ગ તરીકે રજૂ કરવામાં આવ્યો હતો વૈકલ્પિક વિકલ્પચાર* પ્રકારના સ્ટ્રીંગ્સ સાથે કામ કરવા માટે. રેખાઓ જે અક્ષર સાથે સમાપ્ત થાય છે ‘\0’ સી-સ્ટ્રિંગ્સ પણ કહેવાય છે. શબ્દમાળા એક વર્ગ હોવાથી, તમે આ વર્ગના ઑબ્જેક્ટ જાહેર કરી શકો છો.
2. MS વિઝ્યુઅલ સ્ટુડિયો C++ માં સ્ટ્રિંગ ક્લાસની ક્ષમતાઓનો ઉપયોગ કરવા માટે કયા મોડ્યુલ (લાઇબ્રેરીઓ) ને કનેક્ટ કરવાની જરૂર છે?
MS વિઝ્યુઅલ સ્ટુડિયો (C++) માં સ્ટ્રિંગ ક્લાસની ક્ષમતાઓનો ઉપયોગ કરવા માટે, તમારે લાઇબ્રેરીનો સમાવેશ કરવાની જરૂર છે.
3. ટાઈપ સ્ટ્રિંગનું ચલ કેવી રીતે જાહેર કરવામાં આવે છે? ઉદાહરણો
ટાઈપ સ્ટ્રીંગના વેરીએબલને જાહેર કરવું એ રેગ્યુલર વેરીએબલની જેમ જ કરવામાં આવે છે. શક્ય પ્રકારએક સાથે પ્રારંભ સાથે ઘોષણાઓ.
// ટાઈપ સ્ટ્રિંગ સ્ટ્રિંગ s1; // પ્રકાર સ્ટ્રિંગનું s1 નામનું ચલ string s2 = "આ એક શબ્દમાળા ચલ છે" ; // આરંભ સાથે ઘોષણા // અસાઇનમેન્ટ ઓપરેટર સાથે ટાઈપ સ્ટ્રિંગના ચલનો ઉપયોગ કરીને s1 = s2; // s1 = "આ એક સ્ટ્રીંગ વેરીએબલ છે" s2 = "નવું લખાણ" ;4. char* પ્રકારની સરખામણીમાં સ્ટ્રિંગ ક્લાસનો ઉપયોગ કરવાના ફાયદા અને ગેરફાયદા શું છે?
નવા શબ્દમાળા પ્રકારનું નિર્માણ અક્ષર શબ્દમાળાઓ સાથે કામ કરવાની ખામીઓને કારણે હતું, જે char* પ્રકારનું નિદર્શન કરે છે. char* પ્રકારની તુલનામાં, શબ્દમાળા પ્રકારમાં નીચેના મુખ્ય ફાયદા છે:
- પ્રમાણભૂત C++ ઓપરેટરોનો ઉપયોગ કરીને સ્ટ્રિંગ્સ પર પ્રક્રિયા કરવાની ક્ષમતા ( = , + , = = , <> અને તેથી વધુ.). જેમ તમે જાણો છો, char* પ્રકારનો ઉપયોગ કરતી વખતે, શબ્દમાળાઓ સાથેની સૌથી સરળ કામગીરી પણ જટિલ લાગતી હતી અને વધુ પડતા પ્રોગ્રામ કોડ લખવા જરૂરી હતા;
- પ્રોગ્રામ કોડની વધુ સારી વિશ્વસનીયતા (સુરક્ષા) સુનિશ્ચિત કરવી. ઉદાહરણ તરીકે, શબ્દમાળાઓની નકલ કરતી વખતે, શબ્દમાળાનો પ્રકાર યોગ્ય ક્રિયાઓ પ્રદાન કરે છે જે જો સ્ત્રોત સ્ટ્રિંગ ગંતવ્ય સ્ટ્રિંગ કરતા મોટી હોય તો થઈ શકે છે;
- સ્વતંત્ર ડેટા પ્રકાર તરીકે સ્ટ્રિંગ પ્રદાન કરે છે. શબ્દમાળાના પ્રકારને સ્ટ્રિંગ તરીકેની ઘોષણા પ્રોગ્રામમાંના તમામ ચલો માટે સમાન છે, જે ડેટાની સુસંગતતાને સુનિશ્ચિત કરે છે.
char* પ્રકારની સરખામણીમાં સ્ટ્રિંગ પ્રકારનો મુખ્ય ગેરલાભ એ ધીમી ડેટા પ્રોસેસિંગ ઝડપ છે. આ એ હકીકતને કારણે છે કે શબ્દમાળા પ્રકાર હકીકતમાં, કન્ટેનર વર્ગ છે. અને વર્ગ સાથે કામ કરવા માટે પ્રોગ્રામ કોડના વધારાના અમલીકરણની જરૂર છે, જે બદલામાં, વધારાનો સમય લે છે.
5. સ્ટ્રિંગ ક્લાસના ઑબ્જેક્ટ્સ સાથે કયા ઑપરેટર્સનો ઉપયોગ કરી શકાય છે?
સ્ટ્રિંગ ક્લાસ અનુકૂળ છે કારણ કે તે તમને પ્રમાણભૂત (ઓવરલોડેડ) ઓપરેટર્સનો ઉપયોગ કરીને સ્ટ્રિંગને અનુકૂળ રીતે ચાલાકી કરવાની મંજૂરી આપે છે.
નીચેના ઓપરેટરોનો ઉપયોગ સ્ટ્રિંગ ક્લાસના ઓબ્જેક્ટ સાથે કરી શકાય છે
- = - સોંપણી
- + - જોડાણ (જોડાવાની તાર)
- += - જોડાણ સાથે સોંપણી
- == - સમાનતા
- != - અસમાનતા
- < - ઓછું
- <= - ઓછું અથવા સમાન
- > - વધુ
- >= - વધુ અથવા સમાન
- - અનુક્રમણિકા
ઉદાહરણ,જે ઉપરોક્ત વિધાનોનો ઉપયોગ દર્શાવે છે
// શબ્દમાળા પ્રકાર, શબ્દમાળાઓ પર કામગીરીશબ્દમાળા s1 = "s-1" ; શબ્દમાળા s2 = "s-2" ; શબ્દમાળા s3; bool b; // ઓપરેશન "=" (સ્ટ્રિંગ અસાઇનમેન્ટ) s3 = s1; // s3 = "s-1" // ઓપરેશન "+" - શબ્દમાળા જોડાણ s3 = s3 + s2; // s3 = "s-1s-2" // ઓપરેશન "+=" - જોડાણ સાથે સોંપણી s3 = "s-3" ; s3 += "abc" ; // s3 = "s-3abc" // ઓપરેશન "==" - શબ્દમાળા સરખામણી b = s2==s1; // b = ખોટા b = s2=="s-2" ; // b = સાચું // ઓપરેશન "!=" - શબ્દમાળા સરખામણી (સમાન નથી) s1 = "s1" ; s2 = "s2" ; b = s1 != s2; // b = સાચું // ઓપરેશન્સ "<" и ">"- શબ્દમાળા સરખામણી s1 = "abcd" ; s2 = "de"; b = s1 > s2; // b = ખોટા b = s1< s2; // b = true // ઓપરેશન્સ "<=" и ">=" - શબ્દમાળા સરખામણી (ઓછી અથવા સમાન, તેનાથી વધુ અથવા સમાન) s1 = "abcd" ; s2 = "ab" ; b = s1 >= s2; // b = સાચું b = s1<= s2; // b = false b = s2 >= "ab" ; // b = સાચું // ઓપરેશન - ઇન્ડેક્સીંગ char c; s1 = "abcd" ; c = s1; // c = "c" c = s1; // c = "a"6. શું સ્ટ્રિંગ ક્લાસમાં કન્સ્ટ્રક્ટર હોય છે?
કોઈપણ વર્ગની જેમ, શબ્દમાળા વર્ગમાં સંખ્યાબંધ કન્સ્ટ્રક્ટર હોય છે. મુખ્ય નીચે મુજબ છે:
તાર(); શબ્દમાળા(const char * str); શબ્દમાળા(const શબ્દમાળા અને str);
7. કન્સ્ટ્રક્ટરનો ઉપયોગ કરીને આરંભના ઉદાહરણો
નીચે સ્ટ્રિંગ પ્રકાર વેરીએબલ્સ શરૂ કરવાના ઉદાહરણો છે
સ્ટ્રિંગ s1("હેલો!"); string s2 = "હેલો!" ;// આરંભ - કન્સ્ટ્રક્ટર સ્ટ્રિંગ (const char * str) char * ps = "હેલો" ; શબ્દમાળા s3(ps); // આરંભ સ્ટ્રિંગ s4(s3);// આરંભ - કન્સ્ટ્રક્ટર સ્ટ્રિંગ(const string & str) શબ્દમાળા s5;
// આરંભ - સ્ટ્રિંગ() કન્સ્ટ્રક્ટર
એક શબ્દમાળા બીજાને સોંપવા માટે, તમે બેમાંથી એક પદ્ધતિનો ઉપયોગ કરી શકો છો:
- સોંપણી ઓપરેટરનો ઉપયોગ કરો ‘=’ ;
- સ્ટ્રિંગ ક્લાસમાંથી assign() ફંક્શનનો ઉપયોગ કરો.
અસાઇન() ફંક્શનમાં ઘણા ઓવરલોડેડ અમલીકરણો છે.
પ્રથમ વિકલ્પ એ પરિમાણો વિના ફંક્શનને કૉલ કરવાનો છે
શબ્દમાળા અને સોંપણી (રદ
આ કિસ્સામાં, એક સ્ટ્રિંગને બીજામાં સરળ સોંપણી છે.
બીજો વિકલ્પ તમને સ્ટ્રિંગમાંથી અક્ષરોની ચોક્કસ સંખ્યાની નકલ કરવાની મંજૂરી આપે છે:
શબ્દમાળા અને સોંપણી (const શબ્દમાળા અને s, size_type st, size_type num);
- s - ઑબ્જેક્ટ કે જેમાંથી સ્રોત શબ્દમાળા લેવામાં આવે છે;
- st – લાઇનમાં અનુક્રમણિકા (સ્થિતિ) કે જ્યાંથી સંખ્યા અક્ષરોની નકલ શરૂ થાય છે;
- num – પોઝિશન st માંથી કૉપિ કરવાના અક્ષરોની સંખ્યા;
- size_type - ઑર્ડિનલ ડેટા પ્રકાર.
assign() ફંક્શનનું ત્રીજું વેરિઅન્ટ સ્ટ્રિંગ s ના પ્રથમ નંબર અક્ષરોની કોલરને નકલ કરે છે:
શબ્દમાળા અને સોંપણી (const char * s, size_type num);
- s - એક શબ્દમાળા જે અક્ષર સાથે સમાપ્ત થાય છે ‘\0’ ;
- num એ અક્ષરોની સંખ્યા છે જે કૉલિંગ ઑબ્જેક્ટ પર કૉપિ કરવામાં આવે છે. સ્ટ્રિંગ sમાંથી પ્રથમ સંખ્યાના અક્ષરોની નકલ કરવામાં આવે છે.
નીચે assign() ફંક્શનના વિવિધ અમલીકરણ સાથેનું ઉદાહરણ છે.
ઉદાહરણ.
// શબ્દમાળાઓની સોંપણી, સોંપણી() કાર્યશબ્દમાળા s1 = "સાઇટ" ; શબ્દમાળા s2; શબ્દમાળા s3; char * ps = "સાઇટ" ; s3 = s1; // s3 = "સાઇટ" s2.assign(s1); // s2 = "સાઇટ" s2.assign(s1, 0, 4); // s2 = "શ્રેષ્ઠ" s2. સોંપણી(ps, 8); // s2 = "શ્રેષ્ઠ પ્રોગ"9. શબ્દમાળાઓનું સંયોજન. એપેન્ડ() ફંક્શન. ઉદાહરણ
એપેન્ડ() ફંક્શનનો ઉપયોગ શબ્દમાળાઓને જોડવા માટે થાય છે. તમે પંક્તિઓ ઉમેરવા માટે ઓપરેશનનો ઉપયોગ પણ કરી શકો છો ‘+’ , દાખ્લા તરીકે:
શબ્દમાળા s1; શબ્દમાળા s2; s1 = "abc" ; s2 = "def" ; s1 = s1 + s2; // s1 = "abcdef"
જો કે, જો તમારે સ્ટ્રીંગનો ભાગ જોડવાની જરૂર હોય તો append() ફંક્શન સારું છે.
ફંક્શનમાં નીચેના અમલીકરણ વિકલ્પો છે:
સ્ટ્રિંગ અને એપેન્ડ (const સ્ટ્રિંગ અને s, size_type start); સ્ટ્રિંગ અને એપેન્ડ (const char * s, size_type num);
પ્રથમ અમલીકરણમાં, ફંક્શન સ્ટ્રિંગ ઑબ્જેક્ટનો સંદર્ભ મેળવે છે s, જે કૉલિંગ ઑબ્જેક્ટમાં ઉમેરવામાં આવે છે. બીજા અમલીકરણમાં, ફંક્શનને const char * ટાઈપની સ્ટ્રિંગ માટે એક નિર્દેશક પ્રાપ્ત થાય છે, જે અક્ષર '\0' સાથે સમાપ્ત થાય છે.
ઉદાહરણ.એપેન્ડ() ફંક્શનનું પ્રદર્શન.
શબ્દમાળા s1 = "abcdef" ; s2 = "1234567890" ; જોડો(s2, 3, 4); // s1 = "abcdef4567" char * ps = "1234567890" ; s1 = "abcdef" ; s1.append(ps, 3); // s1 = "abcdef123"
10. શબ્દમાળામાં અક્ષરો દાખલ કરી રહ્યા છીએ. insert() ફંક્શન. ઉદાહરણ
બીજી લાઇનની આપેલ સ્થિતિ પર એક લાઇન દાખલ કરવા માટે, તમારે insert() ફંક્શનનો ઉપયોગ કરવાની જરૂર છે, જેમાં ઘણા અમલીકરણ વિકલ્પો છે.
ફંક્શનનું પ્રથમ સંસ્કરણ તમને કૉલિંગ લાઇન (કોલિંગ ઑબ્જેક્ટ) ની નિર્દિષ્ટ શરૂઆતની સ્થિતિ પર સંપૂર્ણ સ્ટ્રિંગ દાખલ કરવાની મંજૂરી આપે છે:
સ્ટ્રિંગ અને ઇન્સર્ટ(size_type start, const string &s);
ફંક્શનનું બીજું સંસ્કરણ તમને કૉલિંગ સ્ટ્રિંગની નિર્દિષ્ટ સ્ટાર્ટ પોઝિશન પર સ્ટ્રિંગ s નો ભાગ (પેરામીટર્સ insStart , num ) દાખલ કરવાની મંજૂરી આપે છે:
સ્ટ્રિંગ અને ઇન્સર્ટ (size_type start, const string &s, size_type insStart, size_type num);
ઉપરોક્ત કાર્યોમાં:
- s – એક શબ્દમાળા જે કૉલિંગ લાઇનમાં દાખલ કરવામાં આવે છે;
- શરૂઆત - કૉલિંગ લાઇનમાં સ્થાન કે જ્યાંથી સ્ટ્રિંગ s દાખલ કરવામાં આવે છે;
- insStart - સ્ટ્રિંગ s માં સ્થાન જેમાંથી નિવેશ થાય છે;
- num – સ્ટ્રિંગ s માં અક્ષરોની સંખ્યા જે insStart પોઝિશનથી દાખલ કરવામાં આવે છે.
11. શબ્દમાળામાં અક્ષરો બદલવું. રિપ્લેસ() ફંક્શન. ઉદાહરણ
રિપ્લેસ() ફંક્શન કૉલિંગ સ્ટ્રિંગમાં અક્ષરોને બદલે છે. ફંક્શનમાં નીચેના અમલીકરણ વિકલ્પો છે:
સ્ટ્રિંગ &બદલો(size_type start, size_type num, const string &s); શબ્દમાળા &બદલો(size_type start, size_type num, const string &s, size_type replStart, size_type replNum);
પ્રથમ અમલીકરણમાં, કૉલિંગ સ્ટ્રિંગને સ્ટ્રિંગ s સાથે બદલવામાં આવે છે. કૉલિંગ લાઇનમાં સ્થાન (પ્રારંભ) અને અક્ષરોની સંખ્યા (સંખ્યા) નો ઉલ્લેખ કરવો શક્ય છે જેને સ્ટ્રિંગ s સાથે બદલવાની જરૂર છે.
રિપ્લેસ() ફંક્શનનું બીજું વર્ઝન પ્રથમ કરતા અલગ છે જેમાં તે સ્ટ્રિંગ s ના માત્ર ભાગને કૉલિંગ સ્ટ્રિંગ દ્વારા બદલવાની મંજૂરી આપે છે. આ કિસ્સામાં, બે વધારાના પરિમાણો આપવામાં આવે છે: replStart ની સ્થિતિ અને સ્ટ્રિંગ s માં અક્ષરોની સંખ્યા, જે કોલિંગ સ્ટ્રિંગને બદલે સબસ્ટ્રિંગ બનાવે છે.
ઉદાહરણ.રિપ્લેસ() ફંક્શનનું પ્રદર્શન.
શબ્દમાળા s1 = "abcdef" ; શબ્દમાળા s2 = "1234567890" ; s2.બદલો(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.બદલો(5, 1, s1); // s2 = "12345abcdef7890" // અક્ષરોને બદલીને, રિપ્લેસ() ફંક્શનશબ્દમાળા s1 = "abcdef" ; શબ્દમાળા s2 = "1234567890" ; s2.બદલો(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.બદલો(5, 1, s1); // s2 = "12345abcdef7890" s2 = "1234567890" ; s2.બદલો(5, 1, s1, 2, 3); // s2 = "12345cde7890" s2 = "1234567890" ; s2.બદલો(4, 2, s1, 0, 4); // s2 = "1234abcd7890"
12. શબ્દમાળામાંથી સ્પષ્ટ કરેલ અક્ષરોની સંખ્યા દૂર કરવી. erase() ફંક્શન. ઉદાહરણ
કૉલિંગ સ્ટ્રિંગમાંથી અક્ષરોને દૂર કરવા માટે, erase() ફંક્શનનો ઉપયોગ કરો:
શબ્દમાળા અને ભૂંસી નાખો(size_type index=0, size_type num = npos);
- અનુક્રમણિકા - અનુક્રમણિકા (સ્થિતિ) જેમાંથી તમે કૉલિંગ લાઇનમાં અક્ષરોને દૂર કરવા માંગો છો;
- num – દૂર કરવામાં આવેલ અક્ષરોની સંખ્યા.
ઉદાહરણ.
શબ્દમાળા s = "01234567890" ; s.erase(3, 5); // s = "012890" s = "01234567890" ; s.erase(); // સે = ""
13. શબ્દમાળામાં અક્ષર માટે શોધો. Find() અને rfind() ફંક્શન. ઉદાહરણો
સ્ટ્રિંગ ક્લાસમાં, સબસ્ટ્રિંગમાં સ્ટ્રિંગની શોધ બે રીતે કરી શકાય છે, જે શોધની દિશામાં અલગ છે:
- find() ફંક્શનનો ઉપયોગ કરીને શરૂઆતથી સમાપ્ત સુધી સ્ટ્રિંગને સ્કેન કરીને;
- rfind() ફંક્શન વડે સ્ટ્રિંગને છેડેથી શરૂઆત સુધી સ્કેન કરીને.
find() ફંક્શન પ્રોટોટાઇપ આના જેવો દેખાય છે:
Size_type find(const string &s, size_type start = 0) const ;
- s એ સબસ્ટ્રિંગ છે જે સ્ટ્રિંગમાં શોધવામાં આવે છે જે આ ફંક્શનને કૉલ કરે છે. ફંક્શન સ્ટ્રિંગ s ની પ્રથમ ઘટના માટે શોધ કરે છે. જો સબસ્ટ્રિંગ s સ્ટ્રિંગમાં જોવા મળે છે જે આ ફંક્શન કહે છે, તો પ્રથમ ઘટનાની સ્થિતિ પરત કરવામાં આવે છે. નહિંતર -1 પરત કરવામાં આવે છે;
rfind() ફંક્શન પ્રોટોટાઇપ આના જેવો દેખાય છે:
Size_type rfind(const string &s, size_type start = npos) const ;
- s એ સબસ્ટ્રિંગ છે જે કૉલિંગ સ્ટ્રિંગમાં જોવામાં આવે છે. શબ્દમાળામાં સબસ્ટ્રિંગની શોધ અંતથી શરૂઆત સુધી હાથ ધરવામાં આવે છે. જો કોલિંગ સ્ટ્રિંગમાં સબસ્ટ્રિંગ s જોવા મળે છે, તો ફંક્શન પ્રથમ ઘટનાની સ્થિતિ પરત કરે છે. નહિંતર, ફંક્શન -1 પરત કરે છે;
- npos - કૉલિંગ લાઇનના છેલ્લા અક્ષરની સ્થિતિ;
- શરૂઆત - તે સ્થાન કે જ્યાંથી શોધ હાથ ધરવામાં આવે છે.
ઉદાહરણ 1.કોડ ફ્રેગમેન્ટ કે જે find() ફંક્શનનું પરિણામ દર્શાવે છે
// ટાઈપ સ્ટ્રિંગ, ફંક્શન ફાઇન્ડ()શબ્દમાળા s1 = "01234567890" ; શબ્દમાળા s2 = "345" ; શબ્દમાળા s3 = "abcd" ; int pos; pos = s1.find(s2); // pos = 3 pos = s1.find(s2, 1); // pos = 3 pos = s1.find("jklmn" , 0); // pos = -1 pos = s1.find(s3); // pos = -1 pos = s2.find(s1); // pos = -1ઉદાહરણ 2. rfind() કાર્યનું પ્રદર્શન.
// સ્ટ્રિંગ પ્રકાર, find() અને rfind() ફંક્શનશબ્દમાળા s1 = "01234567890" ; શબ્દમાળા s2 = "345" ; શબ્દમાળા s3 = "abcd" ; શબ્દમાળા s4 = "abcd---abcd" ; int pos; pos = s1.rfind(s2); // pos = 3 pos = s1.rfind(s2, 12); // pos = 3 pos = s1.rfind(s2, 3); // pos = 3 pos = s1.rfind(s2, 2); // pos = -1 pos = s2.rfind(s1); // pos = -1 pos = s1.rfind(s3, 0); // pos = -1 // find() અને rfind() ફંક્શન વચ્ચેનો તફાવત pos = s4.rfind(s3); // pos = 7 pos = s4.find(s3); // પોઝ = 014. શબ્દમાળાઓના ભાગોની સરખામણી. compare() ફંક્શન. ઉદાહરણ
શબ્દમાળાનો પ્રકાર એક વર્ગ હોવાથી, તમે બે શબ્દમાળાઓને એકબીજા સાથે સરખાવવા માટે ઓપરેશનનો ઉપયોગ કરી શકો છો ‘= =’ . જો બે શબ્દમાળાઓ સમાન હોય, તો સરખામણીનું પરિણામ સાચું હશે. નહિંતર, સરખામણીનું પરિણામ ખોટું હશે.
પરંતુ જો તમારે એક સ્ટ્રીંગના ભાગને બીજી સાથે સરખાવવાની જરૂર હોય, તો compare() ફંક્શન આ માટે આપવામાં આવે છે.
compare() ફંક્શન પ્રોટોટાઇપ:
int compare(size_type start, size_type num, const string &s) const ;- s – સ્ટ્રિંગ કે જેની તુલના કૉલિંગ સ્ટ્રિંગ સાથે કરવામાં આવે છે;
- સ્ટાર્ટ - સ્ટ્રીંગ s માં સ્થિતિ (ઇન્ડેક્સ) જ્યાંથી સરખામણી માટે સ્ટ્રિંગ અક્ષરો જોવાનું શરૂ થાય છે;
- num એ સ્ટ્રિંગ s માં એવા અક્ષરોની સંખ્યા છે જેની સરખામણી કૉલિંગ સ્ટ્રિંગ સાથે કરવામાં આવે છે.
કાર્ય નીચે મુજબ કાર્ય કરે છે. જો કૉલિંગ સ્ટ્રિંગ સ્ટ્રિંગ s કરતાં ઓછી હોય, તો ફંક્શન -1 પરત કરે છે ( નકારાત્મક અર્થ). જો કૉલિંગ સ્ટ્રિંગ સ્ટ્રિંગ s કરતાં મોટી હોય, તો ફંક્શન 1 (ધન મૂલ્ય) આપે છે. જો બે શબ્દમાળાઓ સમાન હોય, તો કાર્ય 0 પરત કરે છે.
ઉદાહરણ. compare() કાર્યનું પ્રદર્શન:
// સ્ટ્રિંગ પ્રકાર, compare() ફંક્શનશબ્દમાળા s1 = "012345" ; શબ્દમાળા s2 = "0123456789" ; int res; res = s1.compare(s2); // res = -1 res = s1.compare("33333" ); // res = -1 res = s1.compare("012345" ); // res = 0 res = s1.compare("345" ); // res = -1 res = s1.compare(0, 5, s2); // res = -1 res = s2.compare(0, 5, s1); // res = -1 res = s1.compare(0, 5, "012345" ); // res = -1 res = s2.compare(s1); // res = 1 res = s2.compare("456" ); // res = -1 res = s2.compare("000000" ); // res = 115. અંત-ઓફ-લાઇન અક્ષર '\0' (char * ) સાથે સ્ટ્રિંગ પ્રાપ્ત કરવી. ફંક્શન c_str() . ઉદાહરણ
અક્ષર સાથે સમાપ્ત થતી સ્ટ્રિંગ મેળવવા માટે ‘\0’ c_str() ફંક્શનનો ઉપયોગ થાય છે.
કાર્ય પ્રોટોટાઇપ:
const char * c_str() const ;કાર્ય કોન્સ્ટ મોડિફાયર સાથે જાહેર કરવામાં આવે છે. આનો અર્થ એ છે કે ફંક્શન કૉલિંગ ઑબ્જેક્ટ (સ્ટ્રિંગ) ને સંશોધિત કરી શકતું નથી.
ઉદાહરણ 1. શબ્દમાળા પ્રકારને const char * માં રૂપાંતરિત કરી રહ્યું છે.
// ટાઈપ સ્ટ્રિંગ, ફંક્શન c_str()શબ્દમાળા s = "abcdef" ; const char * ps; ps = s.c_str(); // ps = "abcdef"ઉદાહરણ 2.
નીચે સ્ટ્રિંગને સ્ટ્રિંગમાંથી સિસ્ટમમાં કન્વર્ટ કરવાનું નિદર્શન છે::સ્ટ્રિંગ પ્રકાર તેને લેબલ કંટ્રોલમાં પ્રદર્શિત કરવા માટે
છેલ્લું અપડેટ: 10/31/2015
જોડાણ
+ ઓપરેટર અથવા કોન્કેટ પદ્ધતિનો ઉપયોગ કરીને સ્ટ્રિંગ જોડાણ અથવા યુનિયન કરી શકાય છે:
શબ્દમાળા s1 = "હેલો"; string s2 = "દુનિયા"; શબ્દમાળા s3 = s1 + " " + s2; // પરિણામ: string "hello world" string s4 = String.Concat(s3, "!!!"); // પરિણામ: શબ્દમાળા "હેલો વર્લ્ડ!!!" Console.WriteLine(s4);
Concat પદ્ધતિ એ સ્ટ્રિંગ વર્ગની સ્થિર પદ્ધતિ છે જે પરિમાણો તરીકે બે શબ્દમાળાઓ લે છે. પદ્ધતિના અન્ય સંસ્કરણો પણ છે જે વિવિધ પરિમાણો લે છે.
જોડાવા માટેની પદ્ધતિનો ઉપયોગ સ્ટ્રિંગ્સને જોડવા માટે પણ થઈ શકે છે:
શબ્દમાળા s5 = "સફરજન"; string s6 = "એક દિવસ"; string s7 = "રાખે છે"; string s8 = "એક ડૉક્ટર"; string s9 = "દૂર"; શબ્દમાળા મૂલ્યો = નવી સ્ટ્રિંગ (s5, s6, s7, s8, s9); સ્ટ્રિંગ s10 = String.Join(" ", મૂલ્યો); // પરિણામ: શબ્દમાળા "એપલ એક દિવસ ડૉક્ટરને દૂર રાખે છે"
જોડાવાની પદ્ધતિ પણ સ્થિર છે. ઉપરોક્ત ઉપયોગમાં લેવાતી પદ્ધતિનું સંસ્કરણ બે પરિમાણો લે છે: એક વિભાજક સ્ટ્રિંગ (આ કિસ્સામાં જગ્યા) અને શબ્દમાળાઓની એરે કે જે વિભાજક દ્વારા જોડવામાં આવશે અને અલગ કરવામાં આવશે.
શબ્દમાળા સરખામણી
શબ્દમાળાઓની તુલના કરવા માટે, સ્થિર તુલના પદ્ધતિનો ઉપયોગ કરો:
શબ્દમાળા s1 = "હેલો"; string s2 = "દુનિયા"; int પરિણામ = String. Compare(s1, s2); જો (પરિણામ<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result >0) ( Console.WriteLine("Line s1 લાઇન s2 પછી આવે છે"); ) else ( Console.WriteLine("લાઇન s1 અને s2 સરખા છે"); ) // પરિણામ "લાઇન s2 પહેલા લાઇન s1" હશે
સરખામણી પદ્ધતિનું આ સંસ્કરણ બે શબ્દમાળાઓ લે છે અને એક નંબર આપે છે. જો પ્રથમ શબ્દમાળા બીજા કરતાં મૂળાક્ષરોની રીતે ઊંચી હોય, તો શૂન્ય કરતાં ઓછી સંખ્યા પરત કરવામાં આવે છે. નહિંતર, શૂન્ય કરતાં મોટી સંખ્યા પરત કરવામાં આવે છે. અને ત્રીજો કેસ - જો શબ્દમાળાઓ સમાન હોય, તો પછી નંબર 0 પાછો આવે છે.
આ કિસ્સામાં, અક્ષર h અક્ષર w કરતાં મૂળાક્ષર રૂપે ઊંચું હોવાથી, પ્રથમ લાઇન ઊંચી હશે.
શબ્દમાળામાં શોધો
IndexOf પદ્ધતિનો ઉપયોગ કરીને, અમે સ્ટ્રિંગમાં એક અક્ષર અથવા સબસ્ટ્રિંગની પ્રથમ ઘટનાની અનુક્રમણિકા નક્કી કરી શકીએ છીએ:
શબ્દમાળા s1 = "હેલો વર્લ્ડ"; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // 4 Console.WriteLine(indexOfChar); string subString = "wor"; int indexOfSubstring = s1.IndexOf(subString); // 6 કન્સોલની બરાબર.WriteLine(indexOfSubstring);
LastIndexOf પદ્ધતિ એ જ રીતે કામ કરે છે, સિવાય કે તે સ્ટ્રીંગમાં અક્ષર અથવા સબસ્ટ્રિંગની છેલ્લી ઘટનાની અનુક્રમણિકા શોધે છે.
પદ્ધતિઓનું બીજું જૂથ તમને એ શોધવાની મંજૂરી આપે છે કે સ્ટ્રિંગ ચોક્કસ સબસ્ટ્રિંગથી શરૂ થાય છે કે સમાપ્ત થાય છે. StartsWith અને EndsWith પદ્ધતિઓ આ માટે તૈયાર કરવામાં આવી છે. ઉદાહરણ તરીકે, અમારી પાસે ફોલ્ડરમાંથી .exe એક્સ્ટેંશન સાથેની બધી ફાઇલોને કાઢી નાખવાનું કાર્ય છે:
સ્ટ્રિંગ પાથ = @"C:\SomeDir"; string files = Directory.GetFiles(path); માટે (int i = 0; i< files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }
સ્ટ્રિંગ વિભાજન
સ્પ્લિટ ફંક્શનનો ઉપયોગ કરીને આપણે સ્ટ્રીંગને સબસ્ટ્રિંગની એરેમાં વિભાજિત કરી શકીએ છીએ. સ્પ્લિટ ફંક્શન પેરામીટર તરીકે અક્ષરો અથવા શબ્દમાળાઓની શ્રેણી લે છે, જે સીમાંકક તરીકે સેવા આપશે. ઉદાહરણ તરીકે, ચાલો શબ્દમાં શબ્દોની સંખ્યાને સફેદ જગ્યા અક્ષરો દ્વારા વિભાજિત કરીને ગણીએ:
શબ્દમાળા ટેક્સ્ટ = "અને તેથી જ તે બધું થયું"; શબ્દમાળા શબ્દો = ટેક્સ્ટ. સ્પ્લિટ(નવું અક્ષર ( " " )); foreach (શબ્દોમાં શબ્દમાળાઓ) ( Console.WriteLine(s); )
જગ્યાઓ દ્વારા વિભાજિત કરવાની આ શ્રેષ્ઠ રીત નથી, કારણ કે ઇનપુટ સ્ટ્રિંગમાં આપણી પાસે સતત ઘણી જગ્યાઓ હોઈ શકે છે અને પરિણામી એરેમાં પણ જગ્યાઓ હશે, તેથી પદ્ધતિના બીજા સંસ્કરણનો ઉપયોગ કરવો વધુ સારું છે:
શબ્દમાળા શબ્દો = ટેક્સ્ટ. સ્પ્લિટ(નવું ચાર ( " " ), StringSplitOptions.RemoveEmptyEntries);
બીજું પેરામીટર StringSplitOptions.RemoveEmptyEntries કહે છે કે બધી ખાલી સબસ્ટ્રિંગ્સ દૂર કરવી જોઈએ.
એક લાઇન ટ્રિમિંગ
આગળના અથવા પાછળના અક્ષરોને ટ્રિમ કરવા માટે, ટ્રિમ ફંક્શનનો ઉપયોગ કરો:
શબ્દમાળા ટેક્સ્ટ = "હેલો વર્લ્ડ"; text = text.Trim(); // પરિણામ "હેલો વર્લ્ડ" ટેક્સ્ટ = ટેક્સ્ટ. ટ્રિમ(નવું અક્ષર ( "ડી", "એચ" )); // પરિણામ "ello world"
ટ્રિમ ફંક્શન, પેરામીટર્સ વિના, આગળ અને પાછળની જગ્યાઓને ટ્રિમ કરે છે અને ટ્રિમ કરેલી સ્ટ્રિંગ પરત કરે છે. સ્પષ્ટપણે સ્પષ્ટ કરવા માટે કે કયા અગ્રણી અને પાછળના અક્ષરોને ટ્રિમ કરવા જોઈએ, અમે તે અક્ષરોની શ્રેણીને ફંક્શનમાં પસાર કરી શકીએ છીએ.
આ ફંક્શનમાં આંશિક એનાલોગ છે: TrimStart ફંક્શન શરૂઆતના અક્ષરોને ટ્રિમ કરે છે, અને TrimEnd ફંક્શન અંતના અક્ષરોને ટ્રિમ કરે છે.
ટ્રીમ ચોક્કસ ભાગસબસ્ટ્રિંગ ફંક્શન સ્ટ્રિંગ્સ માટે પરવાનગી આપે છે:
શબ્દમાળા ટેક્સ્ટ = "શુભ દિવસ"; // ત્રીજા અક્ષર ટેક્સ્ટ = ટેક્સ્ટ. સબસ્ટ્રિંગ(2) થી શરૂ કરીને કાપી નાખો; // પરિણામ "શુભ દિવસ" કન્સોલ. WriteLine(ટેક્સ્ટ); // છેલ્લા બે અક્ષરોમાં પહેલા કાપો ટેક્સ્ટ = ટેક્સ્ટ. સબસ્ટ્રિંગ(0, ટેક્સ્ટ. લંબાઈ - 2); // પરિણામ "roshy de" Console.WriteLine(text);
સબસ્ટ્રિંગ ફંક્શન પણ કાપેલી સ્ટ્રિંગ પરત કરે છે. વપરાયેલ પ્રથમ સંસ્કરણ પરિમાણ તરીકે અનુક્રમણિકાનો ઉપયોગ કરે છે, જેમાંથી શબ્દમાળાને સુવ્યવસ્થિત કરવી જોઈએ. બીજું સંસ્કરણ બે પરિમાણોનો ઉપયોગ કરે છે - ટ્રિમિંગ સ્ટાર્ટ ઇન્ડેક્સ અને સ્ટ્રિંગના કટ ભાગની લંબાઈ.
દાખલ કરો
એક પંક્તિને બીજી પંક્તિમાં દાખલ કરવા માટે, Insert ફંક્શનનો ઉપયોગ કરો:
શબ્દમાળા ટેક્સ્ટ = "શુભ દિવસ"; string subString = "અદ્ભુત"; text = text.Insert(8, subString); Console.WriteLine(ટેક્સ્ટ);
ઇન્સર્ટ ફંક્શનમાં પ્રથમ પેરામીટર એ અનુક્રમણિકા છે કે જેના પર સબસ્ટ્રિંગ દાખલ કરવી જોઈએ, અને બીજું પેરામીટર એ સબસ્ટ્રિંગ પોતે છે.
પંક્તિઓ દૂર કરી રહ્યા છીએ
દૂર કરો પદ્ધતિ સ્ટ્રિંગના ભાગને દૂર કરવામાં મદદ કરે છે:
શબ્દમાળા ટેક્સ્ટ = "શુભ દિવસ"; // છેલ્લા અક્ષરની અનુક્રમણિકા int ind = text.Length - 1; // છેલ્લું અક્ષર કાપો ટેક્સ્ટ = ટેક્સ્ટ. દૂર કરો(ઇન્ડ); Console.WriteLine(ટેક્સ્ટ); // પહેલા બે અક્ષરો કાપો ટેક્સ્ટ = ટેક્સ્ટ. દૂર કરો(0, 2);
દૂર કરો પદ્ધતિનું પ્રથમ સંસ્કરણ સ્ટ્રિંગમાં એક અનુક્રમણિકા લે છે, જેમાંથી બધા અક્ષરો દૂર કરવા જોઈએ. બીજું સંસ્કરણ એક વધુ પરિમાણ લે છે - કેટલા અક્ષરો દૂર કરવા જોઈએ.
બદલી
એક અક્ષર અથવા સબસ્ટ્રિંગને બીજા સાથે બદલવા માટે, બદલો પદ્ધતિનો ઉપયોગ કરો:
શબ્દમાળા ટેક્સ્ટ = "શુભ દિવસ"; ટેક્સ્ટ = ટેક્સ્ટ.બદલો("સારું", "ખરાબ"); Console.WriteLine(ટેક્સ્ટ); ટેક્સ્ટ = ટેક્સ્ટ.બદલો("o", ""); Console.WriteLine(ટેક્સ્ટ);
રિપ્લેસ ફંક્શનનો ઉપયોગ કરવાના બીજા કિસ્સામાં, એક "o" અક્ષરની સ્ટ્રિંગને ખાલી સ્ટ્રિંગથી બદલવામાં આવે છે, એટલે કે, તે ખરેખર ટેક્સ્ટમાંથી દૂર કરવામાં આવે છે. આ પદ્ધતિ લીટીઓમાં ચોક્કસ ટેક્સ્ટને કાઢી નાખવાનું સરળ બનાવે છે.
કેસ બદલો
સ્ટ્રિંગને અપર અને લોઅર કેસમાં કન્વર્ટ કરવા માટે, અનુક્રમે ToUpper() અને ToLower() ફંક્શનનો ઉપયોગ કરો:
શબ્દમાળા હેલો = "હેલો વર્લ્ડ!"; Console.WriteLine(hello.ToLower()); // હેલો વર્લ્ડ! Console.WriteLine(hello.ToUpper()); // હેલો વર્લ્ડ!
p»їવિશ્વાસપાત્ર SEO એજન્સી ભારત નાના વ્યવસાયોની આવકમાં વધારો કરી શકે છે
80% વપરાશકર્તાઓ ખરીદી કરતા પહેલા Google અને અન્ય સર્ચ એન્જિન પર સર્ચ કરે છે અને સર્ચ એન્જિન દ્વારા જનરેટ કરાયેલી 50% થી વધુ પૂછપરછો કન્વર્ટ થઈ જાય છે. આ બે આંકડા સર્ચ એન્જિન ઓપ્ટિમાઇઝેશનનું મહત્વ સાબિત કરે છે. આવા ઘણા આંકડા અને તથ્યો છે જે સ્પષ્ટ મુદ્દો બનાવે છે: કોઈપણ નાના, મધ્યમ અથવા મોટા સ્કેલવાળા વ્યવસાયને વ્યાવસાયિક SEO સેવાઓની જરૂર હોય છે. નાના વ્યવસાયો અને સ્ટાર્ટઅપ્સને ઘણીવાર બજેટ સમસ્યાઓનો સામનો કરવો પડે છે. તેઓ તેમની આવક વધારવા માટે તેમના બજેટમાં શ્રેષ્ઠ SEO સેવા મેળવવા માટે ભારતની કોઈપણ વિશ્વાસપાત્ર SEO એજન્સીની મદદ લઈ શકે છે.
શોધ ઉપભોક્તાઓના મન પર મોટી અસર કરે છે. સર્ચ એન્જિન લેન્ડ, મોઝ, એસઇઓ જર્નલ, ડિજિટલ માર્કેટર્સ ઇન્ડિયા, હબસ્પોટ વગેરે જેવી વિવિધ અધિકૃત વેબસાઇટ્સ પર મુખ્ય સર્ચ એન્જિન ઓપ્ટિમાઇઝેશન નિષ્ણાતો દ્વારા શેર કરવામાં આવેલા વિવિધ આંકડા અનુસાર. SEO મોટાભાગની લીડ્સ મેળવે છે. ઉપરાંત, કાર્બનિક શોધ પરિણામોમાંથી આવતી લીડ્સમાં રૂપાંતરણ દર વધુ હોય છે. આ આંકડા અને ઉપભોક્તા વર્તણૂક એક સ્પષ્ટ મુદ્દો બનાવે છે કે શ્રેષ્ઠ SEO સેવા એ લક્ઝરી નથી, પરંતુ કોઈપણ વ્યવસાય માટે જરૂરી છે.
હરીફાઈને બાયપાસ કરવા અને વ્યાપાર વૃદ્ધિને વધારવા માટે દરેક સંસ્થાએ શોધ એંજીન ઓપ્ટિમાઇઝેશન સેવાઓનો ઉપયોગ કરવાની જરૂર છે. મોટી બ્રાન્ડ્સ ટોચની SEO કંપની અથવા SEO નિષ્ણાત દ્વારા ઓફર કરવામાં આવતી નિષ્ણાત SEO સેવા માટે પૂરતા નાણાંનું રોકાણ કરી શકે છે, પરંતુ નાના વેપારી માલિકો ઘણીવાર ઓછા બજેટને કારણે આ સેવાની ગુણવત્તા સાથે સમાધાન કરે છે. તે એક કઠણ હકીકત છે કે નાના વ્યવસાય અને સ્ટાર્ટઅપ્સ વ્યાવસાયિક SEO સેવા સાથે સર્જી શકાય તેવી તકો છોડી દે છે અથવા સસ્તી SEO સેવાનો ઉપયોગ કરે છે જે કોઈ હકારાત્મક પરિણામ આપતું નથી.
નાના વેપારીઓ અને સ્ટાર્ટઅપ્સ મર્યાદિત બજેટમાં પણ વ્યાવસાયિક SEO સેવાઓનો લાભ લઈ શકે છે. શ્રેષ્ઠ ઉકેલ એ છે કે ભારતની બહાર આવેલી વિશ્વસનીય SEO કંપની શોધવી. ભારતમાં, ઘણા SEO નિષ્ણાતો છે જેઓ ડિજિટલ માર્કેટિંગ એજન્સી સાથે કામ કરી રહ્યા છે અને ઉદ્યોગમાં શ્રેષ્ઠ સેવાઓ પ્રદાન કરે છે. તેઓ તમને તમારા બજેટમાં જરૂરી SEO સેવાઓ પ્રદાન કરી શકે છે. ઓછા દરે વધુ સારી સેવાઓ મેળવવા માટે એસઇઓ એજન્સી ઇન્ડિયા સાથે વેતન અંગે વાટાઘાટ કરી શકાય છે. જો કે, ઓછી કિંમત લેતી સસ્તી SEO સેવા માટે ન પડો અને વધુ આપવાનું વચન આપો કારણ કે કુશળતા તેના પોતાના ખર્ચે આવે છે. તમારા વ્યવસાય માટે કંપનીને કરાર કરતા પહેલા તમારે પોર્ટફોલિયો જોવો અથવા યોગ્ય પ્રશ્નો પૂછવા આવશ્યક છે.
ભારતમાં એસઇઓ નિષ્ણાતો સર્ચ એન્જિન ઓપ્ટિમાઇઝેશનની શ્રેષ્ઠ પદ્ધતિઓ સાથે કુશળ છે. ઉપરાંત, ભારતમાં કેટલાક એસઇઓ નિષ્ણાતો છે જેમ કે એશ વ્યાસ, જેઓ દર્શાવેલ બજેટમાં વ્યવસાય માટે શ્રેષ્ઠ સર્ચ એન્જિન ઓપ્ટિમાઇઝેશન વ્યૂહરચના બનાવવામાં નિષ્ણાત છે. SEO વ્યાવસાયિકો સ્પષ્ટ યોજના બનાવશે અને અપેક્ષિત પરિણામો શું હોઈ શકે તે પણ શેર કરશે. આ રીતે તમે તમારા રોકાણ અને વળતર વિશે સારી રીતે વાકેફ થઈ શકો છો. આનાથી વધુ સારા બિઝનેસ નિર્ણય લેવામાં મદદ મળે છે.
એક સારો વિચાર એ છે કે ભારતમાંથી એક વિશ્વસનીય SEO કંપનીને શોધવી અને કરાર કરવો કે જે બને તેટલી વહેલી તકે શ્રેષ્ઠ SEO સેવાઓ પ્રદાન કરે. તમે તમારા વેબપૃષ્ઠોને અનુક્રમિત કરવા અને સર્ચ એન્જિનમાં તમારા કીવર્ડને વધારવા માટે નાના બજેટ અને મર્યાદિત પ્રવૃત્તિઓથી પણ પ્રારંભ કરી શકો છો. રાહ ન જુઓ સંપૂર્ણસમય અથવા એક દિવસ જ્યારે તમારી પાસે શ્રેષ્ઠ SEO સેવાઓમાં રોકાણ કરવા માટે હજારો ડોલર હશે. જ્યારે તમે તમારા માર્કેટિંગ અભિગમ સાથે આક્રમક બની શકો છો ત્યારે વહેલા પ્રારંભ કરવાથી તમને ઝડપી પરિણામો મેળવવામાં મદદ મળશે. ભારતની બહાર આવેલી વિશ્વસનીય SEO કંપની તમને સારા પરિણામો લાવવા માટે તમારી વર્તમાન અને ભાવિ યોજનાઓને વ્યાખ્યાયિત કરવામાં મદદ કરશે. વધુ અનુક્રમિત પૃષ્ઠો રેન્કિંગમાં વધારો કરે છે અને સતત વ્યાવસાયિક SEO પ્રેક્ટિસ સાથે બનાવેલ તમારા વ્યવસાયની વિશ્વસનીય બ્રાન્ડ પૂછપરછ, વ્યવસાય અને આવકને બમણી કરશે. કોઈપણ નાના વ્યવસાય વ્યાવસાયિક SEO સેવાઓમાં બે-અંકના રોકાણ સાથે શરૂ થઈ શકે છે. ભારતમાં ઘણી એસઇઓ એજન્સીઓ છે જે ઓછા બજેટની ઓફર કરે છે છતાં લક્ષી સર્ચ એન્જિન ઓપ્ટિમાઇઝેશન સેવાઓનું પરિણામ છે.
દેશનિકાલમાંથી સર્વેક્ષણો
-
ક્રેગવ્યુ
12.04.2018p»ї રિયલ એસ્ટેટ અને સામાન્ય વેચાણમાં ગ્રાહક સાથે સંબંધ સ્થાપિત કરવાનું મહત્વ
ગ્રાહક સાથે સંબંધ સ્થાપિત કરવાનું મહત્વ.
ગ્રાહક સાથે તાલમેલ સ્થાપિત કરવા માટે કમાણી કરવી જોઈએ અને વેચાણ પ્રક્રિયાના અત્યંત અભિન્ન અંગ તરીકે સંપર્ક કરવો જોઈએ.
ગ્રાહક અને તમારી જાતને વાસ્તવિક એકથી એક આધાર પર જોડવા માટે, બે બાબતોનો સમાવેશ થાય છે!
પ્રથમ, તમારે જાગૃત રહેવું પડશે અને ત્યાં રહેવું પડશે! બીજું તમારે સમજવું જોઈએ કે આ પ્રક્રિયા દરમિયાન બે જુદા જુદા તબક્કાઓ આવશે.
A-ત્યાં રહો-તેનો અર્થ શું છે?
o મોટા ભાગના લોકો જ્યારે અન્ય વ્યક્તિ વાત કરે છે ત્યારે તેને સાંભળતા નથી. સામાન્ય રીતે તેઓ તેમના આગામી જવાબ અથવા નિવેદનની રચના કરવામાં એટલા વ્યસ્ત હોય છે કે તેઓ કદાચ ખરેખર સાંભળી શકતા નથી.
o જો આ તમારા જેવું લાગે છે, તો ત્યાં હોવાનો અર્થ એ છે કે ચૂપ રહો અને સાંભળો!
B-પ્રથમ કે પ્રારંભિક તબક્કો શું છે?
o સામાન્ય રીતે તમારી પાસે ગ્રાહકોના મનમાં પોતાને એવી વ્યક્તિ તરીકે સ્થાપિત કરવા માટે માત્ર થોડી મિનિટો હોય છે જેની સાથે તેઓ વ્યવહાર કરવા માગે છે.
o જ્યારે શંકા હોય ત્યારે પ્રથમ એવા પ્રશ્નો પૂછવા શ્રેષ્ઠ છે જે તેમને બહાર કાઢશે અને પોતાના વિશે વાત કરશે.
o પ્રોફેશનલ તરીકે દેખાવાનું પણ હંમેશા સલામત છે-મારો મતલબ ઉદાસીન કે શુષ્ક નથી, પરંતુ કોઈ વ્યક્તિ જે જાણે છે કે તેઓ શું કરી રહ્યા છે અને વાત કરે છે અને ભાગ જુએ છે.
સી-અન્ય તબક્કાઓ
o જેમ જેમ સમય પસાર થાય છે તેમ તેમ વાતચીત અને પ્રશ્નો દ્વારા તમે તમારી ક્ષમતા સ્થાપિત કરશો કે નહીં.
o ધ્યાન રાખો કે તેઓ કદાચ થોડા સમય માટે તમને માપતા હશે. સારા સમાચાર એ છે કે અમુક સમયે, જો તમે સંબંધ સ્થાપિત કરવામાં સફળ થયા હોવ તો-તેઓ આરામ કરશે અને તમે બંને ઘર શોધવા અથવા વેચવા પર ધ્યાન કેન્દ્રિત કરી શકો છો.
સંબંધ વિકસાવવામાં મને બીજું શું મદદ કરી શકે?
o વિવિધ પ્રકારના વ્યક્તિત્વને સમજવાનો પ્રયાસ કરીને અને પછી કહીને અને યોગ્ય પ્રશ્નો પૂછીને.
o જો તમારી પાસે સારો તાલમેલ છે (ગ્રાહકની જેમ જ વેવ લેન્થ પર મેળવો) તો વેચાણ મૂળભૂત રીતે સમાપ્ત થઈ ગયું છે, હવે તે માત્ર યોગ્ય ઘર શોધવાની અથવા લિસ્ટિંગ પેપર્સ ભરવાની બાબત છે.
વિવિધ વ્યક્તિત્વ વિશે શું
o આ મનોચિકિત્સા પરનું પુસ્તક ન હોવાથી, હમણાં માટે ફક્ત બે મુખ્ય પ્રકારો સમજો.
o ત્યાં અંતર્મુખી અને બહિર્મુખ લોકો છે.
o તમે પ્રકાર જાણો છો. તમે જાણો છો એવા ત્રણ લોકો વિશે વિચારો જે દરેક વર્ગીકરણને અનુરૂપ છે.
બોડી લેંગ્વેજ અને સ્પીચ પેટર્ન વિશે શું?
o જો તેઓ ઝડપી અથવા ધીમી વાત કરે છે, તો તેમની વાણીની રીતની નકલ કરવાનો પ્રયાસ કરો.
o જો તેઓ મોટેથી અથવા નરમ બોલે છે, તો તે જ કરો. શું તેઓ આગળ કે પાછળ ઝુકેલા છે?
o કહેવાની જરૂર નથી કે આ વિષય પર ઘણાં પુસ્તકો લખાયેલા છે. ફક્ત ધ્યાન રાખો કે તે એક મહત્વપૂર્ણ પરિબળ છે-ખાસ કરીને જ્યારે તમે કોન્ફરન્સ રૂમમાં અથવા કોઈના ઘરે $400,000ના સોદાની ચર્ચા કરતા હો ત્યારે.
તાલમેલ વિકસાવવો એ એક કૌશલ્ય છે જે શીખી શકાય છે અને સુધારી શકાય છે.
o આપણે બધાએ સેલ્સપર્સનનો અનુભવ કર્યો છે જેણે અમને કંઈક વેચ્યું છે અને છતાં અમને એવું લાગ્યું નથી કે અમે વેચાઈ રહ્યા છીએ. કારણ એ છે કે તે અથવા તેણીએ, જ્યાં તમે તેમના પર વિશ્વાસ કર્યો હતો ત્યાં તમને આરામદાયક લાગે છે.
આપણે સંબંધ કેવી રીતે વિકસાવીએ?
o તમારી આંખો અને કાનનો ઉપયોગ કરો અને પ્રશ્નો પૂછો. સમજાવવું
o આંખોનો ઉપયોગ કરો:
o તેમના ડ્રેસ-તેમની કાર-તેમની અંગત સંપત્તિ જુઓ અને મારો મતલબ છે કે ખરેખર તેમને જુઓ અને તેમના વિશે તમને શું કહે છે તે સમજાવો.
o કાનનો ઉપયોગ કરો:
o તેઓ શું કહે છે તે સાંભળો અને તેમના વાસ્તવિક પ્રેરણાના તળિયે જવા માટે પ્રશ્નો પૂછો!
હવે આ બધી વાતચીત દરમિયાન, સંભવતઃ એક કે બે વસ્તુઓ એવી હશે જે તમે શોધી શકશો કે તમારી તેમની સાથે સમાનતા છે. (કુટુંબ, ભૌગોલિક વિસ્તારો, માછીમારી, વગેરે) જ્યારે તમે સામાન્ય મેદાન પર આવો, ત્યારે તેમને જણાવો કે તમે પરિચિત છો અને પછી તેમની સાથે ચર્ચા કરવા માટે એક મિનિટ કાઢો.
ધ્યેય શું છે?
o એકવાર તેઓ તમને તેમાંથી એક તરીકે સ્વીકારી લે તે પછી તમે વેચાણમાં ખરેખર સારો અનુભવ મેળવવાની સ્થિતિમાં છો કારણ કે તમે હવે સાથે મળીને કામ કરી રહ્યા છો અને પછી એક ટીમ તરીકે- તમે હવે સલાહકાર સ્થિતિમાં છો તે સેલ્સમેન નથી. .
o યાદ રાખો, ગ્રાહક કાં તો તમને તેની દુનિયામાં પ્રવેશવા દેશે કે નહિ. જો તમે આ સમજો છો અને તેની સાથે સહાનુભૂતિ રાખવા માટે ખરેખર સખત મહેનત કરો છો, તો તમે વિશ્વાસનું સ્થાન મેળવી શકો છો. મોટાભાગના કિસ્સાઓમાં, જ્યારે તમે રસ્તામાં હોવ ત્યારે તમે ખરેખર તેમને આરામ (બોડી લેંગ્વેજ) જોશો.
o આને સમજાવવા માટે શું તમે ક્યારેય ભાષણ આપ્યું છે અને નોંધ્યું છે કે તમે આખરે પ્રેક્ષક સભ્ય સાથે જોડાયેલા છો ત્યારે તેઓ મંજૂરીમાં હકાર કરશે. આ બધી વસ્તુઓ તુચ્છ લાગે છે પરંતુ તે નથી.
અંતમાં, જો તમે ગ્રાહકોનો વિશ્વાસ મેળવી શકો છો, તો ઉત્પાદન અથવા સેવાનું વેચાણ કરવું વધુ સરળ છે અને તેમાં સામેલ દરેક માટે અનુભવ આનંદદાયક હોઈ શકે છે.
હંમેશા યાદ રાખો કે જીત/જીત એ શ્રેષ્ઠ પરિસ્થિતિ છે.
હું આના જેવી સ્ટ્રિંગ સાથે અક્ષર એરેની તુલના કરવાનો પ્રયાસ કરી રહ્યો છું:
કોન્સ્ટ ચાર *var1 = ""; var1 = getenv("myEnvVar"); if(var1 == "dev") ( // do stuff )
આ જો સ્ટેટમેન્ટ ક્યારેય સાચું પડતું નથી... જ્યારે હું var1 આઉટપુટ કરું છું ત્યારે તે "dev" છે, મેં વિચાર્યું કે કદાચ તેનો નલ ટર્મિનેટેડ સ્ટ્રિંગ સાથે કંઈક સંબંધ છે પરંતુ strlen "dev" અને var1 સમાન છે... મેં એમ પણ વિચાર્યું કે કદાચ var1 = = "dev" મૂલ્યને બદલે var1 ના મેમરી સરનામા સાથે "dev" ની સરખામણી કરી રહ્યું હતું. *var1 == "dev" એ ભૂલમાં પરિણમે છે.... ઘણી બધી વસ્તુઓ અજમાવી, કદાચ સમજદાર C++ ડેવલપર માટે એક સરળ ઉપાય (મેં ઘણા સમયથી C++ કોડ કર્યા નથી).
સંપાદિત કરો: અમે પ્રયાસ કર્યો
જો(strcmp(var1, "dev") == 0)
જો(strncmp(var1, "dev", 3) == 0)
સંપાદિત કરો: ઘરે પરીક્ષણ કર્યા પછી, હું ફક્ત સૂચન કરું છું કે મારા સહકાર્યકર ડેટા પ્રકારને સ્ટ્રિંગમાં બદલો. હું માનું છું કે તે સ્ટ્રિંગ સાથે મોટા કદના ચાર એરેની તુલના કરી રહ્યો હતો. મેં એક પ્રોગ્રામ એકસાથે મૂક્યો છે જે અમને આમાં મદદ કરવા માટે sizeof, strlen વગેરે પ્રિન્ટ કરે છે. તમારી મદદ માટે દરેકનો આભાર.
6 જવાબો
તમે શબ્દમાળાઓ સાથે કામ કરતા નથી. તમે પોઇન્ટર સાથે કામ કરી રહ્યા છો.
var1 એ ચાર પોઇન્ટર છે (const char*). આ એક શબ્દમાળા નથી. જો તે નલ-ટર્મિનેટેડ છે, તો કેટલાક C ફંક્શન્સ તેને સ્ટ્રિંગ તરીકે ગણશે, પરંતુ તે મૂળભૂત રીતે માત્ર એક નિર્દેશક છે.
તેથી જ્યારે તમે તેને char એરે સાથે સરખાવો છો, ત્યારે એરે પોઇન્ટરમાં તૂટી જાય છે અને પછી કમ્પાઇલર ઓપરેટર == (const char*, const char*) શોધવાનો પ્રયાસ કરે છે.
આવા ઓપરેટર અસ્તિત્વમાં છે. તે બે પોઇન્ટર સ્વીકારે છે અને જો તેઓ સમાન સરનામાં તરફ નિર્દેશ કરે છે તો તે સાચું પરત કરે છે. તેથી કમ્પાઈલર આને બોલાવે છે અને તમારો કોડ તૂટી જાય છે.
જો તમે સ્ટ્રીંગ સરખામણી કરવા માંગતા હો, તો તમારે કમ્પાઈલરને જણાવવું જોઈએ કે તમે સ્ટ્રીંગ્સ સાથે કામ કરવા માંગો છો, પોઈન્ટર્સ સાથે નહીં.
આ કરવા માટે તમારે strcmp ફંક્શનનો ઉપયોગ કરવાની જરૂર છે:
Strcmp(var1, "dev");
જો બે શબ્દમાળાઓ સમાન હોય તો આ નલ પરત કરે છે. (જો ડાબી બાજુ જમણી બાજુ કરતાં લેક્સિકોગ્રાફિકલી મોટી હોય તો તે શૂન્ય કરતાં વધુ મૂલ્ય આપશે અને અન્યથા શૂન્ય કરતાં ઓછું મૂલ્ય આપશે.)
તેથી સમાનતા માટે સરખામણી કરવા માટે તમારે નીચેનામાંથી એક કરવાની જરૂર છે:
જો (!strcmp(var1, "dev"))(...) જો (strcmp(var1, "dev") == 0) (...)
ધોરણ::સ્ટ્રિંગ var1 = getenv("myEnvVar"); if(var1 == "dev") ( // do stuff )
કમ્પાઈલર હવે સ્ટ્રીંગ અને ચાર પોઈન્ટર વચ્ચેની સરખામણીનો સામનો કરે છે. તે આને હેન્ડલ કરી શકે છે કારણ કે ચાર પોઇન્ટરને સ્ટ્રિંગમાં રૂપાંતરિત કરી શકાય છે, સ્ટ્રિંગ-ટુ-સ્ટ્રિંગ સરખામણી આપીને. અને તેઓ તમારી અપેક્ષા મુજબ વર્તે છે.
આ કોડમાં તમે સ્ટ્રિંગ વેલ્યુની સરખામણી કરી રહ્યાં નથી, તમે પોઈન્ટર વેલ્યુની સરખામણી કરી રહ્યાં છો. જો તમે સ્ટ્રિંગ વેલ્યુની સરખામણી કરવા માંગો છો, તો તમારે સ્ટ્રિંગ કમ્પેરિઝન ફંક્શનનો ઉપયોગ કરવાની જરૂર છે જેમ કે strcmp.
જો (0 == strcmp(var1, "dev")) ( .. )
"dev" એ સ્ટ્રિંગ નથી, તે var1 ની જેમ const char* છે. આ રીતે તમે ખરેખર મેમરી એડ્રેસની સરખામણી કરી રહ્યા છો. તે var1 એ ચાર પોઇન્ટર છે, *var1 એ એક અક્ષર છે (વધુ સ્પષ્ટ રીતે, ઉલ્લેખિત અક્ષર ક્રમનું પ્રથમ અક્ષર). તમે ચાર પોઇન્ટર સાથે ચારની તુલના કરી શકતા નથી, તેથી તે કામ કરતું નથી અને હેડરમાં ઘોષણા ઉમેરો
// પરિમાણ શક્ય ઑબ્જેક્ટ ભ્રષ્ટાચારને રોકવા માટે "const" નો ઉપયોગ કરે છે. bool string_equal (const char* arg0, const char* arg1);
ઉપયોગ કરવા માટે, જો (અથવા તૃણ) સ્ટેટમેન્ટ/બ્લોકની શરત તરીકે ફક્ત "string_equal" પર કૉલ કરો.
જો (string_equal (var1, "dev")) ( // તે સમાન છે, અહીં જે જરૂરી છે તે કરો. ) બીજું ( // તે સમાન નથી, અહીં જે જરૂરી છે તે કરો (વૈકલ્પિક). )
34--- C# માર્ગદર્શિકા --- શબ્દમાળાઓ
નિયમિત પ્રોગ્રામિંગ દૃષ્ટિકોણથી, શબ્દમાળા સ્ટ્રિંગ ડેટા પ્રકાર C# માં સૌથી મહત્વપૂર્ણ પૈકીનું એક છે. આ પ્રકાર અક્ષર શબ્દમાળાઓને વ્યાખ્યાયિત કરે છે અને સપોર્ટ કરે છે. સંખ્યાબંધ અન્ય પ્રોગ્રામિંગ ભાષાઓમાં, સ્ટ્રિંગ એ અક્ષરોની શ્રેણી છે. અને C# માં, શબ્દમાળાઓ વસ્તુઓ છે. તેથી, શબ્દમાળા પ્રકાર એ સંદર્ભ પ્રકાર છે.
બિલ્ડીંગ સ્ટ્રીંગ્સ
અક્ષર શબ્દમાળા બનાવવાની સૌથી સરળ રીત શબ્દમાળા શબ્દમાળાનો ઉપયોગ કરવાનો છે. ઉદાહરણ તરીકે, કોડની નીચેની લાઇન સ્ટ્રિંગ રેફરન્સ વેરીએબલને સ્ટ્રિંગ શાબ્દિકનો સંદર્ભ અસાઇન કરે છે:
શબ્દમાળા str = "ઉદાહરણ શબ્દમાળા";
આ કિસ્સામાં, ચલ str ને અક્ષરોના ક્રમ "ઉદાહરણ સ્ટ્રિંગ" સાથે પ્રારંભ કરવામાં આવે છે. ટાઇપ સ્ટ્રિંગનો ઑબ્જેક્ટ ચાર પ્રકારના એરેમાંથી પણ બનાવી શકાય છે. દાખ્લા તરીકે:
Char chararray = ("e", "x", "a", "m", "p", "l", "e"); સ્ટ્રિંગ str = નવી સ્ટ્રિંગ(chararray);
એકવાર સ્ટ્રિંગ ઑબ્જેક્ટ બનાવવામાં આવે તે પછી, તમારે અવતરણમાં બંધ કરેલ ટેક્સ્ટની સ્ટ્રિંગની જરૂર હોય ત્યાં તેનો ઉપયોગ કરી શકાય છે.
શબ્દમાળા દ્રઢતા
વિચિત્ર રીતે, સ્ટ્રિંગ પ્રકારના ઑબ્જેક્ટની સામગ્રી બદલી શકાતી નથી. આનો અર્થ એ છે કે એકવાર અક્ષર ક્રમ બનાવવામાં આવે છે, તે બદલી શકાતો નથી. પરંતુ આ મર્યાદા અક્ષર શબ્દમાળાઓના વધુ કાર્યક્ષમ અમલીકરણમાં ફાળો આપે છે. તેથી, આ દેખીતી રીતે દેખીતી ગેરલાભ વાસ્તવમાં ફાયદામાં ફેરવાય છે. આમ, જો હાલની સ્ટ્રિંગના ભિન્નતા તરીકે સ્ટ્રિંગની આવશ્યકતા હોય, તો આ હેતુ માટે તમામ જરૂરી ફેરફારો ધરાવતી નવી સ્ટ્રિંગ બનાવવી જોઈએ. અને બિનઉપયોગી સ્ટ્રિંગ ઑબ્જેક્ટ્સ આપમેળે કચરા તરીકે એકત્રિત થાય છે, ભાવિ ભાગ્યતમારે બિનજરૂરી રેખાઓ વિશે પણ ચિંતા કરવાની જરૂર નથી.
જો કે, એ વાત પર ભાર મૂકવો જોઈએ કે શબ્દમાળાઓના ચલ સંદર્ભો (એટલે કે, સ્ટ્રિંગના પ્રકારો) ફેરફારને આધીન છે, અને તેથી તેઓ અન્ય ઑબ્જેક્ટનો સંદર્ભ લઈ શકે છે. પરંતુ સ્ટ્રિંગ ઑબ્જેક્ટના સમાવિષ્ટો તે બનાવ્યા પછી બદલાતા નથી.
ચાલો એક ઉદાહરણ જોઈએ:
સ્થિર રદબાતલ addNewString() ( સ્ટ્રિંગ s = "આ મારો સ્ટ્રોક છે"; s = "આ નવો સ્ટ્રોક છે";)
ચાલો એપ્લિકેશનને કમ્પાઈલ કરીએ અને પરિણામી એસેમ્બલીને ildasm.exe ઉપયોગિતામાં લોડ કરીએ. આકૃતિ CIL કોડ બતાવે છે જે રદબાતલ addNewString() પદ્ધતિ માટે જનરેટ કરવામાં આવશે:
નોંધ કરો કે ldstr (લોડ સ્ટ્રિંગ) opcode પર અસંખ્ય કૉલ્સ છે. આ CIL ldstr opcode વ્યવસ્થાપિત ઢગલા પર નવા સ્ટ્રિંગ ઑબ્જેક્ટનું લોડિંગ કરે છે. પરિણામે, અગાઉના ઑબ્જેક્ટ કે જેમાં "આ મારો સ્ટ્રોક છે" નું મૂલ્ય હતું તે આખરે કચરો એકત્રિત કરવામાં આવશે.
સ્ટ્રીંગ્સ સાથે કામ કરવું
વર્ગ માં સિસ્ટમ.સ્ટ્રિંગકેરેક્ટર ડેટાની લંબાઈ નક્કી કરવા, વર્તમાન સ્ટ્રિંગમાં સબસ્ટ્રિંગ શોધવા, અક્ષરોને અપરકેસમાંથી લોઅરકેસમાં કન્વર્ટ કરવા વગેરે માટે પદ્ધતિઓનો સમૂહ આપવામાં આવે છે. આગળ આપણે આ વર્ગને વધુ વિગતવાર જોઈશું.
ફીલ્ડ, ઈન્ડેક્સર અને સ્ટ્રિંગ ક્લાસ પ્રોપર્ટી
શબ્દમાળા વર્ગ એક જ ક્ષેત્રને વ્યાખ્યાયિત કરે છે:
પબ્લિક સ્ટેટિક ફક્ત વાંચવા માટે સ્ટ્રિંગ ખાલી;
ખાલી ક્ષેત્ર ખાલી સ્ટ્રિંગ સૂચવે છે, એટલે કે. એક શબ્દમાળા જેમાં કોઈપણ અક્ષરો નથી. આ ખાલી સ્ટ્રિંગ સંદર્ભથી અલગ છે, જે ફક્ત અસ્તિત્વમાં નથી તેવા ઑબ્જેક્ટ માટે બનાવવામાં આવે છે.
વધુમાં, સ્ટ્રિંગ ક્લાસ એક સિંગલ-રીડ-ઓન્લી ઈન્ડેક્સરને વ્યાખ્યાયિત કરે છે:
જાહેર ચાર આ ( મેળવો; )
આ ઇન્ડેક્સર તમને ચોક્કસ અનુક્રમણિકા પર એક અક્ષર મેળવવા માટે પરવાનગી આપે છે. શબ્દમાળાઓનું અનુક્રમણિકા, એરેની જેમ, શૂન્યથી શરૂ થાય છે. સ્ટ્રિંગ ઑબ્જેક્ટ્સ સતત હોય છે અને બદલાતા નથી, તેથી તે અર્થપૂર્ણ છે કે સ્ટ્રિંગ વર્ગ ફક્ત વાંચવા માટેના ઇન્ડેક્સરને સપોર્ટ કરે છે.
છેલ્લે, સ્ટ્રિંગ ક્લાસ સિંગલ-ઓન્લી-રીડ પ્રોપર્ટી વ્યાખ્યાયિત કરે છે:
જાહેર પૂર્ણાંક લંબાઈ ( મેળવો; )
લંબાઈ ગુણધર્મ શબ્દમાળામાં અક્ષરોની સંખ્યા પરત કરે છે. નીચેનું ઉદાહરણ ઇન્ડેક્સર અને લેન્થ પ્રોપર્ટીનો ઉપયોગ દર્શાવે છે:
સિસ્ટમનો ઉપયોગ; વર્ગનું ઉદાહરણ ( static void Main() ( string str = "Simple string"; // indexer Console.WriteLine("સ્ટ્રિંગની લંબાઈ - (0), 6ઠ્ઠી અક્ષર - "(1)"" , str.Length, str);
સ્ટ્રિંગ ક્લાસ ઓપરેટર્સ
સ્ટ્રિંગ વર્ગ નીચેના બે ઓપરેટરોને ઓવરલોડ કરે છે: == અને !=. == ઓપરેટરનો ઉપયોગ સમાનતા માટે બે અક્ષરના તાર ચકાસવા માટે થાય છે. જ્યારે ઑબ્જેક્ટ સંદર્ભો પર == ઑપરેટર લાગુ કરવામાં આવે છે, ત્યારે તે સામાન્ય રીતે પરીક્ષણ કરે છે કે શું બંને સંદર્ભો એક જ ઑબ્જેક્ટ માટે બનાવવામાં આવ્યા છે. અને જ્યારે == ઑપરેટર સ્ટ્રિંગ પ્રકારના ઑબ્જેક્ટના સંદર્ભો પર લાગુ થાય છે, ત્યારે સમાનતા માટે સ્ટ્રિંગ્સના સમાવિષ્ટોની તુલના કરવામાં આવે છે. આ જ != ઓપરેટરને લાગુ પડે છે. જ્યારે તે સ્ટ્રિંગ પ્રકારનાં ઑબ્જેક્ટ્સના સંદર્ભો પર લાગુ થાય છે, ત્યારે સ્ટ્રિંગના સમાવિષ્ટોની તુલના અસમાનતા માટે કરવામાં આવે છે. જો કે, અન્ય રીલેશનલ ઓપરેટરો, જેમાં = સહિત, સ્ટ્રિંગ પ્રકારના ઓબ્જેક્ટના સંદર્ભોની સરખામણી તે જ રીતે કરે છે જે રીતે તેઓ અન્ય પ્રકારની વસ્તુઓ સાથે સંદર્ભોની તુલના કરે છે. અને એક સ્ટ્રિંગ બીજી કરતાં મોટી છે કે કેમ તે ચકાસવા માટે, તમારે સ્ટ્રિંગ ક્લાસમાં વ્યાખ્યાયિત Compare() પદ્ધતિને કૉલ કરવો જોઈએ.
જેમ સ્પષ્ટ થઈ જશે, ઘણા પ્રકારની અક્ષર સ્ટ્રિંગ સરખામણીઓ સાંસ્કૃતિક માહિતી પર આધાર રાખે છે. પરંતુ આ == અને != ઓપરેટરોને લાગુ પડતું નથી. છેવટે, તેઓ ફક્ત શબ્દમાળાઓમાં અક્ષરોના સામાન્ય મૂલ્યોની તુલના કરે છે. (બીજા શબ્દોમાં કહીએ તો, તેઓ અક્ષરોના દ્વિસંગી મૂલ્યોની તુલના કરે છે જે સાંસ્કૃતિક ધોરણો દ્વારા સંશોધિત કરવામાં આવ્યા નથી, એટલે કે, લોકેલ ધોરણો.) તેથી, આ ઓપરેટરો કેસ-સંવેદનશીલ અને સંસ્કૃતિ-સંવેદનશીલ રીતે સ્ટ્રિંગ સરખામણી કરે છે.
શબ્દમાળા વર્ગ પદ્ધતિઓ
નીચેનું કોષ્ટક આ વર્ગની કેટલીક સૌથી રસપ્રદ પદ્ધતિઓની યાદી આપે છે, જે હેતુ દ્વારા જૂથબદ્ધ છે:
| પદ્ધતિ | માળખું અને ઓવરલોડ્સ | હેતુ |
|---|---|---|
| શબ્દમાળા સરખામણી | ||
| તુલના() | સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, સ્ટ્રિંગ strB) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, સ્ટ્રિંગ strB, bool ignoreCase) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, સ્ટ્રિંગ strB, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, સ્ટ્રિંગ strB, bool ignoreCase, CultureInfo સંસ્કૃતિ) |
સ્થિર પદ્ધતિ સ્ટ્રિંગ strA ને સ્ટ્રિંગ strB સાથે સરખાવે છે. જો strA strB કરતા વધારે હોય તો હકારાત્મક મૂલ્ય પરત કરે છે; નકારાત્મક જો strA strB કરતા ઓછું હોય; અને શૂન્ય જો strA અને strB સમાન હોય. સરખામણી રજીસ્ટર અને સંસ્કૃતિના આધારે કરવામાં આવે છે. જો ignoreCase સાચું મૂલ્યાંકન કરે છે, તો સરખામણી અપરકેસ અને લોઅરકેસ અક્ષરો વચ્ચેના તફાવતોને ધ્યાનમાં લેતી નથી. નહિંતર, આ તફાવતો ધ્યાનમાં લેવામાં આવે છે. comparisonType પેરામીટર સ્પષ્ટ કરે છે કે જે રીતે સ્ટ્રિંગ્સની સરખામણી કરવામાં આવે છે. CultureInfo વર્ગ સિસ્ટમ.ગ્લોબલાઇઝેશન નેમસ્પેસમાં વ્યાખ્યાયિત થયેલ છે. |
| સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, int indexA, સ્ટ્રિંગ strB, int indexB, int લંબાઈ) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, int indexA, સ્ટ્રિંગ strB, int indexB, int લંબાઈ, bool ignoreCase) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, int indexA, સ્ટ્રિંગ strB, int indexB, int લંબાઈ, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) સાર્વજનિક સ્થિર પૂર્ણાંક સરખામણી (સ્ટ્રિંગ strA, int indexA, સ્ટ્રિંગ strB, int indexB, int લંબાઈ, bool ignoreCase, CultureInfo સંસ્કૃતિ) |
strA અને strB ના ભાગોની સરખામણી કરે છે. સરખામણી સ્ટ્રિંગ એલિમેન્ટ્સ strA અને strB સાથે શરૂ થાય છે અને તેમાં લંબાઈ પેરામીટર દ્વારા ઉલ્લેખિત અક્ષરોની સંખ્યા શામેલ છે. જો સ્ટ્રિંગ strA નો ભાગ સ્ટ્રિંગ strB ના ભાગ કરતા મોટો હોય તો પદ્ધતિ હકારાત્મક મૂલ્ય આપે છે; નકારાત્મક મૂલ્ય જો સ્ટ્રિંગ strA નો ભાગ શબ્દમાળા strB ના ભાગ કરતા ઓછો હોય; અને શૂન્ય જો strA અને strB ના ભાગો સરખા હોય તો. સરખામણી રજીસ્ટર અને સંસ્કૃતિના આધારે કરવામાં આવે છે. |
|
| CompareOrdinal() | પબ્લિક સ્ટેટિક int CompareOrdinal(સ્ટ્રિંગ strA, સ્ટ્રિંગ strB) પબ્લિક સ્ટેટિક int CompareOrdinal(સ્ટ્રિંગ strA, int indexA, string strB, int indexB, int કાઉન્ટ) |
Compare() પદ્ધતિ જેવું જ કરે છે, પરંતુ સ્થાનિક સેટિંગ્સને ધ્યાનમાં લીધા વિના |
| સરખામણીમાં() | પબ્લિક ઈન્ટ CompareTo(ઓબ્જેક્ટ વેલ્યુ) | વેલ્યુ ઑબ્જેક્ટની સ્ટ્રિંગ રજૂઆત સાથે કૉલિંગ સ્ટ્રિંગની તુલના કરે છે. જો કૉલિંગ સ્ટ્રિંગ મૂલ્ય કરતાં વધુ હોય તો હકારાત્મક મૂલ્ય પરત કરે છે; જો કૉલિંગ સ્ટ્રિંગ મૂલ્ય કરતાં ઓછી હોય તો નકારાત્મક; અને જો તુલનાત્મક તાર સમાન હોય તો શૂન્ય |
| પબ્લિક int CompareTo(સ્ટ્રિંગ strB) | કૉલિંગ સ્ટ્રિંગને સ્ટ્રિંગ strB સાથે સરખાવે છે |
|
| બરાબર() | સાર્વજનિક ઓવરરાઇડ બૂલ સમાન (ઑબ્જેક્ટ ઑબ્જેક્ટ) | જો કૉલિંગ સ્ટ્રિંગમાં obj ની સ્ટ્રિંગ રજૂઆતની જેમ અક્ષરોનો સમાન ક્રમ હોય તો બુલિયન સાચું પરત કરે છે. કેસ-સંવેદનશીલ પરંતુ સાંસ્કૃતિક રીતે અસંવેદનશીલ એવી સામાન્ય સરખામણી કરે છે |
| સાર્વજનિક બૂલ સમાન (સ્ટ્રિંગ મૂલ્ય) સાર્વજનિક બૂલ સમાન (સ્ટ્રિંગ મૂલ્ય, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) |
જો કૉલિંગ સ્ટ્રિંગમાં સ્ટ્રિંગ મૂલ્યની જેમ અક્ષરોનો સમાન ક્રમ હોય તો બુલિયન મૂલ્ય સાચું પરત કરે છે. એક સામાન્ય સરખામણી કરવામાં આવે છે જે કેસ સંવેદનશીલ હોય છે પરંતુ સાંસ્કૃતિક રીતે સંવેદનશીલ નથી. comparisonType પેરામીટર સ્પષ્ટ કરે છે કે જે રીતે સ્ટ્રિંગ્સની સરખામણી કરવામાં આવે છે |
|
| સાર્વજનિક સ્થિર બૂલ સમાન (સ્ટ્રિંગ એ, સ્ટ્રિંગ બી) સાર્વજનિક સ્થિર બૂલ સમાન (સ્ટ્રિંગ એ, સ્ટ્રિંગ બી, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) |
જો સ્ટ્રિંગ a માં સ્ટ્રિંગ b જેવા અક્ષરોનો સમાન ક્રમ હોય તો બુલિયન મૂલ્ય સાચું પરત કરે છે. એક સામાન્ય સરખામણી કરવામાં આવે છે જે કેસ સંવેદનશીલ હોય છે પરંતુ સાંસ્કૃતિક રીતે સંવેદનશીલ નથી. comparisonType પરિમાણ સ્પષ્ટ કરે છે કે જે રીતે સ્ટ્રિંગ્સની સરખામણી કરવામાં આવે છે |
|
| શબ્દમાળાઓનું જોડાણ (જોડાણ). | ||
| કોન્કેટ() | પબ્લિક સ્ટેટિક સ્ટ્રિંગ કોન્કેટ (સ્ટ્રિંગ str0, સ્ટ્રિંગ str1); સાર્વજનિક સ્ટેટિક સ્ટ્રિંગ કોન્કેટ (પરમ સ્ટ્રિંગ મૂલ્યો); |
એકલ સ્ટ્રિંગ (સંકલન) માં વ્યક્તિગત સ્ટ્રિંગ ઉદાહરણોને જોડે છે |
| શબ્દમાળામાં શોધો | ||
| સમાવે છે() | સાર્વજનિક બૂલમાં સમાવે છે (સ્ટ્રિંગ મૂલ્ય) | એક પદ્ધતિ જે તમને સ્ટ્રિંગમાં ચોક્કસ સબસ્ટ્રિંગ (મૂલ્ય) છે કે નહીં તે નિર્ધારિત કરવાની મંજૂરી આપે છે. |
| સાથે શરૂ થાય છે() | જાહેર બૂલ StartsWith(સ્ટ્રિંગ મૂલ્ય) સાર્વજનિક બૂલ StartsWith(સ્ટ્રિંગ મૂલ્ય, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) |
જો કૉલિંગ સ્ટ્રિંગ સબસ્ટ્રિંગ મૂલ્યથી શરૂ થાય તો બુલિયન મૂલ્ય સાચું પરત કરે છે. નહિંતર, બુલિયન મૂલ્ય ફોલ્સ પરત કરવામાં આવે છે. comparisonType પરિમાણ શોધ કરવા માટે ચોક્કસ રીતનો ઉલ્લેખ કરે છે |
| સાથે સમાપ્ત થાય છે() | પબ્લિક બૂલ એન્ડસવિથ(સ્ટ્રિંગ વેલ્યુ) સાર્વજનિક બૂલ સમાપ્ત થાય છે(સ્ટ્રિંગ મૂલ્ય, સ્ટ્રિંગ સરખામણી સરખામણી પ્રકાર) |
જો કૉલિંગ સ્ટ્રિંગ સબસ્ટ્રિંગ મૂલ્ય સાથે સમાપ્ત થાય તો બુલિયન મૂલ્ય સાચું પરત કરે છે. નહિંતર, બુલિયન મૂલ્ય ખોટું પરત કરે છે. comparisonType પરિમાણ ચોક્કસ શોધ પદ્ધતિનો ઉલ્લેખ કરે છે |
| ની અનુક્રમણિકા() | જાહેર ઈન્ડેક્સઓફ(ચાર મૂલ્ય) સાર્વજનિક int IndexOf(સ્ટ્રિંગ મૂલ્ય) |
સ્ટ્રિંગમાં આપેલ સબસ્ટ્રિંગ અથવા અક્ષરની પ્રથમ ઘટના શોધે છે. જો શોધાયેલ અક્ષર અથવા સબસ્ટ્રિંગ ન મળે, તો મૂલ્ય -1 પરત કરવામાં આવે છે. |
| સાર્વજનિક int IndexOf(ચાર મૂલ્ય, પૂર્ણાંક સ્ટાર્ટ ઇન્ડેક્સ) સાર્વજનિક int IndexOf(સ્ટ્રિંગ વેલ્યુ, int startIndex) સાર્વજનિક int IndexOf(ચાર મૂલ્ય, પૂર્ણાંક સ્ટાર્ટ ઇન્ડેક્સ, પૂર્ણાંક સંખ્યા) સાર્વજનિક int IndexOf(સ્ટ્રિંગ વેલ્યુ, int startIndex, int કાઉન્ટ) |
કૉલિંગ સ્ટ્રિંગમાં અક્ષર અથવા સબસ્ટ્રિંગ મૂલ્યની પ્રથમ ઘટનાની અનુક્રમણિકા પરત કરે છે. શોધ સ્ટાર્ટઇન્ડેક્સ દ્વારા ઉલ્લેખિત તત્વથી શરૂ થાય છે અને ગણતરી દ્વારા ઉલ્લેખિત ઘટકોની સંખ્યા સુધી વિસ્તરે છે (જો ઉલ્લેખિત હોય તો). જો શોધાયેલ અક્ષર અથવા સબસ્ટ્રિંગ ન મળે તો પદ્ધતિ -1 પરત કરે છે |
|
| LastIndexOf() | ઓવરલોડ થયેલ આવૃત્તિઓ IndexOf() પદ્ધતિ જેવી જ છે | IndexOf જેવું જ છે, પરંતુ અક્ષર અથવા સબસ્ટ્રિંગની છેલ્લી ઘટના શોધે છે, પ્રથમ નહીં |
| IndexOfAny() | જાહેર int IndexOfAny(char anyOf) સાર્વજનિક int IndexOfAny(char anyOf, int startIndex) સાર્વજનિક int IndexOfAny(char anyOf, int startIndex, int કાઉન્ટ) |
કૉલિંગ સ્ટ્રિંગમાં મળેલા anyOf અરેમાંથી કોઈપણ અક્ષરની પ્રથમ ઘટનાની અનુક્રમણિકા પરત કરે છે. શોધ સ્ટાર્ટઇન્ડેક્સ દ્વારા ઉલ્લેખિત તત્વથી શરૂ થાય છે અને ગણતરી દ્વારા ઉલ્લેખિત ઘટકોની સંખ્યા સુધી વિસ્તરે છે (જો ઉલ્લેખિત હોય તો). જો anyOf એરેમાં કોઈ અક્ષર મેળ ખાતો ન હોય તો પદ્ધતિ -1 પરત કરે છે. શોધ સામાન્ય રીતે હાથ ધરવામાં આવે છે |
| LastIndexOfAny | ઓવરલોડ થયેલ આવૃત્તિઓ IndexOfAny() પદ્ધતિ જેવી જ છે | કૉલિંગ સ્ટ્રિંગમાં મળેલા anyOf એરેમાંથી કોઈપણ અક્ષરની છેલ્લી ઘટનાની અનુક્રમણિકા પરત કરે છે |
| વિભાજન અને શબ્દમાળાઓ જોડાવા | ||
| વિભાજન | સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (પરમ ચાર વિભાજક) સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (પરમ ચાર વિભાજક, પૂર્ણાંક સંખ્યા) |
એક પદ્ધતિ કે જે આ દાખલામાં અંદર હાજર સબસ્ટ્રિંગ સાથે સ્ટ્રિંગ એરે પરત કરે છે, જે ઉલ્લેખિત ચાર અથવા સ્ટ્રિંગ એરેમાંથી તત્વો દ્વારા એકબીજાથી અલગ પડે છે. Split() પદ્ધતિનું પ્રથમ સ્વરૂપ કૉલિંગ સ્ટ્રિંગને તેના ઘટક ભાગોમાં વિભાજિત કરે છે. પરિણામ એ કૉલિંગ સ્ટ્રિંગમાંથી મેળવેલ સબસ્ટ્રિંગ્સ ધરાવતું એરે છે. આ સબસ્ટ્રિંગ્સને સીમાંકિત કરતા અક્ષરો વિભાજક એરેમાં પસાર થાય છે. જો વિભાજક એરે ખાલી હોય અથવા ખાલી સ્ટ્રિંગનો સંદર્ભ આપે, તો સબસ્ટ્રિંગ વિભાજક તરીકે સ્પેસનો ઉપયોગ થાય છે. અને આ પદ્ધતિના બીજા સ્વરૂપમાં, ગણતરી પરિમાણ દ્વારા નિર્ધારિત સબસ્ટ્રિંગની સંખ્યા પરત કરવામાં આવે છે. |
| સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (પરમ ચાર વિભાજક, સ્ટ્રિંગ સ્પ્લિટ વિકલ્પો વિકલ્પો) સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (સ્ટ્રિંગ વિભાજક, સ્ટ્રિંગ સ્પ્લિટ વિકલ્પો વિકલ્પો) સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (પરમ ચાર વિભાજક, પૂર્ણાંક સંખ્યા, સ્ટ્રિંગસ્પ્લિટ વિકલ્પો વિકલ્પો) સાર્વજનિક સ્ટ્રિંગ સ્પ્લિટ (સ્ટ્રિંગ વિભાજક, પૂર્ણાંક સંખ્યા, સ્ટ્રિંગસ્પ્લિટ વિકલ્પો વિકલ્પો) |
સ્પ્લિટ() પદ્ધતિના પ્રથમ બે સ્વરૂપોમાં, કૉલિંગ સ્ટ્રિંગને ભાગોમાં વિભાજિત કરવામાં આવે છે અને કૉલિંગ સ્ટ્રિંગમાંથી મેળવેલા સબસ્ટ્રિંગ્સ ધરાવતું એરે પરત કરવામાં આવે છે. આ સબસ્ટ્રિંગ્સને અલગ કરતા અક્ષરો વિભાજક એરેમાં પસાર થાય છે. જો વિભાજક એરે ખાલી હોય, તો જગ્યાનો ઉપયોગ વિભાજક તરીકે થાય છે. અને આ પદ્ધતિના ત્રીજા અને ચોથા સ્વરૂપમાં, ગણતરી પરિમાણ દ્વારા મર્યાદિત પંક્તિઓની સંખ્યા પરત કરવામાં આવે છે. પરંતુ તમામ સ્વરૂપોમાં, વિકલ્પો પેરામીટર ખાલી રેખાઓને હેન્ડલ કરવાની ચોક્કસ રીતનો ઉલ્લેખ કરે છે જે જ્યારે બે સીમાંકક અડીને હોય ત્યારે ઉત્પન્ન થાય છે. StringSplitOptions ગણતરી માત્ર બે મૂલ્યો વ્યાખ્યાયિત કરે છે: કોઈ નહિઅને ખાલી એન્ટ્રીઓ દૂર કરો. જો વિકલ્પો કંઈ નથી, તો ખાલી શબ્દમાળાઓ મૂળ સ્ટ્રિંગના અંતિમ વિભાજન પરિણામમાં સમાવિષ્ટ છે. અને જો વિકલ્પોનું પેરામીટર RemoveEmptyEntries પર સેટ કરેલ હોય, તો મૂળ સ્ટ્રીંગને વિભાજિત કરવાના અંતિમ પરિણામમાંથી ખાલી લીટીઓ બાકાત રાખવામાં આવે છે. |
|
| જોડાઓ() | સાર્વજનિક સ્થિર સ્ટ્રિંગ જોડાઓ (સ્ટ્રિંગ વિભાજક, શબ્દમાળા મૂલ્ય) સાર્વજનિક સ્થિર સ્ટ્રિંગ જોડાઓ (સ્ટ્રિંગ વિભાજક, સ્ટ્રિંગ મૂલ્ય, પૂર્ણાંક સ્ટાર્ટ ઈન્ડેક્સ, પૂર્ણાંક સંખ્યા) |
સ્ટ્રિંગ્સના એરેના સમાવિષ્ટોને જોડીને નવી સ્ટ્રિંગ બનાવે છે. Join() પદ્ધતિનું પ્રથમ સ્વરૂપ વેલ્યુ એરેમાં પસાર કરાયેલા સંકલિત સબસ્ટ્રિંગનો સમાવેશ કરતી સ્ટ્રિંગ પરત કરે છે. બીજું ફોર્મ મૂલ્ય એરેમાં પસાર કરાયેલા સબસ્ટ્રિંગનો સમાવેશ કરતી સ્ટ્રિંગ પણ આપે છે, પરંતુ તે મૂલ્ય એરે ઘટકથી શરૂ કરીને, ચોક્કસ સંખ્યાની ગણતરીમાં જોડવામાં આવે છે. બંને સ્વરૂપોમાં, દરેક અનુગામી રેખાને વિભાજક પરિમાણ દ્વારા નિર્દિષ્ટ વિભાજક રેખા દ્વારા અગાઉની રેખાથી અલગ કરવામાં આવે છે. |
| લીટીઓ ભરવા અને ટ્રિમિંગ | ||
| ટ્રિમ() | જાહેર શબ્દમાળા ટ્રિમ() સાર્વજનિક સ્ટ્રિંગ ટ્રીમ (પરમ ચાર ટ્રીમ ચાર્સ) |
એક પદ્ધતિ જે તમને વર્તમાન લાઇનની શરૂઆત અને અંતથી અક્ષરોના ચોક્કસ સમૂહની બધી ઘટનાઓને દૂર કરવાની મંજૂરી આપે છે. Trim() પદ્ધતિનું પ્રથમ સ્વરૂપ કૉલિંગ સ્ટ્રિંગમાંથી આગળની અને પાછળની જગ્યાઓ દૂર કરે છે. અને આ પદ્ધતિનું બીજું સ્વરૂપ trimChars એરેમાંથી કૉલિંગ કેરેક્ટર સ્ટ્રિંગની અગ્રણી અને પાછળની ઘટનાઓને દૂર કરે છે. બંને સ્વરૂપો પરિણામી સ્ટ્રિંગ પરત કરે છે. |
| પેડલેફ્ટ() | સાર્વજનિક શબ્દમાળા PadLeft(int totalWidth) સાર્વજનિક સ્ટ્રિંગ PadLeft(int totalWidth, char paddingChar) |
તમને ડાબી બાજુએ અક્ષરો સાથે સ્ટ્રિંગ પેડ કરવાની મંજૂરી આપે છે. PadLeft() પદ્ધતિનું પ્રથમ સ્વરૂપ કૉલિંગ સ્ટ્રિંગની ડાબી બાજુએ જગ્યાઓ રજૂ કરે છે જેથી તેની કુલ લંબાઈ બને. મૂલ્યની સમાનકુલ પહોળાઈ પરિમાણ. અને આ પદ્ધતિના બીજા સ્વરૂપમાં, paddingChar પરિમાણ દ્વારા સૂચિત અક્ષરો કૉલિંગ સ્ટ્રિંગની ડાબી બાજુએ દાખલ કરવામાં આવે છે જેથી તેની કુલ લંબાઈ totalWidth પેરામીટરની કિંમત જેટલી થઈ જાય. બંને સ્વરૂપો પરિણામી શબ્દમાળા પરત કરે છે. જો TotalWidth પેરામીટરનું મૂલ્ય કૉલિંગ સ્ટ્રિંગની લંબાઈ કરતાં ઓછું હોય, તો અપરિવર્તિત કૉલિંગ સ્ટ્રિંગની કૉપિ પરત કરવામાં આવે છે. |
| PadRight() | PadLeft() જેવું જ | તમને જમણી બાજુએ અક્ષરો સાથે સ્ટ્રિંગ ઉમેરવાની મંજૂરી આપે છે. |
| પંક્તિઓ દાખલ કરવી, કાઢી નાખવી અને બદલવી | ||
| દાખલ કરો() | સાર્વજનિક સ્ટ્રિંગ ઇન્સર્ટ (int startIndex, સ્ટ્રિંગ મૂલ્ય) | એક પંક્તિને બીજી પંક્તિમાં દાખલ કરવા માટે વપરાય છે, જ્યાં મૂલ્ય startIndex પર કૉલિંગ પંક્તિમાં દાખલ કરવાની પંક્તિને સૂચવે છે. પદ્ધતિ પરિણામી સ્ટ્રિંગ પરત કરે છે. |
| દૂર કરો() | સાર્વજનિક સ્ટ્રિંગ દૂર કરો(int startIndex) સાર્વજનિક સ્ટ્રિંગ દૂર કરો (int startIndex, int કાઉન્ટ) |
શબ્દમાળાનો ભાગ દૂર કરવા માટે વપરાય છે. Remove() પદ્ધતિના પ્રથમ સ્વરૂપમાં, startIndex દ્વારા દર્શાવેલ સ્થાનથી દૂર કરવાનું શરૂ થાય છે અને લાઇનના અંત સુધી ચાલુ રહે છે. અને આ પદ્ધતિના બીજા સ્વરૂપમાં, કાઉન્ટ પેરામીટર દ્વારા નિર્ધારિત અક્ષરોની સંખ્યાને સ્ટ્રિંગમાંથી દૂર કરવામાં આવે છે, જે startIndex ઇન્ડેક્સ દ્વારા દર્શાવેલ સ્થાનથી શરૂ થાય છે. |
| બદલો() | સાર્વજનિક શબ્દમાળા બદલો (char oldChar, char newChar) સાર્વજનિક સ્ટ્રિંગ બદલો (સ્ટ્રિંગ જૂનું મૂલ્ય, સ્ટ્રિંગ નવું મૂલ્ય) |
શબ્દમાળાના ભાગને બદલવા માટે વપરાય છે. Replace() પદ્ધતિના પ્રથમ સ્વરૂપમાં, કૉલિંગ સ્ટ્રિંગમાં જૂનાChar અક્ષરની તમામ ઘટનાઓ અક્ષર newChar સાથે બદલવામાં આવે છે. અને આ પદ્ધતિના બીજા સ્વરૂપમાં, કૉલિંગ લાઇનમાં જૂના મૂલ્યના સ્ટ્રિંગની તમામ ઘટનાઓ સ્ટ્રિંગ newValue સાથે બદલવામાં આવે છે. |
| કેસ બદલો | ||
| ToUpper() | જાહેર શબ્દમાળા ToUpper() | કૉલિંગ સ્ટ્રિંગમાંના બધા અક્ષરોને કેપિટલાઇઝ કરે છે. |
| નીચે તરફ() | સાર્વજનિક સ્ટ્રિંગ ToLower() | કૉલિંગ સ્ટ્રિંગમાં બધા અક્ષરો લોઅરકેસ કરો. |
| સ્ટ્રિંગમાંથી સબસ્ટ્રિંગ મેળવવી | ||
| સબસ્ટ્રિંગ() | સાર્વજનિક સ્ટ્રિંગ સબસ્ટ્રિંગ(int startIndex) સાર્વજનિક સ્ટ્રિંગ સબસ્ટ્રિંગ (int startIndex, int length) |
સબસ્ટ્રિંગ() પદ્ધતિના પ્રથમ સ્વરૂપમાં, સ્ટાર્ટઇન્ડેક્સ પેરામીટર દ્વારા સૂચિત સ્થાનથી કૉલિંગ સ્ટ્રિંગના અંત સુધી સબસ્ટ્રિંગ મેળવવામાં આવે છે. અને આ પદ્ધતિના બીજા સ્વરૂપમાં, લંબાઈ પરિમાણ દ્વારા નિર્ધારિત અક્ષરોની સંખ્યા ધરાવતી સબસ્ટ્રિંગ કાઢવામાં આવે છે, જે startIndex પેરામીટર દ્વારા દર્શાવેલ સ્થાનથી શરૂ થાય છે. |
નીચેનો ઉદાહરણ પ્રોગ્રામ ઉપરોક્ત પદ્ધતિઓમાંથી ઘણી પદ્ધતિઓનો ઉપયોગ કરે છે:
સિસ્ટમનો ઉપયોગ; System.Collections.Generic નો ઉપયોગ કરીને; System.Linq નો ઉપયોગ કરીને; System.Text નો ઉપયોગ કરીને; namespace ConsoleApplication1 ( વર્ગ પ્રોગ્રામ ( સ્થિર રદબાતલ મુખ્ય (સ્ટ્રિંગ આર્ગ્સ) ( // પ્રથમ બે લાઇનની સ્ટ્રિંગ s1 = "આ એક સ્ટ્રિંગ છે" ની સરખામણી કરો; સ્ટ્રિંગ s2 = "આ ટેક્સ્ટ છે, અને આ એક સ્ટ્રિંગ છે"; જો (સ્ટ્રિંગ. CompareOrdinal(s1, s2) != 0) Console.WriteLine("Strings s1 અને s2 is not equal" if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("જો કે, તેઓ સમાન ટેક્સ્ટ ધરાવે છે"); // સ્ટ્રિંગ્સ કન્સોલનું જોડાણ. / સબસ્ટ્રિંગની પ્રથમ ઘટના જો (s2. IndexOf("this") != -1) Console.WriteLine("શબ્દ \"this\" લીટીમાં જોવા મળે છે, તે "+" પર સ્થિત છે: (0) સ્થિતિ", s2.IndexOf("this")); / સબસ્ટ્રિંગની છેલ્લી ઘટના જો (s2.LastIndexOf("this") != -1) Console.WriteLine("\"this\" શબ્દની છેલ્લી ઘટના છે " + "(0) સ્થાન પર", s2.LastIndexOf("this" )); // અક્ષરોની એરેમાંથી શોધો char myCh = ("Y","x","t"); જો (s2. IndexOfAny(myCh) != -1) Console.WriteLine("એરે ch "+"માંથી એક અક્ષર વર્તમાન લાઇનમાં (0) સ્થાન પર જોવા મળે છે", s2.IndexOfAny(myCh));
// નક્કી કરો કે શું લીટી આપેલ સબસ્ટ્રિંગથી શરૂ થાય છે જો (s2.StartsWith("this is text") == true) Console.WriteLine("Substring found!");
// નિર્ધારિત કરો કે શું શબ્દમાળામાં સબસ્ટ્રિંગ છે // વપરાશકર્તાની OS સ્ટ્રિંગ નક્કી કરવાના ઉદાહરણનો ઉપયોગ કરીને myOS = Environment.OSVersion.ToString();
જો (myOS.Contains("NT 5.1")) Console.WriteLine("તમારી ઓપરેટિંગ સિસ્ટમ Windows XP છે");
અન્ય જો (myOS.Contains("NT 6.1")) Console.WriteLine("તમારી ઓપરેટિંગ સિસ્ટમ Windows 7 છે"); Console.ReadLine();) નક્કી કરવા માટે કે શું એક સ્ટ્રિંગ બીજી સ્ટ્રિંગ કરતાં મોટી છે, તેનાથી ઓછી છે કે તેની બરાબર છે. સામાન્ય સરખામણીમાં, દરેક અક્ષરના અસંશોધિત મૂલ્યના આધારે શબ્દમાળાઓને સરળ રીતે ક્રમાંકિત કરવામાં આવે છે.
સાંસ્કૃતિક શબ્દમાળાની સરખામણીઓ અને સામાન્ય સરખામણીઓમાં તફાવત હોવાને કારણે અને આવી દરેક સરખામણીના પરિણામોને કારણે, અમે ભારપૂર્વક ભલામણ કરીએ છીએ કે તમે હાલમાં Microsoft દ્વારા ઓફર કરવામાં આવતી શ્રેષ્ઠ પદ્ધતિઓનું પાલન કરો. છેવટે, શબ્દમાળાઓની સરખામણી કરવા માટે ખોટી પદ્ધતિ પસંદ કરવાથી પ્રોગ્રામ જ્યારે તે જે વાતાવરણમાં વિકસાવવામાં આવ્યો હતો તેના કરતા અલગ વાતાવરણમાં ચલાવવામાં આવે ત્યારે તેની ખોટી કામગીરી તરફ દોરી જાય છે.
અક્ષર શબ્દમાળાઓની તુલના કેવી રીતે કરવી તે પસંદ કરવું એ ખૂબ જ મહત્વપૂર્ણ નિર્ણય છે. સામાન્ય નિયમ તરીકે, અને અપવાદ વિના, તમારે સાંસ્કૃતિક રીતે સંવેદનશીલ રીતે શબ્દમાળાઓની તુલના કરવાનું પસંદ કરવું જોઈએ જો આ વપરાશકર્તાને પરિણામ પ્રદર્શિત કરવાના હેતુથી કરવામાં આવે છે (ઉદાહરણ તરીકે, શબ્દકોષના ક્રમમાં ક્રમાંકિત તારોની શ્રેણી પ્રદર્શિત કરવા માટે). પરંતુ જો શબ્દમાળાઓમાં નિશ્ચિત માહિતી હોય કે જે સાંસ્કૃતિક તફાવતો, જેમ કે ફાઇલનું નામ, કીવર્ડ, વેબસાઇટ સરનામું, અથવા સુરક્ષા મૂલ્ય માટે સંશોધિત કરવાનો હેતુ નથી, તો તમારે ઓર્ડિનલ સ્ટ્રિંગ સરખામણી પસંદ કરવી જોઈએ. અલબત્ત, વિકસાવવામાં આવી રહેલી ચોક્કસ એપ્લિકેશનની લાક્ષણિકતાઓ અક્ષર શબ્દમાળાઓની તુલના કરવા માટે યોગ્ય પદ્ધતિની પસંદગી નક્કી કરશે.
સ્ટ્રિંગ વર્ગ વિવિધ સ્ટ્રિંગ સરખામણી પદ્ધતિઓ પ્રદાન કરે છે, જે ઉપરના કોષ્ટકમાં સૂચિબદ્ધ છે. તેમાંથી સૌથી વધુ સાર્વત્રિક છે Compare() પદ્ધતિ. તે પ્રકાર પેરામીટર દ્વારા નિર્દિષ્ટ રીતે બે શબ્દમાળાઓને સંપૂર્ણ અથવા આંશિક, કેસ-સંવેદનશીલ અથવા કેસ-અસંવેદનશીલ, સરખામણી કરવાની મંજૂરી આપે છે. શબ્દમાળા સરખામણી, તેમજ પ્રકાર પેરામીટર દ્વારા પૂરી પાડવામાં આવેલ સાંસ્કૃતિક માહિતી સંસ્કૃતિ માહિતી.
Compare() પદ્ધતિના તે ઓવરલોડ્સ કે જેમાં StringComparison પ્રકારનું પરિમાણ શામેલ નથી તે અક્ષર શબ્દમાળાઓની કેસ- અને સંસ્કૃતિ-સંવેદનશીલ સરખામણી કરે છે. અને તે ઓવરલોડ વેરિઅન્ટ્સમાં કે જેમાં CultureInfo પ્રકારનું પરિમાણ નથી, સાંસ્કૃતિક વાતાવરણ વિશેની માહિતી વર્તમાન રનટાઇમ પર્યાવરણ દ્વારા નક્કી કરવામાં આવે છે.
StringComparison પ્રકાર એ એક ગણતરી છે જે નીચેના કોષ્ટકમાં બતાવેલ મૂલ્યોને વ્યાખ્યાયિત કરે છે. આ મૂલ્યોનો ઉપયોગ કરીને, તમે તમારી વિશિષ્ટ એપ્લિકેશનની જરૂરિયાતોને અનુરૂપ સ્ટ્રિંગ સરખામણીઓ બનાવી શકો છો. તેથી, StringComparison પ્રકારનું પરિમાણ ઉમેરવાથી Compare() પદ્ધતિ અને Equals() જેવી અન્ય સરખામણી પદ્ધતિઓની ક્ષમતાઓ વિસ્તરે છે. આનાથી અસ્પષ્ટપણે દર્શાવવાનું પણ શક્ય બને છે કે તારોની તુલના કેવી રીતે કરવાનો છે.
સાંસ્કૃતિક રીતે સંવેદનશીલ સ્ટ્રિંગ સરખામણીઓ અને સામાન્ય સરખામણીઓ વચ્ચેના તફાવતોને કારણે, આ સંદર્ભમાં શક્ય તેટલું ચોક્કસ હોવું મહત્વપૂર્ણ છે.
| અર્થ | વર્ણન |
|---|---|
| વર્તમાન સંસ્કૃતિ | વર્તમાન સાંસ્કૃતિક પર્યાવરણ સેટિંગ્સનો ઉપયોગ કરીને શબ્દમાળાની તુલના કરવામાં આવે છે |
| CurrentCultureIgnoreCase | વર્તમાન સંસ્કૃતિ સેટિંગ્સનો ઉપયોગ કરીને સ્ટ્રિંગની સરખામણી કરવામાં આવે છે, પરંતુ તે કેસ સંવેદનશીલ નથી |
| અપરિવર્તનશીલ સંસ્કૃતિ | સ્ટ્રિંગ સરખામણીઓ અપરિવર્તનશીલ લોકોનો ઉપયોગ કરીને કરવામાં આવે છે, એટલે કે. સાંસ્કૃતિક વાતાવરણ વિશેનો સાર્વત્રિક ડેટા |
| InvariantCultureIgnoreCase | સ્ટ્રિંગ સરખામણીઓ અપરિવર્તનશીલ લોકોનો ઉપયોગ કરીને કરવામાં આવે છે, એટલે કે. સાર્વત્રિક સાંસ્કૃતિક ડેટા અને કેસ-સંવેદનશીલ |
| ઑર્ડિનલ | શબ્દમાળાની તુલના સ્ટ્રિંગમાંના અક્ષરોના સામાન્ય મૂલ્યોનો ઉપયોગ કરીને કરવામાં આવે છે. આ કિસ્સામાં, લેક્સિકોગ્રાફિક ઓર્ડર વિક્ષેપિત થઈ શકે છે, અને પ્રતીકોચોક્કસ સાંસ્કૃતિક વાતાવરણમાં સ્વીકૃત અવગણવામાં આવે છે |
| OrdinalIgnoreCase | શબ્દમાળાની તુલના સ્ટ્રિંગમાંના અક્ષરોના સામાન્ય મૂલ્યોનો ઉપયોગ કરીને કરવામાં આવે છે, પરંતુ તે કેસ સંવેદનશીલ નથી |
કોઈપણ કિસ્સામાં, Compare() પદ્ધતિ નકારાત્મક મૂલ્ય આપે છે જો સરખામણીમાં પ્રથમ સ્ટ્રિંગ બીજા કરતા ઓછી હોય; જો પ્રથમ સ્ટ્રિંગની તુલના કરવામાં આવી રહી છે, તો તે બીજા કરતા વધારે છે; અને અંતે, શૂન્ય જો બંને તાર સરખા હોય. જો કે Compare() પદ્ધતિ શૂન્ય પરત કરે છે જો સરખામણી કરવામાં આવી રહેલી સ્ટ્રિંગ્સ સમાન હોય, તો સામાન્ય રીતે Equals() પદ્ધતિ અથવા == ઓપરેટરનો ઉપયોગ એ નક્કી કરવા માટે કે કેરેક્ટર સ્ટ્રિંગ્સ સમાન છે કે કેમ તે વધુ સારું છે.
હકીકત એ છે કે Compare() પદ્ધતિ તેમના સૉર્ટ ક્રમના આધારે તુલનાત્મક શબ્દમાળાઓની સમાનતા નક્કી કરે છે. આમ, જો શબ્દમાળાઓ વચ્ચે સાંસ્કૃતિક સરખામણી કરવામાં આવે, તો બંને તાર તેમના સૉર્ટ ક્રમમાં સમાન હોઈ શકે છે, પરંતુ પદાર્થમાં સમાન નથી. મૂળભૂત રીતે, શબ્દમાળા સમાનતા Equals() પદ્ધતિમાં નક્કી કરવામાં આવે છે, જે અક્ષરોના સામાન્ય મૂલ્યોને આધારે અને સાંસ્કૃતિક વાતાવરણને ધ્યાનમાં લીધા વિના. તેથી, મૂળભૂત રીતે, બંને શબ્દમાળાઓની તુલના આ પદ્ધતિમાં નિરપેક્ષ, અક્ષર-દ્વારા-પાત્ર સમાનતા માટે કરવામાં આવે છે, જે રીતે તે == ઓપરેટરમાં થાય છે.
Compare() પદ્ધતિની મહાન વૈવિધ્યતા હોવા છતાં, અક્ષર શબ્દમાળાઓની સરળ ઓર્ડિનલ સરખામણીઓ માટે CompareOrdinal() પદ્ધતિનો ઉપયોગ કરવો વધુ સરળ છે. છેલ્લે, ધ્યાનમાં રાખો કે CompareTo() પદ્ધતિ માત્ર સાંસ્કૃતિક રીતે સંવેદનશીલ સ્ટ્રિંગ સરખામણીઓ કરે છે.
નીચેનો પ્રોગ્રામ કેરેક્ટર સ્ટ્રીંગ્સની સરખામણી કરવા માટે Compare(), Equals(), CompareOrdinal() પદ્ધતિઓ અને == અને != ઓપરેટર્સનો ઉપયોગ દર્શાવે છે. નોંધ કરો કે પ્રથમ બે સરખામણી ઉદાહરણો સાંસ્કૃતિક રીતે સંવેદનશીલ સ્ટ્રિંગ સરખામણીઓ અને અંગ્રેજી બોલતા વાતાવરણમાં સામાન્ય સરખામણીઓ વચ્ચેના તફાવતોને સ્પષ્ટપણે દર્શાવે છે:
સિસ્ટમનો ઉપયોગ; વર્ગનું ઉદાહરણ ( સ્થિર રદબાતલ મુખ્ય () ( સ્ટ્રિંગ str1 = "આલ્ફા"; સ્ટ્રિંગ str2 = "આલ્ફા"; સ્ટ્રિંગ str3 = "બીટા"; સ્ટ્રિંગ str4 = "આલ્ફા"; સ્ટ્રિંગ str5 = "આલ્ફા, બીટા"; પૂર્ણ પરિણામ; / / પ્રથમ, સંસ્કૃતિ-સંવેદનશીલ સ્ટ્રિંગ સરખામણી // અને ઑર્ડિનલ સરખામણી પરિણામ = String.Compare(str1, str2, StringComparison.CurrentCulture) વચ્ચેનો તફાવત દર્શાવો. કન્સોલ (str1 + "" + str2 કરતાં વધુ); અન્યથા કન્સોલ.WriteLine(str1 + " equal to " + str2); ) Console.WriteLine(str1 + "" + str2 કરતાં વધુ); .Write("CompareOrdinal():\n" જો (પરિણામ 0) Console.WriteLine(str1 + "" + str2 કરતા વધારે છે), અન્યથા Console.WriteLine(str1 + "" + str4);
Console.WriteLine();
