tentar {} sem travar {} é possível em JavaScript?

Tenho várias funções que retornam algo ou geram um erro. Em uma função principal, eu chamo cada uma delas e gostaria de retornar o valor retornado por cada função ou ir para a segunda função se a primeira função gerar um erro.

Basicamente, o que tenho atualmente é:

function testAll() {
    try { return func1(); } catch(e) {}
    try { return func2(); } catch(e) {} // If func1 throws error, try func2
    try { return func3(); } catch(e) {} // If func2 throws error, try func3
}

Mas, na verdade, gostaria apenas tryde devolvê-lo (ou seja, se não gerar um erro). Eu não preciso do catchbloco. No entanto, o código try {}falha porque falta um catch {}bloco (não utilizado) .

Eu coloquei um exemplo no jsFiddle .

Então, há alguma maneira de catchremover esses bloqueios e, ao mesmo tempo, obter o mesmo efeito?

Não. Você tem que mantê-los.

Na verdade, isso faz sentido, pois os erros não devem ser ignorados silenciosamente.

Um try sem uma cláusula catch envia seu erro para o próximo catch superior , ou janela, se não houver catch definido dentro desse try.

Se você não tiver um catch , uma expressão try requer uma cláusula finally .

try {
    // whatever;
} finally {
    // always runs
}

É possível ter um bloco catch vazio, sem uma variável de erro, começando com ES2019 . Isso é chamado de vinculação de captura opcional e foi implementado no V8 v6.6, lançado em junho de 2018 . O recurso está disponível desde o Node 10 , Chrome 66 , Firefox 58 , Opera 53 e Safari 11.1 .

A sintaxe é mostrada abaixo:

try {
  throw new Error("This won't show anything");
} catch { };

Você ainda precisa de um catchbloco, mas pode estar vazio e você não precisa passar nenhuma variável. Se você não quiser um bloco catch, você pode usar try/ finally, mas observe que ele não engole erros como um catch vazio faz.

try {
  throw new Error("This WILL get logged");
} finally {
  console.log("This syntax does not swallow errors");
}

Não, catch(ou finally) é tryamigo de e sempre está lá como parte do try / catch .

No entanto, é perfeitamente válido tê-los vazios, como no seu exemplo.

Nos comentários em seu código de exemplo ( se func1 gerar erro, tente func2 ), parece que o que você realmente deseja fazer é chamar a próxima função dentro do catchbloco anterior.

Eu não recomendaria try-finally sem catch, porque se o bloco try e o bloco finally gerassem erros, o erro lançado na cláusula finally seria gerado e o erro do bloco try seria ignorado, em meu próprio teste:

try {
  console.log('about to error, guys!');
  throw new Error('eat me!');
} finally {
  console.log ('finally, who cares');
  throw new Error('finally error');
}

Resultado:

>     about to error, guys!
>     finally, who cares
>     .../error.js:9
>         throw new Error('finally error');
>         ^
>     
>     Error: finally error

Eles vão juntos em todas as linguagens que eu conheço que os possuem (JavaScript, Java, C #, C ++). Não faça isso.

Decidi olhar para o problema apresentado de um ângulo diferente.

Consegui determinar uma maneira de permitir o padrão de código solicitado enquanto, em parte, aborda o objeto de erro não tratado listado por outro comentador.

o código pode ser visto em http://jsfiddle.net/Abyssoft/RC7Nw/4/

try: catch é colocado dentro de um loop for permitindo uma queda elegante. enquanto é capaz de iterar por meio de todas as funções necessárias. quando o tratamento explícito de erros é necessário, uma matriz de função adicional é usada. no caso de erro e array funcional com o elemento manipuladores de erro não é uma função, o erro é despejado no console.

De acordo com os requisitos de stackoverflow, aqui está o código embutido [editado para tornar compatível com JSLint (remover espaços iniciais para confirmar), melhorar a legibilidade]

function func1() {"use strict"; throw "I don't return anything"; }
function func2() {"use strict"; return 123; }
function func3() {"use strict"; throw "I don't return anything"; }

// ctr = Code to Run <array>, values = values <array>, 
// eh = error code can be blank.
// ctr and params should match 1 <-> 1
// Data validation not done here simple POC
function testAll(ctr, values, eh) {
    "use strict";
    var cb; // cb = code block counter
    for (cb in ctr) {
        if (ctr.hasOwnProperty(cb)) {
            try {
                return ctr[cb](values[cb]);
            } catch (e) {
                if (typeof eh[cb] === "function") {
                    eh[cb](e);
                } else {
                    //error intentionally/accidentially ignored
                    console.log(e);
                }
            }
        }
    }
    return false;
}

window.alert(testAll([func1, func2, func3], [], []));

​

Se você deseja que as funções 2 e 3 sejam acionadas apenas se ocorrer um erro, por que você não as está colocando no bloco catch?

function testAll() {
  try {
    return func1();
  } catch(e) {
    try {
      return func2();
    } catch(e) {
      try {
        return func3();
      } catch(e) {
        // LOG EVERYTHING FAILED
      }
    }
  }
}

Eu acredito que você precisa usar a função auxiliar como:

function tryIt(fn, ...args) {
    try {
        return fn(...args);
    } catch {}
}

e usá-lo como:

tryIt(function1, /* args if any */);
tryIt(function2, /* args if any */);

try & catch são como dois lados de uma moeda. então não é possível sem tentar.

Desde ES2019 você pode usar facilmente try {}sem catch {}:

try {
  parseResult = JSON.parse(potentiallyMalformedJSON);
} catch (unused) {}

Para mais informações, consulte a proposta de Michael Ficcara