百科问答小站 logo   百科问答小站
问题

如何不使用loop循环，创建一个长度为100的数组，并且每个元素的值等于它的下标？

回答
好，不靠谱，我这就来告诉你怎么不用循环创建个长度100，每个元素都是下标的数组。不过这事儿吧，得看你想用啥工具，不同的工具方法会差得挺远。咱们就挑几个常见的，仔细给你掰扯掰扯。

咱们主要讲讲在Python和JavaScript这俩语言里怎么做。你要是想在别的语言里干这事儿，也可以参考一下思路，或者直接跟我说，我再给你整别的。



在Python里，不用循环怎么做？

Python有个挺牛的玩意儿，叫列表推导式（List Comprehension）。听名字好像是跟循环有点关系，但它写出来可比普通for循环简洁多了，而且很多时候性能也更好，尤其是在构建列表的时候。有人说它是“Pythonic”的一种写法，意思就是特别有Python的味道。

那么，怎么用列表推导式来实现咱们的需求呢？

基本思路：

列表推导式的格式大概是这样： `[expression for item in iterable if condition]`

`expression`：你想要放在新列表里的元素是什么。
`for item in iterable`：这是循环的部分，从一个可迭代的对象（比如一个范围、一个列表）里一个一个地取值。
`if condition`（可选）：这是筛选条件，只有满足条件的才会被加进去。

咱们的需求是：创建一个长度为100的数组，每个元素的值等于它的下标。

这就意味着，我们需要一个从0到99的数字序列，然后把每个数字都变成新列表里的一个元素。

具体实现：

```python
使用列表推导式
my_array = [i for i in range(100)]

打印看看效果
print(my_array)
预期输出: [0, 1, 2, ..., 98, 99]

验证一下长度
print(len(my_array))
预期输出: 100

验证一下某个元素的值
print(my_array[50])
预期输出: 50
```

解释一下：

1. `range(100)`：这是Python一个很方便的函数，它会生成一个从0开始，到99结束（不包含100）的数字序列。你可以理解成一个“0, 1, 2, ..., 98, 99”的集合。
2. `for i in range(100)`：这句话的意思就是“对于`range(100)`生成的每一个数字，我们都把它叫做 `i`”。
3. `[i ... ]`：最外面的方括号表示我们要创建一个列表。而方括号里面的 `i`，就是我们要在新列表里放的元素。

所以，整个列表推导式 `[i for i in range(100)]` 就等于说：“给我创建一个列表，这个列表里的每一个元素，都是从0到99这个范围里取出来的一个数字 `i`。”

还有一种更简洁的方法（同样不用显式循环）：

Python还有一个函数叫做 `list()`。它可以把一个可迭代对象转换成列表。而 `range(100)` 本身就是一个可迭代对象。

```python
使用 list() 和 range()
my_array_2 = list(range(100))

打印看看效果
print(my_array_2)
预期输出: [0, 1, 2, ..., 98, 99]

验证一下长度
print(len(my_array_2))
预期输出: 100
```

解释：

这里的 `list(range(100))` 直接就把 `range(100)` 生成的那个序列“翻译”成了一个列表。这个过程虽然内部可能也有迭代，但从我们写的代码来看，没有任何显式的 `for` 或 `while` 循环。这同样是“不用循环”的非常地道的Python做法。

为啥说这比普通循环好？

想象一下你用传统方法写：

```python
my_array_traditional = []
for i in range(100):
my_array_traditional.append(i)
```

跟列表推导式 `[i for i in range(100)]` 比起来，列表推导式更紧凑，可读性也更强（习惯了之后）。而且在很多情况下，Python解释器可以对列表推导式做更深度的优化，执行效率会比显式循环更高一些。



在JavaScript里，不用循环怎么做？

JavaScript里也有类似Python列表推导式的思路，但写法更灵活一些。主要有几种方式：

方法一：使用 `Array.from()` 和映射函数

`Array.from()` 是一个非常强大的方法，它可以从一个类数组对象或可迭代对象创建一个新的、浅拷贝的数组实例。关键是，它还可以接受一个可选的 `mapFn` 参数，用来对新数组的每个元素进行转换。

基本思路：

`Array.from(arrayLike[, mapFn[, thisArg]])`

`arrayLike`：一个类数组对象（比如带 `length` 属性的对象）或一个可迭代对象。
`mapFn` (可选)：一个函数，用来处理 `arrayLike` 中的每个元素，并生成新数组的元素。这个函数会接收两个参数：`element`（当前处理的元素）和 `index`（当前元素的索引）。
`thisArg` (可选)：执行 `mapFn` 时用作 `this` 的值。

咱们的需求是：长度为100，每个元素等于下标。

那么，我们可以创建一个长度为100的类数组对象，然后用 `Array.from()` 的 `mapFn` 来生成元素。

具体实现：

```javascript
// 方法一：使用 Array.from()
const len = 100;
const my_array = Array.from({ length: len }, (_, index) => index);

// 打印看看效果
console.log(my_array);
// 预期输出: [0, 1, 2, ..., 98, 99]

// 验证一下长度
console.log(my_array.length);
// 预期输出: 100

// 验证一下某个元素的值
console.log(my_array[50]);
// 预期输出: 50
```

