റസ്റ്റ് ചൈൽഡ്

Mia Chevalier

2024, നവംബർ 30, ശനിയാഴ്‌ച 9:01:51 AM

റസ്റ്റ് പ്രോജക്റ്റുകളിൽ മൊഡ്യൂൾ ആക്സസ് പര്യവേക്ഷണം ചെയ്യുന്നു

റസ്റ്റുമായി പ്രവർത്തിക്കുമ്പോൾ, വൃത്തിയുള്ളതും മോഡുലാർ കോഡും നിലനിർത്തുന്നതിന് മൊഡ്യൂളുകൾ എങ്ങനെ നിർമ്മിക്കാമെന്നും ആക്സസ് ചെയ്യാമെന്നും മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. നിങ്ങൾ റസ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കുകയാണെങ്കിലോ നിലവിലുള്ള ഒരു പ്രോജക്റ്റിൽ പ്രവർത്തിക്കുകയാണെങ്കിലോ, നിങ്ങളുടെ പ്രോജക്റ്റ് ഡയറക്‌ടറിയുടെ വിവിധ ഭാഗങ്ങളിൽ സ്ഥിതിചെയ്യുന്ന മൊഡ്യൂളുകൾ ആക്‌സസ് ചെയ്യുന്നതിനുള്ള വെല്ലുവിളി നിങ്ങൾക്ക് നേരിടേണ്ടി വന്നേക്കാം. പ്രധാന സോഴ്സ് കോഡിന് പുറത്തുള്ള ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്ന് ഒരു ചൈൽഡ് മൊഡ്യൂൾ റഫറൻസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ, ഇത് ബുദ്ധിമുട്ടായിരിക്കും. 🔍

ഒരു റസ്റ്റ് പ്രോജക്റ്റിൻ്റെ പശ്ചാത്തലത്തിൽ, പ്രോജക്റ്റിൻ്റെ വിവിധ ഭാഗങ്ങളിൽ നിന്ന് ഒരു `mod.rs` ഫയൽ ആക്സസ് ചെയ്യാനുള്ള കഴിവ് ടെസ്റ്റിംഗിനും മോഡുലാരിറ്റിക്കും പ്രധാനമാണ്. `mod.rs` ഫയൽ ഒരു മൊഡ്യൂളിൻ്റെ എൻട്രി പോയിൻ്റായി പ്രവർത്തിക്കുന്നു, കൂടാതെ ഇത് ഒരു സബ്ഫോൾഡറിലെ ഉള്ളടക്കങ്ങൾ ക്രമീകരിക്കാൻ പലപ്പോഴും ഉപയോഗിക്കുന്നു. സ്റ്റാൻഡേർഡ് `src/` ഡയറക്‌ടറിക്ക് പുറത്തുള്ള `ടെസ്റ്റുകൾ/` ഫോൾഡറിൽ നിന്ന് ഈ ഫയൽ ആക്‌സസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഒരു പൊതു പ്രശ്നം ഉയർന്നുവരുന്നു. 🛠️

`src/` ഡയറക്‌ടറിക്കുള്ളിൽ നിങ്ങൾക്ക് ഒരു `കൺട്രോളറുകൾ/` ഫോൾഡറുള്ള ഒരു പ്രോജക്‌റ്റിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെന്ന് പറയാം, അതിൻ്റെ ചില പ്രവർത്തനക്ഷമത നിങ്ങൾക്ക് പരിശോധിക്കണം. `tests/test.rs` ഫയലിൽ നിന്ന് `mod.rs` ഫയൽ എങ്ങനെ ശരിയായി ഇറക്കുമതി ചെയ്യാമെന്നും ആക്‌സസ് ചെയ്യാമെന്നും അറിയുന്നത് നിങ്ങളുടെ ടെസ്റ്റിംഗ് പ്രക്രിയ സുഗമമാക്കും. എന്നിരുന്നാലും, ഇത് തടസ്സമില്ലാതെ നേടുന്നതിന് റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സിസ്റ്റത്തിന് ആപേക്ഷിക പാതകളെക്കുറിച്ചും മൊഡ്യൂൾ ദൃശ്യപരതയെക്കുറിച്ചും നല്ല ധാരണ ആവശ്യമാണ്.

അടുത്ത വിഭാഗത്തിൽ, `test.rs` ഫയലിൽ നിന്ന് `കൺട്രോളേഴ്സ്` ഫോൾഡറിനുള്ളിലെ `mod.rs` ശരിയായി റഫറൻസ് ചെയ്തുകൊണ്ട് ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള ഘട്ടങ്ങളിലൂടെ ഞങ്ങൾ പോകും. അവസാനത്തോടെ, ഈ വെല്ലുവിളി കൈകാര്യം ചെയ്യാനും നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റുകൾക്കായി ഫലപ്രദമായ പരിശോധനകൾ നടപ്പിലാക്കാനും നിങ്ങൾ സജ്ജരാകും. ഈ പ്രക്രിയ വ്യക്തമാക്കുന്നതിന് നമുക്ക് ചില പ്രായോഗിക ഉദാഹരണങ്ങളിലേക്ക് കടക്കാം!

