---
title: MAKEARRAY – สร้าง Array ด้วย LAMBDA แบบกำหนดเอง
url: https://www.thepexcel.com/functions/excel/logical/makearray/
type: function-explainer
program: Excel
syntax: "=MAKEARRAY(rows, cols, lambda)"
date: 2025-12-18
scores:
  popularity: 9
  difficulty: 7
  usefulness: 9
---

# MAKEARRAY – สร้าง Array ด้วย LAMBDA แบบกำหนดเอง

> สร้าง Dynamic Array โดยใช้ LAMBDA คำนวณค่าแต่ละเซลล์ตาม row/column

## คำอธิบาย

MAKEARRAY สร้าง Dynamic Array ตามขนาดที่กำหนด (rows × cols) โดยใช้ LAMBDA function คำนวณค่าในแต่ละเซลล์ตามตำแหน่ง row และ column index (เริ่มที่ 1) ต่างจาก SEQUENCE ที่สร้างเฉพาะตัวเลขเรียงลำดับ MAKEARRAY สามารถสร้างข้อมูลได้หลากหลายรูปแบบตามการคำนวณที่กำหนดใน LAMBDA เช่น ตารางสูตรคูณ matrix ทางคณิตศาสตร์ pattern ข้อความ หรือค่าสุ่ม เหมาะสำหรับสร้าง dataset ขนาดใหญ่ที่มีรูปแบบเฉพาะ หรือ lookup table แบบ dynamic โดย LAMBDA จะถูกเรียกทำงานสำหรับทุกเซลล์ใน array ผลลัพธ์ ทำให้สร้างข้อมูลจำนวนมากได้อย่างรวดเร็วด้วยสูตรเดียว

## Syntax

```excel
=MAKEARRAY(rows, cols, lambda)
```

**excel**

```excel
=MAKEARRAY(3, 4, LAMBDA(r, c, r*c))
```

สร้างตารางสูตรคูณ 3×4 โดยคูณ row index กับ column index

**excel**

```excel
=MAKEARRAY(5, 1, LAMBDA(r, c, r^2))
```

สร้าง Array แนวตั้ง 5 แถว เก็บค่ากำลังสองของ row index (1, 4, 9, 16, 25)

**excel**

```excel
=MAKEARRAY(10, 10, LAMBDA(r, c, IF(r=c, 1, 0)))
```

สร้าง Identity Matrix 10×10 (diagonal เป็น 1 ที่เหลือเป็น 0)

## Arguments

| Name | Required | Type | Default | Description |
| --- | --- | --- | --- | --- |
| rows | Yes | Number |  | จำนวนแถวของ Array ที่ต้องการสร้าง ต้องเป็นจำนวนเต็มบวก มากกว่าหรือเท่ากับ 1 ถ้าน้อยกว่า 1 หรือไม่ใช่ตัวเลขจะได้ #VALUE! error |
| cols | Yes | Number |  | จำนวนคอลัมน์ของ Array ที่ต้องการสร้าง ต้องเป็นจำนวนเต็มบวก มากกว่าหรือเท่ากับ 1 ถ้าน้อยกว่า 1 หรือไม่ใช่ตัวเลขจะได้ #VALUE! error |
| lambda | Yes | Function |  | LAMBDA function ที่รับ 2 parameters: (1) row index และ (2) column index โดย index เริ่มต้นที่ 1 (ไม่ใช่ 0) และ return ค่าที่จะใส่ในเซลล์ตำแหน่งนั้น LAMBDA ต้องมี parameter ครบ 2 ตัวเสมอ แม้จะไม่ได้ใช้ในการคำนวณก็ตาม |

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

### สร้างตารางสูตรคูณสำหรับการสอน

ใช้ MAKEARRAY สร้างตารางสูตรคูณขนาดใดก็ได้ทันที เช่น 12×12 หรือ 20×20 สำหรับใช้ในการเรียนการสอนคณิตศาสตร์ ครูสามารถปรับขนาดตารางตามความต้องการได้อย่างรวดเร็ว

_เหมาะกับ:_ education

### สร้าง Dataset ทดสอบขนาดใหญ่

สร้างข้อมูลสุ่มหลักพัน-หลักหมื่นเซลล์เพื่อทดสอบสูตร performance หรือ model โดยไม่ต้องพิมพ์ข้อมูลเอง ประหยัดเวลาและสร้างข้อมูลที่มีความหลากหลายสูง

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

### สร้าง Matrix สำหรับคำนวณทางคณิตศาสตร์

สร้าง Identity Matrix, Distance Matrix, Correlation Matrix หรือ Matrix รูปแบบอื่นๆ สำหรับการคำนวณทาง Linear Algebra สถิติ และวิทยาศาสตร์ข้อมูล

_เหมาะกับ:_ mathematical-function

### สร้าง Lookup Table แบบ Calculated

สร้างตารางอ้างอิงที่มีการคำนวณซับซ้อน เช่น tax bracket table, discount tier table หรือ pricing matrix ที่ค่าในแต่ละเซลล์คำนวณจากตำแหน่งและเงื่อนไขต่างๆ

_เหมาะกับ:_ business-function

### สร้าง Pattern และ Grid ที่ซับซ้อน

สร้าง visual pattern เช่น checkerboard, gradient, spiral หรือ fractal pattern สำหรับใช้ใน data visualization หรือการออกแบบ dashboard ที่ต้องการ pattern พิเศษ

_เหมาะกับ:_ visualization

## ตัวอย่าง

### 1. ตัวอย่างที่ 1: Foundation - Array ค่าคงที่

```excel
=MAKEARRAY(2, 3, LAMBDA(r, c, "X"))
```

**ผลลัพธ์:** `{"X","X","X";"X","X","X"}`

สร้าง Array ขนาด 2 แถว × 3 คอลัมน์ เติมค่า "X" ทุกเซลล์ แม้ LAMBDA ไม่ได้ใช้ parameter r และ c ในการคำนวณ แต่ต้องประกาศไว้ครบ 2 ตัวเสมอ
.
ตัวอย่างนี้แสดงให้เห็นว่า MAKEARRAY สามารถสร้าง Array ที่เติมค่าคงที่เหมือนกันทุกเซลล์ได้ครับ

### 2. ตัวอย่างที่ 2: Foundation - ใช้ row index

```excel
=MAKEARRAY(5, 1, LAMBDA(r, c, r))
```

**ผลลัพธ์:** `{1;2;3;4;5}`

สร้าง Array แนวตั้ง (5 แถว × 1 คอลัมน์) โดยใช้ row index (r) เป็นค่าโดยตรง
.
เนื่องจาก r เริ่มที่ 1 จึงได้ลำดับเลข 1, 2, 3, 4, 5 แนวตั้ง ตัวอย่างนี้แสดงว่า row index เริ่มนับจาก 1 ไม่ใช่ 0 (1-based indexing) ต้องระวังถ้าเคยใช้ภาษา programming ที่เริ่มนับจาก 0 อยู่นะครับ 😅

### 3. ตัวอย่างที่ 3: Foundation - ใช้ทั้ง row และ column index

```excel
=MAKEARRAY(3, 3, LAMBDA(r, c, r*c))
```

**ผลลัพธ์:** `{1,2,3;2,4,6;3,6,9}`

สร้างตารางสูตรคูณ 3×3 โดยคูณ row index (r) กับ column index (c)
.
แถวที่ 1: 1×1=1, 1×2=2, 1×3=3
แถวที่ 2: 2×1=2, 2×2=4, 2×3=6
แถวที่ 3: 3×1=3, 3×2=6, 3×3=9
.
นี่คือตัวอย่างง่ายๆ ที่แสดงให้เห็นว่า MAKEARRAY สามารถใช้ทั้ง r และ c ในการคำนวณค่าแต่ละเซลล์ได้ครับ เหมาะสำหรับสร้างตารางสูตรคูณเพื่อใช้สอนเด็กๆ 😎

### 4. ตัวอย่างที่ 4: Practical - สร้าง Identity Matrix

```excel
=MAKEARRAY(4, 4, LAMBDA(r, c, IF(r=c, 1, 0)))
```

**ผลลัพธ์:** `{1,0,0,0;0,1,0,0;0,0,1,0;0,0,0,1}`

สร้าง Identity Matrix 4×4 (matrix ที่เส้นทแยงมุมเป็น 1 ที่เหลือเป็น 0) โดยใช้ IF ตรวจสอบว่า row index เท่ากับ column index หรือไม่
.
ถ้าเท่ากัน (อยู่บนเส้นทแยงมุม) ให้ค่า 1 ถ้าไม่เท่าให้ค่า 0
.
Identity Matrix นี้ใช้ในการคำนวณทางคณิตศาสตร์และ Linear Algebra ครับ เคยเรียน Matrix ในมหา'ลัยแล้วต้องคำนวณด้วยมือ... ตอนนี้ใช้ Excel สร้างได้ทันทีเลย 😎

