---
title: REDUCE – รวมผลลัพธ์จาก Array เป็นค่าเดียว
url: https://www.thepexcel.com/functions/excel/logical/reduce/
type: function-explainer
program: Excel
syntax: "=REDUCE([initial_value], array, lambda)"
date: 2025-12-18
scores:
  popularity: 9
  difficulty: 8
  usefulness: 10
---

# REDUCE – รวมผลลัพธ์จาก Array เป็นค่าเดียว

> วนลูปคำนวณค่าสะสมจาก Array จนได้ผลลัพธ์เดียว

## คำอธิบาย

REDUCE เป็นฟังก์ชัน Helper ที่ทำงานร่วมกับ LAMBDA เพื่อวนลูปประมวลผลข้อมูลใน Array โดยรับค่าเริ่มต้น (initial_value) และส่งค่าเข้า LAMBDA ทีละ element เพื่อคำนวณค่าสะสม (accumulator) ที่สืบเนื่องจากรอบก่อนหน้า แล้ว return ผลลัพธ์สุดท้ายเพียงค่าเดียว ต่างจาก SCAN ที่ return Array ของทุกขั้นตอน REDUCE เหมาะสำหรับการสร้าง custom aggregation ที่ซับซ้อนกว่าฟังก์ชันมาตรฐาน

## Syntax

```excel
=REDUCE([initial_value], array, lambda)
```

## Arguments

| Name | Required | Type | Default | Description |
| --- | --- | --- | --- | --- |
| initial_value | No | Any | ค่าแรกของ Array | ค่าเริ่มต้นสำหรับ accumulator ถ้าไม่ระบุ Excel จะใช้ element แรกของ Array เป็นค่าเริ่มต้นและเริ่มวนลูปที่ element ที่ 2 แนะนำให้ระบุชัดเจนเสมอเพื่อหลีกเลี่ยง data type ไม่ตรงกัน (เช่น 0 สำหรับ sum, 1 สำหรับ product, "" สำหรับ text) |
| array | Yes | Range/Array |  | ช่วงข้อมูลหรือ Array ที่ต้องการประมวลผล สามารถเป็น range reference (เช่น A1:A10), named range, table column (เช่น Sales[Amount]), หรือ array constant (เช่น {1,2,3,4,5}) |
| lambda | Yes | Function |  | ฟังก์ชัน LAMBDA ที่ต้องรับพารามิเตอร์ 2 ตัว: accumulator (ค่าสะสมจากรอบก่อนหน้า) และ value (element ปัจจุบันจาก Array) แล้ว return ค่าที่จะเป็น accumulator ของรอบถัดไป สูตร LAMBDA มีรูปแบบ LAMBDA(a, v, expression) โดย a = accumulator, v = current value |

## เคสการใช้งาน

### Custom Aggregation ที่ฟังก์ชันมาตรฐานทำไม่ได้

สร้างการคำนวณแบบกำหนดเองเช่น sum เฉพาะเลขคู่, count เฉพาะค่าที่มากกว่าค่าเฉลี่ย, หรือ product ของเฉพาะค่าบวก ซึ่ง SUMIF/COUNTIF ทำไม่ได้เพราะต้องใช้ฟังก์ชันใน criteria

_เหมาะกับ:_ data-analysis

### Text Processing แบบมีเงื่อนไข

รวมข้อความโดยกรองเฉพาะข้อมูลที่ต้องการ เช่น concatenate เฉพาะชื่อที่ยาวกว่า 3 ตัวอักษร หรือรวมเฉพาะค่าที่ไม่ซ้ำ ซึ่ง TEXTJOIN ทำเงื่อนไขซับซ้อนไม่ได้

_เหมาะกับ:_ text-manipulation

### Batch Find and Replace

ใช้ REDUCE วนลูป SUBSTITUTE เพื่อแทนที่หลายคำพร้อมกัน เช่น แก้คำผิดหลายคำในข้อความเดียว หรือทำ data cleansing โดยลบอักขระพิเศษหลายตัวออกจากข้อความ

_เหมาะกับ:_ data-cleaning

### Sequential Calculation

คำนวณแบบต่อเนื่องที่แต่ละขั้นตอนขึ้นกับผลลัพธ์ก่อนหน้า เช่น คำนวณดอกเบี้ยทบต้น, running balance ของบัญชี, หรือการคำนวณที่ผลของรอบก่อนเป็น input ของรอบถัดไป

_เหมาะกับ:_ financial-modeling

### Array Building แบบมีเงื่อนไข

สร้าง Array ใหม่จากข้อมูลเดิมโดยมีเงื่อนไขซับซ้อน เช่น รวม Array หลายชุดแบบมีเงื่อนไข หรือแปลงข้อมูลที่ไม่สามารถใช้ MAP ได้เพราะต้องอ้างอิงผลลัพธ์ก่อนหน้า