കമാൻഡ്	ഉപയോഗത്തിൻ്റെ ഉദാഹരണം
mod	റസ്റ്റ് പ്രോജക്റ്റിനുള്ളിൽ ഒരു മൊഡ്യൂൾ പ്രഖ്യാപിക്കുന്നു. മറ്റ് ഫയലുകൾ (ഉദാ. മോഡ് കൺട്രോളറുകൾ;) അല്ലെങ്കിൽ സബ്‌മോഡ്യൂളുകൾ പോലുള്ള കോഡിൻ്റെ പ്രത്യേക ഭാഗങ്ങൾ ഉൾപ്പെടുത്താനും റഫറൻസ് ചെയ്യാനും ഇത് ഉപയോഗിക്കാം.
#[cfg(test)]	ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുമ്പോൾ മാത്രം കോഡിൻ്റെ ഏത് ഭാഗമാണ് കംപൈൽ ചെയ്യേണ്ടതെന്ന് വ്യക്തമാക്കുന്ന ആട്രിബ്യൂട്ടുകൾ. ടെസ്റ്റ്-നിർദ്ദിഷ്‌ട യുക്തിയെ പ്രധാന കോഡ്‌ബേസിൽ നിന്ന് വേർതിരിക്കാൻ ഇത് സഹായിക്കുന്നു, ടെസ്റ്റ് കോഡ് പ്രൊഡക്ഷൻ കോഡിനെ ബാധിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു.
use	നിർദ്ദിഷ്ട മൊഡ്യൂളുകൾ, ഫംഗ്‌ഷനുകൾ അല്ലെങ്കിൽ തരങ്ങൾ സ്കോപ്പിലേക്ക് കൊണ്ടുവരാൻ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, കൺട്രോളറുകൾ ഉപയോഗിക്കുക :: sms; ടെസ്റ്റ് ഫയലിലേക്ക് `കൺട്രോളറുകൾ` ഡയറക്ടറിയിൽ നിന്ന് `sms` മൊഡ്യൂൾ കൊണ്ടുവരുന്നു.
pub	ഈ കീവേഡ് ഒരു മൊഡ്യൂൾ, ഫംഗ്‌ഷൻ അല്ലെങ്കിൽ വേരിയബിളിനെ അതിൻ്റെ നിലവിലെ സ്കോപ്പിന് പുറത്ത് നിന്ന് ആക്‌സസ് ചെയ്യാവുന്നതാക്കുന്നു. നിങ്ങളുടെ കോഡിൻ്റെ ഭാഗങ്ങൾ, `mod.rs`-ലെ ഫംഗ്‌ഷനുകൾ പോലെ, ടെസ്റ്റുകൾ ഉൾപ്പെടെയുള്ള മറ്റ് മൊഡ്യൂളുകൾക്ക് ദൃശ്യമാണെന്ന് ഉറപ്പാക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.
#[test]	ഒരു ഫംഗ്‌ഷനെ ഒരു യൂണിറ്റ് ടെസ്റ്റായി അടയാളപ്പെടുത്തുന്നു. റസ്റ്റിൻ്റെ ബിൽറ്റ്-ഇൻ ടെസ്റ്റ് ചട്ടക്കൂട്, ടെസ്റ്റുകളായി പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഫംഗ്‌ഷനുകൾ തിരിച്ചറിയാൻ ഈ വ്യാഖ്യാനം ഉപയോഗിക്കുന്നു, ഉദാ., #[test] fn test_sms().
assert_eq!	രണ്ട് എക്സ്പ്രഷനുകൾ ഒരേ മൂല്യത്തിലേക്ക് മൂല്യനിർണ്ണയം നടത്തുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു. മൂല്യങ്ങൾ തുല്യമല്ലെങ്കിൽ, പരിശോധന പരാജയപ്പെടും. ഉദാഹരണത്തിന്, assert_eq!(ഫലം, ശരി("സന്ദേശം വിജയകരമായി അയച്ചു!")); ഫലം പ്രതീക്ഷിച്ച ഔട്ട്‌പുട്ടുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു.
Err	റസ്റ്റിലെ ഫല തരത്തിൻ്റെ ഒരു വകഭേദത്തെ പ്രതിനിധീകരിക്കുന്നു, ഒരു പിശക് അല്ലെങ്കിൽ പരാജയം സൂചിപ്പിക്കുന്നു. Err("അസാധുവായ ഇൻപുട്ട്") ൽ കാണുന്നത് പോലെ, ഒരു പരാജയ അവസ്ഥയെ അനുകരിക്കാൻ ഇത് ടെസ്റ്റ് കേസിൽ ഉപയോഗിക്കുന്നു.
Ok	ഫല തരത്തിൻ്റെ വിജയ വേരിയൻ്റിനെ പ്രതിനിധീകരിക്കുന്നു. Ok ("സന്ദേശം വിജയകരമായി അയച്ചു!") പോലുള്ള വിജയകരമായ ഫലം അനുകരിക്കാൻ ഇത് ടെസ്റ്റുകളിൽ ഉപയോഗിക്കുന്നു.
mod.rs	ഒരു ഡയറക്‌ടറിക്കായി ഒരു മൊഡ്യൂൾ പ്രഖ്യാപിക്കാൻ റസ്റ്റ് ഉപയോഗിക്കുന്ന ഫയൽ നാമം. ഒരേ ഫോൾഡറിനുള്ളിൽ സബ്‌മോഡ്യൂളുകൾ ഓർഗനൈസുചെയ്യാൻ ഇത് സഹായിക്കുന്നു, നിങ്ങൾ പാരൻ്റ് ഫോൾഡർ റഫറൻസ് ചെയ്യുമ്പോൾ അവ ആക്‌സസ് ചെയ്യാവുന്നതാക്കുന്നു, ഉദാ. മോഡ് കൺട്രോളറുകൾ; `controllers/mod.rs` ആക്സസ് ചെയ്യുന്നു.