### 5. ตัวอย่างที่ 5: Practical - สร้างข้อความพิกัด

```excel
=MAKEARRAY(3, 4, LAMBDA(r, c, "R"&r&"C"&c))
```

**ผลลัพธ์:** `{"R1C1","R1C2","R1C3","R1C4";"R2C1","R2C2","R2C3","R2C4";"R3C1","R3C2","R3C3","R3C4"}`

สร้าง Array 3×4 ที่แสดงพิกัดตำแหน่งของแต่ละเซลล์ในรูปแบบ "R{row}C{col}" โดยใช้ & ต่อข้อความ "R" กับ row index และ "C" กับ column index
.
เหมาะสำหรับการทำ reference grid หรือ debug ตำแหน่งข้อมูล ส่วนตัวผมใช้วิธีนี้บ่อยมากเวลาต้อง debug ว่า Array ของเราโครงสร้างเป็นยังไง 💡

### 6. ตัวอย่างที่ 6: Practical - สร้างลาย Checkerboard

```excel
=MAKEARRAY(6, 6, LAMBDA(r, c, IF(MOD(r+c, 2)=0, "■", "□")))
```

**ผลลัพธ์:** `{"□","■","□","■","□","■";"■","□","■","□","■","□";...}`

สร้างลาย Checkerboard (กระดานหมากรุก) 6×6 โดยใช้ MOD ตรวจสอบว่า (row+col) หารด้วย 2 ลงตัวหรือไม่
.
ถ้าลงตัว (เศษ 0) แสดงสี่เหลี่ยมเติม (■) ถ้าไม่ลงตัว (เศษ 1) แสดงสี่เหลี่ยมว่าง (□)
.
ตัวอย่างนี้เจ๋งตรงที่ pattern สลับสีได้จากสูตรง่ายๆ แค่ MOD เลยครับ ไม่ต้องใส่เงื่อนไขซับซ้อน 😎

### 7. ตัวอย่างที่ 7: Advanced - สุ่มตัวเลข 1-100

```excel
=MAKEARRAY(10, 5, LAMBDA(r, c, RANDBETWEEN(1, 100)))
```

**ผลลัพธ์:** `{43,87,12,65,29;91,33,58,76,14;...}`

สร้าง Array 10×5 (50 เซลล์) เติมตัวเลขสุ่มระหว่าง 1-100 ในทุกเซลล์ โดยใช้ RANDBETWEEN ในทุกตำแหน่ง
.
ค่าจะเปลี่ยนทุกครั้งที่ recalculate (กด F9 หรือมีการเปลี่ยนแปลงใน workbook)
.
ส่วนตัวผมใช้วิธีนี้สร้าง dataset ทดสอบบ่อยมากครับ แทนที่จะนั่งพิมพ์ข้อมูลเองหลักร้อยหลักพัน ให้ MAKEARRAY สร้างให้ทันที 😎

### 8. ตัวอย่างที่ 8: Advanced - Distance Matrix

```excel
=MAKEARRAY(5, 5, LAMBDA(r, c, ABS(r-c)))
```

**ผลลัพธ์:** `{0,1,2,3,4;1,0,1,2,3;2,1,0,1,2;3,2,1,0,1;4,3,2,1,0}`

สร้าง Distance Matrix 5×5 ที่แสดงระยะห่างระหว่างตำแหน่ง โดยคำนวณจาก ABS(r-c)
.
เส้นทแยงมุมเป็น 0 (ระยะห่างจากตัวเองเป็น 0) ยิ่งห่างจากเส้นทแยงค่ายิ่งมาก
.
matrix แบบนี้ใช้ในการคำนวณ graph theory และ data analysis ครับ ถ้าเคยทำงานเกี่ยวกับ network หรือ logistics น่าจะเจอบ่อย 💡

### 9. ตัวอย่างที่ 9: Advanced - สุ่มตัวอักษร A-Z

```excel
=MAKEARRAY(4, 8, LAMBDA(r, c, CHAR(RANDBETWEEN(65, 90))))
```

**ผลลัพธ์:** `{"K","M","A","X","B","F","T","L";"P","Z","D","Q","H","N","V","G";...}`

