typescript web服务器后台无法存储数据

您好，我在编写一个typescript web服务器时当需要导出原先存储在dataStore.ts文件中的数据时报错,后来经过检查发现数据根本没有保存进dataStore。
这是我的服务器存根的代码：

import express, { json, Request, Response } from 'express';
import morgan from 'morgan';
import config from './config.json';
import cors from 'cors';
import errorHandler from 'middleware-http-errors';
import { tagCreate } from './tagCreate';
import { tagName } from './tagName';
import { tagsList } from './tagsList';
import { itemCreate } from './itemCreate';
import { itemInfo } from './itemInfo';
import { Clear, tagDelete, itemDelete} from './clear';

// Set up web app
const app = express();
// Use middleware that allows us to access the JSON body of requests
app.use(json());
// Use middleware that allows for access from other domains
app.use(cors());

const PORT: number = parseInt(process.env.PORT || config.port);
const HOST: string = process.env.IP || 'localhost';

// for logging errors (print to terminal)
app.use(morgan('dev'));

// ====================================================================
//  ================= WORK IS DONE BELOW THIS LINE ===================
// ====================================================================

// POST for /tag:
app.post('/tag', (req: Request, res: Response) => {
  const { name } = req.body;
  const response = tagCreate(name);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// GET for /tag:
app.get('/tag', (req: Request, res: Response) => {
  const { tagId } = req.body;
  const response = tagName(tagId);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// GET for /tag/list:
app.get('/tag/list', (req: Request, res: Response) => {
  const response = tagsList();

  res.json(response);
});

// POST for /todo/item
app.post('/todo/item', (req: Request, res: Response) => {
  const { description, parentId } = req.body;
  const response = itemCreate(description, parentId);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// GET for /todo/item
app.get('/todo/item', (req: Request, res: Response) => {
  const { todoItemId } = req.body;
  const response = itemInfo(todoItemId);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// DELETE for /tag
app.delete('/tag', (req: Request, res: Response) => {
  const { tagId } = req.body;
  const response = tagDelete(tagId);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// DELETE for /todo/item
app.delete('/todo/item', (req: Request, res: Response) => {
  const { todoItemId } = req.body;
  const response = itemDelete(todoItemId);

// if there is an error, return the 400 status code:
  if ('error' in response) {
    return res.status(400).json(response);
  }

  res.json(response);
});

// DELETE for /clear
app.delete('/clear', (req: Request, res: Response) => {
  res.json(Clear());
});

// ====================================================================
//  ================= WORK IS DONE ABOVE THIS LINE ===================
// ====================================================================

// For handling errors
app.use(errorHandler());

// start server
const server = app.listen(PORT, HOST, () => {
  // DO NOT CHANGE THIS LINE
  console.log(`⚡️ Server started on port ${PORT} at ${HOST}`);
});

// For coverage, handle Ctrl+C gracefully
process.on('SIGINT', () => {
  server.close(() => console.log('Shutting down server gracefully.'));
});

这是我dataStore.ts的代码：

// 1.Create a tag list
export interface Tags {
  tagId: number;
  name: string;
}

// 2. Create a item list
export interface Items {
  todoItemId: number;
  description: string;
  tagIds: number[];
  status: string;
  parentId: number | null;
  score: string | null;
}

// Create a dataStore
export interface DataStore {
  tags: Tags[];
  items: Items[];
}

let dataStore: DataStore = {
  tags: [],
  items: [],
};

// Use get() to access the data
function getData() {
  return dataStore;
}

// Use set(newData) to pass in the entire data object, with modifications made
function setData(newData: DataStore) {
  dataStore = newData;
}

export { getData, setData };

这是我为服务器编写的测试：

import request from 'sync-request';
import { getData } from './dataStore';

import { port, url } from './config.json';
const SERVER_URL = `${url}:${port}`;

beforeEach(() => {
  request(
    'DELETE',
    SERVER_URL + '/clear',
  );
});

function CreateTagHelper(name: string) {
  const res = request(
    'POST',
    SERVER_URL + '/tag',
    {
      json: {
        name: name,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function CreateItemHelper(description: string, parentId: number | null) {
  const res = request(
    'POST',
    SERVER_URL + '/todo/item',
    {
      json: {
        description: description,
        parentId: parentId,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function TagNameHelper(tagId: number) {
  const res = request(
    'GET',
    SERVER_URL + '/tag',
    {
      qs: {
        tagId: tagId,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function TagListHelper() {
  const res = request(
    'GET',
    SERVER_URL + '/tag/list',
  );
  return JSON.parse(res.body.toString());
}

function ItemInfoHelper(todoItemId: number) {
  const res = request(
    'GET',
    SERVER_URL + '/todo/item',
    {
      qs: {
        todoItemId: todoItemId,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function TagDeleteHelper(tagId: number) {
  const res = request(
    'DELETE',
    SERVER_URL + '/tag',
    {
      qs: {
        tagId: tagId,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function ItemDeleteHelper(todoItemId: number) {
  const res = request(
    'DELETE',
    SERVER_URL + '/todo/item',
    {
      qs: {
        todoItemId: todoItemId,
      }
    }
  );
  return JSON.parse(res.body.toString());
}

function ClearHelper() {
  const res = request(
    'DELETE',
    SERVER_URL + '/clear',
  );
  return JSON.parse(res.body.toString());
}

// Tag create function test
// Test - 1 successful tag create:
describe('Successful output', () => {
  test('Successful tag create', () => {
    const tag = CreateTagHelper('AAA');
    expect(tag).toStrictEqual({
      tagId: tag.tagId
    });
    let data = getData();
    console.log(data);
  });
});

// Test - 2 error tag create output:
describe('Error output', () => {
  test('Name is shorter than 1 character', () => {
    const tag = CreateTagHelper('');
    expect(tag).toStrictEqual({
      error: expect.any(String)
    });
  });
  test('Name is longer than 10 characters', () => {
    const tag = CreateTagHelper('AAAAAAAAAAAAAA');
    expect(tag).toStrictEqual({
      error: expect.any(String)
    });
  });
  test('a tag with this name already exists', () => {
    CreateTagHelper('AAA');
    const tag = CreateTagHelper('aaa');
    expect(tag).toStrictEqual({
      error: expect.any(String)
    });
  });
});

// Item create function test
// Test - 1 successfui item create:
describe('Successful output', () => {
  test('Successful item create', () => {
    const item = CreateItemHelper('AAA', null);
    expect(item).toStrictEqual({
      todoItemId: item.todoItemId
    });
  });
});

// Test - 2 error item create output:
describe('Error output', () => {
  test('There are already 50 todo items generated', () => {
    CreateItemHelper('A1', null);
    CreateItemHelper('A2', null);
    CreateItemHelper('A3', null);
    CreateItemHelper('A4', null);
    CreateItemHelper('A5', null);
    CreateItemHelper('A6', null);
    CreateItemHelper('A7', null);
    CreateItemHelper('A8', null);
    CreateItemHelper('A9', null);
    CreateItemHelper('A10', null);
    CreateItemHelper('A11', null);
    CreateItemHelper('A12', null);
    CreateItemHelper('A13', null);
    CreateItemHelper('A14', null);
    CreateItemHelper('A15', null);
    CreateItemHelper('A16', null);
    CreateItemHelper('A17', null);
    CreateItemHelper('A18', null);
    CreateItemHelper('A19', null);
    CreateItemHelper('A20', null);
    CreateItemHelper('A21', null);
    CreateItemHelper('A22', null);
    CreateItemHelper('A23', null);
    CreateItemHelper('A24', null);
    CreateItemHelper('A25', null);
    CreateItemHelper('A26', null);
    CreateItemHelper('A27', null);
    CreateItemHelper('A28', null);
    CreateItemHelper('A29', null);
    CreateItemHelper('A30', null);
    CreateItemHelper('A31', null);
    CreateItemHelper('A32', null);
    CreateItemHelper('A33', null);
    CreateItemHelper('A34', null);
    CreateItemHelper('A35', null);
    CreateItemHelper('A36', null);
    CreateItemHelper('A37', null);
    CreateItemHelper('A38', null);
    CreateItemHelper('A39', null);
    CreateItemHelper('A40', null);
    CreateItemHelper('A41', null);
    CreateItemHelper('A42', null);
    CreateItemHelper('A43', null);
    CreateItemHelper('A44', null);
    CreateItemHelper('A45', null);
    CreateItemHelper('A46', null);
    CreateItemHelper('A47', null);
    CreateItemHelper('A48', null);
    CreateItemHelper('A49', null);
    CreateItemHelper('A50', null);
    const item = CreateItemHelper('A51', null);
    expect(item).toStrictEqual({
      error: expect.any(String)
    });
  });
  test('parentId is not a valid todoItemId', () => {
    const item = CreateItemHelper('AAA', 10);
    expect(item).toStrictEqual({
      error: expect.any(String)
    });
  });
  test('description is already existed', () => {
    CreateItemHelper('AAA', null);
    const item = CreateItemHelper('aaa', null);
    expect(item).toStrictEqual({
      error: expect.any(String)
    });
  });
  test('Description is less than 1 character', () => {
    const item = CreateItemHelper('', null);
    expect(item).toStrictEqual({
      error: expect.any(String)
    });
  });
});

// Tag name function test
// Test - 1 successful tag name return:
describe('Successful output', () => {
  test('Successful tag name return', () => {
    CreateTagHelper('AAA');
    //console.log(tag);
    let data = getData();
    console.log(data);
    const tagname = TagNameHelper(0);
    expect(tagname).toStrictEqual({
      name: tagname.name
    })
  });
});

// Test - 2 error tag name return:
describe('Error output', () => {
  test('tagId does not exist', () => {
    const tagname = TagNameHelper(10);
    expect(tagname).toStrictEqual({
      error: expect.any(String)
    });
  });
});

// Tag list function test
// Test - 1 successful tag list return:
describe('Successful output', () => {
  test('Successful tag list return', () => {
    CreateTagHelper('AAA');
    CreateTagHelper('BBB');
    CreateTagHelper('CCC');
    let data = getData();
    console.log(data);
    const taglist = TagListHelper();
    console.log(taglist);
    expect(taglist).toStrictEqual({
      tags: taglist.tags
    });
  });
});

// Item information function test
// Test - 1 successful item information return:
describe('Successful output', () => {
  test('Successful item information return', () => {
    const item = CreateItemHelper('AAA', null);
    const itemInfo = ItemInfoHelper(item.todoItemId);
    expect(itemInfo).toStrictEqual({
      description: itemInfo.description,
      tagIds: itemInfo.tagIds,
      status: itemInfo.status,
      parentId: itemInfo.parentId,
      score: itemInfo.score
    });
  });
});

// Test - 2 error item information return:
describe('Error output', () => {
  test('todoItemId is not valid', () => {
    const item = CreateItemHelper('AAA', null);
    const itemInfo = ItemInfoHelper(10);
    expect(itemInfo).toStrictEqual({
      error: expect.any(String)
    });
  });
});

// Delete tag function test
// Test - 1 successful tag delete:
describe('Successful output', () => {
  test('Successful tag delete', () => {
    const tag = CreateTagHelper('AAA');
    const tagDelete = TagDeleteHelper(tag.tagId);
    expect(tagDelete).toStrictEqual({});
  });
});

// Test - 2 error tag delete:
describe('Error output', () => {
  test('tagId does not exist', () => {
    const tag = CreateTagHelper('AAA');
    const tagDelete = TagDeleteHelper(10);
    expect(tagDelete).toStrictEqual({
      error: expect.any(String)
    });
  })
});

// Delete item functiontest
// Test - 1 successful items delete:
describe('Successful output', () => {
  test('Successful items delete', () => {
    const item1 = CreateItemHelper('AAA', null);
    const item2 = CreateItemHelper('BBB', item1.todoItemId);
    const item3 = CreateItemHelper('CCC', item2.todoItemId);
    const itemDelete = ItemDeleteHelper(item1.todoItemId);
    expect(itemDelete).toStrictEqual({});
  });
});

// Test - 2 error item delete:
describe('Error output', () => {
  test('todoItemId is not valid', () => {
    CreateItemHelper('AAA', null);
    const itemDelete = ItemDeleteHelper(10);
    expect(itemDelete).toStrictEqual({
      error: expect.any(String)
    });
  });
});

// Clear function test
// Test - 1 successful datastore clear:
describe('Successful output', () => {
  test('Successful datastore clear', () => {
    CreateTagHelper('AAA');
    CreateItemHelper('BBB', null);
    const clear = ClearHelper();
    expect(clear).toStrictEqual({});
  });
});

这是我其中一个用于创建数据并存入dataStore的一个函数：

```typescript
import { getData, setData } from './dataStore';

// Create a new tag
export function tagCreate(name: string) {
  let data = getData();
  let TrueTagLength1 = 0;
  let TrueTagLength2 = 0;
  let WrongName = 0;

// check whether the tag length is bigger than 1 and less than 10 characters 
  if (name.length >= 1) {
    TrueTagLength1++;
  }
  if (name.length <= 10) {
    TrueTagLength2++;
  }
// check whether the tag name is already existed
  for (let i in data.tags) {
    if(data.tags[i].name.toLowerCase() === name.toLowerCase()) {
      WrongName++;
    }
  }

// Error output
  if (TrueTagLength1 === 0) {
    return {
      error: 'name is shorter than 1 character'
    }
  } else if (TrueTagLength2 === 0) {
    return {
      error: 'name is longer than 10 characters'
    }
  } else if (WrongName > 0) {
    return {
      error: 'a tag with this name already exists'
    }
  }

// store tag in datastore and output tagId
  let index = 0;
  let tag;
  for (let i in data.tags) {
    index++;
  }
  tag = {
    tagId: index,
    name: name
  };
  data.tags.push(tag);

  setData(data);

  return {
    tagId: index
  }
}

我通过在测试文件中编写console.log查出没有任何数据存入dataStore:

```typescript
console.log
    { tags: [], items: [] }

      at Object.<anonymous> (src/server.test.ts:118:13)

  console.log
    { tags: [], items: [] }

      at Object.<anonymous> (src/server.test.ts:242:13)

  console.log
    { tags: [], items: [] }

      at Object.<anonymous> (src/server.test.ts:268:13)

  console.log
    {
      tags: [
        { tagId: 0, name: 'AAA' },
        { tagId: 1, name: 'BBB' },
        { tagId: 2, name: 'CCC' }
      ]
    }

      at Object.<anonymous> (src/server.test.ts:270:13)

我怀疑是我没有安装合适的服务器文件所导致的。存储的代码我之前也在其他项目里用过，都没有问题，但是这次就不知道为什么无法存入数据了。
感谢您为我提供帮助！

【以下回答由 GPT 生成】

问题: 导出数据的具体问题和预期结果。

从代码中所给的信息来看，无法确定在哪个部分出现了问题，因为代码给出的只是服务器的一部分存根。因此，无法具体知道数据存储的问题出在哪里。

如果您能够提供更多的代码信息和报错信息，我将能够更好地帮助您解决问题。

注意：请确保在提供代码时，删除了任何敏感信息，如密码或数据库凭据等。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^