react中redux怎么使用-6ren

react中redux怎么使用

转载作者：我是一只小鸟更新时间：2023-02-20 22:31:56

1、redux是什么？

redux 就是react 全局状态管理，作用是存放全局数据。

。

2、核心

state：存放数据。
reducer：修改仓库数据。

是一个函数，参数一：仓库中的数据，参数2：行为 actions 。
返回值就是最新的仓库数据。
就是在reduce中定义的方法，修改数据，相当于mutations 。
只能是同步方法。

actions：派发行为触发reducer; 语法：sotre.dispatch({type:'add'}) 。
语法:

                    
                      function
                    
                      reducer( state={age:10,name:'lisa'
                    
                       },actions){
        
                    
                    
                      switch
                    
                    
                      (action.type){
            
                    
                    
                      case
                    
                     "add"
                    
                      :
                
                    
                    
                      return
                    
                     {...state,  age:state.age+1
                    
                       };
            
                    
                    
                      case
                    
                     "reduce"
                    
                      :
                
                    
                    
                      return
                    
                     { age:state.age-1
                    
                       }
            
                    
                    
                      default
                    
                    
                      :
                
                    
                    
                      return
                    
                    
                       state
        }
    }

。

3、使用redux

1、安装React-redux

                    
                      # NPM
npm install redux

# Yarn
yarn add redux

2、在src目录下创建store文件夹，index.js文件

在项目中使用到哪些api 。

createStore 。
- 作用：创建仓库。
- 语法：let store=createStore(reducer,中间件),
- 输出store:
  - @@observable: ƒ observable() 观察仓库中的数据、。
  - dispatch: ƒ dispatch(action) 触发reducer、。
  - getState: ƒ getState()获取到仓库中的数据、。
  - replaceReducer: ƒ replaceReducer(nextReducer) 替换reducer、。
  - subscribe: ƒ subscribe(listener) 订阅。

                    
                      //
                    
                    
                      创建仓库
                    
                    
                      
import {createStore} from 
                    
                    'redux'



                    
                      //
                    
                    
                       createStore=>创建仓库
                    
                    
                      
//
                    
                    
                      语法
                    
                    
                      //
                    
                    
                      let store = createStore(reducer,中间件)
                    
                    
                      //
                    
                    
                       reducer =>  自己定义
                    
                    
                      //
                    
                    
                       1他是一个函数
                    
                    
                      //
                    
                    
                       2参数1 仓库中的数据   参数2 行为 actions
                    
                    
                      //
                    
                    
                       3这个reduer 返回值 就是最新的仓库中的数据 
                    
                    
                      //
                    
                    
                       4redcuer =》就是在reducer中定义方法修改数据 =》vuex mutations
                    
                    
                      function
                    
                     reducer(state={age:10
                    
                      },actions){
      
                    
                    
                      switch
                    
                    
                      (actions.type){
        
                    
                    
                      case
                    
                     "add"
                    
                      :
            console.log(
                    
                    'add'
                    
                      ,state);
            
                    
                    
                      return
                    
                     {age:state.age+1
                    
                      };
         
                    
                    
                      default
                    
                    
                       :
         
                    
                    
                      return
                    
                    
                       state
      }
 }

 let store 
                    
                    =
                    
                       createStore(reducer)



                    
                    
                      /*
                    
                    
                      *
 * 
 * @@observable: ƒ observable()  观察仓库中的数据
dispatch: ƒ dispatch(action)  =》触发reducer
getState: ƒ getState()  =>获取到仓库中的数据
replaceReducer: ƒ replaceReducer(nextReducer)  替换reducer
subscribe: ƒ subscribe(listener)  订阅
 * 
 * 
 * 
 * *
                    
                    
                      */
                    
                    
                      

   export 
                    
                    
                      default
                    
                     store

3、在App.js根组件中使用仓库

在组件中使用仓库。
1. 引入仓库 import store from './store/index' 。
获取仓库中的数据：store.getState().meReducer.age; (meReducer.age指的是meReducer中的age属性) 。
触发reducer：store.dispatch({type:"add"}) 。

                    import logo from './logo.svg'
                    
                      ;
