09 ਸਤੰ 2025·8 ਮਿੰਟ
Node.js ਕੀ ਹੈ? ਸ਼ੁਰੂਆਤੀਆਂ ਲਈ ਆਸਾਨ ਵਿਆਖਿਆ
ਜਾਣੋ ਕਿ Node.js ਕੀ ਹੈ, ਇਹ ਸਰਵਰਾਂ 'ਤੇ JavaScript ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ, ਇਸ ਦਾ event loop ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਅਤੇ ਕਦੋਂ Node.js ਤੁਹਾਡੇ ਐਪ ਲਈ ਚੰਗਾ ਚੋਣ ਹੈ।
ਜਾਣੋ ਕਿ Node.js ਕੀ ਹੈ, ਇਹ ਸਰਵਰਾਂ 'ਤੇ JavaScript ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ, ਇਸ ਦਾ event loop ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਅਤੇ ਕਦੋਂ Node.js ਤੁਹਾਡੇ ਐਪ ਲਈ ਚੰਗਾ ਚੋਣ ਹੈ।
Node.js ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਤੁਹਾਨੂੰ JavaScript ਆਪਣੇ ਕੰਪਿਊਟਰ (ਜਾਂ ਸਰਵਰ) 'ਤੇ ਚਲਾਉਣ ਦਿੰਦਾ ਹੈ, ਸਿਰਫ਼ ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਅੰਦਰ ਨਹੀਂ।
ਸ਼ਬਦਾਂ ਦਾ ਗਲਤ ਪ੍ਰਯੋਗ ਆਸਾਨੀ ਨਾਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਸਾਫ਼ ਸਥਿਤੀ ਇਹ ਹੈ:
Node.js ਨੂੰ ਉਸ “engine room” ਵਰਗਾ ਸੋਚੋ ਜੋ Chrome, Firefox, Safari ਆਦਿ ਤੋਂ ਬਾਹਰ JavaScript ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ।
ਆਮ ਤੌਰ 'ਤੇ, JavaScript ਉਹ ਚੀਜ਼ਾਂ ਚਲਾਉਂਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਪੇਜ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ ਜਾਂ ਵੇਖਦੇ ਹੋ: ਮੀਨੂੰ, ਫਾਰਮ, ਇੰਟਰਐਕਟਿਵ UI। ਬ੍ਰਾਊਜ਼ਰ ਉਹ ਵਾਤਾਵਰਣ ਮੁਹੱਈਆ ਕਰਦਾ ਹੈ (ਪੇਜ, ਬਟਨ, ਵਿੰਡੋ ਆਦਿ)।
Node.js ਇੱਕ ਵੱਖਰਾ ਵਾਤਾਵਰਣ ਦਿੰਦਾ ਹੈ। ਪੇਜ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਥਾਂ, ਤੁਹਾਡੀ JavaScript ਤੁਹਾਡੇ ਕੰਪਿਊਟਰ ਅਤੇ ਨੈੱਟਵਰਕ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ: ਫਾਇਲਾਂ ਪੜ੍ਹਨਾ, ਡੇਟਾਬੇਸ ਨਾਲ ਗੱਲਬਾਤ, ਵੈੱਬ ਬੇਨਤੀਆਂ ਸੰਭਾਲਣਾ, ਅਤੇ ਨਿਯਤ ਕੰਮ ਚਲਾਉਣਾ।
ਜਦ JavaScript ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਬਾਹਰ ਚਲ ਸਕਦੀ ਹੈ ਤਾਂ ਕੁਝ ਪ੍ਰਯੋਗਿਕ ਨਤੀਜੇ ਹੁੰਦੇ ਹਨ:
ਇਸ ਲਈ, ਜਦ ਕੋਈ ਕਹਿੰਦਾ ਹੈ “ਸਾਡਾ ਬੈਕਐਂਡ Node.js ਤੇ ਹੈ,” ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਇਸ਼ਾਰੇ ਕਰਦੇ ਹਨ: “ਸਾਡਾ ਸਰਵਰ-ਸਾਈਡ ਕੋਡ JavaScript ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਇਹ Node.js ਉੱਤੇ ਚੱਲਦਾ ਹੈ।”
Node.js ਇਸ ਲਈ आया ਕਿ ਪਹਿਲੇ ਵੈੱਬ ਸਰਵਰ ਇੱਕ ਖ਼ਾਸ ਤੇ ਆਮ ਸਮੱਸਿਆ ਨਾਲ ਝੁਝ ਰਹੇ ਸਨ: ਇੱਕੋ ਸਮੇਂ ਬਹੁਤ ਸਾਰੀਆਂ ਛੋਟੀਆਂ ਬੇਨਤੀਆਂ ਸੰਭਾਲਣਾ — ਖ਼ਾਸ ਕਰਕੇ ਜਦ ਉਹ ਬੇਨਤੀਆਂ ਡੇਟਾਬੇਸ, ਫਾਇਲ ਸਿਸਟਮ ਜਾਂ ਬਾਹਰੀ APIs ਤੋਂ ਉਡੀਕ ਕਰਦੀਆਂ ਹਨ।
ਪਹਿਲਾਂ ਬਹੁਤ ਸਾਰੇ ਸਰਵਰ ਹਰ ਆਉਣ ਵਾਲੀ ਕਨੈਕਸ਼ਨ ਨੂੰ “ਇੱਕ ਬੇਨਤੀ, ਇੱਕ ਥ੍ਰੈਡ/ਪ੍ਰੋਸੈੱਸ” ਢੰਗ ਨਾਲ ਸੰਭਾਲਦੇ ਸਨ। ਇਹ ਢੰਗ ਕੰਮ ਕਰ ਸਕਦਾ ਸੀ, ਪਰ ਜਦ ਹਜ਼ਾਰਾਂ ਯੂਜ਼ਰ ਇਕੱਠੇ ਕਨੈਕਟ ਹੋ ਜਾਂਦੇ ਹਨ ਤਾਂ ਇਹ ਮਹਿੰਗਾ ਅਤੇ ਅਣਕਾਰਗਰ ਸਾਬਤ ਹੋ ਸਕਦਾ ਹੈ।
ਚੈਟ ਐਪ ਜਾਂ ਲਾਈਵ ਡੈਸ਼ਬੋਰਡ ਇੱਕ ਕਲਾਸਿਕ ਉਦਾਹਰਨ ਹੈ: ਸਰਵਰ ਬਹੁਤ ਸਮਾਂ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ (ਨੈੱਟਵਰਕ ਜਵਾਬ, ਡਿਸਕ ਪੜ੍ਹਾਈ, ਡੇਟਾਬੇਸ ਕ੍ਵੇਰੀ)। ਜੇ ਹਰ ਯੂਜ਼ਰ ਲਈ ਇੱਕ ਭਾਰੀ ਥ੍ਰੈਡ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ, ਤਾਂ ਯਾਦاشت ਅਤੇ CPU ਗੁੰਮ ਹੋ ਜਾਂਦੇ ਹਨ।
Node.js 2009 ਵਿੱਚ Ryan Dahl ਨੇ ਬਣਾਇਆ ਸੀ। ਵਿਚਾਰ ਸਧਾਰਨ ਸੀ:
ਇਸ ਡਿਜ਼ਾਈਨ ਨੇ Node.js ਨੂੰ ਖਾਸ ਤੌਰ 'ਤੇ ਸ਼ਬਦਾਂ-ਵਰਤੋਂ ਵਾਲੇ ਨੈੱਟਵਰਕ ਐਪਸ ਲਈ ਚੰਗਾ ਬਣਾਇਆ।
Node.js ਤੇਜ਼ੀ ਨਾਲ ਵਧਿਆ ਕਿਉਂਕਿ ਇਹ ਵੈੱਬ ਡਿਵੈਲਪਰਾਂ ਦੇ ਸੋਚਣ ਦੇ ਢੰਗ ਨਾਲ ਮਿਲਦਾ ਸੀ: ਹਰ ਥਾਂ JavaScript। ਥੋੜ੍ਹੇ ਹੀ ਸਮੇਂ ਬਾਅਦ, npm (Node package manager) ਨੇ ਕੋਡ ਸਾਂਝਾ ਅਤੇ ਦੁਬਾਰਾ ਵਰਤਣਾ ਆਸਾਨ ਕੀਤਾ। ਇਹ ਜੋੜ—ਮਸ਼ਹੂਰ ਭਾਸ਼ਾ + ਵੱਡਾ ਲਾਇਬ੍ਰੇਰੀ ਇਕੋਸਿਸਟਮ—Node ਨੂੰ ਇੱਕ ਰੁਝਾਨੀ ਪ੍ਰਯੋਗ ਤੋਂ ਪ੍ਰਮੁੱਖ ਟੂਲਿੰਗ ਤੱਕ ਲੈ ਗਿਆ।
ਅੱਜਕਲ Node.js ਅਕਸਰ:
ਇਹ ਵੈੱਬ ਜਾਂ ਮੋਬਾਈਲ ਐਪ ਦੇ ਪਿੱਛੇ ਹੋ ਸਕਦਾ ਹੈ, “backend for frontend” ਵਾਂਗ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਉਹਨਾਂ ਫਰੇਮਵਰਕਾਂ ਲਈ ਸਰਵਰ-ਸਾਈਡ ਰੈਂਡਰਿੰਗ ਚਲਾ ਸਕਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਇਸ ਦੀ ਲੋੜ ਹੋਵੇ।
Node.js ਨੂੰ ਅਕਸਰ “JavaScript runtime” ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ runtime ਸਿੱਧਾ ਉਹ ਵਾਤావਰਣ ਹੈ ਜੋ JavaScript ਕੋਡ ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਉਹ ਅਤਿ-ਸਹੂਲਤਾਂ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਸਧਾਰਨ JavaScript ਦੇ ਕੋਲ ਨਹੀਂ ਹੁੰਦੀਆਂ—ਜਿਵੇਂ ਫਾਇਲਾਂ ਪੜ੍ਹਨਾ, ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨ, ਜਾਂ ਹੋਰ ਪ੍ਰੋਗਰਾਮ ਸ਼ੁਰੂ ਕਰਨਾ।
Node.js ਦੇ ਕੇਂਦਰ ਵਿੱਚ V8 ਹੈ, ਜੋ Google Chrome ਦੁਆਰਾ ਵੀ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ JavaScript ਇੰਜਣ ਹੈ। V8 ਤੁਹਾਡੇ JavaScript ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਕਮਪਾਇਲ ਕਰਕੇ ਮਸ਼ੀਨ-ਲੇਵਲ ਹੁਕਮਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ।
ਜ਼ਰੂਰੀ ਗੱਲ: V8 Node.js ਨਹੀਂ ਹੈ। V8 ਭਾਸ਼ਾ ਚਲਾਉਣ 'ਤੇ ਧਿਆਨ ਦਿੰਦੀ ਹੈ। Node.js ਵਿਆਪਕ ਪੈਕੇਜ ਹੈ: V8 ਅਤੇ ਉਹ “glue” ਜੋ JavaScript ਨੂੰ ਤੁਹਾਡੇ ਓਐਸ ਨਾਲ ਜੋੜਦਾ ਹੈ।
Node.js ਨੂੰ ਸਰਵਰ-ਸਾਈਡ ਟੂਲ ਮਹਿਸੂਸ ਕਰਨ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਇਸਦੇ built-in ਮੌਡੀਊਲਾਂ (APIs) ਦੀ ਕਲੈਕਸ਼ਨ ਹੈ ਜੋ OS-ਸਤੰਭੀ ਫੀਚਰਾਂ ਨੂੰ JavaScript-ਮਿੱਤਰ ਢੰਗ ਨਾਲ ਖੋਲ੍ਹਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ:
ਜਦ ਤੁਸੀਂ fs.readFile(...) ਵਰਗਾ ਕੁਝ ਕਾਲ ਕਰਦੇ ਹੋ ਜਾਂ HTTP ਸਰਵਰ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, Node ਉਹ ਕੰਮ ਥੱਲੇਲੇ ਸਿਸਟਮ (ਅਤੇ ਨੈਟਿਵ ਲਾਇਬ੍ਰੇਰੀਜ਼) ਨੂੰ ਭੇਜਦਾ ਹੈ ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਤੁਹਾਡੇ JavaScript ਕੋਡ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
JavaScript ਭਾਸ਼ਾ ਹੈ: ਸਿੰਟੈਕਸ, ਵੈਰੀਏਬਲ, ਫੰਕਸ਼ਨ ਆਦਿ।
Node.js ਇੱਕ ਥਾਂ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਉਹ ਭਾਸ਼ਾ ਚਲਾ ਸਕਦੇ ਹੋ—ਖ਼ਾਸ ਕਰਕੇ ਉਹ ਥਾਂ ਜੋ ਕਮਾਂਡ-ਲਾਈਨ ਟੂਲ ਅਤੇ ਬੈਕਐਂਡ ਸਰਵਿਸਾਂ ਬਣਾਉਣ ਲਈ ਬਣਾਈ ਗਈ ਹੈ, ਅਤੇ ਜਿਸ ਨੂੰ ਮਸ਼ੀਨ-ਲੈਵਲ ਪਹੁੰਚ ਮਿਲਦੀ ਹੈ। ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ JavaScript ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ APIs (DOM, window) ਮਿਲਦੇ ਹਨ। Node ਵਿੱਚ ਉਸਦੀ ਜਗ੍ਹਾ Node APIs (filesystem, network, processes) ਹਨ।
ਜਦ ਲੋਕ ਕਹਿੰਦੇ ਨੇ Node.js “asynchronous” ਹੈ, ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਮੰਨਦੇ ਹਨ ਕਿ ਇਹ ਉਡੀਕ ਕਰਨਾ ਬਿਨਾਂ ਸਮਾਂ ਗਵਾਉਂਦੇ ਚੰਗਾ ਕਰਦਾ ਹੈ।
ਕਲੱਪ ਕਰੋ ਕਿ ਤੁਸੀਂ ਰਾਤ ਦਾ ਖਾਣਾ ਬਣਾ ਰਹੇ ਹੋ ਅਤੇ ਇਕ ਪਾਤੀ ਵਿੱਚ ਪਾਣੀ ਉਬਾਲਣ ਲਈ ਰੱਖਿਆ। ਤੁਸੀਂ ਉਥੇ ਖੜੇ ਹੋ ਕੇ ਇਸਨੂੰ ਉਬਲਣ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਦੇ—ਤੁਸੀਂ ਸਬਜ਼ੀਆਂ ਕੱਟਦੇ ਹੋ, ਮੇਜ਼ ਸੈੱਟ ਕਰਦੇ ਹੋ ਅਤੇ ਸੌਸ ਵੇਖਦੇ ਹੋ। ਜਦ ਪਾਣੀ ਤਿਆਰ ਹੁੰਦਾ ਹੈ, ਤੁਸੀਂ ਰਿਆਕਟ ਕਰਦੇ ਹੋ।
ਸਰਵਰ-ਕਾਜ ਆਮਤੌਰ 'ਤੇ ਐਹੋ-ਜਿਹਾ ਹੁੰਦਾ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਕੁਝ ਮੰਗਦਾ ਹੈ ਜੋ ਸਮਾਂ ਲੈਂਦਾ ਹੈ (ਫਾਇਲ ਪੜ੍ਹਨਾ, ਡੇਟਾਬੇਸ ਕ੍ਵੇਰੀ, ਬਾਹਰੀ API), ਫਿਰ ਨਤੀਜੇ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ। ਕਈ ਸਿਸਟਮਾਂ ਵਿੱਚ, ਇਹ ਉਡੀਕ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ "ਬਲਾਕ" ਕਰ ਸਕਦੀ ਹੈ। Node.js ਇਸ ਤਰ੍ਹਾਂ ਬਲਾਕ ਹੋਣ ਤੋਂ ਬਚਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।
ਇਵੈਂਟ ਲੂਪ ਟਾਸਕਾਂ ਲਈ ਟ੍ਰੈਫਿਕ ਕੰਟਰੋਲਰ ਵਾਂਗ ਹੈ। ਬੇਨਤੀਆਂ ਅਤੇ callbacks ਲਾਈਨ ਵਿੱਚ ਖੜੇ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਇਵੈਂਟ ਲੂਪ ਨਿਰਣਾ ਕਰਦਾ ਹੈ ਕਿ ਅਗਲਾ ਕੀ ਚੱਲੇ। ਜੇ ਕੋਈ ਟਾਸਕ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਫਿਰ ਉਡੀਕ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ (ਜਿਵੇਂ I/O), Node ਉਸਨੂੰ ਸਿਸਟਮ ਨੂੰ ਸੌਂਪ ਦਿੰਦਾ ਹੈ, ਹੋਰ ਕੰਮ ਚਲਾਉਂਦਾ ਹੈ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਨਤੀਜਾ ਆਉਣ 'ਤੇ ਸੂਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਇਸ ਲਈ Node.js ਸਰਵਰ ਬਹੁਤ ਸਾਰੀਆਂ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਸੰਭਾਲ ਸਕਦਾ ਹੈ: ਇਹ ਹਰ ਧੀਮੀ ਡਿਸਕ ਪੜ੍ਹਾਈ ਜਾਂ ਨੈੱਟਵਰਕ ਜਵਾਬ ਲਈ ਇੱਕ ਥ੍ਰੈਡ ਬੰਦ ਨਹੀਂ ਰੱਖਦਾ।
“Non-blocking I/O” ਦਾ ਸਧਾਰਨ ਮਤਲਬ ਹੈ: ਛੇਤੀ-ਹੈਲ ਕਰਨ ਵਾਲੀ ਕਾਰਵਾਈ ਸ਼ੁਰੂ ਕਰੋ, ਫਿਰ ਜਦ ਤੱਕ ਇਹ ਖਤਮ ਨਹੀਂ ਹੁੰਦੀ ਹੋਰ ਚੀਜ਼ਾਂ ਕਰੋ। ਜਦ ਇਹ ਖਤਮ ਹੁੰਦਾ ਹੈ, Node ਤੁਹਾਡਾ ਅਗਲਾ ਕੋਡ ਚਲਾਉਂਦਾ ਹੈ (ਆਮ ਤੌਰ 'ਤੇ callback, promise resolution, ਜਾਂ async/await ਦੇ ਜਾਰੀ ਰੂਪ ਰਾਹੀਂ)।
ਇਹ ਢੰਗ I/O-ਭਾਰੀ ਵਰਕਲੋਡ ਲਈ ਚਮਕਦਾ ਹੈ, ਪਰ ਇਹ ਹਰ ਚੀਜ਼ ਲਈ ਜਾਦੂ ਨਹੀਂ ਹੈ। ਜੇ ਤੁਸੀਂ main thread 'ਤੇ ਕੋਈ ਵੱਡਾ CPU-ਭਾਰ ਵਾਲਾ ਕੈਲਕੂਲੇਸ਼ਨ ਚਲਾਉਂਦੇ ਹੋ (ਜਿਵੇਂ ਇਮੇਜ ਪ੍ਰੋਸੈਸਿੰਗ, ਵੱਡਾ ਇਨਕ੍ਰਿਪਸ਼ਨ ਕੰਮ, ਜਾਂ ਭਾਰੀ ਡਾਟਾ ਕ੍ਰੰਚਿੰਗ), ਤਾਂ ਇਹ ਹੋਰ ਸਭ ਕੁਝ ਸੁਸਤ ਕਰ ਸਕਦਾ ਹੈ—ਕਿਉਂਕਿ ਇਵੈਂਟ ਲੂਪ ਉਹ ਟਾਸਕ ਜੋ CPU ਵਰਤ ਰਿਹਾ ਹੈ ਉਸਨੂੰ "ਛੱਡ" ਨਹੀਂ ਸਕਦਾ।
Node.js ਆਮਤੌਰ 'ਤੇ ਸਰਵਰ-ਸਾਈਡ ਸੌਫਟਵੇਅਰ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ: APIs ਜੋ ਵੈੱਬ ਜਾਂ ਮੋਬਾਈਲ ਐਪ ਨੂੰ ਡੇਟਾ ਦਿੰਦੇ ਹਨ, ਬੈਕਗ੍ਰਾਊਂਡ ਜੋਬਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਦੇ ਹਨ, ਅਤੇ ਵੈੱਬ ਸਰਵਰ ਜੋ ਪੇਜ ਅਤੇ ਡਾਟਾ ਡਿਲੀਵਰ ਕਰਦੇ ਹਨ।
ਕਿਉਂਕਿ Node.js ਉਡੀਕ ਕਰਨ ਦੇ ਬਦਲੇ ਹੋਰ ਕੰਮ ਕਰਨ ਵਿੱਚ ਵਧੀਆ ਹੈ, ਇਹ ਉਨ੍ਹਾਂ ਸਥਿਤੀਆਂ ਲਈ ਜ਼ਿਆਦਾ ਪਸੰਦੀਦਾ ਹੈ ਜਿੱਥੇ ਤੁਹਾਡਾ ਐਪ ਛੋਟੇ I/O ਕੰਮ (ਡੇਟਾਬੇਸ ਪੜ੍ਹਾਈ, ਹੋਰ ਸੇਵਾਵਾਂ ਨੂੰ ਕਾਲ, ਸੁਨੇਹੇ ਭੇਜਣਾ) ਕਰਦਾ ਹੈ ਬਦਲੇ ਹੋਏ ਭਾਰੀ ਗਣਿਤ ਦੇ।
ਕੁਝ ਜਗ੍ਹਾਂ ਜਿੱਥੇ Node.js ਬਹੁਤ ਵਰਤੀ ਜਾਂਦੀ ਹੈ:
Node.js ਬੇਹਤਰ ਹੈ ਜਦ:
Node.js ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਡਿਵੈਲਪਰ ਟੂਲ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਬਿਲਡ ਸਕ੍ਰਿਪਟ, ਟਾਸਕ ਰਨਰ, ਅਤੇ CLI ਟੂਲ। ਬਹੁਤ ਸਾਰੀਆਂ ਆਧੁਨਿਕ ਫਰੰਟ-ਐਂਡ ਵਰਕਫਲੋਜ਼ Node-ਅਧਾਰਿਤ ਟੂਲਿੰਗ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ ਭਾਵੇਂ ਅਖ਼ੀਰਕਾਰ ਐਪ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲੇ।
Node.js ਆਮਤੌਰ 'ਤੇ ਲੰਬੇ, CPU-ਭਾਰੀ ਗਣਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਚੋਣ ਨਹੀਂ ਹੈ (ਜਿਵੇਂ ਜਟਿਲ ਵੀਡੀਓ ਰੈਂਡਰਿੰਗ ਜਾਂ ਵੱਡੇ ਵਿਗਿਆਨਕ ਕੈਲਕੂਲੇਸ਼ਨ) ਕਿਉਂਕਿ ਉਹ ਪ੍ਰੋਸੈੱਸ ਨੂੰ ਬਲਾਕ ਕਰ ਸਕਦੇ ਹਨ। ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਟੀਮਾਂ ਅਕਸਰ ਕੰਮ ਨੂੰ ਵੱਖਰੇ ਸਰਵਿਸ, ਬੈਕਗ੍ਰਾਊਂਡ ਵਰਕਰ ਜਾਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ 'ਚ ਆਊਟਸੋਰਸ ਕਰਦੀਆਂ ਹਨ।
JavaScript ਭਾਸ਼ਾ ਹੈ। Node.js ਅਤੇ ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਦੋ ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣ ਹਨ ਜੋ ਉਸ ਭਾਸ਼ਾ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹਨ।
ਜੇ ਤੁਸੀਂ JavaScript ਦੇ ਮੁੱਢਲੇ ਗਿਆਨ (variables, functions, objects, async/await, promises) ਜਾਣਦੇ ਹੋ, ਤਾਂ ਉਹ ਧਾਰਣਾਵਾਂ ਸਿੱਧਾ ਬਦਲ ਕੇ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ। ਬਦਲਾਂ ਇਹ ਹਨ ਕਿ ਤੁਹਾਡਾ ਕੋਡ ਕੀ ਤੱਕ ਪਹੁੰਚ ਸਕਦਾ ਹੈ।
ਬ੍ਰਾਊਜ਼ਰ JavaScript UI ਬਣਾਉਣ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਸਨੂੰ DOM (ਪੇਜ), ਕਲਿਕ ਅਤੇ ਟਾਈਪਿੰਗ ਤੋਂ ਆਉਣ ਵਾਲੇ ਇਵੈਂਟ, ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ APIs ਜਿਵੇਂ localStorage, cookies, ਅਤੇ permissions-ਅਧਾਰਤ Web APIs ਮਿਲਦੇ ਹਨ।
ਇਹ ਸਖ਼ਤ ਤੌਰ 'ਤੇ sandboxed ਵੀ ਹੈ: ਵੈੱਬ ਪੇਜ਼ ਆਮ ਤੌਰ 'ਤੇ ਤੁਹਾਡੇ ਕੰਪਿਊਟਰ ਦੀਆਂ ਫਾਇਲਾਂ ਨਹੀਂ ਪੜ੍ਹ ਸਕਦੇ ਜਾਂ ਜਿਥੇ ਚਾਹੁੰਦੇ ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨ ਨਹੀਂ ਖੋਲ੍ਹ ਸਕਦੇ। ਬ੍ਰਾਊਜ਼ਰ ਸੁਰੱਖਿਆ ਹੱਦਾਂ ਲਗਾਉਂਦਾ ਹੈ।
Node.js ਦਾ ਮੁੱਖ ਲਕਸ਼ server-side JavaScript ਚਲਾਉਣਾ ਹੈ—ਅਕਸਰ ਸਰਵਰ 'ਤੇ। ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਸਿਸਟਮ-ਪੱਧਰੀ ਸ਼ਕਤੀ ਦਿੰਦਾ ਹੈ, ਜਿਵੇਂ:
process.env (ਸਿਕ੍ਰੈਟ ਅਤੇ ਕੰਫਿਗ ਸੰਭਾਲੋ)ਇਹ ਵਾਧੂ ਤਾਕਤ ਵੱਖਰੀ ਸੁਰੱਖਿਆ ਉਮੀਦਾਂ ਨਾਲ ਆਉਂਦੀ ਹੈ। Node ਐਪਸ ਉਹਨਾਂ ਤਰ੍ਹਾਂ sandboxed ਨਹੀਂ ਹੁੰਦੀਆਂ ਜਿਵੇਂ ਬ੍ਰਾਊਜ਼ਰ। ਜੇ Node ਪ੍ਰੋਸੈੱਸ ਨੂੰ ਫਾਇਲ ਪੜ੍ਹਨ ਜਾਂ ਨੈੱਟਵਰਕ ਨਾਲ ਜੋੜਨ ਦੀ ਅਨੁਮਤੀ ਹੈ, ਤਾਂ ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਕਰ ਸਕਦਾ ਹੈ—ਇਸ ਲਈ ਸਰਵਰ ਸੁਰੱਖਿਆ ਪ੍ਰਥਾਵਾਂ ਜਿਵੇਂ access control, secret management, ਅਤੇ dependency hygiene ਲਾਜ਼ਮੀ ਹਨ।
ਬ੍ਰਾਊਜ਼ਰ JS ਤੁਹਾਨੂੰ front end ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ (ਜੋ ਯੂਜ਼ਰ ਵੇਖਦਾ ਹੈ)। Node.js ਤੁਹਾਨੂੰ back end ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ (ਪਿੱਛੇ ਚੱਲ ਰਹੀ ਲੋਜਿਕ)। ਭਾਸ਼ਾ ਇੱਕ ਹੀ—ਓਜ਼ਾਰ ਤੇ ਜਿੰਮੇਵਾਰੀਆਂ ਵੱਖਰੀਆਂ।
Node.js ਦੇ ਤੇਜ਼ੀ ਨਾਲ ਫੈਲਣ ਦਾ ਇੱਕ ਵੱਡਾ ਕਾਰਨ npm ਹੈ, ਜੋ Node ਨਾਲ ਆਉਂਦਾ ਹੈ। npm ਨੂੰ ਇੱਕ ਆਸਾਨ ਤਰੀਕੇ ਵਜੋਂ ਸੋਚੋ ਜੋ ਤੁਹਾਨੂੰ ਤੁਹਾਡੇ ਐਪ ਲਈ ਤਿਆਰ-ਬਣੇ ਹਿੱਸੇ (building blocks) ਡਾਊਨਲੋਡ, ਅਪਡੇਟ ਅਤੇ ਸਾਂਝੇ ਕਰਨ ਦਿੰਦਾ ਹੈ।
Node.js ਵਿੱਚ, ਇੱਕ ਪੈਕੇਜ (ਜਿਸਨੂੰ module ਵੀ ਕਹਿੰਦੇ ਹਨ) ਇੱਕ ਦੁਬਾਰਾ ਵਰਤਣ ਯੋਗ ਕੋਡ ਦਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ ਜੋ ਕਿਸੇ ਖਾਸ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਦਿੰਦਾ ਹੈ—ਤਾਰੀਖਾਂ ਨੂੰ parse ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਤਕ।
ਸਭ ਕੁਝ ਸ਼ੁਰੂ ਤੋਂ ਲਿਖਣ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਇੱਕ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੁਰੰਤ ਵਰਤ ਸਕਦੇ ਹੋ। ਇਹ ਵਿਕਾਸ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਉਹ ਕੋਡ ਵਰਤਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦਾ ਹੈ ਜੋ ਹੋਰ ਲੋਗ ਵੇਖ ਚੁੱਕੇ ਹਨ।
ਜ਼ਿਆਦਾਤਰ Node ਪ੍ਰੋਜੈਕਟਾਂ ਦੀ ਰੂਟ 'ਤੇ ਇੱਕ package.json ਫਾਇਲ ਹੁੰਦੀ ਹੈ। ਇਹ ਪ੍ਰੋਜੈਕਟ ਦੀ “ਖਰੀਦਦਾਰੀ ਸੂਚੀ” ਅਤੇ ਮੈਟਾਡੇਟਾ ਕਾਰਡ ਹੈ।
ਇਸ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਸ਼ਾਮਿਲ ਹੁੰਦਾ ਹੈ:
npm run start ਜਾਂ npm testਜਦ ਤੁਸੀਂ npm install ਚਲਾਉਂਦੇ ਹੋ, npm package.json ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ, ਸਹੀ ਵਰਜਨਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ node_modules ਫੋਲਡਰ ਵਿੱਚ ਰੱਖਦਾ ਹੈ।
npm ਰਜਿਸਟਰੀ ਬਹੁਤ ਵੱਡਾ ਹੈ, ਜੋ ਇੱਕ ਵਧੀਆ ਗੱਲ ਹੈ—ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਚੁਣਦਗੀ ਨਾਲ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਪਸੰਦ ਕਰੋ ਉਹ ਪੈਕੇਜ ਜੋ ਐਕਟਿਵ ਤੌਰ 'ਤੇ maintain ਹੁੰਦੇ ਹਨ (ਹਾਲੀਆ ਅਪਡੇਟ, ਸਾਫ਼ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ, ਸਵਾਸਥ issue tracker). ਕਿਸੇ ਵੀ ਰੈਂਡਮ snippet ਦੀ ਤਰ੍ਹਾਂ copy-paste install ਕਮਾਂਡ ਨੂੰ ਬਿਨਾਂ ਸਮਝੇ ਨਾ ਚਲਾਓ। ਜੇ ਕੋਈ ਪੈਕੇਜ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਟਾਸਕ ਲਈ ਬਹੁਤ ਵੱਡਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਛੋਟਾ ਜਾਂ built-in ਵਿਕਲਪ ਸੁਰੱਖਿਅਤ ਹੋ ਸਕਦਾ ਹੈ।
Node.js ਤੁਹਾਨੂੰ ਬੁਨਿਆਦੀ ਬਿਲਡਿੰਗ ਬਲਾਕ ਦਿੰਦਾ ਹੈ: ਬੇਨਤੀਆਂ ਸੰਭਾਲੋ, ਜਵਾਬ ਭੇਜੋ, ਫਾਇਲਾਂ ਪੜ੍ਹੋ, ਡੇਟਾਬੇਸ ਨਾਲ ਗੱਲ ਕਰੋ ਆਦਿ। ਇੱਕ ਫਰੇਮਵਰਕ ਉਹ ਤਯਾਰ ਪੈਟਰਨ ਅਤੇ ਹੈਲਪਰਾਂ ਦਾ ਸੈੱਟ ਹੁੰਦਾ ਹੈ ਜੋ Node.js ਦੇ ਉੱਪਰ ਬੈਠਦਾ ਹੈ ਤਾਂ ਜੋ ਉਹ ਬਿਲਡਿੰਗ ਬਲਾਕ ਇੱਕ ਸਾਫ਼ ਢਾਂਚੇ ਵਿੱਚ ਰੱਖੇ ਜਾਂ।
Express ਅਕਸਰ ਪਹਿਲਾ Node.js ਫਰੇਮਵਰਕ ਹੁੰਦਾ ਹੈ ਜੋ ਲੋਕ ਸਿੱਖਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਛੋਟਾ, ਲਚਕੀਲਾ ਅਤੇ ਵਿਉਂਤ-ਵਰਤੋਂ ਵਾਲਾ ਹੈ।
Express ਨਾਲ, ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ:
/products ਤੇ ਆਉਂਦਾ ਹੈ, ਇਹ ਕੋਡ ਚਲਾਓ”ਇਹ ਕੋਈ ਕਠੋਰ ਪ੍ਰੋਜੈਕਟ ਲੇਆਉਟ ਫੋਰਸ ਨਹੀਂ ਕਰਦਾ—ਜੋ ਸੀਖਣ ਅਤੇ ਛੋਟੇ ਐਪਾਂ ਲਈ ਵਧੀਆ ਹੈ।
ਜੇ ਤੁਸੀਂ Express ਦੀ ਸਧਾਰਣਤਾ ਨੂੰ ਪਸੰਦ ਕਰਦੇ ਹੋ ਪਰ ਤੇਜ਼ੀ ਅਤੇ ਆਧੁਨਿਕ defaults ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Fastify ਇੱਕ ਲੋਕਪ੍ਰਿਯ ਵਿਕਲਪ ਹੈ।
ਜੇ ਤੁਸੀਂ ਜ਼ਿਆਦਾ opinionated, “batteries-included” ਤਰੀਕੇ ਨੂੰ ਪਸੰਦ ਕਰਦੇ ਹੋ—ਖ਼ਾਸ ਕਰਕੇ ਵੱਡੀਆਂ ਟੀਮਾਂ ਲਈ—NestJS ਆਮ ਹੈ। ਇਹ structured architecture (controllers, services, modules) ਨੂੰ ਉਤਸ਼ਾਹ ਦਿੰਦਾ, ਜੋ ਵੱਡੇ ਕੋਡਬੇਸ ਨੂੰ ਮੈਨੇਜ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
ਜਦ ਤੁਸੀਂ ਬਹੁਤ ਛੋਟੀ ਚੀਜ਼ (ਤੇਜ਼ webhook, ਛੋਟਾ internal ਟੂਲ) ਬਣਾਉਂਦੇ ਹੋ ਜਾਂ ਜਦ ਤੁਹਾਨੂੰ ਜ਼ਿਆਦਾ ਕੰਟਰੋਲ ਅਤੇ ਘੱਟ ਨਿਰਭਰਤਾ ਚਾਹੀਦੀ ਹੈ, ਤਾਂ ਸਿਰਫ Node.js ਵਰਤੋ।
ਜਦ ਤੁਹਾਨੂੰ ਕਈ ਰੂਟ, ਦੁਹਰਾਈ ਵਾਲੀ ਬੇਨਤੀ-ਹੈਂਡਲਿੰਗ ਲੋਜਿਕ, ਜਾਂ ਐਸਾ ਪ੍ਰੋਜੈਕਟ ਜੋ ਵਧੇਗਾ, ਫਰੇਮਵਰਕ ਚੁਣੋ। ਫਰੇਮਵਰਕ ਦੀ ਬਣਤਰ ਤੁਹਾਡਾ ਸਮਾਂ ਬਚਾਉਂਦੀ ਹੈ ਅਤੇ ਜਟਿਲਤਾ ਨੂੰ ਕੰਟਰੋਲ ਵਿੱਚ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ।
Node.js ਲੋਕਪ੍ਰਿਯ ਹੈ ਕਿਉਂਕਿ ਇਹ JavaScript ਨੂੰ ਸਰਵਰ-ਸਾਈਡ ਕੰਮ ਲਈ ਪ੍ਰਯੋਗਿਕ ਬਣਾਉਂਦਾ—ਖ਼ਾਸ ਕਰਕੇ ਜਦ ਤੁਹਾਡਾ ਐਪ ਸਭ ਤੋਂ ਵੱਧ ਸਮਾਂ ਨੈੱਟਵਰਕ ਜਾਂ ਡੇਟਾਬੇਸ ਜਵਾਬ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ।
ਇੱਕ ਵੱਡਾ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਫਰੰਟੈਂਡ ਤੇ ਬੈਕਐਂਡ ਦੋਨੋ ਵਿੱਚ ਇੱਕ ਹੀ ਭਾਸ਼ਾ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਟੀਮਾਂ ਗਿਆਨ ਸਾਂਝਾ ਕਰ ਸਕਦੀਆਂ ਹਨ, validation logic reuse ਕਰ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਇੱਕ ਸਥਿਰ tooling ਸੈਟ ਰੱਖ ਸਕਦੀਆਂ ਹਨ।
Node.js I/O ਲਈ ਤੇਜ਼ ਹੈ। ਜੇ ਤੁਹਾਡਾ ਐਪ ਬਹੁਤ ਸਾਰੀਆਂ ਸੰਮੋਕਤ ਬੇਨਤੀਆਂ ਸੰਭਾਲਦਾ ਹੈ—APIs, ਰੀਅਲ-ਟਾਈਮ ਅੱਪਡੇਟ, ਚੈਟ, ਡੈਸ਼ਬੋਰਡ—ਤਾਂ Node ਦੀ non-blocking ਦ੍ਰਿਸ਼ਟੀ ਲਾਗਤ ਅਤੇ ਪ੍ਰਭਾਵ ਲਈ ਚੰਗੀ ਹੋ ਸਕਦੀ ਹੈ।
ਅਖ਼ੀਰਕਾਰ, ecosystem ਵੱਡਾ ਹੈ। npm ਤੇ ਲਗਭਗ ਹਰ ਚੀਜ਼ ਲਈ ਪੈਕੇਜ ਹਨ: ਵੈੱਬ ਸਰਵਰ, authentication, ਫਾਇਲ ਅੱਪਲੋਡ, payments, testing ਆਦਿ। ਜਦ ਤੁਸੀਂ ਸਿਆਣਾ ਚੋਣ ਕਰਦੇ ਹੋ, ਇਹ ਡਿਲਿਵਰੀ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ।
Dependencies ਜਟਿਲ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਆਧੁਨਿਕ Node ਪ੍ਰੋਜੈਕਟ ਸੈਂਕੜਿਆਂ (ਜਾਂ ਹਜ਼ਾਰਾਂ) transitively ਨਿਰਭਰ ਪੈਕੇਜ ਖਿੱਚ ਸਕਦੇ ਹਨ। ਇਹ ਅਪਡੇਟ ਕੰਮ, ਸੁਰੱਖਿਆ ਰੀਵਿਊ ਅਤੇ ਸੰਭਾਵਿਤ ਟਕਰਾਅ ਦੀ ਸੰਭਾਵਨਾ ਵਧਾਉਂਦਾ ਹੈ।
Async ਸਿੱਖਣ ਦਾ ਕਰਵ ਚੁਲਾਂ ਉੱਪਰ ਹੁੰਦਾ ਹੈ। JavaScript ਦੀ asynchronous ਸ਼ੈਲੀ (Promises, async/await, ਪੁਰਾਣਾ ਕੋਡ ਵਿੱਚ callbacks) ਤਾਕਤਵਰ ਹੈ, ਪਰ ਜੇ ਕੋਡ ਦਾ ਢਾਂਚਾ ਚੰਗਾ ਨਾ ਹੋਵੇ ਤਾਂ ਪੱਧਰ-ਥਲ ਸੰਕਲਪ ਘੁੰਮਾਉਦਾ ਹੋ ਸਕਦਾ ਹੈ।
Node.js CPU-ਭਾਰੀ ਟਾਸਕਾਂ ਲਈ ਸਧਾਰਨ ਚੋਣ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਟਾਸਕਾਂ ਲਈ workers, queues, ਜਾਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ 'ਤੇ ਨਿਰਭਰ ਹੋ ਸਕਦੇ ਹੋ ਤਾਂ ਕਿ ਐਪ ਰਿਸਪਾਂਸਿਵ ਰਹੇ।
ਕਈ ਟੀਮ TypeScript ਵਰਤਦੀਆਂ ਹਨ ਤਾਂ ਕਿ Node ਪ੍ਰੋਜੈਕਟ ਮੈਨੇਜ਼ ਕਰਨ ਯੋਗ ਰਹਿਣ। Types ਗਲਤੀਆਂ ਪਹਿਲਾਂ ਫੜ ਲੈਂਦੇ ਹਨ, autocomplete ਸੁਧਾਰਦਾ ਹੈ, ਅਤੇ ਰੀਫੈਕਟਰਿੰਗ ਸੁਰੱਖਿਅਤ ਬਣਦੀ ਹੈ—ਜਦ ਕੋਡਬੇਸ ਅਤੇ ਟੀਮ ਵਧਦੀ ਹੈ ਤਾਂ ਇਹ ਬਹੁਤ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ।
ਨਿਸ਼ਕਰਸ਼: Node.js ਦੇ ਫਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵਰਕਲੋਡ, ਟੀਮ ਦੇ ਅਨੁਭਵ ਅਤੇ dependencies/ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਕਿੰਨੀ ਸਖ਼ਤੀ ਨਾਲ ਕੰਮ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।
Node.js ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਕੁਝ ਤੁਹਾਡੇ ਮਸ਼ੀਨ 'ਤੇ Node runtime ਇੰਸਟਾਲ ਕਰਨ ਬਾਰੇ ਹੈ ਤਾਂ ਕਿ ਤੁਹਾਡੀ ਮਸ਼ੀਨ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਬਾਹਰ JavaScript ਚਲਾ ਸਕੇ।
ਜਦ ਤੁਸੀਂ Node.js ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ, ਤੁਸੀਂ ਇੰਸਟਾਲ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹੋ:
ਸਰਵਰ 'ਤੇ ਵੀ ਇਹੀ ਕਹਾਣੀ ਹੈ: ਤੁਸੀਂ Node ਇੰਸਟਾਲ ਕਰਦੇ ਹੋ ਤਾਂ ਕਿ ਸਰਵਰ ਤੁਹਾਡਾ JavaScript ਐਪ ਚਲਾ ਸਕੇ—ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਲੰਮਾ ਚੱਲਣ ਵਾਲਾ ਪ੍ਰੋਸੈਸ ਵਜੋਂ।
Node ਰਿਲੀਜ਼ ਦੋ ਆਮ ਟਰੈਕ ਵਿੱਚ ਆਉਂਦੇ ਹਨ:
ਜੇ ਤੁਸੀਂ ਅਣਜਾਣ ਹੋ, ਤਾਂ LTS ਚੁਣੋ।
ਫਾਇਲ ਬਣਾਓ hello.js:\n
console.log("Hello from Node!");
ਫਿਰ ਚਲਾਓ:\n
node hello.js
import http from "node:http";
http.createServer((req, res) => {
res.writeHead(200, { "Content-Type": "text/plain" });
res.end("It works!\n");
}).listen(3000);
console.log("Server running on http://localhost:3000");
ਪ੍ਰੋਜੈਕਟ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਇੱਕ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ:\n
npm init -y
npm install express
ਜੇ ਤੁਹਾਡਾ ਮਕਸਦ Node.js ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਸਿੱਖਣਾ ਹੈ ਪਰ ਹਕੀਕਤ ਵਿੱਚ ਕੁਝ ਤੇਜ਼ੀ ਨਾਲ ਤਿਆਰ ਕਰਨਾ ਵੀ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਕ vibe-coding ਪਲੇਟਫਾਰਮ ਜਿਵੇਂ Koder.ai ਇੱਕ ਪ੍ਰਯੋਗਕਾਰੀ ਛੋਟਾ ਰਾਹ ਹੋ ਸਕਦਾ ਹੈ: ਤੁਸੀਂ ਚੈਟ ਵਿੱਚ ਐਪ ਦਾ ਵਰਣਨ ਕਰੋ (ਰੂਟ, ਡੇਟਾ ਮਾਡਲ, auth, UI), Planning Mode ਨਾਲ ਦੁਹਰਾਅ ਕਰੋ, ਅਤੇ ਜਦ ਤਿਆਰ ਹੋ ਜਾਓ ਤਾਂ ਸੋਭਾ ਕੋਡ export ਕਰੋ। ਇਹ Node ਨੂੰ ਸਮਝਣ ਦੀ ਜਗ੍ਹਾ ਨਹੀਂ ਲੈਂਦਾ—ਪਰ ਇਹ setup friction ਘੱਟ ਕਰ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ APIs ਅਤੇ async ਫਲੋਆਂ ਤੇ ਧਿਆਨ ਦੇ ਸਕੋ।
deploy ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਸੋਚਿਆ ਹੈ:
console.log ਨਹੀਂ)।Node.js ਬਾਰੇ ਕਈ ਮਜ਼ਬੂਤ ਰاءِ ਹੁੰਦੀਆਂ ਹਨ—ਅਕਸਰ ਅਧ-ਸੱਚ ਨੁਮੇਰੇ ਤੇ ਆਧਾਰਿਤ। ਇੱਥੇ ਕੁਝ ਆਮ ਮਿਥ ਹਨ, ਸਧਾਰਨ ਭਾਸ਼ਾ ਵਿੱਚ ਸਮਝਾਏ ਗਏ।
ਉਹ ਸੰਬੰਧਿਤ ਹਨ, ਪਰ ਇੱਕੋ ਨਹੀਂ। Node.js ਉਹ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਤੁਹਾਡੇ ਕੰਪਿਊਟਰ/ਸਰਵਰ 'ਤੇ JavaScript ਚਲਾਂਦਾ ਹੈ (ਇੱਕ JavaScript runtime)। npm ਪੈਕੇਜ ਮੈਨੇਜਰ ਹੈ ਜੋ ਤੀਸਰੇ-ਪੱਖੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਡਾਊਨਲੋਡ ਅਤੇ ਮੈਨੇਜ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ (ਅਕਸਰ npm packages ਕਹਿੰਦੇ ਹਨ)।
Node ਨੂੰ ਛੋਟੀ ਟੀਮਾਂ ਅਤੇ ਵੱਡੀਆਂ ਕੰਪਨੀਆਂ ਦੋਨੋ ਵਰਤਦੇ ਹਨ। ਇਹ APIs, ਰੀਅਲ-ਟਾਈਮ ਫੀਚਰ, ਡਿਵੈਲਪਰ ਟੂਲ ਅਤੇ ਵੈੱਬ ਬੈਕਐਂਡ ਲਈ ਇਕ ਪ੍ਰਯੋਗਿਕ ਚੋਣ ਹੈ ਜਿੱਥੇ ਸਰਵਰ-ਸਾਈਡ JavaScript ਲਾਭਕਾਰੀ ਹੁੰਦੀ ਹੈ।
Node ਦਾ ਮੁੱਖ JavaScript ਐਕਜ਼ੀਕਿਊਸ਼ਨ ਇੱਕ ਥ੍ਰੈਡ 'ਤੇ ਚਲਦਾ ਹੈ, ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਇਹ ਥੱਲੇ-ਥੱਲੇ ਹੈ। ਮੁੱਖ ਵਿਚਾਰ non-blocking I/O ਹੈ: ਜਦ Node ਨੈੱਟਵਰਕ ਜਾਂ ਡਿਸਕ ਕੰਮ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ, ਉਹ ਹੋਰ ਬੇਨਤੀਆਂ ਸੰਭਾਲ ਸਕਦਾ ਹੈ।
CPU-ਭਾਰੀ ਟਾਸਕ (ਜਿਵੇਂ ਵੀਡੀਓ ਐਨਕੋਡਿੰਗ) ਫਿਰ ਵੀ ਇੱਕੋਂ JS ਥ੍ਰੈਡ ਲਈ ਅਚਛੇ ਨਹੀਂ ਹੁੰਦੇ—ਪਰ ਬਹੁਤ ਸਾਰੀਆਂ ਵੈੱਬ ਵਰਕਲੋਡ ਲਈ Node ਤੇਜ਼ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ।
Node ਪ੍ਰਮਾਣਿਤ, ਆਮ ਤਰੀਕੇ ਨਾਲ ਸਕੇਲ ਕਰਦਾ ਹੈ: ਤੁਸੀਂ multiple processes/instances ਚਲਾ ਸਕਦੇ ਹੋ ਅਤੇ ਟ੍ਰੈਫਿਕ ਨੂੰ ਵੰਡ ਸਕਦੇ ਹੋ (ਉਦਾਹਰਣ ਲਈ load balancer ਦੇ ਨਾਲ). ਇਹ ਉਹ ਤਰੀਕਾ ਹੈ ਜੋ ਕਈ ਪ੍ਰੋਡਕਸ਼ਨ Node ਸਿਸਟਮ ਉੱਚ ਟ੍ਰੈਫਿਕ ਲਈ ਵਰਤਦੇ ਹਨ।
ਕੋਈ ਵੀ ਟੂਲ ਵਿਸ਼ਵ-ਭਰ ਲਈ ਨਹੀਂ। Node ਵਧੀਆ ਹੈ ਜਦ ਤੁਸੀਂ end-to-end JavaScript ਚਾਹੁੰਦੇ ਹੋ, ecosystem ਵਿਕਲਪ ਲੋੜੀਂਦੇ ਹੋ, ਅਤੇ I/O-ਭਾਰੀ ਕਾਰਜ ਲਈ ਚੰਗੀ ਪ੍ਰਦਰਸ਼ਨ। ਜੇ ਤੁਹਾਡਾ ਪ੍ਰੋਜੈਕਟ ਮੁੱਖ ਤੌਰ 'ਤੇ CPU-ਭਾਰ ਵਾਲਾ ਹੈ ਜਾਂ ਖ਼ਾਸ runtime ਲੋੜਾਂ ਹਨ, ਤਾਂ ਹੋਰ ਸਟੈਕ ਬਿਹਤਰ ਹੋ ਸਕਦਾ ਹੈ।
Node.js JavaScript ਨੂੰ ਸਰਵਰ 'ਤੇ ਚਲਾਉਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਬੈਕਐਂਡ, ਟੂਲ ਅਤੇ ਸੇਵਾਵਾਂ ਨੂੰ ਉਸੇ ਭਾਸ਼ਾ ਨਾਲ ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ ਬਹੁਤ ਸਾਰੀਆਂ ਟੀਮ ਪਹਿਲਾਂ ਹੀ front end ਲਈ ਵਰਤਦੀਆਂ ਹਨ। ਇਹ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਜ਼ਿਆਦਾ ਚਮਕਦਾ ਹੈ ਜਿੱਥੇ ਤੁਹਾਡਾ ਐਪ ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ ਨੈੱਟਵਰਕ ਬੇਨਤੀਆਂ, ਡੇਟਾਬੇਸ ਜਾਂ ਫਾਈਲ ਅੱਪਲੋਡ ਵਰਗੀਆਂ ਉਡੀਕਾਂ ਵਿੱਚ ਬਿਤਾਂਦਾ ਹੈ।
Node.js ਚੁਣੋ ਜੇ ਤੁਸੀਂ ਬਣਾਉਣ ਵਾਲੇ ਹੋ:
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਨਿਯਮ: ਜੇ ਤੁਹਾਡਾ ਪ੍ਰੋਜੈਕਟ ਮੁੱਖ ਤੌਰ 'ਤੇ “ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਸੰਭਾਲੋ ਅਤੇ I/O ਦੇ ਕੋਆਰਡਿਨੇਟ ਕਰੋ” ਹੈ, ਤਾਂ Node.js ਆਮ ਤੌਰ 'ਤੇ ਮਜ਼ਬੂਤ ਚੋਣ ਹੈ।
ਵਿਕਲਪ ਬਾਰੇ ਸੋਚੋ (ਜਾਂ ਵਾਧੂ ਕੰਮ ਦੀ ਯੋਜਨਾ ਬਣਾਓ) ਜੇ:
Node.js ਹੁਣ ਵੀ ਕਈ ਮਾਮਲਿਆਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਅਕਸਰ worker threads, external services, ਜਾਂ ਕਿਸੇ ਹੋਰ runtime 'ਤੇ ਹਰਟ-ਪਾਥ ਲਈ ਨਿਰਭਰ ਹੋਵੋਗੇ।
ਚੰਗੀ ਪਹਿਲੀ ਪ੍ਰੋਜੈਕਟ: ਇੱਕ ਛੋਟਾ API ਜੋ ਤੁਹਾਨੂੰ ਨੋਟਸ ਜੋੜਨ ਅਤੇ ਲਿਸਟ ਕਰਨ ਦਿੰਦਾ ਹੈ।
POST /notes ਅਤੇ GET /notesਜੇ ਤੁਸੀਂ ਇਸ ਤਜਰਬੇ ਨੂੰ ਤੇਜ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕੋ ਹੀ ਵਿਚਾਰ ਨੂੰ Koder.ai 'ਚ ਵੀ prototype ਕਰ ਸਕਦੇ ਹੋ: endpoints ਅਤੇ ਡੇਟਾ ਫੀਲਡਾਂ ਦਾ ਵਰਣਨ ਕਰੋ, ਫਿਰ ਚੈਟ ਵਿੱਚ iterate ਕਰੋ ਜਦ ਤਕ ਵਿਹਾਰ ਥੋੜ੍ਹਾ ਹਥਿਆਰ ਨਹੀਂ ਹੋ ਜਾਂਦਾ।
ਜੇ ਤੁਸੀਂ ਅੱਗੇ ਵਧਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ ਥੀਮਾਂ Node.js ਨਾਲ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਮਿਲਦੀਆਂ ਹਨ:
Node.js ਇੱਕ runtime ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੰਪਿਊਟਰ ਜਾਂ ਸਰਵਰ 'ਤੇ JavaScript ਚਲਾਉਣ ਦਿੰਦਾ ਹੈ (ਸਿਰਫ਼ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਨਹੀਂ)।
ਇਹ ਆਮ ਤੌਰ 'ਤੇ APIs, ਵੈੱਬ ਸਰਵਰ, ਸਕ੍ਰਿਪਟਸ ਅਤੇ developer tooling ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਨਹੀਂ। JavaScript ਭਾਸ਼ਾ ਹੈ।
Node.js ਇੱਕ ਵਾਤਾਵਰਣ ਹੈ ਜੋ JavaScript ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਸਰਵਰ/OS-ਕੇਂਦਰਤ APIs (ਫਾਇਲਾਂ, ਨੈੱਟਵਰਕ, ਪ੍ਰੋਸੈੱਸ) ਮੁਹੱਈਆ ਕਰਵਾਂਦਾ ਹੈ।
ਨਹੀਂ। Node.js ਬੁਨਿਆਦ ਹੈ।
Express, Fastify, ਜਾਂ NestJS ਵਰਗੇ ਫਰੇਮਵਰਕ Node.js 'ਤੇ ਚਲਦੇ ਹਨ ਤਾਂ ਜੋ ਸਰਵਰ ਅਤੇ ਰੂਟਾਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਬਣਾਇਆ ਜਾ ਸਕੇ।
ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ, JavaScript ਮੁੱਖ ਰੂਪ ਨਾਲ ਪੇਜ (DOM, ਕਲਿਕ, UI) ਨਾਲ ਇੰਟਰਐਕਟ ਕਰਦਾ ਹੈ।
Node.js ਵਿੱਚ, JavaScript ਸਰਵਰ-ਸਾਈਡ ਅਤੇ ਸਿਸਟਮ ਟਾਸਕ ਕਰ ਸਕਦਾ ਹੈ ਜਿਵੇਂ:
ਇਵੈਂਟ ਲੂਪ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ Node ਐਪ ਰਿਸਪਾਂਸਿਵ ਰਹਿੰਦੀ ਹੈ।
ਇਹ ਹੌਲੀ-ਮੁੱਲੀ ਕਾਰਵਾਈਆਂ (ਜਿਵੇਂ ਨੈਟਵਰਕ ਜਾਂ ਡਿਸਕ I/O) ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਫਿਰ ਹੋਰ ਕੰਮ ਸੰਭਾਲਦਾ ਹੈ ਜਦ ਤੱਕ ਨਤੀਜਾ ਤਿਆਰ ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਜਦ ਨਤੀਜਾ ਆਉਂਦਾ ਹੈ, ਇਹ ਤੁਹਾਡੇ ਕੋਡ ਦੀ ਅਗਲੀ ਕੜੀ ਚਲਾਂਦਾ ਹੈ (callbacks, promises, ਜਾਂ async/await)।
ਜੇ ਤੁਸੀਂ ਨਵੇਂ ਹੋ ਜਾਂ ਪ੍ਰੋਡਕਸ਼ਨ 'ਤੇ deploy ਕਰ ਰਹੇ ਹੋ, ਤਾਂ LTS (Long-Term Support) ਚੁਣੋ।
LTS ਵਰਜ਼ਨ ਜ਼ਿਆਦਾ ਸਥਿਰ ਹੁੰਦੇ ਹਨ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਸੁਰੱਖਿਆ ਅਤੇ ਬਗ ਕੁਝ ਜਾਂਚਾਂ ਮਿਲਦੀਆਂ ਹਨ। “Current” ਸਿਰਫ ਉਹਨਾਂ ਲਈ ਚੰਗਾ ਹੈ ਜੋ ਨਵੇਂ ਫੀਚਰਾਂ ਦੀ ਜ਼ਰੂਰਤ ਰੱਖਦੇ ਹਨ ਅਤੇ ਅਕਸਰ ਅਪਡੇਟ ਕਰ ਸਕਦੇ ਹਨ।
ਇੱਕ ਫਾਇਲ ਬਣਾਓ, ਜਿਵੇਂ hello.js:
console.log("Hello from Node!");
ਫਿਰ ਚਲਾਓ:
node hello.js
Node.js ਆਮ ਤੌਰ 'ਤੇ I/O-ਭਾਰ ਵਾਲੇ ਕੰਮਾਂ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਪਰ CPU-ਭਾਰ ਵਾਲੇ ਟਾਸਕ ਮੈਨ ਥ੍ਰੈਡ ਨੂੰ ਬਲਾਕ ਕਰ ਸਕਦੇ ਹਨ।
ਜੇ ਤੁਹਾਨੂੰ ਵੀਡੀਓ ਐਨਕੋਡਿੰਗ, ਵੱਡੇ ਡਾਟਾ ਪਰੋਸੈਸਿੰਗ ਜਾਂ ਭਾਰੀ ਕ੍ਰਿਪਟੋ ਕਰਨੀਆਂ ਹਨ, ਤਾਂ ਸੋਚੋ ਕਿ:
Node ਇੱਕ ਹੀ ਥ੍ਰੈਡ 'ਤੇ ਮਾਰੂ JavaScript ਚਲਾਂਦਾ ਹੈ, ਪਰ ਇਹ ਇਸਦਾ ਮਤਲਬ ਨਹੀਂ ਕਿ ਇਹ ਧੀਮਾ ਹੈ।
ਮੁੱਖ ਗੱਲ non-blocking I/O ਹੈ: ਜਦ Node ਨੈੱਟਵਰਕ ਜਾਂ ਡਿਸਕ ਕੰਮ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ, ਉਹ ਹੋਰ ਬੇਨਤੀਆਂ ਸੰਭਾਲ ਸਕਦਾ ਹੈ।
ਅਮਲ ਵਿੱਚ, ਉੱਚ ਟ੍ਰੈਫਿਕ ਲਈ ਆਮ ਤਰੀਕੇ ਨਾਲ multiple instances/processes ਚਲਾਏ ਜਾਂਦੇ ਹਨ ਤੇ load balancer ਦੇ ਪਿੱਛੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।
npm ਨਾਲ ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਚੋਣ ਕਰਦੇ ਸਮੇਂ ਸਾਵਧਾਨ ਰਹੋ:
ਤੁਹਾਡਾ package.json ਦਰਸਾਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿਸ 'ਤੇ ਨਿਰਭਰ ਹੋ, ਤੇ npm install ਉਹਨਾਂ ਨੂੰ node_modules ਵਿੱਚ ਲਿਆ ਆਉਂਦਾ ਹੈ।