ਵਿਚਕਾਰ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ! ਅਤੇ ? TypeScript ਵਿੱਚ ਓਪਰੇਟਰ

ਸੁਰੱਖਿਅਤ ਪਹੁੰਚ ਅਤੇ ਦਾਅਵੇ ਲਈ ਟਾਈਪਸਕ੍ਰਿਪਟ ਆਪਰੇਟਰਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ TypeScript, ਡਿਵੈਲਪਰ ਅਕਸਰ ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ ਜਿੱਥੇ ਉਹਨਾਂ ਨੂੰ ਕਿਸੇ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਾਂ ਤਰੀਕਿਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਹੋ ਸਕਦਾ ਹੈ ਪਰਿਭਾਸ਼ਿਤ ਜਾਂ null. ਇਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, ਦ ! (ਵਿਸਮਿਕ ਚਿੰਨ੍ਹ) ਅਤੇ ?(ਪ੍ਰਸ਼ਨ ਚਿੰਨ੍ਹ) ਓਪਰੇਟਰ ਖੇਡ ਵਿੱਚ ਆਉਂਦੇ ਹਨ। ਇਹ ਆਪਰੇਟਰ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਇਹ ਨਿਯੰਤਰਣ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ ਕਿ ਕਿਵੇਂ TypeScript ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਹੈਂਡਲ ਕਰਦੀ ਹੈ null ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਮੁੱਲ।

ਦ ! ਆਪਰੇਟਰ, ਆਮ ਤੌਰ 'ਤੇ "ਨਾਨ-ਨਲ ਅਸੈਸਸ਼ਨ ਆਪਰੇਟਰ" ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ, ਦੀ ਵਰਤੋਂ ਟਾਈਪਸਕ੍ਰਿਪਟ ਕੰਪਾਈਲਰ ਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਵੇਰੀਏਬਲ ਜਾਂ ਸਮੀਕਰਨ ਤੱਕ ਪਹੁੰਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ। null ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ. ਦੂਜੇ ਪਾਸੇ, ਦ ?. ਓਪਰੇਟਰ, ਜਾਂ "ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਓਪਰੇਟਰ," ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਸਤੂ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਾਂ ਵਿਧੀਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ।

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

ਵਿਚਕਾਰ ਮੁੱਖ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ obj!.ਪ੍ਰਾਪਰਟੀ ਅਤੇ obj?.ਪ੍ਰਾਪਰਟੀ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਹੋਰ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ਮਜ਼ਬੂਤ ​​TypeScript ਕੋਡ, ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਆਮ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣਾ। ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇਹਨਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ ਇਹਨਾਂ ਸੰਕਲਪਾਂ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਡੁਬਕੀ ਲਵਾਂਗੇ।

TypeScript ਵਿੱਚ ਗੈਰ-ਨਲ ਦਾਅਵੇ ਅਤੇ ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਪਹਿਲਾ ਸੈੱਟ ਦੋ ਮਹੱਤਵਪੂਰਨ ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ: ਗੈਰ-ਨਲ ਦਾਅਵਾ ਆਪਰੇਟਰ (!) ਅਤੇ ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਆਪਰੇਟਰ (?.) ਗੈਰ-ਨੱਲ ਦਾਅਵਾ ਟਾਈਪਸਕ੍ਰਿਪਟ ਕੰਪਾਈਲਰ ਨੂੰ ਇਹ ਦੱਸਣ ਦਾ ਇੱਕ ਸਿੱਧਾ ਤਰੀਕਾ ਹੈ ਕਿ ਇੱਕ ਮੁੱਲ ਕਦੇ ਵੀ ਨਲ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੋਵੇਗਾ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਨਿਸ਼ਚਿਤ ਹੁੰਦੇ ਹਾਂ ਕਿ ਰਨਟਾਈਮ ਦੌਰਾਨ ਕੋਈ ਵਸਤੂ ਮੌਜੂਦ ਰਹੇਗੀ, ਭਾਵੇਂ ਕਿ ਟਾਈਪਸਕ੍ਰਿਪਟ ਕੰਪਾਇਲ ਸਮੇਂ ਇਹ ਸਾਬਤ ਨਹੀਂ ਕਰ ਸਕਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਵਿੱਚ obj!.data, ਅਸੀਂ ਕੰਪਾਈਲਰ ਨੂੰ ਕੋਈ ਵੀ null ਚੈਕ ਛੱਡਣ ਲਈ ਕਹਿ ਰਹੇ ਹਾਂ ਅਤੇ ਮੰਨ ਲਓ ਕਿ obj ਮੌਜੂਦ ਹੈ। ਇਹ ਪਹੁੰਚ, ਜਦਕਿ ਸੁਵਿਧਾਜਨਕ, ਅਗਵਾਈ ਕਰ ਸਕਦਾ ਹੈ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਜੇਕਰ ਵਸਤੂ ਨਲ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਹੋ ਜਾਂਦੀ ਹੈ।

ਦੂਜੇ ਪਾਸੇ, ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਓਪਰੇਟਰ ਇੱਕ ਆਬਜੈਕਟ ਵਿੱਚ ਨੇਸਟਡ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜਾਂ ਤਰੀਕਿਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇੱਕ ਸੁਰੱਖਿਅਤ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਕਿ null ਹੋ ਸਕਦਾ ਹੈ। ਦੀ ਹਾਲਤ ਵਿੱਚ obj?.data, ਕੋਡ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਡੇਟਾ ਸੰਪੱਤੀ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਸਤੂ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ। ਜੇ ਵਸਤੂ ਨਲ ਜਾਂ ਪਰਿਭਾਸ਼ਿਤ ਹੈ, ਤਾਂ ਇਹ ਗਲਤੀ ਸੁੱਟਣ ਦੀ ਬਜਾਏ ਪਰਿਭਾਸ਼ਿਤ ਵਾਪਸ ਆਉਂਦੀ ਹੈ। ਇਹ ਵਿਧੀ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਗਤੀਸ਼ੀਲ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ ਉਪਯੋਗੀ ਹੈ ਜਿੱਥੇ ਵਸਤੂਆਂ ਨੂੰ ਸ਼ਰਤ ਅਨੁਸਾਰ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ APIs ਵਰਗੇ ਬਾਹਰੀ ਸਰੋਤਾਂ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਕਰੈਸ਼ ਜਾਂ ਅਚਾਨਕ ਵਿਵਹਾਰ ਨੂੰ ਰੋਕਦਾ ਹੈ, ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਹੋਰ ਬਣਾਉਂਦਾ ਹੈ ਲਚਕੀਲਾ.

ਦੂਜੀ ਉਦਾਹਰਣ ਇਹਨਾਂ ਓਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨਾਂ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀ ਹੈ। ਗੈਰ-ਨਲ ਦਾਅਵੇ ਦੇ ਨਾਲ, ਅਸੀਂ ਇੱਕ ਵਿਧੀ ਦੀ ਮੰਗ ਨੂੰ ਮਜਬੂਰ ਕਰਦੇ ਹਾਂ, ਇਹ ਮੰਨਦੇ ਹੋਏ ਕਿ ਵਸਤੂ ਅਤੇ ਵਿਧੀ ਦੋਵੇਂ ਮੌਜੂਦ ਹਨ, ਜਿਵੇਂ ਕਿ ਵਿੱਚ ਦੇਖਿਆ ਗਿਆ ਹੈ obj!.doSomething(). ਇਹ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਮਦਦਗਾਰ ਹੋ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਡਿਵੈਲਪਰ ਦਾ ਡੇਟਾ 'ਤੇ ਪੂਰਾ ਨਿਯੰਤਰਣ ਹੁੰਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਧਾਰਨਾ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ ਤਾਂ ਇਹ ਇੱਕ ਜੋਖਮ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਵਿਧੀ ਮੌਜੂਦ ਨਹੀਂ ਹੈ ਜਾਂ ਆਬਜੈਕਟ ਖਾਲੀ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਅਪਵਾਦ ਸੁੱਟੇਗਾ। ਇਹ ਗੈਰ-ਨੂਲ ਦਾਅਵੇ ਨੂੰ ਇੱਕ ਉੱਚ-ਜੋਖਮ, ਉੱਚ-ਇਨਾਮ ਟੂਲ ਬਣਾਉਂਦਾ ਹੈ।

ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਫੰਕਸ਼ਨ ਕਾਲਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਵਿੱਚ obj?.doSomething(), ਇਸ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਜਾਂਚ ਕਰਕੇ ਕਿ ਕੀ ਵਿਧੀ ਮੌਜੂਦ ਹੈ, ਅਜਿਹੀਆਂ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ। ਜੇਕਰ ਵਿਧੀ ਜਾਂ ਆਬਜੈਕਟ ਪਰਿਭਾਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਤਾਂ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਗਲਤੀ ਸੁੱਟੇ ਬਿਨਾਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਜਾਰੀ ਰੱਖਦਾ ਹੈ। ਇਸ ਤਕਨੀਕ ਦੀ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਆਬਜੈਕਟ ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਾਂ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕੁਝ ਪੜਾਵਾਂ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਸੁਰੱਖਿਅਤ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਵਰਬੋਜ਼ ਨਲ-ਚੈਕਿੰਗ ਕੋਡ ਦੀ ਲੋੜ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਦੋਵਾਂ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਕੋਡ ਪੜ੍ਹਨਯੋਗਤਾ।

// Example 1: Using non-null assertion operator (!)
// The assumption here is that obj is definitely not null or undefined
const obj: { data?: string } | null = { data: 'Hello' };
const data: string = obj!.data;  // Non-null assertion, ignores potential null/undefined
console.log(data);  // Output: 'Hello'

