JavaScript ਵਿੱਚ printIn ਅਤੇ console.log ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ? (ਜਵਾਬ) - ਸਾਰੇ ਅੰਤਰ
ਵਿਸ਼ਾ - ਸੂਚੀ
ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਇੱਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ ਜੋ ਸਿਰਫ਼ ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਉਪਲਬਧ ਹੈ। JavaScript ਕੰਸੋਲ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਇੱਕ ਕਮਾਂਡ-ਲਾਈਨ ਇੰਟਰਫੇਸ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਕੋਡ ਸਨਿੱਪਟ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਉਹ ਕੋਡ ਸਨਿੱਪਟ ਤੁਹਾਡੇ ਦੁਆਰਾ ਦੇਖ ਰਹੇ ਵੈੱਬਪੇਜ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅਚਾਨਕ ਨਤੀਜੇ ਆ ਸਕਦੇ ਹਨ।
"ਪ੍ਰਿੰਟਇਨ" ਟੈਕਸਟ ਨੂੰ ਕੰਸੋਲ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਲੌਗ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਵੱਖ-ਵੱਖ ਉਦੇਸ਼ਾਂ ਲਈ ਵਰਤਣ ਲਈ "console.log" ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਸਨੂੰ ਇੱਕ ਬੱਗ ਰਿਪੋਰਟ ਵਜੋਂ ਈਮੇਲ ਕਰਨਾ।
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਵਰਤਣਾ ਅਤੇ ਸਮਝਣਾ ਕਿੰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਸਕਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਜਿਵੇਂ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੈ। ਹਾਲਾਂਕਿ, ਕਈ ਵਾਰ ਤੁਸੀਂ ਇਸਦੇ ਫੰਕਸ਼ਨਾਂ ਬਾਰੇ ਉਲਝਣ ਵਿੱਚ ਹੋ ਸਕਦੇ ਹੋ।
ਬਿਲਕੁਲ printIn ਅਤੇ console.log ਫੰਕਸ਼ਨ ਦੀ ਤਰ੍ਹਾਂ। ਇਹਨਾਂ ਦੋ ਫੰਕਸ਼ਨਾਂ ਦੇ ਅੰਤਰ ਅਤੇ ਉਪਯੋਗ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਲਈ, ਮੈਂ ਦੱਸਾਂਗਾ ਕਿ ਉਹਨਾਂ ਦਾ ਕੀ ਅਰਥ ਹੈ ਅਤੇ ਉਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।
ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ!
JavaScript ਕੀ ਹੈ?
ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੀ ਹੈ?
ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨਿਯਮਤ ਤੌਰ 'ਤੇ ਅੱਪਡੇਟ ਕੀਤੀ ਸਮੱਗਰੀ ਬਣਾਉਣ, ਮਲਟੀਮੀਡੀਆ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ, ਗ੍ਰਾਫਿਕਸ ਨੂੰ ਐਨੀਮੇਟ ਕਰਨ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਕੁਝ ਕਰਨ ਲਈ ਇੱਕ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾ ਹੈ।
ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਕੁਝ ਮਿਆਰੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਸਮਰੱਥਾਵਾਂ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜਿਵੇਂ ਕਿ:
- ਜਦੋਂ ਕਿਸੇ ਵੈੱਬ ਪੰਨੇ 'ਤੇ ਕੁਝ ਘਟਨਾਵਾਂ ਵਾਪਰਦੀਆਂ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਚੱਲ ਰਹੇ ਕੋਡ ਦਾ ਜਵਾਬ ਦੇ ਸਕਦੇ ਹੋ।
- ਤੁਸੀਂ ਉਪਯੋਗੀ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
- ਤੁਸੀਂ "ਸਟਰਿੰਗਜ਼" ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਕਿ ਇੱਕ ਟੈਕਸਟ ਸੰਪਾਦਨ ਕਾਰਜ ਹੈਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ
ਉਪਭੋਗਤਾ JavaScript ਭਾਸ਼ਾ ਦੇ ਸਿਖਰ 'ਤੇ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ ਕਾਰਜਕੁਸ਼ਲਤਾ, ਦੂਜੇ ਪਾਸੇ, ਹੋਰ ਵੀ ਦਿਲਚਸਪ ਹੈ। ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ (APIs) ਤੁਹਾਡੇ JavaScript ਕੋਡ ਨੂੰ ਵਾਧੂ ਫੰਕਸ਼ਨ ਦਿੰਦੇ ਹਨ।
ਸੰਖੇਪ ਵਿੱਚ, JavaScript ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਇਹ ਕੰਟਰੋਲ ਕਰਨ ਦਿੰਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਕੀ ਕੋਡਿੰਗ ਕਰ ਰਹੇ ਹੋ। ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ printIn ਅਤੇ console.log ਸ਼ਾਮਲ ਹਨ।
PrintIn ਕੀ ਹੈ?
ਕੋਡਿੰਗ
ਪ੍ਰਿੰਟਇਨ ਕੰਸੋਲ ਉੱਤੇ ਟੈਕਸਟ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਜਾਵਾ ਵਿਧੀ ਹੈ। ਇਹ ਵਿਧੀ ਇਸ ਟੈਕਸਟ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ। ਇਹ ਪਹੁੰਚ ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਕਰਸਰ ਨੂੰ ਰੱਖਦੇ ਹੋਏ ਟੈਕਸਟ ਨੂੰ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦੀ ਹੈ।
ਅਗਲੀ ਪ੍ਰਿੰਟਿੰਗ ਅਗਲੀ ਲਾਈਨ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ । ਕਈ ਪ੍ਰਿੰਟਇਨ ਢੰਗ ਹਨ ਜਿਵੇਂ:
| void printIn() | ਮੌਜੂਦਾ ਲਾਈਨ ਨੂੰ ਖਤਮ ਕਰਨ ਲਈ ਲਾਈਨ ਵਿਭਾਜਕ ਸਤਰ ਲਿਖਦਾ ਹੈ। |
| void printIn(boolean x) | ਇੱਕ ਬੂਲੀਅਨ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ। |
| void printIn(char x) | ਇੱਕ ਅੱਖਰ ਨੂੰ ਛਾਪਣ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ। |
| void print(char [ ] x) | ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ। |
| void printIn(double x) | ਇੱਕ ਡਬਲ ਲਾਈਨ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਨੂੰ ਸਮਾਪਤ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। |
| void printIn(float x) | ਲਾਈਨ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਬੰਦ ਹੋ ਜਾਂਦੀ ਹੈ। |
| ਰਹਿਤprintIn(int x) | ਇੱਕ ਪੂਰਨ ਅੰਕ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਨੂੰ ਬੰਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। |
| void printIn(long x) | ਲਾਈਨ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਸਮਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void printIn(Object x) | ਇੱਕ ਵਸਤੂ ਨੂੰ ਛਾਪਣ ਤੋਂ ਬਾਅਦ ਲਾਈਨ ਨੂੰ ਸਮਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void printIn(String x) | ਲਾਈਨ ਨੂੰ ਇੱਕ ਸਤਰ ਛਾਪਣ ਤੋਂ ਬਾਅਦ ਸਮਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
ਪ੍ਰਿੰਟਇਨ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ
ਹਾਲਾਂਕਿ ਇਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਤਰੀਕੇ ਹਨ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਕੰਮ ਨੂੰ ਕੋਡਿੰਗ ਕਰਨ ਵਿੱਚ ਵਰਤ ਸਕਦੇ ਹੋ, ਤੁਸੀਂ ਕੰਸੋਲ ਵਿੱਚ ਟੈਕਸਟ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਵਿਧੀ ਦਾ ਸਾਹਮਣਾ ਕਰ ਸਕਦੇ ਹੋ। ਕੰਸੋਲ ਵਿੱਚ, ਇੱਥੇ ਦੋ ਤਰੀਕੇ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਆਪਣੇ ਕੰਮ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰ ਸਕਦੇ ਹੋ, ਪਹਿਲਾ ਇੱਕ ਪ੍ਰਿੰਟਇਨ ਹੈ ਜਦੋਂ ਕਿ ਦੂਜਾ ਪ੍ਰਿੰਟ ਹੈ।
ਤੁਹਾਨੂੰ ਪ੍ਰਿੰਟਿੰਗ ਦੇ ਇਹਨਾਂ ਦੋ ਤਰੀਕਿਆਂ ਵਿੱਚ ਉਲਝਣ ਵਿੱਚ ਨਾ ਪੈਣ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਆਓ ਪ੍ਰਿੰਟਿੰਗ ਵਿੱਚ ਦੂਜੀ ਵਿਧੀ, ਪ੍ਰਿੰਟ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
ਪ੍ਰਿੰਟ ਕੰਸੋਲ ਉੱਤੇ ਟੈਕਸਟ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇੱਕ ਜਾਵਾ ਵਿਧੀ ਹੈ। ਇਹ ਵਿਧੀ ਇਸ ਟੈਕਸਟ ਨੂੰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ। ਸਤਰ. ਇਹ ਪਹੁੰਚ ਟੈਕਸਟ ਨੂੰ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰਦੀ ਹੈ ਜਦੋਂ ਕਿ ਕਰਸਰ ਨੂੰ ਹੇਠਲੀ ਲਾਈਨ ਦੇ ਅੰਤ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ।
ਅਗਲੀ ਪ੍ਰਿੰਟਿੰਗ ਇੱਥੇ ਸ਼ੁਰੂ ਹੋਵੇਗੀ । ਕਈ ਪ੍ਰਿੰਟਇਨ ਵਿਧੀਆਂ ਹਨ ਜਿਵੇਂ:
| ਵੋਇਡ ਪ੍ਰਿੰਟ(ਬੂਲੀਅਨ ਬੀ) 17> | ਇੱਕ ਬੁਲੀਅਨ ਮੁੱਲ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void print(char c) | ਇੱਕ ਅੱਖਰ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void print(char) [] ਸ) | ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। |
| ਵੋਇਡ ਪ੍ਰਿੰਟ(ਡਬਲ ਡੀ) | ਇੱਕ ਡਬਲ-ਸ਼ੁੱਧਤਾ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕੀਤਾ ਗਿਆ ਹੈ। |
| ਵੋਇਡ ਪ੍ਰਿੰਟ(ਫਲੋਟ f) | ਇੱਕ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ ਪ੍ਰਿੰਟ ਕੀਤਾ ਗਿਆ ਹੈ। | <18
| void print(int i) | ਇੱਕ ਪੂਰਨ ਅੰਕ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void print(long l ) | ਇੱਕ ਲੰਬਾ ਪੂਰਨ ਅੰਕ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| void print(Object obj) | ਇੱਕ ਵਸਤੂ ਨੂੰ ਪ੍ਰਿੰਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। . |
| ਵੋਇਡ ਪ੍ਰਿੰਟ(ਸਟ੍ਰਿੰਗ s) | ਇੱਕ ਸਤਰ ਪ੍ਰਿੰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। |
ਪ੍ਰਿੰਟ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ
ਸੰਖੇਪ ਵਿੱਚ, ਦੋਵਾਂ ਵਿੱਚ ਮੁੱਖ ਅੰਤਰ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕੀਤੇ ਟੈਕਸਟ ਦੀ ਪਲੇਸਮੈਂਟ ਹੈ। PrintIn ਹੇਠਲੀ ਲਾਈਨ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਹੈ ਜਦੋਂ ਕਿ ਪ੍ਰਿੰਟ ਹੇਠਾਂ ਦਿੱਤੀ ਲਾਈਨ ਦੇ ਅੰਤ ਵਿੱਚ ਹੈ।
ਜੇਕਰ ਤੁਸੀਂ ਵਿੰਡੋਜ਼ 10-ਪ੍ਰੋ ਅਤੇ ਪ੍ਰੋ-ਐਨ ਬਾਰੇ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਜਾਂਚ ਕਰੋ ਮੇਰਾ ਹੋਰ ਲੇਖ।
Console.log ਕੀ ਹੈ?
Console.log
ਕੰਸੋਲ ਇੱਕ JavaScript ਵਸਤੂ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਡੀਬਗਿੰਗ ਕੰਸੋਲ ਤੱਕ ਪਹੁੰਚ ਦਿੰਦੀ ਹੈ।
ਕੰਸੋਲ.ਲੌਗ ਇੱਕ JavaScript ਹੈ ਫੰਕਸ਼ਨ ਜੋ ਕਿਸੇ ਵੀ ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜੋ ਇਸ ਵਿੱਚ ਪਹਿਲਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਨਾਲ ਹੀ ਕੋਈ ਵੀ ਜਾਣਕਾਰੀ ਜੋ ਉਪਭੋਗਤਾ ਨੂੰ ਦਿਖਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਆਉਟਪੁੱਟ ਜ਼ਿਆਦਾਤਰ ਟਰਮੀਨਲ 'ਤੇ ਲੌਗ (ਪ੍ਰਿੰਟ) ਹੁੰਦੀ ਹੈ। ਸਤਰ, ਐਰੇ, ਆਬਜੈਕਟ ਅਤੇ ਬੁਲੀਅਨ ਸਮੇਤ ਕਿਸੇ ਵੀ ਕਿਸਮ ਨੂੰ log() ਵਿੱਚ ਭੇਜਿਆ ਜਾ ਸਕਦਾ ਹੈ।
console.log() ਵਿਧੀ ਦਾਆਉਟਪੁੱਟ JavaScript ਕੰਸੋਲ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ, ਜੋ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਡਿਵੈਲਪਰ ਟੂਲ ਦੁਆਰਾ ਪਹੁੰਚਯੋਗ ਹੈ। console.log() ਨਾਲ ਤੁਸੀਂ ਜੋ ਵੀ ਆਉਟਪੁੱਟ ਕਰਦੇ ਹੋ, ਉਹ ਸਾਰੇ ਅੰਤਮ-ਉਪਭੋਗਤਿਆਂ ਲਈ ਪਹੁੰਚਯੋਗ ਹੁੰਦਾ ਹੈ, ਉਹਨਾਂ ਦੇ ਸਮੂਹ ਜਾਂ ਭੂਮਿਕਾ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।
ਆਓ ਇੱਕ ਝਾਤ ਮਾਰੀਏ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤ ਸਕਦੇ ਹੋ, ਅਤੇ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਾਅਦ ਆਉਟਪੁੱਟ।
| ਜਾਵਾ ਸਕ੍ਰਿਪਟ | ਆਉਟਪੁੱਟ |
// console. log() ਵਿਧੀ | abc 1 ਸਹੀ ਨਲ ਅਪਰਿਭਾਸ਼ਿਤ ਐਰੇ(4) [ 1, 2, 3, 4 ] ਆਬਜੈਕਟ { a : 1, b : 2 , c : 3
|
console.log ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ
ਕੀ ਹੈ Javascript ਵਿੱਚ Console.log ਵਿਧੀ ਨਾਲ ਕੰਸੋਲ ਵਿੱਚ ਪ੍ਰਿੰਟ ਕਰੋ?
ਇਹ JavaScript ਦਾ ਸਭ ਤੋਂ ਮਸ਼ਹੂਰ ਅਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਕੰਸੋਲ ਤਰੀਕਾ ਹੈ। ਇਹ ਵਿਧੀ ਅਕਸਰ ਕੰਸੋਲ 'ਤੇ ਵੱਖ-ਵੱਖ ਸੁਨੇਹਿਆਂ ਜਾਂ ਗਣਨਾ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਜਾਂ ਕੋਡ ਡੀਬੱਗ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
ਤੁਸੀਂ ਕੁਝ ਕੋਡ ਲਿਖਿਆ ਹੈ ਜੋ ਦੋ ਨੰਬਰ ਜੋੜਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਨਤੀਜਾ ਦੇਖਣਾ ਚਾਹੋਗੇ ਕੰਸੋਲ ਉੱਤੇ ਉਸ ਕਾਰਵਾਈ ਦਾ; ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਤੁਸੀਂ console.log() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
3617
ਕੀ Console.log ਸਮਕਾਲੀ ਜਾਂ ਅਸਿੰਕ੍ਰੋਨਸ ਹੈ?
ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਮੈਂ ਤੁਹਾਡੇ ਨਾਲ ਚਰਚਾ ਕਰਾਂ ਕਿ console.log ਸਮਕਾਲੀ ਹੈ ਜਾਂ ਅਸਿੰਕਰੋਨਸ, ਮੈਂ ਪਹਿਲਾਂ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗਾ ਕਿ ਸਮਕਾਲੀ ਅਤੇ ਅਸਿੰਕਰੋਨਸ ਕੀ ਹਨ।
ਸਮਕਾਲੀ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਇੱਕੋ ਸਮੇਂ ਵਾਪਰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਅਸਿੰਕ੍ਰੋਨਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਇੱਕੋ ਸਮੇਂ ਨਹੀਂ ਵਾਪਰਦਾ। ਇਸ ਲਈਸਮਕਾਲੀ ਵਿੱਚ ਭਾਗੀਦਾਰ/ਉਪਭੋਗਤਾ ਤੁਰੰਤ ਫੀਡਬੈਕ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਨ। ਅਸਿੰਕ੍ਰੋਨਸ ਤੁਹਾਨੂੰ ਆਪਣੇ ਸਮੇਂ ਵਿੱਚ ਸਿੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
ਜਵਾਬ ਦੇਣ ਲਈ, concole.log ਅਸਿੰਕ੍ਰੋਨਸ ਹੈ। ਮੈਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗਾ ਕਿ ਅਜਿਹਾ ਕਿਉਂ ਹੈ, ਉਦਾਹਰਣਾਂ ਦਿਖਾ ਕੇ, ਖਾਸ ਤੌਰ 'ਤੇ ਵਸਤੂਆਂ ਦੀ ਲੜੀ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਨਾਲ ਛਾਂਟਣਾ। ਚਲੋ ਸ਼ੁਰੂ ਕਰੀਏ।
ਆਓ ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੀ ਐਰੇ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਵਸਤੂਆਂ ਹਨ:
| ਵਰਤੋਂ ਕਰਨ ਦਿਓ = [ { ਨਾਮ: “ਨਿਕੋਲ” , ਉਮਰ: 20, ਉਪਨਾਮ: “ਲੂਨਾ” } , { ਨਾਮ: “ਕਾਰਾ” , ਉਮਰ: 21, ਉਪਨਾਮ: “ਲਿਮ” } , { ਨਾਮ: “ਲਾਰਾ” , ਉਮਰ: 20, ਉਪਨਾਮ: “ਟੂਆਜ਼ੋਨ” }; ] |
ਐਰੇ ਆਬਜੈਕਟ
ਤੁਹਾਨੂੰ ਇਸ ਐਰੇ ਨੂੰ ਫੀਲਡ ਨਾਮ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਤਰ੍ਹਾਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
| // ਨਾਮ ਦੁਆਰਾ (ਕਾਰਾ, ਲਾਰਾ, ਨਿਕੋਲ ) users.sort ( ( a, b ) => a.name > b.name ? 1 : -1); / / ਉਮਰ ਦੁਆਰਾ (ਲਾਰਾ, ਨਿਕੋਲ, ਕਾਰਾ ) users.sort ( ( a, b ) => a.age > b.name ? 1 : -1);
|
users.sort(byField('age' ));
ਐਰੇ ਆਬਜੈਕਟਸ ਨੂੰ ਛਾਂਟਣਾ (ਸਧਾਰਨ ਤਰੀਕੇ ਨਾਲ)
ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਾਸ ਕਰਨ ਲਈ "ਬਾਈਫੀਲਡ" ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਆਪਣੀ ਐਰੇ ਵਿੱਚ ਆਬਜੈਕਟ ਦੇ Array.prototype.sort ਵਿੱਚ ਛਾਂਟਣਾ ਚਾਹੀਦਾ ਹੈ। ਖੈਰ, ਇਹ ਇਸ ਲੇਖ ਦਾ ਮੁੱਖ ਫੋਕਸ ਨਹੀਂ ਹੈ ਪਰ ਕਿਰਪਾ ਕਰਕੇ ਉਪਰੋਕਤ ਉਦਾਹਰਣ ਨੂੰ ਸਰਲ ਤਰੀਕੇ ਨਾਲ ਪੂਰਾ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵੇਖੋ।
| > ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ =[ { ਨਾਮ: “ਨਿਕੋਲ”, ਉਮਰ: 20, ਉਪਨਾਮ: “ਲੂਨਾ” } , { ਨਾਮ: “ਕੈਰਾ” , ਉਮਰ: 21, ਉਪਨਾਮ: “ਲਿਮ” } , { ਨਾਮ: “ਲਾਰਾ”, ਉਮਰ: 20, ਉਪਨਾਮ: "ਟੁਆਜ਼ੋਨ" }; ] ਫੀਲਡ ਦੁਆਰਾ ਫੰਕਸ਼ਨ (ਫੀਲਡ ਨਾਮ) { ਰਿਟਰਨ (ਏ, ਬੀ ) => a[fieldName]? 1 : -1 ; users.sort(byField( 'name' ) ); concole.log(users); users.sort(byField( 'age' ) ); concole.log(users); (3) [ { … }, { … }, { … } ] > 0: { ਨਾਮ: " ਲਾਰਾ ", ਉਮਰ: " 20 " , ਉਪਨਾਮ: " Tuazon " > 1: { ਨਾਮ: ” ਨਿਕੋਲ “, ਉਮਰ: ” 20 ” , ਉਪਨਾਮ: ” ਲੂਨਾ ” > 1: { ਨਾਮ: ” ਕਾਰਾ “, ਉਮਰ: ” 21 ” , ਉਪਨਾਮ: ” ਲਿਮ ” ਲੰਬਾਈ: 3 > _proto_: ਐਰੇ (0) (3) [ { … }, { … }, { … } ] > 0: { ਨਾਮ: " ਲਾਰਾ ", ਉਮਰ: " 20 " , ਉਪਨਾਮ: " Tuazon " > 1: { ਨਾਮ: ” ਨਿਕੋਲ “, ਉਮਰ: ” 20 ” , ਉਪਨਾਮ: ” ਲੂਨਾ ” > 1: { ਨਾਮ: ” ਕਾਰਾ “, ਉਮਰ: ” 21 ” , ਉਪਨਾਮ: ” ਲਿਮ ” ਲੰਬਾਈ: 3 > _proto_: ਐਰੇ (0)
|
ਕ੍ਰਮਬੱਧ ਐਰੇ ਆਬਜੈਕਟ
ਤੁਸੀਂ ਉਪਰੋਕਤ ਸਾਰਣੀ ਤੋਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਮੈਂ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹਾਂ ਐਰੇ ਆਬਜੈਕਟਸ ਦੋ ਵਾਰ, ਮੈਂ ਪਹਿਲਾਂ ਨਾਮ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕਰਦਾ ਹਾਂ, ਅਗਲੀ ਉਮਰ ਦੁਆਰਾ, ਅਤੇ ਹਰੇਕ ਲੜੀਬੱਧ ਕਾਰਵਾਈ ਤੋਂ ਬਾਅਦ, ਮੈਂ console.log () ਚਲਾਉਂਦਾ ਹਾਂ. ਨਾਲ ਹੀ, ਤੁਸੀਂ ਦੇਖਿਆ ਹੋਵੇਗਾ ਕਿ console.log() ਨੇ ਹਰ ਕਿਸਮ ਦੇ ਨਤੀਜੇ ਲਈ ਇੱਕੋ ਆਉਟਪੁੱਟ ਨੂੰ ਬਹਾਲ ਕੀਤਾ ਹੈ, ਪਰ ਅਜਿਹਾ ਨਹੀਂ ਹੈ; ਮੈਨੂੰ ਇਹ ਦੱਸਣ ਦਿਓ ਕਿ ਕਿਉਂ।
ਮੈਂ ਸਭ ਤੋਂ ਉੱਪਰ ਕੋਡ ਨੂੰ ਇੱਕੋ ਵਾਰ ਚਲਾਇਆ, ਫਿਰ console.log () ਤੋਂ ਹਰ ਪ੍ਰਤੀਕ੍ਰਿਆ ਨੂੰ ਵਧਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ console.log() ਹੈਅਸਿੰਕ੍ਰੋਨਸ।
ਈਵੈਂਟ ਲੂਪ ਦੇ ਰੂਪ ਵਿੱਚ, ਸਾਰੀਆਂ ਅਸਿੰਕਰੋਨਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇਵੈਂਟ ਟੇਬਲ 'ਤੇ ਪਹੁੰਚਦੀਆਂ ਹਨ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, console.log() ਨੂੰ ਲਿਆਉਣ ਤੋਂ ਬਾਅਦ, ਇਹ ਇਵੈਂਟ ਟੇਬਲ ਤੇ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਖਾਸ ਘਟਨਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ।
ਜਦੋਂ ਕੋਈ ਇਵੈਂਟ ਵਾਪਰਦਾ ਹੈ, ਤਾਂ console.log() ਨੂੰ ਇਵੈਂਟ ਕਤਾਰ ਵਿੱਚ ਭੇਜਿਆ ਜਾਵੇਗਾ, ਜਿੱਥੇ ਇਹ ਇਸ ਇਵੈਂਟ ਕਤਾਰ ਵਿੱਚ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਹੋਣ ਤੱਕ ਇੰਤਜ਼ਾਰ ਕਰਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਸਨ ਜਦੋਂ ਤੁਹਾਡਾ console.log ਰੱਖਿਆ ਗਿਆ ਸੀ ਅਤੇ ਕਾਲ ਵਿੱਚ ਭੇਜਿਆ ਗਿਆ ਸੀ। ਸਟੈਕ, ਫਿਰ ਤੁਹਾਡੇ console.log() ਨੂੰ ਇਸ ਕਾਲ ਸਟੈਕ 'ਤੇ ਵੀ ਭੇਜਿਆ ਜਾ ਰਿਹਾ ਹੈ।
Javascript Console.log ਨੂੰ ਕਿਵੇਂ ਖੋਲ੍ਹਿਆ ਜਾਵੇ?
ਵੈੱਬ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ, ਕੰਸੋਲ ਕਈ ਡਿਵੈਲਪਰ ਟੂਲਸ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਆਪਣੇ JavaScript ਕੋਡ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਕੰਸੋਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਕੰਸੋਲ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਆਧਾਰ 'ਤੇ ਕਈ ਥਾਵਾਂ 'ਤੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
ਮੈਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਨੂੰ ਸਿਖਾਵਾਂਗਾ ਕਿ ਤੁਹਾਡੇ Google Chrome ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਕੰਸੋਲ ਨੂੰ ਕਿੱਥੇ ਖੋਜਣਾ ਹੈ।
Chrome ਵਿੱਚ ਕੰਸੋਲ ਲੌਗ ਨੂੰ ਕਿਵੇਂ ਖੋਲ੍ਹਣਾ ਹੈ ਇਸ ਬਾਰੇ ਕਦਮ
ਆਓ ਦੇਖੀਏ ਕਿ Chrome ਕੰਸੋਲ ਲੌਗ ਨੂੰ ਕਿਵੇਂ ਖੋਲ੍ਹਣਾ ਹੈ।
- Chrome ਬ੍ਰਾਊਜ਼ਰ ਖੁੱਲ੍ਹਣ ਵੇਲੇ ਪੌਪ-ਅੱਪ ਮੀਨੂ ਤੋਂ ਨਿਰੀਖਣ ਕਰੋ ਨੂੰ ਚੁਣੋ।
- ਡਿਵੈਲਪਰ ਟੂਲਸ ਦੇ “ਐਲੀਮੈਂਟਸ ਜਦੋਂ ਤੁਸੀਂ ਨਿਰੀਖਣ ਕਰਦੇ ਹੋ ਤਾਂ ਟੈਬ ਮੂਲ ਰੂਪ ਵਿੱਚ ਖੋਲ੍ਹਿਆ ਜਾਵੇਗਾ। "ਐਲੀਮੈਂਟਸ" ਦੇ ਸੱਜੇ ਪਾਸੇ, "ਕੰਸੋਲ" 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
- ਤੁਸੀਂ ਹੁਣ ਕੰਸੋਲ ਦੇ ਨਾਲ-ਨਾਲ ਕੰਸੋਲ ਲੌਗ ਵਿੱਚ ਰਿਕਾਰਡ ਕੀਤੇ ਕਿਸੇ ਵੀ ਆਉਟਪੁੱਟ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ।
ਤੁਸੀਂ ਵੀ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ। ਕਈ ਸ਼ਾਰਟਕੱਟ ਕੁੰਜੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Chrome ਡਿਵੈਲਪਰ ਟੂਲ। ਤੁਹਾਡੇ Chrome ਦੇ ਸੰਸਕਰਣ ਦੇ ਅਨੁਸਾਰ, ਤੁਸੀਂਹੇਠਾਂ ਦਿੱਤੇ ਸ਼ਾਰਟਕੱਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:
ਵਿੰਡੋਜ਼ ਅਤੇ ਲੀਨਕਸ ਲਈ,
| Ctrl + Shift + I | ਡਿਵੈਲਪਰ ਟੂਲ ਵਿੰਡੋ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ। |
| Ctrl + Shift + J | ਡਿਵੈਲਪਰ ਟੂਲਸ ਵਿੱਚ ਕੰਸੋਲ ਟੈਬ ਨੂੰ ਚੁਣਦਾ ਹੈ। |
| Ctrl + Shift + C<17 | ਐਲੀਮੈਂਟ ਮੋਡ ਟੌਗਲਾਂ ਦੀ ਜਾਂਚ ਕਰੋ |
ਸ਼ਾਰਟਕੱਟ ਕੁੰਜੀਆਂ
ਅੰਤਿਮ ਵਿਚਾਰ
ਪ੍ਰਿੰਟਇਨ ਵਿਚਕਾਰ ਮੁੱਖ ਅੰਤਰ ਅਤੇ console.log ਉਹਨਾਂ ਦਾ ਫੰਕਸ਼ਨ ਹੈ ਅਤੇ ਕੋਡ ਦਾ ਨਤੀਜਾ । ਪ੍ਰਿੰਟਇਨ ਟੈਕਸਟ ਨੂੰ ਕੰਸੋਲ ਤੇ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿ console.log ਕਿਸੇ ਵੀ ਵੇਰੀਏਬਲ ਨੂੰ ਸਤਰ ਦੇ ਨਾਲ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਕੋਡ ਕੀਤੇ ਗਏ ਹਨ।
ਅਸਲ ਵਿੱਚ, Javascript ਦੇ ਇਹ ਫੰਕਸ਼ਨ ਤੁਹਾਨੂੰ ਕੰਸੋਲ ਵਿੱਚ ਵੇਰੀਏਬਲ ਅਤੇ ਟੈਕਸਟ ਨੂੰ ਪ੍ਰਿੰਟ ਅਤੇ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ। JavaScript ਵਿੱਚ, ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਢੰਗਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਿੰਟ ਕਰ ਸਕਦੇ ਹੋ।
ਡੀਬੱਗ ਕਰਨ ਵੇਲੇ JavaScript ਕੰਸੋਲ ਲੌਗ ਵਿਧੀ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਵਿਕਲਪ ਹੈ। ਆਪਣੇ ਕੋਡ ਨੂੰ ਹੋਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਡੀਬੱਗ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਸਾਰਿਆਂ ਦਾ ਅਭਿਆਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਵਰਤਣਾ ਸਿੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।
ਪ੍ਰੋਗਰਾਮਰ ਅਤੇ ਡਿਵੈਲਪਰ ਅਕਸਰ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਿਸੇ ਵੀ ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕਰਦੇ ਹਨ ਜੋ ਇਸ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤੇ ਗਏ ਹਨ, ਨਾਲ ਹੀ ਕੋਈ ਵੀ ਜਾਣਕਾਰੀ ਜਿਸਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਉਪਭੋਗਤਾ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਲਈ.
