Je travaille sur un programme qui saisit un nombre avant et après une incidence d'une chaîne, puis compare ces nombres - mais cela ne peut arriver que si l'incidence de cette chaîne est présente.
J'ai essayé d'itérer via object.keys (peut-être que je n'ai pas compris comment correctement)
J'ai essayé d'imbriquer des boucles (qui ont enregistré des lettres individuelles dans la chaîne 'restart')
let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]
const switch = (Array) => {
console.log(formattedTemps)
let previousValue = 0
let nextValue = 0
for (let elements of array) {
console.log(previousValue)
console.log(nextValue)
// let previousValue = elements[-1]
// let nextValue = elements[1]
//console.log(previousValue , element, nextValue
// save the iterables beside 'restart' on both sides here
}
}
4 Réponses :
Bouclez en utilisant l'index au lieu d'utiliser for of . Ensuite, si un élément de cet index est 'restart' , vous pouvez revenir en arrière d'un index et avancer d'un index pour obtenir les valeurs.
let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]
for (let i = 0; i < formattedTemps.length; i++) {
let temp = formattedTemps[i]
if (typeof temp === 'string') {
beforeTemp = formattedTemps[i-1];
afterTemp = formattedTemps[i+1];
console.log(beforeTemp, temp, afterTemp);
}
}
Vous pouvez ajouter des vérifications pour la première et la dernière contrainte d'index.
Cela suppose des données bien formatées, mais vous avez raison.
Vous pouvez accéder au-delà de chaque côté du tableau, ce qui vous donnera la valeur undefined . Ainsi, vous pouvez simplement vérifier si vous avez un nombre de chaque côté d'une chaîne:
.as-console-wrapper {
max-height: 100% !important;
}Exemple en direct:
let formattedTemps = [10,'restart',68,80,'restart',70.1,'restart',
72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ];
const highLimitSwitch = (formattedTemps) => {
for (const [index, operation] of formattedTemps.entries()) {
if (typeof operation === "string") {
const num1 = formattedTemps[index - 1];
const num2 = formattedTemps[index + 1];
console.log(num1, operation, num2);
}
}
};
highLimitSwitch(formattedTemps);
const highLimitSwitch = (formattedTemps) => {
for (const [index, operation] of formattedTemps.entries()) {
if (typeof operation === "string") {
const num1 = formattedTemps[index - 1];
const num2 = formattedTemps[index + 1];
console.log(num1, operation, num2);
}
}
};
(Notez comment 70.1 est utilisé deux fois, à la fois comme num2 et comme num1 de l'opération suivante, car il y a un seul chiffre entre deux 'restart' dans les exemples de données.)
Ou si vous pouvez supposer que lorsque vous voyez une chaîne il a des numéros de chaque côté (comme le fait votre réponse actuellement acceptée ), alors c'est encore plus simple: p >
.as-console-wrapper {
max-height: 100% !important;
}Exemple en direct:
let formattedTemps = [10,'restart',68,80,'restart',70.1,'restart',
72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ];
const highLimitSwitch = (formattedTemps) => {
for (const [index, operation] of formattedTemps.entries()) {
const num1 = formattedTemps[index - 1];
const num2 = formattedTemps[index + 1];
if (typeof num1 === "number" && typeof operation === "string" && typeof num2 === "number") {
console.log(num1, operation, num2);
}
}
};
highLimitSwitch(formattedTemps);
const highLimitSwitch = (formattedTemps) => {
for (const [index, operation] of formattedTemps.entries()) {
const num1 = formattedTemps[index - 1];
const num2 = formattedTemps[index + 1];
if (typeof num1 === "number" && typeof operation === "string" && typeof num2 === "number") {
console.log(num1, operation, num2);
}
}
};
C'est bien - pour mes besoins, le même nombre peut être comparé plusieurs fois. Maintenant pour moi d'étudier et d'apprendre de l'implantation! (Merci!)
const highLimitSwitch = (formattedTemps) => {for (const [index, operation] of formattedTemps.entries ()) { // puisque .enteries peut être décomposé en paires clé-valeur - nous disent à javascript que le 1er est un index et le 2ème est un type de données défini ** const num1 = formattedTemps [index - 1]; const num2 = formattedTemps [index + 1]; ** les crochets indiquent à javascript num1 et 2 sont des itérations
if (typeof num1 === "number" && typeof operation === "string" && typeof num2 === "number") {console.log (num1, operation, num2); }}}; Les arguments typeOf doivent être des chaînes.
@JasonHarder - Non, les opérandes typeof n'ont pas besoin d'être des chaînes. Il n'y aurait aucun intérêt à typeof si tel était le cas. Essayez ceci dans votre console: const a = 42; console.log (typeof a); typeof résultat est toujours une chaîne, mais son opérande peut être n'importe quoi. Les vérifications dans la réponse sont correctes.
Eh bien, je veux dire que si vous recherchez un nombre, l'argument typeOf serait `` nombre '' qui est une chaîne - donc j'ai mal compris ou mal communiqué
@JasonHarder - J'ai bien peur de ne pas vous suivre du tout. Le type de vérification dans la réponse est correct. Les opérandes sont les entrées du tableau, qui sont soit des nombres, soit des chaînes, le résultat de typeof est toujours une chaîne ( "number" ou "string" < / code>), et c'est ce à quoi le code de la réponse les compare.
Je vois que j'ai mal écrit! ce que j'aurais dû dire, c'est que les résultats sont des chaînes que nous utilisons comme arguments lorsque nous définissons ce que nous recherchons. J'ai l'impression que je ne comprenais pas pleinement à ce moment-là. l'entrée, dans ce cas, étant le tableau lui-même et la sortie est une chaîne représentant le type de données.
Nous pouvons utiliser Voici ma tentative d'expliquer la logique derrière ceci: Array .reduce pour capturer le dernier index de l'itération dans l'accumulateur (l'accumulateur ou acc dans mon code est le premier paramètre du code Array.reduce > callback) et n'imprime le précédent et le suivant que lorsque l'élément actuel est restart ou n'importe quelle string
nombre . Nous renvoyons simplement l'index actuel comme valeur de l'accumulateur. typeof ele === "string" est satisfaite donc maintenant la valeur de acc est 0 ( car il contient le dernier index visité) qui serait précédent et le suivant est un de plus que l'index actuel. acc ) que nous pouvons utiliser dans l'itération courante pour trouver la valeur de l'élément précédent. Ensuite, nous imprimons si l'élément courant est une chaîne. La valeur de l'élément suivant résiderait dans un de plus que l'index actuel idx du tableau.
let formattedTemps = [ 10,'restart',68,80,'restart',70.1,'restart',
72,80,'restart',69,'restart',78,'restart',84,100,300,50,'restart',70,
'restart',90,'restart',50,'restart',100 ]
const highLimitSwitch = (formattedTemps) => {
formattedTemps.reduce((acc, ele, idx, arr) => {
if(typeof arr[acc] === "number" && typeof ele === "string" && typeof arr[idx + 1] === "number"){
console.log(`${arr[acc]} ${ele} ${arr[idx + 1]}`)
}
return idx;
}, 0)
}
highLimitSwitch(formattedTemps);
C'est une façon étrange d'utiliser réduire
@JordanS est-ce que ça ressemble à un hack? :)
On dirait un hack. Réduire est déjà un peu incertain tel quel, mais c'est assez sauvage :)
Merci d'avoir expliqué, j'ai fait des études sur .map (), .reduce () et .filter () mais j'ai toujours l'impression de comprendre les choses - je codifie par intermittence depuis 2 ans mais c'est le première fois Cela n'a pas fait partie d'un tutoriel ou de quelque chose depuis un certain temps.
@JasonHarder - C'est dramatiquement plus compliqué que nécessaire, et ne fait rien pour garantir que les opérandes de chaque côté de restart sont des nombres. Tout ce dont vous avez besoin (comme je l'ai démontré) est une simple boucle.
@ T.J.Crowder J'ai ajouté les chèques de numéro, merci :)
Vous pouvez mapper de nouveaux tableaux si la valeur réelle est une chaîne. Puis filtrez et conservez les tableaux.
.as-console-wrapper { max-height: 100% !important; top: 0; }
var array = [10, 'restart', 68, 80, 'restart', 70.1, 'restart', 72, 80, 'restart', 69, 'restart', 78, 'restart', 84, 100, 300, 50, 'restart', 70, 'restart', 90, 'restart', 50, 'restart', 100],
result = array
.map((v, i, a) => typeof v === 'string' && [a[i - 1], v, a[i + 1]])
.filter(Boolean);
console.log(result.map(a => a.join(' ')));
temperature [-1]n'est pas définie, vous accédez hors des limites du tableauVous avez dit "boucle dans une boucle" mais je ne vois qu'une couche de boucle ...?
ahh @ T.J.Crowder J'ai essayé une boucle dans une boucle plus tôt mais console. redémarrage enregistré sous forme de lettres individuelles avec des valeurs de chaîne