സ്ക്രിപ്റ്റ് മനസ്സിലാക്കുന്നു: റസ്റ്റിൽ ചൈൽഡ് മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യുന്നു

മുമ്പത്തെ ഉദാഹരണത്തിൽ, എങ്ങനെ ആക്സസ് ചെയ്യാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു mod.rs ഉള്ളിലുള്ള ഫയൽ കൺട്രോളറുകൾ എന്നതിൽ സ്ഥിതിചെയ്യുന്ന ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്നുള്ള ഫോൾഡർ പരിശോധനകൾ ഡയറക്ടറി. സ്ക്രിപ്റ്റുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്നും ഓരോ ഭാഗവും പ്രധാനമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്നും നമുക്ക് ആഴത്തിൽ നോക്കാം. നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റിലെ മൊഡ്യൂളുകൾ പ്രഖ്യാപിക്കുകയാണ് ആദ്യ പടി, പ്രത്യേകിച്ച് മോഡ് പരാമർശിക്കാനുള്ള കീവേഡ് കൺട്രോളറുകൾ നിങ്ങളുടെ പ്രധാന കോഡ്ബേസിൽ നിന്നുള്ള മൊഡ്യൂൾ. ഇത് ഉള്ളടക്കത്തിൻ്റെ ഉള്ളടക്കം ഉണ്ടാക്കുന്നു കൺട്രോളറുകൾ ഫോൾഡർ, പോലുള്ളവ sms.rs, ടെസ്റ്റുകൾ ഉൾപ്പെടെ നിങ്ങളുടെ ബാക്കി കോഡിലേക്ക് ആക്‌സസ് ചെയ്യാനാകും. ഈ പ്രഖ്യാപനം കൂടാതെ, നിങ്ങളുടെ ടെസ്റ്റ് ഫയലുകൾക്ക് മൊഡ്യൂൾ കണ്ടെത്താനോ ഉപയോഗിക്കാനോ കഴിയില്ല. ഇത് ഒരു സ്ഥലത്തിന് വ്യക്തമായ വിലാസം നൽകുന്നത് പോലെയാണ്-അതില്ലാതെ, എവിടേക്ക് പോകണമെന്ന് സിസ്റ്റത്തിന് അറിയില്ല. 🛠️

ഈ സ്ക്രിപ്റ്റുകളുടെ മറ്റൊരു പ്രധാന വശം ഇതിൻ്റെ ഉപയോഗമാണ് #[cfg(ടെസ്റ്റ്)] ആട്രിബ്യൂട്ട്. ടെസ്റ്റിംഗ് സമയത്ത് മാത്രം കോഡിൻ്റെ പ്രത്യേക ഭാഗങ്ങൾ കംപൈൽ ചെയ്യാനും ഉൾപ്പെടുത്താനും ഈ ആട്രിബ്യൂട്ട് റസ്റ്റിനോട് പറയുന്നു. ഞങ്ങളുടെ കാര്യത്തിൽ, ടെസ്റ്റ് ഫംഗ്‌ഷനുകൾ ഒറ്റപ്പെടുത്താൻ ഇത് ഉപയോഗിക്കുന്നു, അതിനാൽ അവ ആപ്ലിക്കേഷൻ്റെ പ്രധാന യുക്തിയെ ബാധിക്കില്ല. ഈ സമീപനം ശുദ്ധമായ കോഡ് നിലനിർത്തുന്നതിനും ലോജിക് ടെസ്റ്റിംഗ് പ്രൊഡക്ഷൻ കോഡിൽ ഇടപെടുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നതിനും സഹായിക്കുന്നു. സിസ്റ്റത്തിൻ്റെ പ്രകടനമോ പ്രവർത്തനമോ പരിശോധിക്കാൻ നിങ്ങൾ തയ്യാറാകുമ്പോൾ മാത്രം പ്രവർത്തനക്ഷമമാകുന്ന ഒരു ടെസ്റ്റ് എൻവയോൺമെൻ്റ് ഉള്ളതുപോലെ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് ചിന്തിക്കാനാകും. ഇത് സിസ്റ്റം സ്ഥിരതയുള്ളതും പരീക്ഷണ പ്രവർത്തനങ്ങളാൽ ബാധിക്കപ്പെടാത്തതും ഉറപ്പാക്കുന്നു.

