ஜாவாஸ்கிரிப்ட் பைப்லைன் ஆபரேட்டர் வகை அனுமானம்: ஃபங்ஷன் செயின் வகை பாதுகாப்பில் ஒரு ஆழமான பார்வை

நவீன மென்பொருள் மேம்பாட்டு உலகில், சுத்தமான, படிக்கக்கூடிய, மற்றும் பராமரிக்கக்கூடிய குறியீட்டை எழுதுவது ஒரு சிறந்த நடைமுறை மட்டுமல்ல; அது வெவ்வேறு நேர மண்டலங்கள் மற்றும் பின்னணிகளில் ஒத்துழைக்கும் உலகளாவிய குழுக்களுக்கு ஒரு அவசியமாகும். வலையின் பொது மொழியாகிய ஜாவாஸ்கிரிப்ட், இந்த தேவைகளைப் பூர்த்தி செய்ய தொடர்ந்து வளர்ந்து வருகிறது. இந்த மொழிக்கு மிகவும் எதிர்பார்க்கப்படும் சேர்த்தல்களில் ஒன்று பைப்லைன் ஆபரேட்டர் (|>) ஆகும், இது நாம் செயல்பாடுகளை எவ்வாறு இணைக்கிறோம் என்பதை அடிப்படையில் மாற்றும் ஒரு அம்சமாகும்.

பைப்லைன் ஆபரேட்டர் பற்றிய பல விவாதங்கள் அதன் அழகியல் மற்றும் வாசிப்புத்திறன் நன்மைகளில் கவனம் செலுத்தினாலும், அதன் ஆழமான தாக்கம் பெரிய அளவிலான பயன்பாடுகளுக்கு முக்கியமான ஒரு பகுதியில் உள்ளது: வகை பாதுகாப்பு. டைப்ஸ்கிரிப்ட் போன்ற ஒரு ஸ்டேடிக் வகை சரிபார்ப்பாளருடன் இணைந்தால், பைப்லைன் ஆபரேட்டர், தரவு ஒரு தொடர்ச்சியான மாற்றங்களின் வழியாக சரியாகப் பாய்வதை உறுதிசெய்யும் ஒரு சக்திவாய்ந்த கருவியாக மாறுகிறது, கம்பைலர் பிழைகளை உற்பத்திக்கு வருவதற்கு முன்பே கண்டறிகிறது. இந்தக் கட்டுரை, பைப்லைன் ஆபரேட்டர் மற்றும் வகை அனுமானத்திற்கு இடையிலான ஒருங்கியல் உறவைப் பற்றி ஒரு ஆழமான பார்வையை வழங்குகிறது, இது டெவலப்பர்கள் சிக்கலான, ஆனாலும் குறிப்பிடத்தக்க வகையில் பாதுகாப்பான, செயல்பாட்டுச் சங்கிலிகளை உருவாக்க எப்படி உதவுகிறது என்பதை ஆராய்கிறது.

பைப்லைன் ஆபரேட்டரைப் புரிந்துகொள்ளுதல்: குழப்பத்திலிருந்து தெளிவிற்கு

வகை பாதுகாப்பில் அதன் தாக்கத்தை நாம் பாராட்டுவதற்கு முன்பு, பைப்லைன் ஆபரேட்டர் தீர்க்கும் சிக்கலை முதலில் புரிந்து கொள்ள வேண்டும். இது புரோகிராமிங்கில் ஒரு பொதுவான வடிவத்தை கையாள்கிறது: ஒரு மதிப்பை எடுத்து, அதற்கு தொடர்ச்சியான செயல்பாடுகளைப் பயன்படுத்துதல், இதில் ஒரு செயல்பாட்டின் வெளியீடு அடுத்த செயல்பாட்டிற்கான உள்ளீடாக மாறுகிறது.

சிக்கல்: ஃபங்ஷன் அழைப்புகளில் 'பேரழிவின் பிரமிட்'

ஒரு எளிய தரவு மாற்றப் பணியைக் கவனியுங்கள். நம்மிடம் ஒரு பயனர் ஆப்ஜெக்ட் உள்ளது, மேலும் நாம் அவர்களின் முதல் பெயரைப் பெற்று, அதை பெரிய எழுத்துகளுக்கு மாற்றி, பின்னர் எந்த வெற்றிடத்தையும் நீக்க விரும்புகிறோம். வழக்கமான ஜாவாஸ்கிரிப்டில், நீங்கள் இதை இப்படி எழுதலாம்:

            const user = { firstName: '  johnny ', lastName: 'appleseed' };

function getFirstName(person) {
  return person.firstName;
}

function toUpperCase(text) {
  return text.toUpperCase();
}

function trim(text) {
  return text.trim();
}

// The nested approach
const result = trim(toUpperCase(getFirstName(user)));

