---
title: MAP – ประมวลผลทุก Element ใน Array ด้วย LAMBDA
url: https://www.thepexcel.com/functions/excel/logical/map/
type: function-explainer
program: Excel
syntax: "=MAP(array1, [array2, ...], lambda)"
date: 2025-12-18
scores:
  popularity: 9
  difficulty: 7
  usefulness: 10
---

# MAP – ประมวลผลทุก Element ใน Array ด้วย LAMBDA

> ส่งค่าทีละ element เข้า LAMBDA เพื่อแปลงทุกค่าใน Array

## คำอธิบาย

MAP ส่งค่าทีละ element จาก Array หนึ่งหรือหลายตัวเข้าไปประมวลผลใน LAMBDA แล้วคืน Array ผลลัพธ์ที่มีขนาดเท่ากับ input array ต้นฉบับ เหมาะสำหรับ element-wise operations เช่น การแปลงค่าทุกตัว การตรวจสอบเงื่อนไขทีละเซลล์ หรือการคำนวณจากหลาย Array พร้อมกัน ต่างจาก BYROW/BYCOL ที่ส่งทั้งแถวหรือทั้งคอลัมน์ MAP จะส่งเฉพาะค่าเดี่ยวๆ ทีละตำแหน่ง

## Syntax

```excel
=MAP(array1, [array2, ...], lambda)
```

## Arguments

| Name | Required | Type | Default | Description |
| --- | --- | --- | --- | --- |
| array1 | Yes | Array |  | Array ตัวแรกที่ต้องการนำไปประมวลผล สามารถเป็น range, array constant, หรือผลลัพธ์จากฟังก์ชันอื่น |
| array2 | No | Array |  | Array ตัวที่สอง (optional) ต้องมีขนาด (rows × columns) เท่ากับ array1 พอดี สามารถใส่ได้หลาย Array (array3, array4, ...) โดยทุกตัวต้องมีขนาดเท่ากัน |
| lambda | Yes | Function |  | LAMBDA function ที่รับ parameter เท่ากับจำนวน Array ที่ใส่เข้ามา ถ้าใส่ 2 Array, LAMBDA ต้องมี 2 parameters เช่น LAMBDA(a, b, ...) ฟังก์ชันนี้จะถูกเรียกทีละครั้งสำหรับแต่ละตำแหน่งใน Array |

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

### Element-wise Transformation

แปลงค่าทุกตัวใน Array ตามกฎเฉพาะ เช่น คูณทุกค่าด้วย 2, ยกกำลังสอง, หรือแปลงหน่วย (กิโลกรัม → ปอนด์) โดยไม่ต้องใช้ helper column

### Conditional Element Processing

ตรวจสอบเงื่อนไขทีละเซลล์และ return ค่าตามเงื่อนไข เช่น ถ้าค่ามากกว่า 50 ให้ใส่ "Pass" ไม่เช่นนั้นให้ "Fail" หรือแทนที่ค่าที่ไม่ใช่ตัวเลขด้วย 0

### Multi-Array Parallel Calculations

คำนวณจาก 2-3 Array พร้อมกัน เช่น คำนวณ price × quantity จากสอง Array, หา MAX จากหลาย Array ตำแหน่งเดียวกัน, หรือตรวจเงื่อนไข AND/OR จากหลายคอลัมน์

### Custom Text Processing

ใช้ MAP ร่วมกับฟังก์ชัน text เพื่อแปลงข้อความทั้ง Array เช่น ดึง domain จาก email, แยกชื่อ-นามสกุล, format ตัวเลขแบบกำหนดเอง, หรือ clean data

### Data Validation and Cleaning

ตรวจสอบความถูกต้องของข้อมูลทั้ง Array เช่น กรอง blank cells, ลบ non-numeric values, แทนที่ errors ด้วยค่า default, หรือ normalize ข้อมูล

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: พื้นฐาน - คูณทุกค่าด้วย 2

```excel
=MAP({1; 2; 3; 4; 5}, LAMBDA(v, v * 2))
```

**ผลลัพธ์:** `{2; 4; 6; 8; 10}`

นี่คือตัวอย่างพื้นฐานที่สุดของ MAP ครับ ส่งค่าทีละตัว (1, 2, 3, 4, 5) เข้า LAMBDA ที่มี parameter เดียว (v) แล้ว LAMBDA ก็คูณค่าแต่ละตัวด้วย 2 แล้ว return กลับมา
.
ได้ผลลัพธ์เป็น Array ขนาดเท่าเดิม (5 แถว × 1 คอลัมน์) นี่เป็น element-wise transformation แบบง่ายที่สุด เหมาะสำหรับเริ่มต้นทำความเข้าใจ MAP

### 2. ตัวอย่างที่ 2: การใช้งานจริง - ตรวจคะแนนสอบ

```excel
=MAP(StudentScores, LAMBDA(score, IF(score >= 50, "ผ่าน", "ไม่ผ่าน")))
```

**ผลลัพธ์:** `{"ผ่าน"; "ไม่ผ่าน"; "ผ่าน"; "ผ่าน"}`

สมมติ StudentScores = {75; 42; 68; 55} MAP จะส่งคะแนนทีละตัวเข้า LAMBDA ทำให้ได้:
.
• คะแนน 75 >= 50 → "ผ่าน"
• คะแนน 42 >= 50 → "ไม่ผ่าน" 😭
• คะแนน 68 >= 50 → "ผ่าน"
• คะแนน 55 >= 50 → "ผ่าน"
.
ตัวอย่างนี้แสดงการใช้เงื่อนไข IF ภายใน LAMBDA เพื่อแปลงค่าตัวเลขเป็น text ตามเงื่อนไข ทำได้ง่ายๆ แค่ใส่ IF ใน LAMBDA เท่านั้นครับ

### 3. ตัวอย่างที่ 3: หลาย Array - คำนวณราคารวม

```excel
=MAP(Prices, Quantities, LAMBDA(price, qty, price * qty))
```

**ผลลัพธ์:** `{200; 500; 90}`

สมมติ Prices = {10; 20; 30} และ Quantities = {20; 25; 3} MAP จะจับคู่ค่าจาก 2 Array ตามตำแหน่งเดียวกัน:
.
• ตำแหน่งที่ 1 → 10 × 20 = 200
• ตำแหน่งที่ 2 → 20 × 25 = 500
• ตำแหน่งที่ 3 → 30 × 3 = 90
.
นี่คือ parallel array processing ที่ LAMBDA รับ 2 parameters (price, qty) และคำนวณทีละคู่ เจ๋งตรงที่ไม่ต้องสร้าง helper column เลย 😎

### 4. ตัวอย่างที่ 4: Advanced - ดึง Domain จาก Email

```excel
=MAP(EmailList, LAMBDA(email, MID(email, FIND("@", email) + 1, LEN(email))))
```

**ผลลัพธ์:** `{"gmail.com"; "outlook.com"; "company.co.th"}`

สมมติ EmailList = {"john@gmail.com"; "jane@outlook.com"; "admin@company.co.th"}
.
MAP ส่ง email ทีละตัวเข้า LAMBDA ซึ่งใช้ FIND หาตำแหน่ง @ แล้วใช้ MID ตัดข้อความตั้งแต่หลัง @ จนจบ ได้ domain ของแต่ละ email
.
ตัวอย่างนี้แสดงให้เห็นว่า MAP ใช้กับ text functions ซับซ้อนได้ด้วยนะครับ ไม่ใช่แค่ตัวเลขอย่างเดียว 💡

### 5. ตัวอย่างที่ 5: Advanced - หา MAX จาก 3 Array

