जावास्क्रिप्ट में सैद्धांतिक डेटा संरचनाएं और उनका अनुप्रयोग। P1। युगल

“बुरे प्रोग्रामर कोड के बारे में सोचते हैं। अच्छे प्रोग्रामर डेटा संरचनाओं और उनके रिश्तों के बारे में सोचते हैं, “लिनस टॉर्वाल्ड्स, लिनक्स के निर्माता।

var vm = new Vue({
  el: '#demo',
  data: {
    firstName: 'Foo',
    lastName: 'Bar'
  },
  computed: {
    fullName: function () {
      return this.firstName + ' ' + this.lastName
    }
  }
})

• , .. - , , . , ( - . , )
• . . . , , , , , .
  
  :
  
  

  pair = { a, b }
  

  
  यदि कॉलिंग कोड में हम इस शैली में सीधे जोड़ी के साथ काम करेंगे: pair.aतो जोड़ी के कार्यान्वयन को बदलने से हम कॉलिंग कोड को फिर से लिखने के लिए मजबूर हो जाएंगे जहां जोड़ी को कॉल दिखाई देता है। यह महान नहीं है!
  
  एक युगल एक अमूर्त (यहां तक ​​कि एक निम्न स्तर) है, इसलिए इसके घटकों के साथ सीधे काम करना गलत होगा। किसी भी एब्सट्रैक्शन के घटकों के साथ काम करते समय, हमें एब्सट्रैक्शन इंटरफ़ेस का उपयोग करना चाहिए, अन्यथा कोड अराजकता में बदल जाएगा (यह पढ़ना कठिन हो जाएगा, गलती करना आसान होगा, लेकिन सबसे महत्वपूर्ण बात यह है कि इसे बदलना अधिक कठिन है, क्योंकि कोड के विभिन्न भागों में एक बदलाव करना होगा)।

//       
//      
const pair = (first, second) => (elementType) => {
  switch(elementType) {
    case 'first':
     return first;
   case 'second':
     return second;
  }
};
//    ,      ,
//    
const getFirstElement = (pair) => (pair('first'));
const getSecondElement = (pair) => (pair('second'));

//     
//  ,       
const pair = (first, second) => (
  new Map([
    ['first', first],
    ['second', second],
  ])
);
//    
const getFirst = (pair) => (pair.get('first'));
const getSecond = (pair) => (pair.get('second'));

//       
//   
const pair = (first, second) => (
  Object.freeze({
    'first': first,
    'second': second,
  })
);
//    ,       
const getFirst = (pair) => (pair.first);
const getSecond = (pair) => (pair.second);

हमें सैद्धांतिक डेटा संरचनाओं के ज्ञान की आवश्यकता क्यों है?

//        ,
//  ,    
//          ,
//     
const makeRational = (num, denom) => (
  new Map([
    ['num', num],
    ['denom', denom],
  ])
);

//  ,    
//   ,      ,    
//    
const getNumer = (rat) => (rat.get('num'));
const getDenom = (rat) => (rat.get('denom'));

//Gcd     
const getGcd = (a, b) => ((a % b) ? getGcd(b, a % b) : Math.abs(b));

const normalize = (n1, n2) => {
  const commonDivisor = getGcd(n1, n2);
  return [n1 / commonDivisor, n2 / commonDivisor];
};

const makeRational = (num, denom) => {
  const [normalizeNum, normalizeDenom] = normalize(num, denom);
  return new Map([
    ['num', normalizeNum],
    ['denom', normalizeDenom],
  ]);
};

//..       ,
//       ,
//         
const add = (rat1, rat2) => (
  makeRational(
    getNumer(rat1) * getDenom(rat2) + getNumer(rat2) * getDenom(rat1),
    getDenom(rat1) * getDenom(rat2),
  ));

//    
//     
const sub = (rat1, rat2) => (
  makeRational(
    getNumer(rat1) * getDenom(rat2) - getNumer(rat2) * getDenom(rat1),
    getDenom(rat1) * getDenom(rat2),
  ));

const multi = (rat1, rat2) => (
  makeRational(
    getNumer(rat1) * getNumer(rat2),
    getDenom(rat1) * getDenom(rat2),
  ));

const div = (rat1, rat2) => (
  makeRational(
    getNumer(rat1) * getDenom(rat2),
    getDenom(rat1) * getNumer(rat2),
  ));

const ratToString = (rat) => `${getNumer(rat)}/${getDenom(rat)}`;

describe('normalize', () => {
  test('should work', () => {
    expect(normalize(21, 6)).toEqual([7, 2]);
    expect(normalize(2, 3)).toEqual([2, 3]);
  });
});


describe('rational', () => {
  test('getters', () => {
    const rat1 = makeRational(3, 9);
    expect(getNumer(rat1)).toBe(1);
    expect(getDenom(rat1)).toBe(3);

    const rat3 = makeRational(-4, 16);
    expect(getNumer(rat3)).toBe(-1);
    expect(getDenom(rat3)).toBe(4);
  });

  test('add&sub', () => {
    const rat1 = makeRational(3, 9);
    const rat2 = makeRational(10, 3);
    expect(add(rat1, rat2)).toEqual(makeRational(11, 3));
    expect(sub(rat1, rat2)).toEqual(makeRational(-3, 1));

    const rat4 = makeRational(12, 5);
    const rat3 = makeRational(-4, 16);
    expect(add(rat3, rat4)).toEqual(makeRational(43, 20));
    expect(sub(rat3, rat4)).toEqual(makeRational(-53, 20));

    const rat5 = makeRational(1, 15);
    const rat6 = makeRational(4, 25);
    expect(add(rat5, rat6)).toEqual(makeRational(17, 75));
    expect(sub(rat5, rat6)).toEqual(makeRational(-7, 75));
  });

  test('multi&div', () => {
    const rat1 = makeRational(1, 2);
    const rat2 = makeRational(2, 3);
    expect(multi(rat1, rat2)).toEqual(makeRational(2, 6));

    const rat3 = makeRational(1, 3);
    const rat4 = makeRational(1, 2);
    expect(div(rat3, rat4)).toEqual(makeRational(2, 3));
  });

  test('ratToString', () => {
    const rat1 = makeRational(3, 9);
    const rat3 = makeRational(-4, 16);
    expect(ratToString(rat1)).toBe('1/3');
    expect(ratToString(rat3)).toBe('-1/4');
  });
});

निष्कर्ष

1. जब भी हमें तार्किक रूप से दो असंबंधित मूल्यों को संयोजित करने की आवश्यकता होती है, हम भाप डेटा संरचना का उपयोग कर सकते हैं
2. दंपति को इम्यून होना चाहिए
3. युगल को अपने घटकों के साथ काम करने के लिए एक इंटरफ़ेस प्रदान करना होगा