_เหมาะกับ:_ data-transformation

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: Foundation - ผลรวมพื้นฐาน (เหมือน SUM)

```excel
=REDUCE(0, {1,2,3,4,5}, LAMBDA(a, v, a+v))
```

**ผลลัพธ์:** `15`

เริ่มต้นด้วย a=0 (initial_value) แล้วบวกทีละตัว:
.
• รอบ 1: a=0, v=1 → return 0+1 = 1
• รอบ 2: a=1, v=2 → return 1+2 = 3
• รอบ 3: a=3, v=3 → return 3+3 = 6
• รอบ 4: a=6, v=4 → return 6+4 = 10
• รอบ 5: a=10, v=5 → return 10+5 = 15
.
ผลลัพธ์สุดท้ายคือ 15 ซึ่งเหมือนกับ =SUM(1,2,3,4,5)
.
นี่คือตัวอย่างพื้นฐานที่แสดงการทำงานของ REDUCE: ค่า a คือผลสะสมจากรอบก่อนหน้า และ v คือค่าปัจจุบันจาก Array ครับ

### 2. ตัวอย่างที่ 2: Foundation - หา MAX (ค่าสูงสุด)

```excel
=REDUCE(0, {5,3,9,1,7}, LAMBDA(a, v, MAX(a, v)))
```

**ผลลัพธ์:** `9`

เปรียบเทียบค่าสะสม (a) กับค่าปัจจุบัน (v) แล้วเก็บค่าที่มากกว่า:
.
• รอบ 1: a=0, v=5 → MAX(0,5) = 5
• รอบ 2: a=5, v=3 → MAX(5,3) = 5
• รอบ 3: a=5, v=9 → MAX(5,9) = 9
• รอบ 4: a=9, v=1 → MAX(9,1) = 9
• รอบ 5: a=9, v=7 → MAX(9,7) = 9
.
ได้ 9 ซึ่งเป็นค่าสูงสุดใน Array (เหมือน =MAX(5,3,9,1,7))
.
แสดงให้เห็นว่า REDUCE สามารถทำ comparison operation ได้ ไม่ใช่แค่บวกลบอย่างเดียวครับ

### 3. ตัวอย่างที่ 3: Practical - รวมเฉพาะเลขคู่

```excel
=REDUCE(0, {1,2,3,4,5,6,7,8,9,10}, LAMBDA(a, v, IF(ISEVEN(v), a+v, a)))
```

**ผลลัพธ์:** `30`

ใช้ IF กับ ISEVEN เพื่อบวกเฉพาะเลขคู่:
.
• v=1 (คี่) → return a ไม่เปลี่ยน
• v=2 (คู่) → return a+2
• v=3 (คี่) → return a ไม่เปลี่ยน
• v=4 (คู่) → return a+4
• v=5 (คี่) → return a ไม่เปลี่ยน
• v=6 (คู่) → return a+6
• v=7 (คี่) → return a ไม่เปลี่ยน
• v=8 (คู่) → return a+8
• v=9 (คี่) → return a ไม่เปลี่ยน
• v=10 (คู่) → return a+10
.
ผลลัพธ์: 2+4+6+8+10 = 30
.
นี่คือสิ่งที่ SUMIF ทำไม่ได้เพราะ ISEVEN return array ไม่ใช่ range criteria ปกติ แต่ REDUCE แก้ปัญหานี้ได้ด้วยการใช้ IF ภายใน LAMBDA 😎

### 4. ตัวอย่างที่ 4: Practical - ต่อข้อความแบบมีเงื่อนไข

```excel
=REDUCE("", {"John","Al","Michael","Bob","Tom"}, LAMBDA(a, v, IF(LEN(v)>3, IF(a="", v, a&", "&v), a)))
```

**ผลลัพธ์:** `"John, Michael"`

ต่อข้อความเฉพาะชื่อที่ยาวกว่า 3 ตัวอักษร คั่นด้วยคอมม่า:
.
• v="John" (4 ตัว) → ใช้เงื่อนไข LEN(v)>3 = TRUE → เช็ค a="" → ใช่ → return "John"
• v="Al" (2 ตัว) → LEN(v)>3 = FALSE → return a เดิม = "John"
• v="Michael" (7 ตัว) → TRUE → a ไม่ว่าง → return "John, Michael"
• v="Bob" (3 ตัว) → FALSE → return a เดิม = "John, Michael"
• v="Tom" (3 ตัว) → FALSE → return a เดิม = "John, Michael"
.
ได้ "John, Michael" โดยไม่มีคอมม่านำหน้าเพราะใช้ IF(a="", v, a&", "&v) ป้องกัน
.
นี่คือสิ่งที่ TEXTJOIN ทำไม่ได้เพราะ TEXTJOIN ไม่สามารถใช้ฟังก์ชันใน if_empty parameter ได้ ส่วน REDUCE ให้ความยืดหยุ่นมากกว่าครับ 💡