```excel
=MAP(Q1Sales, Q2Sales, Q3Sales, LAMBDA(q1, q2, q3, MAX(q1, q2, q3)))
```

**ผลลัพธ์:** `{80; 150; 70}`

สมมติ Q1Sales = {50; 100; 30}, Q2Sales = {80; 75; 70}, Q3Sales = {60; 150; 45}
.
MAP จับคู่ค่าจาก 3 Array ตำแหน่งเดียวกัน:
.
• ตำแหน่งที่ 1 → MAX(50, 80, 60) = 80
• ตำแหน่งที่ 2 → MAX(100, 75, 150) = 150
• ตำแหน่งที่ 3 → MAX(30, 70, 45) = 70
.
นี่คือจุดเด่นของ MAP ครับ ใช้ได้กับ 3+ Array พร้อมกันและใส่ฟังก์ชัน aggregation อย่าง MAX ใน LAMBDA ได้เลย

### 6. ตัวอย่างที่ 6: Complex - Data Cleaning (ลบค่าที่ไม่ใช่ตัวเลข)

```excel
=MAP(RawData, LAMBDA(value, IF(ISNUMBER(value), value, "")))
```

**ผลลัพธ์:** `{100; ""; 250; ""; 75}`

สมมติ RawData = {100; "N/A"; 250; "Error"; 75}
.
MAP ตรวจสอบทีละค่าว่าเป็นตัวเลขหรือไม่ด้วย ISNUMBER:
• ถ้าเป็นตัวเลข → return ค่าเดิม
• ถ้าไม่ใช่ → return empty string ("")
.
นี่คือเทคนิคที่ผมใช้บ่อยมากสำหรับ clean data ครับ เพราะบางทีข้อมูลที่ได้มามันมี "N/A" หรือ "Error" ปนอยู่ ใช้ MAP แบบนี้กรองออกได้เลย 😎

### 7. ตัวอย่างที่ 7: Complex Real-World - คำนวณส่วนลดแบบซับซ้อน

```excel
=MAP(Prices, CustomerTypes, LAMBDA(p, type, 
  IF(type="VIP", p * 0.8,
  IF(type="Member", p * 0.9, p))))
```

**ผลลัพธ์:** `{800; 450; 600}`

สมมติ Prices = {1000; 500; 600} และ CustomerTypes = {"VIP"; "Member"; "Guest"}
.
MAP ส่งคู่ค่า (price, type) เข้า LAMBDA ทีละคู่:
.
• ตำแหน่งที่ 1 → type="VIP" ลด 20% → 1000 × 0.8 = 800
• ตำแหน่งที่ 2 → type="Member" ลด 10% → 500 × 0.9 = 450
• ตำแหน่งที่ 3 → type="Guest" ไม่ลด → 600
.
ตัวอย่างนี้แสดงการใช้ nested IF ใน LAMBDA เพื่อคำนวณส่วนลดตาม customer type แบบซับซ้อน นี่คือตัวอย่างการใช้งานจริงที่เจอบ่อยในงานครับ 💡

### 8. ตัวอย่างที่ 8: ใช้ร่วมกับ FILTER - กรองแถวที่ตรงเงื่อนไขหลายคอลัมน์

```excel
=FILTER(ProductTable, MAP(ProductTable[Size], ProductTable[Color], LAMBDA(s, c, AND(s="Large", c="Red"))))
```

**ผลลัพธ์:** `Array of products where Size=Large AND Color=Red`

MAP ตรวจสอบทีละแถวว่า Size="Large" AND Color="Red" หรือไม่ โดย return TRUE/FALSE เป็น Array
.
จากนั้น FILTER ใช้ Array ของ TRUE/FALSE นี้เพื่อกรองแถวที่ต้องการ
.
ตัวอย่างนี้แสดงเทคนิคที่หลายคนไม่รู้ครับ คือใช้ MAP เป็น helper สำหรับ AND logic ที่ FILTER ทำไม่ได้โดยตรง เพราะ AND จะ aggregate เป็นค่าเดียว แต่ MAP ทำให้ได้ array ของผลลัพธ์ 😎

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

