TypeScript CRUD路由

Question

我正在做一个用户的CRUD实现。

我有一个用户类，用户由名字、用户名、姓氏和密码组成。

class User {
    public readonly uName: string;
    public fName: string;
    public lName: string;
    private password: string;

    constructor(fName: string, lName: string, uName: string, password: string) {
        this.fName = fName;
        this.lName = lName;
        this.uName = uName;
        this.password = password;
    }
}

let Users: User[];
Users = [];

我已经有了一个比较输入数据并插入数据的东西。

router.post("/nutzer?", (req: express.Request, res: express.Response)=>{
    const fName: string = req.body.fName;
    const lName: string = req.body.lName;
    const uName: string = req.body.uName;
    const password: string = req.body.password;

    if (fName && lName && uName && password) {
        let neuerUser = new User(fName, lName, uName, password);
        Users.push(neuerUser);
        res.status(201);
        res.send({
            neuerUser,
            message: 'Nutzer erstellt'
        });
    } else {
        res.status(400);
        res.send({
            message: 'alle Felder müssen ausgefüllt sein',
        });
    }
});

但是，我在readupdatedelete的过程中遇到了一个问题。

阅览

路由只从数组中吐出第一条，而不寻找我在url中的当前一条。

router.get('/nutzer/:uName?', (req: express.Request, res: express.Response) => {
    const uName: string = req.params.uName;
    for (let User of Users) {
        if (User.uName === uName) {
           res.status(200);
               res.send({
                User,
                message: 'Nutzer gefunden',
            });
        }else{
            res.status(404);
                res.send({
                message: 'Nutzer nicht gefunden',
            });
        }
    }
});

编辑用户PUT不能从前向后编辑。

router.put('/nutzer/:uName?', (req: express.Request, res: express.Response)=> {
    const uName: string = req.params.userId;
    const fName: string = req.body.firstName;
    const lName: string = req.body.lastName;

    if (fName && lName) {
        for (const user of Users) {
            if (uName === req.params.uName) {
                user.fName = fName;
                user.lName = lName;
                res.status(200);
                res.send({
                    user,
                    message: `Nutzer erfolgreich ugedatet ${user.fName} ${user.lName}`
                });
            }else{
                res.status(400).send({
                message: 'Nutzerupdate nicht gefunden'
            });
            }
        }
    }
});

删除用户DELETE只能删除数组中的第一个用户。

router.delete("/nutzer/:uName?", (req: express.Request, res: express.Response) => {
                    const uName: string = req.params.uName;
                    if (uName === req.params.uName) {
                        //nicht
                        Users.splice(Users.indexOf(uName), 1);
                        res.status(200);
                        res.send({
                            message: 'Benutzer gelöscht'});
                    } else {
                        res.status(404);
                        res.send({
                            message: 'Benutzer nicht gefunden'});
                    }
                });

Answer 1

问题是你在数组上迭代，每次都在响应。相反，你应该在数组上进行readupdatedelete操作。然后 响应一次。这个，或者类似的东西，应该会更好的工作

// READ
router.get('/nutzer/:uName?', (req: express.Request, res: express.Response) => {
    const uName: string = req.params.uName;
    const found = Users.find(user => user.uName === uName);
    if (found) {
        res.status(200);
        res.send({ User: found, message: 'Nutzer gefunden' });
    } else {
        res.status(404);
        res.send({ message: 'Nutzer nicht gefunden' });
    }
});

// UPDATE
router.put('/nutzer/:uName?', (req: express.Request, res: express.Response)=> {
    const uName: string = req.params.userId;
    const fName: string = req.body.firstName;
    const lName: string = req.body.lastName;

    let found = null;
    if (fName && lName) {
        for (const user of Users) {
            if (uName === req.params.uName) {
                found = user;
                user.fName = fName;
                user.lName = lName;
                res.status(200);
            }
        }
    }

    if (found) {
        res.status(200);
        res.send({ user: found, message: `Nutzer erfolgreich ugedatet ${user.fName} ${user.lName}` });
    } else {
        res.status(400).send({ message: 'Nutzerupdate nicht gefunden' });
    }
});

对于你的删除，你搞得不一样，因为你甚至没有找到正确的元素。这应该可以

// DELETE
router.delete("/nutzer/:uName?", (req: express.Request, res: express.Response) => {
    const uName: string = req.params.uName;
    const index = Users.findIndex(user => user.uName === uName);
    if (index == -1) {
        res.status(404);
        res.send({ message: 'Benutzer nicht gefunden' });
    } else {
        Users.splice(index, 1);
        res.status(200);
        res.send({ message: 'Benutzer gelöscht'});
    }
});

Answer 2

你的逻辑被打破了。

for (let User of Users) {
   if (User.uName === uName) {
     res.status(200);
     res.send({
       User,
       message: 'Nutzer gefunden',
     });
   } else {
     res.status(404);
     res.send({
       message: 'Nutzer nicht gefunden',
     });
   }
 }

循环比较数组中的第一个元素，然后将响应发送到客户端： 如果第一个元素匹配，则发送200。uName 否则404。

而不是使用 find 在你的数组中找到某个用户。

const user = users.find(value => value.uName === uName);

if (user) {
  // User found
} else {
  // Not found
}

// Or just
return user
  ? res.json({ user, message: '...' }).status(200)
  : res.json({ message: '...' }).status(404);