Como retornar Chaves, Atributos, Índice de um Value pesquisado no JSON com Nodejs?

[eriseu]

Tenho um arquivo JSON com essa estrutura:

arquivo.json

{
    "um": {
        "umum": [
            "umumum",
            "umumdois",
            "umumtres"
        ],
        "umdois": [
            "umdoisum",
            "umdoisdois",
            "umdoistres"
        ]
     },
     "dois": {
         "doisum": [
            "doisumum",
            "doisumdois",
            "doisumtres"
         ],
         "doisdois": [
            "doisdoisum",
            "doisdoisdois",
            "doisdoistres"
         ]
     }
}

arquivo.js

let obj = require('./arquivo.json')
JSON.parse(JSON.stringify(obj), (key, value) => {
      
  if(value == valor ){
 
    console.log("Palavra pesquisada : "+value)
    if(key == 0){
      console.log("Índice : "+key)
    } else if (key == 1){
      console.log("Índice : "+key)
    } else if (key == 2){
      console.log("Índice : "+key)
    } else if (key == 3){
      console.log("Índice : "+key)
    } else if (key == 4){
      console.log("Índice : "+key)
    } else if (key == 5){
      console.log("Índice : "+key)
    }
  }
  return key
})

Este é um exemplo de arquivo, quero aplicar em qualquer arquivo com este padrão de níveis.
Faço uma busca pelo value doisumum, ele me retorna o índice 0, preciso das chaves dois e doisum e também o value do índice 1 neste caso doisumdois.
Entendeu? São os 6 valores que preciso.

Estou usando Nodejs!

Você faz ideia de como faço isso?
Já há alguns dias venho tentando e descobri algumas formas de como não fazê-lo. :)

[felquis]

Manda a sua solução que retorna o indice 0

[eriseu]

JSON.parse(JSON.stringify(obj), (key, value) => {
      
  if(value == valor ){
 
    console.log("Palavra pesquisada : "+value)
    if(key == 0){
      console.log("Índice : "+key)
    } else if (key == 1){
      console.log("Índice : "+key)
    } else if (key == 2){
      console.log("Índice : "+key)
    } else if (key == 3){
      console.log("Índice : "+key)
    } else if (key == 4){
      console.log("Índice : "+key)
    } else if (key == 5){
      console.log("Índice : "+key)
    }
  }
  return key
})

[wmartins]

@eriseu pode dar mais uns exemplos de entrada e saída esperados?

Por exemplo:

• Entrada: doisumum
• Saída: ?

Tem bastante informação aqui:

Faço uma busca pelo value doisumum, ele me retorna o índice 0, preciso das chaves dois e doisum e também o value do índice 1 neste caso doisumdois.
Entendeu? São os 6 valores que preciso.

Tu precisa dos índices? Dos valores? Dos dois?

[eriseu]

A entrada "doisumum" retorna o índice "0"

Preciso que "doisumum", retorne "0", "doisum", "dois", o caminho completo, para que depois eu possa retornar nele e chamar os irmãos de acordo com o índice.

[wmartins]

Presumi algumas coisas e venho te trazer uma sugestão. Deixei o código que fiz aqui https://jsfiddle.net/fL5dxmo1/. O resultado foi esse:

{
  result: [
    "doisumum",
    "doisumdois",
    "doisumtres",
    "doisdoisum",
    "doisdoisdois",
    "doisdoistres"
  ]
}

Acredito que tava em linha com o que tu esperava (de trazer os 6 valores). Agora, falando da implementação. Eu acho que tem um erro no teu input, faltou uma chave entre o elemento um e dois, então corrigi isso:

{
  "um": ...,
  "dois": ...
}

Caso não seja isso, só dá um aviso.

Com isso em mente, o algoritmo que fiz é bem simples e não tão eficiente quanto poderia ser (explico mais a seguir):

• Busco, a partir de todas as possibilidades, pelo texto pesquisado (no caso doisumum)
• Se encontro o texto, retorno o caminho que fiz até encontrar (no caso, dois > doisum)
• Tenho uma função adicional que, a partir do caminho, busca todos os elementos (nesse caso, a partir de dois)

Função de busca

function find(input, word, path = []) {
  if (Array.isArray(input)) {
    if (input.indexOf(word) === -1) {
    	return [];
    }
    
    return path;
  }
  
  const entries = Object.entries(input);
  
  const result = entries.map(([key, values]) => {
  	return find(input[key], word, path.concat(key));
  });
  
  return result.flat();
}

Função de agregação dos resultados

function all(input, key) {
  if (Array.isArray(input)) {
    return input;
  }

  const entries = Object.entries(input[key]);

  const result = entries.map(([key, values]) => {
    return all(values, key);
  });

  return result.flat();
}

Uso

const search = "doisdoisum";

const keys = find(input, search);

const result = all(input, keys[0]);

console.log({ result });

Se era isso o que tu queria essa é uma solução.

Falando sobre a eficiência desse algoritmo, é um algoritmo extremamente ineficiente. Se tu tivesse mais chaves além de um e dois, o algoritmo iria buscar em todas as chaves até encontrar o elemento pesquisado, o que não é algo eficiente.

Acredito que uma implementação mais eficiente pode ser feita usando uma estrutura de dados como Trie/Prefix Tree. Uma outra maneira seria iterar em cima da palavra pesquisada até encontrar uma das chaves no teu array. Por exemplo:

 doisumum
 ^  ^
 doisumum
 ^    ^

No momento que encontrou, começa a pesquisar em cima das chaves de dois. Segue olhando até encontrar a próxima chave (no caso doisum). No momento que achou um array, verifica se o elemento pesquisado existe. Se existir, tu tem o caminho que foi percorrido até encontrar e, por consequência, sabe os elementos.

Existem algumas outras formas de fazer, mas espero ajudar com algumas ideias!

[eriseu]

Excelente seu código, já resolve parte da solução. Já trás os irmãos. Valeu por ajudar.

Agora preciso do filho, do pai e do avô. O caminho completo até chegar no avô, através do filho.

doisumum / doisum / dois