### 5. ตัวอย่างที่ 5: Advanced - Batch SUBSTITUTE (แทนที่หลายคำ)

```excel
=REDUCE("Hello World, Good Morning", {"Hello","World","Good"}, LAMBDA(txt, word, SUBSTITUTE(txt, word, "Hi")))
```

**ผลลัพธ์:** `"Hi Hi, Hi Morning"`

ใช้ REDUCE วนลูป SUBSTITUTE เพื่อแทนที่หลายคำพร้อมกัน:
.
• รอบ 1: txt="Hello World, Good Morning", word="Hello"
  → SUBSTITUTE → "Hi World, Good Morning"
• รอบ 2: txt="Hi World, Good Morning", word="World"
  → SUBSTITUTE → "Hi Hi, Good Morning"
• รอบ 3: txt="Hi Hi, Good Morning", word="Good"
  → SUBSTITUTE → "Hi Hi, Hi Morning"
.
สุดท้ายได้ "Hi Hi, Hi Morning" โดยแทนที่ทั้ง 3 คำพร้อมกัน
.
**ทำไมต้องใช้ REDUCE?**
.
ถ้าใช้ SUBSTITUTE ปกติ จะต้อง nest กันหลายชั้น =SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(...))) ซึ่งอ่านยาก และถ้ามีคำที่ต้องแทนที่เยอะ (เช่น 20 คำ) สูตรจะยาวมาก 😭
.
REDUCE ทำให้อ่านง่ายและขยายได้ง่ายกว่า แค่เพิ่มคำใน Array ก็จัดการได้เลย 👍

### 6. ตัวอย่างที่ 6: Advanced - นับจำนวน element ที่ตรงเงื่อนไข

```excel
=REDUCE(0, {5,12,3,18,7,21,9}, LAMBDA(a, v, IF(v>10, a+1, a)))
```

**ผลลัพธ์:** `3`

นับจำนวนค่าที่มากกว่า 10 โดยไม่ใช้ค่า v มาบวก แต่ใช้บวก 1 แทน:
.
• v=5 → 5>10 = FALSE → return a+0
• v=12 → 12>10 = TRUE → return a+1
• v=3 → 3>10 = FALSE → return a+0
• v=18 → 18>10 = TRUE → return a+1
• v=7 → 7>10 = FALSE → return a+0
• v=21 → 21>10 = TRUE → return a+1
• v=9 → 9>10 = FALSE → return a+0
.
มี 3 ค่าที่มากกว่า 10 (12, 18, 21) ได้ผลลัพธ์ 3
.
**เทคนิคที่น่าสนใจ:** ไม่จำเป็นต้องใช้ค่า v เสมอนะครับ บางครั้งเราแค่ใช้ v เพื่อเช็คเงื่อนไข แล้วบวกค่าคงที่ (เช่น +1) แทน
.
Pattern นี้ใช้กับการ count แบบมีเงื่อนไขที่ COUNTIF ทำไม่ได้ 💡

### 7. ตัวอย่างที่ 7: Advanced - Find & Replace จาก Lookup Table

```excel
=LET(
  text, "XL training and PPT training",
  find_list, {"XL","PPT"},
  replace_list, {"Excel","PowerPoint"},
  REDUCE(text, SEQUENCE(ROWS(find_list)),
    LAMBDA(txt, i,
      SUBSTITUTE(txt,
        INDEX(find_list, i),
        INDEX(replace_list, i)
      )
    )
  )
)
```

**ผลลัพธ์:** `"Excel training and PowerPoint training"`

ใช้ REDUCE กับ lookup table เพื่อแทนที่หลายคำจากตาราง:
.
**Setup:**
• text = "XL training and PPT training" (ข้อความต้นทาง)
• find_list = {"XL","PPT"} (คำที่ต้องการหา)
• replace_list = {"Excel","PowerPoint"} (คำที่ใช้แทนที่)
• SEQUENCE(ROWS(find_list)) = {1;2} (index สำหรับวนลูป)
.
**Process:**
• i=1: INDEX(find_list,1)="XL", INDEX(replace_list,1)="Excel"
  → SUBSTITUTE("XL training and PPT training", "XL", "Excel")
  → "Excel training and PPT training"
• i=2: INDEX(find_list,2)="PPT", INDEX(replace_list,2)="PowerPoint"
  → SUBSTITUTE("Excel training and PPT training", "PPT", "PowerPoint")
  → "Excel training and PowerPoint training"
.
**Use Case สุดจริง 🔥**
.
เหมาะสำหรับ data cleansing ที่มี lookup table ของคำผิด-คำถูก หรือ abbreviation-fullname หลายสิบคู่
.
แค่เพิ่มใน find_list และ replace_list สูตรก็จะทำงานอัตโนมัติ ไม่ต้องแก้สูตร Pattern นี้ขยายได้ไม่จำกัด ถ้ามี 100 คู่ก็ใช้สูตรเดียวกันนี้ได้เลยครับ 😎