## เปรียบเทียบ LAMBDA Helper Functions

MAP เป็นหนึ่งใน 5 LAMBDA Helper Functions หลักของ Excel 365 ครับ แต่ละตัวมีจุดประสงค์ต่างกัน มาดูกันว่าแต่ละตัวทำอะไร:

| Function | Input ต่อ iteration | Output | Use Case |
|----------|---------------------|--------|----------|
| **MAP** | ทีละ element | Array ขนาดเท่าเดิม | แปลงค่าทุกตัว, element-wise ops |
| **BYROW** | ทีละแถว (array) | Column เดียว (1 ค่า/แถว) | Aggregate แต่ละแถว (SUM, AVERAGE) |
| **BYCOL** | ทีละคอลัมน์ (array) | Row เดียว (1 ค่า/คอลัมน์) | Aggregate แต่ละคอลัมน์ |
| **REDUCE** | ทีละ element + accumulator | ค่าเดียว | รวมค่าทั้งหมดเป็นผลลัพธ์เดียว |
| **SCAN** | ทีละ element + accumulator | Array ขนาดเท่าเดิม | Running total, cumulative calc |

**ตัวอย่างเปรียบเทียบ:**

```excel
// Input: {1; 2; 3; 4; 5}

// MAP - คูณ 2 ทุกค่า
=MAP({1;2;3;4;5}, LAMBDA(v, v*2))
→ {2; 4; 6; 8; 10}  // 5 ค่า

// REDUCE - รวมทุกค่า
=REDUCE(0, {1;2;3;4;5}, LAMBDA(acc, v, acc+v))
→ 15  // 1 ค่า

// SCAN - running total
=SCAN(0, {1;2;3;4;5}, LAMBDA(acc, v, acc+v))
→ {1; 3; 6; 10; 15}  // 5 ค่า (cumulative)
```

## การใช้ MAP กับหลาย Array - Array Size Rules

**กฎสำคัญ:** ทุก Array ต้องมีขนาดเท่ากันพอดี (rows × columns)

```excel
// ✅ CORRECT - ขนาดเท่ากัน (3 elements แต่ละตัว)
=MAP({10;20;30}, {2;3;4}, LAMBDA(a,b, a*b))
→ {20; 60; 120}

// ✅ CORRECT - 2D arrays ขนาดเท่ากัน (2×3)
=MAP({1,2,3;4,5,6}, {10,20,30;40,50,60}, LAMBDA(a,b, a+b))
→ {11,22,33;44,55,66}

// ❌ ERROR - ขนาดไม่ตรงกัน (3 vs 2 elements)
=MAP({10;20;30}, {2;3}, LAMBDA(a,b, a*b))
→ #VALUE! "Incorrect Parameters"

// ❌ ERROR - dimensions ไม่ตรง (3×1 vs 1×3)
=MAP({10;20;30}, {2,3,4}, LAMBDA(a,b, a*b))
→ #VALUE! "Incorrect Parameters"
```

## MAP Position Matching (การจับคู่ตำแหน่ง)

เมื่อใช้หลาย Array, MAP จะจับคู่ค่าตามตำแหน่งเดียวกัน (index-by-index):

```excel
Array1: {A, B, C}
Array2: {1, 2, 3}
Array3: {X, Y, Z}

// MAP จับคู่:
// Position 1: A, 1, X
// Position 2: B, 2, Y  
// Position 3: C, 3, Z

=MAP(Array1, Array2, Array3, LAMBDA(a, b, c, a & b & c))
→ {"A1X"; "B2Y"; "C3Z"}
```

## Performance Tips

💡 **Tips จากประสบการณ์:**

