如何在React组件/视图中同步DOM和数据库

Question

我在React中创建了一个列表组件，但遇到了两个明显的问题。

1. 虽然该项目被删除（从数据库中也一样）它是建立刷新仅仅体现
2. 在将项目从列表中删除您可能已经注意到列表＃或ID列没有减。

我在后端使用PostgreSQL，Sequelize作为我的对象/关系映射器和React作为我的视图/组件。

我提供了一个gif，所以你可以看到我的意思。

在此先感谢！

这是我的代码：

阵营： Student.js

import React, { Component } from "react"; 
import store from "../store"; 
import { deleteStudent } from "../reducers"; 

export default class Students extends Component { 
    constructor(props) { 
    super(props); 
    this.state = store.getState(); 
    this.deleteStudent = this.deleteStudent.bind(this); 
    } 

    componentDidMount() { 
    this.unsubscribe = store.subscribe(() => { 
     this.setState(store.getState()); 
    }); 
    } 

    componentWillUnmount() { 
    this.unsubscribe(); 
    } 

    deleteStudent(index) { 
    store.dispatch(deleteStudent(index)); 
    this.state = store.getState(); 
    } 

    render() { 
    var students = this.props.students; 
    return (
     <div className="container"> 
     <div className="sixteen columns"> 
      <h1 className="remove-bottom">Students</h1> 
      <h5>List of current students and their campus</h5> 
      <hr /> 
     </div> 
     <div className="sixteen columns"> 
      <div className="example"> 
      <div> 
       <table className="u-full-width"> 
       <thead> 
        <tr> 
        <th>#</th> 
        <th>Name</th> 
        <th>Email</th> 
        <th>Campus</th> 
        </tr> 
       </thead> 
       <tbody> 
        {students.map(function(student, index) { 
        return (
         <tr key={index}> 
         <td> 
          {student.id} 
         </td> 
         <td> 
          {student.name} 
         </td> 
         <td> 
          {student.email} 
         </td> 
         <td> 
          {student.campus} 
         </td> 
         <td> 
          <a 
          className="button button-icon" 
          onClick={() => { 
           console.log(student.id); 
           this.deleteStudent(student.id); 
          }} 
          key={index} 
          > 
          <i className="fa fa-remove" /> 
          </a> 
         </td> 
         </tr> 
        ); 
        }, this)} 
       </tbody> 
       </table> 
      </div> 
      </div> 
     </div> 
     </div> 
    ); 
    } 
} 

我减速机：

import { combineReducers } from "redux"; 
import axios from "axios"; 

const logError = console.error.bind(console); 

// INITIAL STATE 

const initialState = { 
    students: [], 
    campuses: [] 
}; 

//ACTION CREATORS 

const UPDATE_NAME = "UPDATE_NAME"; 
const ADD_STUDENT = "ADD_STUDENT"; 
const DELETE_STUDENT = "DELETE_STUDENT"; 
const GET_STUDENTS = "GET_STUDENTS"; 
const UPDATE_CAMPUS = "UPDATE_CAMPUS"; 
const GET_CAMPUS = "GET_CAMPUS"; 
const GET_CAMPUSES = "GET_CAMPUSES"; 

// ACTION CREATORS 

export function updateName(name) { 
    const action = { 
    type: UPDATE_NAME, 
    name 
    }; 
    return action; 
} 

export function addStudent(student) { 
    return { 
    type: ADD_STUDENT, 
    student 
    }; 
} 

export function scrubStudent(student) { 
    return { 
    type: DELETE_STUDENT, 
    student 
    }; 
} 

export function getStudents(students) { 
    const action = { 
    type: GET_STUDENTS, 
    students 
    }; 
    return action; 
} 

export function updateCampus(campus) { 
    const action = { 
    type: UPDATE_CAMPUS, 
    campus 
    }; 
    return action; 
} 

export function getCampus(campus) { 
    const action = { 
    type: GET_CAMPUS, 
    campus 
    }; 
    return action; 
} 

export function getCampuses(campuses) { 
    const action = { 
    type: GET_CAMPUSES, 
    campuses 
    }; 
    return action; 
} 

//THUNK CREATORS 

export function fetchStudents() { 
    return function thunk(dispatch) { 
    return axios 
     .get("/api/students") 
     .then(function(res) { 
     return res.data; 
     }) 
     .then(students => { 
     dispatch(getStudents(students)); 
     }) 
     .catch(logError); 
    }; 
} 

export function postStudent(student) { 
    return function thunk(dispatch) { 
    return axios 
     .post("/api/students", student) 
     .then(function(res) { 
     return res.data; 
     }) 
     .then(function(newStudent) { 
     return dispatch(addStudent(newStudent)); 
     }) 
     .catch(logError); 
    }; 
} 

export function deleteStudent(id) { 
    // console.log("student", student); 
    return function thunk(dispatch) { 
    return axios 
     .delete("/api/students" + "/" + id) 
     .then(function(id) { 
     return dispatch(scrubStudent(id)); 
     }) 
     .catch(function(err) { 
     return console.error("Removing student: " + id + " unsuccessful", err); 
     }); 
    }; 
} 