สร้าง Array 4×8 เติมตัวอักษรพิมพ์ใหญ่สุ่ม A-Z โดยใช้ RANDBETWEEN(65, 90) สุ่มเลข ASCII code (A=65, Z=90) แล้วแปลงเป็นตัวอักษรด้วย CHAR
.
ค่าจะเปลี่ยนทุกครั้งที่ recalculate
.
เหมาะสำหรับสร้างรหัสสุ่มหรือข้อมูลทดสอบแบบตัวอักษร ผมเคยใช้วิธีนี้สร้าง random password ทดสอบครับ 😅

### 10. ตัวอย่างที่ 10: Advanced - Pascal's Triangle Row

```excel
=MAKEARRAY(1, 7, LAMBDA(r, c, COMBIN(6, c-1)))
```

**ผลลัพธ์:** `{1,6,15,20,15,6,1}`

สร้างแถวที่ 7 ของ Pascal's Triangle โดยใช้ COMBIN(n, k) ที่ n=6 และ k=c-1
.
(เนื่องจาก column index เริ่มที่ 1 ต้องลบ 1 เพื่อให้ k เริ่มที่ 0)
.
Pascal's Triangle แต่ละแถวคือ binomial coefficient ของ (x+y)^n ใช้ในการคำนวณความน่าจะเป็นและ combinatorics ครับ ถ้าเคยเรียนสถิติหรือ probability น่าจะคุ้นเคยกับ pattern นี้ 💡

### 11. ตัวอย่างที่ 11: Complex - Fibonacci Sequence แนวตั้ง

```excel
=LET(
  n, 10,
  init, {0;1},
  fib, REDUCE(init, SEQUENCE(n-2), LAMBDA(acc, i, VSTACK(acc, INDEX(acc,-1) + INDEX(acc,-2)))),
  MAKEARRAY(n, 1, LAMBDA(r, c, INDEX(fib, r)))
)
```

**ผลลัพธ์:** `{0;1;1;2;3;5;8;13;21;34}`

สร้าง Fibonacci Sequence 10 ตัวแรกในรูปแบบ Array แนวตั้ง โดยใช้ LET และ REDUCE สร้าง sequence ก่อน แล้วใช้ MAKEARRAY ดึงค่าแต่ละตัวมาเรียงเป็น Array
.
ตัวอย่างนี้แสดงการผสม MAKEARRAY กับ advanced functions อื่นๆ เพื่อสร้างข้อมูลที่ซับซ้อน
.
ถ้าสูตรนี้ดูซับซ้อนไป... ไม่ต้องตกใจครับ 😅 แค่ต้องการแสดงให้เห็นว่า MAKEARRAY ทำงานร่วมกับ LAMBDA functions อื่นๆ ได้ดีมาก

### 12. ตัวอย่างที่ 12: Complex - สร้าง Lookup Table แบบ Dynamic

```excel
=LET(
  categories, {"Bronze","Silver","Gold","Platinum"},
  thresholds, {0,100,500,1000},
  MAKEARRAY(ROWS(categories), 2, LAMBDA(r, c, IF(c=1, INDEX(categories,r), INDEX(thresholds,r))))
)
```

**ผลลัพธ์:** `{"Bronze",0;"Silver",100;"Gold",500;"Platinum",1000}`

สร้าง Lookup Table 2 คอลัมน์ (Category และ Threshold) โดยใช้ LET เก็บข้อมูล categories และ thresholds ใน array แล้วใช้ MAKEARRAY ดึงค่ามาเรียงเป็นตาราง
.
คอลัมน์ 1 ดึงจาก categories และคอลัมน์ 2 ดึงจาก thresholds
.
ตัวอย่างนี้เจ๋งตรงที่สร้าง lookup table แบบ dynamic ได้ เวลาต้องการเพิ่ม tier ใหม่ แค่เพิ่มใน array categories และ thresholds ตารางก็จะอัพเดตเองทันที 😎

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

💡 **Tip จากประสบการณ์จริง:**

