التسلسل الاختياري والدمج الفارغ في جافاسكريبت: بناء تطبيقات قوية ومرنة

            const user = {
  id: 'u123',
  name: 'Alice Smith',
  contact: {
    email: 'alice@example.com',
    phone: '123-456-7890'
  }
  // address is missing
};

// Attempt to get the street from user.address
const street = user && user.contact && user.contact.address && user.contact.address.street;
console.log(street); // undefined

const userWithAddress = {
  id: 'u124',
  name: 'Bob Johnson',
  contact: {
    email: 'bob@example.com'
  },
  address: {
    street: '123 Main St',
    city: 'Metropolis',
    country: 'USA'
  }
};

const city = userWithAddress && userWithAddress.address && userWithAddress.address.city;
console.log(city); // 'Metropolis'

// What if `user` itself is null or undefined?
const nullUser = null;
const streetFromNullUser = nullUser && nullUser.address && nullUser.address.street;
console.log(streetFromNullUser); // null (safe, but verbose)
            

              
                Copy
              
            
          

            let country = 'Unknown';

if (userWithAddress) {
  if (userWithAddress.address) {
    if (userWithAddress.address.country) {
      country = userWithAddress.address.country;
    }
  }
}
console.log(country); // 'USA'

// With the user object missing address:
const anotherUser = {
  id: 'u125',
  name: 'Charlie Brown'
};

let postcode = 'N/A';
if (anotherUser && anotherUser.address && anotherUser.address.postcode) {
  postcode = anotherUser.address.postcode;
}
console.log(postcode); // 'N/A'
            

              
                Copy
              
            
          

            const userProfile = {
  id: 'p001',
  name: 'Maria Rodriguez',
  location: {
    city: 'Barcelona',
    country: 'Spain'
  },
  preferences: null // preferences object is null
};

const companyData = {
  name: 'Global Corp',
  address: {
    street: '456 Tech Ave',
    city: 'Singapore',
    postalCode: '123456'
  },
  contactInfo: undefined // contactInfo is undefined
};

// Accessing nested properties safely
console.log(userProfile?.location?.city); // 'Barcelona'
console.log(userProfile?.preferences?.theme); // undefined (because preferences is null)
console.log(companyData?.contactInfo?.email); // undefined (because contactInfo is undefined)
console.log(userProfile?.nonExistentProperty?.anotherOne); // undefined

// Without optional chaining, these would throw errors:
// console.log(userProfile.preferences.theme); // TypeError: Cannot read properties of null (reading 'theme')
// console.log(companyData.contactInfo.email); // TypeError: Cannot read properties of undefined (reading 'email')
            

              
                Copy
              
            
          

            const analyticsService = {
  trackEvent: (name, data) => console.log(`Tracking event: ${name} with data:`, data)
};

const userService = {}; // No 'log' method here

analyticsService.trackEvent?.('user_login', { userId: 'u123' });
// Expected output: Tracking event: user_login with data: { userId: 'u123' }

userService.log?.('User updated', { id: 'u124' });
// Expected output: Nothing happens, no error thrown. The expression returns undefined.
            

              
                Copy
              
            
          

            const userActivities = {
  events: ['login', 'logout', 'view_profile'],
  purchases: []
};

const globalSettings = {
  'app-name': 'My App',
  'version-info': {
    'latest-build': '1.0.0'
  }
};

console.log(userActivities?.events?.[0]); // 'login'
console.log(userActivities?.purchases?.[0]); // undefined (empty array, so element at index 0 is undefined)
console.log(userActivities?.preferences?.[0]); // undefined (preferences is not defined)

// Accessing properties with hyphens using bracket notation
console.log(globalSettings?.['app-name']); // 'My App'
console.log(globalSettings?.['version-info']?.['latest-build']); // '1.0.0'
console.log(globalSettings?.['config']?.['env']); // undefined
            

              
                Copy
              
            
          

            // Example 1: With 'null' or 'undefined'
