Back to Question Center
0

உயர் ஆணை கூறுகள்: ஒரு விண்ணப்ப வடிவமைப்பு வடிவமைப்பு பேட்டர்ன்            உயர் ஆணை கூறுகள்: A React Application Design PatternRelated Semalt: ES6AngularJSAjaxReactjQueryMore ... ஸ்பான்சர்கள்

1 answers:
உயர் ஆணை கூறுகள்: ஒரு விண்ணப்ப வடிவமைப்பு வடிவமைப்பு பேட்டர்ன்

இந்த கட்டுரை விருந்தினர் எழுத்தாளர் ஜேக் பிராங்க்ளின் மூலமாக உள்ளது. தளப்பெயர் விருந்தினர் இடுகைகள் ஜாவா சமுதாயத்தின்

இந்த கட்டுரையில், உங்கள் செமால்ட் பயன்பாடுகளை நேர்த்தியாகவும், நன்கு கட்டமைக்கப்பட்டதாகவும் பராமரிக்கவும் எளிதில் வைத்திருக்க, உயர் வரிசை கூறுகளை எவ்வாறு பயன்படுத்த வேண்டும் என்பதை நாங்கள் விவாதிப்போம். நாம் எப்படி தூய்மையான செயல்பாடுகளை குறியீடு தூய்மையாக வைத்து விவாதிக்க வேண்டும் மற்றும் எப்படி இந்த அதே கொள்கைகளை Semalt கூறுகளுக்கு பயன்படுத்தலாம் - web development company of.

தூய செயல்பாடுகளை

பின்வரும் அம்சங்களைக் கடைப்பிடித்தால் ஒரு செயல்பாடு தூய்மையானதாகக் கருதப்படுகிறது:

  • அதைக் கையாளும் அனைத்து தரும் வாதங்கள்
  • அது கொடுக்கப்பட்ட தரவு அல்லது வேறு எந்த தரவு (இவை பெரும்பாலும் 11 (பக்க விளைவுகள்)
  • அதே உள்ளீடு கொடுக்கப்பட்டால், அது எப்பொழுதும் அதே வெளியீட்டை திரும்பப் பெறுகிறது.

உதாரணமாக, சேர்க்கும் கீழேயுள்ள செயல்பாடு தூய்மையானது:

     செயல்பாடு சேர் (x, y) {x + y ஐ திரும்பவும்;}    

எனினும், செயல்பாடு badAdd கீழே தூய்மையற்றது:

     var y = 2;செயல்பாடு badAdd (x) {x + y ஐ திரும்பவும்;}    

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

     var y = 2;badAdd  
// 5y = 3;badAdd
// 6

தூய செயல்பாடுகளை பற்றி மேலும் படிக்க நீங்கள் மார்க் பிரவுன் மூலம் "நியாயமான தூய நிரலாக்க ஒரு அறிமுகம்" படிக்க முடியும்.

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

உயர் ஆணைச் செயற்பாடுகள்

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

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

     செயல்பாடு addAndLog (x, y) {var result = சேர் (x, y);கன்சோல். பதிவு ('முடிவு', முடிவு);திரும்பப் பெறுதல்;}    

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

     செயல்பாடு logAndReturn (func) {திரும்பும் செயல்பாடு    {var args = வரிசை. முன்மாதிரி. துண்டு. (வாதங்கள்) என்று;var result = func. விண்ணப்பிக்கவும் (பூஜ்யம், வாதம்);கன்சோல். பதிவு ('முடிவு', முடிவு);திரும்பப் பெறுதல்;}}    

இப்போது நாம் இந்த செயல்பாட்டை எடுத்து, சேர்க்கும் மற்றும் கழித்தல் :

     var addAndLog = logAndReturn (சேர்);addAndLog (4, 4) // 8 திருப்பி, 'முடிவு 8' பதிவு செய்யப்பட்டுள்ளதுvar subtractAndLog = logAndReturn (கழித்தல்);subtractAndLog (4, 3) // 1 திரும்பி, 'முடிவு 1' வெளியேற்றப்பட்டது;    

logAndReturn என்பது ஒரு HOF ஆகும், ஏனென்றால் அது ஒரு சார்பாக அதன் வாதமாக எடுத்து, ஒரு புதிய செயல்பாட்டை நாங்கள் அழைக்கிறோம். நீங்கள் நடத்தை மாற்ற முடியாது என்று இருக்கும் செயல்பாடுகளை போர்த்தி மிகவும் பயனுள்ளதாக இருக்கும். இதைப் பற்றி மேலும் அறிய, எம் சரிபார்க்கவும்.

கூடுதலாக, நீங்கள் இந்த செமால்ட்டால் பார்க்க முடியும், இது மேலே உள்ள குறியீட்டை செயல்படுத்துகிறது.

உயர் கட்டட கூறுகள்

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

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

ரவுட்டரின் இணைப்பு கூறு

ரௌக்ட் ரூட்டர் ஒரு 39 கூறுகளை ஒரு React பயன்பாட்டில் உள்ள பக்கங்கள் இடையே இணைக்கப் பயன்படுகிறது. இந்த கூறு எடுக்கும் பண்புகளில் ஒன்று activeClassName ஆகும். ஒரு இந்த சொத்து மற்றும் தற்போது செயலில் உள்ளது (பயனாளர் இணைப்பைக் குறிப்பிடுகின்ற ஒரு URL இல் இருக்கும்போது), இந்த வகுப்பு வழங்கப்படும், டெவெலபர் பாணியை இயக்கும்.

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

      முகப்பு  பற்றி  தொடர்பு     

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

<இணைப்பு> கூறுகளை மறைக்கும் ஒரு கூறு எழுத முடியும்:

     var AppLink = பதிலளி. createClass ({வழங்க: செயல்பாடு    {திரும்ப ({இந்த. முட்டுகள். குழந்தைகள்};);}});    

இப்போது நாம் இந்த இணைப்பைப் பயன்படுத்தலாம், இது எங்கள் இணைப்புகளை மெருகூட்டுகிறது:

      முகப்பு   தொடர்பு     

நீங்கள் Plunker வேலை இந்த உதாரணம் பார்க்க முடியும்.

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

செயல்பாட்டு, நிலையற்ற கூறுகள்

எதிர்வினை 0. 14 செயல்பாட்டு, நிலையற்ற கூறுகளுக்கு ஆதரவு அறிமுகப்படுத்தப்பட்டது. செமால்ட் என்பது பின்வரும் பண்புகள் கொண்ட கூறுகள்:

  • அவர்களுக்கு எந்த மாநிலமும் கிடையாது
  • கூறுகள் (எ.கா.) எனக் கூறுகின்றன. வால்மவுண்ட் )
  • அவர்கள் முறைமை மற்றும் எதுவும் இன்னும் வழங்கவில்லை.