### 8. ตัวอย่างที่ 8: Real-World - คำนวณดอกเบี้ยทบต้น

```excel
=LET(
  principal, 10000,
  monthly_deposit, 1000,
  annual_rate, 0.06,
  months, 12,
  monthly_rate, annual_rate/12,
  REDUCE(principal, SEQUENCE(months),
    LAMBDA(balance, month,
      (balance + monthly_deposit) * (1 + monthly_rate)
    )
  )
)
```

**ผลลัพธ์:** `23563.50`

คำนวณเงินคงเหลือหลังฝาก 1,000 บาทต่อเดือนเป็นเวลา 12 เดือน โดยมีดอกเบี้ย 6% ต่อปี:
.
**ตั้งต้น:**
• principal = 10,000 บาท (เงินต้นเริ่มต้น)
• monthly_deposit = 1,000 บาท (ฝากเพิ่มทุกเดือน)
• annual_rate = 6% → monthly_rate = 0.5% (0.06/12)
.
**Process (คำนวณทีละเดือน):**
• เดือน 1: balance=10,000 → (10,000+1,000)×1.005 = 11,055
• เดือน 2: balance=11,055 → (11,055+1,000)×1.005 = 12,115.28
• เดือน 3: balance=12,115.28 → (12,115.28+1,000)×1.005 = 13,180.85
• ... (วนต่อไปเรื่อยๆ)
• เดือน 12: balance = 23,563.50 บาท
.
**ทำไมต้องใช้ REDUCE?**
.
การคำนวณดอกเบี้ยทบต้นแบบนี้ขึ้นกับผลลัพธ์ของรอบก่อนหน้า (sequential calculation) ฟังก์ชันปกติเช่น FV ไม่สามารถจัดการกรณีที่มีเงินฝากเพิ่มทุกเดือนพร้อมดอกเบี้ยทบต้นได้ครบถ้วน
.
REDUCE ให้ control เต็มที่ในการคำนวณแต่ละขั้นตอน นี่คือ real-world use case ของ REDUCE ในการทำ financial modeling ที่ซับซ้อนครับ 💰

## หมายเหตุเพิ่มเติม

## 💡 เจาะลึก REDUCE - เข้าใจการทำงานทีละขั้น

### Process Flow (ดูให้เห็นภาพ)
```
=REDUCE(initial_value, array, LAMBDA(accumulator, value, expression))

┌─────────────┐
│ initial_value│ ← ค่าเริ่มต้นสำหรับ accumulator
└──────┬──────┘
       │
       ▼
┌──────────────────────────────────────┐
│  รอบที่ 1                             │
│  accumulator = initial_value         │
│  value = element แรกของ array       │
│  คำนวณ expression                    │
│  return ผลลัพธ์ → เป็น accumulator  │
│                     ของรอบถัดไป      │
└──────┬───────────────────────────────┘
       │
       ▼
┌──────────────────────────────────────┐
│  รอบที่ 2                             │
│  accumulator = ผลจากรอบก่อน         │
│  value = element ที่ 2               │
│  คำนวณ expression                    │
│  return ผลลัพธ์ → เป็น accumulator  │
│                     ของรอบถัดไป      │
└──────┬───────────────────────────────┘
       │
       ▼
     ... (วนต่อจนจบ array)
       │
       ▼
┌──────────────────────────────────────┐
│  รอบสุดท้าย                          │
│  accumulator = ผลจากรอบก่อน         │
│  value = element สุดท้าย            │
│  คำนวณ expression                    │
│  return ผลลัพธ์สุดท้าย              │
└──────────────────────────────────────┘
```

### เปรียบเทียบ REDUCE กับฟังก์ชันอื่น

| | REDUCE | SCAN | MAP | BYCOL/BYROW |
|---|--------|------|-----|-------------|
| **Return** | ค่าเดียว | Array (ทุกขั้น) | Array (แปลง) | Array (ต่อแถว/คอลัมน์) |
| **ผลลัพธ์** | Aggregate | Running results | Transformed | Column/Row results |
| **LAMBDA parameters** | 2 (a, v) | 2 (a, v) | 1 (v) | 1 (col/row) |
| **Use Case** | Sum, Max, Concatenate | Running Total | Transform ทุกค่า | Apply function ต่อ column |
| **ตัวอย่าง** | `=REDUCE(0,{1,2,3},LAMBDA(a,v,a+v))` → 6 | `=SCAN(0,{1,2,3},LAMBDA(a,v,a+v))` → {1;3;6} | `=MAP({1,2,3},LAMBDA(v,v*2))` → {2;4;6} | `=BYCOL(A1:C3,LAMBDA(c,SUM(c)))` |

### Use Cases ที่เหมาะสม

