સ્પ્રેડ અને રેસ્ટ ઑપરેટર્સ શું છે?

Question

Accepted Answer

બંને `...` વાપરે છે પરંતુ **વિપરીત દિશામાં**: સ્પ્રેડ **વિસ્તૃત** કરે છે એક કલેક્શનને વ્યક્તિગત આઇટમ્સમાં; રેસ્ટ **એકત્રિત** કરે છે આઇટમ્સને એક એરે/ઑબ્જેક્ટમાં.

## સ્પ્રેડ — વિસ્તૃત કરો

```js
const a = [1, 2], b = [3, 4];
const merged = [...a, ...b];          // [1, 2, 3, 4]
const copy = [...a];                   // shallow copy
const obj = { ...user, active: true }; // copy object + override/add a field
Math.max(...[1, 5, 3]);                // 5 — spread array into arguments
```

## રેસ્ટ — એકત્રિત કરો

```js
function sum(...nums) {     // gather all args into an array
  return nums.reduce((a, n) => a + n, 0);
}
sum(1, 2, 3);               // 6

const [first, ...others] = [10, 20, 30]; // first=10, others=[20, 30]
const { id, ...rest } = user;            // pull out id, keep the rest
```

## એક મહત્વપૂર્ણ વિશેષતા: સ્પ્રેડ એ એક શેલો કopી છે

```js
const original = { user: { name: "Ann" } };
const copy = { ...original };
copy.user.name = "Bob"; // ⚠️ also changes original.user.name — nested object is SHARED
```

સ્પ્રેડ ફક્ત ટોપ લેવલ કپી કરે છે; નેસ્ટેડ ઑબ્જેક્ટ્સ હજુ પણ શેર કરેલા રેફરન્સ છે. સ્ટેટ અપડેટ્સ માટે તમે સામાન્યતઃ ટોપ લેવલ જ બદલો છો, જે બરાબર છે, પરંતુ ડીપ સ્ટ્રક્ચર્સ માટે જાણવું જરૂરી છે.

## તે શા માટે મહત્વપૂર્ણ છે

સ્પ્રેડ એ પ્રમાણભૂત રીત છે **અપરિવર્તનશીલ અપડેટ્સ** (કોપી + બદલો) કરવાની React/Redux માં, અને રેસ્ટ વેરીએડિક ફંક્શન્સ અને "બાકીના ભાગો લો" destructuring ને સ્વચ્છ બનાવે છે.