ദി ഉപയോഗിക്കുക നിർദ്ദിഷ്ട മൊഡ്യൂളുകളോ ഫംഗ്‌ഷനുകളോ വ്യാപ്തിയിലേക്ക് കൊണ്ടുവരുന്നതിൽ കീവേഡ് നിർണായക പങ്ക് വഹിക്കുന്നു. തിരക്കഥയിൽ, കൺട്രോളറുകൾ ഉപയോഗിക്കുക ::sms ആക്സസ് ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു sms.rs ഉള്ളിലെ മൊഡ്യൂൾ കൺട്രോളറുകൾ ടെസ്റ്റ് ഫയലിൽ നിന്നുള്ള ഫോൾഡർ. ഇത് എല്ലാ പൊതു പ്രവർത്തനങ്ങളും ഉള്ളിലാക്കുന്നു sms.rs ആക്സസ് ചെയ്യാവുന്നത് പോലെ അയയ്ക്കുക_sms ഫംഗ്‌ഷൻ, അത് പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ പരിശോധിക്കുന്നു. കോഡ് പുനരുപയോഗക്ഷമതയ്ക്കും മോഡുലാരിറ്റിക്കുമായി റസ്റ്റിൽ ഈ സമീപനം ഒരു സാധാരണ പാറ്റേണാണ്. നിങ്ങൾ ഒരു ലൈബ്രറിയിലാണെന്ന് സങ്കൽപ്പിക്കുക, ഒപ്പം ഉപയോഗിക്കുക നിങ്ങളുടെ ജോലി പൂർത്തിയാക്കാൻ ഷെൽഫിൽ നിന്ന് ആവശ്യമുള്ള ഒരു പ്രത്യേക പുസ്തകം ലഭിക്കുന്നത് പോലെയാണ് ഇത് - കോഡിൻ്റെ പ്രസക്ത ഭാഗങ്ങൾ മാത്രം നിങ്ങൾക്ക് ലഭ്യമാക്കുന്നതിലൂടെ സമയവും പരിശ്രമവും ലാഭിക്കുന്നു. 📚

ഒടുവിൽ, ദി #[ടെസ്റ്റ്] വ്യാഖ്യാനവും assert_eq! ഞങ്ങളുടെ യൂണിറ്റ് ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനും സാധൂകരിക്കുന്നതിനും മാക്രോ അത്യാവശ്യമാണ്. #[ടെസ്റ്റ്] ഒരു ഫംഗ്‌ഷനെ ഒരു ടെസ്റ്റ് കേസായി അടയാളപ്പെടുത്തുന്നു, അത് റസ്റ്റ് ടെസ്റ്റ് ഫ്രെയിംവർക്ക് സ്വയമേവ തിരിച്ചറിയുന്നു. സ്ക്രിപ്റ്റിൽ, ഞങ്ങൾ ഉപയോഗിച്ചു assert_eq! പ്രതീക്ഷിക്കുന്ന ഫലത്തെ യഥാർത്ഥ ഫലവുമായി താരതമ്യം ചെയ്യാൻ അയയ്ക്കുക_sms പ്രവർത്തനം. മൂല്യങ്ങൾ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ, പരിശോധന പരാജയപ്പെടും, ഇത് ഞങ്ങളുടെ കോഡിൻ്റെ പ്രവർത്തനത്തെക്കുറിച്ച് ഉടനടി ഫീഡ്‌ബാക്ക് നൽകും. ഞങ്ങളുടെ മൊഡ്യൂളുകൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഇത് ഞങ്ങളെ സഹായിക്കുന്നു, പ്രശ്നങ്ങൾ പെട്ടെന്ന് തിരിച്ചറിയാനും പരിഹരിക്കാനും ഞങ്ങളെ അനുവദിക്കുന്നു. വികസന വേളയിൽ ഒരു സുരക്ഷാ വലയം ഉള്ളതുപോലെയാണ് ഇത്—എന്തെങ്കിലും തെറ്റ് സംഭവിച്ചാൽ, പരിശോധന അത് പിടിക്കുകയും എവിടെയാണ് നോക്കേണ്ടതെന്ന് കൃത്യമായി ഞങ്ങളോട് പറയുകയും ചെയ്യും.

റസ്റ്റിലെ ഒരു ടെസ്റ്റിൽ നിന്ന് mod.rs ഫയൽ എങ്ങനെ ആക്സസ് ചെയ്യാം

തുരുമ്പ് - ബാക്കെൻഡ് വികസനം

