---
source_url: https://docs.dolphindb.cn/zh/funcs/s/slice.html
fetched_at: 2026-05-19T09:39:30Z
category: funcs
title: slice
sha1: 1d49f72e9aad56ef3d1af9f8e4515ebaafaaa4cc
---

# slice

## 语法

`slice(obj, index)`

或

`slice(obj, rowIndex, [colIndex])`

相当于`obj[index]`或`obj[rowIndex, colIndex]`

## 详情

对于第一种用法：

- 如果 *obj* 是一个数组向量，

  - *index* 是标量，返回指定的列，用向量表示。
  - *index* 是向量，返回指定行组成的数组向量。
  - *index* 是数据对，返回指定列组成的数组向量。
- 如果 *obj* 是一个矩阵，

  - *index* 是标量，返回指定的列，用向量表示。
  - *index* 是向量或数据对，返回指定列组成的子矩阵。
- 如果 *obj* 是一个表，

  - *index* 是标量，返回指定的行，用字典表示。
  - *index* 是向量或数据对，返回指定行组成的子表。

对于第二种用法：

- 如果 *obj* 是一个数组向量，

  - *rowIndex* 和 *colIndex*
    都是标量，返回指向行列的值，用向量表示。
  - *rowIndex* 是标量，*colIndex*
    是数据对，返回由指定行列组成的数组向量。
  - *rowIndex* 是数据对，*colIndex*
    是标量，返回由指定行列组成的向量。
  - *rowIndex* 和 *colIndex*
    都是数据对，返回由指定行列组成的数组向量。
- 如果 *obj* 是一个矩阵，

  - *rowIndex* 和 *colIndex*
    都是标量，返回指定行列的值，用标量表示。
  - *rowIndex* 和 *colIndex*
    中一个是标量，另一个是数据对，返回由指定行列组成的子矩阵。
  - *rowIndex* 和 *colIndex*
    都是向量或数据对，返回指定行列组成的子矩阵。
- 如果 *obj* 是一个表，

  - *rowIndex* 和 *colIndex*
    都是标量，返回指定行列的值，用标量表示。
  - *rowIndex* 和 *colIndex*
    中一个是标量，另一个是数据对，返回指定行列组成的子表。
  - *rowIndex* 和 *colIndex*
    都是向量或数据对，返回指定行列组成的子表。

注：

*index*, *rowIndex*，*collIndex* 作为数组向量或矩阵的索引值或索引范围时，若其值不在 [0, size(X)-1] 内，则超出 [0, size(X)-1]
的值所对应的位置返回空值。

## 参数

**obj** 可以是数组向量、矩阵或表。

**index**, **rowIndex** 和 **colIndex** 可以是标量、向量或数据对，表示行或列的下标。如果
*index*, *rowIndex* 或 *colIndex* 为数据对，那么它表示下标的范围，上边界不包含在内。

## 返回值

返回向量、数组向量、矩阵或表。

## 例子

例1. 矩阵

```dolphindb
m=1..9$3:3
m.slice(0);
[1,2,3]

m.slice([0]);
```

| #0 |
| --- |
| 1 |
| 2 |
| 3 |

```dolphindb
m.slice(0:2);
```

| #0 | #1 |
| --- | --- |
| 1 | 4 |
| 2 | 5 |
| 3 | 6 |

```dolphindb
m.slice(0 2);
```

| #0 | #1 |
| --- | --- |
| 1 | 7 |
| 2 | 8 |
| 3 | 9 |

```dolphindb
m.slice(0,1);
// output
4

m.slice(0 1,0 1);
```

| #0 | #1 |
| --- | --- |
| 1 | 4 |
| 2 | 5 |

```dolphindb
m.slice(1:2,1:2);
```

| #0 |
| --- |
| 5 |

例2. 表

```dolphindb
t=table(`A`B`C as sym,2018.01.01..2018.01.03 as date,10 48 5 as val)
t.slice(0);

// output
val->10
date->2018.01.01
sym->A
t.slice([0]);
```

| sym | date | val |
| --- | --- | --- |
| A | 2018.01.01 | 10 |

```dolphindb
t.slice(0 1);
```

| sym | date | val |
| --- | --- | --- |
| A | 2018.01.01 | 10 |
| B | 2018.01.02 | 48 |

```dolphindb
t.slice(0:1);
```

| sym | date | val |
| --- | --- | --- |
| A | 2018.01.01 | 10 |

```dolphindb
t.slice(0,1);
// output
2018.01.01

t.slice(0 1,0 1);
```

| sym | date |
| --- | --- |
| A | 2018.01.01 |
| B | 2018.01.02 |

```dolphindb
t.slice(1:2,1:2);
```

| date |
| --- |
| 2018.01.02 |

例3. 数组向量

```dolphindb
av =array(DOUBLE[], 0, 10).append!([1.0, 2.1 4.1 6.8, 0.5 2.2 2]);
av[1]
// output
[,4.1,2.2]
av[1,1]
// output
[4.1]
av[1:3,1:3]
// output
[[4.1,6.8],[2.2,2]]
```