1. **ใช้ native array operations เมื่อทำได้:**
   - ใช้ `A1:A10 * 2` แทน `MAP(A1:A10, LAMBDA(v, v*2))` เร็วกว่าเยอะครับ
   - MAP ควรใช้เฉพาะเมื่อ logic ซับซ้อนเกินกว่า native ops จะทำได้

2. **หลีกเลี่ยง volatile functions ภายใน LAMBDA:**
   - LAMBDA ที่มี NOW(), TODAY(), RAND(), OFFSET() จะทำให้ MAP recalculate บ่อย
   - ถ้าจำเป็นต้องใช้ ให้คำนวณค่าเหล่านี้ข้างนอกก่อนแล้วส่งเข้าไปเป็น parameter

3. **ใช้ MAP กับ Array ขนาดใหญ่ (10,000+ cells) ระวังความช้า:**
   - LAMBDA ถูกเรียกทีละ element อาจช้าในข้อมูลขนาดใหญ่มาก 😅
   - ส่วนตัวผมแนะนำให้ใช้ helper columns หรือ Power Query สำหรับ dataset ขนาดใหญ่แทนครับ

## Common Patterns

### Pattern 1: Conditional Replacement
```excel
// แทนที่ค่าที่เป็น error ด้วย 0
=MAP(A1:A100, LAMBDA(v, IFERROR(v, 0)))

// แทนที่ blank ด้วย "N/A"
=MAP(A1:A100, LAMBDA(v, IF(v="", "N/A", v)))
```

### Pattern 2: Type Conversion
```excel
// แปลง text เป็น number (บังคับด้วย unary +)
=MAP(A1:A100, LAMBDA(v, +v))

// แปลงทุกค่าเป็น text
=MAP(A1:A100, LAMBDA(v, TEXT(v, "0")))
```

### Pattern 3: Multi-Column Logic (AND/OR)
```excel
// ใช้ MAP เพื่อทำ AND logic ที่ FILTER ต้องการ
=FILTER(Table, MAP(Table[Col1], Table[Col2], 
  LAMBDA(a, b, AND(a>100, b="Active"))))

// OR logic แบบซับซ้อน
=MAP(Status, Priority, LAMBDA(s, p, 
  OR(s="Urgent", AND(s="High", p>7))))
```

## Error Handling

**#VALUE! "Incorrect Parameters"** เกิดได้จาก:
- จำนวน parameters ใน LAMBDA ไม่ตรงกับจำนวน Array
- Array sizes ไม่เท่ากัน
- LAMBDA syntax ผิด

**#CALC! error:**
- LAMBDA มี circular reference
- Calculation chain เกิน limit (แก้ด้วย F9 force calculate)

**Solutions:**
```excel
// ตรวจสอบขนาด Array ก่อนใช้
=IF(AND(ROWS(Array1)=ROWS(Array2), COLUMNS(Array1)=COLUMNS(Array2)),
  MAP(Array1, Array2, LAMBDA(a,b, a+b)),
  "Array sizes don't match")
```

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

**Q: MAP ต่างจาก BYROW และ BYCOL อย่างไร?**

นี่เป็นคำถามที่เจอบ่อยมากครับ แต่ละตัวส่งข้อมูลเข้า LAMBDA คนละแบบ:
.
**MAP** → ส่งค่าทีละ element (ค่าเดี่ยว) และ return Array ขนาดเท่าเดิม
**BYROW** → ส่งทั้งแถว (array ย่อย) และ return column เดียว (1 ค่าต่อ 1 แถว)
**BYCOL** → ส่งทั้งคอลัมน์ (array ย่อย) และ return row เดียว (1 ค่าต่อ 1 คอลัมน์)
.
ตัวอย่าง: MAP({1,2,3}, LAMBDA(v, v*2)) → {2,4,6} (3 ค่า)
BYROW({1,2,3}, LAMBDA(row, SUM(row))) → {6} (1 ค่า)

