Javascript 重构过滤和搜索结果

我正在开发一个类似airbnb的应用程序。有两个搜索功能，一个用于搜索公寓，另一个用于搜索租车。搜索公寓时，结果页面显示搜索结果以及一些过滤选项，如从价格范围过滤和从各种选项（如便利设施、服务）过滤。租车结果页面与公寓结果页面相同。我的意思是“汽车结果”显示有关汽车的搜索结果，这些汽车可作为租金和过滤类别使用

下面是我的减速机和这些功能的操作。这是一个工作代码。我正在尽可能地以最好的方式编写代码，以训练我的编码技能。我需要其他专家程序员的帮助，帮助我如何将代码重构得更好

actions.js

export function showResultofCar(cityFrom, cityTo, date, paisFrom, paisTo) {
      return (dispatch) => {
        dispatch({ type: 'CAR_FETCH_START' });
        const token = localStorage.getItem('token');
        return axios.get(`${API_URL}/car/....`)
          .then((response) => {
            setTimeout(() => {
              dispatch({ type: 'CAR_FETCH_SUCCESS', payload: response.data });
            }, 1000);
          })
          .catch((err) => {
            dispatch({ type: 'CAR_FETCH_FAILURE', payload: err });
          });
      };
    }


export function showResultofApartment(people, city, dateFrom, dateTo, pais) {
  console.log('people', people, city, dateFrom, dateTo, pais);
  return (dispatch) => {
    dispatch({ type: 'APARTMENT_FETCH_START' });
    const token = localStorage.getItem('token');
    return axios.get(`${API_URL}/apartment/...`)
    .then((response) => {
      console.log('response apart', response.data);
        dispatch({ type: 'APARTMENT_FETCH_SUCCESS', payload: response.data });
    })
    .catch((err) => {
      dispatch({ type: 'APARTMENT_FETCH_FAILURE', payload: err });
    });
  };
}

export function getFilteredResults(price) {
  console.log('price', price);
  return function (dispatch) {
    dispatch({ type: 'CAR_FETCH_WITH_FILTER', payload: price });
  };
}

export function getTimeFilteredResults(time) {
  console.log('time', time);
  return function (dispatch) {
    dispatch({ type: 'CAR_FETCH_WITH_TIME_FILTER', payload: time });
  };
}

export function sortCarByPrice(price) {
  console.log('price is', price);
  return function (dispatch) {
    dispatch({ type: 'SORT_CAR_BY_PRICE', payload: price });
  };
}

export function getApartmentFromPrice(price) {
  return function (dispatch) {
    dispatch({ type: 'APARTMENT_FILTER_BY_PRICE', payload: price });
  };
}

export function getApartmentFromCategories(filter) {
  return function (dispatch) {
    dispatch({ type: 'APARTMENT_FILTER_BY_CATEGORIES', payload: filter });
  };
}

reducers.js

let cars = [];
const initialState = {
  fetching: false,
  fetched: true,
  cars: [],
  error: null
};

function carFilterFromPrice(price) {
  return cars.filter(car => car.price > price.min && car.price < price.max);
}

function carFilterFromTime(time) {
  return cars.filter(function (car) {
    const departure = car.departure;
    const isValidDate = moment(departure).isValid();
    const departureWithDayandTime = isValidDate ?
      moment(departure).format('hh.mm') : '';
      return departureWithDayandTime > time.min && departureWithDayandTime < time.max;
  });
}

function carSortFromPrice(price) {
  return cars.sort((a, b) => {
    if (price === 'descending') {
      return parseFloat(a.price) - parseFloat(b.price);
    }
      return parseFloat(b.price) - parseFloat(a.price);
  });
}

export function getCarResult(state = initialState, action) {
  switch (action.type) {
    case 'CAR_FETCH_START':
      return { ...state, fetching: true };
    case 'CAR_FETCH_SUCCESS':
      cars = action.payload;
      return {
              ...state,
              fetched: true,
              fetching: false,
              cars: action.payload,
             };
    case 'CAR_FETCH_WITH_FILTER':
      return { ...state, fetched: true, fetching: false, cars: carFilterFromPrice(action.payload) };
    case 'CAR_FETCH_WITH_TIME_FILTER':
      return { ...state, fetched: true, fetching: false, cars: carFilterFromTime(action.payload) };
    case 'SORT_CAR_BY_PRICE':
      return { ...state, fetched: true, fetching: false, cars: carSortFromPrice(action.payload) };
    case 'CAR_FETCH_FAILURE':
      return { ...state, error: action.payload };
    default:
      return state;
  }
}

let apartments = [];
const apartmentInitialState = {
  fetching: false,
  fetched: true,
  apartments: [],
  error: null
};

function apartmentFilterFromPrice(price) {
  return apartments.filter(apartment =>
    apartment.price > price.min && apartment.price < price.max
  );
}

function apartmentFilterFromCategory(filter) {
  console.log('filter', filter);
}

export function getApartmentResult(state = apartmentInitialState, action) {
  switch (action.type) {
    case 'APARTMENT_FETCH_START':
      console.log('action', action);
      return { ...state, fetching: true };
    case 'APARTMENT_FETCH_SUCCESS':
    apartments = action.payload;
    return { ...state, fetched: true, fetching: false, apartments: action.payload };
    case 'APARTMENT_FILTER_BY_PRICE':
      return { ...state,
              fetched: true,
              fetching: false,
              apartments: apartmentFilterFromPrice(action.payload)
            };
    case 'APARTMENT_FILTER_BY_CATEGORIES':
      return { ...state,
              fetched: true,
              fetching: false,
              apartments: apartmentFilterFromCategory(action.payload)
             };
    case 'APARTMENT_FETCH_FAILURE':
      return { ...state, error: action.payload };
    default:
      return state;
  }
}

let cars=[]；
常量初始状态={
取景：假，
真的，
汽车：[]，
错误：null
};
函数carFilterFromPrice（价格）{
返回cars.filter（car=>car.price>price.min&&car.pricetime.min&&departureWithDayandTime{
如果（价格=='下降'）{
返回parseFloat（a.价格）-parseFloat（b.价格）；
}
返回parseFloat（b.价格）-parseFloat（a.价格）；
});
}
导出函数getCarResult（状态=初始状态，操作）{
开关（动作类型）{
案例“汽车取车启动”：
返回{…状态，获取：true}；
“汽车取车成功”案例：
cars=行动。有效载荷；
返回{
……国家，
真的，
取景：假，
汽车：行动，有效载荷，
};
案例“带过滤器的汽车取车”：
返回{…state，fetched:true，fetching:false，cars:carFilterFromPrice（action.payload）}；
案例“带时间过滤器的汽车取车”：
返回{…state，fetched:true，fetching:false，cars:carFilterFromTime（action.payload）}；
案例“按价格分类汽车”：
返回{…state，fetched:true，fetching:false，cars:carSortFromPrice（action.payload）}；
“车辆取车故障”案例：
返回{…状态，错误：action.payload}；
违约：
返回状态；
}
}
出租公寓=[]；
const apartmentInitialState={
取景：假，
真的，
公寓：[]，
错误：null
};
function apartmentFilterFromPrice（价格）{
返回公寓。过滤器（公寓=>
plant.price>price.min&&plant.price