import 
                    
                    './App.css'
                    
                      ;

                    
                    
                      //
                    
                    
                       在组件中引入仓库
                    
                    
import store from './store/index'
                    
                      
import {useState} from 
                    
                    'react'


                    
                      function
                    
                    
                       App() {
 
                    
                    
                      //
                    
                    
                       1获取到仓库中的数据
                    
                    
                      //
                    
                    
                       console.log(store.getState());
                    
                    
                      //
                    
                    
                       let age = store.getState().age
                    
                    
  let [age,setAge] =
                    
                       useState(store.getState().age)

  const changeAge 
                    
                    = ()=>
                    
                      {
     
                    
                    
                      //
                    
                    
                      触发 reducer
                    
                    
     store.dispatch({type:'add'
                    
                      })
    
                    
                    
                      //
                    
                    
                        问题=》仓库中的数据更新了=》但是视图没有更新 =》组件没有更新
                    
                    
                      //
                    
                    
                       1 讲这个数据=》动态数据
                    
                    
                      //
                    
                    
                       setAge(仓库中的最新数据) =>和仓库进行关联
                    
                    
                          setAge(store.getState().age)
  }
  
                    
                    
                      return
                    
                    
                       (
    
                    
                    <div className="App">
       <h2>我的年龄{age}</h2>
       <button onClick={()=>changeAge()}>修改仓库选中数据</button>
    </div>

                    
                        );
}

export 
                    
                    
                      default
                    
                     App;

4、combineReducers 合并reducer

combineReducers:

作用：合并reducer 。
语法：let reducers = combineReducers({属性:各自的reducer, 属性:各自的reducer}) 。

使用webpack中的api： require.context 自动获取到文件中的暴露的内容。

作用：通过该函数可以获取一个上下文，从而实现工程自动化（遍历文件夹的文件，从中获取指定文件，自动导入模块）。在前端工程中，如果一个文件夹中的模块需要频繁引用时可以使用该中方式一次性引入。
语法：let webf = require.context('文件路径'，布尔值，正则) 。

返回值： 1 webf.keys() 返回一个数组，由匹配成功的文件所组成的数组 2 webf(路径).default 获取到路径中导出的模块。

手动合并reducer 。

                    
                      //
                    
                    
                        合拼reducer
                    
                    
                      
import {combineReducers} from 
                    
                    'redux'


                    
                      //
                    
                    
                       combineReducers
                    
                    
import CartReducer from './CartReducer'
                    
                      
import meReducer from 
                    
                    './meReducer'

                    
                      //
                    
                    
                      作用：合拼reducer
                    
                    
                      
//
                    
                    
                      语法： let reducers = combineReducers({属性：各自的reducer,属性：各自的reducer})
                    
                    
                      

let reducers 
                    
                    =
                    
                       combineReducers({
    CartReducer,
    meReducer
})

export 
                    
                    
                      default
                    
                     reducers

工程化处理reducer 合拼。

                    
                      /*
                    
                    
                       
    combineReducer
        作用： 合并 reducer 数据实现模块化
        语法：let reducers=combineReducers({属性:各自的reducer, 属性:各自的reducer})

                    
                    
                      */
                    
                    
                      //
                    
                    
                       工程化处理Reducer 合拼
                    
                    
                      
import { combineReducers } from 
                    
                    "redux"
                    
                      ;


                    
                    
                      //
                    
                    
                       combineReducers
                    
                    
import CartReducer from "./CartReducer"
                    
                      ;
import MeReducer from 
                    
                    "./MeReducer"
                    
                      ;

                    
                    
                      //
                    
                    
                       在这里引入各自的reducer
                    
                    
                      
//
                    
                    
                       处理方法 =》 自动引入reducer 自动合拼reducer
                    
                    
                      //
                    
                    
                       1 在reducers文件夹下创建一个 reducer 文件 =》 再给我 合拼成reducer
                    
                    
                      //
                    
                    
                       1 webpack =》 require.context =》自动获取到文件中的暴露内容
                    
                    
                      //
                    
                    
                       语法：require.context('文件路径'，布尔值，正则)
                    
                    
                      