mod controllers; // Declare the module from the controllers folder
use controllers::sms; // Use a specific module inside controllers
#[cfg(test)] // Mark the module for testing only
mod tests; // Declare the test module
#[cfg(test)] // Only compile the test code in test configuration
use crate::controllers::sms::send_sms; // Example of using the sms.rs file from controllers
#[test] // Declare a test function
fn test_sms_function() {
    assert_eq!(send_sms("12345", "Test message"), Ok("Message sent successfully!")); // Test the function
}

മൊഡ്യൂൾ ആക്സസിനായി mod.rs ഉപയോഗിച്ചുള്ള ആപേക്ഷിക പാതകളുമായുള്ള പരിഹാരം

റസ്റ്റ് - മൊഡ്യൂൾ ഓർഗനൈസേഷനോടുകൂടിയ ബാക്കെൻഡ് വികസനം

mod controllers { // Declare the controllers module
    pub mod sms; // Make the sms module accessible
    pub mod mod.rs; // Ensure mod.rs is public and accessible in tests
}
#[cfg(test)] // Only include this part in test builds
mod tests; // Test module declaration
use crate::controllers::sms::send_sms; // Access the sms function from controllers
#[test] // Mark this function as a test
fn test_sms() {
    let result = send_sms("12345", "Test message");
    assert_eq!(result, Ok("Message sent successfully!")); // Validate test results
}

കൺട്രോളറുകൾക്കുള്ള യൂണിറ്റ് ടെസ്റ്റ്, test.rs-ൽ നിന്നുള്ള മൊഡ്യൂൾ ആക്സസ്

തുരുമ്പ് - കൺട്രോളർ മൊഡ്യൂൾ പരിശോധിക്കുന്നു

mod controllers; // Declare the module path for controllers
use controllers::sms; // Use the sms module from controllers
#[cfg(test)] // This module is only included during testing
mod test; // Test module declaration
#[test] // The test annotation for unit tests
fn test_send_sms() {
    let result = sms::send_sms("12345", "Hello, World!");
    assert_eq!(result, Ok("Message sent successfully!")); // Check for expected result
}
#[test] // Another test for failure case
fn test_send_sms_failure() {
    let result = sms::send_sms("", "");
    assert_eq!(result, Err("Invalid input")); // Expect failure case
}

പരിശോധനയ്‌ക്കായി റസ്റ്റിലെ മൊഡ്യൂളുകൾ എങ്ങനെ ആക്‌സസ് ചെയ്യാം, സ്ട്രക്ചർ ചെയ്യാം

റസ്റ്റുമായി പ്രവർത്തിക്കുമ്പോൾ, മൊഡ്യൂളുകൾ എങ്ങനെയാണ് ഘടനാപരമായിരിക്കുന്നതെന്നും അവ എങ്ങനെ ആക്സസ് ചെയ്യാമെന്നും മനസ്സിലാക്കുന്നത് വികസന പ്രക്രിയയുടെ നിർണായക ഭാഗമാണ്. നിങ്ങൾക്ക് ഒരു ചൈൽഡ് മൊഡ്യൂൾ ആക്‌സസ് ചെയ്യാൻ താൽപ്പര്യപ്പെടുമ്പോൾ ഇത് വളരെ പ്രധാനമാണ് mod.rs പോലുള്ള ഒരു ഫോൾഡറിനുള്ളിൽ കൺട്രോളറുകൾ, ഒരു പ്രത്യേക ഫോൾഡറിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്ന് പരിശോധനകൾ. ചൈൽഡ് മൊഡ്യൂളുകൾ വിജയകരമായി ആക്‌സസ് ചെയ്യുന്നതിനും ഉപയോഗിക്കുന്നതിനുമുള്ള താക്കോൽ റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സിസ്റ്റം മനസ്സിലാക്കുക എന്നതാണ്, ഇത് വ്യക്തമായ മൊഡ്യൂൾ പ്രഖ്യാപനങ്ങളെയും ആപേക്ഷിക പാതകളുടെ ഉപയോഗത്തെയും ആശ്രയിച്ചിരിക്കുന്നു. റസ്റ്റ് ഒരു പ്രത്യേക ശ്രേണി ഉപയോഗിക്കുന്നു, അവിടെ ഓരോ ഫോൾഡറും a അടങ്ങിയിരിക്കാം mod.rs മൊഡ്യൂളിൻ്റെ വ്യാപ്തി നിർവചിക്കുന്നതിനുള്ള ഫയൽ. ഈ പാതകൾ എങ്ങനെ പരാമർശിക്കണമെന്ന് നിങ്ങൾ മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, നിങ്ങളുടെ കോഡ്ബേസിൻ്റെ വിവിധ ഭാഗങ്ങൾ കാര്യക്ഷമമായി പരീക്ഷിക്കാൻ നിങ്ങൾക്ക് കഴിയും.