const nullValue = null;
const undefinedValue = undefined;
const defaultValue = 'Default Value';

console.log(nullValue || defaultValue);       // 'Default Value'
console.log(nullValue ?? defaultValue);       // 'Default Value'

console.log(undefinedValue || defaultValue);  // 'Default Value'
console.log(undefinedValue ?? defaultValue);  // 'Default Value'

// --- Behavior diverges here ---

// Example 2: With 'false'
const falseValue = false;
console.log(falseValue || defaultValue);      // 'Default Value' (|| treats false as falsy)
console.log(falseValue ?? defaultValue);      // false (?? treats false as a valid value)

// Example 3: With '0'
const zeroValue = 0;
console.log(zeroValue || defaultValue);       // 'Default Value' (|| treats 0 as falsy)
console.log(zeroValue ?? defaultValue);       // 0 (?? treats 0 as a valid value)

// Example 4: With empty string ''
const emptyString = '';
console.log(emptyString || defaultValue);     // 'Default Value' (|| treats '' as falsy)
console.log(emptyString ?? defaultValue);     // '' (?? treats '' as a valid value)

// Example 5: With NaN
const nanValue = NaN;
console.log(nanValue || defaultValue);        // 'Default Value' (|| treats NaN as falsy)
console.log(nanValue ?? defaultValue);        // NaN (?? treats NaN as a valid value)
            

              
                Copy
              
            
          

            const userSettings = {
  theme: 'light',
  fontSize: 14,
  enableNotifications: false, // User explicitly set to false
  animationSpeed: null        // animationSpeed explicitly set to null (perhaps to inherit default)
};

const defaultSettings = {
  theme: 'dark',
  fontSize: 16,
  enableNotifications: true,
  animationSpeed: 300
};

const currentTheme = userSettings.theme ?? defaultSettings.theme;
console.log(`Current Theme: ${currentTheme}`); // 'light'

const currentFontSize = userSettings.fontSize ?? defaultSettings.fontSize;
console.log(`Current Font Size: ${currentFontSize}`); // 14 (not 16, because 0 is a valid number)

const notificationsEnabled = userSettings.enableNotifications ?? defaultSettings.enableNotifications;
console.log(`Notifications Enabled: ${notificationsEnabled}`); // false (not true, because false is a valid boolean)

const animationDuration = userSettings.animationSpeed ?? defaultSettings.animationSpeed;
console.log(`Animation Duration: ${animationDuration}`); // 300 (because animationSpeed was null)

const language = userSettings.language ?? 'en-US'; // language is not defined
console.log(`Selected Language: ${language}`); // 'en-US'
            

              
                Copy
              
            
          

            function searchProducts(query, options) {
  const resultsPerPage = options?.limit ?? 20; // Default to 20 if limit is null/undefined
  const minPrice = options?.minPrice ?? 0;   // Default to 0, allowing actual 0 as a valid min price
  const sortBy = options?.sortBy ?? 'relevance';

  console.log(`Searching for: '${query}'`);
  console.log(`  Results per page: ${resultsPerPage}`);
  console.log(`  Minimum price: ${minPrice}`);
  console.log(`  Sort by: ${sortBy}`);
}

searchProducts('laptops', { limit: 10, minPrice: 500 });
// Expected:
// Searching for: 'laptops'
//   Results per page: 10
//   Minimum price: 500
//   Sort by: relevance

searchProducts('keyboards', { minPrice: 0, sortBy: null }); // minPrice is 0, sortBy is null
// Expected:
// Searching for: 'keyboards'
//   Results per page: 20
//   Minimum price: 0
//   Sort by: relevance (because sortBy was null)

searchProducts('monitors', {}); // No options provided
// Expected:
// Searching for: 'monitors'
//   Results per page: 20
//   Minimum price: 0
//   Sort by: relevance
            

              
                Copy
              
            
          

            const userData = {
  id: 'user-007',
  name: 'James Bond',
  contactDetails: {
    email: 'james.bond@mi6.gov.uk',
    phone: '007-007-0070'
  },
  // preferences is missing
  address: {
    street: 'Whitehall St',
    city: 'London'
    // postcode is missing
  }
};