//
                    
                    
                       requeire.context('文件路径'，布尔值，正则)  => 返回值  （是webpack）实例方式
                    
                    
                      //
                    
                    
                       两个方法 1. webf.keys()=>['文件路径'，布尔值，正则]
                    
                    
                      
//
                    
                    
                       2.获取到它的内容 webf(路径).default
                    
                    
                      
let webf 
                    
                    = require.context("./", 
                    
                      true
                    
                    , /\.js/
                    
                      );
let webfList 
                    
                    =
                    
                       webf.keys();

                    
                    
                      //
                    
                    
                       console.log(webfList);
                    
                    
                      
//
                    
                    
                       删除自身 index.js
                    
                    
let index=webfList.findIndex((item,index)=>
                    
                      {
    
                    
                    
                      return
                    
                     item=='./index.js'
                    
                      
})
webfList.splice(index,
                    
                    1
                    
                      )

                    
                    
                      //
                    
                    
                       console.log(webfList);
                    
                    
                      //
                    
                    
                       将webfList合并成一个对象
                    
                    
let objs=
                    
                      {};
webfList.forEach((item,index)
                    
                    =>{
                    
                      //
                    
                    
                       文件路径     ./ CartReducer .js
                    
                    
                      //
                    
                    
                       console.log(webf(item).default);
                    
                    
                      //
                    
                    
                       处理属性 = item
                    
                    
        let items=item.replace('./','').replace('.js',''
                    
                      )
        
                    
                    
                      //
                    
                    
                       console.log(items)
                    
                    
        objs[items]=webf(item).
                    
                      default
                    
                    
                      
})

                    
                    
                      //
                    
                    
                       console.log(objs)
                    
                    
                      //
                    
                    
                       作用：合并reducer
                    
                    
                      
//
                    
                    
                       语法：let reducers=combineReducers({属性：各自的reducer,属性：各自的reducer})
                    
                    
                      
let reducers 
                    
                    =
                    
                       combineReducers(objs);

export 
                    
                    
                      default
                    
                     reducers;

5、bindActionCreators 自动触发reducer

作用：实现自动派发，实现行为 reducer 处理方法一一对应。
语法：let 对象 = bindActionCreators({属性：属性值是一个方法}，store.dispatch)，属性值是一个方法 => 就是你的reducer中的方法。
实现步骤:

                    
                      /*
                    
                    
                       
    五：bindActionCreators

    bindActionCreators => 自动触发reducer => 你想要触发

    语法：let 对象 =bindActionCreators({属性：属性值是一个方法},dispatch)  属性值是一个方法=》 就是你的reducers中的方法


    使用： 
        1 实现reducer 和他的行为一一对应
        2 使用 bindActionCreators 来实现
            2.1 语法 bindActionsCreators({就是你的reducer 和 使用的行为对应},dispatch)

         全部触发我的模板中的reducer 行为
             1 我的模块reducer 有多少个行为
             2 我的模块中add
        
    
                    
                    
                      */
                    
                    
                      

import { bindActionCreators } from 
                    
                    "redux"
                    
                      ;
import store from 
                    
                    "../index"
                    
                      ;


                    
                    
                      //
                    
                    
                       bindActionCreators => 自动触发reducer => 你想要触发
                    
                    
                      
//
                    
                    
                       语法 let对象 =bindActionCreators({属性：属性值是一个方法}，dispatch)，属性值是一个方法 =》就是你的reducer中的方法
                    
                    
                      //
                    
                    
                       创建方法
                    
                    
let meAdd = () =>
                    
                       {
  
                    
                    
                      return
                    
                    
                       {
    
                    
                    
                      //
                    
                    
                       行为 =》 actions
                    
                    
    type: "add"
                    
                      ,
  };
};

let meSub 
                    
                    = () =>
                    
                       {
  
                    
                    
                      return
                    
                    
                       {
    type: 
                    
                    "sub"
                    
                      ,
  };
};

let meActions 
                    
                    =
                    
                       bindActionCreators({ meAdd, meSub }, store.dispatch);

export 
                    
                    
                      default
                    
                     meActions;

引入这个自动派发的方法：直接使用。

                    import logo from './logo.svg'
                    
                      ;
import 
                    
                    './App.css'
                    
                      ;

                    
                    
                      //
                    
                    
                      来到组件
                    
                    
