Darbas su stygomis. Styginių klasė. Klasių konstruktoriai. Funkcijos assign() , append() , insert() , change() , erase() , find() , rfind() , palyginti() , c_str() . Pavyzdžiai
1. Kokia yra eilučių klasės paskirtis C++ programose?
Styginių klasė skirta dirbti su char* eilutėmis, kurios yra nulinės eilutės. Styginių klasė buvo pristatyta kaip alternatyvus variantas darbui su char* tipo eilutėmis. Eilutės, kurios baigiasi simboliu ‘\0’ dar vadinamos C raidėmis. Kadangi eilutė yra klasė, galite deklaruoti šios klasės objektus.
2. Kokius modulius (bibliotekas) reikia prijungti norint naudotis stygų klasės galimybėmis MS Visual Studio C++?
Norėdami naudoti MS Visual Studio (C++) eilutės klasės galimybes, turite įtraukti biblioteką
3. Kaip deklaruojamas eilutės tipo kintamasis? Pavyzdžiai
Eilutės tipo kintamasis deklaruojamas taip pat, kaip įprastas kintamasis. Galimas variantas deklaracijos su tuo pačiu inicijavimu.
// įveskite string string s1; // kintamasis, pavadintas s1 tipo eilutės string s2 = "Tai yra eilutės kintamasis" ; // deklaracija su inicijavimu // naudojant eilutės tipo kintamąjį su priskyrimo operatoriumi s1 = s2; // s1 = "Tai yra eilutės kintamasis" s2 = "Naujas tekstas" ;4. Kokie yra stygų klasės naudojimo pranašumai ir trūkumai, palyginti su char* tipu?
Naujas eilučių tipas buvo sukurtas dėl darbo su simbolių eilutėmis trūkumų, kuriuos rodė char* tipas. Palyginti su char* tipu, eilutės tipas turi šiuos pagrindinius pranašumus:
- galimybė apdoroti eilutes naudojant standartinius C++ operatorius ( = , + , = = , <> ir tt). Kaip žinote, naudojant char* tipą, net pačios paprasčiausios operacijos su eilutėmis atrodė sudėtingos ir reikalavo rašyti per daug programos kodo;
- geresnio programos kodo patikimumo (saugumo) užtikrinimas. Pavyzdžiui, kopijuojant eilutes, eilutės tipas numato atitinkamus veiksmus, kurie gali įvykti, jei šaltinio eilutė yra didesnė už paskirties eilutę;
- pateikiant eilutę kaip nepriklausomą duomenų tipą. Eilutės tipo deklaravimas kaip eilutė yra vienodas visiems programos kintamiesiems, o tai užtikrina duomenų nuoseklumą.
Pagrindinis eilutės tipo trūkumas, palyginti su char* tipu, yra lėtesnis duomenų apdorojimo greitis. Taip yra dėl to, kad eilutės tipas iš tikrųjų yra konteinerio klasė. O dirbant su klase reikia papildomai įdiegti programos kodą, o tai savo ruožtu užima papildomo laiko.
5. Kokius operatorius galima naudoti su stygų klasės objektais?
Stygų klasė patogi, nes leidžia patogiai manipuliuoti eilutėmis naudojant standartinius (perkrautus) operatorius.
Šie operatoriai gali būti naudojami su stygų klasės objektais
- = – pavedimas
- + – sujungimas (stygų sujungimas)
- += – priskyrimas su sujungimu
- == – lygybė
- != – nelygybė
- < - mažiau
- <= - mažesnis arba lygus
- > - daugiau
- >= - didesnis arba lygus
- – indeksavimas
Pavyzdys, kuris parodo minėtų teiginių naudojimą
// eilutės tipas, operacijos su eilutėmis eilutė s1 = "s-1" ; eilutė s2 = "s-2" ; eilutė s3; bool b; // operacija "=" (eilutės priskyrimas) s3 = s1; // s3 = "s-1" // operacija "+" - eilučių sujungimas s3 = s3 + s2; // s3 = "s-1s-2" // operacija "+=" - priskyrimas su jungimu s3 = "s-3"; s3 += "abc" ; // s3 = "s-3abc" // operacija "==" - eilučių palyginimas b = s2 = = s1; // b = klaidinga b = s2=="s-2" ; // b = tiesa // operacija "!=" - eilučių palyginimas (nelygus) s1 = "s1" ; s2 = "s2" ; b = s1 ! = s2; // b = tiesa // operacijos "<" и ">“ – stygų palyginimas s1 = "abcd" ; s2 = "de"; b = s1 > s2; // b = klaidinga b = s1< s2; // b = true // operacijos "<=" и ">= – eilutės palyginimas (mažiau arba lygus, didesnis arba lygus) s1 = "abcd" ; s2 = "ab" ; b = s1 > = s2; // b = tiesa b = s1<= s2; // b = false b = s2 >= "ab" ; // b = tiesa // operacija – indeksavimas char c; s1 = "abcd" ; c = s1; // c = "c" c = s1; // c = "a"6. Ar eilutės klasėje yra konstruktorių?
Kaip ir bet kuri klasė, stygų klasė turi daugybę konstruktorių. Pagrindiniai iš jų yra šie:
Styga (); string(const char * str); string(const string & str);
7. Inicializacijos pavyzdžiai naudojant konstruktorius
Žemiau pateikiami eilutės tipo kintamųjų inicijavimo pavyzdžiai
Styga s1("Sveiki!" ); string s2 = "Sveiki!" ;// inicijavimas - konstruktoriaus eilutė (const char * str) char * ps = "Sveiki" ; eilutė s3(ps); // inicijavimo eilutė s4(s3);// inicijavimas - konstruktoriaus eilutė (const string & str) eilutė s5;
// inicijavimas - string() konstruktorius
Norėdami priskirti vieną eilutę kitai, galite naudoti vieną iš dviejų būdų:
- naudokite priskyrimo operatorių ‘=’ ;
- naudokite funkciją assign() iš eilučių klasės.
Funkcija assign() turi keletą perkrautų įgyvendinimų.
Pirmasis variantas yra iškviesti funkciją be parametrų
Eilutę &assign(void);
Šiuo atveju yra paprastas vienos eilutės priskyrimas kitai.
Antroji parinktis leidžia nukopijuoti tam tikrą skaičių simbolių iš eilutės:
Styga &assign(const string & s, size_type st, size_type num);
- s – objektas, iš kurio paimta šaltinio eilutė;
- st – indeksas (pozicija) eilutėje, nuo kurios pradedamas num simbolių kopijavimas;
- num – simbolių skaičius, kurį reikia nukopijuoti iš st padėties;
- size_type – eilinis duomenų tipas.
Trečiasis funkcijos assign() variantas nukopijuoja pirmuosius eilutės s simbolius skambintojui:
String & assign(const char * s, size_type num);
- s – eilutė, kuri baigiasi simboliu ‘\0’ ;
- skaičius yra simbolių, nukopijuotų į skambinantį objektą, skaičius. Nukopijuojami pirmieji numerio simboliai iš eilutės s.
Žemiau pateikiamas pavyzdys su skirtingais funkcijos assign() įgyvendinimais.
Pavyzdys.
// eilučių priskyrimas, assign() funkcija eilutė s1 = "svetainė" ; eilutė s2; eilutė s3; char * ps = "svetainė" ; s3 = s1; // s3 = "svetainė" s2.assign(s1); // s2 = "svetainė" s2.assign(s1, 0, 4); // s2 = "geriausias" s2.assign(ps, 8); // s2 = "geriausia programa"9. Stygų derinimas. Funkcija append(). Pavyzdys
Funkcija append() naudojama eilutėms sujungti. Taip pat galite naudoti eilutes pridėti ‘+’ , Pavyzdžiui:
Styga s1; eilutė s2; s1 = "abc" ; s2 = "def" ; s1 = s1 + s2; // s1 = "abcdef"
Tačiau funkcija append() yra gera, jei reikia pridėti dalį eilutės.
Funkcija turi šias įgyvendinimo parinktis:
String &append(const string & s, size_type pradžia); string &append(const char * s, size_type num);
Pirmajame įgyvendinime funkcija gauna nuorodą į eilutės objektą s, kuris pridedamas prie skambinamojo objekto. Antruoju įgyvendinimu funkcija gauna žymeklį į const char * tipo eilutę, kuri baigiasi simboliu „\0“.
Pavyzdys. Funkcijos append() demonstravimas.
Eilutė s1 = "abcdef" ; s2 = "1234567890" ; pridėti(s2, 3, 4); // s1 = "abcdef4567" char * ps = "1234567890" ; s1 = "abcdef" ; s1.pridėti(ps, 3); // s1 = "abcdef123"
10. Simbolių įterpimas į eilutę. Įterpti () funkcija. Pavyzdys
Norėdami įterpti vieną eilutę nurodytoje kitos eilutės vietoje, turite naudoti funkciją insert(), kuri turi keletą įgyvendinimo parinkčių.
Pirmoji funkcijos versija leidžia įterpti visą eilutę s nurodytoje skambinamosios linijos (skambinimo objekto) pradžios vietoje:
String & insert(size_type start, const string &s);
Antroji funkcijos versija leidžia įterpti dalį (parametrus insStart , num ) eilutės s nurodytoje iškviečiamosios eilutės pradžios vietoje:
String & insert(dydžio_tipo pradžia, const string &s, dydžio_tipas insStart, dydžio_tipo skaičius);
Aukščiau nurodytose funkcijose:
- s – eilutė, kuri įterpiama į skambinimo liniją;
- start – padėtis iškviečiančioje eilutėje, iš kurios įterpiama eilutė s;
- insStart – padėtis eilutėje s, iš kurios vyksta įterpimas;
- num – simbolių skaičius eilutėje s, įterpiamas iš insStart padėties.
11. Simbolių keitimas eilutėje. pakeisti () funkciją. Pavyzdys
Funkcija „replace()“ pakeičia simbolius iškvietimo eilutėje. Funkcija turi šias įgyvendinimo parinktis:
Styga &replace(dydžio_tipo pradžia, dydžio_tipo skaičius, const eilutė &s); string &replace(dydžio_tipas pradžia, dydžio_tipo skaičius, const string &s, dydžio_tipas replStart, dydžio_type replNum);
Pirmajame įgyvendinime iškvietimo eilutė pakeičiama eilute s. Galima nurodyti vietą (pradžia) ir simbolių skaičių (skaičius) skambinimo eilutėje, kuriuos reikia pakeisti eilute s.
Antroji funkcijos replace() versija skiriasi nuo pirmosios tuo, kad leidžia tik dalį eilutės s pakeisti iškvietimo eilute. Šiuo atveju pateikiami du papildomi parametrai: replStart padėtis ir simbolių skaičius eilutėje s, kurios sudaro poeilelę, kuri pakeičia iškvietimo eilutę.
Pavyzdys. Pakeitimo() funkcijos demonstravimas.
Eilutė s1 = "abcdef" ; string s2 = "1234567890" ; s2.replace(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.replace(5, 1, s1); // s2 = "12345abcdef7890" // simbolių pakeitimas, funkcija pakeisti () eilutė s1 = "abcdef" ; string s2 = "1234567890" ; s2.replace(2, 4, s1); // s2 = "12abcdef7890" s2 = "1234567890" ; s2.replace(3, 2, s1); // s2 = "123abcdef67890" s2 = "1234567890" ; s2.replace(5, 1, s1); // s2 = "12345abcdef7890" s2 = "1234567890" ; s2.replace(5, 1, s1, 2, 3); // s2 = "12345cde7890" s2 = "1234567890" ; s2.replace(4, 2, s1, 0, 4); // s2 = "1234abcd7890"
12. Nurodyto simbolių skaičiaus pašalinimas iš eilutės. erase() funkcija. Pavyzdys
Norėdami pašalinti simbolius iš skambinimo eilutės, naudokite funkciją erase():
String & erase(dydžio_tipas indeksas=0, dydžio_tipas skaičius = npos);
- index – indeksas (pozicija), nuo kurios norima pašalinti skambančios linijos simbolius;
- skaičius – pašalintų simbolių skaičius.
Pavyzdys.
s eilutė = "01234567890" ; s.erase(3, 5); // s = "012890" s = "01234567890" ; s.erase(); // s = ""
13. Ieškokite simbolio eilutėje. Find() ir rfind() funkcijos. Pavyzdžiai
Eilučių klasėje eilutės paieška poeilėje gali būti atliekama dviem būdais, kurie skiriasi paieškos kryptimi:
- nuskaitant eilutę nuo pradžios iki pabaigos naudojant funkciją find();
- nuskaitydami eilutę nuo pabaigos iki pradžios naudodami funkciją rfind().
Funkcijos find() prototipas atrodo taip:
Dydžio_tipas find(const string &s, size_type start = 0) const ;
- s yra poeilutė, kurios ieškoma eilutėje, kuri iškviečia šią funkciją. Funkcija ieško pirmos eilutės s pasireiškimo. Jei poeilutė s randama eilutėje, kuri iškvietė šią funkciją, tada grąžinama pirmojo įvykio padėtis. Kitu atveju grąžinamas -1;
Funkcijos rfind() prototipas atrodo taip:
Dydžio_tipas rfind(const string &s, size_type start = npos) const ;
- s yra poeilutė, kurios ieškoma iškvietimo eilutėje. Poeilutės paieška eilutėje vykdoma nuo pabaigos iki pradžios. Jei poeilutė s randama iškvietimo eilutėje, funkcija grąžina pirmojo įvykio vietą. Kitu atveju funkcija grąžina -1;
- npos – paskutinio skambinančios linijos simbolio padėtis;
- pradžia – padėtis, iš kurios atliekama paieška.
1 pavyzdys. Kodo fragmentas, rodantis funkcijos find() rezultatą
// įveskite eilutę, funkcija find() eilutė s1 = "01234567890" ; eilutė s2 = "345" ; eilutė s3 = "abcd" ; int poz.; poz = s1.rasti(s2); // poz = 3 poz = s1.rasti(s2, 1); // poz = 3 poz = s1.find("jklmn" , 0); // poz = -1 poz = s1.rasti(s3); // poz = -1 poz = s2.rasti(s1); // poz = -12 pavyzdys. Funkcijos rfind() demonstravimas.
// eilutės tipas, Find() ir rfind() funkcijos eilutė s1 = "01234567890" ; eilutė s2 = "345" ; eilutė s3 = "abcd" ; eilutė s4 = "abcd---abcd" ; int poz.; poz = s1.rfind(s2); // poz = 3 poz = s1.rfind(s2, 12); // poz = 3 poz = s1.rfind(s2, 3); // poz = 3 poz = s1.rfind(s2, 2); // poz = -1 poz = s2.rfind(s1); // poz = -1 poz = s1.rfind(s3, 0); // poz = -1 // skirtumas tarp Find() ir rfind() funkcijų poz = s4.rfind(s3); // poz = 7 poz = s4.rasti(s3); // poz = 014. Stygų dalių palyginimas. Palyginti () funkciją. Pavyzdys
Kadangi eilutės tipas yra klasė, galite naudoti operaciją, kad palygintumėte dvi eilutes tarpusavyje ‘= =’ . Jei dvi eilutės yra vienodos, palyginimo rezultatas bus teisingas . Priešingu atveju palyginimo rezultatas bus klaidingas.
Bet jei jums reikia palyginti vienos eilutės dalį su kita, tada funkcija palyginti () yra tam skirta.
Palyginti () funkcijos prototipas:
int palyginti(dydžio_tipo pradžia, dydžio_tipo skaičius, const eilutė &s) const ;- s – eilutė, kuri lyginama su iškvietimo eilute;
- start – padėtis (indeksas) eilutėje s, nuo kurios pradedama žiūrėti eilutės simbolius palyginimui;
- skaičius yra simbolių skaičius eilutėje s, lyginamas su iškviečiamąja eilute.
Funkcija veikia taip. Jei iškviečiama eilutė yra mažesnė už eilutę s , tada funkcija grąžina -1 ( neigiama vertė). Jei iškvietimo eilutė yra didesnė už eilutę s , funkcija grąžina 1 (teigiama reikšmė). Jei dvi eilutės yra lygios, funkcija grąžina 0.
Pavyzdys. Funkcijos Palyginti () demonstravimas:
// eilutės tipas, palyginimo () funkcija eilutė s1 = "012345" ; eilutė s2 = "0123456789" ; int res; res = s1.palyginti(s2); // res = -1 res = s1.palyginti("33333" ); // res = -1 res = s1.palyginti("012345" ); // res = 0 res = s1.palyginti("345" ); // res = -1 res = s1.palyginti(0, 5, s2); // res = -1 res = s2.palyginti(0, 5, s1); // res = -1 res = s1.palyginti(0, 5, "012345" ); // res = -1 res = s2.palyginti(s1); // res = 1 res = s2.palyginti("456" ); // res = -1 res = s2.palyginti("000000" ); // res = 115. Gauti eilutę su eilutės pabaigos simboliu ‘\0’ (char * ). Funkcija c_str() . Pavyzdys
Norėdami gauti eilutę, kuri baigiasi simboliu ‘\0’ Naudojama funkcija c_str().
Funkcijos prototipas:
const char * c_str() const ;Funkcija deklaruojama su const modifikatoriumi. Tai reiškia, kad funkcija negali keisti iškviečiamo objekto (eilutės).
1 pavyzdys. Konvertuojamas eilutės tipas į const char * .
// įveskite eilutę, funkciją c_str() string s = "abcdef" ; const char * ps; ps = s.c_str(); // ps = "abcdef"2 pavyzdys.
Toliau pateikiamas eilutės konvertavimo iš eilutės į System::String tipą demonstravimas, kad jis būtų rodomas etiketės valdiklyje
Paskutinį kartą atnaujinta: 2015-10-31
Sujungimas
Eilučių sujungimas arba sujungimas gali būti atliekamas naudojant + operatorių arba Concat metodą:
Styga s1 = "labas"; eilutė s2 = "pasaulis"; eilutė s3 = s1 + " " + s2; // rezultatas: string "hello world" string s4 = String.Concat(s3, "!!!"); // rezultatas: eilutė "labas pasaulis!!!" Console.WriteLine(s4);
„Concat“ metodas yra statinis „String“ klasės metodas, kurio parametrai yra dvi eilutės. Taip pat yra ir kitų metodo versijų, kurioms taikomas skirtingas parametrų skaičius.
Sujungimo metodas taip pat gali būti naudojamas jungiant eilutes:
Styga s5 = "obuolys"; eilutė s6 = "diena"; eilutė s7 = "išlaiko"; eilutė s8 = "gydytojas"; eilutė s9 = "toli"; eilutės reikšmės = nauja eilutė (s5, s6, s7, s8, s9); String s10 = String.Join(" ", reikšmės); // rezultatas: eilutė "obuolys per dieną atlaiko gydytoją"
Sujungimo metodas taip pat yra statinis. Aukščiau naudoto metodo versija turi du parametrus: skyriklio eilutę (šiuo atveju tarpą) ir eilučių masyvą, kurie bus sujungti ir atskirti skyrikliu.
Stygų palyginimas
Norėdami palyginti eilutes, naudokite statinio palyginimo metodą:
Styga s1 = "labas"; eilutė s2 = "pasaulis"; int rezultatas = String.Palyginti(s1, s2); jei (rezultatas<0) { Console.WriteLine("Строка s1 перед строкой s2"); } else if (result >0) ( Console.WriteLine("Eilutė s1 ateina po s2 eilutės"); ) else ( Console.WriteLine("S1 ir s2 eilutės yra identiškos"); ) // rezultatas bus "S1 eilutė prieš s2 eilutę"
Ši palyginimo metodo versija paima dvi eilutes ir pateikia skaičių. Jei pirmoji eilutė abėcėlės tvarka yra didesnė už antrąją, grąžinamas skaičius, mažesnis už nulį. Kitu atveju grąžinamas skaičius, didesnis už nulį. Ir trečias atvejis – jei eilutės lygios, tada grąžinamas skaičius 0.
Šiuo atveju, kadangi simbolis h yra abėcėlės tvarka didesnis už simbolį w, pirmoji eilutė bus aukštesnė.
Ieškokite eilutėje
Naudodami IndexOf metodą, galime nustatyti pirmojo vieno simbolio ar poeilės pasireiškimo eilutėje indeksą:
Styga s1 = "sveikas pasaulis"; char ch = "o"; int indexOfChar = s1.IndexOf(ch); // lygus 4 Console.WriteLine(indexOfChar); string subString = "wor"; int indexOfSubstring = s1.IndexOf(subString); // lygus 6 Console.WriteLine(indexOfSubstring);
Metodas LastIndexOf veikia panašiai, išskyrus tai, kad jis suranda paskutinio simbolio ar poeilutės pasireiškimo eilutėje indeksą.
Kita metodų grupė leidžia išsiaiškinti, ar eilutė prasideda, ar baigiasi tam tikra poeile. Tam yra sukurti metodai StartsWith ir EndsWith. Pavyzdžiui, turime užduotį iš aplanko ištrinti visus failus su plėtiniu .exe:
Eilutės kelias = @"C:\SomeDir"; string files = Directory.GetFiles(kelias); už (int i = 0; i< files.Length; i++) { if(files[i].EndsWith(".exe")) File.Delete(files[i]); }
Stygų skilimas
Naudodami funkciją Split galime padalyti eilutę į eilučių masyvą. Funkcija Split kaip parametrą paima simbolių arba eilučių masyvą, kuris bus naudojamas kaip skyriklis. Pavyzdžiui, suskaičiuokime žodžių skaičių termine, padalydami jį iš tarpo simbolių:
String text = "Ir todėl viskas atsitiko"; eilutės žodžiai = tekstas.Split(new char ( " " )); foreach (eilutė s žodžiuose) ( Console.WriteLine(s); )
Tai nėra geriausias būdas skaidyti tarpais, nes įvesties eilutėje galime turėti keletą tarpų iš eilės, o gautame masyve taip pat būtų tarpų, todėl geriau naudoti kitą metodo versiją:
Eilučių žodžiai = text.Split(new char ( " " ), StringSplitOptions.RemoveEmptyEntries);
Antrasis parametras StringSplitOptions.RemoveEmptyEntries sako, kad reikia pašalinti visas tuščias eilutes.
Linijos apkarpymas
Norėdami apkarpyti pirmuosius arba galinius simbolius, naudokite apkarpymo funkciją:
String text = "labas pasaulis"; tekstas = tekstas.Trim(); // rezultatas "hello world" text = text.Trim(new char ( "d", "h" )); // rezultatas "ello world"
Funkcija Trim be parametrų apkarpo priekinius ir galinius tarpus ir grąžina apkarpytą eilutę. Norėdami aiškiai nurodyti, kurie priekiniai ir galiniai simboliai turi būti apkarpyti, funkcijai galime perduoti tų simbolių masyvą.
Ši funkcija turi dalinius analogus: funkcija TrimStart apkarpo pradžios simbolius, o funkcija TrimEnd – pabaigos simbolius.
Apkarpyti tam tikra dalis Funkcija „Postring“ leidžia eilutes:
String text = "Laba diena"; // nutraukti pradedant nuo trečiojo simbolio tekstas = text.Substring(2); // rezultatas "laba diena" Console.WriteLine(text); // pirmiausia iškirpti iki paskutinių dviejų simbolių text = text.Substring(0, text.Length - 2); // rezultatas "roshy de" Console.WriteLine(text);
Funkcija Substring taip pat grąžina sutrumpintą eilutę. Pirmoje naudotoje versijoje indeksas naudojamas kaip parametras, nuo kurio reikia apkarpyti eilutę. Antroje versijoje naudojami du parametrai – apkarpymo pradžios indeksas ir nupjautos eilutės dalies ilgis.
Įterpti
Norėdami įterpti vieną eilutę į kitą, naudokite funkciją Įterpti:
String text = "Laba diena"; string subString = "nuostabu"; tekstas = tekstas.Insert(8, subString); Console.WriteLine(tekstas);
Pirmasis funkcijos Įterpti parametras yra indeksas, į kurį turi būti įterpta poeilutė, o antrasis parametras yra pati poeilutė.
Pašalinamos eilutės
Pašalinimo metodas padeda pašalinti dalį eilutės:
String text = "Laba diena"; // paskutinio simbolio indeksas int ind = tekstas.Ilgis - 1; // iškirpti paskutinį simbolį tekstas = text.Remove(ind); Console.WriteLine(tekstas); // iškirpti pirmuosius du simbolius text = text.Remove(0, 2);
Pirmoji pašalinimo metodo versija paima indeksą eilutėje, nuo kurios reikia pašalinti visus simbolius. Antroji versija užima dar vieną parametrą - kiek simbolių reikia pašalinti.
Pakeitimas
Norėdami pakeisti vieną simbolį ar eilutę kitu, naudokite pakeitimo metodą:
String text = "laba diena"; tekstas = tekstas.Replace("geras", "blogas"); Console.WriteLine(tekstas); tekstas = tekstas.Pakeisti("o", ""); Console.WriteLine(tekstas);
Antruoju funkcijos Replace naudojimo atveju vieno „o“ simbolio eilutė pakeičiama tuščia eilute, tai yra, ji iš tikrųjų pašalinama iš teksto. Šis metodas leidžia lengvai ištrinti konkretų tekstą eilutėse.
Keisti didžiąją raidę
Norėdami konvertuoti eilutę į didžiąsias ir mažąsias raides, naudokite atitinkamai ToUpper() ir ToLower() funkcijas:
Styga labas = "Sveikas pasaulis!"; Console.WriteLine(labas.ToLower()); // labas pasauli! Console.WriteLine(labas.ToUpper()); // SVEIKAS PASAULIS!
p»ї Patikima SEO agentūra Indija gali padidinti mažųjų įmonių pajamas
80 % vartotojų prieš pirkdami atlieka paiešką Google ir kitose paieškos sistemose, o daugiau nei 50 % per paieškos variklius sugeneruotų užklausų konvertuojama. Šie du statistiniai duomenys įrodo paieškos sistemų optimizavimo svarbą. Yra daug statistikos ir faktų, kurie aiškiai rodo: bet kokiam mažam, vidutiniam ar dideliam verslui reikia profesionalių SEO paslaugų. Mažos įmonės ir startuoliai dažnai susiduria su biudžeto problemomis. Jie gali padėti bet kuriai patikimai SEO agentūrai iš Indijos, kad gautų geriausią SEO paslaugą savo biudžete ir padidintų savo pajamas.
Paieška daro didelį poveikį vartotojų mintims. Remiantis įvairia statistika, kuria dalijasi pagrindiniai paieškos sistemų optimizavimo ekspertai įvairiose įgaliotose svetainėse, tokiose kaip Search Engine Land, Moz, SEO Journal, Digital Marketers India, Hubspot ir kt. SEO užfiksuoja daugumą potencialių klientų. Be to, potencialių klientų, gaunamų iš natūralios paieškos rezultatų, konversijų rodiklis yra didesnis. Ši statistika ir vartotojų elgesys aiškiai parodo, kad geriausia SEO paslauga yra ne prabanga, o būtinybė bet kokiam verslui.
Kad aplenktų konkurenciją ir padidintų verslo augimą, kiekviena organizacija turi naudotis Search Engine Optimization paslaugomis. Didieji prekiniai ženklai gali investuoti pakankamai pinigų į profesionalią SEO paslaugą, kurią siūlo aukščiausio lygio SEO kompanija ar SEO specialistas, tačiau smulkaus verslo savininkai dėl mažesnio biudžeto dažnai daro kompromisus dėl šios paslaugos kokybės. Sunkus faktas, kad smulkus verslas ir startuoliai galiausiai palieka galimybes, kurias galima sukurti naudojant profesionalią SEO paslaugą arba pasinaudoti pigia SEO paslauga, kuri neduoda teigiamų rezultatų.
Smulkaus verslo savininkai ir pradedančios įmonės gali pasinaudoti profesionaliomis SEO paslaugomis net ir turėdami ribotą biudžetą. Geriausias sprendimas yra rasti patikimą SEO įmonę, įsikūrusią iš Indijos. Indijoje yra daug SEO ekspertų, kurie dirba su skaitmeninės rinkodaros agentūra ir siūlo geriausias pramonės paslaugas. Jie gali suteikti jums reikiamas SEO paslaugas pagal jūsų biudžetą. Dėl darbo užmokesčio galima derėtis su SEO agentūra Indijoje, kad gautumėte geresnes paslaugas mažesnėmis kainomis. Tačiau neapsigaukite pigių SEO paslaugų, kurios kainuoja mažiau ir žada duoti daugiau, nes patirtis kainuoja savomis kainomis. Prieš sudarydami sutartį su įmone savo verslui, turite peržiūrėti portfelį arba užduoti tinkamus klausimus.
SEO ekspertai Indijoje išmano geriausią paieškos sistemų optimizavimo praktiką. Be to, Indijoje yra keletas SEO specialistų, pvz., Ash Vyas, kurie specializuojasi kuriant geriausią paieškos sistemos optimizavimo strategiją verslui pagal nurodytą biudžetą. SEO specialistai sudarys aiškų planą ir pasidalins, kokių rezultatų galima tikėtis. Taip galėsite gerai žinoti savo investicijas ir grąžą. Tai padeda priimti geresnį verslo sprendimą.
Gera idėja yra kuo greičiau susirasti ir sudaryti sutartį su patikima SEO kompanija iš Indijos, kuri siūlo geriausias SEO paslaugas. Taip pat galite pradėti nuo nedidelio biudžeto ir ribotos veiklos, kad pradėtumėte indeksuoti savo tinklalapius ir padidinti raktinius žodžius paieškos sistemose. Nelaukite tobulas laikas ar diena, kai turėsite tūkstančius dolerių investuoti į geriausias SEO paslaugas. Pradėję anksti, galėsite pasiekti greitesnių rezultatų, kai galėsite imtis agresyvaus rinkodaros metodo. Patikima SEO įmonė, įsikūrusi iš Indijos, padės jums apibrėžti dabartinius ir būsimus planus, kad pasiektumėte gerų rezultatų. Daugiau indeksuotų puslapių padidino jūsų verslo reitingus ir patikimą prekės ženklą, sukurtą taikant profesionalią SEO praktiką, užklausų skaičius, verslas ir pajamos padvigubės. Bet kuris mažas verslas gali pradėti nuo dviženklės investicijos į profesionalias SEO paslaugas. Indijoje yra daug SEO agentūrų, kurios siūlo mažą biudžetą, tačiau yra orientuotos į paieškos sistemų optimizavimo paslaugas.
apklausos iš tremties
-
CraigWew
12.04.2018p»їRyšio su klientu užmezgimo svarba nekilnojamojo turto ir bendrųjų pardavimų srityje
Ryšio su klientu užmezgimo svarba.
Ryšio su klientu užmezgimas turi būti pelnytas ir turi būti vertinamas kaip neatsiejama pardavimo proceso dalis.
Norint priversti klientą ir save susieti realiai vienas prieš vieną, reikia dviejų dalykų!
Pirma, jūs turite būti sąmoningi ir būti ten! Antra, turite suprasti, kad šio proceso metu įvyks du skirtingi etapai.
A-Būk ten, ką tai reiškia?
o Dauguma žmonių iš tikrųjų neklauso kito žmogaus, kai jis kalba. Paprastai jie yra taip užsiėmę formuluodami kitą atsakymą ar teiginį, kad negali iš tikrųjų išklausyti.
o Jei tai skamba kaip jūs, būti ten reiškia užsičiaupti ir klausytis!
B-Kas yra pirmasis arba pradinis etapas?
o Paprastai jūs turite vos kelias minutes, kad įsitvirtintumėte klientų mintyse kaip asmuo, su kuriuo jie nori bendrauti.
o Kilus abejonėms, geriausia pirmiausia užduoti klausimus, kurie juos sudomins ir papasakos apie save.
o Taip pat visada saugu pasirodyti kaip profesionalui – aš neturiu galvoje stoiką ar sausą, o žmogų, kuris žino, ką daro, kalba ir atrodo kaip žmogus.
C-Kiti etapai
o Laikui bėgant, per pokalbį ir jiems kils klausimus, jūs arba nustatysite savo sugebėjimus, arba ne.
o Žinokite, kad jie tikriausiai kurį laiką jus matuos. Geros naujienos yra tai, kad tam tikru momentu, jei jums pasisekė užmegzti ryšį, jie atsipalaiduos ir galėsite susikoncentruoti ties būsto paieška arba pardavimu.
Kas dar gali padėti man užmegzti ryšį?
o Bandydami suprasti skirtingus asmenybės tipus, tada sakydami ir užduodami tinkamus klausimus.
o Jei turite gerus santykius (turite tokį patį bangos ilgį kaip ir klientas), tada pardavimas iš esmės baigtas, dabar belieka rasti tinkamą namą arba užpildyti sąrašo dokumentus.
Ką jau kalbėti apie skirtingas asmenybes
o Kadangi tai nėra knyga apie psichiatriją, dabar tiesiog supraskite du pagrindinius tipus.
o Yra intravertų ir ekstravertų žmonių.
o Jūs žinote tipą. Pagalvokite apie tris pažįstamus žmones, kurie atitinka kiekvieną klasifikaciją.
Ką apie kūno kalbą ir kalbos modelius?
o Jei jie kalba greitai arba lėtai, stenkitės mėgdžioti jų kalbos modelius.
o Jei jie kalba garsiai arba tyliai, darykite tą patį. Ar jie palinkę į priekį ar atgal?
o Nereikia nė sakyti, kad šia tema parašyta daug knygų. Tiesiog atminkite, kad tai yra svarbus veiksnys, ypač kai sėdite konferencijų salėje arba kieno nors namuose aptariate 400 000 USD sandorį.
Ryšio ugdymas yra įgūdis, kurio galima išmokti ir tobulinti.
o Mes visi esame patyrę pardavėją, kuris mums kažką pardavė, tačiau nesijautėme, kad mus parduoda. Priežastis ta, kad jis ar ji privertė jus jaustis patogiai ten, kur jais pasitikėjote.
Kaip plėtojame ryšį?
o Naudokite akis ir ausis ir užduokite klausimus. Norėdami paaiškinti
o Naudokite akis:
o Pažiūrėkite į jų suknelę – į automobilį – į asmeninį turtą ir aš turiu galvoje, kad tikrai pažiūrėkite į juos ir iššifruokite, ką tai jums apie juos pasakoja.
o Naudokite ausis:
o Klausykite, ką jie sako, ir užduokite klausimus, kad išsiaiškintumėte savo tikrąją MOTYVACIJĄ!
Dabar per visą šį pokalbį tikriausiai atrasite vieną ar du dalykus, kurie jus sieja su jais. (Šeima, geografinės vietovės, žvejyba ir t. t.) Kai susiduriate su bendromis mintimis, praneškite jiems, kad esate pažįstami, ir skirkite minutę tai su jais aptarti.
Kas yra Tikslas?
o Kai jie priims jus kaip vieną iš jų, jūs tikrai turėsite didelę pardavimo patirtį, nes dabar dirbate kartu, o tada kaip komanda – nebesate tas pardavėjas, kurį dabar užimate patarėjo pareigas. .
o Atsiminkite, klientas arba leis, arba neleis jums patekti į jo pasaulį. Jei tai suprasite ir tikrai sunkiai dirbsite, kad taptumėte jam/jai empatiški, galite įgyti pasitikėjimo poziciją. Daugeliu atvejų jūs iš tikrųjų matysite, kaip jie atsipalaiduoja (kūno kalba), kai tai atsitiks jums pakeliui.
o Norėdami tai iliustruoti, ar kada nors pasakėte kalbą ir pastebėjote, kad kai pagaliau susisiekėte su auditorijos nariu, jie pritariamai linktels. Visi šie dalykai gali atrodyti banalūs, bet taip nėra.
Pabaigai, jei galite užsitarnauti klientų pasitikėjimą, parduoti produktą ar paslaugą yra daug lengviau, o patirtis gali būti maloni visiems dalyvaujantiems.
Visada atminkite, kad laimėjimas / laimėjimas yra geriausia situacija.
Bandau palyginti simbolių masyvą su tokia eilute:
Const char *var1 = " "; var1 = getenv("manoEnvVar"); if(var1 == "dev") ( // daryti dalykus )
Šis if teiginys niekada nepasitvirtina... kai išvedu var1 tai yra "dev" , pagalvojau, kad gal tai turi ką nors bendro su nuliniu terminu, bet strlen "dev" ir var1 yra lygūs... Aš taip pat pagalvojau, kad galbūt var1 = = "dev" lygino "dev" su var1 atminties adresu, o ne reikšme. *var1 == "dev" sukelia klaidą.... išbandžiau daug dalykų, gal paprastas sprendimas, skirtas saavy C++ kūrėjui (seniai nekodavau C++).
Redaguoti: bandėme
If(strcmp(var1, "dev") == 0)
If(strncmp(var1, "dev", 3) == 0)
Redaguoti: Išbandžius namuose, aš tiesiog siūlau mano bendradarbiui pakeisti duomenų tipą į eilutę. Manau, kad jis palygino didelio dydžio char masyvą su eilute. Sukūriau programą, kuri spausdina sizeof, strlen ir kt., kad padėtų mums tai padaryti. Ačiū visiems už pagalbą.
6 atsakymai
Jūs nedirbate su stygomis. Jūs dirbate su rodyklėmis.
var1 yra char rodyklė (const char*). Tai nėra eilutė. Jei jis nulinis, kai kurios C funkcijos traktuos ją kaip eilutę, bet iš esmės tai tik rodyklė.
Taigi, kai lyginate jį su char masyvu, masyvas suskaidomas į žymeklį, o tada kompiliatorius bando rasti operatorių == (const char*, const char*) .
Toks operatorius egzistuoja. Ji priima dvi rodykles ir grąžina teisingą, jei jos nukreipia į tą patį adresą. Taigi kompiliatorius tai iškviečia ir jūsų kodas sugenda.
Jei norite palyginti eilutes, turite pasakyti kompiliatoriui, kad norite dirbti su eilutėmis, o ne su rodyklėmis.
Norėdami tai padaryti, turite naudoti strcmp funkciją:
Strcmp(var1, "dev");
Tai grąžina nulį, jei dvi eilutės yra lygios. (Jei kairioji pusė yra leksikografiškai didesnė už dešinę, ji pateiks reikšmę, didesnę už nulį, o kitu atveju – mažesnę už nulį.)
Taigi, norėdami palyginti lygybę, turite atlikti vieną iš šių veiksmų:
If (!strcmp(var1, "dev"))(...) if (strcmp(var1, "dev") == 0) (...)
Std::string var1 = getenv("myEnvVar"); if(var1 == "dev") ( // daryti dalykus )
Kompiliatorius dabar susiduria su eilutės ir simbolio rodyklės palyginimu. Jis gali tai susidoroti, nes simbolio rodyklė gali būti netiesiogiai konvertuojama į eilutę, suteikiant eilutės palyginimą. Ir jie elgiasi taip, kaip tikėjotės.
Šiame kode jūs lyginate ne eilutės reikšmes, o rodyklės reikšmes. Jei norite palyginti eilučių reikšmes, turite naudoti eilučių palyginimo funkciją, pvz., strcmp.
Jei (0 == strcmp(var1, "dev")) ( .. )
"dev" nėra eilutė, tai yra const char * kaip var1. Tokiu būdu jūs iš tikrųjų lyginate atminties adresus. Kadangi var1 yra char rodyklė, *var1 yra vienas simbolis (tiksliau, pirmasis nurodytos simbolių sekos simbolis). Negalite lyginti char su char rodykle, todėl jis neveikė. Antraštėje pridėkite deklaraciją
// Parametrai naudoja "const", kad išvengtų galimo objekto sugadinimo. bool string_equal (const char* arg0, const char* arg1);
Norėdami naudoti, tiesiog pakvieskite „string_equal“ kaip if (arba trijų dalių) sakinio / bloko sąlygą.
If (string_equal (var1, "dev")) ( // Tai lygu, darykite tai, ko reikia čia. ) else ( // Nelygu, darykite tai, ko reikia čia (neprivaloma). )
34--- C# vadovas --- Stygos
Įprasto programavimo požiūriu, eilutė eilutės duomenų tipas yra vienas iš svarbiausių C#. Šis tipas apibrėžia ir palaiko simbolių eilutes. Daugelyje kitų programavimo kalbų eilutė yra simbolių masyvas. Ir C #, eilutės yra objektai. Todėl eilutės tipas yra nuorodos tipas.
Statybinės stygos
Paprasčiausias būdas sukurti simbolių eilutę yra naudoti eilutės literalą. Pavyzdžiui, ši kodo eilutė eilutės nuorodos kintamajam str priskiria nuorodą į eilutės literalą:
String str = "Eilutės pavyzdys";
Šiuo atveju kintamasis str inicijuojamas simbolių seka „Example String“. String tipo objektas taip pat gali būti sukurtas iš char tipo masyvo. Pavyzdžiui:
Chararray = („e“, „x“, „a“, „m“, „p“, „l“, „e“); string str = nauja eilutė(chararray);
Sukūrus eilutės objektą, jį galima naudoti bet kur, kur reikia teksto eilutės su kabutėmis.
Styginių atkaklumas
Kaip bebūtų keista, eilutės tipo objekto turinio pakeisti negalima. Tai reiškia, kad sukūrus simbolių seką, jos pakeisti negalima. Tačiau šis apribojimas prisideda prie efektyvesnio simbolių eilučių įgyvendinimo. Todėl šis iš pažiūros akivaizdus trūkumas iš tikrųjų virsta privalumu. Taigi, jei eilutė reikalinga kaip esamos eilutės variantas, šiuo tikslu reikia sukurti naują eilutę, kurioje būtų visi reikalingi pakeitimai. Ir kadangi nepanaudoti eilutės objektai automatiškai surenkami kaip šiukšlės, ateities likimas Jums net nereikia jaudintis dėl nereikalingų eilučių.
Tačiau reikia pabrėžti, kad kintamųjų nuorodos į eilutes (ty eilutės tipo objektus) gali keistis, todėl jos gali nurodyti kitą objektą. Tačiau paties eilutės objekto turinys po jo sukūrimo nesikeičia.
Pažiūrėkime į pavyzdį:
Static void addNewString() ( string s = "Tai mano potėpis"; s = "Tai naujas potėpis"; )
Sukompiliuokime programą ir gautą rinkinį įkelkime į ildasm.exe įrankį. Paveikslėlyje parodytas CIL kodas, kuris bus sugeneruotas negaliojančiam addNewString() metodui:
Atkreipkite dėmesį, kad yra daug iškvietimų į ldstr (eilutės įkrovos) opcode. Šis CIL ldstr opkodas įkelia naują eilutės objektą į valdomą krūvą. Dėl to ankstesnis objektas, kuriame buvo reikšmė „Tai mano potėpis“, ilgainiui bus surinktas.
Darbas su stygomis
Klasėje Sistema.Styga pateikiamas metodų rinkinys, leidžiantis nustatyti simbolių duomenų ilgį, ieškoti poeilutės esamoje eilutėje, konvertuoti simbolius iš didžiųjų į mažąsias ir atvirkščiai ir kt. Toliau mes apžvelgsime šią klasę išsamiau.
Lauko, rodyklės ir eilutės klasės ypatybė
Styginių klasė apibrėžia vieną lauką:
Vieša statinė tik skaitoma eilutė Tuščia;
Laukas Empty žymi tuščią eilutę, t.y. eilutė, kurioje nėra jokių simbolių. Tai skiriasi nuo tuščios eilutės nuorodos, kuri tiesiog daroma į neegzistuojantį objektą.
Be to, eilutės klasė apibrėžia vieną tik skaitomą indeksatorių:
Viešai paženklink tai ( gauti; )
Šis indeksavimo įrankis leidžia gauti simbolį nurodytoje rodyklėje. Eilučių, kaip ir masyvų, indeksavimas prasideda nuo nulio. Styginių objektai yra patvarūs ir nesikeičia, todėl logiška, kad Styginių klasė palaiko tik skaitymo indeksavimo priemonę.
Galiausiai, eilutės klasė apibrėžia vieną tik skaitymo ypatybę:
Viešas int Ilgis (gauti; )
Savybė Length grąžina simbolių skaičių eilutėje. Toliau pateiktame pavyzdyje parodytas rodyklės ir ilgio savybės naudojimas:
Sistemos naudojimas; class Pavyzdys ( static void Main() ( string str = "Paprasta eilutė"; // Gaukite eilutės ilgį ir 6-ąjį simbolį eilutėje naudodami indeksavimo priemonę Console.WriteLine("Eilutės ilgis - (0), 6th simbolis - "(1)"" , str.Length, str);
Styginių klasės operatoriai
Styginių klasė perkrauna šiuos du operatorius: == ir !=. == operatorius naudojamas dviejų simbolių eilučių lygybei patikrinti. Kai objektų nuorodoms taikomas operatorius ==, jis paprastai patikrina, ar abi nuorodos daromos į tą patį objektą. O kai operatorius == taikomas nuorodoms į String tipo objektus, lygybė lyginama su pačių eilučių turiniu. Tas pats pasakytina ir apie operatorių !=. Kai jis taikomas nuorodoms į String tipo objektus, pačių eilučių turinys lyginamas dėl nelygybės. Tačiau kiti reliaciniai operatoriai, įskaitant =, lygina nuorodas į String tipo objektus taip pat, kaip lygina nuorodas į kitų tipų objektus. Ir norėdami patikrinti, ar viena eilutė yra didesnė už kitą, turėtumėte iškviesti Palyginti () metodą, apibrėžtą eilutės klasėje.
Kaip paaiškės, daugelis simbolių eilučių palyginimo tipų remiasi kultūrine informacija. Bet tai netaikoma == ir != operatoriams. Galų gale, jie tiesiog lygina eilučių simbolių reikšmes. (Kitaip tariant, jie lygina dvejetaines simbolių reikšmes, kurios nebuvo modifikuotos kultūros normų, ty lokalių standartų.) Todėl šie operatoriai atlieka eilučių palyginimus nejausdami didžiųjų ir mažųjų raidžių ir kultūrai.
Styginių klasės metodai
Šioje lentelėje pateikiami kai kurie įdomiausi šios klasės metodai, sugrupuoti pagal paskirtį:
| Metodas | Struktūra ir perkrovos | Tikslas |
|---|---|---|
| Stygų palyginimas | ||
| palyginti () | viešas statinis int Palyginti (string strA, string strB) Viešas statinis int Palyginti (string strA, string strB, bool ignoreCase) Viešas statinis int Palyginti (eilutė strA, eilutė strB, eilutės palyginimo palyginimo tipas) Viešas statinis int Palyginti (string strA, string strB, bool ignoreCase, CultureInfo kultūra) |
Statinis metodas lygina eilutę strA su eilute strB. Grąžina teigiamą reikšmę, jei strA yra didesnis nei strB; neigiamas, jei strA yra mažesnis už strB; ir nulis, jei eilutės strA ir strB yra lygios. Palyginimai atliekami remiantis registru ir kultūra. Jei ignoreCase įvertinama kaip tiesa, palyginime neatsižvelgiama į skirtumus tarp didžiųjų ir mažųjų raidžių. Kitu atveju į šiuos skirtumus atsižvelgiama. Parametras „completionType“ nurodo konkretų eilučių palyginimo būdą. CultureInfo klasė yra apibrėžta System.Globalization vardų erdvėje. |
| viešas statinis int Palyginti (string strA, int indexA, string strB, int indexB, int ilgis) Viešas statinis int Palyginti (string strA, int indexA, string strB, int indexB, int ilgis, bool ignoreCase) Viešas statinis int Palyginti (string strA, int indexA, string strB, int indexB, int ilgis, StringComparison palyginimo tipas) Viešas statinis int Palyginti (string strA, int indexA, string strB, int indexB, int ilgis, bool ignoreCase, CultureInfo kultūra) |
Lygina stygų strA ir strB dalis. Palyginimas prasideda eilutės elementais strA ir strB ir apima ilgio parametro nurodytą simbolių skaičių. Metodas grąžina teigiamą reikšmę, jei dalis eilutės strA yra didesnė nei eilutės strB dalis; neigiama reikšmė, jei eilutės strA dalis yra mažesnė nei eilutės strB dalis; ir nulis, jei lyginamų eilučių strA ir strB dalys yra lygios. Palyginimai atliekami remiantis registru ir kultūra. |
|
| Palyginti eilinį () | public static int Palyginti eilutę(string strA, string strB) Viešas statinis int Palyginti eilės eilutę (string strA, int indexA, string strB, int indexB, int count) |
Atlieka tą patį, ką palyginimo () metodas, tačiau neatsižvelgiama į vietinius nustatymus |
| Palyginti su () | viešas int Palyginti su(objekto vertė) | Lygina iškvietimo eilutę su vertės objekto eilutės atvaizdavimu. Grąžina teigiamą reikšmę, jei iškvietimo eilutė yra didesnė už reikšmę; neigiamas, jei iškvietimo eilutė yra mažesnė už reikšmę; ir nulis, jei lyginamos eilutės yra lygios |
| viešas int Palyginti su(string strB) | Lygina skambinimo eilutę su eilute strB |
|
| Lygu () | viešas nepaisymas bool lygus (objekto objektas) | Grąžina loginę reikšmę true, jei iškviečiamoje eilutėje yra tokia pati simbolių seka kaip ir obj eilutės vaizde. Atlieka eilinį palyginimą, kuriame skiriamos didžiosios ir mažosios raidės, bet kultūriškai nejautrus |
| viešoji bool Lygu (eilutės reikšmė) Viešoji bool lygi (eilutės vertė, eilutės palyginimo tipas) |
Grąžina loginę reikšmę true, jei iškvietimo eilutėje yra tokia pati simbolių seka kaip ir eilutės reikšmė. Atliekamas eilinis palyginimas, kuriame skiriamos didžiosios ir mažosios raidės, bet ne kultūriškai. Parametras „completionType“ nurodo konkretų eilučių palyginimo būdą |
|
| vieša statinė bool Lygu (eilutė a, eilutė b) Viešas statinis bool lygus (eilutė a, eilutė b, eilutės palyginimo palyginimo tipas) |
Grąžina loginę reikšmę true, jei eilutėje a yra tokia pati simbolių seka kaip eilutėje b . Atliekamas eilinis palyginimas, kuriame skiriamos didžiosios ir mažosios raidės, bet ne kultūriškai. Parametras „completionType“ nurodo konkretų eilučių palyginimo būdą |
|
| Eilučių sujungimas (jungimas). | ||
| Concat () | vieša statinė eilutė Concat(string str0, string str1); vieša statinė eilutė Concat(params eilutės reikšmės); |
Sujungia atskirus eilutės atvejus į vieną eilutę (sujungimas) |
| Ieškokite eilutėje | ||
| Sudėtyje yra () | public bool Yra (eilutės reikšmė) | Metodas, leidžiantis nustatyti, ar eilutėje yra konkreti poeilutė (reikšmė) |
| Pradeda nuo () | viešoji bool Pradeda nuo (eilutės reikšmė) Viešoji bool prasideda nuo(eilutės reikšmė, eilutės palyginimo tipas) |
Grąžina loginę reikšmę true, jei iškvietimo eilutė prasideda poeilutės reikšme. Kitu atveju grąžinama loginė vertė false. Parametras „CommunityType“ nurodo konkretų paieškos atlikimo būdą |
| Baigiasi () | public bool EndsWith (eilutės reikšmė) Vieša bool EndsWith (eilutės reikšmė, eilutės palyginimo tipas) |
Grąžina loginę reikšmę true, jei iškvietimo eilutė baigiasi poeilutės reikšme. Kitu atveju grąžina loginę reikšmę false. Parametras „CommunityType“ nurodo konkretų paieškos metodą |
| IndexOf() | public int IndexOf(char reikšmė) Viešoji int IndexOf (eilutės reikšmė) |
Suranda pirmąjį tam tikros poeilutės ar simbolio atvejį eilutėje. Jei ieškomas simbolis arba poeilutė nerandama, grąžinama reikšmė -1. |
| public int IndexOf(char reikšmė, int startIndex) Viešas int IndexOf (eilutės reikšmė, int startIndex) Viešoji int IndexOf(char reikšmė, int startIndex, int count) Viešoji int IndexOf (eilutės reikšmė, int startIndex, int count) |
Grąžina pirmojo simbolio arba poeilutės reikšmės pasireiškimo iškvietimo eilutėje indeksą. Paieška prasideda nuo elemento, nurodyto startIndex, ir apima elementų skaičių, nurodytą pagal skaičių (jei nurodyta). Metodas grąžina -1, jei ieškomas simbolis arba poeilutė nerasta |
|
| LastIndexOf() | Perkrautos versijos yra panašios į IndexOf() metodą | Tas pats kaip IndexOf, bet randa ne pirmą, o paskutinį simbolio ar poeilutės pasireiškimą |
| IndexOfAny() | public int IndexOfAny(char anyOf) Viešas int IndexOfAny(char anyOf, int startIndex) Viešas int IndexOfAny(char anyOf, int startIndex, int count) |
Grąžina pirmojo bet kurio simbolio iš anyOf masyvo, rasto iškvietimo eilutėje, pasireiškimo indeksą. Paieška prasideda nuo elemento, nurodyto startIndex, ir apima elementų skaičių, nurodytą pagal skaičių (jei nurodyta). Metodas grąžina -1, jei nėra atitikimo anyOf masyve. Krata atliekama eiline tvarka |
| LastIndexOfAny | Perkrautos versijos yra panašios į IndexOfAny() metodą | Grąžina paskutinio bet kurio simbolio iš anyOf masyvo, rasto skambinimo eilutėje, indeksą |
| Stygų skaidymas ir sujungimas | ||
| Padalinti | viešoji eilutė Padalyti (paramų simbolių skyriklis) Vieša eilutė Paskaidyta (paramų simbolių skyriklis, int skaičius) |
Metodas, grąžinantis eilučių masyvą, kurio viduje yra šiame pavyzdyje esančios poeilutės, kurios viena nuo kitos yra atskirtos elementais iš nurodyto simbolio arba eilučių masyvo. Pirmoji Split() metodo forma padalija iškvietimo eilutę į sudedamąsias dalis. Rezultatas yra masyvas, kuriame yra poeilutės, gautos iš iškvietimo eilutės. Šias eilutes ribojantys simboliai perduodami skyriklio masyve. Jei skyriklio masyvas yra tuščias arba nurodo tuščią eilutę, tarpas naudojamas kaip poeilutės skyriklis. O antroje šio metodo formoje grąžinamas eilučių skaičius, nustatytas pagal skaičiavimo parametrą. |
| viešoji eilutė Split (paramų simbolių skyriklis, StringSplitOptions parinktys) Vieša eilutės padalijimas (eilutės skyriklis, StringSplitOptions parinktys) Vieša eilutės padalijimas (paramų simbolių skyriklis, int count, StringSplitOptions parinktys) Viešoji eilutės padalijimas (eilutės skyriklis, int count, StringSplitOptions parinktys) |
Pirmosiose dviejose Split() metodo formose iškvietimo eilutė yra padalyta į dalis ir grąžinamas masyvas, kuriame yra poeilutės, gautos iš iškvietimo eilutės. Simboliai, skiriantys šias eilutes, perduodami skyriklio masyve. Jei skyriklio masyvas tuščias, tarpas naudojamas kaip skyriklis. O trečioje ir ketvirtoje šio metodo formose grąžinamas eilučių skaičius, kurį riboja skaičiavimo parametras. Bet visų formų parametras parinktys nurodo konkretų būdą, kaip tvarkyti tuščias eilutes, kurios sukuriamos, kai du skyrikliai yra greta. Sąrašas „StringSplitOptions“ apibrėžia tik dvi reikšmes: Nėra Ir PašalintiEmptyEntries. Jei parinktys yra Nėra, tuščios eilutės įtraukiamos į galutinį pradinės eilutės padalijimo rezultatą. Ir jei parinkčių parametras nustatytas į RemoveEmptyEntries, tuščios eilutės neįtraukiamos į galutinį pradinės eilutės padalijimo rezultatą. |
|
| Prisijunk () | vieša statinė eilutė Prisijungimas (eilutės skyriklis, eilutės reikšmė) Vieša statinė eilutė Sujungimas (eilutės skyriklis, eilutės reikšmė, int startIndex, int count) |
Sukuria naują eilutę, derindama eilučių masyvo turinį. Pirmoji metodo Join() forma grąžina eilutę, susidedančią iš sujungtų poeilučių, perduodamų reikšmių masyve. Antroji forma taip pat grąžina eilutę, kurią sudaro reikšmių masyve perduotos poeilutės, tačiau jos sujungiamos tam tikru skaičių skaičiumi, pradedant reikšmių masyvo elementu. Abiejose formose kiekviena paskesnė eilutė yra atskirta nuo ankstesnės eilutės skiriamąja linija, nurodyta skyriklio parametru. |
| Užpildymo ir kirpimo linijos | ||
| Trim () | vieša eilutė Trim() Vieša eilutė Trim (params char trimChars) |
Metodas, leidžiantis pašalinti visus konkretaus simbolių rinkinio atvejus nuo dabartinės eilutės pradžios ir pabaigos. Pirmoji Trim() metodo forma pašalina iškvietimo eilutės priekinius ir galinius tarpus. O antroji šio metodo forma pašalina pirminius ir galinius iškvietimo simbolių eilutės atvejus iš trimChars masyvo. Abi formos grąžina gautą eilutę. |
| PadLeft () | vieša eilutė PadLeft(int totalWidth) Vieša eilutė PadLeft(int totalWidth, char paddingChar) |
Leidžia užpildyti eilutę su simboliais kairėje. Pirmoji metodo PadLeft() forma įveda tarpus kairėje iškviečiamosios eilutės pusėje, kad bendras jos ilgis taptų lygi vertei totalWidth parametras. O antroje šio metodo formoje simboliai, pažymėti parametru paddingChar, įvedami kairėje iškvietimo eilutės pusėje, kad bendras jos ilgis taptų lygus parametro totalWidth reikšmei. Abi formos grąžina gautą eilutę. Jei parametro totalWidth reikšmė yra mažesnė už iškvietimo eilutės ilgį, grąžinama nepakeistos iškvietimo eilutės kopija. |
| PadRight () | Tas pats kaip PadLeft() | Leidžia pridėti eilutę su simboliais dešinėje. |
| Eilučių įterpimas, trynimas ir pakeitimas | ||
| Įterpti () | viešoji eilutė Įterpti(int startIndex, eilutės reikšmė) | Naudojama vienai eilutei įterpti į kitą, kur reikšmė nurodo eilutę, kuri turi būti įterpta į iškvietimo eilutę startIndex. Metodas grąžina gautą eilutę. |
| Pašalinti () | vieša eilutė Pašalinti(int startIndex) Vieša eilutė Pašalinti (int startIndex, int count) |
Naudojamas eilutės daliai pašalinti. Pirmoje Remove() metodo formoje pašalinimas prasideda startIndex nurodytoje vietoje ir tęsiasi iki eilutės pabaigos. Ir antroje šio metodo formoje simbolių skaičius, nustatytas pagal skaičiavimo parametrą, pašalinamas iš eilutės, pradedant nuo startIndex indekso nurodytos vietos. |
| Pakeisti () | viešoji eilutė Pakeisti (char oldChar, char newChar) Vieša eilutė Pakeisti (eilutė oldValue, eilutė newValue) |
Naudojamas pakeisti dalį eilutės. Pirmoje Replace() metodo formoje visi simbolio oldChar atvejai iškvietimo eilutėje pakeičiami simboliu newChar. O antroje šio metodo formoje visi eilutės oldValue atvejai iškviečiamojoje eilutėje pakeičiami eilute newValue. |
| Keisti didžiąją raidę | ||
| ToUpper() | vieša eilutė ToUpper() | Visos skambinimo eilutės raidės rašomos didžiosiomis raidėmis. |
| Žemiau () | vieša eilutė ToLower() | Visos skambinimo eilutės raidės yra mažosios. |
| Poeilutės gavimas iš eilutės | ||
| Poeilutė () | viešoji eilutė Poeilutė (int startIndex) Vieša eilutė Poeilutė (int startIndex, int ilgis) |
Pirmoje substring() metodo formoje poeilutė gaunama pradedant nuo startindex parametro nurodytos vietos ir baigiant iškvietimo eilutės pabaiga. O antroje šio metodo formoje ištraukiama poeilutė, susidedanti iš ilgio parametro nustatyto simbolių skaičiaus, pradedant nuo startIndex parametro nurodytos vietos. |
Toliau pateiktoje pavyzdinėje programoje naudojami keli iš pirmiau minėtų metodų:
Sistemos naudojimas; naudojant System.Collections.Generic; naudojant System.Linq; naudojant System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args)) ( // Palyginkite pirmas dvi eilutes string s1 = "tai yra eilutė"; string s2 = "tai tekstas, o tai yra eilutė"; if (String. PalygintiOrdinal(s1, s2) != 0) Console.WriteLine("Stygos s1 ir s2 nėra lygios"); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine ("Tačiau juose yra tas pats tekstas" // Eilučių sujungimas Console.WriteLine(String.Concat("\n" + "One, two ","tree, four") // Ieškoti eilutėje //); / Pirmasis poeilutės įvykis if (s2. IndexOf("this") != -1) Console.WriteLine("Žodis \"this\" randamas eilutėje, jis yra "+ "esantis: (0) pozicija", s2.IndexOf("this")); / Paskutinis poeilutės įvykis if (s2.LastIndexOf("this") != -1) Console.WriteLine("Paskutinis žodžio \"this\" yra " + "(0) pozicijoje", s2.LastIndexOf("this" )); // Ieškokite iš simbolių masyvo char myCh = ("Y","x", "t"); if (s2. IndexOfAny(myCh) != -1) Console.WriteLine("Vienas iš simbolių iš masyvo ch "+ "rastas dabartinėje eilutėje pozicijoje (0)", s2.IndexOfAny(myCh));
// Nustatykite, ar eilutė prasideda duota eilute if (s2.StartsWith("tai tekstas") == true) Console.WriteLine("Poeilutė rasta!");
// Nustatykite, ar eilutėje yra poeilutė // naudodamiesi vartotojo OS eilutės nustatymo pavyzdžiu myOS = Environment.OSVersion.ToString();
if (myOS.Contains("NT 5.1")) Console.WriteLine("Jūsų operacinė sistema yra Windows XP");
else if (myOS.Contains("NT 6.1")) Console.WriteLine("Jūsų operacinė sistema yra Windows 7"); Console.ReadLine();), kad nustatytų, ar viena eilutė yra didesnė, mažesnė už kitą eilutę arba jai lygi. Palyginus eilės tvarka, eilutės tiesiog išdėstomos pagal nepakeistą kiekvieno simbolio reikšmę.
Dėl skirtingų kultūrinių eilučių palyginimų ir eilinių palyginimų skirtumų ir kiekvieno tokio palyginimo pasekmių primygtinai rekomenduojame vadovautis geriausios praktikos pavyzdžiais, kuriuos šiuo metu siūlo „Microsoft“. Galų gale, pasirinkus netinkamą eilučių palyginimo metodą, programa gali veikti netinkamai, kai ji veikia kitoje aplinkoje, nei buvo sukurta.
Pasirinkimas, kaip palyginti simbolių eilutes, yra labai svarbus sprendimas. Paprastai ir be išimties turėtumėte pasirinkti lyginti eilutes kultūriškai jautriu būdu, jei tai daroma siekiant vartotojui parodyti rezultatą (pavyzdžiui, kad būtų rodoma eilučių serija, surūšiuota leksikografine tvarka). Tačiau jei eilutėse yra fiksuotos informacijos, kurios neketinama keisti atsižvelgiant į kultūrinius skirtumus, pvz., failo pavadinimas, raktinis žodis, svetainės adresas arba saugos reikšmė, turėtumėte pasirinkti eilinių eilučių palyginimą. Žinoma, konkrečios kuriamos programos charakteristikos lems tinkamo metodo simbolių eilučių palyginimui pasirinkimą.
Styginių klasėje pateikiami įvairūs eilučių palyginimo metodai, kurie išvardyti aukščiau esančioje lentelėje. Universaliausias iš jų yra Compare() metodas. Tai leidžia visiškai arba iš dalies palyginti dvi eilutes, skiriant didžiąsias ir mažąsias arba neskiriančias didžiąsias ir mažąsias raides, tipo parametro nurodytu būdu Styginių palyginimas, taip pat tipo parametro teikiama kultūrinė informacija Kultūros informacija.
Tos Compare() metodo perkrovos, kurios neapima StringComparison parametro, atlieka simbolių eilučių palyginimą pagal didžiąsias ir mažąsias raides ir kultūrą. O tuose perkrautuose variantuose, kuriuose nėra CultureInfo tipo parametro, informaciją apie kultūrinę aplinką lemia esama vykdymo aplinka.
„StringComparison“ tipas yra sąrašas, apibrėžiantis reikšmes, parodytas toliau esančioje lentelėje. Naudodami šias reikšmes galite sukurti eilučių palyginimus, atitinkančius jūsų konkrečios programos poreikius. Todėl, pridėjus StringComparison tipo parametrą, išplečiamos Compare() metodo ir kitų palyginimo metodų, pvz., Equals(), galimybės. Tai taip pat leidžia vienareikšmiškai nurodyti, kaip eilutes ketinama palyginti.
Dėl kultūriškai jautrių eilučių palyginimų ir eilinių palyginimų skirtumų svarbu šiuo atžvilgiu būti kuo tikslesni.
| Reikšmė | Aprašymas |
|---|---|
| CurrentCulture | Stygų palyginimai atliekami naudojant dabartines kultūrinės aplinkos nuostatas |
| CurrentCultureIgnoreCase | Eilučių palyginimai atliekami naudojant dabartinius kultūros nustatymus, tačiau neskiriamos didžiosios ir mažosios raidės |
| Nekintamoji kultūra | Stygų palyginimai atliekami naudojant nekintamuosius, t.y. universalūs duomenys apie kultūrinę aplinką |
| InvariantCultureIgnoreCase | Stygų palyginimai atliekami naudojant nekintamuosius, t.y. universalūs kultūros duomenys ir neskiriami didžiųjų ir mažųjų raidžių |
| Eilinis | Eilučių palyginimai atliekami naudojant eilutės simbolių eilės vertes. Tokiu atveju gali sutrikti leksikografinė tvarka, ir simboliai priimti tam tikroje kultūrinėje aplinkoje yra ignoruojami |
| Ordinal IgnoreCase | Eilučių palyginimas atliekamas naudojant eilutės simbolių eilės vertes, bet neskiriamos didžiosios ir mažosios raidės |
Bet kuriuo atveju metodas Compare() grąžina neigiamą reikšmę, jei pirmoji palyginta eilutė yra mažesnė už antrąją; teigiamas, jei pirmoji palyginta eilutė yra didesnė už antrąją; ir galiausiai nulis, jei abi lyginamos eilutės yra lygios. Nors metodas Compare() grąžina nulį, jei lyginamos eilutės yra lygios, paprastai geriau naudoti Equals() metodą arba == operatorių, kad nustatytų, ar simbolių eilutės yra lygios.
Faktas yra tai, kad Compare() metodas nustato lyginamų eilučių lygybę pagal jų rūšiavimo tvarką. Taigi, jei stygų kultūrinis palyginimas atliekamas, abi eilutės gali būti vienodos savo rūšiavimo tvarka, bet nevienodos iš esmės. Pagal numatytuosius nustatymus eilučių lygybė nustatoma naudojant Equals() metodą, remiantis simbolių eilės reikšmėmis ir neatsižvelgiant į kultūrinę aplinką. Todėl pagal numatytuosius nustatymus abi eilutės lyginamos šiuo metodu, siekiant absoliučios lygybės po simbolius, panašiai kaip tai daroma naudojant operatorių ==.
Nepaisant didelio Compare() metodo universalumo, paprastam simbolių eilučių eiliniam palyginimui lengviau naudoti CompareOrdinal() metodą. Galiausiai atminkite, kad CompareTo() metodas atlieka tik kultūriškai jautrių eilučių palyginimus.
Toliau pateiktoje programoje parodytas Compare(), Equals(), CompareOrdinal() metodų ir == ir != operatorių naudojimas simbolių eilutėms palyginti. Atkreipkite dėmesį, kad pirmieji du palyginimo pavyzdžiai aiškiai parodo skirtumus tarp kultūriškai jautrių eilučių palyginimų ir eilinių palyginimų angliškai kalbančioje aplinkoje:
Sistemos naudojimas; class Pavyzdys ( static void Main() ( string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alfa, beta"; int rezultatas; / / Pirmiausia pademonstruokite skirtumus tarp kultūrai jautrių eilučių palyginimo // ir eilės palyginimo rezultato = String.Compare(str1, str2, StringComparison.CurrentCulture) ("Kultūrai jautrių eilučių palyginimas: ") Console.WriteLine (str1 + " didesnis nei " + str2); else Console.WriteLine(str1 + " lygus " + str2) rezultatas = String (str1, str2, StringComparison. Eilutės: "); if (rezultatas 0). ) Console.WriteLine(str1 + " didesnis nei " + str2); else Console.WriteLine(str1 + " lygus " + str4) // Naudokite CompareOrdinal() metodą rezultatas = String.CompareOrdinal( str1, str2); .Write("Stygų palyginimas naudojant CompareOrdinal():\n"); if (rezultatas 0) Console.WriteLine(str1 + " didesnis nei " + str2) else Console.WriteLine(str1 + " lygus " + str4);
Console.WriteLine();
