C# இல், ஸ்பேஸ், டேப், நியூலைன், கேரேஜ் ரிட்டர்ன் மற்றும் பிற ஒத்த எழுத்துக்களால் வைட்ஸ்பேஸ் எழுத்துக்கள் குறிப்பிடப்படுகின்றன. சரத்தில் இருந்து இடைவெளிகளை அகற்றுவது சரம் கையாளுதலில் ஒரு பொதுவான பணியாகும், குறிப்பாக பயனர் உள்ளீடுகள், கோப்பு செயலாக்கம் மற்றும் தரவு பாகுபடுத்துதல் ஆகியவற்றைக் கையாளும் போது. இந்த கட்டுரை C# இல் உள்ள ஒரு சரத்திலிருந்து இடைவெளிகளை அகற்றுவதற்கான பல்வேறு முறைகளை ஆராய்கிறது.
இடைவெளிகள் என்றால் என்ன?
ஒயிட்ஸ்பேஸ் என்பது உரை சரத்தில் உள்ள வெற்று அல்லது வெற்று இடைவெளிகளைக் குறிக்கும் எழுத்துகள். அவை பொதுவாக சொற்கள் மற்றும் உரையின் பிற கூறுகளைப் பிரிக்கவும், உரையின் வாசிப்புத்திறன் மற்றும் காட்சித் தோற்றத்தை மேம்படுத்தவும் பயன்படுத்தப்படுகின்றன.
நிரலாக்கத்தில், இடைவெளிகள், தாவல்கள், புதிய வரிகள் மற்றும் கேரேஜ் ரிட்டர்ன்கள் போன்ற எழுத்துக்களை வைட்ஸ்பேஸ் உள்ளடக்கியது. பல நிரலாக்க மொழிகளில், குறியீட்டைச் செயலாக்கும்போது அல்லது விளக்கும்போது இடைவெளிகள் புறக்கணிக்கப்படுகின்றன அல்லது முக்கியமற்றதாகக் கருதப்படுகின்றன, ஆனால் அவை குறியீட்டின் தளவமைப்பு, வடிவமைத்தல் மற்றும் தொடரியல் ஆகியவற்றைப் பாதிக்கலாம்.
ஒரு சரத்தில் இடைவெளிகளை எவ்வாறு அகற்றுவது
இடைவெளிகளை அகற்றுவது அல்லது கையாளுவது சரம் செயலாக்கம் மற்றும் உரை கையாளுதலில் ஒரு பொதுவான பணியாகும். உரை உள்ளீடுகளை இயல்பாக்குவது அல்லது தரப்படுத்துவது பெரும்பாலும் இடைவெளிகளை அகற்றுவது அல்லது மாற்றுவது அவசியம். குறியீட்டின் செயல்பாடு அல்லது தரவின் துல்லியத்தை பாதிக்கக்கூடிய தேவையற்ற எழுத்துக்களை அகற்ற அல்லது குறியீட்டின் திறன் மற்றும் வாசிப்புத்திறனை மேம்படுத்த, அதைச் செய்வதற்கான சில இங்கே:
1: String.Replace() முறையைப் பயன்படுத்துதல்
நேரடியான முறையில் ஒரு சரத்திலிருந்து இடைவெளிகளை அகற்ற, String.Replace() முறையைப் பயன்படுத்தலாம். இந்தச் சூழ்நிலையில், ஸ்பேஸ் கேரக்டரை '' பழைய மதிப்பாகவும், வெற்று சரத்தை '' புதிய மதிப்பாகவும் குறிப்பிடலாம். அவ்வாறு செய்வதன் மூலம், சரத்தில் உள்ள அனைத்து இடைவெளிகளும் திறம்பட அகற்றப்படும்.
கணினியைப் பயன்படுத்துதல்;
வகுப்பு வெள்ளை வேகம்
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
சரம் அசல் சரம் = 'வணக்கம், சாம்!' ;
சரம் trimmedString = அசல் சரம்.மாற்று ( '' , '' ) ;
கன்சோல்.WriteLine ( trimmedString ) ;
}
}
கன்சோல் உள்ளீடு மற்றும் வெளியீட்டிற்கு கன்சோல் வகுப்பைப் பயன்படுத்துவதற்குத் தேவைப்படும் சிஸ்டம் நேம்ஸ்பேஸை இறக்குமதி செய்யும் பயன்பாட்டு அறிக்கையை இந்த நிரல் கொண்டுள்ளது.
முதன்மை முறையில், அசல் ஸ்ட்ரிங் என்ற ஸ்ட்ரிங் மாறியை “ஹலோ, சாம்!” மதிப்புடன் துவக்குகிறோம்.
அடுத்து, trimmedString என்ற மற்றொரு சரம் மாறியை அறிவித்து, அசல் ஸ்ட்ரிங்கில் Replace() முறையை செயல்படுத்துவதன் விளைவை அதற்கு ஒதுக்குவோம். தி மாற்று() முறை இரண்டு வாதங்களுடன் அழைக்கப்படுகிறது: முதல் வாதமானது நாம் மாற்ற விரும்பும் பழைய சப்ஸ்ட்ரிங்கைக் குறிக்கிறது, இந்த விஷயத்தில் இது ஒரு ஒற்றை இடைவெளி எழுத்து ' ', மற்றும் இரண்டாவது வாதம், நாம் அதை மாற்ற விரும்பும் புதிய சப்ஸ்ட்ரிங்கைக் குறிக்கிறது, அதாவது வெற்று சரம். ''.
2: String.Join() முறையைப் பயன்படுத்துதல்
ஒரு சரத்தில் இருந்து இடைவெளிகளை அகற்றுவதற்கான மற்றொரு வழி, String.Split() முறையைப் பயன்படுத்தி சரத்தை துணை சரங்களின் வரிசையாகப் பிரித்து, பின் சரங்களை மீண்டும் ஒன்றாக இணைப்பது String.Join() முறை. தொடர்ச்சியான இடைவெளிகளில் இருந்து எழக்கூடிய காலியான துணைச்சரங்களை அகற்ற, StringSplitOptions.RemoveEmptyEntries விருப்பத்தைப் பயன்படுத்தலாம்.
கணினியைப் பயன்படுத்துதல்;வகுப்பு வெள்ளை வேகம்
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
சரம் அசல் சரம் = 'வணக்கம், சாம்!' ;
லேசான கயிறு [ ] substrings = அசல் சரம்.Split ( புதிய எரி [ ] { '''' } , StringSplitOptions.RemoveEmptyEntries ) ;
சரம் trimmedString = String.Join ( '' , துணைச்சரங்கள் ) ;
கன்சோல்.WriteLine ( trimmedString ) ;
}
}
இந்தக் குறியீட்டிற்குள், 'ஒரிஜினல்ஸ்ட்ரிங்' என்ற ஸ்ட்ரிங் மாறியின் அறிவிப்பு உள்ளது, மேலும் அது 'ஹலோ, சாம்!' என்ற மதிப்புடன் துவக்கப்படுகிறது. பின்னர் ஸ்பேஸ் கேரக்டரை டிலிமிட்டராகப் பயன்படுத்தி துணை சரங்களின் வரிசையாகப் பிரிக்கப்படுகிறது. ரிமூவ்எம்ப்டிஎன்ட்ரிஸ் விருப்பமானது, விளைந்த அணிவரிசையிலிருந்து காலியான சப்ஸ்ட்ரிங்ஸை விலக்கப் பயன்படுகிறது.
பின்னர், குறியீடு பயன்படுத்துகிறது String.Join() காலியாக இல்லாத சப்ஸ்ட்ரிங்ஸை ஒரு யூனிஃபைட் சரமாக ஒன்றிணைக்கும் முறை, வெற்று சரத்தை பிரிப்பானாகப் பயன்படுத்துகிறது.
கடைசியாக, கன்சோல் விண்டோவில் டிரிம் செய்யப்பட்ட சரத்தைக் காட்ட, கன்சோல்.ரைட்லைனை குறியீடு பயன்படுத்துகிறது. இந்தக் குறியீட்டை இயக்கியவுடன், “ஹலோ, சாம்!” என்ற வெளியீட்டைக் கவனிக்கலாம். கன்சோலில் அச்சிடப்படுகிறது.
3: வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துதல்
வழக்கமான வெளிப்பாடுகள் சரங்களில் உள்ள வடிவங்களைப் பொருத்தவும் மாற்றவும் ஒரு சக்திவாய்ந்த வழியை வழங்குகிறது. பயன்படுத்துவதன் மூலம் Regex.Replace() முறை, நாம் ஒரு சரத்திலிருந்து அனைத்து இடைவெளி எழுத்துகளையும் திறம்பட அகற்றலாம்.
கணினியைப் பயன்படுத்துதல்;System.Text.RegularExpressions ஐப் பயன்படுத்துதல்;
வகுப்பு இடைவெளி
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
சரம் அசல் சரம் = 'வணக்கம், சாம்!' ;
சரம் trimmedString = Regex.Replace ( அசல் சரம், @ '\s+' , '' ) ;
கன்சோல்.WriteLine ( trimmedString ) ; '
}
}
இந்தக் குறியீட்டில், “ஒரிஜினல்ஸ்ட்ரிங்” என்ற ஸ்ட்ரிங் மாறி அறிவிக்கப்பட்டு, “ஹலோ, சாம்!” என்ற மதிப்புடன் துவக்கப்படும். பின் குறியீடு Regex.Replace() முறையைப் பயன்படுத்தி ஒன்று அல்லது அதற்கு மேற்பட்ட இடைவெளி எழுத்துகளை (வழக்கமான வெளிப்பாடு \s+ மூலம் குறிப்பிடப்படுகிறது) வெற்று சரத்துடன் மாற்றுகிறது.
இறுதியாக, குறியீடு Console.WriteLine() ஐப் பயன்படுத்தி, டிரிம் செய்யப்பட்ட சரத்தை கன்சோல் சாளரத்தில் வெளியிடுகிறது, மேலும் இந்த நிரலை இயக்கும்போது, 'ஹலோ, சாம்!' என்ற வெளியீட்டைக் கவனிப்பீர்கள். கன்சோலில் அச்சிடப்பட்டது.
இந்தக் குறிப்பிட்ட எடுத்துக்காட்டில், ஒன்று அல்லது அதற்கு மேற்பட்ட இடைவெளி எழுத்துகளுடன் (இடைவெளிகள், தாவல்கள் மற்றும் புதிய வரிகள் உட்பட) பொருத்துவதற்கு @”\s+” வழக்கமான வெளிப்பாடு முறை பயன்படுத்தப்படுகிறது, பின்னர் அவற்றை வெற்று சரத்துடன் மாற்றுகிறது.
4: LINQ ஐப் பயன்படுத்துதல்
LINQ ஐப் பயன்படுத்தி ஒரு சரத்திலிருந்து இடைவெளிகளை அகற்றலாம். வைட்ஸ்பேஸ் எழுத்துக்களை வடிகட்டுவதற்கு நாம் Where() முறையைப் பயன்படுத்தலாம், பின்னர் மீதமுள்ள எழுத்துக்களை மீண்டும் ஒன்றாக இணைக்கலாம் String. Concat() முறை.
கணினியைப் பயன்படுத்துதல்;System.Linq ஐப் பயன்படுத்துதல்;
வகுப்பு இடைவெளி
{
நிலையான வெற்றிட முதன்மை ( லேசான கயிறு [ ] args )
{
சரம் அசல் சரம் = 'வணக்கம், சாம்!' ;
சரம் trimmedString = புதிய சரம் ( அசல் சரம். எங்கே ( c = > ! char.IsWhiteSpace ( c ) ) .ToArray ( ) ) ;
கன்சோல்.WriteLine ( trimmedString ) ;
}
}
இந்த குறியீடு துணுக்கில், 'ஒரிஜினல்ஸ்ட்ரிங்' எனப்படும் ஒரு சரம் மாறி அறிவிக்கப்பட்டு, 'ஹலோ, சாம்! '. இது அசல் சரத்திலிருந்து எந்த இடைவெளி எழுத்துகளையும் வடிகட்டக்கூடிய LINQ வெளிப்பாட்டைப் பயன்படுத்தி trimmedString என்ற புதிய சரம் மாறியை உருவாக்குகிறது. எழுத்துகளை வடிகட்ட எங்கே() நீட்டிப்பு முறை பயன்படுத்தப்படுகிறது, அதன் விளைவாக வரும் எழுத்துக்கள் அணிவரிசையாக மாற்றப்பட்டு புதிய சரத்தை உருவாக்க புதிய சரம் கட்டமைப்பாளருக்கு அனுப்பப்படும்.
இறுதியாக, கன்சோல் சாளரத்தில் டிரிம் செய்யப்பட்ட சரத்தை வெளியிட, குறியீடு Console.WriteLine() ஐப் பயன்படுத்துகிறது. இந்தக் குறியீட்டை இயக்கியவுடன், “ஹலோ, சாம்!” என்ற வெளியீட்டைக் கவனிக்கலாம். கன்சோலில் காட்டப்படும்.
முடிவுரை
C# இல், ஒரு சரத்திலிருந்து இடைவெளிகளை அகற்ற பல்வேறு முறைகள் உள்ளன மற்றும் அவை String.Replace() முறை, String.Join() முறை, வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்தி LINQ ஐப் பயன்படுத்துகின்றன. திறமையான, வலுவான மற்றும் எளிதில் புரிந்துகொள்ளக்கூடிய ஒரு முறையைத் தேர்ந்தெடுப்பது மிகவும் முக்கியமானது, இது பராமரிப்பு மற்றும் வாசிப்புத்திறனை எளிதாக்குகிறது.