Javascript React-Redux:尝试调度一个操作时，钩子调用无效，该操作将嵌套数组分配给另一个数组

这是我第一个使用React-Redux的项目。我正在尝试将从MoveDown（）函数返回的数组分配给处于分派MoveDown（）操作状态的数组

行动：

export const moveDown = () => {
    return {
    type: MOVE_DOWN,
    };
};

以下是每次按下特定按钮时调用的函数：

  const Press = () => {
       dispatch(moveDown());
  };

初始状态：

 export const initialState = {
     board: {
        gridSize: 4,
        arr: [
               [0, 0, 0, 0],
               [0, 2, 4, 0],
               [0, 0, 16, 2],
               [0, 2, 32, 0],
               ],
    },
};

以及我调用的reducer和函数，以更改返回另一个数组的数组：

export const board = (state = initialState.board, action) => {
       if (action.type == MOVE_DOWN) {
              return {
                     ...state,
                     arr: MoveDown(),
              };
       }
       return state;
};
const MoveDown = () => {
        const mat = useSelector((state) => state.board.arr);
        const size = useSelector((state) => state.board.gridSize);
        var ok = 1;
        for (var j = 0; j < size; j++) {
             while (ok) {
                    ok = 0;
                    for (var i = size - 2; i < 0; i--) {
                            if (mat[i][j] != 0) {
                                 if (mat[i + 1][j] == mat[i][j]) {
                                      mat[i][j] = 0;
                                      mat[i + 1][j] = 2 * mat[i + 1][j];
                                      ok = 1;
                                 } else {
                                        if (mat[i + 1][j] == 0) {
                                                 mat[i + 1][j] = mat[i][j];
                                                 ok = 1;
                                        }
                                   }
                           }
                    }
           }
       }
    return mat;
 };

export const board=（state=initialState.board，action）=>{
if（action.type==下移）{
返回{
……国家，
arr:MoveDown（），
};
}
返回状态；
};
常量下移=（）=>{
const mat=useSelector（（state）=>state.board.arr）；
const size=useSelector（（state）=>state.board.gridSize）；
var-ok=1；
对于（var j=0；j

代码看起来毫无意义，因为您正在使用

useSelector

hook-in-reducer

useSelector

是一个钩子，在组件内部使用它可以更快地访问状态值，作为

MapStateTrops

的替代方案。在您的情况下，将状态值作为参数传递给

MoveDown

函数并直接读取就足够了

export const board = (state = initialState.board, action) => {
       if (action.type == MOVE_DOWN) {
              return {
                     ...state,
                     arr: MoveDown(state),
              };
       }
       return state;
};
const MoveDown = state => {
        const mat = state.arr;
        const size = state.gridSize;
        // ...etc

但是您的函数还有另一个您将遇到的问题，例如，此循环将不起作用

for (var i = size - 2; i < 0; i--) 

for（变量i=size-2；i<0；i--）

因为第二个参数是循环工作的条件，所以它很可能是

i>=0

，否则，如果size-2是正数，它将永远不会开始，如果size-2是负数，它将永远不会结束

PS还规定js代码样式对函数名使用驼峰大小写，所以它不应该以大写字母M开头

React挂钩应仅用于React功能部件内部或内部 另一个钩子

useSelector

是一个react钩子。但是您是从一个普通的JavaScript函数调用它的

我已经修改了你的代码，请随意尝试一下

export const board = (state = initialState.board, action) => {
       if (action.type == MOVE_DOWN) {
              return {
                     ...state,
                     arr: MoveDown(state),
              };
       }
       return state;
};
const MoveDown = (boardState) => {
        const mat = boardState.arr;
        const size = boardState.gridSize;
        var ok = 1;
        for (var j = 0; j < size; j++) {
             while (ok) {
                    ok = 0;
                    for (var i = size - 2; i < 0; i--) {
                            if (mat[i][j] != 0) {
                                 if (mat[i + 1][j] == mat[i][j]) {
                                      mat[i][j] = 0;
                                      mat[i + 1][j] = 2 * mat[i + 1][j];
                                      ok = 1;
                                 } else {
                                        if (mat[i + 1][j] == 0) {
                                                 mat[i + 1][j] = mat[i][j];
                                                 ok = 1;
                                        }
                                   }
                           }
                    }
           }
       }
    return mat;
 };

export const board=（state=initialState.board，action）=>{
if（action.type==下移）{
返回{
……国家，
arr：向下移动（状态），
};
}
返回状态；
};
常量下移=（boardState）=>{
const mat=boardState.arr；
const size=boardState.gridSize；
var-ok=1；
对于（var j=0；j

给出与现有答案完全相同的答案有什么意义？我没有看到你的答案。我只看到问题并回答了它。