જાવાસ્ક્રિપ્ટ રેકોર્ડ અને ટ્યુપલ: ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સની સમજૂતી

જાવાસ્ક્રિપ્ટ સતત વિકસિત થઈ રહ્યું છે, અને ક્ષિતિજ પરના સૌથી રોમાંચક પ્રસ્તાવોમાંનો એક રેકોર્ડ અને ટ્યુપલની રજૂઆત છે, જે ભાષાના મૂળમાં ઇમ્યુટેબિલિટી (અપરિવર્તનશીલતા) લાવવા માટે ડિઝાઇન કરાયેલ બે નવા ડેટા સ્ટ્રક્ચર્સ છે. આ પોસ્ટ રેકોર્ડ અને ટ્યુપલ શું છે, તે શા માટે મહત્વપૂર્ણ છે, તે કેવી રીતે કાર્ય કરે છે, અને તે વિશ્વભરના જાવાસ્ક્રિપ્ટ ડેવલપર્સને શું ફાયદાઓ આપે છે તે વિશે ઊંડાણપૂર્વક સમજાવે છે.

રેકોર્ડ અને ટ્યુપલ શું છે?

રેકોર્ડ અને ટ્યુપલ જાવાસ્ક્રિપ્ટમાં પ્રિમિટિવ, ડીપલી ઇમ્યુટેબલ (ઊંડાણપૂર્વક અપરિવર્તનશીલ) ડેટા સ્ટ્રક્ચર્સ છે. તેમને અનુક્રમે જાવાસ્ક્રિપ્ટ ઓબ્જેક્ટ્સ અને એરેના ઇમ્યુટેબલ વર્ઝન તરીકે વિચારો.

• રેકોર્ડ: એક ઇમ્યુટેબલ ઓબ્જેક્ટ. એકવાર બનાવ્યા પછી, તેના પ્રોપર્ટીઝમાં ફેરફાર કરી શકાતો નથી.
• ટ્યુપલ: એક ઇમ્યુટેબલ એરે. એકવાર બનાવ્યા પછી, તેના એલિમેન્ટ્સમાં ફેરફાર કરી શકાતો નથી.

આ ડેટા સ્ટ્રક્ચર્સ ડીપલી ઇમ્યુટેબલ છે, જેનો અર્થ છે કે માત્ર રેકોર્ડ અથવા ટ્યુપલમાં જ ફેરફાર કરી શકાતો નથી, પરંતુ તેની અંદરના કોઈપણ નેસ્ટેડ ઓબ્જેક્ટ્સ અથવા એરે પણ ઇમ્યુટેબલ છે.

ઇમ્યુટેબિલિટી શા માટે મહત્વપૂર્ણ છે

ઇમ્યુટેબિલિટી સોફ્ટવેર ડેવલપમેન્ટમાં ઘણા મુખ્ય ફાયદાઓ લાવે છે:

• સુધારેલ પર્ફોર્મન્સ: ઇમ્યુટેબિલિટી ડીપ કમ્પેરીઝન (બે ઓબ્જેક્ટ્સની સામગ્રીની તુલના કરવી) ને બદલે શેલો કમ્પેરીઝન (બે વેરિયેબલ્સ મેમરીમાં સમાન ઓબ્જેક્ટને રેફરન્સ કરે છે કે કેમ તે તપાસવું) જેવા ઓપ્ટિમાઇઝેશનની મંજૂરી આપે છે. આ એવા સંજોગોમાં પર્ફોર્મન્સમાં નોંધપાત્ર સુધારો કરી શકે છે જ્યાં તમે વારંવાર ડેટા સ્ટ્રક્ચર્સની તુલના કરો છો.
• ઉન્નત ટાઇપ સેફ્ટી: ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સ ડેટાની અખંડિતતા વિશે મજબૂત ગેરંટી પૂરી પાડે છે, જેનાથી કોડ વિશે તર્ક કરવો અને અણધારી આડઅસરોને રોકવાનું સરળ બને છે. ટાઇપસ્ક્રિપ્ટ જેવી ટાઇપ સિસ્ટમ્સ ઇમ્યુટેબિલિટીની મર્યાદાઓને વધુ સારી રીતે ટ્રેક અને લાગુ કરી શકે છે.
• સરળ ડિબગિંગ: ઇમ્યુટેબલ ડેટા સાથે, તમે વિશ્વાસ રાખી શકો છો કે કોઈ મૂલ્ય અણધારી રીતે બદલાશે નહીં, જેનાથી ડેટાના પ્રવાહને ટ્રેસ કરવું અને બગ્સના સ્ત્રોતને ઓળખવું સરળ બને છે.
• કન્કરન્સી સેફ્ટી: ઇમ્યુટેબિલિટી કન્કરન્ટ કોડ લખવાનું ખૂબ સરળ બનાવે છે, કારણ કે તમારે એક જ સમયે સમાન ડેટા સ્ટ્રક્ચરમાં ફેરફાર કરતા બહુવિધ થ્રેડ્સ વિશે ચિંતા કરવાની જરૂર નથી.
• અનુમાનિત સ્ટેટ મેનેજમેન્ટ: React, Redux, અને Vue જેવા ફ્રેમવર્કમાં, ઇમ્યુટેબિલિટી સ્ટેટ મેનેજમેન્ટને સરળ બનાવે છે અને ટાઇમ-ટ્રાવેલ ડિબગિંગ જેવી સુવિધાઓને સક્ષમ કરે છે.