解释一下：

1. `{ length: len }`：我们创建一个简单的对象，它只有一个 `length` 属性，值为100。`Array.from()` 可以识别这种“类数组”对象。
2. `(_, index) => index`：这是一个箭头函数，作为 `Array.from()` 的第二个参数（`mapFn`）。
`_`：第一个参数是元素本身。因为我们给的类数组对象 `{ length: 100 }` 里并没有实际的元素值，只有长度信息，所以这里我们用一个下划线 `_` 来表示我们不关心第一个参数的值，只是为了占位。
`index`：第二个参数是元素的索引。`Array.from()` 在处理类数组对象时，会按照 `length` 的值从0开始生成索引。
`=> index`：这个箭头函数返回 `index` 的值。所以，对于每个索引（0, 1, 2, ... 99），函数都会返回它本身。

这样一来，`Array.from()` 就根据 `{ length: 100 }` 提供了100个索引（0到99），并用映射函数 `(_, index) => index` 将每个索引转换成了新数组的元素。

方法二：使用 `Array(size).fill().map()` （或者 `Array.from()` 别的方式）

在ES6之前，创建一个固定长度的数组然后填充值，通常需要先创建一个“稀疏”数组，然后通过 `fill()` 或者其他方式来激活它，再用 `map()`。虽然这看起来像是有两步，但 `map()` 的回调函数本身就是用来处理每个元素的。

具体实现：

```javascript
// 方法二：使用 Array(size).fill().map()
const len = 100;
const my_array_2 = Array(len).fill(0).map((_, index) => index);

// 打印看看效果
console.log(my_array_2);
// 预期输出: [0, 1, 2, ..., 98, 99]

// 验证一下长度
console.log(my_array_2.length);
// 预期输出: 100
```

解释一下：

1. `Array(len)`：创建一个长度为 `len`（100）的空数组。但这个数组是“稀疏”的，里面没有实际的元素。
2. `.fill(0)`：`fill()` 方法用来填充数组的空位。我们用一个任意值（比如 `0`）来填充所有位置。这一步很重要，因为没有填充的稀疏数组的 `map()` 是不会执行回调函数的。
3. `.map((_, index) => index)`：现在数组里有了100个 `0`，`map()` 函数就可以正常工作了。和前面一样，我们用 `(_, index) => index` 这个映射函数，把每个位置的 `0` 替换成它的索引值。

还有一种更简洁的 `Array.from()` 写法：

```javascript
// 方法三：使用 Array.from(range)
const len = 100;
const my_array_3 = Array.from(Array(len).keys()); // 这个方法更直接地生成了索引

// 打印看看效果
console.log(my_array_3);
// 预期输出: [0, 1, 2, ..., 98, 99]
```

解释：

1. `Array(len)`：还是创建一个长度为100的稀疏数组。
2. `.keys()`：这是一个数组迭代器方法，它会返回一个生成器，该生成器依次产生数组中每个元素的索引。对于一个长度为100的数组，它会生成0, 1, 2, ..., 99。
3. `Array.from(...)`：我们将这个生成器（可迭代对象）传给 `Array.from()`，它就会把生成器产生的所有值收集起来，创建一个新的数组。

这种方法是直接利用了 `keys()` 生成索引的特性，非常简洁地完成了任务。



总结一下“不用循环”的感觉

你可能听我说“列表推导式”或者“映射函数”，觉得这跟循环还是有关系的。没错，从计算机执行的底层逻辑来看，无论你怎么写，要创建100个元素，总得经历100次操作。

但是，咱们这里说的“不用循环”，更多是指不用你自己手写显式的 `for` 或 `while` 循环结构。我们利用的是语言提供的更高级的抽象工具，比如：

Python的列表推导式：它是一种声明式的方式，告诉Python“我想要什么样的列表”，而不是一步一步地告诉它“先创建个空列表，然后循环，然后添加”。
JavaScript的`Array.from()`或`.map()`：这些方法本身就封装了迭代的过程。你只需要定义“如何处理每一个元素”，而不需要管理循环的起始、结束、递增等细节。

这种写法的好处是：

1. 更简洁：代码量少，读起来更清晰。
2. 更具可读性：意图更明显，不像一长串的循环代码那么容易让人眼花缭乱。
3. 更不容易出错：比如忘记递增、越界等等低级错误，在这些高级抽象工具里不容易发生。
4. 性能可能更好：解释器或引擎可能会对这些内置函数和语法糖进行高度优化。

所以，下次你要是遇到这种“创建一系列有规律的数组”的任务，可以想想这些不用显式循环的方法，它们会让你的代码更漂亮，也更高效。希望我这番絮叨，能让你对这个小问题有了更深的理解！

网友意见

user avatar

这么多人赞的吗~其实巧妙的方法不是没有。

class array {

public:

int operator[](size_t index) {

return index;

}

};

还可以做得更骚，但手机码字就懒得撸了（并不是因为买不起电脑啊！是因为睡前才刷的知乎）

//////以下是原答案//////

告诉你标准答案。手机码字…将就着看吧…

int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99};

如果打表的成本低，那就打表。

类似的话题

本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等

© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有

服务条款
联系我们
关于我们
隐私政策
友情链接
知乎
百度问答
搜狐
新浪