// Example 2: Optional chaining (?.) for safer access
// This approach checks if obj exists before accessing data property
const obj2: { data?: string } | null = null;
const data2: string | undefined = obj2?.data;  // Safely returns undefined if obj2 is null
console.log(data2);  // Output: undefined

// Note: The first approach forces the compiler to assume obj is not null
// The second approach ensures no runtime error if obj is null or undefined

// Example 1: Using non-null assertion operator for function invocation
// Assumes obj is not null or undefined before invoking the method
const objFunc: { doSomething?: () => void } | null = { doSomething: () => console.log('Action') };
objFunc!.doSomething();  // Forces execution, assuming objFunc is valid

// Example 2: Optional chaining operator for function invocation
// This approach safely checks if objFunc exists before calling the method
const objFunc2: { doSomething?: () => void } | null = null;
objFunc2?.doSomething();  // No error thrown, simply does nothing if objFunc2 is null

// Conclusion: Non-null assertion is riskier but direct, while optional chaining is safer but may return undefined

// Unit Test 1: Testing non-null assertion operator (!)
import { expect } from 'chai';
it('should return data with non-null assertion', () => {
  const obj = { data: 'Test' };
  const result = obj!.data;
  expect(result).to.equal('Test');
});

// Unit Test 2: Testing optional chaining operator (?.)
it('should return undefined if obj is null using optional chaining', () => {
  const obj = null;
  const result = obj?.data;
  expect(result).to.be.undefined;
});

// Ensures both methods behave as expected in null/undefined scenarios

ਉੱਨਤ ਤਕਨੀਕਾਂ: ਗੈਰ-ਨਲ ਦਾਅਵੇ ਅਤੇ ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

ਦੇ ਬੁਨਿਆਦੀ ਵਰਤੋਂ ਦੇ ਕੇਸਾਂ ਤੋਂ ਇਲਾਵਾ ਗੈਰ-ਨਲ ਦਾਅਵਾ ਅਤੇ ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਪਹਿਲਾਂ ਚਰਚਾ ਕੀਤੀ ਗਈ ਸੀ, ਇਹ ਓਪਰੇਟਰ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਵੀ ਮਹੱਤਵਪੂਰਨ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੱਡੇ ਪੈਮਾਨੇ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ। ਜਦੋਂ ਡੂੰਘਾਈ ਨਾਲ ਨੇਸਟਡ ਵਸਤੂਆਂ ਜਾਂ APIs ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਵੱਡੇ ਡੇਟਾਸੇਟਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ ਜਿੱਥੇ ਐਪਲੀਕੇਸ਼ਨ ਜੀਵਨ ਚੱਕਰ ਦੇ ਵੱਖ-ਵੱਖ ਪੜਾਵਾਂ 'ਤੇ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਮੌਜੂਦ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਾਂ ਨਹੀਂ ਵੀ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਵਿਕਲਪਿਕ ਚੇਨਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਦਰਜਾਬੰਦੀ ਵਿੱਚ ਹਰੇਕ ਸੰਪੱਤੀ ਲਈ ਵਾਰ-ਵਾਰ ਨਲ ਜਾਂਚਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤੇ ਬਿਨਾਂ ਕਲੀਨਰ ਅਤੇ ਵਧੇਰੇ ਸਾਂਭਣਯੋਗ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹਨ।

ਵਿਚਾਰਨ ਲਈ ਇਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਇਹ ਹੈ ਕਿ ਇਹ ਓਪਰੇਟਰ ਟਾਈਪਸਕ੍ਰਿਪਟ ਦੇ ਸਖਤ ਮੋਡ ਨਾਲ ਕਿਵੇਂ ਅੰਤਰਕਿਰਿਆ ਕਰਦੇ ਹਨ। ਸਖਤ ਮੋਡ ਵਿੱਚ, TypeScript ਸਖਤ ਨਲ ਅਤੇ ਪਰਿਭਾਸ਼ਿਤ ਜਾਂਚਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨਾ ਵਧੇਰੇ ਚੁਣੌਤੀਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਦ ! ਆਪਰੇਟਰ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਸੰਭਾਵਿਤ null ਮੁੱਲਾਂ ਬਾਰੇ TypeScript ਦੀਆਂ ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਸਨੂੰ ਸਾਵਧਾਨੀ ਨਾਲ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਸਦੀ ਦੁਰਵਰਤੋਂ ਹੋਣ 'ਤੇ ਰਨਟਾਈਮ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਲਈ, ਦ ? ਓਪਰੇਟਰ ਨੂੰ ਅਕਸਰ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਕਿਸੇ ਵਸਤੂ ਜਾਂ ਸੰਪੱਤੀ ਦੀ ਹੋਂਦ ਅਨਿਸ਼ਚਿਤ ਹੁੰਦੀ ਹੈ।

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