રેકોર્ડ અને ટ્યુપલ કેવી રીતે કામ કરે છે

રેકોર્ડ અને ટ્યુપલ `new Record()` અથવા `new Tuple()` જેવા કન્સ્ટ્રક્ટરનો ઉપયોગ કરીને બનાવવામાં આવતા નથી. તેના બદલે, તે એક વિશિષ્ટ સિન્ટેક્સનો ઉપયોગ કરીને બનાવવામાં આવે છે:

• રેકોર્ડ: `#{ key1: value1, key2: value2 }`
• ટ્યુપલ: `#[ item1, item2, item3 ]`

ચાલો કેટલાક ઉદાહરણો જોઈએ:

રેકોર્ડના ઉદાહરણો

રેકોર્ડ બનાવવો:

const myRecord = #{ name: "Alice", age: 30, city: "London" }; console.log(myRecord.name); // Output: Alice

રેકોર્ડમાં ફેરફાર કરવાનો પ્રયાસ કરવાથી એરર આવશે:

try { myRecord.age = 31; // Throws an error } catch (error) { console.error(error); }

ડીપ ઇમ્યુટેબિલિટીનું ઉદાહરણ:

const address = #{ street: "Baker Street", number: 221, city: "London" }; const person = #{ name: "Sherlock", address: address }; // Trying to modify the nested object will throw an error. try { person.address.number = 221; } catch (error) { console.error("Error caught: " + error); }

ટ્યુપલના ઉદાહરણો

ટ્યુપલ બનાવવો:

const myTuple = #[1, 2, 3, "hello"]; console.log(myTuple[0]); // Output: 1

ટ્યુપલમાં ફેરફાર કરવાનો પ્રયાસ કરવાથી એરર આવશે:

try { myTuple[0] = 4; // Throws an error } catch (error) { console.error(error); }

ડીપ ઇમ્યુટેબિલિટીનું ઉદાહરણ:

const innerTuple = #[4, 5, 6]; const outerTuple = #[1, 2, 3, innerTuple]; // Trying to modify the nested tuple will throw an error try { outerTuple[3][0] = 7; } catch (error) { console.error("Error caught: " + error); }

રેકોર્ડ અને ટ્યુપલનો ઉપયોગ કરવાના ફાયદા

• પર્ફોર્મન્સ ઓપ્ટિમાઇઝેશન: અગાઉ ઉલ્લેખ કર્યો તેમ, રેકોર્ડ અને ટ્યુપલની ઇમ્યુટેબિલિટી શેલો કમ્પેરીઝન જેવા ઓપ્ટિમાઇઝેશનને સક્ષમ કરે છે. શેલો કમ્પેરીઝનમાં ડેટા સ્ટ્રક્ચર્સની સામગ્રીની ઊંડાણપૂર્વક તુલના કરવાને બદલે મેમરી એડ્રેસની તુલના કરવાનો સમાવેશ થાય છે. આ નોંધપાત્ર રીતે ઝડપી છે, ખાસ કરીને મોટા ઓબ્જેક્ટ્સ અથવા એરે માટે.
• ડેટા ઇન્ટિગ્રિટી: આ ડેટા સ્ટ્રક્ચર્સનો ઇમ્યુટેબલ સ્વભાવ ખાતરી આપે છે કે ડેટા આકસ્મિક રીતે સંશોધિત થશે નહીં, બગ્સનું જોખમ ઘટાડે છે અને કોડ વિશે તર્ક કરવાનું સરળ બનાવે છે.
• સુધારેલ ડિબગિંગ: ડેટા ઇમ્યુટેબલ છે તે જાણવાથી ડિબગિંગ સરળ બને છે, કારણ કે તમે અણધાર્યા મ્યુટેશન્સની ચિંતા કર્યા વિના ડેટાના પ્રવાહને ટ્રેસ કરી શકો છો.
• કન્કરન્સી-ફ્રેન્ડલી: ઇમ્યુટેબિલિટી રેકોર્ડ અને ટ્યુપલને સ્વાભાવિક રીતે થ્રેડ-સેફ બનાવે છે, જે કન્કરન્ટ પ્રોગ્રામિંગને સરળ બનાવે છે.
• ફંક્શનલ પ્રોગ્રામિંગ સાથે બહેતર એકીકરણ: રેકોર્ડ અને ટ્યુપલ ફંક્શનલ પ્રોગ્રામિંગ પેરાડાઇમ્સ માટે કુદરતી રીતે યોગ્ય છે, જ્યાં ઇમ્યુટેબિલિટી એ મુખ્ય સિદ્ધાંત છે. તે પ્યોર ફંક્શન્સ લખવાનું સરળ બનાવે છે, જે એવા ફંક્શન્સ છે જે સમાન ઇનપુટ માટે હંમેશા સમાન આઉટપુટ આપે છે અને તેની કોઈ આડઅસર હોતી નથી.

રેકોર્ડ અને ટ્યુપલના ઉપયોગના કિસ્સા

રેકોર્ડ અને ટ્યુપલનો ઉપયોગ વિવિધ પરિસ્થિતિઓમાં થઈ શકે છે, જેમાં નીચેનાનો સમાવેશ થાય છે:

• કન્ફિગરેશન ઓબ્જેક્ટ્સ: એપ્લિકેશન કન્ફિગરેશન સેટિંગ્સને સ્ટોર કરવા માટે રેકોર્ડ્સનો ઉપયોગ કરો, ખાતરી કરો કે તેમાં આકસ્મિક રીતે ફેરફાર કરી શકાતો નથી. ઉદાહરણ તરીકે, API કી, ડેટાબેઝ કનેક્શન સ્ટ્રિંગ્સ, અથવા ફીચર ફ્લેગ્સ સ્ટોર કરવા.
• ડેટા ટ્રાન્સફર ઓબ્જેક્ટ્સ (DTOs): એપ્લિકેશનના વિવિધ ભાગો વચ્ચે અથવા વિવિધ સેવાઓ વચ્ચે ટ્રાન્સફર થતા ડેટાને રજૂ કરવા માટે રેકોર્ડ્સ અને ટ્યુપલ્સનો ઉપયોગ કરો. આ ડેટાની સુસંગતતા સુનિશ્ચિત કરે છે અને ટ્રાન્ઝિટ દરમિયાન આકસ્મિક ફેરફારોને અટકાવે છે.
• સ્ટેટ મેનેજમેન્ટ: Redux અથવા Vuex જેવી સ્ટેટ મેનેજમેન્ટ લાઇબ્રેરીઓમાં રેકોર્ડ અને ટ્યુપલને એકીકૃત કરો જેથી એપ્લિકેશન સ્ટેટ ઇમ્યુટેબલ રહે, જે સ્ટેટ ફેરફારો વિશે તર્ક કરવાનું અને ડિબગ કરવાનું સરળ બનાવે છે.
• કેશિંગ: કાર્યક્ષમ કેશ લુકઅપ માટે શેલો કમ્પેરીઝનનો લાભ લેવા માટે કેશમાં કી તરીકે રેકોર્ડ્સ અને ટ્યુપલ્સનો ઉપયોગ કરો.
• ગાણિતિક વેક્ટર્સ અને મેટ્રિસિસ: ટ્યુપલ્સનો ઉપયોગ ગાણિતિક વેક્ટર્સ અને મેટ્રિસિસને રજૂ કરવા માટે થઈ શકે છે, જે આંકડાકીય ગણતરીઓ માટે ઇમ્યુટેબિલિટીનો લાભ લે છે. ઉદાહરણ તરીકે, વૈજ્ઞાનિક સિમ્યુલેશન્સ અથવા ગ્રાફિક્સ રેન્ડરિંગમાં.
• ડેટાબેઝ રેકોર્ડ્સ: ડેટાબેઝ રેકોર્ડ્સને રેકોર્ડ્સ અથવા ટ્યુપલ્સ તરીકે મેપ કરો, જે ડેટાની અખંડિતતા અને એપ્લિકેશનની વિશ્વસનીયતામાં સુધારો કરે છે.

કોડ ઉદાહરણો: વ્યવહારુ એપ્લિકેશન્સ

ઉદાહરણ 1: રેકોર્ડ સાથે કન્ફિગરેશન ઓબ્જેક્ટ

const config = #{ apiUrl: "https://api.example.com", timeout: 5000, maxRetries: 3 }; function fetchData(url) { // Use config values console.log(`Fetching data from ${config.apiUrl + url} with timeout ${config.timeout}`); // ... rest of the implementation } fetchData("/users");

ઉદાહરણ 2: ટ્યુપલ સાથે ભૌગોલિક કોઓર્ડિનેટ્સ

const latLong = #[34.0522, -118.2437]; // Los Angeles function calculateDistance(coord1, coord2) { // Implementation for calculating distance using coordinates const [lat1, lon1] = coord1; const [lat2, lon2] = coord2; const R = 6371; // Radius of the earth in km const dLat = deg2rad(lat2 - lat1); const dLon = deg2rad(lon2 - lon1); const a = Math.sin(dLat/2) * Math.sin(dLat/2) + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.sin(dLon/2) * Math.sin(dLon/2); const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); const distance = R * c; return distance; // Distance in kilometers } function deg2rad(deg) { return deg * (Math.PI/180) } const londonCoords = #[51.5074, 0.1278]; const distanceToLondon = calculateDistance(latLong, londonCoords); console.log(`Distance to London: ${distanceToLondon} km`);

ઉદાહરણ 3: રેકોર્ડ સાથે Redux સ્ટેટ

એક સરળ Redux સેટઅપ માનીને:

const initialState = #{ user: null, isLoading: false, error: null }; function reducer(state = initialState, action) { switch (action.type) { case 'FETCH_USER_REQUEST': return #{ ...state, isLoading: true }; case 'FETCH_USER_SUCCESS': return #{ ...state, user: action.payload, isLoading: false }; case 'FETCH_USER_FAILURE': return #{ ...state, error: action.payload, isLoading: false }; default: return state; } }

પર્ફોર્મન્સ સંબંધિત વિચારણાઓ

જ્યારે રેકોર્ડ અને ટ્યુપલ શેલો કમ્પેરીઝન દ્વારા પર્ફોર્મન્સના લાભો પ્રદાન કરે છે, ત્યારે આ ડેટા સ્ટ્રક્ચર્સ બનાવતી અને સંચાલિત કરતી વખતે સંભવિત પર્ફોર્મન્સ અસરોથી વાકેફ રહેવું મહત્વપૂર્ણ છે, ખાસ કરીને મોટી એપ્લિકેશન્સમાં. નવો રેકોર્ડ અથવા ટ્યુપલ બનાવવા માટે ડેટાની કોપી કરવાની જરૂર પડે છે, જે કેટલાક કિસ્સાઓમાં હાલના ઓબ્જેક્ટ અથવા એરેમાં ફેરફાર કરવા કરતાં વધુ ખર્ચાળ હોઈ શકે છે. જો કે, ઇમ્યુટેબિલિટીના ફાયદાઓને કારણે આ ટ્રેડ-ઓફ ઘણીવાર યોગ્ય છે.

પર્ફોર્મન્સને ઑપ્ટિમાઇઝ કરવા માટે નીચેની વ્યૂહરચનાઓનો વિચાર કરો:

• મેમોઇઝેશન: રેકોર્ડ અને ટ્યુપલ ડેટાનો ઉપયોગ કરતી મોંઘી ગણતરીઓના પરિણામોને કેશ કરવા માટે મેમોઇઝેશન તકનીકોનો ઉપયોગ કરો.
• સ્ટ્રક્ચરલ શેરિંગ: સ્ટ્રક્ચરલ શેરિંગનો ઉપયોગ કરો, જેનો અર્થ છે નવા ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સ બનાવતી વખતે હાલના ડેટા સ્ટ્રક્ચર્સના ભાગોનો ફરીથી ઉપયોગ કરવો. આ કોપી કરવાની જરૂર પડતા ડેટાની માત્રાને ઘટાડી શકે છે. ઘણી લાઇબ્રેરીઓ મૂળ ડેટાના મોટા ભાગને શેર કરતી વખતે નેસ્ટેડ સ્ટ્રક્ચર્સને અપડેટ કરવાની કાર્યક્ષમ રીતો પ્રદાન કરે છે.
• લેઝી ઇવેલ્યુએશન: ગણતરીઓને ત્યાં સુધી મુલતવી રાખો જ્યાં સુધી તેની ખરેખર જરૂર ન હોય, ખાસ કરીને જ્યારે મોટા ડેટાસેટ્સ સાથે કામ કરતા હોવ.

બ્રાઉઝર અને રનટાઇમ સપોર્ટ

વર્તમાન તારીખ (ઓક્ટોબર 26, 2023) મુજબ, રેકોર્ડ અને ટ્યુપલ હજી પણ ECMAScript માનકીકરણ પ્રક્રિયામાં એક પ્રસ્તાવ છે. આનો અર્થ છે કે તે હજુ સુધી મોટાભાગના બ્રાઉઝર્સ અથવા Node.js એન્વાયર્નમેન્ટ્સમાં મૂળભૂત રીતે સપોર્ટેડ નથી. આજે તમારા કોડમાં રેકોર્ડ અને ટ્યુપલનો ઉપયોગ કરવા માટે, તમારે યોગ્ય પ્લગઇન સાથે બેબલ (Babel) જેવા ટ્રાન્સપાઇલરનો ઉપયોગ કરવાની જરૂર પડશે.

રેકોર્ડ અને ટ્યુપલને સપોર્ટ કરવા માટે બેબલ કેવી રીતે સેટ કરવું તે અહીં છે:

1. બેબલ ઇન્સ્ટોલ કરો: npm install --save-dev @babel/core @babel/cli @babel/preset-env
2. રેકોર્ડ અને ટ્યુપલ બેબલ પ્લગઇન ઇન્સ્ટોલ કરો: npm install --save-dev @babel/plugin-proposal-record-and-tuple
3. બેબલને કન્ફિગર કરો (`.babelrc` અથવા `babel.config.js` ફાઇલ બનાવો):

   ઉદાહરણ `.babelrc`:

   { "presets": ["@babel/preset-env"], "plugins": ["@babel/plugin-proposal-record-and-tuple"] }
4. તમારા કોડને ટ્રાન્સપાઇલ કરો: babel your-code.js -o output.js

`@babel/plugin-proposal-record-and-tuple` પ્લગઇન માટેના સત્તાવાર દસ્તાવેજીકરણને સૌથી અપ-ટુ-ડેટ ઇન્સ્ટોલેશન અને કન્ફિગરેશન સૂચનાઓ માટે તપાસો. કોડ સરળતાથી ટ્રાન્સફર કરી શકાય અને વિવિધ સંદર્ભોમાં અસરકારક રીતે કાર્ય કરે તેની ખાતરી કરવા માટે તમારા ડેવલપમેન્ટ એન્વાયર્નમેન્ટને ECMAScript ધોરણો સાથે સંરેખિત રાખવું નિર્ણાયક છે.

અન્ય ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સ સાથે સરખામણી

જાવાસ્ક્રિપ્ટમાં પહેલેથી જ એવી લાઇબ્રેરીઓ છે જે ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સ પ્રદાન કરે છે, જેમ કે Immutable.js અને Mori. અહીં એક સંક્ષિપ્ત સરખામણી છે:

• Immutable.js: એક લોકપ્રિય લાઇબ્રેરી જે Lists, Maps, અને Sets સહિત ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સની વિશાળ શ્રેણી પૂરી પાડે છે. તે એક પરિપક્વ અને સારી રીતે પરીક્ષણ કરેલ લાઇબ્રેરી છે, પરંતુ તે તેની પોતાની API રજૂ કરે છે, જે પ્રવેશ માટે અવરોધ બની શકે છે. રેકોર્ડ અને ટ્યુપલનો હેતુ ભાષા સ્તરે ઇમ્યુટેબિલિટી પ્રદાન કરવાનો છે, જે તેને વાપરવા માટે વધુ સ્વાભાવિક બનાવે છે.
• Mori: એક લાઇબ્રેરી જે ક્લોજર (Clojure)ના પર્સિસ્ટન્ટ ડેટા સ્ટ્રક્ચર્સ પર આધારિત ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સ પ્રદાન કરે છે. Immutable.jsની જેમ, તે તેની પોતાની API રજૂ કરે છે.

રેકોર્ડ અને ટ્યુપલનો મુખ્ય ફાયદો એ છે કે તે ભાષામાં જ બનેલા છે, જેનો અર્થ છે કે તે આખરે તમામ જાવાસ્ક્રિપ્ટ એન્જિન દ્વારા મૂળભૂત રીતે સપોર્ટેડ હશે. આ બાહ્ય લાઇબ્રેરીઓની જરૂરિયાતને દૂર કરે છે અને ઇમ્યુટેબલ ડેટા સ્ટ્રક્ચર્સને જાવાસ્ક્રિપ્ટમાં ફર્સ્ટ-ક્લાસ સિટીઝન બનાવે છે.

જાવાસ્ક્રિપ્ટ ડેટા સ્ટ્રક્ચર્સનું ભવિષ્ય

રેકોર્ડ અને ટ્યુપલની રજૂઆત જાવાસ્ક્રિપ્ટ માટે એક મહત્વપૂર્ણ પગલું છે, જે ઇમ્યુટેબિલિટીના ફાયદાઓને ભાષાના મૂળમાં લાવે છે. જેમ જેમ આ ડેટા સ્ટ્રક્ચર્સ વધુ વ્યાપક રીતે અપનાવવામાં આવશે, તેમ આપણે વધુ ફંક્શનલ અને અનુમાનિત જાવાસ્ક્રિપ્ટ કોડ તરફ વલણ જોઈ શકીએ છીએ.

નિષ્કર્ષ

રેકોર્ડ અને ટ્યુપલ જાવાસ્ક્રિપ્ટમાં શક્તિશાળી નવા ઉમેરણો છે જે પર્ફોર્મન્સ, ટાઇપ સેફ્ટી અને કોડની જાળવણીક્ષમતાના સંદર્ભમાં નોંધપાત્ર ફાયદાઓ પ્રદાન કરે છે. હજુ પણ એક પ્રસ્તાવ હોવા છતાં, તે જાવાસ્ક્રિપ્ટ ડેટા સ્ટ્રક્ચર્સની ભવિષ્યની દિશાનું પ્રતિનિધિત્વ કરે છે અને તે જાણવા યોગ્ય છે.

રેકોર્ડ અને ટ્યુપલ સાથે ઇમ્યુટેબિલિટી અપનાવીને, તમે વધુ મજબૂત, કાર્યક્ષમ અને જાળવણીક્ષમ જાવાસ્ક્રિપ્ટ કોડ લખી શકો છો. જેમ જેમ આ સુવિધાઓ માટે સપોર્ટ વધશે, તેમ વિશ્વભરના ડેવલપર્સને જાવાસ્ક્રિપ્ટ ઇકોસિસ્ટમમાં તેમના દ્વારા લાવવામાં આવેલી વધેલી વિશ્વસનીયતા અને અનુમાનિતતાનો લાભ મળશે.

રેકોર્ડ અને ટ્યુપલ પ્રસ્તાવ પરના અપડેટ્સ માટે જોડાયેલા રહો અને આજે જ તમારા પ્રોજેક્ટ્સમાં તેનો પ્રયોગ કરવાનું શરૂ કરો! જાવાસ્ક્રિપ્ટનું ભવિષ્ય પહેલા કરતાં વધુ ઇમ્યુટેબલ દેખાઈ રહ્યું છે.