ส่วนตัวผมใช้ MAKEARRAY บ่อยมากเวลาต้องสร้าง test data หรือ mock dataset ครับ เพราะมันสร้างข้อมูลหลักพันแถวได้ภายในไม่กี่วินาที ไม่ต้องนั่งพิมพ์เอง หรือ import จากที่อื่น
.
แต่ต้องระวังเรื่อง performance นะครับ ถ้า Array ใหญ่มากหรือ LAMBDA ซับซ้อน Excel อาจช้าลงได้ แนะนำให้ทดสอบด้วยขนาดเล็กก่อน (เช่น 10×10) แล้วค่อยขยายขนาดทีละน้อย 😎

---

**พฤติกรรมสำคัญของ MAKEARRAY:**

| พฤติกรรม | รายละเอียด |
|----------|------------|
| **Index เริ่มที่ 1** | r=1, c=1 คือมุมซ้ายบน (ไม่ใช่ 0) ต่างจากภาษา programming ส่วนใหญ่ |
| **LAMBDA ต้องมี 2 params** | แม้ไม่ใช้ r หรือ c ก็ต้องประกาศครบทั้งคู่ มิเช่นนั้นจะได้ #VALUE! |
| **Recalculate behavior** | ถ้าใช้ RAND/RANDBETWEEN ค่าจะเปลี่ยนทุกครั้งที่ recalc (กด F9 หรือแก้ไขเซลล์ใดๆ) |
| **Dynamic Array Spill** | ผลลัพธ์จะ spill ลง sheet อัตโนมัติ ต้องมีพื้นที่ว่างเพียงพอ ถ้าพื้นที่ไม่พอจะได้ #SPILL! error |
| **Performance** | Array ใหญ่หรือ LAMBDA ซับซ้อนจะช้า ทดสอบด้วยขนาดเล็กก่อนขยายใหญ่ |
| **Error Propagation** | ถ้า LAMBDA เกิด error ใน 1 เซลล์ จะทำให้ทั้ง array เป็น error ใช้ IFERROR ใน LAMBDA ป้องกัน |

**เปรียบเทียบกับ Functions อื่น:**

| Function | จุดประสงค์ | ตัวอย่าง |
|----------|----------|----------|
| **SEQUENCE** | สร้างตัวเลขเรียงลำดับ (ง่าย, เร็ว) | `=SEQUENCE(5)` → {1;2;3;4;5} |
| **MAKEARRAY** | สร้างข้อมูลโดย LAMBDA (ยืดหยุ่น, ซับซ้อน) | `=MAKEARRAY(5,1,LAMBDA(r,c,r^2))` → {1;4;9;16;25} |
| **MAP** | แปลงค่า array ที่มีอยู่ | `=MAP({1,2,3}, LAMBDA(x, x*2))` → {2,4,6} |
| **REDUCE** | ประมวลผล array เป็นค่าเดียว | `=REDUCE(0,{1,2,3},LAMBDA(a,x,a+x))` → 6 |

**เคล็ดลับการใช้งาน:**

1. **Debug ด้วย F9:** Select บางส่วนของสูตร (เช่น `r*c`) แล้วกด F9 เพื่อดูผลลัพธ์
2. **ใช้ LET ลด complexity:** เก็บค่า intermediate ไว้ใน LET แทนที่จะซับซ้อนใน LAMBDA
3. **ป้องกัน Error:** ใช้ IFERROR ห่อการคำนวณใน LAMBDA เพื่อป้องกัน error ทำให้ทั้ง array พัง
4. **Test ขนาดเล็กก่อน:** สร้าง 3×3 ทดสอบก่อน แล้วค่อยขยายเป็น 100×100
5. **Paste Values ถ้าใช้ RAND:** ถ้าไม่ต้องการให้ค่าเปลี่ยน copy → paste values หลังสร้างเสร็จ

**ข้อจำกัดและข้อควรระวัง:**

- **Excel 365/2024 เท่านั้น:** เวอร์ชันเก่าจะได้ #NAME? error
- **Spill Range ต้องว่าง:** ถ้าพื้นที่ที่จะ spill มีข้อมูลอยู่จะได้ #SPILL! error
- **Maximum Size:** rows × cols ≤ 1,048,576 (limit ของ Excel worksheet)
- **Performance:** Array ขนาด 1000×1000 กับ LAMBDA ซับซ้อนอาจช้ามาก
- **Circular Reference:** ห้าม LAMBDA อ้างอิงตัวมันเองหรือเซลล์ที่กำลังคำนวณ

**ตัวอย่าง Pattern ที่เป็นประโยชน์:**