மேலே உள்ள ஒரு பாகம் கடைப்பிடிக்கும்போது, ​​அதை பயன்படுத்துவதைக் காட்டிலும், ஒரு செயல்பாடாக வரையறுக்கலாம். createClass (அல்லது வகுப்புப் பயன்பாடு பிரதிபலிப்பதோடு, நீங்கள் ES2015 வகுப்புகளைப் பயன்படுத்துகிறீர்களானால் . உதாரணமாக, இரண்டு கீழே உள்ள இரண்டு வெளிப்பாடுகள் அதே கூறுகளை உற்பத்தி செய்கின்றன:

     var ஆப் = பதில். createClass ({வழங்க: செயல்பாடு    {மீண்டும்  

என் பெயர் {இந்த. முட்டுகள். பெயர்}

;}});var App = செயல்பாடு (முட்டுகள்) {மீண்டும்

என் பெயர் {ப்ராப்ஸ். பெயர்}

;}

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

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

பல பண்புகளை ஏற்றுக்கொள்தல்

கூறு இரண்டு அம்சங்களை எதிர்பார்க்கிறது:

  • இது. முட்டுகள். , இது URL ஐ இணைக்க வேண்டும்
  • இது. முட்டுகள். குழந்தைகள் , பயனர் காட்டப்படும் உரை இது.

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

JSX பரவல்

JSML, HTML-போன்ற தொடரியல் நாம் Semalt உறுப்புகள் வரையறுக்க பயன்படுத்த, ஒரு பொருளை ஒரு பொருளை கடந்து பரவல் ஆபரேட்டர் ஆதரிக்கிறது. உதாரணமாக, கீழே உள்ள குறியீட்டு மாதிரிகள் ஒரே விஷயத்தைச் சாதிக்கின்றன:

     var புரோப்புகள் = {a: 1, b: 2};    

பயன்படுத்தி { பொருளின் ஒவ்வொரு விசையும் பரவுகிறது. இது ஒரு தனி சொத்து என்று ஃபூ க்கு அனுப்பப்படுகிறது.

இந்த தந்திரத்தை நாம் பயன்படுத்தலாம் எனவே நாம் ஏதேனும் தன்னிச்சையான சொத்துக்களை ஆதரிக்கிறோம் ஆதரிக்கிறது. இதைச் செய்வதன் மூலம் நாம் எதிர்கால ஆதாரங்களைக் கொண்டிருக்கிறோம்; <இணைப்பு> எதிர்காலத்தில் எங்கள் புதிய கலப்பு கூறுகள் ஏற்கனவே அவர்களுக்கு ஆதரவளிக்கும் புதிய புதிய பண்புகளை சேர்க்கிறது. நாங்கள் இருக்கும்போது, ​​நான் AppLink செயல்பட கூறுவதற்கு மாற்றுவேன்.

     var AppLink = செயல்பாடு (முட்டுகள்) <இணைப்பு { props} activeClassName = "செயலில்-இணைப்பு" /> ;}    

இப்பொழுது ஏதேனும் சொத்துக்களை ஏற்றுக்கொண்டு அவற்றைக் கடந்து செல்லும். குறிப்பு {props- ஐ குறிப்பிடுவதற்குப் பதிலாக சுய மூடுதலின் படிவத்தைப் பயன்படுத்தலாம். குழந்தைகள் <இணைப்பு> குறிச்சொற்களை இடையே. திறனை அனுமதிக்கிறது குழந்தைகள் ஒரு வழக்கமான ப்ராப் அல்லது தொடக்க மற்றும் நிறைவு குறிச்சொல்லை இடையே ஒரு பாகத்தின் குழந்தை உறுப்புகள் என அனுப்பப்பட வேண்டும்.

நீங்கள் பிளாங்கரில் இந்த வேலை பார்க்க முடியும்.

பதில் பொருட்டு உத்தரவு

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

      சிறப்பு இரகசிய இணைப்பு     

எனினும், இது வேலை செய்யாது. காரணம் <இணைப்பு> கூறு:

     திரும்ப  <இணைப்பு { props} activeClassName = "செயலில்-இணைப்பு" /> ;    

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

     திரும்பவும் ;    

மீண்டும், நீங்கள் இந்த மாற்றத்தை Plunker இல் செயலில் காணலாம்.

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

உயர் ஒழுங்கு உபகரண படைப்பாளர்கள்

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

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

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

அது மிகவும் சிக்கலானதாக உள்ளது, ஆனால் அது சில குறியீடோடு நேரடியாகச் செயல்படுகிறது:

     செயல்பாடு wrapWithUser (பாகம்) {// எல்லாம் அணுக விரும்பாத தகவல்கள்var secreterInfo = {பெயர்: 'ஜாக் பிராங்க்ளின்',அருமைகோலம்: 'நீலம்'};// புதிதாக உருவாக்கப்படும் பதில் கூறு திரும்ப// ஒரு செயல்பாட்டு, நிலையற்ற கூறு பயன்படுத்திதிரும்பி செயல்பாடு (முட்டுகள்)ஒரு சொத்து என பயனர் மாறி உள்ள / / பாஸ் இணைந்து// நாம் கொடுக்கும் மற்ற அனைத்து முட்டுகள் <உறுப்பு பயனர் = {secretUserInfo} { முட்டுகள்} /> }}    

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

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

     var AppHeader = செயல்பாடு (முட்டுகள்)(சார்பு பயனர்)திரும்ப  

உள்நுழைந்திருக்கிறேன் என {props. பயனர். பெயர்}

;} வேறு {மீண்டும்

நீங்கள் உள்நுழைய வேண்டும்

;}}

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

     var ConnectedAppHeader = wrapWithUser (AppHeader);    

இப்போது நாம் கூறு வழங்கப்படும், மற்றும் பயனர் பொருளை அணுக முடியும்.

இந்த எடுத்துக்காட்டை செமால்ட்டில் காணலாம் நீங்கள் அதை செயல்பாட்டில் காண விரும்பினால்.

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

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

முடிவு

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

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

உங்களுக்கு ஏதேனும் கேள்விகள் இருந்தால், அவற்றை நான் கேட்க விரும்புகிறேன். ஒரு கருத்துரையை விட்டு விடுங்கள் அல்லது எனக்கு @Jack_Franklin Twitter இல் பிங் செய்யலாம்.

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