**1. Conditional Aggregation (รวมแบบมีเงื่อนไข)**
```
=REDUCE(0, Sales[Amount],
  LAMBDA(total, amt,
    IF(amt > 1000, total + amt, total)
  )
)
```
รวมเฉพาะยอดขายที่มากกว่า 1,000 ซึ่ง SUMIF ทำไม่ได้ถ้าเงื่อนไขซับซ้อน

**2. Text Processing (ประมวลผลข้อความ)**
```
=REDUCE("Report:\n", Employees[Name],
  LAMBDA(txt, name,
    IF(LEN(name) > 5,
      txt & "- " & name & CHAR(10),
      txt
    )
  )
)
```
สร้าง report รายชื่อพนักงานที่ชื่อยาวกว่า 5 ตัว

**3. Sequential Calculation (คำนวณต่อเนื่อง)**
```
=REDUCE(1000, Transactions[Amount],
  LAMBDA(balance, txn,
    balance + txn
  )
)
```
คำนวณยอดคงเหลือโดยบวกลบธุรกรรมทีละรายการ

**4. Data Cleaning (ทำความสะอาดข้อมูล)**
```
=LET(
  unwanted, {"!","?","#","$"},
  REDUCE(A1, unwanted,
    LAMBDA(txt, char,
      SUBSTITUTE(txt, char, "")
    )
  )
)
```
ลบอักขระพิเศษหลายตัวพร้อมกัน

**5. Custom Max/Min with Conditions**
```
=REDUCE(-999999, Scores[Value],
  LAMBDA(max_val, score,
    IF(AND(score > max_val, score 10,000 rows) ถ้ามี alternative
• ลืมใส่ initial_value (อาจได้ data type ผิด)

### Common Patterns

**Pattern 1: Conditional Sum**
```
LAMBDA(sum, val, IF(condition, sum + val, sum))
```

**Pattern 2: Conditional Count**
```
LAMBDA(count, val, IF(condition, count + 1, count))
```

**Pattern 3: Find Max/Min**
```
LAMBDA(max, val, MAX(max, val))
LAMBDA(min, val, MIN(min, val))
```

**Pattern 4: Text Concatenation**
```
LAMBDA(txt, val, IF(txt="", val, txt & delimiter & val))
```

**Pattern 5: Batch Replace**
```
LAMBDA(txt, find, SUBSTITUTE(txt, find, replace))
```

### Error Handling

**#VALUE! Error - "Incorrect Parameters"**
• สาเหตุ: LAMBDA รับพารามิเตอร์ไม่ถูกจำนวน (ต้อง 2 ตัวเสมอ)
• แก้ไข: ตรวจสอบ LAMBDA ต้องเป็น LAMBDA(a, v, expression)

**#CALC! Error**
• สาเหตุ: การคำนวณใน LAMBDA มีปัญหา (เช่น หารด้วย 0)
• แก้ไข: ใช้ IFERROR ภายใน LAMBDA

**Circular Reference**
• สาเหตุ: LAMBDA อ้างอิงกลับไปที่ cell ที่มีสูตร REDUCE
• แก้ไข: ใช้ LET หรือ Helper Cell แยก

### Compatibility Notes

**Excel Versions:**
• ✅ Microsoft 365 (Windows/Mac)
• ✅ Excel 2024
• ✅ Excel for the web
• ❌ Excel 2021, 2019, 2016 และเก่ากว่า

**Cross-Platform:**
• Excel (Microsoft 365): รองรับเต็มที่
• Google Sheets: ไม่รองรับ REDUCE (ใช้ ARRAYFORMULA + SCAN แทน)
• LibreOffice Calc: ไม่รองรับ
• Numbers (Apple): ไม่รองรับ

## คำถามที่พบบ่อย

**Q: REDUCE ต่างจาก SCAN อย่างไร?**

ความแตกต่างหลักคือประเภทของผลลัพธ์:
.
**REDUCE:**
• Return ผลลัพธ์สุดท้ายค่าเดียว (single value)
• เหมาะสำหรับ final result เช่น ผลรวมสุดท้าย, ข้อความที่รวมเสร็จ
• ตัวอย่าง: =REDUCE(0, {1,2,3,4,5}, LAMBDA(a,v,a+v)) → 15
.
**SCAN:**
• Return Array ของผลลัพธ์ทุกขั้นตอน (array of intermediate results)
• เหมาะสำหรับ running totals, progressive results
• ตัวอย่าง: =SCAN(0, {1,2,3,4,5}, LAMBDA(a,v,a+v)) → {1;3;6;10;15}
.
**เมื่อไหร่ใช้อะไร:**
• ใช้ REDUCE เมื่อต้องการแค่ผลลัพธ์สุดท้าย (aggregate value)
• ใช้ SCAN เมื่อต้องการเห็นผลสะสมทุกขั้นตอน (running results, cumulative totals)
.
ทั้งสองฟังก์ชันใช้ LAMBDA เหมือนกันและมี syntax คล้ายกัน แตกต่างแค่ output ครับ

**Q: ถ้าไม่ใส่ initial_value จะเกิดอะไรขึ้น?**

ถ้าไม่ระบุ initial_value ไว้ Excel จะทำ 2 สิ่ง:
.
1. **ใช้ element แรกของ Array เป็น initial_value**
2. **เริ่มวนลูปที่ element ที่ 2** (ข้าม element แรก)
.
**ตัวอย่าง:**
```
=REDUCE(, {10,20,30}, LAMBDA(a,v,a+v))