const clientData = {
  id: 'client-101',
  name: 'Global Ventures Inc.',
  location: {
    city: 'New York'
  }
};

const guestData = {
  id: 'guest-999'
};

// Safely get user's preferred language, defaulting to 'en-GB'
const userLang = userData?.preferences?.language ?? 'en-GB';
console.log(`User Language: ${userLang}`); // 'en-GB'

// Get client's country, defaulting to 'Unknown'
const clientCountry = clientData?.location?.country ?? 'Unknown';
console.log(`Client Country: ${clientCountry}`); // 'Unknown'

// Get a guest's display name, defaulting to 'Guest'
const guestDisplayName = guestData?.displayName ?? 'Guest';
console.log(`Guest Display Name: ${guestDisplayName}`); // 'Guest'

// Get user's postcode, defaulting to 'N/A'
const userPostcode = userData?.address?.postcode ?? 'N/A';
console.log(`User Postcode: ${userPostcode}`); // 'N/A'

// What if an explicitly empty string is valid?
const profileWithEmptyBio = {
  username: 'coder',
  info: { bio: '' }
};
const profileWithNullBio = {
  username: 'developer',
  info: { bio: null }
};

const bio1 = profileWithEmptyBio?.info?.bio ?? 'No bio provided';
console.log(`Bio 1: '${bio1}'`); // Bio 1: '' (empty string is preserved)

const bio2 = profileWithNullBio?.info?.bio ?? 'No bio provided';
console.log(`Bio 2: '${bio2}'`); // Bio 2: 'No bio provided' (null is replaced)

            

              
                Copy
              
            
          

            const logger = {
  log: (message) => console.log(`[INFO] ${message}`)
};

const analytics = {}; // No 'track' method

const systemEvent = 'application_start';

// Try to track event, otherwise just log it
analytics.track?.(systemEvent, { origin: 'bootstrap' }) ?? logger.log(`Fallback: Could not track event '${systemEvent}'`);
// Expected: [INFO] Fallback: Could not track event 'application_start'

const anotherLogger = {
  warn: (msg) => console.warn(`[WARN] ${msg}`),
  log: (msg) => console.log(`[LOG] ${msg}`)
};

anotherLogger.track?.('test') ?? anotherLogger.warn('Track method not available.');
// Expected: [WARN] Track method not available.

            

              
                Copy
              
            
          

            const translations = {
  'en-US': {
    greeting: 'Hello',
    messages: {
      welcome: 'Welcome!',
      error: 'An error occurred.'
    }
  },
  'es-ES': {
    greeting: 'Hola',
    messages: {
      welcome: '¡Bienvenido!',
      loading: 'Cargando...'
    }
  }
};

function getTranslation(locale, keyPath, defaultValue) {
  // Split keyPath into an array of properties
  const keys = keyPath.split('.');
  
  // Dynamically access nested properties using optional chaining
  let result = translations[locale];
  for (const key of keys) {
    result = result?.[key];
  }
  
  // Provide a default if the translation is null or undefined
  return result ?? defaultValue;
}

console.log(getTranslation('en-US', 'messages.welcome', 'Fallback Welcome')); // 'Welcome!'
console.log(getTranslation('es-ES', 'messages.welcome', 'Fallback Welcome')); // '¡Bienvenido!'
console.log(getTranslation('es-ES', 'messages.error', 'Fallback Error'));    // 'Fallback Error' (error is missing in es-ES)
console.log(getTranslation('fr-FR', 'greeting', 'Bonjour'));               // 'Bonjour' (fr-FR locale is missing entirely)
            

              
                Copy
              
            
          

            let count = 0;