**Q: Array ที่ใส่เข้า MAP ต้องมีขนาดเท่ากันหรือไม่?**

ใช่ครับ ต้องเท่ากันพอดี 💯
.
ทุก Array ที่ใส่เข้า MAP ต้องมีขนาด (rows × columns) เท่ากันเป๊ะ ถ้าใส่ array1 เป็น 5×3 แล้ว array2 ต้องเป็น 5×3 เหมือนกัน
.
ถ้าขนาดไม่ตรงกัน Excel จะแสดง #VALUE! error พร้อมข้อความ "Incorrect Parameters" ทันที
.
ส่วนตัวผมแนะนำให้ตรวจสอบขนาดด้วย ROWS() และ COLUMNS() ก่อนใช้ MAP กับหลาย Array นะครับ จะได้ไม่ต้องมานั่งแก้ error ทีหลัง 😅

**Q: LAMBDA ใน MAP ต้องมี parameter กี่ตัว?**

จำนวน parameter ของ LAMBDA ต้องเท่ากับจำนวน Array ที่ใส่เข้า MAP พอดี:
.
• ใส่ 1 Array → LAMBDA(v, ...) ต้องมี 1 parameter
• ใส่ 2 Array → LAMBDA(a, b, ...) ต้องมี 2 parameters
• ใส่ 3 Array → LAMBDA(a, b, c, ...) ต้องมี 3 parameters
.
ถ้าจำนวนไม่ตรง จะได้ #VALUE! error ทันทีครับ นี่เป็นข้อผิดพลาดที่เจอบ่อยตอนเริ่มใช้ MAP 😅

**Q: MAP กับ REDUCE ต่างกันอย่างไร เมื่อไหร่ควรใช้อะไร?**

ต่างกันเยอะเลยครับ จำง่ายๆ:
.
**MAP** → return Array ขนาดเท่าเดิม (element-wise transformation)
เหมาะสำหรับ: แปลงค่าทุกตัว
ตัวอย่าง: {1,2,3} → {2,4,6} (ได้ 3 ค่า)
.
**REDUCE** → return ค่าเดียว (aggregation)
เหมาะสำหรับ: รวมหรือสะสมค่า
ตัวอย่าง: {1,2,3} → 6 (ได้ 1 ค่า)
.
เลือกใช้: MAP เมื่อต้องการผลลัพธ์เป็น array, REDUCE เมื่อต้องการผลลัพธ์เป็นค่าเดียว

**Q: MAP สามารถใช้กับ 2D Array (หลายแถวหลายคอลัมน์) ได้หรือไม่?**

ได้แน่นอนครับ 💯
.
MAP ทำงานกับ 2D Array ได้เต็มรูปแบบ โดยจะประมวลผลทีละเซลล์ (ทุกแถวทุกคอลัมน์) และคืนค่า Array ที่มีขนาดเท่าเดิม
.
ตัวอย่าง: =MAP({1,2,3;4,5,6}, LAMBDA(v, v*10)) จะได้ {10,20,30;40,50,60} (2 แถว × 3 คอลัมน์เหมือนเดิม)
.
สังเกตว่า MAP จะวน loop ผ่านทุก element ตามลำดับ column-major (คอลัมน์ที่ 1 ทุกแถวก่อน แล้วคอลัมน์ที่ 2 ทุกแถว)

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

MAP ใช้ได้เฉพาะ **Microsoft 365** และ **Excel 2024** เท่านั้นครับ เป็นหนึ่งใน LAMBDA Helper Functions ที่ออกมาพร้อม dynamic arrays
.
❌ ไม่รองรับใน Excel 2021, 2019, 2016 หรือเวอร์ชันก่อนหน้า
.
ถ้าใช้ Excel รุ่นเก่า ต้องใช้วิธีทางเลือกเช่น helper columns หรือ array formulas แบบเดิม (Ctrl+Shift+Enter) ซึ่งจะยุ่งยากกว่านี้เยอะครับ 😅

