Запутался с тем, как проверить, соответствуют ли ключи в словаре элементам в двух или одном из двух других массивов, а затем правильно добавить совпадающие словарные записи в строки.
Код:
target = {
'A': 1,
'B': 1,
'D': 2,
'L': 2
}
let a_include = ["A","B","C","D","E","F","G"];
let b_include = ["H","I","J","K","L","M","N","O","P","Q","R"];
a_string = ""
b_string = ""
if (target.length == 0) {
a_string += "None for a"
b_string += "None for b"
} else {
for(const i of Object.keys(target)) {
const verify = a_include.includes(i)
const verify2 = b_include.includes(i)
if (verify && !verify2) {
a_string += i + ": " + target[i] + "\n";
b_string += "None for B";
} else if (!verify && verify2){
a_string += "None for A"
b_string += i + ": " + target[i] + "\n"
} else {
a_string += "None for A"
b_string += "None for B"
}
}
}
В основном код должен проверять, соответствуют ли ключи словаря target
каким-либо элементам в массиве a_include
или b_include
, а затем добавлять либо к a_string
, либо к b_string
(также со значениями ключа словаря)
ожидаемая функция:
Код добавляет "None for A" or B
к обоим a&b_string
, если нет записи в target
.
Если не пусто, то он запускает цикл for для ключей цели и сравнивает его с a_include
и b_include
Если все ключи совпадают в обоих массивах, записи включаются в a_include
, затем добавляются в a_string
, в противном случае добавляются в b_string
Если все ключи совпали в a_include
, но не совпали для b_string
, добавьте записи в a_string
, но «Нет для B» для b_string
, обратимо добавьте «Нет для A» в a_string
, если нет совпадений с a_include
.
Если target
не пусто и нет совпадений для обоих массивов, добавьте «Нет» как к a, так и к b_string.
В настоящее время, если target = {'A': 1,'B': 1,'D': 2,'L': 2}
, выходная строка выдает:
a_string's output: "A: 1 b_string's ouput: "None for BNone for BNone for BL: 2
B: 1 "
D: 2
None for A"
Но то, что я пытаюсь вывести, это:
a_string's output: "A: 1 b_string's ouput: "L: 2"
B: 1
D: 2"
Я попытался просто удалить «Нет для A/B», чтобы предотвратить ошибочное добавление «Нет для A/B» в строки, но тогда вывод «Нет для» также не будет создан, если в словаре нет ключей, соответствующих одному из массивов:
Если target = {'A': 1,'B': 1,'D': 2}
, выходная строка выдает:
a_string's output: "A: 1 b_string's ouput: "None for BNone for BNone for B"
B: 1
D: 2
"
Вместо:
a_string's output: "A: 1 b_string's ouput: "None for B"
B: 1
D: 2
"
Итак, как установить условия/цикл, чтобы строки a и b_string давали ожидаемый результат?
*на самом деле это используется для встраивания Discord, поэтому «значения поля MessageEmbed могут быть не пустыми» произойдет, если удалить «Нет для ...» и оставить строки пустыми
Спасибо за чтение.
Итак, согласно моей отладке вашего кода. Цикл проходит через каждый ключ словаря цель, а условный оператор проверяет каждый ключ. Вот где проблема в том, что вы не хотите, чтобы условный оператор проверял ненужные условия. Например -
Здесь,
for(const i of Object.keys(target)) {
const verify = a_include.includes(i)
const verify2 = b_include.includes(i)
if (verify && !verify2) {
a_string += i + ": " + target[i] + "\n";
b_string += "None for B";
} else if (!verify && verify2){
a_string += "None for A"
b_string += i + ": " + target[i] + "\n"
} else {
a_string += "None for A"
b_string += "None for B"
}
}
Предположим, target = { "A": 1, "B": 1, "D": 2, "L": 2 }
Цикл проверит наличие А, Б, Г и Л и подтвердит первые три, т. е. А, Б и Г как строка, но он также проверит наличие л и назначит его b_string.
Проблема заключается в том, что для строка последний ключ, то есть л является мошенническим ключом и, таким образом, назначит "Нет для А", даже если в строка уже есть некоторый текст, и аналогично для b_string первые три ключа являются ложными.
Итак, вы получили представление о том, как работает ваша программа, теперь к решению -
if (verify && !verify2) {
a_string += i + ": " + target[i] + "\n";
b_string += "None for B"; // Remove this line
} else if (!verify && verify2){
a_string += "None for A"
b_string += i + ": " + target[i] + "\n" // Remove this line
} else {
a_string += "None for A"
b_string += "None for B"
}
Вместо того, чтобы проверять там мошеннические ключи, добавьте новый условный оператор после цикла следующим образом:
{...}
if (verify && !verify2) {
a_string += i + ": " + target[i] + "\n";
// b_string += "None for B";
} else if (!verify && verify2) {
// a_string += "None for A"
b_string += i + ": " + target[i] + "\n"
} else {
a_string += "None for A"
b_string += "None for B"
}
{...}
//after the loop
if (a_string.length === 0) {
a_string = "None for a";
}
if (b_string.length === 0) { // edited
b_string = "None for b"
}
Это работает, потому что после завершения цикла условие проверяет, строка или b_string пуст, и если он пуст, он назначит новые изменения.
There are more solutions to this particular problem, but I have tried to do it in a simple and understandable way.
Большое спасибо, я не заметил этого, когда писал код. ценится
Спасибо, но
else if (b_string.length === 0)
приведет к тому, чтоb_string
ничего не вернет""
вместо"None for b"
, если дляtarget
нет записей. Это было исправлено заменой «else if
» на «if
», и после этого все заработало.