const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];

// Without spread
const combined1 = arr1.concat(arr2);

// With spread
const combined2 = [...arr1, ...arr2];
console.log(combined2); // [1, 2, 3, 4, 5, 6]

const arr = [1, 2, 3];

const withStart = [0, ...arr];
console.log(withStart); // [0, 1, 2, 3]

const withEnd = [...arr, 4];
console.log(withEnd); // [1, 2, 3, 4]

const withMiddle = [1, ...arr, 5];
console.log(withMiddle); // [1, 1, 2, 3, 5]

const original = [1, 2, 3];

// Shallow copy
const copy = [...original];
console.log(copy); // [1, 2, 3]
console.log(copy === original); // false (different arrays)

const str = "hello";

const chars = [...str];
console.log(chars); // ["h", "e", "l", "l", "o"]

const obj1 = { a: 1, b: 2 };
const obj2 = { c: 3, d: 4 };

const merged = { ...obj1, ...obj2 };
console.log(merged); // { a: 1, b: 2, c: 3, d: 4 }

const defaults = { host: "localhost", port: 3000, ssl: false };
const config = { port: 8080, ssl: true };

const final = { ...defaults, ...config };
console.log(final); // { host: "localhost", port: 8080, ssl: true }

const original = { name: "Alice", age: 30 };

// Shallow copy
const copy = { ...original };
console.log(copy === original); // false

function sum(...numbers) {
    return numbers.reduce((a, b) => a + b, 0);
}

console.log(sum(1, 2, 3)); // 6
console.log(sum(1, 2, 3, 4, 5)); // 15

function greet(greeting, ...names) {
    return `${greeting} ${names.join(" and ")}!`;
}

console.log(greet("Hello", "Alice")); // "Hello Alice!"
console.log(greet("Hi", "Bob", "Charlie")); // "Hi Bob and Charlie!"

// Correct
function test(a, b, ...rest) {
    console.log(a, b, rest);
}

// Error - rest must be last
// function test(...rest, a, b) { }

const sum = (...numbers) => numbers.reduce((a, b) => a + b, 0);

console.log(sum(1, 2, 3, 4)); // 10

function createList(...items) {
    return items.map((item, index) => `${index + 1}. ${item}`);
}

console.log(createList("Learn", "Practice", "Master"));
// ["1. Learn", "2. Practice", "3. Master"]

function merge(...objects) {
    return Object.assign({}, ...objects);
}

const obj1 = { a: 1 };
const obj2 = { b: 2 };
const obj3 = { c: 3 };

console.log(merge(obj1, obj2, obj3)); // { a: 1, b: 2, c: 3 }

const arr = [1, 2, 2, 3, 3, 3, 4];
const unique = [...new Set(arr)];
console.log(unique); // [1, 2, 3, 4]

const nested = [[1, 2], [3, 4], [5, 6]];
const flat = [...nested[0], ...nested[1], ...nested[2]];
console.log(flat); // [1, 2, 3, 4, 5, 6]

// Or with flat()
console.log(nested.flat()); // [1, 2, 3, 4, 5, 6]

function multiply(a, b, c) {
    return a * b * c;
}

const numbers = [2, 3, 4];
console.log(multiply(...numbers)); // 24

function logArgs(first, ...rest) {
    console.log("First:", first);
    console.log("Rest:", rest);
}

const args = [1, 2, 3, 4];
logArgs(...args);
// First: 1
// Rest: [2, 3, 4]

const user = { id: 1, name: "Alice", role: "user" };

// Create admin version
const admin = { ...user, role: "admin" };
console.log(admin); // { id: 1, name: "Alice", role: "admin" }
console.log(user); // { id: 1, name: "Alice", role: "user" } (unchanged)

function formatMessage(template, ...values) {
    let result = template;
    values.forEach((value, index) => {
        result = result.replace(`{${index}}`, value);
    });
    return result;
}

console.log(formatMessage("Hello {0}, you are {1} years old", "Alice", 30));
// "Hello Alice, you are 30 years old"

const original = { a: 1, b: { c: 2 } };

// Shallow copy - nested objects are still referenced
const copy = { ...original };
copy.b.c = 99;

console.log(original.b.c); // 99 (affected!)

const original = { a: 1, b: { c: 2 } };

// Deep copy using JSON
const copy = JSON.parse(JSON.stringify(original));
copy.b.c = 99;

console.log(original.b.c); // 2 (not affected)

// Spread
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const result1 = [...arr1, ...arr2];

// concat()
const result2 = arr1.concat(arr2);

// Both are similar in performance

// Spread
const obj1 = { a: 1 };
const obj2 = { b: 2 };
const result1 = { ...obj1, ...obj2 };

// Object.assign()
const result2 = Object.assign({}, obj1, obj2);

// Spread is more readable

function request(url, options = {}) {
    const { method = "GET", timeout = 5000, ...headers } = options;
    console.log(method, timeout, headers);
}

request("https://api.example.com", {
    method: "POST",
    timeout: 10000,
    "Content-Type": "application/json"
});

const [first, second, ...rest] = [1, 2, 3, 4, 5];
console.log(first); // 1
console.log(second); // 2
console.log(rest); // [3, 4, 5]

const arr = [1, 2, 3];
const obj = { a: 1, b: 2 };

const combined = {
    items: [...arr],
    config: { ...obj }
};

console.log(combined);
// { items: [1, 2, 3], config: { a: 1, b: 2 } }