ആക്സസ് ചെയ്യാൻ mod.rs നിങ്ങളുടെ ടെസ്റ്റ് കോഡിൽ ഫയൽ ചെയ്യുക, സോഴ്സ് കോഡിൽ മൊഡ്യൂൾ ശരിയായി പ്രഖ്യാപിച്ചിട്ടുണ്ടെന്ന് നിങ്ങൾ ആദ്യം ഉറപ്പാക്കേണ്ടതുണ്ട്. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ദി mod controllers പ്രധാന പ്രോജക്റ്റ് ഡയറക്‌ടറിയിലെ പ്രസ്താവന, ഫോൾഡർ റഫറൻസ് ചെയ്യാൻ ഞങ്ങളെ സഹായിക്കുന്നു mod.rs ഫയൽ സ്ഥിതിചെയ്യുന്നു. ടെസ്റ്റ് ഫയലിനുള്ളിൽ, നിങ്ങൾക്ക് പിന്നീട് ഉപയോഗിക്കാം use crate::controllers::sms പോലുള്ള നിർദ്ദിഷ്ട ഫയലുകൾ ആക്സസ് ചെയ്യാൻ sms.rs അതിൻ്റെ പ്രവർത്തനങ്ങളും. ഈ മോഡുലാർ ഘടന മെച്ചപ്പെട്ട കോഡ് ഓർഗനൈസേഷനും പുനരുപയോഗക്ഷമതയും അനുവദിക്കുന്നു, കാരണം നിങ്ങൾ ടെസ്റ്റിംഗിന് ആവശ്യമായ നിർദ്ദിഷ്ട ഫംഗ്ഷനുകളോ തരങ്ങളോ മാത്രമേ ഇറക്കുമതി ചെയ്യാവൂ.

റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സംവിധാനം ദൃശ്യപരതയെക്കുറിച്ച് വളരെ കർശനമാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഉദാഹരണത്തിന്, നിങ്ങൾ അവയുടെ യഥാർത്ഥ മൊഡ്യൂളിന് പുറത്ത് ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ഏതെങ്കിലും ഫംഗ്ഷനുകളോ തരങ്ങളോ ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കണം pub അവ പരസ്യമാക്കുന്നതിനുള്ള കീവേഡ്. ഈ സാഹചര്യത്തിൽ, ദി sms::send_sms അകത്തുള്ള പ്രവർത്തനം sms.rs ടെസ്റ്റ് ഫയലിൽ ആക്‌സസ് ചെയ്യുന്നതിന് ഫയൽ പൊതുവായിരിക്കണം. കോഡ്ബേസിൻ്റെ മറ്റ് ഭാഗങ്ങളിലേക്ക് ആവശ്യമായ ഘടകങ്ങൾ മാത്രം തുറന്നുകാട്ടുന്നത് ഉറപ്പാക്കിക്കൊണ്ട് ഇത് സിസ്റ്റത്തെ സുരക്ഷിതവും പ്രവർത്തനക്ഷമവുമാക്കുന്നു. നിങ്ങളുടെ മൊഡ്യൂളുകളും ടെസ്റ്റുകളും ഫലപ്രദമായി സംഘടിപ്പിക്കുന്നതിലൂടെ, നിങ്ങളുടെ റസ്റ്റ് ആപ്ലിക്കേഷൻ അളക്കാവുന്നതും പരിപാലിക്കാവുന്നതുമാണെന്ന് ഉറപ്പാക്കാൻ കഴിയും. ⚙️