import store from './store/index'
                    
                      
import {useState} from 
                    
                    'react'


                    
                      //
                    
                    
                      使用 自动派发
                    
                    
import meActions from './store/actions/meActions'


                    
                      function
                    
                    
                       App() {
 
                    
                    
                      //
                    
                    
                       1获取到仓库中的数据
                    
                    
                        console.log(store.getState());
  
                    
                    
                      //
                    
                    
                       let age = store.getState().meReducer.age
                    
                    
  let [age,setAge] =
                    
                       useState(store.getState().meReducer.age)


                    
                    
                      //
                    
                    
                       3引入我们这个自动派发的方法 =》直接使用
                    
                    
  const changeAge = ()=>
                    
                      {
      console.log( meActions);
    
                    
                    
                      //
                    
                    
                        store.dispatch({type:'add'}) //触发reducer
                    
                    
                          meActions.meAdd()
 
    setAge(store.getState().meReducer.age)
  }

  
                    
                    
                      return
                    
                    
                       (
    
                    
                    <div className="App">
       <h2>我的年龄{age}</h2>
       <button onClick={()=>changeAge()}>修改仓库选中数据</button>
    </div>

                    
                        );
}

export 
                    
                    
                      default
                    
                     App;

。

6、React Redux

1、为什么应该使用React-Redux？

因为React是一个独立的库，可以与React、Vue、Angular一直使用，但是它们是相互独立的；。

如果想要同时使用 Redux 和 React，应该使用 React-Redux 来绑定这两个库。

react-redux是连接react和redux 的桥梁，让react中使用redux时低耦合，方便快捷 react-redux 提供了两个 api 。

作用：提供全局组件和hooks，在父级组件提供仓库组件，在自己组件中获取到仓库的数据。
Provider 为后代组件提供 store 。
connect 为组件提供数据和变更⽅法。

核心：为我们react项目提供的一个组件，两个hooks 。

组件： Provider 1 作用：在父级组件中提供数据，其他的子集组件就可以获取到；。

2 在父组件中提供了数据 store；。

hooks:

useSelector 1 作用：在组件中获取仓库中的数据，再通过useState修改数据方法，让数据更新。