**Q: MAP กับการใช้ array formula แบบธรรมดา (เช่น A1:A10*2) ต่างกันอย่างไร?**

ต่างกันครับ ในแง่ของความยืดหยุ่น:
.
**Array formula แบบธรรมดา (A1:A10*2)**
• ใช้ได้เฉพาะ operations พื้นฐาน (+, -, *, /, ^)
• ฟังก์ชันบางตัวที่รองรับ arrays โดยตรง
• เร็วกว่า MAP
.
**MAP**
• ใช้ได้กับ logic ซับซ้อนใดๆ ผ่าน LAMBDA
• รองรับ nested IF, text functions, VLOOKUP
• รองรับหลาย input arrays พร้อมกัน
• สามารถทำ custom logic ที่ array formula แบบเดิมทำไม่ได้
.
ส่วนตัวผมแนะนำว่า ถ้าทำได้ด้วย array formula ธรรมดา ให้ใช้แบบนั้นเพราะเร็วกว่า แต่ถ้า logic ซับซ้อน ให้ใช้ MAP เลยครับ 😎

**Q: ถ้า LAMBDA ภายใน MAP เกิด error บางตำแหน่ง จะเกิดอะไรขึ้น?**

ถ้า LAMBDA return error ที่ตำแหน่งใดตำแหน่งหนึ่ง (เช่น #DIV/0!, #N/A, #VALUE!) ตำแหน่งนั้นใน output array จะแสดง error นั้น
.
ส่วนตำแหน่งอื่นๆ ที่คำนวณสำเร็จจะแสดงผลลัพธ์ปกติครับ
.
ตัวอย่าง: =MAP({10,0,5}, LAMBDA(v, 100/v)) → {10, #DIV/0!, 20}
.
ถ้าต้องการป้องกัน error สามารถใช้ IFERROR ภายใน LAMBDA ได้เลย:
LAMBDA(v, IFERROR(100/v, 0)) จะได้ {10, 0, 20} แทน
.
นี่เป็นเทคนิคที่ผมใช้บ่อยมากสำหรับ data cleaning ครับ 💡

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

- [LAMBDA – สร้างฟังก์ชันที่กำหนดเอง](https://www.thepexcel.com/functions/excel/logical/lambda/)
- [BYROW – ประมวลผลทีละแถวด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/byrow/)
- [BYCOL – ประมวลผลทีละคอลัมน์ด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/bycol/)
- [REDUCE – รวมผลลัพธ์จาก Array เป็นค่าเดียว](https://www.thepexcel.com/functions/excel/logical/reduce/)
- [SCAN – คำนวณและแสดงผลลัพธ์สะสมทุกขั้นตอน](https://www.thepexcel.com/functions/excel/logical/scan/)
- [MAKEARRAY – สร้าง Array ด้วย LAMBDA แบบกำหนดเอง](https://www.thepexcel.com/functions/excel/logical/makearray/)
- [FILTER – ฟังก์ชันกรองข้อมูลแบบไดนามิก](https://www.thepexcel.com/functions/excel/lookup-and-reference/filter/)
- [IF – ฟังก์ชันตรรกะพื้นฐาน](https://www.thepexcel.com/functions/excel/logical/if/)
- [ISNUMBER – ตรวจสอบว่าเป็นตัวเลขหรือไม่](https://www.thepexcel.com/functions/excel/information/isnumber/)

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

- [Microsoft Support: MAP function](https://support.microsoft.com/en-us/office/map-function-48006093-f97c-47c1-bfcc-749263bb1f01) _(official)_
- [ExcelJet: Excel MAP function](https://exceljet.net/functions/map-function) _(guide)_
- [Microsoft: Introduction to LAMBDA](https://support.microsoft.com/en-us/office/lambda-function-bd212d27-1cd1-4321-a34a-ccbf254b8b67) _(official)_

---

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