```excel
// Identity Matrix
=MAKEARRAY(n, n, LAMBDA(r, c, IF(r=c, 1, 0)))

// Upper Triangular Matrix (0 ด้านล่างเส้นทแยง)
=MAKEARRAY(n, n, LAMBDA(r, c, IF(r=c, value, 0)))

// Multiplication Table
=MAKEARRAY(n, n, LAMBDA(r, c, r*c))

// Checkerboard Pattern
=MAKEARRAY(n, n, LAMBDA(r, c, MOD(r+c, 2)))

// Random Integers
=MAKEARRAY(rows, cols, LAMBDA(r, c, RANDBETWEEN(min, max)))

// Coordinate Grid
=MAKEARRAY(rows, cols, LAMBDA(r, c, "("&r&","&c&")"))

// Lookup from Existing Data
=MAKEARRAY(rows, cols, LAMBDA(r, c, INDEX(SourceData, r, c)))
```

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

**Q: MAKEARRAY ต่างจาก SEQUENCE อย่างไร?**

SEQUENCE สร้างเฉพาะตัวเลขเรียงลำดับ (1, 2, 3, ...) โดยกำหนด start value และ step ได้
.
ส่วน MAKEARRAY ใช้ LAMBDA function คำนวณค่าแต่ละเซลล์ได้อิสระตาม row/column index ทำให้สร้างข้อมูลได้หลากหลายกว่ามาก เช่น ข้อความ สูตรคูณ ค่าสุ่ม หรือการคำนวณที่ซับซ้อน
.
ส่วนตัวผมคิดว่า... ถ้าต้องการแค่ตัวเลขเรียงลำดับธรรมดา ใช้ SEQUENCE จะง่ายและเร็วกว่า แต่ถ้าต้องการ logic พิเศษหรือข้อมูลที่ไม่ใช่ตัวเลขเรียง MAKEARRAY คือตัวเลือกที่ดีกว่าครับ 😎

**Q: Row และ Column index ใน LAMBDA เริ่มที่ 0 หรือ 1?**

เริ่มที่ 1 (1-based indexing) ครับ เช่น เซลล์มุมซ้ายบนสุดจะได้ r=1, c=1 ไม่ใช่ r=0, c=0
.
ดังนั้น =MAKEARRAY(2, 3, LAMBDA(r, c, r*c)) จะได้ {1,2,3;2,4,6} ไม่ใช่ {0,0,0;0,0,0}
.
ต้องระวังเรื่องนี้ถ้าคุณเคยใช้ภาษา programming ที่เริ่มนับจาก 0 (เช่น Python, JavaScript) เพราะ Excel ใช้ 1-based indexing ในทุก function อ่ะนะ ผมเองก็เคยงงตอนแรกๆ เหมือนกัน 555

**Q: ทำไมได้ #VALUE! error?**

สาเหตุหลัก 3 ข้อครับ:
.
**(1) rows หรือ cols น้อยกว่า 1 หรือไม่ใช่ตัวเลข** → ตรวจสอบว่าใส่ค่าเป็นจำนวนเต็มบวกหรือไม่
.
**(2) LAMBDA ไม่ได้รับ parameter ครบ 2 ตัว** → ต้องประกาศ (r, c) ครบเสมอ แม้ไม่ได้ใช้ในการคำนวณ เช่น ใช้ LAMBDA(r, c, "X") ไม่ใช่ LAMBDA("X")
.
**(3) การคำนวณภายใน LAMBDA เกิด error** → เช่น หารด้วยศูนย์ หรือ INDEX เกินขอบเขต
.
💡 **Tip:** ใช้ Evaluate Formula (Alt+M+V) เพื่อดูว่า error เกิดที่ไหน ผมใช้วิธีนี้ debug บ่อยมากครับ

**Q: ใช้ MAKEARRAY โดยไม่ใช้ r หรือ c ได้ไหม?**

ใช้ได้ครับ แต่ต้องประกาศ parameter ครบ 2 ตัวเสมอ
.
เช่น =MAKEARRAY(3, 3, LAMBDA(r, c, "X")) จะเติม "X" ทุกเซลล์ แม้ไม่ได้ใช้ r และ c ในการคำนวณ
.
หรือ =MAKEARRAY(5, 5, LAMBDA(r, c, RANDBETWEEN(1,100))) ก็ไม่ได้ใช้ r, c แต่ต้องประกาศไว้
.
ถ้าไม่ประกาศ parameter ครบจะได้ #VALUE! error ทันที นี่คือข้อกำหนดของ MAKEARRAY ที่ LAMBDA ต้องรับ parameter 2 ตัวเสมอครับ แม้จะไม่ได้ใช้ก็ตาม 😅

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

