C#లో, వైట్‌స్పేస్ అక్షరాలు స్పేస్, ట్యాబ్, న్యూలైన్, క్యారేజ్ రిటర్న్ మరియు ఇతర సారూప్య అక్షరాల ద్వారా సూచించబడతాయి. స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను తీసివేయడం అనేది స్ట్రింగ్ మానిప్యులేషన్‌లో ఒక సాధారణ పని, ముఖ్యంగా వినియోగదారు ఇన్‌పుట్‌లు, ఫైల్ ప్రాసెసింగ్ మరియు డేటా పార్సింగ్‌తో వ్యవహరించేటప్పుడు. ఈ వ్యాసం C#లోని స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను తొలగించడానికి వివిధ పద్ధతులను పరిశీలిస్తుంది.
వైట్‌స్పేస్‌లు అంటే ఏమిటి?
వైట్‌స్పేస్‌లు టెక్స్ట్ స్ట్రింగ్‌లో ఖాళీ లేదా ఖాళీ స్థలాలను సూచించే అక్షరాలు. అవి సాధారణంగా పదాలు మరియు టెక్స్ట్ యొక్క ఇతర అంశాలను వేరు చేయడానికి మరియు టెక్స్ట్ యొక్క రీడబిలిటీ మరియు దృశ్య రూపాన్ని మెరుగుపరచడానికి ఉపయోగిస్తారు.
ప్రోగ్రామింగ్‌లో, వైట్‌స్పేస్‌లు ఖాళీలు, ట్యాబ్‌లు, కొత్త లైన్‌లు మరియు క్యారేజ్ రిటర్న్‌లు వంటి అక్షరాలను కలిగి ఉంటాయి. అనేక ప్రోగ్రామింగ్ భాషలలో, కోడ్‌ను ప్రాసెస్ చేస్తున్నప్పుడు లేదా వివరించేటప్పుడు వైట్‌స్పేస్‌లు విస్మరించబడతాయి లేదా చాలా తక్కువగా పరిగణించబడతాయి, అయితే అవి కోడ్ యొక్క లేఅవుట్, ఫార్మాటింగ్ మరియు సింటాక్స్‌ను ప్రభావితం చేస్తాయి.
స్ట్రింగ్‌లో వైట్‌స్పేస్‌లను ఎలా తొలగించాలి
స్ట్రింగ్ ప్రాసెసింగ్ మరియు టెక్స్ట్ మానిప్యులేషన్‌లో వైట్‌స్పేస్‌లను తీసివేయడం లేదా మార్చడం అనేది ఒక సాధారణ పని. టెక్స్ట్ ఇన్‌పుట్‌లను సాధారణీకరించడం లేదా ప్రామాణీకరించడం తరచుగా వైట్‌స్పేస్‌లను తీసివేయడం లేదా భర్తీ చేయడం అవసరం. కోడ్ యొక్క కార్యాచరణను లేదా డేటా యొక్క ఖచ్చితత్వాన్ని ప్రభావితం చేసే అనవసరమైన అక్షరాలను తీసివేయడానికి లేదా కోడ్ యొక్క సామర్థ్యాన్ని మరియు రీడబిలిటీని మెరుగుపరచడానికి, దీన్ని చేయడానికి ఇక్కడ కొన్ని ఉన్నాయి:
1: String.Replace() పద్ధతిని ఉపయోగించడం
స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను సూటిగా తొలగించడానికి, String.Replace() పద్ధతిని ఉపయోగించవచ్చు. ఈ దృష్టాంతంలో, మేము స్పేస్ క్యారెక్టర్ ” ”ని పాత విలువగా మరియు ఖాళీ స్ట్రింగ్ “”ని కొత్త విలువగా పేర్కొనవచ్చు. అలా చేయడం ద్వారా, స్ట్రింగ్‌లోని అన్ని ఖాళీలు సమర్థవంతంగా తీసివేయబడతాయి.
వ్యవస్థను ఉపయోగించడం;
క్లాస్ వైట్‌పేస్
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
స్ట్రింగ్ అసలైన స్ట్రింగ్ = 'హలో, సామ్!' ;
string trimmedString = అసలైన స్ట్రింగ్.రీప్లేస్ ( '' , '' ) ;
కన్సోల్.WriteLine ( కత్తిరించిన స్ట్రింగ్ ) ;
}
}
ఈ ప్రోగ్రామ్ కన్సోల్ ఇన్‌పుట్ మరియు అవుట్‌పుట్ కోసం కన్సోల్ క్లాస్‌ని ఉపయోగించడానికి అవసరమైన సిస్టమ్ నేమ్‌స్పేస్‌ను దిగుమతి చేసే వినియోగ ప్రకటనను కలిగి ఉంటుంది.
ప్రధాన పద్ధతిలో, మేము “హలో, సామ్!” విలువతో అసలైన స్ట్రింగ్ అనే స్ట్రింగ్ వేరియబుల్‌ని ప్రారంభిస్తాము.
తర్వాత, మేము trimmedString పేరుతో మరొక స్ట్రింగ్ వేరియబుల్‌ని ప్రకటిస్తాము మరియు OriginalStringలో రీప్లేస్() పద్ధతిని అమలు చేయడం యొక్క ఫలితాన్ని దానికి కేటాయిస్తాము. ది భర్తీ() పద్ధతిని రెండు ఆర్గ్యుమెంట్‌లతో పిలుస్తారు: మొదటి ఆర్గ్యుమెంట్ మనం భర్తీ చేయాలనుకుంటున్న పాత సబ్‌స్ట్రింగ్‌ను సూచిస్తుంది, ఈ సందర్భంలో ఒకే స్పేస్ క్యారెక్టర్ ” “, మరియు రెండవ ఆర్గ్యుమెంట్ మనం భర్తీ చేయాలనుకుంటున్న కొత్త సబ్‌స్ట్రింగ్‌ను సూచిస్తుంది, అవి ఖాళీ స్ట్రింగ్. ''.
2: String.Join() పద్ధతిని ఉపయోగించడం
స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను తీసివేయడానికి మరొక మార్గం ఏమిటంటే, స్ట్రింగ్‌ను స్ట్రింగ్.స్ప్లిట్() పద్ధతిని ఉపయోగించి సబ్‌స్ట్రింగ్‌ల శ్రేణిగా విభజించి, ఆపై సబ్‌స్ట్రింగ్‌లను తిరిగి కలపడం String.Join() పద్ధతి. వరుస వైట్‌స్పేస్‌ల నుండి వచ్చే ఏవైనా ఖాళీ సబ్‌స్ట్రింగ్‌లను తొలగించడానికి, మేము StringSplitOptions.RemoveEmptyEntries ఎంపికను ఉపయోగించవచ్చు.
వ్యవస్థను ఉపయోగించడం;క్లాస్ వైట్‌పేస్
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
స్ట్రింగ్ అసలైన స్ట్రింగ్ = 'హలో, సామ్!' ;
స్ట్రింగ్ [ ] substrings = అసలైన స్ట్రింగ్.స్ప్లిట్ ( కొత్త చార్ [ ] { '' } , StringSplitOptions.RemoveEmptyEntries ) ;
string trimmedString = స్ట్రింగ్.చేరండి ( '' , సబ్‌స్ట్రింగ్‌లు ) ;
కన్సోల్.WriteLine ( కత్తిరించిన స్ట్రింగ్ ) ;
}
}
ఈ కోడ్‌లో, “ఒరిజినల్ స్ట్రింగ్” అనే స్ట్రింగ్ వేరియబుల్ డిక్లరేషన్ ఉంది మరియు అది “హలో, సామ్!” విలువతో ప్రారంభించబడింది. ఆపై ఒక స్పేస్ క్యారెక్టర్‌ను డీలిమిటర్‌గా ఉపయోగించి సబ్‌స్ట్రింగ్‌ల శ్రేణిగా విభజించడం జరుగుతుంది. ఫలిత శ్రేణి నుండి ఏదైనా ఖాళీ సబ్‌స్ట్రింగ్‌లను మినహాయించడానికి RemoveEmptyEntries ఎంపిక ఉపయోగించబడుతుంది.
తదనంతరం, కోడ్ నియమిస్తుంది String.Join() ఖాళీ కాని సబ్‌స్ట్రింగ్‌లను ఏకీకృత స్ట్రింగ్‌లో విలీనం చేసే పద్ధతి, ఖాళీ స్ట్రింగ్‌ను సెపరేటర్‌గా ఉపయోగిస్తుంది.
చివరగా, కోడ్ కన్సోల్ విండోలో కత్తిరించిన స్ట్రింగ్‌ను ప్రదర్శించడానికి Console.WriteLineని ఉపయోగిస్తుంది. ఈ కోడ్‌ని అమలు చేసిన తర్వాత, మీరు “హలో, సామ్!” అవుట్‌పుట్‌ను గమనించవచ్చు. కన్సోల్‌లో ముద్రించబడుతోంది.
3: సాధారణ వ్యక్తీకరణలను ఉపయోగించడం
సాధారణ వ్యక్తీకరణలు స్ట్రింగ్‌లలో నమూనాలను సరిపోల్చడానికి మరియు భర్తీ చేయడానికి శక్తివంతమైన మార్గాన్ని అందిస్తాయి. ఉపయోగించడం ద్వారా Regex.Replace() పద్ధతి, మేము స్ట్రింగ్ నుండి అన్ని వైట్‌స్పేస్ అక్షరాలను సమర్థవంతంగా తొలగించగలము.
వ్యవస్థను ఉపయోగించడం;System.Text.RegularExpressions ఉపయోగించి;
తరగతి ఖాళీ స్థలం
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
స్ట్రింగ్ అసలైన స్ట్రింగ్ = 'హలో, సామ్!' ;
string trimmedString = Regex.Replace ( అసలైన స్ట్రింగ్, @ '\s+' , '' ) ;
కన్సోల్.WriteLine ( కత్తిరించిన స్ట్రింగ్ ) ; '
}
}
ఈ కోడ్‌లో, “ఒరిజినల్‌స్ట్రింగ్” అనే స్ట్రింగ్ వేరియబుల్ ప్రకటించబడింది మరియు “హలో, సామ్!” విలువతో ప్రారంభించబడుతుంది. కోడ్ ఒకటి లేదా అంతకంటే ఎక్కువ వైట్‌స్పేస్ అక్షరాలను (సాధారణ వ్యక్తీకరణ \s+ ద్వారా సూచించబడుతుంది) ఖాళీ స్ట్రింగ్‌తో భర్తీ చేయడానికి Regex.Replace() పద్ధతిని ఉపయోగిస్తుంది.
చివరగా, కోడ్ కన్సోల్ విండోకు కత్తిరించిన స్ట్రింగ్‌ను అవుట్‌పుట్ చేయడానికి Console.WriteLine()ని ఉపయోగిస్తుంది మరియు మీరు ఈ ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, మీరు “హలో, సామ్!” అవుట్‌పుట్‌ను గమనిస్తారు. కన్సోల్‌కు ముద్రించబడింది.
ఈ ప్రత్యేక ఉదాహరణలో, సాధారణ వ్యక్తీకరణ నమూనా @”\s+” ఒకటి లేదా అంతకంటే ఎక్కువ వైట్‌స్పేస్ అక్షరాలు (ఖాళీలు, ట్యాబ్‌లు మరియు కొత్త లైన్‌లతో సహా) సరిపోలడానికి ఉపయోగించబడింది మరియు తదనంతరం వాటిని ఖాళీ స్ట్రింగ్‌తో భర్తీ చేస్తుంది.
4: LINQని ఉపయోగించడం
మేము LINQని ఉపయోగించి స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను కూడా తీసివేయవచ్చు. మేము వైట్‌స్పేస్ క్యారెక్టర్‌లను ఫిల్టర్ చేయడానికి వేర్() పద్ధతిని ఉపయోగించవచ్చు మరియు మిగిలిన అక్షరాలను తిరిగి కలిపి String.Concat() పద్ధతి.
వ్యవస్థను ఉపయోగించడం;System.Linqని ఉపయోగించడం;
తరగతి ఖాళీ స్థలం
{
స్టాటిక్ శూన్య ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
స్ట్రింగ్ అసలైన స్ట్రింగ్ = 'హలో, సామ్!' ;
string trimmedString = కొత్త స్ట్రింగ్ ( అసలు స్ట్రింగ్.ఎక్కడ ( c = > ! char.IsWhiteSpace ( సి ) ) .ToArray ( ) ) ;
కన్సోల్.WriteLine ( కత్తిరించిన స్ట్రింగ్ ) ;
}
}
ఈ కోడ్ స్నిప్పెట్‌లో, “ఒరిజినల్ స్ట్రింగ్” అనే స్ట్రింగ్ వేరియబుల్ ప్రకటించబడింది మరియు ”హలో, సామ్! '. ఇది LINQ వ్యక్తీకరణను ఉపయోగించి trimmedString అనే కొత్త స్ట్రింగ్ వేరియబుల్‌ను సృష్టిస్తుంది, అది అసలు స్ట్రింగ్ నుండి ఏవైనా వైట్‌స్పేస్ అక్షరాలను ఫిల్టర్ చేస్తుంది. అక్షరాలను ఫిల్టర్ చేయడానికి Where() పొడిగింపు పద్ధతి ఉపయోగించబడుతుంది మరియు ఫలితంగా వచ్చే అక్షరాలు శ్రేణికి మార్చబడతాయి మరియు కొత్త స్ట్రింగ్‌ను సృష్టించడానికి కొత్త స్ట్రింగ్ కన్‌స్ట్రక్టర్‌కు పంపబడతాయి.
చివరగా, కోడ్ కన్సోల్ విండోకు కత్తిరించిన స్ట్రింగ్‌ను అవుట్‌పుట్ చేయడానికి Console.WriteLine()ని ఉపయోగిస్తుంది. ఈ కోడ్‌ని అమలు చేసిన తర్వాత, మీరు “హలో, సామ్!” అవుట్‌పుట్‌ను గమనించవచ్చు. కన్సోల్‌లో ప్రదర్శించబడుతుంది.
ముగింపు
C#లో, స్ట్రింగ్ నుండి వైట్‌స్పేస్‌లను తీసివేయడానికి వివిధ పద్ధతులు ఉన్నాయి మరియు అవి String.Replace() పద్ధతి, String.Join() పద్ధతి, సాధారణ వ్యక్తీకరణలను ఉపయోగించడం మరియు LINQని ఉపయోగించడం. నిర్వహణ మరియు పఠన సౌలభ్యాన్ని అనుమతించే సమర్థవంతమైన, దృఢమైన మరియు సులభంగా అర్థమయ్యే పద్ధతిని ఎంచుకోవడం చాలా కీలకం.