Thep Excel
REDUCE – รวมผลลัพธ์จาก Array เป็นค่าเดียว
REDUCE เป็นฟังก์ชัน Helper ที่ทำงานร่วมกับ LAMBDA เพื่อวนลูปประมวลผลข้อมูลใน Array โดยรับค่าเริ่มต้น (initial_value) และส่งค่าเข้า LAMBDA ทีละ element เพื่อคำนวณค่าสะสม (accumulator) ที่สืบเนื่องจากรอบก่อนหน้า แล้ว return ผลลัพธ์สุดท้ายเพียงค่าเดียว ต่างจาก SCAN ที่ return Array ของทุกขั้นตอน REDUCE เหมาะสำหรับการสร้าง custom aggregation ที่ซับซ้อนกว่าฟังก์ชันมาตรฐาน
=REDUCE([initial_value], array, lambda)
Function Metrics
Popularity
9/10
Difficulty
8/10
Usefulness
10/10
Syntax & Arguments
=REDUCE([initial_value], array, lambda)
| Argument | Type | Required | Default | Description |
|---|---|---|---|---|
| initial_value | Any | Optional | ค่าแรกของ Array | ค่าเริ่มต้นสำหรับ accumulator ถ้าไม่ระบุ Excel จะใช้ element แรกของ Array เป็นค่าเริ่มต้นและเริ่มวนลูปที่ element ที่ 2 แนะนำให้ระบุชัดเจนเสมอเพื่อหลีกเลี่ยง data type ไม่ตรงกัน (เช่น 0 สำหรับ sum, 1 สำหรับ product, “” สำหรับ text) |
| array | Range/Array | Yes | ช่วงข้อมูลหรือ Array ที่ต้องการประมวลผล สามารถเป็น range reference (เช่น A1:A10), named range, table column (เช่น Sales[Amount]), หรือ array constant (เช่น {1,2,3,4,5}) | |
| lambda | Function | Yes | ฟังก์ชัน LAMBDA ที่ต้องรับพารามิเตอร์ 2 ตัว: accumulator (ค่าสะสมจากรอบก่อนหน้า) และ value (element ปัจจุบันจาก Array) แล้ว return ค่าที่จะเป็น accumulator ของรอบถัดไป สูตร LAMBDA มีรูปแบบ LAMBDA(a, v, expression) โดย a = accumulator, v = current value |
How it works
Custom Aggregation ที่ฟังก์ชันมาตรฐานทำไม่ได้
สร้างการคำนวณแบบกำหนดเองเช่น sum เฉพาะเลขคู่, count เฉพาะค่าที่มากกว่าค่าเฉลี่ย, หรือ product ของเฉพาะค่าบวก ซึ่ง SUMIF/COUNTIF ทำไม่ได้เพราะต้องใช้ฟังก์ชันใน criteria
Text Processing แบบมีเงื่อนไข
รวมข้อความโดยกรองเฉพาะข้อมูลที่ต้องการ เช่น concatenate เฉพาะชื่อที่ยาวกว่า 3 ตัวอักษร หรือรวมเฉพาะค่าที่ไม่ซ้ำ ซึ่ง TEXTJOIN ทำเงื่อนไขซับซ้อนไม่ได้
Batch Find and Replace
ใช้ REDUCE วนลูป SUBSTITUTE เพื่อแทนที่หลายคำพร้อมกัน เช่น แก้คำผิดหลายคำในข้อความเดียว หรือทำ data cleansing โดยลบอักขระพิเศษหลายตัวออกจากข้อความ
Sequential Calculation
คำนวณแบบต่อเนื่องที่แต่ละขั้นตอนขึ้นกับผลลัพธ์ก่อนหน้า เช่น คำนวณดอกเบี้ยทบต้น, running balance ของบัญชี, หรือการคำนวณที่ผลของรอบก่อนเป็น input ของรอบถัดไป
Array Building แบบมีเงื่อนไข
สร้าง Array ใหม่จากข้อมูลเดิมโดยมีเงื่อนไขซับซ้อน เช่น รวม Array หลายชุดแบบมีเงื่อนไข หรือแปลงข้อมูลที่ไม่สามารถใช้ MAP ได้เพราะต้องอ้างอิงผลลัพธ์ก่อนหน้า
Examples
ตัวอย่างที่ 1: Foundation – ผลรวมพื้นฐาน (เหมือน SUM)
REDUCE(0, {1,2,3,4,5}, LAMBDA(a, v, a+v))
.
• รอบ 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 ครับ
=REDUCE(0, {1,2,3,4,5}, LAMBDA(a, v, a+v))
15
ตัวอย่างที่ 2: Foundation – หา MAX (ค่าสูงสุด)
REDUCE(0, {5,3,9,1,7}, LAMBDA(a, v, MAX(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 ได้ ไม่ใช่แค่บวกลบอย่างเดียวครับ
=REDUCE(0, {5,3,9,1,7}, LAMBDA(a, v, MAX(a, v)))
9
ตัวอย่างที่ 3: Practical – รวมเฉพาะเลขคู่
REDUCE(0, {1,2,3,4,5,6,7,8,9,10}, LAMBDA(a, v, IF(ISEVEN(v), a+v, a)))
.
• 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 😎
=REDUCE(0, {1,2,3,4,5,6,7,8,9,10}, LAMBDA(a, v, IF(ISEVEN(v), a+v, a)))
30
ตัวอย่างที่ 4: Practical – ต่อข้อความแบบมีเงื่อนไข
REDUCE("", {"John","Al","Michael","Bob","Tom"}, LAMBDA(a, v, IF(LEN(v)>3, IF(a="", v, a&", "&v), a)))
.
• 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 ให้ความยืดหยุ่นมากกว่าครับ 💡
=REDUCE("", {"John","Al","Michael","Bob","Tom"}, LAMBDA(a, v, IF(LEN(v)>3, IF(a="", v, a&", "&v), a)))
"John, Michael"
ตัวอย่างที่ 5: Advanced – Batch SUBSTITUTE (แทนที่หลายคำ)
REDUCE("Hello World, Good Morning", {"Hello","World","Good"}, LAMBDA(txt, word, SUBSTITUTE(txt, word, "Hi")))
.
• รอบ 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 ก็จัดการได้เลย 👍
=REDUCE("Hello World, Good Morning", {"Hello","World","Good"}, LAMBDA(txt, word, SUBSTITUTE(txt, word, "Hi")))
"Hi Hi, Hi Morning"
ตัวอย่างที่ 6: Advanced – นับจำนวน element ที่ตรงเงื่อนไข
REDUCE(0, {5,12,3,18,7,21,9}, LAMBDA(a, v, IF(v>10, a+1, a)))
.
• 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 ทำไม่ได้ 💡
=REDUCE(0, {5,12,3,18,7,21,9}, LAMBDA(a, v, IF(v>10, a+1, a)))
3
ตัวอย่างที่ 7: Advanced – Find & Replace จาก Lookup Table
LET( text, "XL training and PPT training", find_list, {"XL","PPT"}, replace_list, {"Excel","PowerPoint"}, REDUCE(text, SEQUENCE(ROWS(find_list)), LAMBDA(txt, i,…
.
**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 คู่ก็ใช้สูตรเดียวกันนี้ได้เลยครับ 😎
=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"
ตัวอย่างที่ 8: Real-World – คำนวณดอกเบี้ยทบต้น
LET( principal, 10000, monthly_deposit, 1000, annual_rate, 0.06, months, 12, monthly_rate, annual_rate/12, REDUCE(principal, SEQUENCE(months), LAMBDA(balance, m…
.
**ตั้งต้น:**
• 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 ที่ซับซ้อนครับ 💰
=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
FAQs
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 ครับ
ถ้าไม่ใส่ 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
.
ส่วนตัวผมแนะนำให้ใส่เสมอนะครับ จะได้อ่านสูตรง่ายกว่า
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 ได้คล่องมากขึ้นครับ
สามารถใช้ 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 จะได้แค่ตัวเลขสุดท้ายมาตัวเดียว ซึ่งไม่ใช่สิ่งที่ต้องการนะครับ
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 ครอบครัวได้หมดเลย
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 ใช้เมื่อจำเป็นจริงๆ นะครับ
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
.
เข้าใจความต่างตรงนี้ แล้วจะเลือกใช้ได้ถูกต้องครับ
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 ก่อนนะครับ
Resources & Related
Resources
-
Microsoft Support: REDUCE function
official -
ExcelJet: Excel REDUCE function
guide -
Coefficient: REDUCE Function Tutorial
tutorial
Related posts
Related functions
Additional Notes
REDUCE เป็น LAMBDA Helper Function ที่ใช้วนลูปผ่านทุก element ใน Array และคำนวณค่าสะสม (accumulator) ด้วย LAMBDA ที่กำหนดเอง จนได้ผลลัพธ์สุดท้ายเพียงค่าเดียว
.
ต่างจาก SCAN ที่ return Array ของทุกขั้นตอน REDUCE return เฉพาะค่าสุดท้าย เหมาะสำหรับการสร้าง custom aggregation เช่น conditional sum ที่ซับซ้อนกว่า SUMIF, text concatenation แบบมีเงื่อนไข, batch find-replace หลายคำพร้อมกัน หรือการคำนวณแบบ sequential ที่ขั้นตอนถัดไปขึ้นกับผลลัพธ์ก่อนหน้า
.
เอาจริงๆ REDUCE เป็นฟังก์ชันที่ทรงพลังมาก แต่ต้องเข้าใจ concept ของ accumulator ให้ดีก่อนนะครับ พอเข้าใจแล้วจะเปิดโลกใหม่ให้กับการทำงานกับ Array เลย 😎