MAKEARRAY เป็น LAMBDA Helper Function ที่มีใน Excel for Microsoft 365, Excel 2024 และ Excel for the web เท่านั้นครับ
.
ไม่มีใน Excel 2021, 2019, 2016 หรือเวอร์ชันเก่ากว่า
.
ถ้าคุณใช้ Excel เวอร์ชันเก่า จะเห็น #NAME? error เมื่อใช้ MAKEARRAY เพราะ Excel ไม่รู้จัก function นี้
.
ต้อง upgrade เป็น Microsoft 365 subscription หรือ Excel 2024 ถึงจะใช้ได้ (ต้องยอมรับว่า LAMBDA functions เหล่านี้เจ๋งจริงๆ คุ้มค่า upgrade ครับ 😎)

**Q: จะสร้าง Array ขนาดใหญ่มากได้ไหม?**

ได้ครับ แต่มีข้อจำกัดและข้อควรระวัง:
.
**(1) Limit ของ Excel Worksheet** → Dynamic Array รองรับสูงสุดประมาณ 1 ล้านเซลล์ (rows × cols ≤ 1,048,576)
.
**(2) Performance อาจช้า** → ถ้า Array ใหญ่มาก (เช่น 1000×1000) จะทำให้ไฟล์ช้าลงเพราะทุกเซลล์ต้องคำนวณผ่าน LAMBDA
.
**(3) Function ซับซ้อนยิ่งช้า** → ถ้าใช้ function ที่หนักใน LAMBDA (เช่น VLOOKUP, XLOOKUP) จะยิ่งช้า
.
💡 **แนะนำ:** ทดสอบด้วยขนาดเล็กก่อน (เช่น 10×10) แล้วค่อยขยายขนาดทีละน้อย ผมเคยสร้าง 5000×5000 แล้ว Excel แทบค้างเลยครับ 😭

**Q: ค่าที่ได้จาก MAKEARRAY จะเปลี่ยนทุกครั้งที่ recalculate หรือไม่?**

ขึ้นอยู่กับว่าใช้ function อะไรใน LAMBDA ครับ
.
**ถ้าใช้ volatile function** (เช่น RANDBETWEEN, RAND, NOW, TODAY) → ค่าจะเปลี่ยนทุกครั้งที่ workbook recalculate (กด F9 หรือมีการแก้ไขเซลล์ใดๆ)
.
**ถ้าใช้ function ธรรมดา** (เช่น r*c หรือ IF(r=c,1,0)) → ค่าจะคงที่ไม่เปลี่ยนแปลง
.
💡 **Tip:** ถ้าต้องการให้ค่าสุ่มคงที่ หลังจากสร้างด้วย RANDBETWEEN แล้ว ให้ Copy ผลลัพธ์ → Paste Values เพื่อแปลงเป็นค่าแบบคงที่ (ผมใช้วิธีนี้บ่อยมากเวลาสร้าง test data ครับ)

**Q: สามารถใช้ MAKEARRAY กับ Named Range หรือ Table ได้ไหม?**

ได้ครับ คุณสามารถอ้างอิง Named Range หรือ Table ภายใน LAMBDA ได้ตามปกติ
.
**ตัวอย่างที่ 1:** =MAKEARRAY(Rows, Cols, LAMBDA(r, c, INDEX(DataTable, r, c))) → สร้าง Array โดยดึงค่าจาก Table
.
**ตัวอย่างที่ 2:** =MAKEARRAY(5, 3, LAMBDA(r, c, VLOOKUP(INDEX(IDList, r), ProductTable, c+1, FALSE))) → ดึงข้อมูลจากหลาย column ตาม ID list
.
วิธีนี้เจ๋งมากเวลาต้องการทำ dynamic report หรือ dashboard ครับ ผมใช้บ่อยมากตอนทำงานกับ Table ใน Excel 😎

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