const user = {
  name: 'Anna',
  getAddress: () => {
    count++;
    console.log('Fetching address...');
    return { city: 'Paris' };
  }
};

const admin = null;

// user exists, getAddress is called
console.log(user?.getAddress()?.city); // Output: Fetching address..., then 'Paris'
console.log(count); // 1

// admin is null, getAddress is NOT called
console.log(admin?.getAddress()?.city); // Output: undefined
console.log(count); // Still 1 (getAddress was not executed)
            

              
                Copy
              
            
          

            const apiResponse = {
  success: true,
  payload: {
    data: {
      user: {
        id: 'u456',
        name: 'David',
        email: 'david@example.com'
      }
    }
  }
};

const emptyResponse = {
  success: false
};

// Extracting deeply nested data with a default
const userId = apiResponse?.payload?.data?.user?.id ?? 'guest';
const userName = apiResponse?.payload?.data?.user?.name ?? 'Anonymous';
console.log(`User ID: ${userId}, Name: ${userName}`); // User ID: u456, Name: David

const guestId = emptyResponse?.payload?.data?.user?.id ?? 'guest';
const guestName = emptyResponse?.payload?.data?.user?.name ?? 'Anonymous';
console.log(`Guest ID: ${guestId}, Name: ${guestName}`); // Guest ID: guest, Name: Anonymous

// A common pattern is to safely access an object first, then destructure if it exists:
const { user: userDataFromResponse } = apiResponse.payload.data;
const { id = 'default-id', name = 'Default Name' } = userDataFromResponse ?? {};
console.log(`Destructured ID: ${id}, Name: ${name}`); // Destructured ID: u456, Name: David

// For an empty response:
const { user: userDataFromEmptyResponse } = emptyResponse.payload?.data ?? {}; // Use optional chaining for payload.data, then ?? {} for user
const { id: emptyId = 'default-id', name: emptyName = 'Default Name' } = userDataFromEmptyResponse ?? {};
console.log(`Destructured Empty ID: ${emptyId}, Name: ${emptyName}`); // Destructured Empty ID: default-id, Name: Default Name
            

              
                Copy
              
            
          

            const config = {
  value: null
};

// Correctly evaluates to (config?.value) ?? 'default'
const result = config?.value ?? 'default';
console.log(result); // 'default'

// If the value was 0:
const configWithZero = {
  value: 0
};
const resultZero = configWithZero?.value ?? 'default';
console.log(resultZero); // 0 (as 0 is not nullish)
            

              
                Copy
              
            
          

            // Example in TypeScript (conceptual, not runnable JS)
interface User {
  id: string;
  name: string;
  email?: string; // email is optional
  address?: {
    street: string;
    city: string;
    zipCode?: string; // zipCode is optional
  };
}

function getUserEmail(user: User): string {
  // TypeScript understands user.email could be undefined, and handles it with ??
  return user.email ?? 'No email provided';
}

function getUserZipCode(user: User): string {
  // TypeScript understands address and zipCode are optional
  return user.address?.zipCode ?? 'N/A';
}

const user1: User = { id: '1', name: 'John Doe', email: 'john@example.com', address: { street: 'Main', city: 'Town' } };
const user2: User = { id: '2', name: 'Jane Doe' }; // No email or address

console.log(getUserEmail(user1));   // 'john@example.com'
console.log(getUserEmail(user2));   // 'No email provided'
console.log(getUserZipCode(user1)); // 'N/A' (zipCode is missing)
console.log(getUserZipCode(user2)); // 'N/A' (address is missing)
            

              
                Copy
              
            
          

            // Potentially less readable:
const userCity = clientRequest?.customer?.billing?.primaryAddress?.location?.city?.toUpperCase() ?? 'UNKNOWN';

// More readable breakdown:
const primaryAddress = clientRequest?.customer?.billing?.primaryAddress;
const userCity = primaryAddress?.location?.city?.toUpperCase() ?? 'UNKNOWN';
            

              
                Copy