ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਇੱਕ ਵੇਰੀਏਬਲ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਤਾਂ ਇਸਦੀ ਪੁਸ਼ਟੀ ਕਿਵੇਂ ਕਰੀਏ

JavaScript ਵਿੱਚ ਵੇਰੀਏਬਲ ਕਿਸਮਾਂ ਨੂੰ ਸਮਝਣਾ

JavaScript ਵਿੱਚ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਬੁਨਿਆਦੀ ਹੁਨਰ ਹੈ। ਵੱਖ-ਵੱਖ ਡੇਟਾ ਕਿਸਮਾਂ ਵਿੱਚ, ਸਤਰ ਟੈਕਸਟ ਅਤੇ ਅੱਖਰਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੇ ਹਨ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇਹ ਜਾਂਚਣ ਲਈ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਪੜਚੋਲ ਕਰਾਂਗੇ ਕਿ ਕੀ ਇੱਕ ਵੇਰੀਏਬਲ JavaScript ਵਿੱਚ ਇੱਕ ਸਤਰ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾ ਕੇ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ​​ਅਤੇ ਗਲਤੀ-ਮੁਕਤ ਕੋਡ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ ਕਿ ਤੁਹਾਡੇ ਵੇਰੀਏਬਲ ਸੰਭਾਵਿਤ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਰੱਖਦੇ ਹਨ।

JavaScript ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕਰਨਾ

ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ JavaScript ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਰੰਟਐਂਡ ਲਾਗੂਕਰਨ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ। ਇਹ ਦੋ ਪ੍ਰਾਇਮਰੀ ਤਰੀਕਿਆਂ ਨੂੰ ਵਰਤਦਾ ਹੈ: typeof ਅਤੇ instanceof. ਦ typeof ਆਪਰੇਟਰ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦਾ ਇੱਕ ਸਿੱਧਾ ਤਰੀਕਾ ਹੈ। ਜਦੋਂ ਕਿਸੇ ਵੇਰੀਏਬਲ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਿਸਮ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ 'ਸਟਰਿੰਗ', 'ਨੰਬਰ', ਜਾਂ 'ਬੁਲੀਅਨ'। ਇਹ ਵਿਧੀ ਮੁੱਢਲੇ ਸਤਰ ਮੁੱਲਾਂ ਲਈ ਸਰਲ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ। ਦੂਜੇ ਪਾਸੇ, ਦ instanceof ਓਪਰੇਟਰ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਵਸਤੂ ਕਿਸੇ ਖਾਸ ਕੰਸਟਰਕਟਰ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਏ ਗਏ ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਇਹ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ new String() ਕੰਸਟਰਕਟਰ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨਾਂ ਦੇ ਨਾਲ ਦੋਨਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੀ ਹੈ ਤਾਂ ਜੋ ਦੋਨਾਂ ਮੁੱਢਲੀਆਂ ਸਤਰਾਂ ਅਤੇ ਸਟ੍ਰਿੰਗ ਆਬਜੈਕਟਾਂ ਲਈ ਵਿਆਪਕ ਕਿਸਮ ਦੀ ਜਾਂਚ ਨੂੰ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ।

ਦੂਜੀ ਸਕ੍ਰਿਪਟ Node.js ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬੈਕਐਂਡ ਪ੍ਰਮਾਣਿਕਤਾ ਨੂੰ ਸੰਬੋਧਨ ਕਰਦੀ ਹੈ। ਇਹ ਆਯਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ http ਮੋਡੀਊਲ ਅਤੇ ਨਾਲ ਇੱਕ HTTP ਸਰਵਰ ਬਣਾਉਣਾ http.createServer() ਫੰਕਸ਼ਨ। ਸਰਵਰ URL ਮਾਰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਮੁੱਲ ਕੱਢਦਾ ਹੈ req.url ਅਤੇ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇਹ ਇੱਕ ਸਤਰ ਹੈ। ਦ typeof ਓਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਇੱਥੇ ਮੁੱਲ ਦੀ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨਤੀਜੇ ਦੇ ਆਧਾਰ 'ਤੇ, ਸਰਵਰ ਢੁਕਵੇਂ ਸੁਨੇਹਿਆਂ ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਦ res.writeHead() ਵਿਧੀ ਜਵਾਬ ਸਿਰਲੇਖਾਂ ਨੂੰ ਸੈੱਟ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਥਿਤੀ ਕੋਡ ਅਤੇ ਸਮੱਗਰੀ ਦੀ ਕਿਸਮ, ਅਤੇ res.end() ਵਿਧੀ ਅੰਤਮ ਜਵਾਬ ਗਾਹਕ ਨੂੰ ਵਾਪਸ ਭੇਜਦੀ ਹੈ। ਸਰਵਰ ਪੋਰਟ 3000 'ਤੇ ਆਉਣ ਵਾਲੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਸੁਣਦਾ ਹੈ, ਬੈਕਐਂਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਕਿਸਮ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਇੱਕ ਵਿਹਾਰਕ ਉਦਾਹਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

