小编use*_*999的帖子

我有两个空的选择字段,我想在某个数组上迭代一次,在每次迭代中创建一个选项元素,并将其附加到两个选择字段.问题是只有最后一个元素获得选项,第一个元素保持为空:

HTML

<select class="form-control" id="typeCol">
</select>
<br>
<select class="form-control" id="diffCol">
</select>

JavaScript的

let typeCol = document.getElementById('typeCol');
let diffCol = document.getElementById('diffCol');
for (let i in cols) {
    let opt = document.createElement('option');
    opt.value = i;
    opt.innerHTML = cols[i];
    typeCol.appendChild(opt);
    diffCol.appendChild(opt);
}

添加另一个for循环并附加到第二个循环select似乎工作,但仍然 - 发生了什么？

我有两个 go 程序——一个作为服务器守护进程运行，另一个手动执行。我希望能够从其他程序向服务器发送请求，通过 post 请求在那里发送一些二进制数据。我怎样才能做到这一点？

我知道我可以发送这样的字符串：

data := url.Values{}
data.Set("req", buf)
u, _ := url.ParseRequestURI(domain)
u.Path = path
urlStr := fmt.Sprintf("%v", u)
client := &http.Client{}
r, _ := http.NewRequest("POST", urlStr, bytes.NewBufferString(data.Encode()))
r.Header.Add("Authorization", "auth_token=\"XXXXXXX\"")
r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
r.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))
resp, _ := client.Do(r)
return resp.Status

但我想发送一个octet-stream，然后我可以从中读取ioutil.ReadAll(r.Body)。

我想将一个对象或数组传递给一个函数,使其未定义,并在函数执行结束后查看更改.

var arr = ['aaa', 'bbb', 'ccc'];
var reset = function (param) {
   param[0] = 'bbb';
   param = undefined;
}
reset(arr);

好的,结果是['bbb', 'bbb', 'ccc'],但我希望它是undefined.是否有可能有效地做到这一点？

现在，我通过ajax将请求发送到后端服务器，该服务器执行一些操作并返回响应：

function getData() {
  new Ajax().getResponse()
    .then(function (response) {
      // handle response
    })
    .catch(function (error) {
      // handle error
    });
}

事实是，每次用户刷新网站时，都会再次发送每个请求。我一直在考虑将它们缓存在本地存储中：

function getData() {
  if (Cache.get('getResponse')) {
    let response = Cache.get('getResponse');
    // handle response
    return true;
  }
  new Ajax().getResponse()
    .then(function (response) {
      // handle response
    })
    .catch(function (error) {
      // handle error
    });
}

这样，如果用户已经发出请求，并且响应被缓存在localStorage内部，则不必从服务器获取数据。如果用户更改的值，则getResponse只需清除缓存。

这是一个好方法吗？如果是，是否有更好的方法可以做到这一点？另外，是否应该以相同的方式缓存后端响应？前端和后端缓存之间有什么区别？

我不太了解重新选择如何减少组件的渲染。这是我无需重新选择的内容：

const getListOfSomething = (state) => (
  state.first.list[state.second.activeRecord]
);

const mapStateToProps = (state, ownProps) => {
  console.log(state.first.list, state.second.activeRecord);
  return {
    ...ownProps,
    listOfSomething: getListOfSomething(state)
  }
};

它根据某个值组合某个列表中的元素。每当状态发生任何变化时，都会调用Render，例如我的console.log输出：

{}, ""
{}, ""
{}, ""
{}, "1"
{"filled", "1"}

因为商店的不同部分正在发生某些事情。因此，该组件被渲染5次，即2次。

但是使用重新选择：

const getList = state => state.first.list;
const getActiveRecord = state => state.second.activeRecord;
const listOfSomething = (list, activeRecord) => {
  console.log(list, activeRecord);
  return list[activeRecord];
}
const getListOfSomething = createSelector(getList, getActiveRecord, listOfSomething);

const mapStateToProps = (state, ownProps) => {
  console.log(state.first.list, state.second.activeRecord);
  return …