റസ്റ്റിൽ ചൈൽഡ് മൊഡ്യൂളുകൾ ആക്‌സസ് ചെയ്യുന്നതിനെ കുറിച്ച് പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്ന് ഉപഡയറക്‌ടറിയിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു മൊഡ്യൂൾ എങ്ങനെ ആക്‌സസ് ചെയ്യാം?
നിങ്ങൾക്ക് ഉപയോഗിക്കാം mod മൊഡ്യൂൾ പ്രഖ്യാപിക്കുന്നതിനുള്ള കീവേഡ്, തുടർന്ന് use ആ മൊഡ്യൂളിൽ നിന്ന് നിർദ്ദിഷ്ട ഫംഗ്ഷനുകളോ തരങ്ങളോ കൊണ്ടുവരുന്നതിനുള്ള കീവേഡ്. ഉദാഹരണത്തിന്, use crate::controllers::sms ഉണ്ടാക്കുന്നു sms.rs മൊഡ്യൂൾ ആക്സസ് ചെയ്യാവുന്നതാണ്.
എന്താണ് ചെയ്യുന്നത് #[cfg(test)] റസ്റ്റ് എന്നതിൽ അർത്ഥമാക്കുന്നത്?
കംപൈൽ ചെയ്യേണ്ടതും ടെസ്റ്റിംഗ് സമയത്ത് മാത്രം പ്രവർത്തിപ്പിക്കേണ്ടതുമായ കോഡ് ഇത് അടയാളപ്പെടുത്തുന്നു. ടെസ്റ്റ്-നിർദ്ദിഷ്ട ലോജിക് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ പ്രൊഡക്ഷൻ ബിൽഡിനെ ബാധിക്കില്ലെന്ന് ഉറപ്പാക്കാൻ ഇത് സഹായിക്കുന്നു.
റസ്റ്റിലെ മറ്റൊരു മൊഡ്യൂളിൽ എങ്ങനെ ഒരു ഫംഗ്‌ഷൻ ആക്‌സസ് ചെയ്യാം?
നിങ്ങൾ ഫംഗ്‌ഷൻ ഇതായി പ്രഖ്യാപിക്കേണ്ടതുണ്ട് pub, ഇത് പൊതുവായതും സ്വന്തം മൊഡ്യൂളിന് പുറത്ത് ആക്സസ് ചെയ്യാവുന്നതുമാക്കുന്നു. ഉദാഹരണത്തിന്, pub fn send_sms() അനുവദിക്കും അയയ്ക്കുക_sms ടെസ്റ്റ് ഫയലുകളിൽ ഉപയോഗിക്കാൻ.
എന്തിനാണ് mod.rs റസ്റ്റിൽ ഉപയോഗിച്ചത്?
mod.rs ഒരു മൊഡ്യൂൾ ഫോൾഡറിൻ്റെ പ്രധാന എൻട്രി പോയിൻ്റായി പ്രവർത്തിക്കുന്നു. വലിയ പ്രോജക്റ്റുകൾക്ക് വ്യക്തമായ ഘടന നൽകിക്കൊണ്ട് സബ്‌മോഡ്യൂളുകളായി ഫയലുകൾ ഓർഗനൈസുചെയ്യാൻ ഇത് റസ്റ്റിനെ അനുവദിക്കുന്നു.
റസ്റ്റിൽ ഒരു പ്രത്യേക ടെസ്റ്റ് ഫംഗ്‌ഷൻ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം?
ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ അടയാളപ്പെടുത്താൻ കഴിയും #[test] ഇത് ഒരു പരീക്ഷണ പ്രവർത്തനമാണെന്ന് സൂചിപ്പിക്കാൻ. ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ, ലളിതമായി നടപ്പിലാക്കുക cargo test നിങ്ങളുടെ ടെർമിനലിൽ.
എന്താണ് ചെയ്യുന്നത് assert_eq! റസ്റ്റ് ടെസ്റ്റുകളിൽ ചെയ്യണോ?
assert_eq! ഒരു ടെസ്റ്റിലെ രണ്ട് മൂല്യങ്ങൾ താരതമ്യം ചെയ്യുന്നു. മൂല്യങ്ങൾ തുല്യമല്ലെങ്കിൽ, പരിശോധന പരാജയപ്പെടും. യൂണിറ്റ് ടെസ്റ്റുകളിൽ പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ടുമായി യഥാർത്ഥ ഔട്ട്പുട്ട് പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഈ മാക്രോ സാധാരണയായി ഉപയോഗിക്കുന്നു.
എന്നതിൽ നിന്ന് എനിക്ക് മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യാൻ കഴിയുമോ? tests പ്രധാന സോഴ്സ് കോഡിലെ ഫോൾഡർ?
ഇല്ല, ദി tests പ്രധാന കോഡിൽ നിന്ന് ഡിഫോൾട്ടായി ഫോൾഡർ വേർതിരിച്ചിരിക്കുന്നു. ഉപയോഗിച്ച് നിങ്ങളുടെ ടെസ്റ്റുകളിലെ പ്രധാന മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും mod ഒപ്പം use ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ കീവേഡുകൾ.
വലിയ റസ്റ്റ് പ്രോജക്റ്റുകൾക്കായുള്ള എൻ്റെ കോഡ് എങ്ങനെ ക്രമീകരിക്കാം?
വലിയ പ്രോജക്റ്റുകൾക്കായി, നിങ്ങളുടെ കോഡ് സബ്മോഡ്യൂളുകളായി ക്രമീകരിക്കുക mod.rs ഓരോ ഫോൾഡറിലെയും ഫയലുകൾ. എന്ന് അടയാളപ്പെടുത്തിയ പൊതു പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുക pub ക്രോസ്-മൊഡ്യൂൾ ആക്സസിനായി.
റസ്റ്റിൽ ഒരു ഫംഗ്‌ഷൻ പബ്ലിക് ആക്കാൻ ഞാൻ മറന്നാൽ എന്ത് സംഭവിക്കും?
ഒരു ഫംഗ്‌ഷൻ ആയി പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിൽ pub, അത് അതിൻ്റെ മൊഡ്യൂളിന് സ്വകാര്യമായിരിക്കും. ടെസ്റ്റ് ഫയലുകൾ ഉൾപ്പെടെയുള്ള മറ്റ് മൊഡ്യൂളുകൾക്ക്, വ്യക്തമായി പരസ്യമാക്കിയില്ലെങ്കിൽ, അത് ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല.
റസ്റ്റിൽ ബാഹ്യ ഡിപൻഡൻസികളുള്ള മൊഡ്യൂളുകൾ എങ്ങനെ പരിശോധിക്കാം?
ബാഹ്യ ഡിപൻഡൻസികളുള്ള മൊഡ്യൂളുകൾ പരിശോധിക്കാൻ മോക്ക് ലൈബ്രറികൾ അല്ലെങ്കിൽ ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിക്കുക. ഇത് നിങ്ങളുടെ ടെസ്റ്റുകൾ ഒറ്റപ്പെട്ടതാണെന്നും ബാഹ്യ സിസ്റ്റങ്ങളെ ആശ്രയിക്കുന്നില്ലെന്നും ഉറപ്പാക്കുന്നു.