// Method 1: Using typeof
function isString(value) {
  return typeof value === 'string';
}
// Example usage
console.log(isString("Hello")); // true
console.log(isString(123)); // false

// Method 2: Using instanceof
function isString(value) {
  return value instanceof String || typeof value === 'string';
}
// Example usage
console.log(isString(new String("Hello"))); // true
console.log(isString("World")); // true
console.log(isString(123)); // false

const http = require('http');
// Create an HTTP server
const server = http.createServer((req, res) => {
  let value = req.url.substring(1); // Get value from URL path
  if (typeof value === 'string') {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('The value is a string');
  } else {
    res.writeHead(400, {'Content-Type': 'text/plain'});
    res.end('The value is not a string');
  }
});
server.listen(3000, () => {
  console.log('Server is running at http://localhost:3000');
});

JavaScript ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਉੱਨਤ ਢੰਗ

ਬੁਨਿਆਦੀ ਤੋਂ ਇਲਾਵਾ typeof ਅਤੇ instanceof ਵਿਧੀਆਂ, JavaScript ਸਤਰ ਪ੍ਰਮਾਣਿਕਤਾ ਲਈ ਹੋਰ ਉੱਨਤ ਤਕਨੀਕਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ। ਇੱਕ ਅਜਿਹਾ ਤਰੀਕਾ ਵਰਤ ਰਿਹਾ ਹੈ Object.prototype.toString.call() ਫੰਕਸ਼ਨ. ਇਹ ਪਹੁੰਚ ਲਾਭਦਾਇਕ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਸਹੀ ਕਿਸਮ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਇੱਕ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਬੁਲਾ ਕੇ Object.prototype.toString.call(value), ਤੁਹਾਨੂੰ ਸਟ੍ਰਿੰਗ ਵੈਲਯੂਜ਼ ਲਈ "[object String]" ਵਰਗੀ ਇੱਕ ਸਤਰ ਮਿਲਦੀ ਹੈ, ਜਿਸਦੀ ਫਿਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਤੁਲਨਾ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਇੱਕ ਸਤਰ ਹੈ। ਇਹ ਵਿਧੀ ਖਾਸ ਤੌਰ 'ਤੇ ਗੁੰਝਲਦਾਰ ਕੋਡਬੇਸਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ ਜਿੱਥੇ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਕਿਸਮ ਤੁਰੰਤ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੋ ਸਕਦੀ ਹੈ।

ਇੱਕ ਹੋਰ ਉੱਨਤ ਵਿਧੀ ਵਿੱਚ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਸ਼ਾਮਲ ਹੈ। ਰੈਗੂਲਰ ਸਮੀਕਰਨ, ਜਾਂ regex, ਦੀ ਵਰਤੋਂ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਕੀ ਕੋਈ ਵੇਰੀਏਬਲ ਕਿਸੇ ਖਾਸ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ RegExp ਇੱਕ regex ਬਣਾਉਣ ਲਈ ਆਬਜੈਕਟ ਜੋ ਸਿਰਫ਼ ਸਤਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਹ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਇੱਕ ਸਤਰ ਕਿਸੇ ਖਾਸ ਫਾਰਮੈਟ, ਜਿਵੇਂ ਕਿ ਈਮੇਲ ਪਤਾ ਜਾਂ ਫ਼ੋਨ ਨੰਬਰ ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ। ਬੁਨਿਆਦੀ ਤਰੀਕਿਆਂ ਨਾਲ ਇਹਨਾਂ ਉੱਨਤ ਤਕਨੀਕਾਂ ਨੂੰ ਜੋੜਨਾ ਮਜਬੂਤ ਅਤੇ ਬਹੁਮੁਖੀ ਸਟ੍ਰਿੰਗ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਹਾਡਾ JavaScript ਕੋਡ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕਰਦਾ ਹੈ ਅਤੇ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਦੇ ਜੋਖਮ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

JavaScript ਵਿੱਚ ਵੇਰੀਏਬਲ ਟਾਈਪ ਚੈਕਿੰਗ ਨੂੰ ਸਮੇਟਣਾ

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਕਿ ਕੀ ਇੱਕ ਵੇਰੀਏਬਲ JavaScript ਵਿੱਚ ਇੱਕ ਸਤਰ ਹੈ, ਭਰੋਸੇਯੋਗ ਅਤੇ ਕੁਸ਼ਲ ਕੋਡ ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਵਰਗੇ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ typeof, instanceof, ਅਤੇ ਉੱਨਤ ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ Object.prototype.toString.call() ਅਤੇ ਨਿਯਮਤ ਸਮੀਕਰਨ ਵਿਆਪਕ ਪ੍ਰਮਾਣਿਕਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ। ਇਹਨਾਂ ਰਣਨੀਤੀਆਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਭਰੋਸੇ ਨਾਲ ਵੇਰੀਏਬਲ ਕਿਸਮਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਸਕਦੇ ਹਨ, ਕੋਡ ਸਥਿਰਤਾ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹਨ ਅਤੇ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹਨ।