SDP ਨਾਲ ਸਰਕੂਲਰ ਡਿਪੈਂਡੈਂਸੀਆਂ (Circular Dependencies) ਨੂੰ ਰੋਕੋ
ਸਰਕੂਲਰ ਡਿਪੈਂਡੈਂਸੀਆਂ (Circular dependencies) ਚੁੱਪ-ਚਾਪ ਮਾਰਨ ਵਾਲੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਬਿਲਡ ਐਰਰ (build errors) ਪੈਦਾ ਨਹੀਂ ਕਰਦੀਆਂ। ਇਹ ਇੰਪੋਰਟ (import) ਵੇਲੇ ਰਨਟਾਈਮ ਐਕਸੈਪਸ਼ਨ (runtime exceptions) ਵੀ ਨਹੀਂ ਦਿੰਦੀਆਂ। ਇਸ ਦੀ ਬਜਾਏ, ਇਹ ਅਜਿਹੀਆਂ ਬਾਰੀਕ 'undefined' ਵੈਲਯੂਜ਼ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ ਜੋ ਹਫ਼ਤਿਆਂ ਬਾਅਦ ਪ੍ਰੋਡਕਸ਼ਨ (production) ਵਿੱਚ ਸਾਹਮਣੇ ਆਉਂਦੀਆਂ ਹਨ।
ਇੱਕ ਚੱਕਰ (cycle) ਉਦੋਂ ਬਣਦਾ ਹੈ ਜਦੋਂ ਮੋਡਿਊਲ A, B ਤੋਂ ਇੰਪੋਰਟ ਕਰਦਾ ਹੈ, ਅਤੇ B ਵਾਪਸ A ਤੋਂ ਇੰਪੋਰਟ ਕਰਦਾ ਹੈ।
JavaScript ਇਹਨਾਂ ਇੰਪੋਰਟਸ ਨੂੰ ਚੁੱਪਚਾਪ ਹੱਲ ਕਰ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਮੋਡਿਊਲ B ਦੁਆਰਾ ਮੰਗ ਕੀਤੇ ਜਾਣ ਸਮੇਂ ਮੋਡਿਊਲ A ਅਜੇ ਵੀ ਲੋਡ ਹੋ ਰਿਹਾ ਹੈ, ਤਾਂ JavaScript ਇੱਕ ਖਾਲੀ ਆਬਜੈਕਟ (empty object) ਵਾਪਸ ਕਰ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਡਾ ਕੋਡ ਬਾਅਦ ਵਿੱਚ ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਸਟੈਕ ਟ੍ਰੇਸ (stack trace) ਗਲਤ ਜਗ੍ਹਾ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ।
ਤੁਸੀਂ ਇਸਨੂੰ dependency-cruiser ਨਾਲ ਠੀਕ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਟੂਲ ਤੁਹਾਡੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਸਕੈਨ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਡਿਪੈਂਡੈਂਸੀ ਗ੍ਰਾਫ (dependency graph) ਨੂੰ ਮੈਪ ਕਰਦਾ ਹੈ। ਇਹ TypeScript ਅਤੇ monorepos ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
ਇਸਨੂੰ ਕਿਵੇਂ ਸੈੱਟਅੱਪ ਕਰਨਾ ਹੈ:
- ਇਸਨੂੰ ਆਪਣੀਆਂ dev dependencies ਵਿੱਚ ਜੋੜੋ:
yarn add -D dependency-cruiser - ਆਪਣੇ package.json ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਜੋੜੋ:
"depcruise": "depcruise packages --config .dependency-cruiser.js" - ਚੱਕਰਾਂ (cycles) ਨੂੰ ਫੜਨ ਲਈ ਇੱਕ .dependency-cruiser.js ਫਾਈਲ ਬਣਾਓ।
ਪਰ ਚੱਕਰ ਲੱਭਣਾ ਤਾਂ ਅੱਧੀ ਜੰਗ ਹੈ। ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਬਣਨ ਤੋਂ ਰੋਕਣਾ ਚਾਹੀਦਾ ਹੈ।
ਸਟੇਬਲ ਡਿਪੈਂਡੈਂਸੀਜ਼ ਪ੍ਰਿੰਸੀਪਲ (Stable Dependencies Principle - SDP) ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ ਨਿਯਮ ਕਹਿੰਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਸਥਿਰਤਾ (stability) ਦੀ ਦਿਸ਼ਾ ਵਿੱਚ ਡਿਪੈਂਡ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਸਥਿਰਤਾ (Stability) ਇੱਕ ਸੰਰਚਨਾਤਮਕ ਗੁਣ (structural property) ਹੈ। ਇੱਕ ਮੋਡਿਊਲ ਉਦੋਂ ਸਥਿਰ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਬਹੁਤ ਸਾਰੇ ਹੋਰ ਮੋਡਿਊਲ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸਥਿਰ ਮੋਡਿਊਲ ਨੂੰ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹੋ। ਇਹ 'ਕਾਸਟ' (cost) ਹੀ ਇਸਨੂੰ ਸਥਿਰ ਬਣਾਉਂਦੀ ਹੈ।
Instability ਫਾਰਮੂਲੇ ਦੀ ਵਰਤੋਂ ਕਰੋ:
I = Fan-Out / (Fan-In + Fan-Out)
• I = 0 ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮੋਡਿਊਲ ਵੱਧ ਤੋਂ ਵੱਧ ਸਥਿਰ (maximally stable) ਹੈ। ਹਰ ਚੀਜ਼ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਹ ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ। • I = 1 ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਮੋਡਿਊਲ ਵੱਧ ਤੋਂ ਵੱਧ ਅਸਥਿਰ (maximally unstable) ਹੈ। ਇਹ ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੋਈ ਵੀ ਚੀਜ਼ ਇਸ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦੀ।
ਨਿਯਮ: ਇੱਕ ਮੋਡਿਊਲ ਦਾ instability ਸਕੋਰ ਉਸ ਹਰ ਮੋਡਿਊਲ ਦੇ ਸਕੋਰ ਨਾਲੋਂ ਵੱਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਨੂੰ ਉਹ ਇੰਪੋਰਟ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੇ ਤੀਰ (arrows) ਘੱਟ ਅਸਥਿਰਤਾ (lower instability) ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ।
ਤੁਹਾਡੇ low-level utils (I ≈ 0) ਨੂੰ ਕਦੇ ਵੀ ਤੁਹਾਡੇ high-level pages (I ≈ 1) ਤੋਂ ਇੰਪੋਰਟ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ।
ਤੁਸੀਂ dependency-cruiser ਨਾਲ ਇਸ ਸਿਧਾਂਤ ਨੂੰ ਇੱਕ ਆਟੋਮੇਟਡ ਨਿਯਮ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ। ਸਿਰਫ਼ ਚੱਕਰਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਬਜਾਏ, ਦਿਸ਼ਾ ਦੀ ਜਾਂਚ ਕਰੋ:
- Utils ਨੂੰ features ਤੋਂ ਇੰਪੋਰਟ ਕਰਨ ਤੋਂ ਰੋਕੋ।
- Features ਨੂੰ pages ਤੋਂ ਇੰਪੋਰਟ ਕਰਨ ਤੋਂ ਰੋਕੋ।
ਇਹ ਉਹਨਾਂ ਸੰਰਚਨਾਤਮਕ ਸਥਿਤੀਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ ਚੱਕਰ (cycles) ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਬੱਗਸ (bugs) ਪ੍ਰਤੀ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇਣਾ ਬੰਦ ਕਰਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਰੋਕਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ।