当使用ReactJS和JSX时，我们可以编写简单的JS代码，以某种方式返回一些元素吗？

当我们在JSX中返回一些东西时，我们可以写：

  <ul>
    {Array.from({ length: 9 }).map((e, i) => (
      <li>{i}</li>
    ))}
  </ul>

{Array.from（{length:9}）.map（（e，i）=>(
{i}
))}

或者使用一种生活方式：

  <ul>
    {(function () {
      const result = [];
      for (let i = 0; i < 9; i++) {
        result.push(<li>{i}</li>);
      }
      return result;
    })()}
  </ul>

{（函数（）{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；
})()}

例如：

但是有没有可能写出这样的东西：

  <ul>
    {
      const result = [];
      for (let i = 0; i < 9; i++) {
        result.push(<li>{i}</li>);
      }
      return result;  // somehow "return" the array
    }
  </ul>

{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；//以某种方式“返回”数组
}

---

也就是说，只需编写没有IIFE的普通代码，就能以某种方式返回我们创建的数组？

您可以将for循环拉到JSX上方，如下所示：

const result = [];
for (let i = 0; i < 9; i++) {
  result.push(<li>{i}</li>);
}

return (
  <ul>
    {result}
  </ul>
)

查看该函数版本，很明显以下代码不是合法语法：

React.createElement(
  "ul",
  null,
  const result = [];
  for (let i = 0; i < 9; i++) {
    result.push(<li>{i}</li>);
  }
  return result;
)

React.createElement(
“ul”，
无效的
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；
)

---

这就是为什么JSX也不允许您这样做。

您可以将for循环拉到JSX上方，如下所示：

const result = [];
for (let i = 0; i < 9; i++) {
  result.push(<li>{i}</li>);
}

return (
  <ul>
    {result}
  </ul>
)

查看该函数版本，很明显以下代码不是合法语法：

React.createElement(
  "ul",
  null,
  const result = [];
  for (let i = 0; i < 9; i++) {
    result.push(<li>{i}</li>);
  }
  return result;
)

React.createElement(
“ul”，
无效的
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；
)

---

这就是为什么JSX也不允许您这么做。

正如您所指出的，JSX支持任意操作。强调词语的表达。IIFE之所以有效，是因为它是一个函数定义表达式和一个调用表达式。不支持后面的示例，因为JSX没有支持块而不是表达式的机制，JavaScript也没有将块视为表达式的机制，而不是通过IIFE

但是，有一个第1阶段的提案，如果我理解正确的话，可以让您：

<ul>
  {
    do {
      const result = [];
      for (let i = 0; i < 9; i++) {
        result.push(<li>{i}</li>);
      }
      result;
    }
  }
</ul>

{
做{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
结果；
}
}

---

它是一个标准，所以它还不在标准中，可能会也可能不会成为标准。幸运的是，它有一个Babel插件，您可能有兴趣尝试一下：

正如您所注意到的，JSX支持任意操作。强调词语的表达。IIFE之所以有效，是因为它是一个函数定义表达式和一个调用表达式。不支持后面的示例，因为JSX没有支持块而不是表达式的机制，JavaScript也没有将块视为表达式的机制，而不是通过IIFE

但是，有一个第1阶段的提案，如果我理解正确的话，可以让您：

<ul>
  {
    do {
      const result = [];
      for (let i = 0; i < 9; i++) {
        result.push(<li>{i}</li>);
      }
      result;
    }
  }
</ul>

{
做{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
结果；
}
}

它是一个标准，所以它还不在标准中，可能会也可能不会成为标准。幸运的是，它有一个巴别塔插件，您可能有兴趣尝试一下：

没有写出来，i、 e.返回值的代码。您可以在返回其他代码的代码中编写“不返回”代码；例如，您可以在

映射

中指定

常量

s。因此，如果您真的想写上述内容，可以将其包装在

映射中

：

{
[0]。映射（（）=>{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；
});
}

对我来说，这就像是一个思想实验，可能不是对最佳实践的要求。在我看来，这将是在JSX外部构建值数组，并在内部映射

constyourcomponent=（）=>{
...
const numbers=Array.from（{length:9}）；
返回(

{numbers.map（（{，i）=>
{i}
）}

);

不作为书面形式，即返回值的代码。您可以在返回其他代码的代码中写入“不返回”代码；例如，您可以在

映射

中分配

常量

{
[0]。映射（（）=>{
常量结果=[]；
for（设i=0；i<9；i++）{
结果：推挤（
{i}
）；
}
返回结果；
});
}

对我来说，这就像是一个思想实验，可能不是对最佳实践的要求。在我看来，这将是在JSX外部构建值数组，并在内部映射

constyourcomponent=（）=>{
...
const numbers=Array.from（{length:9}）；
返回(

{numbers.map（（{，i）=>
{i}
）}

);

解释JSX变成

React.createElement（“ul”，null，something）；

然后变成最终形式使事情变得非常清楚。现在我明白了为什么我们可以在那里放一个元素或数组，JSX可以处理它解释JSX变成

React.createElement（“ul”，null，something）

然后成为最终形式，这让事情变得非常清楚。现在我明白了为什么我们可以在那里放一个元素，或者放一个数组，JSX可以处理它。这回答了你的问题吗？这回答了你的问题吗？