Sa C#, ang mga whitespace na character ay kinakatawan ng space, tab, newline, carriage return, at iba pang katulad na mga character. Ang pag-alis ng mga whitespace mula sa isang string ay isang karaniwang gawain sa pagmamanipula ng string, lalo na kapag nakikitungo sa mga input ng user, pagproseso ng file, at pag-parse ng data. Ang artikulong ito ay sumasalamin sa iba't ibang mga pamamaraan para sa pag-alis ng mga whitespace mula sa isang string sa C#.
Ano ang mga whitespace?
Ang mga whitespace ay mga character na kumakatawan sa mga walang laman o blangkong espasyo sa isang text string. Karaniwang ginagamit ang mga ito upang paghiwalayin ang mga salita at iba pang elemento ng isang teksto at upang pahusayin ang pagiging madaling mabasa at biswal na hitsura ng teksto.
Sa programming, ang mga whitespace ay sumasaklaw sa mga character gaya ng mga space, tab, newline, at carriage return. Sa maraming mga programming language, ang mga whitespace ay binabalewala o itinuturing na hindi gaanong mahalaga kapag pinoproseso o binibigyang-kahulugan ang code, ngunit maaari itong makaapekto sa layout, pag-format, at syntax ng code.
Paano Mag-alis ng Mga Whitespace sa isang String
Ang pag-alis o pagmamanipula ng mga whitespace ay isang karaniwang gawain sa pagproseso ng string at pagmamanipula ng teksto. Ang pag-normalize o pag-standardize ng mga text input ay kadalasang nagsasangkot ng pangangailangang alisin o palitan ang mga whitespace. Upang alisin ang mga hindi kinakailangang character na maaaring makaapekto sa functionality ng code o sa katumpakan ng data, o upang mapabuti ang kahusayan at pagiging madaling mabasa ng code, narito ang ilan para sa paggawa nito:
1: Paggamit ng String.Replace() Method
Upang alisin ang mga whitespace mula sa isang string sa isang direktang paraan, ang String.Replace() na paraan ay maaaring gamitin. Sa sitwasyong ito, maaari naming italaga ang space character na ' ' bilang ang lumang halaga at isang walang laman na string '' bilang ang bagong halaga. Sa paggawa nito, mabisang maaalis ang lahat ng puwang sa loob ng string.
gamit ang System;
whitepace ng klase
{
static void Main ( string [ ] args )
{
string originalString = 'Hello, Sam!' ;
string trimmedString = originalString.Palitan ( '' , '' ) ;
Console.WriteLine ( trimmedString ) ;
}
}
Kasama sa program na ito ang isang using statement na nag-i-import ng System namespace, na kinakailangan para sa paggamit ng Console class para sa console input at output.
Sa loob ng Main method, sinisimulan namin ang isang string variable na pinangalanang originalString na may value na 'Hello, Sam!'.
Susunod, idedeklara namin ang isa pang string variable na pinangalanang trimmedString at italaga dito ang kinalabasan ng paggamit ng Replace() method sa originalString. Ang Palitan() Ang pamamaraan ay tinatawag na may dalawang argumento: ang unang argumento ay kumakatawan sa lumang substring na nais nating palitan, na sa kasong ito ay isang solong espasyo na karakter ' ', at ang pangalawang argumento ay nagpapahiwatig ng bagong substring na nais nating palitan ito, ibig sabihin ay isang walang laman na string. “”.
2: Paggamit ng String.Join() Method
Ang isa pang paraan upang alisin ang mga whitespace mula sa isang string ay ang hatiin ang string sa isang hanay ng mga substring gamit ang String.Split() na pamamaraan at pagkatapos ay pagsama-samahin ang mga substring gamit ang String.Join() paraan. Upang alisin ang anumang walang laman na mga substring na maaaring lumabas mula sa magkakasunod na mga whitespace, maaari naming gamitin ang pagpipiliang StringSplitOptions.RemoveEmptyEntries.
gamit ang System;whitepace ng klase
{
static void Main ( string [ ] args )
{
string originalString = 'Hello, Sam!' ;
string [ ] substrings = originalString.Split ( bagong char [ ] { '' } , StringSplitOptions.RemoveEmptyEntries ) ;
string trimmedString = String.Join ( '' , mga substring ) ;
Console.WriteLine ( trimmedString ) ;
}
}
Sa loob ng code na ito, mayroong isang deklarasyon ng isang string variable na pinangalanang 'originalString' at ito ay sinisimulan sa halagang 'Hello, Sam!' at pagkatapos ay sumasailalim sa paghahati sa isang hanay ng mga substring gamit ang isang space character bilang delimiter. Ang opsyon na RemoveEmptyEntries ay ginagamit upang ibukod ang anumang walang laman na mga substring mula sa resultang array.
Kasunod nito, ginagamit ng code ang String.Join() paraan upang pagsamahin ang mga hindi walang laman na substring sa isang pinag-isang string, gamit ang isang walang laman na string bilang separator.
Panghuli, ginagamit ng code ang Console.WriteLine upang ipakita ang trimmed string sa console window. Sa pag-execute ng code na ito, maaari mong asahan na obserbahan ang output na 'Hello, Sam!' na naka-print sa console.
3: Paggamit ng Mga Regular na Ekspresyon
Ang mga regular na expression ay nagbibigay ng isang mahusay na paraan upang itugma at palitan ang mga pattern sa mga string. Sa pamamagitan ng paggamit ng Regex.Replace() paraan, maaari naming epektibong alisin ang lahat ng mga character na whitespace mula sa isang string.
gamit ang System;gamit ang System.Text.RegularExpressions;
whitespace ng klase
{
static void Main ( string [ ] args )
{
string originalString = 'Hello, Sam!' ;
string trimmedString = Regex.Palitan ( orihinal na String, @ '\s+' , '' ) ;
Console.WriteLine ( trimmedString ) ; '
}
}
Sa code na ito, ang isang string variable na pinangalanang 'originalString' ay idineklara at sinisimulan sa halagang 'Hello, Sam!'. Ang code pagkatapos ay gumagamit ng Regex.Replace() na pamamaraan upang palitan ang isa o higit pang mga whitespace na character (kinakatawan ng regular na expression na \s+) ng isang walang laman na string.
Sa wakas, ginagamit ng code ang Console.WriteLine() upang i-output ang trimmed string sa console window at Kapag pinaandar mo ang program na ito, makikita mo ang output na 'Hello, Sam!' naka-print sa console.
Sa partikular na halimbawang ito, ang regular na pattern ng expression na @”\s+” ay ginagamit upang tumugma sa isa o higit pang mga whitespace na character (kabilang ang mga puwang, tab, at bagong linya) at pagkatapos ay papalitan ang mga ito ng walang laman na string.
4: Paggamit ng LINQ
Maaari din nating alisin ang mga whitespace mula sa isang string gamit ang LINQ. Magagamit natin ang pamamaraang Where() para i-filter ang mga character na whitespace at pagkatapos ay pagsamahin muli ang natitirang mga character gamit ang String.Concat() paraan.
gamit ang System;gamit ang System.Linq;
whitespace ng klase
{
static void Main ( string [ ] args )
{
string originalString = 'Hello, Sam!' ;
string trimmedString = bagong string ( originalString.Saan ( c = > ! char.IsWhiteSpace ( c ) ) .ToArray ( ) ) ;
Console.WriteLine ( trimmedString ) ;
}
}
Sa code snippet na ito, ang isang string variable na tinatawag na 'originalString' ay idineklara at sinisimulan na may value na ' Hello, Sam! “. Lumilikha ito ng bagong string variable na pinangalanang trimmedString gamit ang isang LINQ expression na nagpi-filter ng anumang mga whitespace na character mula sa orihinal na string. Ang Where() na paraan ng extension ay ginagamit upang i-filter ang mga character at ang mga nagresultang character ay na-convert sa isang array at ipinapasa sa bagong string constructor upang lumikha ng isang bagong string.
Panghuli, ginagamit ng code ang Console.WriteLine() para i-output ang trimmed string sa console window. Sa pag-execute ng code na ito, maaari mong asahan na obserbahan ang output na 'Hello, Sam!' ipinapakita sa console.
Konklusyon
Sa C#, mayroong iba't ibang pamamaraan para sa pag-alis ng mga whitespace mula sa isang string at ang mga iyon ay String.Replace() method, String.Join() method, gamit ang mga regular na expression at gamit ang LINQ. Napakahalagang mag-opt para sa isang paraan na mahusay, matatag, at madaling maunawaan, na nagbibigay-daan para sa kadalian ng pagpapanatili at pagiging madaling mabasa.