export function fetchCampuses() { 
    return function thunk(dispatch) { 
    return axios 
     .get("/api/campuses") 
     .then(function(res) { 
     return res.data; 
     }) 
     .then(function(campuses) { 
     return dispatch(getCampuses(campuses)); 
     }) 
     .catch(logError); 
    }; 
} 

export function postCampus(student) { 
    return function thunk(dispatch) { 
    return axios 
     .post("/api/campuses", campus) 
     .then(function(res) { 
     return res.data; 
     }) 
     .then(function(newCampus) { 
     return dispatch(getCampus(newCampus)); 
     }) 
     .catch(logError); 
    }; 
} 

// REDUCER 

const rootReducer = function(state = initialState, action) { 
    var newState = Object.assign({}, state); 

    switch (action.type) { 
    case GET_STUDENTS: 
     newState.students = state.students.concat(action.students); 
     return newState; 

    case ADD_STUDENT: 
     newState.students = state.students.concat([action.student]); 
     return newState; 

    case DELETE_STUDENT: 
     console.log("action.student", action.student); 
     console.log("state", state); 
     state.filter(function(student) { 
     return student.id !== action.id; 
     }); 
     return newState; 

    case GET_CAMPUSES: 
     newState.campuses = state.campuses.concat(action.campuses); 
     return newState; 

    case GET_CAMPUS: 
     newState.campuses = state.campuses.concat([action.campus]); 
     return newState; 

    default: 
     return state; 
    } 
}; 

export default rootReducer; 

这是我的学生模型：

'use strict'; 
var Sequelize = require('sequelize') 
var db = require('../index.js') 

//hasOne, hasMany, belongsTo, belongsToMany Sequelize methods 

module.exports = db.define('student', { 
    name: { 
    type: Sequelize.STRING, 
    allowNull: false, 

    }, 

    email: { 
    type: Sequelize.STRING, 
    allowNull: false, 
    unique: true, 
    validate: { 
     isEmail: true 
    } 
    }, 

    campus: { 
    type: Sequelize.STRING, 
    allowNull: false, 

    } 
}) 

Answer 1

我想回答这个问题，但是这里有一点你想要的。我认为你需要将它放在GIT仓库中，并以这种方式获得更多帮助。

您需要做的第一件事是创建一个适当的商店配置/构建。类似于下面的...

import { createStore, applyMiddleware, compose } from 'redux' 
import thunk from 'redux-thunk' 
import createLogger from 'redux-logger' 
import baseMiddleware from 'redux/middleware/' 
import reducer from 'redux/modules/reducer' 
import { routerMiddleware } from 'react-router-redux' 
import { persistState } from 'redux-devtools'; 

export default function configureStore(initialState, history) { 
    const middleware = baseMiddleware.with(thunk, createLogger(), routerMiddleware(history)) 

    const store = createStore(
     reducer, 
     initialState, 
     compose(
      applyMiddleware(...middleware), 
      window.devToolsExtension ? window.devToolsExtension() : f => f, 
      persistState(window.location.href.match(/[?&]debug_session=([^&]+)\b/)) 
     ) 
    ) 

    if (module.hot) { 
     // Enable Webpack hot module replacement for reducers 
     module.hot.accept('redux/modules/reducer',() => { 
      const nextRootReducer = require('redux/modules/reducer').default 
      store.replaceReducer(nextRootReducer) 
     }) 
    } 

    return store 
} 

这引用了两个主要文件。一个用于我的减速器，另一个用于我的中间件。这很重要，因为它适合的SOLID

在S这是我的中间件...

import api from './api' 
import authenticationMiddleware from './authenticationMiddleware' 
import analyticsMiddleware from './analyticsMiddleware' 

const middleware = [ api, analyticsMiddleware, authenticationMiddleware ] 

export default { 
    with(){ 
     for(let i = 0; i < arguments.length; i++){ 
      middleware[middleware.length] = arguments[i]; 
     } 

     return middleware 
    }, 
    ...middleware 
} 

和减速器

import { combineReducers } from 'redux'; 
import { routerReducer } from 'react-router-redux'; 

import {reducer as form} from 'redux-form'; 

import authentication from './authentication' 

const reducer = combineReducers({ 
    router: routerReducer, 
    authentication 
}) 

export default reducer 

然后，您可以通过在你的商店到您的根组件和使用Provider更高阶的组件然后将Redux上下文添加到对象图

import React, { Component, PropTypes } from 'react' 
import { Provider } from 'react-redux' 
import routes from '../routes' 
import { Router } from 'react-router' 

export default class Root extends Component { 
    render() { 
    const { store, history } = this.props 
    return (
     <Provider store={store}> 
     <div> 
      <Router history={history} routes={routes} /> 
     </div> 
     </Provider> 
    ) 
    } 
} 

Root.propTypes = { 
    store: PropTypes.object.isRequired, 
    history: PropTypes.object.isRequired 
} 

现在，您如何在商店中传递根组件更多的是您和您选择的历史记录，我将把最后一部分留给您。

你也将需要开始使用你的组件连接功能来创建容器