**MAP** → ใช้กับ array ที่มีอยู่แล้ว และประมวลผลแต่ละค่าใน array นั้น
.
**MAKEARRAY** → สร้าง array ใหม่จากศูนย์โดยใช้ row/column index คำนวณค่า
.
**ตัวอย่างเปรียบเทียบ:**
- =MAP({1,2,3}, LAMBDA(x, x*2)) → ใช้ MAP เพราะมี array {1,2,3} อยู่แล้ว
- =MAKEARRAY(3,1,LAMBDA(r,c,r*2)) → ใช้ MAKEARRAY เพราะสร้าง array ใหม่จากตำแหน่ง
.
สรุปง่ายๆ คือ... ใช้ MAP เมื่อต้องการ**แปลงข้อมูลเดิม** ใช้ MAKEARRAY เมื่อต้องการ**สร้างข้อมูลใหม่** ครับ 😎

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

- [LAMBDA – สร้างฟังก์ชันที่กำหนดเอง](https://www.thepexcel.com/functions/excel/logical/lambda/)
- [MAP – ประมวลผลทุก Element ใน Array ด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/map/)
- [REDUCE – รวมผลลัพธ์จาก Array เป็นค่าเดียว](https://www.thepexcel.com/functions/excel/logical/reduce/)
- [SCAN – คำนวณและแสดงผลลัพธ์สะสมทุกขั้นตอน](https://www.thepexcel.com/functions/excel/logical/scan/)
- [BYCOL – ประมวลผลทีละคอลัมน์ด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/bycol/)
- [BYROW – ประมวลผลทีละแถวด้วย LAMBDA](https://www.thepexcel.com/functions/excel/logical/byrow/)
- [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/)
- [FILTER – ฟังก์ชันกรองข้อมูลแบบไดนามิก](https://www.thepexcel.com/functions/excel/lookup-and-reference/filter/)
- [LET – กำหนดตัวแปรในสูตรเพื่อเพิ่มความเร็วและความชัดเจน](https://www.thepexcel.com/functions/excel/logical/let/)
- [VSTACK – ฟังก์ชันรวมข้อมูลแนวตั้ง](https://www.thepexcel.com/functions/excel/lookup-and-reference/vstack/)
- [HSTACK – ฟังก์ชันรวมข้อมูลแนวนอน](https://www.thepexcel.com/functions/excel/lookup-and-reference/hstack/)
- [ABS – หาค่าสัมบูรณ์ (Absolute Value)](https://www.thepexcel.com/functions/excel/math-and-trigonometry/abs/)
- [COMBIN – หาจำนวนวิธีเลือก (C n,r)](https://www.thepexcel.com/functions/excel/math-and-trigonometry/combin/)
- [RANDBETWEEN – สุ่มตัวเลขจำนวนเต็ม](https://www.thepexcel.com/functions/excel/math-and-trigonometry/randbetween/)
- [VLOOKUP – ฟังก์ชันค้นหาค่าแนวตั้งจากตาราง](https://www.thepexcel.com/functions/excel/lookup-and-reference/vlookup/)
- [XLOOKUP – ฟังก์ชันค้นหาข้อมูลแนวตั้งและแนวนอน](https://www.thepexcel.com/functions/excel/lookup-and-reference/xlookup/)
- [TODAY – แสดงวันที่ปัจจุบัน (อัปเดตอัตโนมัติ)](https://www.thepexcel.com/functions/excel/date-and-time/today/)
- [CHAR – แปลงรหัสเป็นตัวอักษร](https://www.thepexcel.com/functions/excel/text/char/)
- [MOD – หาเศษเหลือจากการหาร](https://www.thepexcel.com/functions/excel/math-and-trigonometry/mod/)
- [IF – ฟังก์ชันตรรกะพื้นฐาน](https://www.thepexcel.com/functions/excel/logical/if/)
- [IFERROR – ดักจับ Error และเปลี่ยนเป็นค่าอื่น](https://www.thepexcel.com/functions/excel/logical/iferror/)
- [ROWS – นับจำนวนแถวทั้งหมด](https://www.thepexcel.com/functions/excel/lookup-and-reference/rows/)

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

- [Microsoft Support: MAKEARRAY function](https://support.microsoft.com/en-us/office/makearray-function-b80da5ad-b338-4149-a523-5b221da09097) _(official)_
- [ExcelJet: Excel MAKEARRAY function](https://exceljet.net/functions/makearray-function) _(guide)_
- [Microsoft Tech Community: Advanced Array Functions](https://techcommunity.microsoft.com/t5/excel-blog/announcing-lambda-turn-excel-formulas-into-custom-functions/ba-p/1925546) _(tutorial)_

---

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