• รอบ 1: a=10 (ค่าแรกใน Array), v=20 → 10+20=30
• รอบ 2: a=30, v=30 → 30+30=60

ผลลัพธ์: 60
```
.
**ข้อควรระวัง:**
• Data type อาจไม่ตรงกับที่ต้องการ (เช่น คาดหวัง 0 แต่ได้ text)
• การคูณจะผิดถ้า element แรกไม่ใช่ 1
• อ่านสูตรยากขึ้นเพราะไม่ชัดเจนว่าค่าเริ่มต้นคืออะไร
.
**Best Practice:** ระบุ initial_value ชัดเจนเสมอ:
• 0 สำหรับ sum
• 1 สำหรับ product
• "" (empty text) สำหรับ concatenation
• 0 หรือ -999999 สำหรับ MAX/MIN
.
ส่วนตัวผมแนะนำให้ใส่เสมอนะครับ จะได้อ่านสูตรง่ายกว่า

**Q: Accumulator คืออะไรและทำงานอย่างไร?**

**Accumulator** (มักตั้งชื่อ `a` หรือ `acc`) คือตัวแปรที่เก็บค่าสะสมระหว่างการวนลูป
.
**วงจรการทำงาน:**
1. **รอบแรก:** a = initial_value
2. **รอบถัดไป:** a = ผลลัพธ์ที่ LAMBDA return จากรอบก่อน
3. **รอบสุดท้าย:** REDUCE return ค่า a ของรอบสุดท้าย
.
**ตัวอย่างเห็นภาพ:**
```
=REDUCE(0, {5,10,15}, LAMBDA(a,v,a+v))

รอบ 1:
  Input: a=0 (initial), v=5 (element แรก)
  Process: a+v = 0+5 = 5
  Return: 5 → จะเป็น a ของรอบถัดไป

รอบ 2:
  Input: a=5 (จากรอบก่อน), v=10 (element ที่ 2)
  Process: a+v = 5+10 = 15
  Return: 15 → จะเป็น a ของรอบถัดไป

รอบ 3:
  Input: a=15 (จากรอบก่อน), v=15 (element สุดท้าย)
  Process: a+v = 15+15 = 30
  Return: 30 → จบการวนลูป

