ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?'] ", 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? " ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \'] ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\nਟਾਇਪ ਬੇਨਤੀ = (); \\nਟਾਇਪ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\nਟਾਇਪ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਸਕਦੇ ਹੋ? ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\nਟਾਇਪ ਬੇਨਤੀ = (); \\nਟਾਇਪ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\nਟਾਇਪ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰ ਸਕਦੇ ਹੋ? \'", ਬੇਸ਼ਕ, ਇੱਥੇ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਆ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਤਿਆਰ ਕਰਦਾ ਹੈ।ਵੈੱਬ ਪੰਨੇ। \\n\\ਨਿਮਪੋਰਟ \'ਰੀਐਕਟ\' ਤੋਂ ਪ੍ਰਤੀਕਿਰਿਆ; \\n\\nਕੌਨਸਟ ਉਦਾਹਰਨ = () => {\\n ਰਿਟਰਨ (\\n <ਡਿਵੀ> \\n ਹੈਲੋ ਵਰਲਡ! \\n </ਡਿਵੀ> \\n); \\n; \\n\\ਨੇਕਸਪੋਰਟ ਡਿਫਾਲਟਉਦਾਹਰਨ; \\n\\n #!/usr/bin/env ਨੋਡ ", \'ਚੰਗਾ ਕੀਤਾ\'] ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\nਟਾਇਪ ਬੇਨਤੀ = (); \\nਟਾਇਪ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\nਟਾਇਪ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰ ਸਕਦੇ ਹੋ? \'", ਬੇਸ਼ਕ, ਇੱਥੇ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਆ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਤਿਆਰ ਕਰਦਾ ਹੈ।ਵੈੱਬ ਪੰਨੇ। \\n\\ਨਿਮਪੋਰਟ \'ਰੀਐਕਟ\' ਤੋਂ ਪ੍ਰਤੀਕਿਰਿਆ; \\n\\nਕੌਨਸਟ ਉਦਾਹਰਨ = () => {\\n ਰਿਟਰਨ (\\n <ਡਿਵੀ> \\n ਹੈਲੋ ਵਰਲਡ! \\n </ਡਿਵੀ> \\n); \\n; \\n\\ਨੇਕਸਪੋਰਟ ਡਿਫਾਲਟਉਦਾਹਰਨ; \\n\\n #!/usr/bin/env ਨੋਡ ", \'ਚੰਗਾ ਕੀਤਾ\', \'ਤੁਸੀਂ ਹੁਣੇ ਹੀ HTTP ਸਰਵਰ ਅਤੇ ਕਲਾਇੰਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਰਸਟ ਵਿੱਚ ਸੰਰਚਿਤ ਕੀਤਾ ਹੈ। ਸਰਵਰ ਕਰ ਸਕਦਾ ਹੈਇਸ ਦੀ ਵਰਤੋਂ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। \',\' ਜਾਣ ਬਾਰੇ ਕੀ? \'] ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\nਟਾਇਪ ਬੇਨਤੀ = (); \\nਟਾਇਪ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\nਟਾਇਪ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰ ਸਕਦੇ ਹੋ? \'", ਬੇਸ਼ਕ, ਇੱਥੇ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਆ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਤਿਆਰ ਕਰਦਾ ਹੈ।ਵੈੱਬ ਪੰਨੇ। \\n\\ਨਿਮਪੋਰਟ \'ਰੀਐਕਟ\' ਤੋਂ ਪ੍ਰਤੀਕਿਰਿਆ; \\n\\nਕੌਨਸਟ ਉਦਾਹਰਨ = () => {\\n ਰਿਟਰਨ (\\n <ਡਿਵੀ> \\n ਹੈਲੋ ਵਰਲਡ! \\n </ਡਿਵੀ> \\n); \\n; \\n\\ਨੇਕਸਪੋਰਟ ਡਿਫਾਲਟਉਦਾਹਰਨ; \\n\\n #!/usr/bin/env ਨੋਡ ", \'ਚੰਗਾ ਕੀਤਾ\', \'ਤੁਸੀਂ ਹੁਣੇ ਹੀ HTTP ਸਰਵਰ ਅਤੇ ਕਲਾਇੰਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਰਸਟ ਵਿੱਚ ਸੰਰਚਿਤ ਕੀਤਾ ਹੈ। ਸਰਵਰ ਕਰ ਸਕਦਾ ਹੈਇਸ ਦੀ ਵਰਤੋਂ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। \',\' ਜਾਣ ਬਾਰੇ ਕੀ? \',\' ਜਾਣ ਲਈ ਇੱਕ ਸਮਾਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜਿਸ ਨੂੰ golang.org/x/NAME_1/http ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਦੀ ਵਰਤੋਂ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।ਵੈੱਬ ਸਰਵਰ. \',\' ਜਾਓ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਲਿਖੋ \'] ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\n ਕਿਸਮ ਦੀ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਦਾ ਜਵਾਬ = (); \\n ਕਿਸਮ ਦੀ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰ ਸਕਦੇ ਹੋ? \'", ਬੇਸ਼ਕ, ਇੱਥੇ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਆ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਤਿਆਰ ਕਰਦਾ ਹੈ।ਵੈੱਬ ਪੰਨੇ। \\n\\ਨਿਮਪੋਰਟ \'ਰੀਐਕਟ\' ਤੋਂ ਪ੍ਰਤੀਕਿਰਿਆ; \\n\\nਕੌਨਸਟ ਉਦਾਹਰਨ = () => {\\n ਰਿਟਰਨ (\\n <ਡਿਵੀ> \\n ਹੈਲੋ ਵਰਲਡ! \\n </ਡਿਵੀ> \\n); \\n; \\n\\ਨੇਕਸਪੋਰਟ ਡਿਫਾਲਟਉਦਾਹਰਨ; \\n\\n #!/usr/bin/env ਨੋਡ ", \'ਚੰਗਾ ਕੀਤਾ\', \'ਤੁਸੀਂ ਹੁਣੇ ਹੀ HTTP ਸਰਵਰ ਅਤੇ ਕਲਾਇੰਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਰਸਟ ਵਿੱਚ ਸੰਰਚਿਤ ਕੀਤਾ ਹੈ। ਸਰਵਰ ਕਰ ਸਕਦਾ ਹੈਇਸ ਦੀ ਵਰਤੋਂ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। \',\' ਜਾਣ ਬਾਰੇ ਕੀ? \',\' ਜਾਣ ਲਈ ਇੱਕ ਸਮਾਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜਿਸ ਨੂੰ golang.org/x/NAME_1/http ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਦੀ ਵਰਤੋਂ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।ਵੈੱਬ ਸਰਵਰ. \',\' ਗੋ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਲਿਖੋ \',\' ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ ਗੋ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਂਦਾ ਹੈ।) \\n\\n ਫੰਕ ਮੇਨ () {\\n http.HandleFunc ("/", ਇੰਡੈਕਸ) \\n http.ListenAndServe (": 8000", ਨਿਲ) \\n\\n ਫੰਕ ਇੰਡੈਕਸ (w http.ResponseWriter, r * http.Request) {\\nfmt.Fprintf (ਡਬਲਯੂ, "ਹੈਲੋ, ਵਰਲਡ!") \\n} \\n\\n #!/usr/bin/env goruntime.org/x/NAME_1/http \',\' ਕੀ ਇਹ ਸਭ ਹੈ? \' ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?', ' [\'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ?\', \'ਜ਼ਰੂਰ, ਇੱਥੇ ਤੁਸੀਂ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਬੁਨਿਆਦੀ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹੋ। ਪਹਿਲਾਂ, ਅਸੀਂ ਦੱਸਾਂਗੇਜ਼ਰੂਰੀ ਰਸਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ। ਅਸੀਂ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਾਂਗੇਃਃ ਕਲਾਇੰਟ ਅਤੇਃ ਸਰਵਰ ਲਾਇਬ੍ਰੇਰੀਆਂ। \\n\\nextern ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹਣ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹ ਵਾਲੀ ਬੰਨ੍ਹਅਸੀਂ HTTP ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਵਾਂਗੇ। ਅਸੀਂ ਆਪਣੇ ਲਈ ਇੱਕ ਕਿਸਮ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ।ਬੇਨਤੀ, ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਰੱਖਣ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ, ਕਿਸਮ ਦਾ ਨਤੀਜਾ <HTTP:: ਰਿਸਪਾਂਸ ਬਾਡੀ, ਸੈਲਫ>। ਅਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ HTTP:: ਕਲਾਇੰਟ ਉਦਾਹਰਣ ਉੱਤੇ ਮੋਕੋ _ ਰੇਕ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲੋ। ਇਹ ਵਿਧੀ ਨਿਰਧਾਰਤ ਹੋਸਟ ਨੂੰ ਇੱਕ HTTP ਬੇਨਤੀ ਭੇਜੇਗੀ ਅਤੇਪੋਰਟ, ਅਤੇ ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਗਲਤੀ ਵਾਪਸ ਕਰੋ। \\n\\n// ਸਰਵਰ ਬੇਨਤੀ ਡਾਟਾ ਕਿਸਮ \\n// ਪ੍ਰਤੀਕਿਰਿਆ ਕਿਸਮ \\n// ਗਲਤੀ ਕਿਸਮ \\n ਕਿਸਮ ਬੇਨਤੀ = (); \\n ਕਿਸਮ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\n ਕਿਸਮਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ \\n ਪਰਿਵਰਤਨ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n//ਕਲਾਇੰਟ ਨੂੰ ਜਵਾਬ ਭੇਜੋ ਠੀਕ ਹੈ ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਆਪਣੀ ਬੇਨਤੀ, ਜਵਾਬ ਅਤੇ ਗਲਤੀ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ HTTP ਸਰਵਰ ਬਣਾਵਾਂਗੇ।ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਸਰਵਰ ਇੰਸਟੈਂਸ ਬਣਾ ਕੇ ਸ਼ੁਰੂ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਫੰਕਸ਼ਨ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਸਰਵਰ ਆਪਣੇ ਆਪ ਸਾਰੇ ਸਥਾਨਕ ਉੱਤੇ ਸੁਣ ਲਵੇਗਾ।ਇੰਟਰਫੇਸ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬੇ ਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰੋ। \\n\\nlet ਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\n ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ HTTP ਕਲਾਇੰਟ ਬਣਾਵਾਂਗੇ ਅਤੇ ਇਸ ਨਾਲ ਜੁਡ਼ਾਂਗੇ।ਸਰਵਰ। ਅਸੀਂ ਨਿਰਧਾਰਤ ਯੂਆਰਐਲ ਉੱਤੇ ਸਰਵਰ ਨਾਲ ਜੁਡ਼ਨ ਲਈ ਕਨੈਕਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਵਾਰ ਜੁਡ਼ਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਸਰਵਰ ਨੂੰ ਇੱਕ ਜਾਇਜ਼ ਬੇਨਤੀ ਭੇਜਾਂਗੇ।ਸਰਵਰ ਉਸ ਜਵਾਬ ਨਾਲ ਜਵਾਬ ਦੇਵੇਗਾ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਸੀ। \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nletਜਵਾਬ = result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \\n\\n ਵੈੱਬ ਸਰਵਰ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹਨ, ਹਾਲਾਂਕਿ ਉਹ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹਨ।ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਦੇ ਦ੍ਰਿਸ਼। ਇੱਕ ਵਾਸਤਵਿਕ ਸੰਸਾਰ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਸੁਰੱਖਿਆ, ਪ੍ਰਮਾਣਿਕਤਾ ਅਤੇ ਹੋਰ ਆਮ ਵੈੱਬ ਸਰਵਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਜੋਡ਼ਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ।ਤੁਹਾਡਾ ਕੰਮ? ", \'ਮੈਂ ਇੱਕ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ। ਮੇਰਾ ਕੰਮ ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦੇ ਹਨ।\', \'ਮੈਨੂੰ ਇੱਕ ਲਿਖੋ\'ਪ੍ਰੋਗਰਾਮ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰਦਾ ਹੈ \',\' ਜ਼ਰੂਰ, ਇੱਥੇ ਇੱਕ ਰਸਟ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐੱਚ. ਟੀ. ਐੱਮ. ਐੱਲ. ਵੈੱਬ ਪੇਜ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।HTTP:: ਸਰਵਰਃ: HttpServer; \\nse HTTP:: ਕਲਾਇੰਟ; \\n\\nਟਾਇਪ ਬੇਨਤੀ = (); \\nਟਾਇਪ ਪ੍ਰਤੀਕਿਰਿਆ = (); \\nਟਾਇਪ ਗਲਤੀ = (); \\n\\nfn ਹੈਂਡਲ _ ਬੇਨਤੀ (ਪਰਿਵਰਤਨ ਬੇਨਤੀਃ ਬੇਨਤੀ)-> ਨਤੀਜਾ <ਪ੍ਰਤੀਕਿਰਿਆ, ਗਲਤੀ> {\\n// ਇੱਕ ਪ੍ਰਤੀਕਿਰਿਆ ਬਣਾਓ \\n ਲੈੱਟ ਮਿਊਟ ਪ੍ਰਤੀਕਿਰਿਆ = "ਹੈਲੋ ਵਰਲਡ!"; \\n\\n// ਕਲਾਇੰਟ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਭੇਜੋ \\n ਠੀਕ ਹੈ (ਪ੍ਰਤੀਕਿਰਿਆ) \\n} \\n\\nletਸਰਵਰ = HttpServer:: ਨਵਾਂ (ਹੈਂਡਲ _ ਬੇਨਤੀ); \\n\\nlet ਕਲਾਇੰਟ = HTTP:: ਕਲਾਇੰਟਃਃ ਨਵਾਂ (); \\nlet ਨਤੀਜਾ = client.connect ("ਲੋਕਲਹੋਸਟਃ 5000")?; \\nlet ਜਵਾਬ =result.send (""). ਉਮੀਦ ("ਬੇਨਤੀ ਸਫਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ"); \',\' ਕੀ ਤੁਸੀਂ ਵੀ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰ ਸਕਦੇ ਹੋ? \'", ਬੇਸ਼ਕ, ਇੱਥੇ ਇੱਕ ਪ੍ਰਤੀਕ੍ਰਿਆ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਤਿਆਰ ਕਰਦਾ ਹੈ।ਵੈੱਬ ਪੰਨੇ। \\n\\ਨਿਮਪੋਰਟ \'ਰੀਐਕਟ\' ਤੋਂ ਪ੍ਰਤੀਕਿਰਿਆ; \\n\\nਕੌਨਸਟ ਉਦਾਹਰਨ = () => {\\n ਰਿਟਰਨ (\\n <ਡਿਵੀ> \\n ਹੈਲੋ ਵਰਲਡ! \\n </ਡਿਵੀ> \\n); \\n; \\n\\ਨੇਕਸਪੋਰਟ ਡਿਫਾਲਟਉਦਾਹਰਨ; \\n\\n #!/usr/bin/env ਨੋਡ ", \'ਚੰਗਾ ਕੀਤਾ\', \'ਤੁਸੀਂ ਹੁਣੇ ਹੀ HTTP ਸਰਵਰ ਅਤੇ ਕਲਾਇੰਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ ਵੈੱਬ ਸਰਵਰ ਨੂੰ ਰਸਟ ਵਿੱਚ ਸੰਰਚਿਤ ਕੀਤਾ ਹੈ। ਸਰਵਰ ਕਰ ਸਕਦਾ ਹੈਇਸ ਦੀ ਵਰਤੋਂ ਐਚ. ਟੀ. ਐਮ. ਐਲ. ਵੈੱਬ ਪੇਜ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। \',\' ਜਾਣ ਬਾਰੇ ਕੀ? \',\' ਜਾਣ ਲਈ ਇੱਕ ਸਮਾਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜਿਸ ਨੂੰ golang.org/x/NAME_1/http ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਦੀ ਵਰਤੋਂ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।ਵੈੱਬ ਸਰਵਰ. \',\' ਗੋ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਲਿਖੋ \',\' ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ ਗੋ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਬਣਾਉਂਦਾ ਹੈ।) \\n\\n ਫੰਕ ਮੇਨ () {\\n http.HandleFunc ("/", ਇੰਡੈਕਸ) \\n http.ListenAndServe (": 8000", ਨਿਲ) \\n\\n ਫੰਕ ਇੰਡੈਕਸ (w http.ResponseWriter, r * http.Request) {\\nfmt.Fprintf (ਡਬਲਯੂ, "ਹੈਲੋ, ਵਰਲਡ!") \\n} \\n\\n #!/usr/bin/env goruntime.org/x/NAME_1/http \',\' ਕੀ ਇਹ ਸਭ ਹੈ? \', "ਠੀਕ ਹੈ, ਇਹ ਇਸ ਉਦਾਹਰਣ ਲਈ ਹੈ। ਅਗਲੇ ਵਿੱਚਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਇੱਕ ਹੋਰ ਉੱਨਤ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ ਜੋ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਕਈ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ, ਅਤੇ ਕਈ ਗਾਹਕਾਂ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈਉਸੇ ਸਮੇਂ. ", \'ਕਿਰਪਾ ਕਰਕੇ ਅਗਲੀ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰੋ\'] ', 'ਹੈਲੋ, ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਜੰਗਾਲ ਵਿੱਚ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ? \n ']