ஜாவாஸ்கிரிப்ட் வரிசை குளோனிங் மற்றும் பிறழ்வை புரிந்துகொள்வது
க்ளோனிங் வரிசைகள் என்பது ஜாவாஸ்கிரிப்டில் உள்ள ஒரு பிரபலமான செயலாகும், இது அசல் தரவை பாதிக்காமல் அசல் வரிசையின் நகலில் மாற்றங்களைச் செய்ய உங்களை அனுமதிக்கிறது. இருப்பினும், ஜாவாஸ்கிரிப்ட் பொருள்கள் செயல்படும் விதம் காரணமாக நேரடியான குளோனிங் நுட்பங்கள் உத்தேசித்தபடி செயல்படாமல் போகலாம். நகலெடுக்கப்பட்ட வரிசையில் செய்யப்பட்ட மாற்றங்கள் அசல் வரிசையையும் பாதிக்கும் காட்சிகளை டெவலப்பர்கள் அடிக்கடி எதிர்கொள்கின்றனர்.
இந்த சிக்கல் பெரும்பாலும் ஒரு வரிசையில் உருப்படிகள் இருக்கும் போது ஏற்படுகிறது, இது மிகவும் சிக்கலான தரவு கட்டமைப்புகளில் அடிக்கடி நிகழ்கிறது. எளிய பரவல் தொடரியல் பொருள்களுக்கான சுட்டிகளை மட்டுமே பிரதிபலிக்கிறது, வரிசையின் உண்மையான ஆழமான நகல் அல்ல, இது அசல் மற்றும் குளோன் செய்யப்பட்ட வரிசை இரண்டிற்கும் தேவையற்ற மாற்றங்களை விளைவிக்கிறது.
இந்த சிக்கலை விளக்குவதற்கு, இந்த கட்டுரையில் ஒரு மிக எளிய உதாரணம் மூலம் செல்வோம். அணிகளின் பெயர்களைக் கொண்ட வரிசையை குளோன் செய்ய ஸ்ப்ரெட் ஆபரேட்டரைப் பயன்படுத்துவோம். அடுத்து, நகலெடுக்கப்பட்ட வரிசையில் மாற்றங்களைச் செய்ய முயற்சிப்போம், அசல் அணிவரிசையும் மாற்றப்பட்டுள்ளதா என்பதைப் பார்ப்போம்.
இதற்குப் பின்னால் உள்ள பொறிமுறையைப் புரிந்துகொள்வதன் மூலமும், சாத்தியமான தீர்வுகளை ஆராய்வதன் மூலமும், ஜாவாஸ்கிரிப்ட் வரிசை குளோனிங் முறைகள் பற்றிய நமது அறிவை மேம்படுத்துவோம். பெரிய பயன்பாடுகளில், மாற்றக்கூடிய தரவுகளுடன் பணிபுரியும் போது பிழைகளைத் தடுக்க இது அவசியம்.
| கட்டளை | பயன்பாட்டின் உதாரணம் |
|---|---|
| [...array] | ஸ்ப்ரெட் ஆபரேட்டர், இது தொடரியல் ஆகும், இது ஒரு வரிசையின் மேலோட்டமான நகலை உருவாக்க பயன்படுகிறது. இந்தக் கட்டுரையின் பின்னணியில் அசல் வரிசையை குளோன் செய்ய இது பயன்படுத்தப்பட்டது, ஆனால் அது ஒரு மேலோட்டமான நகலை மட்டுமே உருவாக்குவதால், வரிசையின் உள்ளே உள்ள பொருள்கள் தொடர்ந்து அதே குறிப்பை சுட்டிக்காட்டுகின்றன. |
| JSON.parse(JSON.stringify(array)) | ஒரு வரிசையின் ஆழமான குளோனிங் இந்த கலவையுடன் அடையப்படுகிறது. வரிசையை JSON சரமாக மாற்றி, அதை மீண்டும் ஒரு பொருளாகப் பாகுபடுத்துவதன் மூலம், அசல் பொருளுடன் பொருள் குறிப்புகளைப் பகிர்ந்து கொள்ளாத வரிசையின் புதிய நகலை இது உருவாக்குகிறது. |
| _.cloneDeep(array) | இந்த லோடாஷ் நூலக முறையானது குறிப்பாக ஆழமான குளோனிங் அணிகள் அல்லது பொருள்களுக்காக உருவாக்கப்பட்டது. உள்ளமைக்கப்பட்ட பொருட்களும் நகலெடுக்கப்படும் என்று உத்தரவாதம் அளிப்பதன் மூலம், பகிரப்பட்ட குறிப்புகள் தவிர்க்கப்படுகின்றன. |
| for(n=0; n<a.length; n++) | இந்த கிளாசிக் ஃபார் லூப் ஆனது, ஒரு வரிசையின் மீது இயங்க n எனப்படும் எதிர் மாறியைப் பயன்படுத்துகிறது. ஒவ்வொரு அணியின் பெயரும் அணிவரிசையிலிருந்து அச்சிடப்பட்டு, மாற்றத்திற்கு முன்னும் பின்னும் விளைவுகளைக் காண்பிக்கும். |
| require('lodash') | ஒரு Node.js சூழலில், இந்த கட்டளை Lodash நூலகத்தை இறக்குமதி செய்கிறது. ஆழமான குளோனிங் வரிசைகளுக்கு அவசியமான _.cloneDeep உட்பட, அதன் பயன்பாட்டு செயல்பாடுகளை அணுகக்கூடியதாக ஆக்குகிறது. |
| console.log() | இந்தச் செயல்பாடு கன்சோலுக்கு தரவை வெளியிடுகிறது, இது மதிப்புகளைக் காட்ட அல்லது சரிசெய்தலுக்குப் பயன்படும். ஆரம்ப மற்றும் மாற்றியமைக்கப்பட்ட குளோன் வரிசைகளின் விளைவுகளை ஒப்பிட இந்த நிகழ்வில் இது பயன்படுத்தப்பட்டது. |
| function change_team(d, club) | வரிசை d மற்றும் அணியின் பெயர் கிளப் ஆகியவை இந்த முறை ஏற்றுக்கொள்ளும் இரண்டு வாதங்கள். அதன் பிறகு, அது இரண்டாவது அணியின் புதிய பெயருடன் வரிசையை புதுப்பித்து அதைத் திருப்பித் தருகிறது. ஆழமற்ற நகலெடுப்பு எவ்வாறு செயல்படுகிறது மற்றும் ஒரு வரிசையின் மாற்றங்கள் மற்றொன்றை எவ்வாறு பாதிக்கின்றன என்பதை இது விளக்குகிறது. |
| return | மாற்றப்பட்ட வரிசையானது change_team செயல்பாட்டின் மூலம் திரும்ப அறிக்கையைப் பயன்படுத்தி திரும்பும். செயல்பாட்டின் உள்ளே ஒரு பிறழ்வைத் தொடர்ந்து மாற்றியமைக்கப்பட்ட கட்டமைப்பை திரும்பப் பெறுவது இதைப் பொறுத்தது. |
ஜாவாஸ்கிரிப்ட் வரிசை குளோனிங் மற்றும் பிறழ்வு சிக்கல்களைப் புரிந்துகொள்வது
இந்த ஜாவாஸ்கிரிப்ட் உதாரணம், வரிசை குளோனிங் எவ்வாறு அசல் வரிசையில் எதிர்பாராத மாற்றங்களை ஏற்படுத்தும் என்ற சிக்கலை விளக்குகிறது. ஸ்ப்ரெட் ஆபரேட்டருடன் ஒரு வரிசையை குளோனிங் செய்யும் போது மேலோட்டமான பிரதிகள் உருவாக்கப்படுகின்றன. வரிசை நகலெடுக்கப்பட்டாலும், அதில் உள்ள அனைத்து பொருட்களும் ஒரே நினைவக இருப்பிடங்களைக் குறிப்பிடுவதை இது குறிக்கிறது. அணிப் பெயர்களைப் பொறுத்தவரை, இரண்டு அணிவரிசைகளும் வரிசையாக இருந்தாலும் ஒரே மாதிரியான உருப்படிகளை சுட்டிக்காட்டுகின்றன வரிசையின் குளோன் ஆகும் . இதன் விளைவாக, ஒரு அணிவரிசையில் அணி பெயரில் செய்யப்படும் மாற்றங்கள் மற்றொன்றையும் பாதிக்கும்.
ஜாவாஸ்கிரிப்ட் விஷயங்களை மதிப்பை விட குறிப்பு மூலம் கையாளுவதால், இந்த நடத்தை நடைபெறுகிறது. கட்டளையுடன் ஒரு புதிய வரிசை அமைப்பு உருவாக்கப்படும் போது அணிவரிசையில் உள்ள பொருள்கள் நகல் செய்யப்படாது . இவ்வாறு, செயல்பாட்டின் போது ஒரே பொருள் இரண்டு அணிகளிலும் மாற்றப்படுகிறது அணியின் பெயரை மாற்ற அழைக்கப்பட்டது. ஒரே ஒரு வரிசை மட்டுமே மாற்றப்பட வேண்டும் என்றாலும், இரண்டு அணிகளும் மாற்றத்தைக் காட்டுகின்றன என்பதை இது விளக்குகிறது. பொருள்களின் JavaScript வரிசைகளைப் பயன்படுத்தும் போது, இது அடிக்கடி ஏற்படும் பிரச்சனை.
இந்த சிக்கலுக்கான இரண்டு தீர்வுகளை நாங்கள் விளக்கினோம்: ஆழமான குளோனிங் மற்றும் நூலக பயன்பாடு. தி செயல்பாடு வரிசையை ஒரு சரமாக மாற்றுகிறது மற்றும் ஆழமான நகலை வழங்க மீண்டும். இந்த முறை பயன்படுத்த எளிதானது மற்றும் அசல் வரிசைக்கு முற்றிலும் தொடர்பில்லாத புதிய உருப்படிகளை உருவாக்குவதற்கு திறமையானது. நகலெடுக்கப்பட்ட அணிவரிசையில் ஏதேனும் மாற்றங்கள் செய்யப்பட்டால் அசல் அணிவரிசை மாறாமல் இருக்கும். இருப்பினும், இந்த முறைக்கு குறைபாடுகள் உள்ளன, குறிப்பாக செயல்பாடுகள் அல்லது வரையறுக்கப்படாத மதிப்புகள் போன்ற மிகவும் சிக்கலான தரவு கட்டமைப்புகளைக் கையாளும் போது.
மிகவும் நம்பகமான வழி லோடாஷைப் பயன்படுத்துகிறது நுட்பம். நன்கு அறியப்பட்ட ஜாவாஸ்கிரிப்ட் பயன்பாட்டு நூலகமான லோடாஷ் வழங்கிய பல நுட்பங்களில் ஒன்று பொருள்கள் மற்றும் வரிசைகளின் ஆழமான குளோனிங் ஆகும். இந்த நுட்பம் உள்ளமைக்கப்பட்ட பொருள்கள் சரியாக குளோன் செய்யப்படுவதையும், திறமையானதாகவும் நம்பகமானதாகவும் இருப்பதை உறுதி செய்கிறது. இது மிகவும் சிக்கலான தரவு கட்டமைப்புகளை எளிதாகக் கையாளுகிறது, JSON வரிசைப்படுத்தலுடன் தொடர்புடைய சிக்கல்களைத் தவிர்க்கிறது. இந்த இரண்டு ஆழமான குளோனிங் நுட்பங்களும் தரவு நிலைத்தன்மை முக்கியமான பெரிய திட்டங்களில் மிகவும் உதவியாக இருக்கும், ஏனெனில் அவை வரிசை அல்லது பொருள் கையாளுதலைச் சார்ந்திருக்கும் பயன்பாடுகளில் எதிர்பாராத பக்க விளைவுகளைத் தவிர்க்கின்றன.
ஜாவாஸ்கிரிப்டில் அணிவரிசைகளை குளோனிங் மற்றும் மாற்றுதல்
வரிசை எடிட்டிங் மற்றும் குளோனிங் முறைகளில் கவனம் செலுத்தும் ஜாவாஸ்கிரிப்ட் முன்-இறுதி தீர்வை இந்த எடுத்துக்காட்டு காட்டுகிறது.
a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function change_team(d, club) {d[1].team = club;return d;}b = [...a]; // Shallow copy of the arraychange_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
பிறழ்வைத் தடுக்க ஜாவாஸ்கிரிப்டில் ஆழமான குளோனிங் வரிசைகள்
ஆழமான நகலைப் பயன்படுத்தி அசலைப் பாதிக்காமல் குளோன் செய்யப்பட்ட அணிவரிசையில் எவ்வாறு மாற்றங்களைச் செய்வது என்பதை இந்த எடுத்துக்காட்டு காட்டுகிறது.
a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function deepCloneArray(arr) {return JSON.parse(JSON.stringify(arr)); // Deep copy}function change_team(d, club) {d[1].team = club;return d;}b = deepCloneArray(a);change_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
ஜாவாஸ்கிரிப்டில் வரிசைகளை குளோனிங் செய்ய Lodash ஐப் பயன்படுத்துதல்
குறிப்பு அடிப்படையிலான மாற்றங்களைத் தடுக்க, இந்த உதாரணம் நன்கு அறியப்பட்ட பயன்பாட்டுத் தொகுப்பான லோடாஷைப் பயன்படுத்தி டீப் க்ளோன் வரிசைகளை உருவாக்குகிறது.
const _ = require('lodash');a = [];a[0] = {};a[0].team = "Arsenal";a[1] = {};a[1].team = "Chelsea";a[2] = {};a[2].team = "West Ham";function change_team(d, club) {d[1].team = club;return d;}b = _.cloneDeep(a);change_team(b, "Spurs");for(n = 0; n < a.length; n++) {console.log(n + "] " + a[n].team); // Arsenal, Chelsea, West Ham}for(n = 0; n < b.length; n++) {console.log(n + "] " + b[n].team); // Arsenal, Spurs, West Ham}
செயல்திறன் மற்றும் பாதுகாப்பிற்காக ஜாவாஸ்கிரிப்டில் வரிசை குளோனிங்கை மேம்படுத்துதல்
நினைவகம் மற்றும் செயல்திறனை திறம்பட நிர்வகிக்கும் திறன் ஜாவாஸ்கிரிப்ட் அணி குளோனிங்கின் ஒரு முக்கிய அங்கமாகும், குறிப்பாக பெரிய அளவிலான பயன்பாடுகளில். பெரிய வரிசைகளுடன் பணிபுரியும் போது நீங்கள் பயன்படுத்தும் குளோனிங் நுட்பங்கள் நினைவக பயன்பாடு மற்றும் வேகத்தில் குறிப்பிடத்தக்க தாக்கத்தை ஏற்படுத்தும். சிக்கலான, உள்ளமை கட்டமைப்புகளுடன் பணிபுரியும் போது, ஆழமற்ற நகலெடுக்கும் முறை, இது பரவல் ஆபரேட்டரைப் பயன்படுத்துகிறது , அவ்வளவு பயனுள்ளதாக இல்லை மற்றும் சிறிய அணிகளுக்கு மெதுவாக இருக்கும். போன்ற ஆழமான நகலெடுக்கும் நுட்பங்கள் அல்லது Lodash போன்ற நூலகங்களைப் பயன்படுத்துதல் அதிக நினைவக நுகர்வு காரணமாக பெரிய தரவுத் தொகுப்புகளுக்கு செயல்படுத்தல் தாமதமாகலாம்.
செயல்திறனை மிகவும் திறமையாக நிர்வகிப்பதற்கு, ஆழமான மற்றும் ஆழமற்ற பிரதிகள் தேவைப்படும் சூழ்நிலைகளை நீங்கள் மதிப்பீடு செய்ய வேண்டும். எடுத்துக்காட்டாக, உங்கள் பயன்பாடு புதுப்பிக்கும் ஒரே பழமையான தரவு எண்கள் அல்லது சரங்களின் அடிப்படை வரிசைகளாக இருந்தால், மேலோட்டமான நகல் செய்யும். இருப்பினும், குறிப்பு அடிப்படையிலான பக்க விளைவுகளைத் தடுக்க, பொருள்கள் அல்லது வரிசைகளின் வரிசைகளைக் கொண்ட அணிகளுக்கு ஆழமான குளோன் அவசியம். டீப் குளோனிங் நுட்பங்கள் செயல்திறனைக் குறைத்தாலும் தரவு ஒருமைப்பாட்டிற்கு உத்தரவாதம் அளிக்கின்றன, குறிப்பாக ரியாக்ட் ஸ்டேட்ஸ் போன்ற நிகழ்நேர பயன்பாடுகளில் சர்வர் பக்க லாஜிக் அல்லது படிநிலை தரவு மாதிரிகளில் பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது.
மேலும், பாதுகாப்பை மேம்படுத்துவதற்கான திறவுகோல் எதிர்பாராத பிறழ்வுகளைத் தவிர்ப்பதாகும். மேலோட்டமான பிரதிகள் தவறாகப் பயன்படுத்தப்படும்போது, அவை பொருள் குறிப்புகள் மூலம் திட்டமிடப்படாத மாற்றங்களை அனுமதிக்கலாம், இது முக்கியமான தரவை வெளிப்படுத்தலாம். குளோன் செய்யப்பட்ட வரிசைகள் அல்லது பொருள்களின் மாற்றங்கள் அசல் தரவுத்தொகுப்புகளில் கசியாமல் இருப்பதை ஆழமாக நகலெடுப்பதை உறுதிசெய்கிறது, தரவு ஒருமைப்பாட்டைப் பாதுகாக்கிறது மற்றும் நிதி அல்லது மருத்துவ மென்பொருள் போன்ற முக்கியமான அமைப்புகளில் முக்கியமான பிழைகளைத் தவிர்க்கிறது. செயல்திறன் காரணிகளைக் கருத்தில் கொள்வது மற்றும் பொருள் குறிப்புகளை சரியாகக் கையாளுதல் ஆகியவை தற்கால வலை வளர்ச்சிக்கு வரிசை குளோனிங்கை இன்றியமையாத பாடமாக்குகின்றன.
- ஆழமற்ற நகலிலிருந்து ஆழமான பிரதியை வேறுபடுத்துவது எது?
- ஒரு ஆழமற்ற நகல், போன்ற , ஒரு அணிவரிசையின் உயர்மட்ட கட்டமைப்பை நகலெடுக்கிறது; அசல் மற்றும் குளோன் செய்யப்பட்ட வரிசை பொருள் குறிப்புகளை தொடர்ந்து பகிர்ந்து கொள்கிறது. பயன்படுத்துவதன் மூலம் அல்லது , ஒரு ஆழமான நகல் உள்ளமைக்கப்பட்ட உருப்படிகள் உட்பட ஒவ்வொரு நிலையையும் நகலெடுக்கிறது.
- க்ளோன் செய்யப்பட்ட வரிசையைத் திருத்துவது ஏன் அசல் வரிசையை மாற்றக்கூடும்?
- மேலோட்டமான நகலைப் பயன்படுத்தி நீங்கள் குளோன் செய்யும் வரிசையில் உள்ள பொருள்கள் அசல் வரிசையின் அதே நினைவக முகவரிகளுடன் இன்னும் தொடர்புடையவை. இதன் விளைவாக, குளோன் செய்யப்பட்ட அணிவரிசையின் பொருளில் உள்ள பண்புக்கூறை மாற்றுவதும் அசலை மாற்றியமைக்கிறது.
- ஜாவாஸ்கிரிப்ட்டில் ஆழமான நகலை நான் எப்போது பயன்படுத்த வேண்டும்?
- சிக்கலான கட்டமைப்புகள் அல்லது உள்ளமை பொருள்களைக் கொண்ட அணிகள் அல்லது பொருள்களுடன் பணிபுரியும் போது, குறிப்பு அடிப்படையிலான மாற்றங்களைத் தடுக்க ஆழமான நகலெடுக்கும் முறைகளைப் பயன்படுத்த வேண்டும்.
- ஜாவாஸ்கிரிப்டில் வரிசை குளோனிங்கிற்கு Lodash எப்படி உதவ முடியும்?
- தி லோடாஷ் வழங்கும் முறை, ஆழமான குளோனிங் வரிசைகள் மற்றும் பொருள்களை நோக்கமாகக் கொண்டது, அசல் தரவுக்கான பிரதிகள் எந்த குறிப்புகளையும் பகிர்ந்து கொள்ளாது என்று உத்தரவாதம் அளிக்கிறது.
- ஆழமான குளோனிங் வரிசைகளின் செயல்திறன் கருத்தில் என்ன?
- ஆழமான குளோனிங் நினைவகம்-தீவிர மற்றும் மெதுவாக இருக்கலாம், குறிப்பாக பெரிய தரவுத்தொகுப்புகள் அல்லது சிக்கலான உள்ளமைக்கப்பட்ட கட்டமைப்புகளைக் கையாளும் போது. ஆழமான பிரதிகள் முற்றிலும் அவசியமான போது மட்டுமே பயன்படுத்தப்பட வேண்டும்; இல்லையெனில், உங்கள் பயன்பாட்டின் குறிப்பிட்ட தேவைகளின் வெளிச்சத்தில் மற்ற விருப்பங்களைக் கருத்தில் கொள்ள வேண்டும்.
ஜாவாஸ்கிரிப்ட் வரிசை குளோனிங்கிற்கு ஆழமற்ற மற்றும் ஆழமான நகலெடுப்பு பற்றிய திடமான புரிதல் தேவைப்படுகிறது. ஸ்ப்ரெட் ஆபரேட்டருடன் ஆழமற்ற நகல்களைப் பயன்படுத்துவது பயனுள்ளதாக இருந்தாலும், வரிசையின் உள்ளே உள்ள பொருள்களுக்கான குறிப்புகளை மட்டும் நகலெடுப்பது தேவையற்ற மாற்றங்களை ஏற்படுத்தலாம்.
அசல் தரவு ஒருமைப்பாட்டை பராமரிப்பது அவசியமான சூழ்நிலைகளில் சிறந்த தீர்வு, போன்ற நுட்பங்களைப் பயன்படுத்தி ஆழமாக நகலெடுப்பதாகும். பாகுபடுத்துதல் அல்லது பயன்பாட்டு நூலகங்கள் போன்றவை . சிக்கலான தரவுக் கட்டமைப்புகளை நிர்வகிப்பதற்கு இரண்டு அணுகுமுறைகளும் அவசியம், ஏனெனில் நகலெடுக்கப்பட்ட வரிசையில் செய்யப்பட்ட மாற்றங்கள் அசலைப் பாதிக்காது.
- ஜாவாஸ்கிரிப்டில் உள்ள ஆழமான குளோனிங் பொருள்கள் பற்றிய இந்தக் கட்டுரை, உள்ளமைக்கப்பட்ட தரவு கட்டமைப்புகளைக் கையாள்வதற்கான கருத்து மற்றும் வெவ்வேறு அணுகுமுறைகளை விளக்குகிறது. நீங்கள் இங்கே தலைப்பைப் பற்றி மேலும் அறியலாம்: MDN Web Docs - Object.assign() .
- லோடாஷைப் பயன்படுத்தி குளோனிங் வரிசைகள் மற்றும் பொருட்களைப் பற்றிய ஆழமான புரிதலுக்கு, இந்த ஆதாரம் போன்ற அத்தியாவசிய செயல்பாடுகளை உள்ளடக்கியது : லோடாஷ் ஆவணம் .
- JSON வரிசைமுறையைப் பயன்படுத்தி ஜாவாஸ்கிரிப்ட் குளோனிங் நுட்பங்களுக்கான மற்றொரு சிறந்த வழிகாட்டியை StackOverflow இல் காணலாம்: StackOverflow - ஜாவாஸ்கிரிப்டில் திறமையான குளோனிங் .