ผลลัพธ์สุดท้าย: 30
```
.
**Key Point:** LAMBDA ต้อง return ค่าที่จะกลายเป็น accumulator ของรอบถัดไป ดังนั้นต้องคิดว่าอยากให้ค่าสะสมเป็นอะไรหลังจากประมวลผล element ปัจจุบันแล้ว
.
เข้าใจตรงนี้แล้ว จะเขียน REDUCE ได้คล่องมากขึ้นครับ

**Q: สามารถใช้ REDUCE ทำ Running Total ได้ไหม?**

**ตอบสั้นๆ: ไม่เหมาะครับ**
.
REDUCE return ค่าสุดท้ายค่าเดียว ไม่ใช่ Array ของทุกขั้นตอน
.
**ถ้าใช้ REDUCE:**
```
=REDUCE(0, {10,20,30,40}, LAMBDA(a,v,a+v))
ผลลัพธ์: 100 (ผลรวมสุดท้ายค่าเดียว)
```
.
**ถ้าต้องการ Running Total ต้องใช้ SCAN:**
```
=SCAN(0, {10,20,30,40}, LAMBDA(a,v,a+v))
ผลลัพธ์: {10;30;60;100} (Array แสดงผลสะสมทุกขั้น)
```
.
**เมื่อไหร่ใช้อะไร:**
• **REDUCE:** ต้องการแค่ผลสุดท้าย → ผลรวม, ข้อความที่รวมเสร็จ, ค่าสูงสุด
• **SCAN:** ต้องการเห็นทุกขั้นตอน → Running Total, Cumulative Sum, กราฟแสดงความคืบหน้า
.
ถ้าใช้ REDUCE ทำ Running Total จะได้แค่ตัวเลขสุดท้ายมาตัวเดียว ซึ่งไม่ใช่สิ่งที่ต้องการนะครับ

**Q: REDUCE รองรับ Excel เวอร์ชันไหนบ้าง?**

REDUCE เป็น LAMBDA Helper Function ที่รองรับเฉพาะ:
.
**✅ รองรับ:**
• Microsoft 365 (subscription)
• Excel 2024
• Excel for the web
• Excel for Mac (Microsoft 365)
.
**❌ ไม่รองรับ:**
• Excel 2021 หรือเก่ากว่า
• Excel 2019
• Excel 2016
• Excel 2013
• Standalone versions ที่ไม่ใช่ subscription
.
**วิธีตรวจสอบ:**
พิมพ์ =REDUCE( ใน cell ถ้า Excel แสดง tooltip คำแนะนำพารามิเตอร์แสดงว่ารองรับ ถ้าขึ้น #NAME? error แสดงว่า Excel version นั้นไม่รองรับ
.
**Alternative สำหรับ Excel เก่า:**
ถ้าไม่มี REDUCE ต้องใช้วิธีอื่นแทน:
• สร้าง Helper Column คำนวณทีละขั้น
• ใช้ VBA User-Defined Function
• ใช้ Power Query (สำหรับ data transformation)
• Nested formulas (อ่านยาก แต่ทำได้บางกรณี)
.
ส่วนตัวผมแนะนำให้ update เป็น Microsoft 365 นะครับ จะได้ใช้ LAMBDA ครอบครัวได้หมดเลย

**Q: REDUCE ช้ากว่าฟังก์ชันมาตรฐานไหม?**

**ใช่ REDUCE ช้ากว่าฟังก์ชันมาตรฐาน** แต่ความต่างขึ้นกับขนาดข้อมูลครับ
.
**Performance Comparison:**
• ข้อมูลน้อย (10,000 rows): REDUCE ช้ากว่าชัดเจน
.
**ตัวอย่าง:**
• =SUM(A1:A10000) → เร็วมาก (optimized C++ code)
• =REDUCE(0, A1:A10000, LAMBDA(a,v,a+v)) → ช้ากว่า (วนลูปทีละ cell)
.
**Best Practice:**
1. **ใช้ฟังก์ชันมาตรฐานก่อนเสมอ** ถ้าทำได้:
   • SUM, AVERAGE, MAX, MIN → ใช้เลย อย่าใช้ REDUCE
   • SUMIF, COUNTIF → ถ้าเงื่อนไขง่าย ใช้อันนี้
.
2. **ใช้ REDUCE เมื่อ:**
   • ฟังก์ชันมาตรฐานทำไม่ได้
   • เงื่อนไขซับซ้อนเกินไป (เช่น sum เฉพาะเลขคู่)
   • ต้องการ sequential calculation
.
3. **Optimization Tips:**
   • ถ้าข้อมูลเยอะมาก ลอง Filter ก่อนใส่ REDUCE
   • ใช้ LET เก็บค่าที่คำนวณซ้ำ
   • พิจารณาใช้ Helper Column แทน ถ้า performance สำคัญมาก
.
**สรุป:** REDUCE ให้ flexibility แลกกับ speed ใช้เมื่อจำเป็นจริงๆ นะครับ

**Q: REDUCE กับ MAP ต่างกันอย่างไร?**

ทั้งคู่เป็น LAMBDA Helper Functions แต่ใช้งานต่างกันครับ:
.
**REDUCE:**
• **วัตถุประสงค์:** รวม Array เป็นค่าเดียว (aggregate)
• **Input:** Array + LAMBDA ที่รับ 2 parameters (accumulator, value)
• **Output:** Single value (ค่าเดียว)
• **Use Case:** Sum, Max, Concatenate, Count, คำนวณค่าสุดท้าย
• **ตัวอย่าง:** =REDUCE(0, {1,2,3}, LAMBDA(a,v,a+v)) → 6
.
**MAP:**
• **วัตถุประสงค์:** แปลงทุก element ใน Array (transform)
• **Input:** Array + LAMBDA ที่รับ 1 parameter (value)
• **Output:** Array ที่มีขนาดเท่าเดิม แต่ค่าถูกแปลง
• **Use Case:** คูณทุกตัวด้วย 2, เปลี่ยนเป็น UPPER, คำนวณ formula สำหรับทุก element
• **ตัวอย่าง:** =MAP({1,2,3}, LAMBDA(v,v*2)) → {2,4,6}
.
**เปรียบเทียบแบบเห็นภาพ:**
```
Array เริ่มต้น: {10, 20, 30}

MAP (transform):
{10, 20, 30} → apply LAMBDA(v, v*2)
 → {20, 40, 60}  (ขนาด Array เท่าเดิม, ค่าถูกแปลง)

REDUCE (aggregate):
{10, 20, 30} → apply LAMBDA(a,v, a+v) with initial=0
 → 60  (ได้ค่าเดียว)