ടെസ്റ്റുകളിൽ നിന്ന് റസ്റ്റ് മൊഡ്യൂളുകൾ ആക്സസ് ചെയ്യുന്നു: ഒരു റീക്യാപ്പ്

എങ്ങനെ ആക്സസ് ചെയ്യാമെന്ന് മനസിലാക്കുന്നു mod.rs ഫയലിനുള്ളിൽ കൺട്രോളറുകൾ ഒരു ടെസ്റ്റ് ഫയലിൽ നിന്നുള്ള ഫോൾഡർ നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റുകൾ ഫലപ്രദമായി രൂപപ്പെടുത്തുന്നതിന് നിർണായകമാണ്. ഉപയോഗിച്ചുകൊണ്ട് use ഒപ്പം mod, നിങ്ങൾക്ക് നിർദ്ദിഷ്ട മൊഡ്യൂളുകൾ വ്യാപ്തിയിലേക്ക് കൊണ്ടുവരാൻ കഴിയും, ഇത് കാര്യക്ഷമവും ഒറ്റപ്പെട്ടതുമായ പരിശോധനയ്ക്ക് അനുവദിക്കുന്നു. ഈ മോഡുലാർ സമീപനം കോഡ് റീഡബിലിറ്റി വർദ്ധിപ്പിക്കുക മാത്രമല്ല നിങ്ങളുടെ പ്രോജക്റ്റിലുടനീളം പുനരുപയോഗം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. ⚙️

ഉപസംഹാരമായി, റസ്റ്റ് മൊഡ്യൂളുകളുടെ ഓർഗനൈസേഷൻ ഉപയോഗിക്കുന്നു mod.rs ശുദ്ധമായ കോഡ് വേർതിരിവും ആക്‌സസ് എളുപ്പവും ഉറപ്പാക്കുന്നു. മൊഡ്യൂൾ ഡിക്ലറേഷനും ദൃശ്യപരതയ്ക്കുമായി റസ്റ്റിൻ്റെ കൺവെൻഷനുകൾ പിന്തുടരുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് അളക്കാവുന്നതും പരിശോധിക്കാവുന്നതുമായ ഒരു കോഡ്ബേസ് നിലനിർത്താൻ കഴിയും. നന്നായി ചിട്ടപ്പെടുത്തിയ ടെസ്റ്റുകൾ ഉപയോഗിച്ച്, നിങ്ങളുടെ റസ്റ്റ് പ്രോജക്റ്റ് ദീർഘകാലത്തേക്ക് സുസ്ഥിരവും പരിപാലിക്കാവുന്നതുമായി നിലനിൽക്കും. 📦

ഉറവിടങ്ങളും റഫറൻസുകളും

റസ്റ്റിൻ്റെ മൊഡ്യൂൾ സിസ്റ്റം മനസിലാക്കാൻ, ഈ ലേഖനം റസ്റ്റിലെ മൊഡ്യൂളുകൾ ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാം എന്നതിൻ്റെ വിശദമായ വിശദീകരണം നൽകുന്നു. റസ്റ്റ് മൊഡ്യൂൾ സിസ്റ്റത്തെക്കുറിച്ച് നിങ്ങൾക്ക് ഔദ്യോഗികത്തിൽ കൂടുതൽ വായിക്കാം റസ്റ്റ് ഡോക്യുമെൻ്റേഷൻ .
റസ്റ്റിലെ പരിശോധനയെക്കുറിച്ചും നിങ്ങളുടെ ടെസ്റ്റുകൾ എങ്ങനെ രൂപപ്പെടുത്താമെന്നതിനെക്കുറിച്ചും പഠിക്കുന്നതിനുള്ള മറ്റൊരു ഉപയോഗപ്രദമായ ഉറവിടം ഔദ്യോഗിക റസ്റ്റ് ബുക്കിൽ ലഭ്യമാണ്. ഇവിടെ കൂടുതൽ കണ്ടെത്തുക: റസ്റ്റ് ടെസ്റ്റിംഗ് .

റസ്റ്റ് ചൈൽഡ് മൊഡ്യൂളിൽ mod.rs ആക്‌സസ് ചെയ്യാൻ ഒരു ടെസ്റ്റ് ഫയൽ എങ്ങനെ ഉപയോഗിക്കാം