2 语法：useSelector(state => { return 返回值}） // 返回在仓库中获取的数据。

useDispatch 1 作用：可以获取到更新组件的dispatch，先触发reducer，。

2 语法：let dispatch=useDispatch(); dispatch({type:'add'}),

。

2、在项目中使用redux

安装react-redux 。

                    npm install react-redux

2.在入口文件中使用Provider提供仓库store 。

                    import React from 'react'
                    
                      ;
import ReactDOM from 
                    
                    'react-dom/client'
                    
                      ;
import 
                    
                    './index.css'
                    
                      ;
import App from 
                    
                    './App'
                    
                      ;
import { Provider } from 
                    
                    'react-redux'
                    
                      ;
import store from 
                    
                    './store'
                    
                      ;

const root 
                    
                    = ReactDOM.createRoot(document.getElementById('root'
                    
                      ));
root.render(
  
                    
                    <Provider store={store}>
                    
                      
    {
                    
                    
                      /*
                    
                    
                       在父组件中提供数据 
                    
                    
                      */
                    
                    
                      }
    
                    
                    <App />
  </Provider>
);

3.useSelector使用。

4.useDispatch使用。

                    
                      /*
                    
                    
                       
   react-redux 作用
      提供 1 组件 =》 在子级组件提供仓库组件，在自己组件中获取到仓库数据
      2 hooks  

      useSelector => 得到仓库中的数据
      // 语法
      useDispatch 作用：可以获取到更新组件的dispatch；触发 reducer  =》 语法 useDispatch() => dispatch()

                    
                    
                      */
                    
                    
                      //
                    
                    
                       使用
                    
                    
                      
//
                    
                    
                       在自己组件中获取到仓库中的数据 =》 使用它提供的两个hooks
                    
                    
import {useSelector,useDispatch} from 'react-redux' 

                    
                      //
                    
                    
                       useSelector(state=>{返回值}) =》返回值  得到仓库中的数据
                    
                    
                      
//
                    
                    
                       useDispatch 触发redcuer =》 语法 useDispatch()=> 的返回值就是 dispatch()
                    
                    
                      //
                    
                    
                       作用：获取到可以更新组件的dispatch
                    
                    
                      function
                    
                    
                       App(){
  let age
                    
                    =useSelector(state=>{  
                    
                      //
                    
                    
                       state是来自父组件的store数据
                    
                    
                      return
                    
                    
                       state.MeReducer.age
  })

  let dispatch
                    
                    =useDispatch() 
                    
                      //
                    
                    
                       1 先触发reducer，获取到仓库中的数据，再通过useState修改数据方法，让数据更新
                    
                    
  console.log(age,'组件重新创建'
                    
                      );

  
                    
                    
                      return
                    
                    
                      (
      
                    
                    <div>
          <h2>我的年龄{age}</h2>
          <button onClick={()=>{dispatch({type:'add'})}}>修改仓库</button>
      </div>

                    
                        )

}

export 
                    
                    
                      default
                    
                    
                       App


                    
                    
                      /*
                    
                    
                       
  总结：react-redux
      作用：让仓库和react项目进行关联
            它为react项目提供了一个组件（Provider），两个hooks（useSelector、useDispatch）
      Provider: 在父级组件中提供数据，其他的自己组件就可以获取到
      useSelector：在组件获取到仓库中的数据
      useDispatch：先触发reducer，获取到仓库中的数据，再通过useState修改数据，让数据更新


                    
                    
                      */

。

7、异步actions

1、为什么需要处理异步？

因为reducer 只能处理同步问题，但是我们在工作中，可能需要在仓库中发生请求，获取到异步的数据。

2、异步actions作用？

1）在仓库中获取异步收据 2）触发reducer 修改仓库中的数据。

3、实现异步actions?

在store文件夹下创建一个 actions 文件夹，实现异步actions 和各自的reducer 一一对应。

                    
                      //
                    
                    
                      我的模块中 异步处理
                    
                    
import axios from 'axios'
                    
                      
import store from 
                    
                    '../index'
 
                    
                      //
                    
                    
                       定义异步处理方法
                    
                    
                      //
                    
                    
                      根据actions作用来进行定义 =》1 获取到异步数据   2 触发reducer
                    
                    
                      //
                    
                    
                      定义异步处理方法
                    
                    
                      //
                    
                    
                       1 是一个方法
                    
                    
                      //
                    
                    
                       2 获取到异步数据
                    
                    
                      //
                    
                    
                       3 触发reducer   => store
                    
                    
  export  
                    
                      function
                    
                    
                         getAgeSub(){
       
     
                    
                    
                      //
                    
                    
                      1获取到异步数据
                    
                    
                      function
                    
                    
                       getData(){
        
                    
                    
                      return
                    
                      axios.get('').then(res=>{ 
                    
                      //
                    
                    
                      后端给的数据
                    
                    
              let a = 100
              
                    
                      return
                    
                    
                       a
          })
     }

     
                    
                    
                      //
                    
                    
                       2触发reducer
                    
                    
                      return
                    
                      async()=>
                    
                      {
          
                    
                    
                      //
                    
                    
                       1获取到异步数据
                    
                    
        let data =
                    
                         await getData()
        console.log(data);
          
                    
                    
                      //
                    
                    
                       2 触发reducer =>将异步数据传递给 reducer
                    
                    
          console.log('触发reducer'
                    
                      );
          store.dispatch({type:
                    
                    'add'
                    
                      ,data })
     }
 }

 
                    
                    
                      //
                    
                    
                       getAgeSub()
                    
                    
                      //
                    
                    
                      总结 定义actions 
                    
                    
                      //
                    
                    
                      1 获取到异步数据
                    
                    
                      //
                    
                    
                      2 触发reducer
                    
                    
                      //
                    
                    
                      3 知道执行的获取到异步数据，再 执行reducer
                    
                    
                      //
                    
                    
                      定义异步actions => 函数劫持
                    
                    
                      
//
                    
                    
                      高阶函数=》  1 这个函数的参数是一个函数  或者 这个函数的返回值是一个函数
                    
                    
                      //
                    
                    
                       函数劫持 =》我在处理某个逻辑之前，要做一些操作，我们把这个方法叫做函数劫持

4 、在组件中使用 dispatch 触发异步actions

会报错 => 需要使用 1 中间件 2 redux-thunk 。

redux-thunk =》作用1：处理异步action =》给异步action触发方法，第一个参数就是dispatch 。

5、配置中间件 =》redux-thunk

在store/index.js 文件中进行配置。
安装redex-thunk 。

                    npm install redux-thunk

                    
                      //
                    
                    
                       引入中间件
                    
                    
import {createStore,applyMiddleware} from 'redux'
                    
                      
import reducers from 
                    
                    './reducers'

                    
                      //
                    
                    
                       引入'redux-thunk'
                    
                    
import ReduxThunk from 'redux-thunk'
                    
                      



let store 
                    
                    =
                    
                       createStore(reducers,applyMiddleware(ReduxThunk))
  
                    
                    
                      //
                    
                    
                      applyMiddleware(ReduxThunk) =>1处理组件中 dispatch（）这个方法内容可以写 方法 
                    
                    
                      //
                    
                    
                       2 异步actions 返回的处理方法 的第一次参数就是dispatch
                    
                    
                      

export 
                    
                    
                      default
                    
                     store

6、在其他组件中触发异步actions

创建异步actions 返回的处理方法的第一次参数就是dispatch 。

                    export  
                    
                      function
                    
                    
                         getAgeReduce(){
       
    
                    
                    
                      //
                    
                    
                      1获取到异步数据
                    
                    
                      function
                    
                    
                       getData(){
       
                    
                    
                      return
                    
                      axios.get('').then(res=>{ 
                    
                      //
                    
                    
                      后端给的数据
                    
                    
             let a = 100
             
                    
                      return
                    
                    
                       a
         })
    }

    
                    
                    
                      //
                    
                    
                       2触发reducer
                    
                    
                      return
                    
                      async(dispatch)=>{ 
                    
                      //
                    
                    
                      第一个参数 就是  dispatch
                    
                    
                      //
                    
                    
                       1获取到异步数据
                    
                    
       let data =
                    
                         await getData()
       console.log(data);
         
                    
                    
                      //
                    
                    
                       2 触发reducer =>将异步数据传递给 reducer
                    
                    
         console.log('触发reducer'
                    
                      );
      
        dispatch({type:
                    
                    'reduce'
                    
                      ,data })
    }
}

。

总结

。

最后此篇关于react中redux怎么使用的文章就讲到这里了,如果你想了解更多关于react中redux怎么使用的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐：【Go并发编程】Goroutine的基本使用

文章推荐：修改ctags让fzf.vim插件显示C,C++方法声明的标签

文章推荐： odoo给列表视图添加按钮实现数据文件导入

javascript - 使用 WebScriptEndpoint 使用 javascript 使用 WCF 服务
我在网上搜索但没有找到任何合适的文章解释如何使用 javascript 使用 WCF 服务，尤其是 WebScriptEndpoint。任何人都可以对此给出任何指导吗？谢谢最佳答案这是一篇关于
c - 没有结果!!使用 fork() 使用 dup2 使用 2 个管道运行 execlp()
我正在编写一个将运行 Linux 命令的 C 程序，例如: cat/etc/passwd | grep 列表 |剪切-c 1-5 我没有任何结果 *这里 parent 等待第一个 child (chi
python - 处理文件上传，使用 Pillow 调整大小，使用 SQLAlchemy 存储，使用 Flask 提供文件
所以我正在尝试处理文件上传，然后将该文件作为二进制文件存储到数据库中。在我存储它之后，我尝试在给定的 URL 上提供文件。我似乎找不到适合这里的方法。我需要使用数据库，因为我使用 Google 应用引
excel - 使用 IF 使用 VBA 在单元格中添加公式的问题
我正在尝试制作一个宏，将下面的公式添加到单元格中，然后将其拖到整个列中并在 H 列中复制相同的公式我想在 F 和 H 列中输入公式的数据 Range("F1").formula = "=IF(ISE
使用 OperatorPrecedenceParser 使用 FParsec 解析函数应用程序？
问题类似于this one ，但我想使用 OperatorPrecedenceParser 解析带有函数应用程序的表达式在 FParsec . 这是我的 AST: type Expression =
sql - 使用 sequelize 使用 where 查询编码计数
我想通过使用 sequelize 和 node.js 将这个查询更改为代码取决于在哪里 select COUNT(gender) as genderCount from customers where
bash - 使用 “let”分配Bash失败，使用 “/”
我正在使用GNU bash，版本5.0.3(1)-发行版(x86_64-pc-linux-gnu)，我想知道为什么简单的赋值语句会出现语法错误: #/bin/bash var1=/tmp
javascript - 使用 JavaScript 使用 FOR OF 数组循环时出现错误？
这里，为什么我的代码在 IE 中不起作用。我的代码适用于所有浏览器。没有问题。但是当我在 IE 上运行我的项目时，它发现错误。而且我的 jquery 类和 insertadjacentHTMl 也不
javascript - 使用 javascript 使用 for 属性更改表单标签内容
我正在尝试更改标签的innerHTML。我无权访问该表单，因此无法编辑 HTML。标签具有的唯一标识符是“for”属性。这是输入和标签的结构:
javascript - 使用 jquery 使用 .on() 将事件附加到页面上的动态插入按钮
我有一个页面，我可以在其中返回用户帖子，可以使用一些 jquery 代码对这些帖子进行即时评论，在发布新评论后，我在帖子下插入新评论以及删除按钮。问题是 Delete 按钮在新插入的元素上不起作用，
使用 awk 使用 sha1sum 进行散列
我有一个大约有 20 列的“管道分隔”文件。我只想使用 sha1sum 散列第一列，它是一个数字，如帐号，并按原样返回其余列。使用 awk 或 sed 执行此操作的最佳方法是什么？ Accounti
mysql - 使用 insert into 使用 mysql
我需要将以下内容插入到我的表中...我的用户表有五列 id、用户名、密码、名称、条目。 (我还没有提交任何东西到条目中，我稍后会使用 php 来做)但由于某种原因我不断收到这个错误:#1054 - U
jquery - 将输入字段值修剪为仅字母数字字符/使用 .使用 jQuery
所以我试图有一个输入字段，我可以在其中输入任何字符，但然后将输入的值小写，删除任何非字母数字字符，留下“。”而不是空格。例如，如果我输入: 地球的 70% 是水，-!*#$^^ & 30% 土地输
javascript - 使用 .innerHTML 使用 DOM
我正在尝试做一些我认为非常简单的事情，但出于某种原因我没有得到想要的结果？我是 javascript 的新手，但对 java 有经验，所以我相信我没有使用某种正确的规则。这是一个获取输入值、检查选择
php - 使用 angularjs 使用 where 子句从数据库获取数据
我想使用 angularjs 从 mysql 数据库加载数据。这就是应用程序的工作原理；用户登录，他们的用户名存储在 cookie 中。该用户名显示在主页上我想获取这个值并通过 angularjs
ios - 使用 UITableViewCell 使用 AutoLayout
我正在使用 autoLayout，我想在 UITableViewCell 上放置一个 UIlabel，它应该始终位于单元格的右侧和右侧的中心。这就是我想要实现的目标所以在这里你可以看到我正在谈论的
mysql - 使用 ElasticSearch 使用 or 和运算符搜索多个字段
我需要与 MySql 等效的 elasticsearch 查询。我的 sql 查询: SELECT DISTINCT t.product_id AS id FROM tbl_sup_price t
ios - 使用 Swift 使用 JSON
我正在实现代码以使用 JSON。 func setup() { if let flickrURL = NSURL(string: "https://api.flickr.com/
javascript - 使用 JavaScript 使用 for 循环声明变量
我尝试使用for循环声明变量，然后测试cols和rols是否相同。如果是，它将运行递归函数。但是，我在 javascript 中执行 do 时遇到问题。有人可以帮忙吗？现在，在比较 col.1 和
jquery - 使用 :after 使用 jquery 更改样式
我举了一个我正在处理的问题的简短示例。 HTML代码: 1 2 3 CSS 代码: .BB a:hover{ color: #000; } .BB > li:after {

我是一只小鸟

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城