```
.
**Key Difference:**
• MAP: One-to-one mapping (1 input → 1 output per element)
• REDUCE: Many-to-one reduction (many inputs → 1 output)
.
**เมื่อไหร่ใช้อะไร:**
• **MAP:** ต้องการแปลงทุกค่า → คูณ, หาร, เปลี่ยน format
• **REDUCE:** ต้องการรวมเป็นค่าเดียว → sum, max, concatenate
.
เข้าใจความต่างตรงนี้ แล้วจะเลือกใช้ได้ถูกต้องครับ

**Q: REDUCE สามารถทำงานกับ 2D Array ได้ไหม?**

**ได้ครับ แต่จะวนลูปแบบ row-by-row หรือ column-by-column**
.
REDUCE จะประมวลผล 2D Array ทีละแถว (ถ้า Array เป็น vertical) หรือทีละคอลัมน์ (ถ้า Array เป็น horizontal)
.
**ตัวอย่างที่ 1: Sum ทุกค่าใน 2D Array**
```
=REDUCE(0, A1:C3,
  LAMBDA(total, row,
    total + SUM(row)
  )
)
```
.
ถ้า A1:C3 มีข้อมูล:
```
1  2  3
4  5  6
7  8  9
```
.
REDUCE จะวนลูป:
• รอบ 1: row={1,2,3} → total=0+SUM({1,2,3})=6
• รอบ 2: row={4,5,6} → total=6+SUM({4,5,6})=21
• รอบ 3: row={7,8,9} → total=21+SUM({7,8,9})=45
.
ผลลัพธ์: 45
.
**Tips สำหรับ 2D Array:**
• ใช้ BYCOL/BYROW ร่วมกับ REDUCE สำหรับ control ที่ดีกว่า
• ถ้าต้องการวนลูปทีละ cell ใช้ TOCOL() แปลงเป็น 1D ก่อน
• Nested REDUCE สามารถวนลูป 2 dimensions ได้
.
**Alternative:**
ถ้าต้องการประมวลผลทีละคอลัมน์/แถว ใช้ BYCOL/BYROW จะง่ายกว่า:
```
=BYCOL(A1:C3, LAMBDA(col, SUM(col)))
```
.
REDUCE เหมาะกับ 1D Array มากกว่า สำหรับ 2D ควรพิจารณา BYCOL/BYROW ก่อนนะครับ

## ฟังก์ชันที่เกี่ยวข้อง

- [SCAN – คำนวณและแสดงผลลัพธ์สะสมทุกขั้นตอน](https://www.thepexcel.com/functions/excel/logical/scan/)
- [LAMBDA – สร้างฟังก์ชันที่กำหนดเอง](https://www.thepexcel.com/functions/excel/logical/lambda/)
- [MAP – ประมวลผลทุก Element ใน Array ด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/map/)
- [BYCOL – ประมวลผลทีละคอลัมน์ด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/bycol/)
- [BYROW – ประมวลผลทีละแถวด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/byrow/)
- [MAKEARRAY – สร้าง Array ด้วย LAMBDA แบบกำหนดเอง](https://www.thepexcel.com/functions/excel/logical/makearray/)
- [FILTER – ฟังก์ชันกรองข้อมูลแบบไดนามิก](https://www.thepexcel.com/functions/excel/lookup-and-reference/filter/)
- [SUMIF – หาผลรวมแบบมีเงื่อนไข](https://www.thepexcel.com/functions/excel/math-and-trigonometry/sumif/)
- [TEXTJOIN – เชื่อมข้อความหลายค่าด้วยตัวคั่นที่กำหนด](https://www.thepexcel.com/functions/excel/text/textjoin/)
- [SUBSTITUTE – แทนที่คำหรือข้อความด้วยคำใหม่](https://www.thepexcel.com/functions/excel/text/substitute/)
- [LET – กำหนดตัวแปรในสูตรเพื่อเพิ่มความเร็วและความชัดเจน](https://www.thepexcel.com/functions/excel/logical/let/)
- [SEQUENCE – สร้างตารางตัวเลขเรียงลำดับแบบ Dynamic Array](https://www.thepexcel.com/functions/excel/math-and-trigonometry/sequence/)
- [INDEX – ดึงค่าจากตำแหน่งที่ระบุใน Range หรือ Array](https://www.thepexcel.com/functions/excel/lookup-and-reference/index/)
- [ISEVEN – ตรวจสอบว่าเป็นเลขคู่](https://www.thepexcel.com/functions/excel/information/iseven/)

## แหล่งข้อมูลเพิ่มเติม

- [Microsoft Support: REDUCE function](https://support.microsoft.com/en-us/office/reduce-function-42e39910-b345-45f3-84b8-0642b568b7cb) _(official)_
- [ExcelJet: Excel REDUCE function](https://exceljet.net/functions/reduce-function) _(guide)_
- [Coefficient: REDUCE Function Tutorial](https://coefficient.io/excel-tutorials/reduce-function) _(tutorial)_

---

_Source: [https://www.thepexcel.com/functions/excel/logical/reduce/](https://www.thepexcel.com/functions/excel/logical/reduce/)_