Большинство ответов здесь дают полезные советы, когда у вас есть одна операция async, но иногда это возникает, когда вам нужно выполнить асинхронную операцию для каждой записи в массиве или другом списке подобная структура. Искушение состоит в том, чтобы сделать это:
// WRONG
var results = [];
theArray.forEach(function(entry) {
doSomethingAsync(entry, function(result) {
results.push(result);
});
});
console.log(results); // E.g., using them, returning them, etc.
Пример:
// WRONG
var theArray = [1, 2, 3];
var results = [];
theArray.forEach(function(entry) {
doSomethingAsync(entry, function(result) {
results.push(result);
});
});
console.log("Results:", results); // E.g., using them, returning them, etc.
function doSomethingAsync(value, callback) {
console.log("Starting async operation for " + value);
setTimeout(function() {
console.log("Completing async operation for " + value);
callback(value * 2);
}, Math.floor(Math.random() * 200));
}
.as-console-wrapper {
max-height: 100% !important;
}
Причина, 't работа заключается в том, что обратные вызовы из doSomethingAsync
еще не запущены к тому моменту, когда вы пытаетесь использовать результаты.
Итак, если у вас есть массив (или список какого-то типа) и хотите выполнять асинхронные операции для каждой записи, у вас есть два варианта: выполнять операции параллельно (перекрывающиеся) или последовательно (последовательно последовательно).
Вы могут запускать все из них и отслеживать количество обратных вызовов, которые вы ожидаете, а затем использовать результаты, когда вы получили много обратных вызовов:
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
console.log("Results:", results); // E.g., using the results
}
});
});
Пример:
var theArray = [1, 2, 3];
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
console.log("Results:", results); // E.g., using the results
}
});
});
function doSomethingAsync(value, callback) {
console.log("Starting async operation for " + value);
setTimeout(function() {
console.log("Completing async operation for " + value);
callback(value * 2);
}, Math.floor(Math.random() * 200));
}
.as-console-wrapper {
max-height: 100% !important;
}
(Мы могли бы покончить с expecting
и просто использовать results.length === theArray.length
, но это оставляет нам открытым возможность того, что theArray
изменяется, пока вызовы выдающиеся ...)
Обратите внимание, как мы используем index
из forEach
, чтобы сохранить результат в results
в том же положении, что и запись это относится, даже если результаты a (поскольку асинхронные вызовы не обязательно завершаются в том порядке, в котором они были запущены).
Но что, если вам нужно вернуть те результаты от функции? Как указывали другие ответы, вы не можете; вы должны принять вашу функцию и вызвать обратный вызов (или вернуть Promise ). Вот вариант обратного вызова:
function doSomethingWith(theArray, callback) {
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
callback(results);
}
});
});
}
doSomethingWith(theArray, function(results) {
console.log("Results:", results);
});
Пример:
function doSomethingWith(theArray, callback) {
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
callback(results);
}
});
});
}
doSomethingWith([1, 2, 3], function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value, callback) {
console.log("Starting async operation for " + value);
setTimeout(function() {
console.log("Completing async operation for " + value);
callback(value * 2);
}, Math.floor(Math.random() * 200));
}
.as-console-wrapper {
max-height: 100% !important;
}
Или вот версия, возвращающая Promise
вместо:
function doSomethingWith(theArray) {
return new Promise(function(resolve) {
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
resolve(results);
}
});
});
});
}
doSomethingWith(theArray).then(function(results) {
console.log("Results:", results);
});
Конечно, если doSomethingAsync
передал нам ошибки, мы использовали бы reject
, чтобы отклонить обещание, когда мы получили сообщение об ошибке.)
Пример:
function doSomethingWith(theArray) {
return new Promise(function(resolve) {
var results = [];
var expecting = theArray.length;
theArray.forEach(function(entry, index) {
doSomethingAsync(entry, function(result) {
results[index] = result;
if (--expecting === 0) {
// Done!
resolve(results);
}
});
});
});
}
doSomethingWith([1, 2, 3]).then(function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value, callback) {
console.log("Starting async operation for " + value);
setTimeout(function() {
console.log("Completing async operation for " + value);
callback(value * 2);
}, Math.floor(Math.random() * 200));
}
.as-console-wrapper {
max-height: 100% !important;
}
(Или, альтернативно, вы можете сделать обертку для doSomethingAsync
, который возвращает обещание, а затем сделайте следующее ...)
Если doSomethingAsync
дает вам Promise , вы можете использовать Promise.all
:
function doSomethingWith(theArray) {
return Promise.all(theArray.map(function(entry) {
return doSomethingAsync(entry, function(result) {
results.push(result);
});
}));
}
doSomethingWith(theArray).then(function(results) {
console.log("Results:", results);
});
Пример:
function doSomethingWith(theArray) {
return Promise.all(theArray.map(function(entry) {
return doSomethingAsync(entry, function(result) {
results.push(result);
});
}));
}
doSomethingWith([1, 2, 3]).then(function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value) {
console.log("Starting async operation for " + value);
return new Promise(function(resolve) {
setTimeout(function() {
console.log("Completing async operation for " + value);
resolve(value * 2);
}, Math.floor(Math.random() * 200));
});
}
.as-console-wrapper {
max-height: 100% !important;
}
Обратите внимание, что Promise.all
решает свое обещание с помощью массива результатов всех обещаний, которые вы даете ему, когда все они разрешены, или отвергает его обещание, когда первый обещаний, которые вы ему даете, отклоняет.
Предположим, вы не хотите, чтобы операции были параллельны? Если вы хотите запускать их один за другим, вам нужно дождаться завершения каждой операции до начала следующего. Вот пример функции, которая делает это, и вызывает обратный вызов с результатом:
function doSomethingWith(theArray, callback) {
var results = [];
doOne(0);
function doOne(index) {
if (index < theArray.length) {
doSomethingAsync(theArray[index], function(result) {
results.push(result);
doOne(index + 1);
});
} else {
// Done!
callback(results);
}
}
}
doSomethingWith(theArray, function(results) {
console.log("Results:", results);
});
(Поскольку мы выполняем работу последовательно, мы можем просто использовать results.push(result)
, так как мы знаю, что мы не получим результаты не в порядке. В приведенном выше примере мы могли бы использовать results[index] = result;
, но в некоторых из следующих примеров у нас нет индекса для использования.)
Пример:
function doSomethingWith(theArray, callback) {
var results = [];
doOne(0);
function doOne(index) {
if (index < theArray.length) {
doSomethingAsync(theArray[index], function(result) {
results.push(result);
doOne(index + 1);
});
} else {
// Done!
callback(results);
}
}
}
doSomethingWith([1, 2, 3], function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value, callback) {
console.log("Starting async operation for " + value);
setTimeout(function() {
console.log("Completing async operation for " + value);
callback(value * 2);
}, Math.floor(Math.random() * 200));
}
.as-console-wrapper {
max-height: 100% !important;
}
(Или снова создайте обертку для doSomethingAsync
, которая дает вам обещание и выполните ниже ...)
Если doSomethingAsync
дает вам обещание, если вы можете использовать синтаксис ES2017 + (возможно, с транспилером, например Babel ), вы можете использовать функцию async
с помощью for-of
и await
:
async function doSomethingWith(theArray) {
const results = [];
for (const entry of theArray) {
results.push(await doSomethingAsync(entry));
}
return results;
}
doSomethingWith(theArray).then(results => {
console.log("Results:", results);
});
Пример:
async function doSomethingWith(theArray) {
const results = [];
for (const entry of theArray) {
results.push(await doSomethingAsync(entry));
}
return results;
}
doSomethingWith([1, 2, 3]).then(function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value) {
console.log("Starting async operation for " + value);
return new Promise(function(resolve) {
setTimeout(function() {
console.log("Completing async operation for " + value);
resolve(value * 2);
}, Math.floor(Math.random() * 200));
});
}
.as-console-wrapper {
max-height: 100% !important;
}
Если вы не можете использовать синтаксис ES2017 + (пока), вы можете использовать вариацию на Обещают уменьшить шаблон (это сложнее, чем обычное сокращение Promise, потому что мы не передаем результат от одного к другому, а вместо gat
function doSomethingWith(theArray) {
return theArray.reduce(function(p, entry) {
return p.then(function(results) {
return doSomethingAsync(entry).then(function(result) {
results.push(result);
return results;
});
});
}, Promise.resolve([]));
}
doSomethingWith(theArray).then(function(results) {
console.log("Results:", results);
});
Пример:
function doSomethingWith(theArray) {
return theArray.reduce(function(p, entry) {
return p.then(function(results) {
return doSomethingAsync(entry).then(function(result) {
results.push(result);
return results;
});
});
}, Promise.resolve([]));
}
doSomethingWith([1, 2, 3]).then(function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value) {
console.log("Starting async operation for " + value);
return new Promise(function(resolve) {
setTimeout(function() {
console.log("Completing async operation for " + value);
resolve(value * 2);
}, Math.floor(Math.random() * 200));
});
}
.as-console-wrapper {
max-height: 100% !important;
}
.. , который менее громоздк с функциями стрелок ES2015 + :
function doSomethingWith(theArray) {
return theArray.reduce((p, entry) => p.then(results => doSomethingAsync(entry).then(result => {
results.push(result);
return results;
})), Promise.resolve([]));
}
doSomethingWith(theArray).then(results => {
console.log("Results:", results);
});
Пример:
function doSomethingWith(theArray) {
return theArray.reduce((p, entry) => p.then(results => doSomethingAsync(entry).then(result => {
results.push(result);
return results;
})), Promise.resolve([]));
}
doSomethingWith([1, 2, 3]).then(function(results) {
console.log("Results:", results);
});
function doSomethingAsync(value) {
console.log("Starting async operation for " + value);
return new Promise(function(resolve) {
setTimeout(function() {
console.log("Completing async operation for " + value);
resolve(value * 2);
}, Math.floor(Math.random() * 200));
});
}
.as-console-wrapper {
max-height: 100% !important;
}
Я несколько раз сталкивался с этой проблемой в MacOS. Git чувствителен к регистру, но Mac - только сохранение случаев.
Кто-то фиксирует файл: Foobar.java
и через несколько дней решает переименовать его в FooBar.java
. Когда вы вытаскиваете последний код, он терпит неудачу с The following untracked working tree files would be overwritten by checkout...
. Единственный надежный способ, который я видел, который исправляет это:
git rm Foobar.java
git commit -m 'TEMP COMMIT!!'
git rebase --continue
git rebase -i HEAD~2
и drop
TEMP COMMIT!!
FooBar.java
Использование SourceTree Я смог сделать все это из UI
FILE.ext
в whatever.ext
whatever.ext
в file.ext
Это немного утомительно, но если вам нужно всего лишь сделать это с несколькими файлами, это довольно быстро
Я попробовал следующие решения из других ответов, и они не работали:
Если ваш репозиторий размещен на GitHub, как у меня, вы можете переименовать файл по происхождению (GitHub.com) и принудительно переименовать файл в нисходящем порядке манера. Вот что я сделал:
branchname
ветви» Mac OSX High Sierra 10.13 исправляет это несколько. Просто создайте виртуальный раздел APFS для своих проектов git, по умолчанию он не имеет ограничения по размеру и не занимает места.
Sensitive
git
и ln -s /Volumes/Sensitive/git /Users/johndoe/git
Ваш диск будет находиться в /Volumes/Sensitive/
1) переименуйте файл Name.jpg
в name1.jpg
2) зафиксируйте удаленный файл Name.jpg
3) переименуйте файл name1.jpg
в name.jpg
4) добавляет добавленный файл name.jpg
к предыдущему commit
git add
git commit --amend
Вы можете использовать git mv :
git mv -f OldFileNameCase newfilenamecase
Когда вы сделали много переименования файлов, а некоторые из них - просто замена корпуса, трудно вспомнить, что именно. вручную «git moving», файл может быть весьма полезной. Итак, что бы я делал во время моих задач смены имени файла:
Это устранит все проблемы, не пытаясь определить, какие файлы или папки вы переименовали.
Это то, что я сделал в OS X:
git mv File file.tmp
git mv file.tmp file
Два шага, потому что в противном случае я получил ошибку «файл существует». Возможно, это можно сделать за один шаг, добавив --cached
или такой.
Иногда полезно временно изменить чувствительность регистра Git. Вот два возможных метода: -
Метод 1:
git -c core.ignorecase=
<<true or false>>
<<command>>
можно использовать для изменения чувствительности к регистру для одна команда. Например: git -c core.ignorecase=true checkout mybranch
. (кредит для VonC для предложения этого в комментариях.)
Способ 2:
Чтобы изменить настройку дольше (например, если несколько команд должны быть перед тем, как изменить его):
git config core.ignorecase
(это возвращает текущую настройку, например false
). git config core.ignorecase
<<true or false>>
- установите желаемую новую настройку. git config core.ignorecase
<<false or true>>
- установить конфигурацию значение возвращается к предыдущей настройке. Git имеет настройку конфигурации, которая указывает, будет ли регистр чувствителен к регистру или нечувствителен: core.ignorecase
. Чтобы сообщить Git, чтобы он был случайным, просто установите для этого параметра значение false
:
git config core.ignorecase false
Из документации git config
:
core.ignorecase
Если true, эта опция позволяет использовать различные обходные пути, чтобы git лучше работал на файловых системах, которые не чувствительны к регистру, например FAT. Например, если список каталогов обнаруживает
makefile
, когда git ожидаетMakefile
, git будет считать, что это действительно тот же файл, и продолжает помнить его какMakefile
.По умолчанию установлено значение false, кроме git-clone (1) или git-init (1) проверит и установит
blockquote>core.ignorecase
true, если это необходимо, когда создается репозиторий.Нечувствительные к регистру файловые системы
Две самые популярные операционные системы, в которых я не знаю файловые системы, не зависящие от регистра,
- Windows
- OS X
В OSX, чтобы избежать этой проблемы и избежать других проблем с разработкой в файловой системе без регистра, вы можете использовать Disk Utility для создания образа диска с чувствительным -чувствительным .
Запустите утилиту диска, создайте новый образ диска и используйте следующие настройки (или измените по своему усмотрению, но сохраните его с учетом регистра):
[/g1]
Обязательно сообщите git, что теперь он находится на чувствительном к регистру FS:
git config core.ignorecase false