console.log(result); // "JOHNNY"

            

              
                Copy
              
            
          

இந்தக் குறியீடு வேலை செய்கிறது, ஆனால் இதில் ஒரு குறிப்பிடத்தக்க வாசிப்புத்திறன் சிக்கல் உள்ளது. செயல்பாடுகளின் வரிசையைப் புரிந்து கொள்ள, நீங்கள் அதை உள்ளிருந்து வெளியே படிக்க வேண்டும்: முதலில் `getFirstName`, பின்னர் `toUpperCase`, பின்னர் `trim`. மாற்றங்களின் எண்ணிக்கை அதிகரிக்கும் போது, இந்த உள்ளமைக்கப்பட்ட அமைப்பு பகுப்பாய்வு செய்வதற்கும், பிழைத்திருத்தம் செய்வதற்கும், பராமரிப்பதற்கும் மிகவும் கடினமாகிறது—இந்த முறை பெரும்பாலும் 'பேரழிவின் பிரமிட்' அல்லது 'நெஸ்டட் ஹெல்' என்று குறிப்பிடப்படுகிறது.

தீர்வு: பைப்லைன் ஆபரேட்டருடன் ஒரு நேரியல் அணுகுமுறை

பைப்லைன் ஆபரேட்டர், தற்போது TC39 (ஜாவாஸ்கிரிப்டை தரப்படுத்தும் குழு) இல் ஒரு நிலை 2 முன்மொழிவாக உள்ளது, இது ஒரு நேர்த்தியான, நேரியல் மாற்றீட்டை வழங்குகிறது. இது அதன் இடது பக்கத்தில் உள்ள மதிப்பை எடுத்து, அதை அதன் வலது பக்கத்தில் உள்ள செயல்பாட்டிற்கு ஒரு ஆர்குமென்டாக அனுப்புகிறது.

முன்னேறியுள்ள F# ஸ்டைல் முன்மொழிவைப் பயன்படுத்தி, முந்தைய உதாரணத்தை இவ்வாறு மீண்டும் எழுதலாம்:

            // The pipeline approach
const result = user 
  |> getFirstName 
  |> toUpperCase 
  |> trim;

console.log(result); // "JOHNNY"

            

              
                Copy
              
            
          

வேறுபாடு வியக்க வைக்கிறது. குறியீடு இப்போது இடமிருந்து வலமாக இயல்பாகப் படிக்கப்படுகிறது, இது தரவின் உண்மையான ஓட்டத்தைப் பிரதிபலிக்கிறது. `user` என்பது `getFirstName` க்குள் செலுத்தப்படுகிறது, அதன் முடிவு `toUpperCase` க்குள் செலுத்தப்படுகிறது, மேலும் அந்த முடிவு `trim` க்குள் செலுத்தப்படுகிறது. இந்த நேரியல், படிப்படியான அமைப்பு படிக்க எளிதானது மட்டுமல்ல, பிழைத்திருத்தம் செய்வதற்கும் கணிசமாக எளிதானது, அதை நாம் பின்னர் காண்போம்.

போட்டியிடும் முன்மொழிவுகள் பற்றிய ஒரு குறிப்பு

வரலாற்று மற்றும் தொழில்நுட்ப சூழலுக்காக, பைப்லைன் ஆபரேட்டருக்கு இரண்டு முக்கிய முன்மொழிவுகள் இருந்தன என்பதைக் குறிப்பிடுவது மதிப்பு:

• F# ஸ்டைல் (எளியது): இதுவே ஆதரவைப் பெற்று தற்போது நிலை 2 இல் உள்ள முன்மொழிவு. x |> f என்ற கோவை f(x) என்பதற்கு நேரடி சமமானது. இது எளிமையானது, கணிக்கக்கூடியது மற்றும் ஒற்றை செயல்பாட்டு கலவைக்கு சிறந்தது.
• ஸ்மார்ட் மிக்ஸ் (டாபிக் ரெஃபரன்ஸுடன்): இந்த முன்மொழிவு மிகவும் நெகிழ்வானதாக இருந்தது, பைப் செய்யப்படும் மதிப்பைக் குறிக்க ஒரு சிறப்பு ப்ளேஸ்ஹோல்டரை (உதாரணமாக, # அல்லது ^) அறிமுகப்படுத்தியது. இது value |> Math.max(10, #) போன்ற சிக்கலான செயல்பாடுகளை அனுமதிக்கும். சக்தி வாய்ந்ததாக இருந்தாலும், அதன் கூடுதல் சிக்கல், எளிமையான F# ஸ்டைல் தரப்படுத்தலுக்கு சாதகமாக அமைய வழிவகுத்தது.

இந்தக் கட்டுரையின் மீதமுள்ள பகுதியில், நாம் F# ஸ்டைல் பைப்லைனில் கவனம் செலுத்துவோம், ஏனெனில் இதுவே ஜாவாஸ்கிரிப்ட் தரத்தில் சேர்க்கப்பட அதிக வாய்ப்புள்ள வேட்பாளராகும்.

விளையாட்டை மாற்றுபவர்: வகை அனுமானம் மற்றும் ஸ்டேடிக் வகை பாதுகாப்பு

வாசிப்புத்திறன் ஒரு அருமையான நன்மை, ஆனால் பைப்லைன் ஆபரேட்டரின் உண்மையான சக்தி நீங்கள் டைப்ஸ்கிரிப்ட் போன்ற ஒரு ஸ்டேடிக் வகை அமைப்பை அறிமுகப்படுத்தும் போது திறக்கப்படுகிறது. இது பார்வைக்கு இனிமையான தொடரியலை பிழையற்ற தரவு செயலாக்கச் சங்கிலிகளை உருவாக்குவதற்கான ஒரு வலுவான கட்டமைப்பாக மாற்றுகிறது.

வகை அனுமானம் என்றால் என்ன? ஒரு விரைவான நினைவுபடுத்தல்

வகை அனுமானம் என்பது பல ஸ்டேடிக்காக-வகைப்படுத்தப்பட்ட மொழிகளில் உள்ள ஒரு அம்சமாகும், இதில் கம்பைலர் அல்லது வகை-சரிபார்ப்பாளர் ஒரு கோவையின் தரவு வகையை டெவலப்பர் வெளிப்படையாக எழுதாமலேயே தானாகவே ஊகிக்க முடியும். உதாரணமாக, டைப்ஸ்கிரிப்டில், நீங்கள் const name = "Alice"; என்று எழுதினால், கம்பைலர் `name` மாறி `string` வகையைச் சேர்ந்தது என்று அனுமானிக்கிறது.

பாரம்பரிய செயல்பாட்டுச் சங்கிலிகளில் வகை பாதுகாப்பு

அங்கு வகை பாதுகாப்பு எவ்வாறு செயல்படுகிறது என்பதைக் காண, நமது அசல் உள்ளமைக்கப்பட்ட உதாரணத்திற்கு டைப்ஸ்கிரிப்ட் வகைகளைச் சேர்ப்போம். முதலில், நமது வகைகள் மற்றும் வகைப்படுத்தப்பட்ட செயல்பாடுகளை வரையறுக்கிறோம்:

            interface User {
  id: number;
  firstName: string;
  lastName: string;
}

const user: User = { id: 1, firstName: '  clara ', lastName: 'oswald' };

const getFirstName = (person: User): string => person.firstName;

const toUpperCase = (text: string): string => text.toUpperCase();

const trim = (text: string): string => text.trim();

// TypeScript correctly infers 'result' is of type 'string'
const result: string = trim(toUpperCase(getFirstName(user)));

            

              
                Copy
              
            
          

இங்கே, டைப்ஸ்கிரிப்ட் முழுமையான வகை பாதுகாப்பை வழங்குகிறது. அது சரிபார்க்கிறது:

1. getFirstName ஆனது `User` இடைமுகத்துடன் இணக்கமான ஒரு ஆர்குமென்டைப் பெறுகிறது.
2. getFirstName இன் திரும்பும் மதிப்பு (ஒரு `string`) `toUpperCase` இன் எதிர்பார்க்கப்படும் உள்ளீட்டு வகையுடன் (`string`) பொருந்துகிறது.
3. toUpperCase இன் திரும்பும் மதிப்பு (ஒரு `string`) `trim` இன் எதிர்பார்க்கப்படும் உள்ளீட்டு வகையுடன் (`string`) பொருந்துகிறது.

முழு `user` ஆப்ஜெக்ட்டையும் `toUpperCase` க்கு அனுப்ப முயற்சிப்பது போன்ற தவறை நாம் செய்திருந்தால், டைப்ஸ்கிரிப்ட் உடனடியாக ஒரு பிழையைக் காட்டும்: toUpperCase(user) // பிழை: 'User' வகையின் ஆர்குமென்ட் 'string' வகையின் அளவுருவிற்கு ஒதுக்க முடியாதது.

பைப்லைன் ஆபரேட்டர் வகை அனுமானத்தை எப்படி சூப்பர்சார்ஜ் செய்கிறது

இப்போது, இந்த வகைப்படுத்தப்பட்ட சூழலில் பைப்லைன் ஆபரேட்டரைப் பயன்படுத்தும்போது என்ன நடக்கிறது என்று பார்ப்போம். டைப்ஸ்கிரிப்டிற்கு இன்னும் ஆபரேட்டரின் தொடரியலுக்கான நேரடி ஆதரவு இல்லை என்றாலும், குறியீட்டை மாற்றுவதற்கு பேபலைப் பயன்படுத்தும் நவீன மேம்பாட்டு அமைப்புகள், டைப்ஸ்கிரிப்ட் சரிபார்ப்பாளரை அதைச் சரியாகப் பகுப்பாய்வு செய்ய அனுமதிக்கின்றன.

            // Assume a setup where Babel transpiles the pipeline operator

const finalResult: string = user
  |> getFirstName   // Input: User, Output inferred as string
  |> toUpperCase    // Input: string, Output inferred as string
  |> trim;           // Input: string, Output inferred as string

            

              
                Copy
              
            
          

இங்குதான் மாயாஜாலம் நிகழ்கிறது. டைப்ஸ்கிரிப்ட் கம்பைலர், நாம் குறியீட்டைப் படிக்கும்போது செய்வது போலவே தரவு ஓட்டத்தைப் பின்பற்றுகிறது:

1. இது `user` உடன் தொடங்குகிறது, இது `User` வகையைச் சேர்ந்தது என்று அதற்குத் தெரியும்.
2. `user` ஆனது `getFirstName` க்குள் செலுத்தப்படுவதைக் காண்கிறது. `getFirstName` ஒரு `User` வகையை ஏற்க முடியுமா என்று சரிபார்க்கிறது. முடியும். பின்னர் இந்த முதல் படியின் முடிவை `getFirstName` இன் திரும்பும் வகையாக, அதாவது `string` என்று அனுமானிக்கிறது.
3. இந்த அனுமானிக்கப்பட்ட `string` இப்போது பைப்லைனின் அடுத்த கட்டத்திற்கான உள்ளீடாக மாறுகிறது. இது `toUpperCase` க்குள் செலுத்தப்படுகிறது. கம்பைலர் `toUpperCase` ஒரு `string` ஐ ஏற்கிறதா என்று சரிபார்க்கிறது. ஏற்கிறது. இந்த கட்டத்தின் முடிவு `string` என அனுமானிக்கப்படுகிறது.
4. இந்த புதிய `string` ஆனது `trim` க்குள் செலுத்தப்படுகிறது. கம்பைலர் வகை இணக்கத்தன்மையைச் சரிபார்த்து, முழு பைப்லைனின் இறுதி முடிவையும் `string` என அனுமானிக்கிறது.

முழு சங்கிலியும் தொடக்கத்திலிருந்து இறுதி வரை ஸ்டேடிக்காக சரிபார்க்கப்படுகிறது. நாம் உள்ளமைக்கப்பட்ட பதிப்பின் அதே அளவிலான வகை பாதுகாப்பைப் பெறுகிறோம், ஆனால் மிகவும் உயர்ந்த வாசிப்புத்திறன் மற்றும் டெவலப்பர் அனுபவத்துடன்.

பிழைகளை முன்கூட்டியே கண்டறிதல்: வகை பொருத்தமின்மையின் ஒரு நடைமுறை உதாரணம்

இந்த வகை-பாதுகாப்பான சங்கிலியின் உண்மையான மதிப்பு ஒரு தவறு அறிமுகப்படுத்தப்படும்போது தெளிவாகத் தெரிகிறது. ஒரு `number` ஐத் திருப்பியளிக்கும் ஒரு செயல்பாட்டை உருவாக்கி, அதை நமது ஸ்டிரிங்-செயலாக்க பைப்லைனில் தவறாக வைப்போம்.

            const getUserId = (person: User): number => person.id;

// Incorrect pipeline
const invalidResult = user
  |> getFirstName   // OK: User -> string
  |> getUserId      // ERROR! getUserId expects a User, but receives a string
  |> toUpperCase;

            

              
                Copy
              
            
          

இங்கே, டைப்ஸ்கிரிப்ட் உடனடியாக `getUserId` வரியில் ஒரு பிழையை வீசும். செய்தி மிகவும் தெளிவாக இருக்கும்: 'string' வகையின் ஆர்குமென்ட் 'User' வகையின் அளவுருவிற்கு ஒதுக்க முடியாதது. `getFirstName` இன் வெளியீடு (`string`) `getUserId` க்குத் தேவையான உள்ளீட்டுடன் (`User`) பொருந்தவில்லை என்பதை கம்பைலர் கண்டறிந்தது.

வேறு ஒரு தவறை முயற்சிப்போம்:

            const invalidResult2 = user
  |> getUserId      // OK: User -> number
  |> toUpperCase;    // ERROR! toUpperCase expects a string, but receives a number

            

              
                Copy
              
            
          

இந்த வழக்கில், முதல் படி செல்லுபடியானது. `user` ஆப்ஜெக்ட் சரியாக `getUserId` க்கு அனுப்பப்பட்டு, அதன் விளைவாக ஒரு `number` கிடைக்கிறது. இருப்பினும், பைப்லைன் பின்னர் இந்த `number` ஐ `toUpperCase` க்கு அனுப்ப முயற்சிக்கிறது. டைப்ஸ்கிரிப்ட் உடனடியாக இதை மற்றொரு தெளிவான பிழையுடன் குறிக்கிறது: 'number' வகையின் ஆர்குமென்ட் 'string' வகையின் அளவுருவிற்கு ஒதுக்க முடியாதது.

இந்த உடனடி, உள்ளூர்மயமாக்கப்பட்ட பின்னூட்டம் விலைமதிப்பற்றது. பைப்லைன் தொடரியலின் நேரியல் தன்மை, சங்கிலியில் தோல்வியுற்ற இடத்தில் நேரடியாக, வகை பொருத்தமின்மை எங்கு ஏற்பட்டது என்பதைக் கண்டறிவதை அற்பமாக்குகிறது.

மேம்பட்ட காட்சிகள் மற்றும் வகை-பாதுகாப்பான வடிவங்கள்

பைப்லைன் ஆபரேட்டர் மற்றும் அதன் வகை அனுமான திறன்களின் நன்மைகள் எளிய, ஒத்திசைவான செயல்பாட்டுச் சங்கிலிகளைத் தாண்டி நீண்டுள்ளன. மிகவும் சிக்கலான, நிஜ-உலக காட்சிகளை ஆராய்வோம்.

ஒத்திசைவற்ற செயல்பாடுகள் மற்றும் ப்ராமிஸ்களுடன் வேலை செய்தல்

தரவு செயலாக்கம் பெரும்பாலும் ஒரு API இலிருந்து தரவைப் பெறுவது போன்ற ஒத்திசைவற்ற செயல்பாடுகளை உள்ளடக்கியது. சில ασύγχρονο செயல்பாடுகளை வரையறுப்போம்:

            interface Post { id: number; userId: number; title: string; body: string; }

const fetchPost = async (id: number): Promise<Post> => {
  const response = await fetch(`https://jsonplaceholder.typicode.com/posts/${id}`);
  return response.json();
};

const getTitle = (post: Post): string => post.title;

// We need to use 'await' in an async context
async function getPostTitle(id: number): Promise<string> {
  const post = await fetchPost(id);
  const title = getTitle(post);
  return title; 
}

            

              
                Copy
              
            
          

F# பைப்லைன் முன்மொழிவில் `await` க்கு சிறப்பு தொடரியல் இல்லை. இருப்பினும், நீங்கள் அதை ஒரு `async` செயல்பாட்டிற்குள் பயன்படுத்தலாம். முக்கிய விஷயம் என்னவென்றால், ப்ராமிஸ்களை புதிய ப்ராமிஸ்களைத் திருப்பியளிக்கும் செயல்பாடுகளுக்குள் செலுத்த முடியும், மேலும் டைப்ஸ்கிரிப்டின் வகை அனுமானம் இதை அழகாக கையாள்கிறது.

            const extractJson = <T>(res: Response): Promise<T> => res.json();

async function getPostTitlePipeline(id: number): Promise<string> {
  const url = `https://jsonplaceholder.typicode.com/posts/${id}`;

  const title = await (url
    |> fetch // fetch returns a Promise<Response>
    |> p => p.then(extractJson<Post>) // .then returns a Promise<Post>
    |> p => p.then(getTitle) // .then returns a Promise<string>
  );

  return title;
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், டைப்ஸ்கிரிப்ட் ப்ராமிஸ் சங்கிலியின் ஒவ்வொரு கட்டத்திலும் வகையைச் சரியாக அனுமானிக்கிறது. `fetch` ஒரு `Promise` ஐத் திருப்புகிறது என்றும், `p.then(extractJson)` அதை ஒரு `Promise` ஆக மாற்றுகிறது என்றும், `p.then(getTitle)` அதை ஒரு `Promise` ஆக மாற்றுகிறது என்றும் அதற்குத் தெரியும். இறுதி `await` இதை ஒரு `string` ஆக அவிழ்க்கிறது. முழு பைப்லைனும் ஒத்திசைவற்ற எல்லைகளுக்கு அப்பாலும் வகை-பாதுகாப்பாக உள்ளது.

அதிகபட்ச கலவைக்கான கரியிங் மற்றும் பகுதி பயன்பாடு

ஃபங்ஷனல் ப்ரோகிராமிங் கரியிங் மற்றும் பகுதி பயன்பாடு போன்ற கருத்துக்களை பெரிதும் நம்பியுள்ளது, அவை பைப்லைன் ஆபரேட்டருக்கு hoàn hảoவாகப் பொருந்துகின்றன. கரியிங் என்பது பல ஆர்குமென்ட்களை எடுக்கும் ஒரு செயல்பாட்டை, ஒவ்வொன்றும் ஒரு ஆர்குமென்டை எடுக்கும் செயல்பாடுகளின் வரிசையாக மாற்றும் செயல்முறையாகும்.

கலவைக்காக வடிவமைக்கப்பட்ட ஒரு பொதுவான `map` மற்றும் `filter` செயல்பாட்டைக் கவனியுங்கள்:

            // Curried map function: takes a function, returns a new function that takes an array
const map = <T, U>(fn: (item: T) => U) => (arr: T[]): U[] => arr.map(fn);

// Curried filter function
const filter = <T>(predicate: (item: T) => boolean) => (arr: T[]): T[] => arr.filter(predicate);

const numbers: number[] = [1, 2, 3, 4, 5, 6];

// Create partially applied functions
const double = map((n: number) => n * 2);
const isGreaterThanFive = filter((n: number) => n > 5);

const processedNumbers = numbers
  |> double               // TypeScript infers the output is number[]
  |> isGreaterThanFive;   // TypeScript infers the final output is number[]

console.log(processedNumbers); // [6, 8, 10, 12]

            

              
                Copy
              
            
          

இங்கே, டைப்ஸ்கிரிப்டின் அனுமான இயந்திரம் பிரகாசிக்கிறது. `double` என்பது `(arr: number[]) => number[]` வகையின் ஒரு செயல்பாடு என்பதை அது புரிந்துகொள்கிறது. `numbers` (ஒரு `number[]`) அதற்குள் செலுத்தப்படும்போது, கம்பைலர் வகைகள் பொருந்துவதை உறுதிசெய்து, முடிவும் ஒரு `number[]` என்று அனுமானிக்கிறது. இந்த விளைவான வரிசை பின்னர் `isGreaterThanFive` க்குள் செலுத்தப்படுகிறது, இது ஒரு இணக்கமான கையொப்பத்தைக் கொண்டுள்ளது, மேலும் இறுதி முடிவு சரியாக `number[]` என அனுமானிக்கப்படுகிறது. இந்த முறை, பைப்லைன் ஆபரேட்டரைப் பயன்படுத்தி எந்த வரிசையிலும் கலக்கக்கூடிய, மீண்டும் பயன்படுத்தக்கூடிய, வகை-பாதுகாப்பான தரவு மாற்ற 'லெகோ செங்கற்கள்' ஒரு நூலகத்தை உருவாக்க உங்களை அனுமதிக்கிறது.

பரந்த தாக்கம்: டெவலப்பர் அனுபவம் மற்றும் குறியீடு பராமரிப்புத்திறன்

பைப்லைன் ஆபரேட்டர் மற்றும் வகை அனுமானத்திற்கு இடையிலான ஒருங்கிணைப்பு வெறும் பிழைகளைத் தடுப்பதைத் தாண்டியது; இது முழு வளர்ச்சி வாழ்க்கைச் சுழற்சியையும் அடிப்படையில் மேம்படுத்துகிறது.

பிழைத்திருத்தம் எளிதாக்கப்பட்டது

`c(b(a(x)))` போன்ற ஒரு உள்ளமைக்கப்பட்ட செயல்பாட்டு அழைப்பை பிழைத்திருத்தம் செய்வது வெறுப்பாக இருக்கலாம். `a` மற்றும் `b` க்கு இடையில் உள்ள இடைநிலை மதிப்பைப் பரிசோதிக்க, நீங்கள் கோவையை உடைக்க வேண்டும். பைப்லைன் ஆபரேட்டருடன், பிழைத்திருத்தம் அற்பமாகிறது. குறியீட்டை மறுசீரமைக்காமல் சங்கிலியில் எந்த இடத்திலும் ஒரு பதிவு செயல்பாட்டை நீங்கள் செருகலாம்.

            // A generic 'tap' or 'spy' function for debugging
const tap = <T>(label: string) => (value: T): T => {
  console.log(`[${label}]:`, value);
  return value;
};

const result = user
  |> getFirstName
  |> tap('After getFirstName') // Inspect the value here
  |> toUpperCase
  |> tap('After toUpperCase') // And here
  |> trim;

            

              
                Copy
              
            
          

டைப்ஸ்கிரிப்டின் ஜெனரிக்ஸ்-க்கு நன்றி, நமது `tap` செயல்பாடு முழுமையாக வகை-பாதுகாப்பானது. இது `T` வகையின் ஒரு மதிப்பை ஏற்று, அதே வகை `T` இன் ஒரு மதிப்பைத் திருப்புகிறது. இதன் பொருள், வகைச் சங்கிலியை உடைக்காமல் பைப்லைனில் எங்கும் இதைச் செருகலாம். `tap` இன் வெளியீடு அதன் உள்ளீட்டின் அதே வகையைக் கொண்டுள்ளது என்பதை கம்பைலர் புரிந்துகொள்கிறது, எனவே வகை தகவலின் ஓட்டம் தடையின்றி தொடர்கிறது.

ஜாவாஸ்கிரிப்டில் ஃபங்ஷனல் ப்ரோகிராமிங்கிற்கான ஒரு நுழைவாயில்

பல டெவலப்பர்களுக்கு, பைப்லைன் ஆபரேட்டர் ஃபங்ஷனல் ப்ரோகிராமிங் கொள்கைகளுக்கு ஒரு அணுகக்கூடிய நுழைவுப் புள்ளியாக செயல்படுகிறது. இது இயல்பாகவே சிறிய, தூய்மையான, ஒற்றைப்-பொறுப்பு செயல்பாடுகளை உருவாக்க ஊக்குவிக்கிறது. ஒரு தூய்மையான செயல்பாடு என்பது அதன் திரும்பும் மதிப்பு அதன் உள்ளீட்டு மதிப்புகளால் மட்டுமே தீர்மானிக்கப்படுகிறது, கவனிக்கக்கூடிய பக்க விளைவுகள் இல்லாமல். அத்தகைய செயல்பாடுகளைப் பற்றி பகுத்தறிவது, தனித்தனியாகச் சோதிப்பது, மற்றும் ஒரு திட்டம் முழுவதும் மீண்டும் பயன்படுத்துவது எளிதானது—இவை அனைத்தும் வலுவான, அளவிடக்கூடிய மென்பொருள் கட்டமைப்பின் அடையாளங்களாகும்.

உலகளாவிய பார்வை: பிற மொழிகளிலிருந்து கற்றல்

பைப்லைன் ஆபரேட்டர் ஒரு புதிய கண்டுபிடிப்பு அல்ல. இது மற்ற வெற்றிகரமான நிரலாக்க மொழிகள் மற்றும் சூழல்களில் இருந்து கடன் வாங்கப்பட்ட ஒரு போர்க்களத்தில் சோதிக்கப்பட்ட கருத்து. F#, எலிக்சிர் மற்றும் ஜூலியா போன்ற மொழிகள் நீண்ட காலமாக பைப்லைன் ஆபரேட்டரை அவற்றின் தொடரியலின் ஒரு முக்கிய பகுதியாகக் கொண்டுள்ளன, அங்கு அது அறிவிப்பு மற்றும் படிக்கக்கூடிய குறியீட்டை ஊக்குவிப்பதற்காகக் கொண்டாடப்படுகிறது. அதன் கருத்தியல் முன்னோடி யூனிக்ஸ் பைப் (`|`) ஆகும், இது பல தசாப்தங்களாக கணினி நிர்வாகிகள் மற்றும் டெவலப்பர்களால் கட்டளை-வரி கருவிகளை ஒன்றாக இணைக்கப் பயன்படுத்தப்படுகிறது. ஜாவாஸ்கிரிப்டில் இந்த ஆபரேட்டரை ஏற்றுக்கொள்வது அதன் நிரூபிக்கப்பட்ட பயன்பாட்டிற்கு ஒரு சான்றாகும் மற்றும் வெவ்வேறு சுற்றுச்சூழல் அமைப்புகளில் சக்திவாய்ந்த நிரலாக்க முன்னுதாரணங்களை ஒத்திசைப்பதை நோக்கிய ஒரு படியாகும்.

இன்று பைப்லைன் ஆபரேட்டரை எவ்வாறு பயன்படுத்துவது

பைப்லைன் ஆபரேட்டர் இன்னும் ஒரு TC39 முன்மொழிவாக இருப்பதால் மற்றும் எந்த அதிகாரப்பூர்வ ஜாவாஸ்கிரிப்ட் இயந்திரத்தின் ஒரு பகுதியாக இன்னும் இல்லாததால், அதை உங்கள் திட்டங்களில் இன்று பயன்படுத்த உங்களுக்கு ஒரு டிரான்ஸ்பைலர் தேவை.

1. பேபலுடன் டிரான்ஸ்பைலேஷன்

பைப்லைன் ஆபரேட்டருக்கான பேபல் செருகுநிரலை நீங்கள் நிறுவ வேண்டும். 'fsharp' முன்மொழிவைக் குறிப்பிடுவதை உறுதிப்படுத்திக் கொள்ளுங்கள், ஏனெனில் அதுதான் முன்னேறி வருகிறது.

சார்பை நிறுவவும்:

            npm install --save-dev @babel/plugin-proposal-pipeline-operator
            

              
                Copy
              
            
          

பின்னர், உங்கள் பேபல் அமைப்புகளை உள்ளமைக்கவும் (உதாரணமாக, `.babelrc.json` இல்):

            {
  "plugins": [
    ["@babel/plugin-proposal-pipeline-operator", { "proposal": "fsharp" }]
  ]
}

            

              
                Copy
              
            
          

2. டைப்ஸ்கிரிப்டுடன் ஒருங்கிணைப்பு

டைப்ஸ்கிரிப்ட் தானாக பைப்லைன் ஆபரேட்டரின் தொடரியலை டிரான்ஸ்பைல் செய்யாது. நிலையான அமைப்பு வகை சரிபார்ப்புக்கு டைப்ஸ்கிரிப்டையும், டிரான்ஸ்பைலேஷனுக்கு பேபலையும் பயன்படுத்துவதாகும்.

1. வகை சரிபார்ப்பு: உங்கள் குறியீடு எடிட்டர் (VS குறியீடு போன்றவை) மற்றும் டைப்ஸ்கிரிப்ட் கம்பைலர் (tsc) உங்கள் குறியீட்டைப் பகுப்பாய்வு செய்து, அம்சம் பூர்வீகமாக இருப்பது போல வகை அனுமானம் மற்றும் பிழை சரிபார்ப்பை வழங்கும். வகை பாதுகாப்பை அனுபவிக்க இது முக்கியமான படியாகும்.
2. டிரான்ஸ்பைலேஷன்: உங்கள் உருவாக்க செயல்முறை பேபலை (@babel/preset-typescript மற்றும் பைப்லைன் செருகுநிரலுடன்) பயன்படுத்தி முதலில் டைப்ஸ்கிரிப்ட் வகைகளை அகற்றி, பின்னர் பைப்லைன் தொடரியலை எந்த உலாவி அல்லது Node.js சூழலிலும் இயங்கக்கூடிய நிலையான, இணக்கமான ஜாவாஸ்கிரிப்டாக மாற்றும்.

இந்த இரு-படி செயல்முறை உங்களுக்கு இரு உலகங்களிலும் சிறந்ததை வழங்குகிறது: வலுவான, ஸ்டேடிக் வகை பாதுகாப்புடன் அதிநவீன மொழி அம்சங்கள்.

முடிவு: ஜாவாஸ்கிரிப்ட் கலவைக்கான ஒரு வகை-பாதுகாப்பான எதிர்காலம்

ஜாவாஸ்கிரிப்ட் பைப்லைன் ஆபரேட்டர் வெறும் தொடரியல் இனிப்பை விட அதிகம். இது குறியீடு எழுதுவதில் மிகவும் அறிவிப்பு, படிக்கக்கூடிய, மற்றும் பராமரிக்கக்கூடிய பாணியை நோக்கிய ஒரு முன்னுதாரண மாற்றத்தைக் குறிக்கிறது. அதன் உண்மையான ஆற்றல், இருப்பினும், டைப்ஸ்கிரிப்ட் போன்ற ஒரு வலுவான வகை அமைப்புடன் இணைக்கப்படும்போது மட்டுமே முழுமையாக உணரப்படுகிறது.

செயல்பாட்டு கலவைக்கு ஒரு நேரியல், உள்ளுணர்வு தொடரியலை வழங்குவதன் மூலம், பைப்லைன் ஆபரேட்டர் டைப்ஸ்கிரிப்டின் சக்திவாய்ந்த வகை அனுமான இயந்திரம் ஒரு மாற்றத்திலிருந்து அடுத்ததற்கு தடையின்றி பாய அனுமதிக்கிறது. இது தரவின் பயணத்தின் ஒவ்வொரு படியையும் சரிபார்த்து, வகை பொருத்தமின்மைகள் மற்றும் தர்க்கப் பிழைகளை கம்பைல் நேரத்தில் பிடிக்கிறது. இந்த ஒருங்கிணைப்பு உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு ஒரு முழு வகை இயக்க நேரப் பிழைகள் அகற்றப்பட்டுவிட்டன என்பதை அறிந்து, புதிய நம்பிக்கையுடன் சிக்கலான தரவு செயலாக்க தர்க்கத்தை உருவாக்க அதிகாரம் அளிக்கிறது.

இந்த முன்மொழிவு ஜாவாஸ்கிரிப்ட் மொழியின் ஒரு நிலையான பகுதியாக மாறுவதற்கான அதன் பயணத்தைத் தொடரும்போது, பேபல் போன்ற கருவிகள் மூலம் இன்று அதை ஏற்றுக்கொள்வது குறியீட்டின் தரம், டெவலப்பர் உற்பத்தித்திறன், மற்றும் மிக முக்கியமாக, பாறை போன்ற திடமான வகை பாதுகாப்பில் ஒரு முன்னோக்கிய சிந்தனை முதலீடாகும்.