['   \n  \n "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n "\'] ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \'', ' "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n \'\', "ਯਕੀਨਨ, ਮੈਨੂੰ ਮਦਦ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ! ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਫਿਲਟਰ ਕਰਦਾ ਜਾਪਦਾ ਹੈ।ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਲਡ਼ੀ। ਇੱਥੇ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ ਇਸ ਦਾ ਟੁੱਟਣਾ ਹੈਃ \\n\\n * \'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ =...\': ਇਹ ਲਾਈਨ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਦਾ ਨਾਮ ਹੈ\'_ ਆਲਪੋਸਟਸ\' ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। \\n * \'ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []\' ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟ ਕਰਦਾ ਹੈਃ ਇਹ ਲਾਈਨ \'ਪੋਸਟਸਨ\' ਵੇਰੀਏਬਲ ਨੂੰ ਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ ਵਿੱਚ ਸੁੱਟਦੀ ਹੈ, ਜਿੱਥੇਹਰੇਕ ਅੰਦਰੂਨੀ ਐਰੇ ਵਿੱਚ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ \'Post.Post\' ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। \'ਦੇ ਰੂਪ ਵਿੱਚ\' ਕੀਵਰਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੱਸਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ \'ਪੋਸਟਜਸਨ\' ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਹੈਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ, ਭਾਵੇਂ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਉੱਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। \\n * \'ਫਿਲਟਰ ((e) => {...}\': ਇਹ ਲਾਈਨ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਐਰੇ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਉਹ ਤੱਤ ਹੁੰਦੇ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਗਏ ਟੈਸਟ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ। ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ \'ਈ\' ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਦਿੰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਤੱਤ ਨੂੰ NAME _ 1 ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n * \'ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')} \': ਇਹ ਲਾਈਨ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ\' ਈ [1]. ਵਿਕਲਪ \'ਐਰੇ (ਜਿੱਥੇ\' ਈ [1] \'\' Post.Post \'ਆਬਜੈਕਟ ਹੈ) ਵਿੱਚ ਸਤਰ ਸ਼ਾਮਲ ਹੈ।\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\'। ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ \'ਗਲਤ\' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਨਵੀਂ ਐਰੇ ਵਿੱਚ NAME _ 1 ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\', ਫੰਕਸ਼ਨ \'ਸਹੀ\' ਦਿੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\nSo, ਕੋਡ ਪੋਸਟਾਂ ਦੀ ਅਸਲ ਐਰੇ ਨੂੰ ਸਿਰਫ ਇਸ ਲਈ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ \'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਾਮ _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ ਨਹੀਂ ਹੈ। \\n\\n ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਮਦਦ ਕਰੇਗਾ! ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਕੋਈ ਵਿਕਲਪ ਹੈ।ਪ੍ਰਸ਼ਨ., \'\' ਦੇ ਕਿਸੇ ਹੋਰ ਫਿਲਟਰ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ \'([ਸਤਰ, Post.Post] [] ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟਜਸਨ) ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \'', ' "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n \'\', "ਯਕੀਨਨ, ਮੈਨੂੰ ਮਦਦ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ! ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਫਿਲਟਰ ਕਰਦਾ ਜਾਪਦਾ ਹੈ।ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਲਡ਼ੀ। ਇੱਥੇ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ ਇਸ ਦਾ ਟੁੱਟਣਾ ਹੈਃ \\n\\n * \'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ =...\': ਇਹ ਲਾਈਨ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਦਾ ਨਾਮ ਹੈ\'_ ਆਲਪੋਸਟਸ\' ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। \\n * \'ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []\' ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟ ਕਰਦਾ ਹੈਃ ਇਹ ਲਾਈਨ \'ਪੋਸਟਸਨ\' ਵੇਰੀਏਬਲ ਨੂੰ ਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ ਵਿੱਚ ਸੁੱਟਦੀ ਹੈ, ਜਿੱਥੇਹਰੇਕ ਅੰਦਰੂਨੀ ਐਰੇ ਵਿੱਚ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ \'Post.Post\' ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। \'ਦੇ ਰੂਪ ਵਿੱਚ\' ਕੀਵਰਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੱਸਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ \'ਪੋਸਟਜਸਨ\' ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਹੈਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ, ਭਾਵੇਂ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਉੱਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। \\n * \'ਫਿਲਟਰ ((e) => {...}\': ਇਹ ਲਾਈਨ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਐਰੇ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਉਹ ਤੱਤ ਹੁੰਦੇ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਗਏ ਟੈਸਟ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ। ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ \'ਈ\' ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਦਿੰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਤੱਤ ਨੂੰ NAME _ 1 ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n * \'ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')} \': ਇਹ ਲਾਈਨ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ\' ਈ [1]. ਵਿਕਲਪ \'ਐਰੇ (ਜਿੱਥੇ\' ਈ [1] \'\' Post.Post \'ਆਬਜੈਕਟ ਹੈ) ਵਿੱਚ ਸਤਰ ਸ਼ਾਮਲ ਹੈ।\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\'। ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ \'ਗਲਤ\' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਨਵੀਂ ਐਰੇ ਵਿੱਚ NAME _ 1 ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\', ਫੰਕਸ਼ਨ \'ਸਹੀ\' ਦਿੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\nSo, ਕੋਡ ਪੋਸਟਾਂ ਦੀ ਅਸਲ ਐਰੇ ਨੂੰ ਸਿਰਫ ਇਸ ਲਈ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ \'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਾਮ _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ ਨਹੀਂ ਹੈ। \\n\\n ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਮਦਦ ਕਰੇਗਾ! ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਕੋਈ ਵਿਕਲਪ ਹੈ।ਪ੍ਰਸ਼ਨ., \'ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਨਾਲ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ\' ([ਸਤਰ, Post.Post] [] ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟਜਸਨ), "ਯਕੀਨਨ! ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਦੂਜੇ ਨਾਲ ਜੋਡ਼ਨ ਲਈ।\'ਪੋਸਟਸਜਨ\' ਐਰੇ ਦਾ ਫਿਲਟਰ, ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਜਨ)ਜਿਵੇਂ ਕਿ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਫਿਲਟਰ ((e) => {\\n// ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕਰੋਇੱਥੇ \\n ਰਿਟਰਨ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\nNAME _ 1 ਇਹ ਉਦਾਹਰਣ, ਪਹਿਲਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ NAME _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ, ਅਤੇ ਦੂਜਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ।ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਵਿੱਚ ਸਿਰਫ ਉਹ ਪੋਸਟਾਂ ਹੋਣਗੀਆਂ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਗੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਹੀਂ ਹੈ ਅਤੇ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਹੈ। \\n\\n \'ਕੰਕਟ ()\' ਵਿਧੀ ਹੈਦੋ ਫਿਲਟਰ ਕੀਤੇ ਐਰੇ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਰੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਤੁਸੀਂ ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਬਜਾਏ \'ਮੈਪ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ,ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\nਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ।ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਮੂਲ ਐਰੇ ਦੇ ਬਰਾਬਰ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਜਦੋਂ ਕਿ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ।ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਐਰੇ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਅਸਲ ਐਰੇ ਨਾਲੋਂ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ। \\n\\n ਤੁਸੀਂ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\') {\\n acc.push (ਈ); \\n} \\n ਰੀਟਰਨ ਐਕਸੀ; \\n}, []); ", \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ, ਨਾ ਕਿ\' ਪੋਸਟਜਸਨ \'ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ? ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \'', ' "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n \'\', "ਯਕੀਨਨ, ਮੈਨੂੰ ਮਦਦ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ! ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਫਿਲਟਰ ਕਰਦਾ ਜਾਪਦਾ ਹੈ।ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਲਡ਼ੀ। ਇੱਥੇ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ ਇਸ ਦਾ ਟੁੱਟਣਾ ਹੈਃ \\n\\n * \'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ =...\': ਇਹ ਲਾਈਨ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਦਾ ਨਾਮ ਹੈ\'_ ਆਲਪੋਸਟਸ\' ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। \\n * \'ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []\' ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟ ਕਰਦਾ ਹੈਃ ਇਹ ਲਾਈਨ \'ਪੋਸਟਸਨ\' ਵੇਰੀਏਬਲ ਨੂੰ ਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ ਵਿੱਚ ਸੁੱਟਦੀ ਹੈ, ਜਿੱਥੇਹਰੇਕ ਅੰਦਰੂਨੀ ਐਰੇ ਵਿੱਚ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ \'Post.Post\' ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। \'ਦੇ ਰੂਪ ਵਿੱਚ\' ਕੀਵਰਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੱਸਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ \'ਪੋਸਟਜਸਨ\' ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਹੈਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ, ਭਾਵੇਂ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਉੱਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। \\n * \'ਫਿਲਟਰ ((e) => {...}\': ਇਹ ਲਾਈਨ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਐਰੇ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਉਹ ਤੱਤ ਹੁੰਦੇ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਗਏ ਟੈਸਟ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ। ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ \'ਈ\' ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਦਿੰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਤੱਤ ਨੂੰ NAME _ 1 ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n * \'ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')} \': ਇਹ ਲਾਈਨ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ\' ਈ [1]. ਵਿਕਲਪ \'ਐਰੇ (ਜਿੱਥੇ\' ਈ [1] \'\' Post.Post \'ਆਬਜੈਕਟ ਹੈ) ਵਿੱਚ ਸਤਰ ਸ਼ਾਮਲ ਹੈ।\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\'। ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ \'ਗਲਤ\' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਨਵੀਂ ਐਰੇ ਵਿੱਚ NAME _ 1 ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\', ਫੰਕਸ਼ਨ \'ਸਹੀ\' ਦਿੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\nSo, ਕੋਡ ਪੋਸਟਾਂ ਦੀ ਅਸਲ ਐਰੇ ਨੂੰ ਸਿਰਫ ਇਸ ਲਈ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ \'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਾਮ _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ ਨਹੀਂ ਹੈ। \\n\\n ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਮਦਦ ਕਰੇਗਾ! ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਕੋਈ ਵਿਕਲਪ ਹੈ।ਪ੍ਰਸ਼ਨ., \'ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਨਾਲ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ\' ([ਸਤਰ, Post.Post] [] ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟਜਸਨ), "ਯਕੀਨਨ! ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਦੂਜੇ ਨਾਲ ਜੋਡ਼ਨ ਲਈ।\'ਪੋਸਟਸਜਨ\' ਐਰੇ ਦਾ ਫਿਲਟਰ, ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਜਨ)ਜਿਵੇਂ ਕਿ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਫਿਲਟਰ ((e) => {\\n// ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕਰੋਇੱਥੇ \\n ਰਿਟਰਨ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\nNAME _ 1 ਇਹ ਉਦਾਹਰਣ, ਪਹਿਲਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ NAME _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ, ਅਤੇ ਦੂਜਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ।ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਵਿੱਚ ਸਿਰਫ ਉਹ ਪੋਸਟਾਂ ਹੋਣਗੀਆਂ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਗੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਹੀਂ ਹੈ ਅਤੇ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਹੈ। \\n\\n \'ਕੰਕਟ ()\' ਵਿਧੀ ਹੈਦੋ ਫਿਲਟਰ ਕੀਤੇ ਐਰੇ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਰੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਤੁਸੀਂ ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਬਜਾਏ \'ਮੈਪ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ,ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\nਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ।ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਮੂਲ ਐਰੇ ਦੇ ਬਰਾਬਰ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਜਦੋਂ ਕਿ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ।ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਐਰੇ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਅਸਲ ਐਰੇ ਨਾਲੋਂ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ। \\n\\n ਤੁਸੀਂ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\') {\\n acc.push (ਈ); \\n} \\n ਰੀਟਰਨ ਐਕਸੀ; \\n}, []); ", \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ, ਨਾ ਕਿ\' ਪੋਸਟਜਸਨ \'ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ?\', \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ,ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) =>{\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')); \\n}). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਕਨਕੈਟ ((e) => {\\nਵਾਪਸ ਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਹ ਪਹਿਲਾਂ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੇਗਾ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\' ਗੈਰ-ਸੂਚੀਬੱਧ \'ਵਿਕਲਪ ਹੈ, ਫਿਰ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋਜਿਸ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਜਾਵਾਸਕ੍ਰਿਪਟ\' ਟੈਗ ਨਹੀਂ ਹੈ। \\n\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਮੈਪ ()\' ਵਿਧੀ NAME _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਸ ਦਾ ਪ੍ਰਭਾਵ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਾਂਗ ਹੀ ਹੋਵੇਗਾ, ਪਰ ਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ।ਤੁਸੀਂ ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਨਾਮ _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \'\\n\' \'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\' & &ਈ [1]. ਟੈਗ. ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\')) {\\n acc.push (ਈ); \\n} \\n ਰਿਟਰਨ ਐਕਸੀ; \\n}, []); \\n \'\\n ਇਸ ਦਾ ਵੀ ਪਿਛਲੇ ਉਦਾਹਰਣਾਂ ਵਾਂਗ ਹੀ ਪ੍ਰਭਾਵ ਪਵੇਗਾ, ਪਰਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਪਡ਼੍ਹਨ ਵਿੱਚ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ। \\n\\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਉਸੇ ਗਿਣਤੀ ਦੇ ਤੱਤਾਂ ਨਾਲ ਵਾਪਸ ਕਰੇਗੀਮੂਲ ਐਰੇ, ਜਦੋਂ ਕਿ \'ਘਟਾਓ ()\' ਵਿਧੀ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਪਰ ਲੰਬਾਈ \',\' ਦੋ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਨਾ ਹੈ ਨਾਮ _ 1ਜਾਵਾਸਕ੍ਰਿਪਟ? \'] ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \'', ' "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n \'\', "ਯਕੀਨਨ, ਮੈਨੂੰ ਮਦਦ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ! ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਫਿਲਟਰ ਕਰਦਾ ਜਾਪਦਾ ਹੈ।ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਲਡ਼ੀ। ਇੱਥੇ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ ਇਸ ਦਾ ਟੁੱਟਣਾ ਹੈਃ \\n\\n * \'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ =...\': ਇਹ ਲਾਈਨ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਦਾ ਨਾਮ ਹੈ\'_ ਆਲਪੋਸਟਸ\' ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। \\n * \'ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []\' ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟ ਕਰਦਾ ਹੈਃ ਇਹ ਲਾਈਨ \'ਪੋਸਟਸਨ\' ਵੇਰੀਏਬਲ ਨੂੰ ਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ ਵਿੱਚ ਸੁੱਟਦੀ ਹੈ, ਜਿੱਥੇਹਰੇਕ ਅੰਦਰੂਨੀ ਐਰੇ ਵਿੱਚ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ \'Post.Post\' ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। \'ਦੇ ਰੂਪ ਵਿੱਚ\' ਕੀਵਰਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੱਸਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ \'ਪੋਸਟਜਸਨ\' ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਹੈਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ, ਭਾਵੇਂ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਉੱਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। \\n * \'ਫਿਲਟਰ ((e) => {...}\': ਇਹ ਲਾਈਨ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਐਰੇ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਉਹ ਤੱਤ ਹੁੰਦੇ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਗਏ ਟੈਸਟ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ। ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ \'ਈ\' ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਦਿੰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਤੱਤ ਨੂੰ NAME _ 1 ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n * \'ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')} \': ਇਹ ਲਾਈਨ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ\' ਈ [1]. ਵਿਕਲਪ \'ਐਰੇ (ਜਿੱਥੇ\' ਈ [1] \'\' Post.Post \'ਆਬਜੈਕਟ ਹੈ) ਵਿੱਚ ਸਤਰ ਸ਼ਾਮਲ ਹੈ।\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\'। ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ \'ਗਲਤ\' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਨਵੀਂ ਐਰੇ ਵਿੱਚ NAME _ 1 ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\', ਫੰਕਸ਼ਨ \'ਸਹੀ\' ਦਿੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\nSo, ਕੋਡ ਪੋਸਟਾਂ ਦੀ ਅਸਲ ਐਰੇ ਨੂੰ ਸਿਰਫ ਇਸ ਲਈ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ \'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਾਮ _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ ਨਹੀਂ ਹੈ। \\n\\n ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਮਦਦ ਕਰੇਗਾ! ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਕੋਈ ਵਿਕਲਪ ਹੈ।ਪ੍ਰਸ਼ਨ., \'ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਨਾਲ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ\' ([ਸਤਰ, Post.Post] [] ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟਜਸਨ), "ਯਕੀਨਨ! ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਦੂਜੇ ਨਾਲ ਜੋਡ਼ਨ ਲਈ।\'ਪੋਸਟਸਜਨ\' ਐਰੇ ਦਾ ਫਿਲਟਰ, ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਜਨ)ਜਿਵੇਂ ਕਿ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਫਿਲਟਰ ((e) => {\\n// ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕਰੋਇੱਥੇ \\n ਰਿਟਰਨ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\nNAME _ 1 ਇਹ ਉਦਾਹਰਣ, ਪਹਿਲਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ NAME _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ, ਅਤੇ ਦੂਜਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ।ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਵਿੱਚ ਸਿਰਫ ਉਹ ਪੋਸਟਾਂ ਹੋਣਗੀਆਂ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਗੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਹੀਂ ਹੈ ਅਤੇ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਹੈ। \\n\\n \'ਕੰਕਟ ()\' ਵਿਧੀ ਹੈਦੋ ਫਿਲਟਰ ਕੀਤੇ ਐਰੇ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਰੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਤੁਸੀਂ ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਬਜਾਏ \'ਮੈਪ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ,ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\nਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ।ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਮੂਲ ਐਰੇ ਦੇ ਬਰਾਬਰ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਜਦੋਂ ਕਿ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ।ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਐਰੇ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਅਸਲ ਐਰੇ ਨਾਲੋਂ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ। \\n\\n ਤੁਸੀਂ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\') {\\n acc.push (ਈ); \\n} \\n ਰੀਟਰਨ ਐਕਸੀ; \\n}, []); ", \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ, ਨਾ ਕਿ\' ਪੋਸਟਜਸਨ \'ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ?\', \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ,ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) =>{\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')); \\n}). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਕਨਕੈਟ ((e) => {\\nਵਾਪਸ ਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਹ ਪਹਿਲਾਂ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੇਗਾ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\' ਗੈਰ-ਸੂਚੀਬੱਧ \'ਵਿਕਲਪ ਹੈ, ਫਿਰ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋਜਿਸ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਜਾਵਾਸਕ੍ਰਿਪਟ\' ਟੈਗ ਨਹੀਂ ਹੈ। \\n\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਮੈਪ ()\' ਵਿਧੀ NAME _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਸ ਦਾ ਪ੍ਰਭਾਵ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਾਂਗ ਹੀ ਹੋਵੇਗਾ, ਪਰ ਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ।ਤੁਸੀਂ ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਨਾਮ _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \'\\n\' \'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\' & &ਈ [1]. ਟੈਗ. ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\')) {\\n acc.push (ਈ); \\n} \\n ਰਿਟਰਨ ਐਕਸੀ; \\n}, []); \\n \'\\n ਇਸ ਦਾ ਵੀ ਪਿਛਲੇ ਉਦਾਹਰਣਾਂ ਵਾਂਗ ਹੀ ਪ੍ਰਭਾਵ ਪਵੇਗਾ, ਪਰਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਪਡ਼੍ਹਨ ਵਿੱਚ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ। \\n\\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਉਸੇ ਗਿਣਤੀ ਦੇ ਤੱਤਾਂ ਨਾਲ ਵਾਪਸ ਕਰੇਗੀਮੂਲ ਐਰੇ, ਜਦੋਂ ਕਿ \'ਘਟਾਓ ()\' ਵਿਧੀ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਪਰ ਲੰਬਾਈ \',\' ਦੋ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਨਾ ਹੈ ਨਾਮ _ 1ਜਾਵਾਸਕ੍ਰਿਪਟ? \', ਦੋ ਐਰੇ ਨਾਮ _ 1 ਜਾਵਾਸਕ੍ਰਿਪਟ ਨੂੰ ਜੋਡ਼ਨ ਲਈ, ਤੁਸੀਂ\' ਕੰਕਟ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'\\nkonst array1 = [1,2,3]; \\nkonstਐਰੇ2 = [4,5,6]; \\n\\nਕੌਂਸਟ ਕੰਬਾਈਨ ਐਰੇ = array1.concat (ਐਰੇ2); \\n\\ nconsole.log (ਕੰਬਾਈਨ ਐਰੇ);// [1,2,3,4,5,6] \\n "\'\\n" ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ।ਇੱਕ ਐਰੇ ਦੇ ਤੱਤਾਂ ਨੂੰ ਦੂਜੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ \'ਪੁਸ਼\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋਃ \\n \'\' \\nkonst ਐਰੇ1 = [1,2,3]; \\nkonst ਐਰੇ2 = [4,5,6]; \\n\\ narray1.push (... ਐਰੇ 2); \\n\\ nconsole.log (ਐਰੇ 1);// [1,2,3,4,5,6] \\n "\'\\n ਨੋਟ ਕਰੋ ਕਿ\' ਕੰਕੈਟ \'ਵਿਧੀ ਸੰਗਠਿਤ ਕਰਕੇ ਇੱਕ ਨਵੀਂ ਐਰੇ ਬਣਾਉਂਦੀ ਹੈ।ਦੋ ਇੰਪੁੱਟ ਐਰੇ, ਜਦੋਂ ਕਿ \'ਪੁਸ਼\' ਵਿਧੀ ਮੌਜੂਦਾ ਐਰੇ ਨੂੰ ਸੋਧਦੀ ਹੈ। \',\' ਨਾਮ _ 1 ਸਵੇਲਟਕਿੱਟ ਇਸ ਕੋਡ ਦਾ ਕੀ ਅਰਥ ਹੈਃ \\n \'\\n <ਮੁੱਖ ਕਲਾਸ = "flex{className??\\\'flex-col\\\'} "\\n </main> \\n"] ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \'', ' "ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? \\n" \'\\nਕੋਨਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}); \\n \'\', "ਯਕੀਨਨ, ਮੈਨੂੰ ਮਦਦ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ! ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ, ਅਤੇ ਇਹ ਇੱਕ ਫਿਲਟਰ ਕਰਦਾ ਜਾਪਦਾ ਹੈ।ਇੱਕ ਸ਼ਰਤ ਦੇ ਅਧਾਰ ਉੱਤੇ ਆਬਜੈਕਟ ਦੀ ਲਡ਼ੀ। ਇੱਥੇ ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ ਇਸ ਦਾ ਟੁੱਟਣਾ ਹੈਃ \\n\\n * \'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ =...\': ਇਹ ਲਾਈਨ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਘੋਸ਼ਿਤ ਕਰਦੀ ਹੈ ਜਿਸ ਦਾ ਨਾਮ ਹੈ\'_ ਆਲਪੋਸਟਸ\' ਅਤੇ ਇਸ ਨੂੰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। \\n * \'ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []\' ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟ ਕਰਦਾ ਹੈਃ ਇਹ ਲਾਈਨ \'ਪੋਸਟਸਨ\' ਵੇਰੀਏਬਲ ਨੂੰ ਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ ਵਿੱਚ ਸੁੱਟਦੀ ਹੈ, ਜਿੱਥੇਹਰੇਕ ਅੰਦਰੂਨੀ ਐਰੇ ਵਿੱਚ ਇੱਕ ਸਤਰ ਅਤੇ ਇੱਕ \'Post.Post\' ਆਬਜੈਕਟ ਹੁੰਦਾ ਹੈ। \'ਦੇ ਰੂਪ ਵਿੱਚ\' ਕੀਵਰਡ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੱਸਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿ \'ਪੋਸਟਜਸਨ\' ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਹੈਐਰੇ ਦੀ ਇੱਕ ਲਡ਼ੀ, ਭਾਵੇਂ ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ ਉੱਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੋਵੇ। \\n * \'ਫਿਲਟਰ ((e) => {...}\': ਇਹ ਲਾਈਨ ਇੱਕ ਨਵਾਂ ਬਣਾਉਣ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।ਐਰੇ ਜਿਸ ਵਿੱਚ ਸਿਰਫ ਉਹ ਤੱਤ ਹੁੰਦੇ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੇ ਗਏ ਟੈਸਟ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਨ। ਫੰਕਸ਼ਨ ਇੱਕ ਤੱਤ \'ਈ\' ਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ, ਅਤੇਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਦਿੰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਤੱਤ ਨੂੰ NAME _ 1 ਨਵੀਂ ਐਰੇ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n * \'ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')} \': ਇਹ ਲਾਈਨ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ\' ਈ [1]. ਵਿਕਲਪ \'ਐਰੇ (ਜਿੱਥੇ\' ਈ [1] \'\' Post.Post \'ਆਬਜੈਕਟ ਹੈ) ਵਿੱਚ ਸਤਰ ਸ਼ਾਮਲ ਹੈ।\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\'। ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ \'ਗਲਤ\' ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਨਵੀਂ ਐਰੇ ਵਿੱਚ NAME _ 1 ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\', ਫੰਕਸ਼ਨ \'ਸਹੀ\' ਦਿੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤੱਤ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। \\n\\nSo, ਕੋਡ ਪੋਸਟਾਂ ਦੀ ਅਸਲ ਐਰੇ ਨੂੰ ਸਿਰਫ ਇਸ ਲਈ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ ਜਿਨ੍ਹਾਂ ਕੋਲ \'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਾਮ _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ ਨਹੀਂ ਹੈ। \\n\\n ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਮਦਦ ਕਰੇਗਾ! ਮੈਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਹੋਰ ਕੋਈ ਵਿਕਲਪ ਹੈ।ਪ੍ਰਸ਼ਨ., \'ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਨਾਲ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ\' ([ਸਤਰ, Post.Post] [] ਦੇ ਰੂਪ ਵਿੱਚ ਪੋਸਟਜਸਨ), "ਯਕੀਨਨ! ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਦੂਜੇ ਨਾਲ ਜੋਡ਼ਨ ਲਈ।\'ਪੋਸਟਸਜਨ\' ਐਰੇ ਦਾ ਫਿਲਟਰ, ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਜਨ)ਜਿਵੇਂ ਕਿ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਫਿਲਟਰ ((e) => {\\n// ਇੱਕ ਹੋਰ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕਰੋਇੱਥੇ \\n ਰਿਟਰਨ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\nNAME _ 1 ਇਹ ਉਦਾਹਰਣ, ਪਹਿਲਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\'ਗ਼ੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ NAME _ 1 ਉਹਨਾਂ ਦੇ \'ਵਿਕਲਪਾਂ\' ਦੀ ਲਡ਼ੀ, ਅਤੇ ਦੂਜਾ \'ਫਿਲਟਰ ()\' ਢੰਗ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ।ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਵਿੱਚ ਸਿਰਫ ਉਹ ਪੋਸਟਾਂ ਹੋਣਗੀਆਂ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਗੈਰ-ਸੂਚੀਬੱਧ\' ਵਿਕਲਪ ਨਹੀਂ ਹੈ ਅਤੇ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਹੈ। \\n\\n \'ਕੰਕਟ ()\' ਵਿਧੀ ਹੈਦੋ ਫਿਲਟਰ ਕੀਤੇ ਐਰੇ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਰੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। \\n\\n ਤੁਸੀਂ ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਦੀ ਬਜਾਏ \'ਮੈਪ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ,ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\nਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}); \\n \'\' \\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ।ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਮੂਲ ਐਰੇ ਦੇ ਬਰਾਬਰ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਜਦੋਂ ਕਿ \'ਫਿਲਟਰ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ।ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਐਰੇ, ਪਰ ਨਤੀਜੇ ਵਜੋਂ ਐਰੇ ਦੀ ਲੰਬਾਈ ਅਸਲ ਐਰੇ ਨਾਲੋਂ ਛੋਟੀ ਹੋ ਸਕਦੀ ਹੈ। \\n\\n ਤੁਸੀਂ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।ਐਰੇ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ, ਇਹ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗਾ, ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n "\'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\') {\\n acc.push (ਈ); \\n} \\n ਰੀਟਰਨ ਐਕਸੀ; \\n}, []); ", \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਿਆ ਜਾਵੇ, ਨਾ ਕਿ\' ਪੋਸਟਜਸਨ \'ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ?\', \'ਇੱਕ ਹੋਰ ਐਰੇ ਫਿਲਟਰ ਨੂੰ\' _ ਆਲਪੋਸਟਸ \'ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ,ਤੁਸੀਂ \'ਫਿਲਟਰ ()\' ਢੰਗ ਨਾਲ \'ਕੰਕਟ ()\' ਢੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਕਨਕੈਟ ((e) =>{\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\')); \\n}). ਕਨਕੈਟ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਕਨਕੈਟ ((e) => {\\nਵਾਪਸ ਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਹ ਪਹਿਲਾਂ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੇਗਾ ਜਿਨ੍ਹਾਂ ਵਿੱਚ\' ਗੈਰ-ਸੂਚੀਬੱਧ \'ਵਿਕਲਪ ਹੈ, ਫਿਰ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋਜਿਸ ਵਿੱਚ \'ਟੈਕਨੋਲੋਜੀ\' ਸ਼੍ਰੇਣੀ ਨਹੀਂ ਹੈ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਪੋਸਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ \'ਜਾਵਾਸਕ੍ਰਿਪਟ\' ਟੈਗ ਨਹੀਂ ਹੈ। \\n\\n ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਮੈਪ ()\' ਵਿਧੀ NAME _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \\n \'\' \\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਜਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ, Post.Post] []). ਮੈਪ ((e) => {\\n ਵਾਪਸੀ! (e [1]. ਵਿਕਲਪ & & e [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\'); \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀ e [1]. ਸ਼੍ਰੇਣੀ = = = \'ਟੈਕਨੋਲੋਜੀ\'; \\n}). ਨਕਸ਼ਾ ((e) => {\\n ਵਾਪਸੀਈ [1]. ਟੈਗ ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\'); \\n}); \\n \'\\n ਇਸ ਦਾ ਪ੍ਰਭਾਵ ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਾਂਗ ਹੀ ਹੋਵੇਗਾ, ਪਰ ਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ।ਤੁਸੀਂ ਕਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ \'ਘਟਾਓ ()\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਨਾਮ _ 1 ਇੱਕ ਚੇਨ, ਇਸ ਤਰ੍ਹਾਂਃ \'\\n\' \'\\nkonst _ allਪੋਸ੍ਟਸ = (ਪੋਸਟਸਨ ਦੇ ਰੂਪ ਵਿੱਚ [ਸਤਰ,Post.Post] []). ਘਟਾਓ ((ਏ. ਸੀ., ਈ) => {\\n ਜੇਕਰ (ਈ [1]. ਵਿਕਲਪ & & ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\') & & ਈ [1]. ਸ਼੍ਰੇਣੀ = = \'ਟੈਕਨੋਲੋਜੀ\' & &ਈ [1]. ਟੈਗ. ਸ਼ਾਮਲ ਹਨ (\'ਜਾਵਾਸਕ੍ਰਿਪਟ\')) {\\n acc.push (ਈ); \\n} \\n ਰਿਟਰਨ ਐਕਸੀ; \\n}, []); \\n \'\\n ਇਸ ਦਾ ਵੀ ਪਿਛਲੇ ਉਦਾਹਰਣਾਂ ਵਾਂਗ ਹੀ ਪ੍ਰਭਾਵ ਪਵੇਗਾ, ਪਰਇਹ ਵਧੇਰੇ ਸੰਖੇਪ ਅਤੇ ਪਡ਼੍ਹਨ ਵਿੱਚ ਅਸਾਨ ਹੋ ਸਕਦਾ ਹੈ। \\n\\n ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ \'ਮੈਪ ()\' ਵਿਧੀ ਇੱਕ ਨਵੀਂ ਐਰੇ ਨੂੰ ਉਸੇ ਗਿਣਤੀ ਦੇ ਤੱਤਾਂ ਨਾਲ ਵਾਪਸ ਕਰੇਗੀਮੂਲ ਐਰੇ, ਜਦੋਂ ਕਿ \'ਘਟਾਓ ()\' ਵਿਧੀ ਲੋਡ਼ੀਂਦੇ ਤੱਤਾਂ ਨਾਲ ਇੱਕ ਨਵੀਂ ਐਰੇ ਵਾਪਸ ਕਰੇਗੀ, ਪਰ ਲੰਬਾਈ \',\' ਦੋ ਐਰੇ ਨੂੰ ਕਿਵੇਂ ਜੋਡ਼ਨਾ ਹੈ ਨਾਮ _ 1ਜਾਵਾਸਕ੍ਰਿਪਟ? \', ਦੋ ਐਰੇ ਨਾਮ _ 1 ਜਾਵਾਸਕ੍ਰਿਪਟ ਨੂੰ ਜੋਡ਼ਨ ਲਈ, ਤੁਸੀਂ\' ਕੰਕਟ \'ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\' \'\\nkonst array1 = [1,2,3]; \\nkonstਐਰੇ2 = [4,5,6]; \\n\\nਕੌਂਸਟ ਕੰਬਾਈਨ ਐਰੇ = array1.concat (ਐਰੇ2); \\n\\ nconsole.log (ਕੰਬਾਈਨ ਐਰੇ);// [1,2,3,4,5,6] \\n "\'\\n" ਵਿਕਲਪਿਕ ਤੌਰ ਉੱਤੇ, ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ।ਇੱਕ ਐਰੇ ਦੇ ਤੱਤਾਂ ਨੂੰ ਦੂਜੇ ਵਿੱਚ ਜੋਡ਼ਨ ਲਈ \'ਪੁਸ਼\' ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋਃ \\n \'\' \\nkonst ਐਰੇ1 = [1,2,3]; \\nkonst ਐਰੇ2 = [4,5,6]; \\n\\ narray1.push (... ਐਰੇ 2); \\n\\ nconsole.log (ਐਰੇ 1);// [1,2,3,4,5,6] \\n "\'\\n ਨੋਟ ਕਰੋ ਕਿ\' ਕੰਕੈਟ \'ਵਿਧੀ ਸੰਗਠਿਤ ਕਰਕੇ ਇੱਕ ਨਵੀਂ ਐਰੇ ਬਣਾਉਂਦੀ ਹੈ।ਦੋ ਇੰਪੁੱਟ ਐਰੇ, ਜਦੋਂ ਕਿ \'ਪੁਸ਼\' ਵਿਧੀ ਮੌਜੂਦਾ ਐਰੇ ਨੂੰ ਸੋਧਦੀ ਹੈ। \',\' ਨਾਮ _ 1 ਸਵੇਲਟਕਿੱਟ ਇਸ ਕੋਡ ਦਾ ਕੀ ਅਰਥ ਹੈਃ \\n \'\\n <ਮੁੱਖ ਕਲਾਸ = "flex{className??\\\'flex-col\\\'} "\\n </main> \\n", "NAME _ 1 SvelteKit, ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਕੋਡ ਇੱਕ ਹਿੱਸਾ ਹੈ ਜੋ ਇੱਕ ਕਲਾਸ ਦੇ ਨਾਲ ਇੱਕ \'ਮੁੱਖ\' ਤੱਤ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।\'flex\'. \'??\' ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ \'ਕਲਾਸਨਾਮ\' ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਇੱਕ ਡਿਫਾਲਟ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜੇਕਰ ਇਹ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। \\n\\nਇੱਥੇ \'ਕਲਾਸਨਾਮ\' ਦਾ ਟੁੱਟਣਾ ਹੈ।ਕੋਡਃ \\n\\n * \'ਮੇਨ\': ਇਹ ਉਹ ਤੱਤ ਹੈ ਜਿਸ ਨੂੰ ਭਾਗ ਦਾ ਨਾਮ _ 1 ਦਿੱਤਾ ਜਾਵੇਗਾ। \\n * \'ਕਲਾਸ\': ਇਹ \'ਮੇਨ\' ਤੱਤ ਦੇ ਕਲਾਸ ਗੁਣ ਨੂੰ ਸੈੱਟ ਕਰਦਾ ਹੈ। \\n *\'flex\': ਇਹ ਕਲਾਸ ਨੂੰ \'flex\' ਸੈੱਟ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ CSS ਕਲਾਸ ਹੈ ਜੋ ਇੱਕ ਲਚਕਦਾਰ ਬਾਕਸ ਲੇਆਉਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ। \\n * \'{className??\' flex-col \'}\': ਇਹ ਇੱਕ ਸ਼ਰਤੀਆ ਹੈ।ਸਮੀਕਰਨ ਜੋ \'ਕਲਾਸਨਾਮ\' ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਇੱਕ ਡਿਫਾਲਟ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। \'??\' ਓਪਰੇਟਰ ਇੱਕ ਨੱਲਿਸ਼ ਕੋਲੇਸਸਿੰਗ ਓਪਰੇਟਰ ਹੈ ਜੋ ਪਹਿਲਾ ਵਾਪਸ ਕਰਦਾ ਹੈ।ਓਪਰੇਡ ਜੇਕਰ ਇਹ ਨੱਲ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਅਤੇ ਦੂਜਾ ਓਪਰੇਡ ਜੇਕਰ ਇਹ ਨੱਲ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਨਾਮ _ 1, ਜੇਕਰ \'ਕਲਾਸਨਾਮ\' ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ ਹੈਬਸ਼ਰਤੇ, ਇਸ ਨੂੰ "flex-col" ਲਈ ਸੈੱਟ ਕੀਤਾ ਜਾਵੇਗਾ। \\n\\nSo, ਜੇਕਰ \'ਕਲਾਸਨਾਮ\' ਵਿਸ਼ੇਸ਼ਤਾ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਤਾਂ \'ਮੁੱਖ\' ਤੱਤ ਵਿੱਚ "flex-col" ਦੀ ਇੱਕ ਕਲਾਸ ਹੋਵੇਗੀ।ਨਹੀਂ ਤਾਂ, ਇਸ ਵਿੱਚ ਉਹ ਕਲਾਸ ਹੋਵੇਗੀ ਜੋ ਨਾਮ _ 1 \'ਕਲਾਸਨਾਮ\' ਵਿਸ਼ੇਸ਼ਤਾ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਹੈ। \',\' path.relative () \'ਫੰਕਸ਼ਨ ਨਾਮ _ 1 ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੀ ਕਰਦਾ ਹੈ?\' ', 'ਕੀ ਤੁਸੀਂ ਇਸ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੋਡ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ? "\'ਕਾਂਸਟ _ ਆਲਪੋਸਟਸ = (ਪੋਸਟਸਨ ਨੂੰ [ਸਤਰ, Post.Post] []). ਫਿਲਟਰ ((ਈ) => {ਵਾਪਸੀ! (ਈ [1]. ਵਿਕਲਪ & &ਈ [1]. ਵਿਕਲਪ. ਸ਼ਾਮਲ ਹਨ (\'ਗੈਰ-ਸੂਚੀਬੱਧ\');}); \' \n ']