1 files changed, 249 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/statements/try...catch/index.html b/files/pt-br/web/javascript/reference/statements/try...catch/index.html
new file mode 100644
index 0000000000..001e7fcc13
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/try...catch/index.html
@@ -0,0 +1,249 @@
+---
+title: try...catch
+slug: Web/JavaScript/Reference/Statements/try...catch
+translation_of: Web/JavaScript/Reference/Statements/try...catch
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>As declarações <strong>try...catch</strong> marcam um bloco de declarações para testar (<strong>try</strong>),  e especifica uma resposta, caso uma exceção seja lançada.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">try {
+   <em>try_statements</em>
+}
+[catch (<em>exception_var_1</em> if <em>condition_1</em>) {
+   <em>catch_statements_1</em>
+}]
+...
+[catch (<em>exception_var_2</em>) {
+   <em>catch_statements_2</em>
+}]
+[finally {
+   <em>finally_statements</em>
+}]
+</pre>
+
+<dl>
+ <dt><code>try_statements</code></dt>
+ <dd>Declarações (statements) a serem executadas.</dd>
+</dl>
+
+<dl>
+ <dt><code>catch_statements_1</code>, <code>catch_statements_2</code></dt>
+ <dd>Declarações que são executadas se uma exceção é lançada no bloco <code style="font-style: normal; line-height: 1.5;">try.</code></dd>
+</dl>
+
+<dl>
+ <dt><code>exception_var_1</code>, <code>exception_var_2</code></dt>
+ <dd>Um indentificador que leva um objeto exceção para uma cláusula <code>catch</code>  associada.</dd>
+</dl>
+
+<dl>
+ <dt><code>condition_1</code></dt>
+ <dd>Uma expressão condicional.</dd>
+</dl>
+
+<dl>
+ <dt><code>finally_statements</code></dt>
+ <dd>Declarações que são executadas depois que a declaração <code>try</code> é completada. Essas declarações são executadas independetemente se uma exceção foi ou não lançada ou capturada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>A declaração <code>try</code> consiste  em um bloco <code>try</code>, que contém uma ou mais declarações, e ao menos uma cláusula <code>catch</code>  ou uma cláusula <code>finally</code>,  ou ambas. Ou seja, há 3 formas de declarações <code>try</code> :</p>
+
+<ol>
+ <li><code>try...catch</code></li>
+ <li><code>try...finally</code></li>
+ <li><code>try...catch...finally</code></li>
+</ol>
+
+<p>Uma cláusula <code>catch</code> contém declarações que especificam o que fazer caso uma exceção seja lançada no bloco <code>try</code>. Ou seja, se você quer que o bloco <code>try </code>tenha êxito, e caso não tenha, você quer que o controle passe para o bloco <code>catch</code>. Caso qualquer declaração dentro do bloco <code>try</code>  (ou em uma função chamada no interior do bloco <code>try</code>) lançar uma exceção o controle imediatamente muda para a cláusula <code>catch</code>. Se nenhuma exceção for lançada no bloco <code>try</code> a cláusula <code>catch</code> é ignorada.</p>
+
+<p>A cláusula <code>finally</code> é executada após a excecução do bloco <code>try</code> e da(s) cláusula(s) <code>catch </code>porém antes das declarações seguintes ao <code>try</code>. Ela sempre é executada, independente se uma exceção for lançada ou capturada.</p>
+
+<p>Você pode aninhar uma ou mais declarações <code>try</code>. Caso uma declaração <code>try</code> interior não tenha uma cláusula <code>catch</code>, a cláusula catch pertencente a declaração <code>try</code> que a envolve é introduzida. </p>
+
+<p>Você pode usar a declaração try para manipular exceções em JavaScript. Veja o <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia Javascript</a> para informações sobre exceções em JavaScript.</p>
+
+<h3 id="Unconditional_catch_clause" name="Unconditional_catch_clause">Cláusula catch incondicional</h3>
+
+<p>Quando uma única, incondicional cláusula <code>catch</code> é utilizada, o bloco <code>catch</code>  é inserido quando qualquer exceção for lançada. Por exemplo, quando a exceção ocorre no código a seguir, o controle é transferido para a cláusula <code>catch</code>.</p>
+
+<pre class="brush: js">try {
+   throw "myException"; // gera uma exceção
+}
+catch (e) {
+   // declarações para manipular quaisquer exceções
+   logMyErrors(e); // <code>passa o objeto de exceção para o manipulador de erro</code>
+}
+</pre>
+
+<h3 id="Conditional_catch_clauses" name="Conditional_catch_clauses">Cláusulas <code>catch</code> condicionais</h3>
+
+<p>{{non-standard_header}}</p>
+
+<p>Você pode utilizar uma ou mais cláusulas <code>catch</code> condicionals para manipular exceções específicas. Nesse caso a cláusula <code>catch</code> apropriada será inserida quando a exceção espeficica for lançada. No exemplo a seguir, o código no bloco <code>try</code> pode potencialmente jogar três exceções: <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/TypeError"><code>TypeError</code></a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RangeError"><code>RangeError</code></a>, e <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/EvalError"><code>EvalError</code></a>. Quando a exceção ocorre, o controle transfere para a cláusula <code>catch</code> apropriada. Caso a exceção não seja uma das especificadas e uma cláusula <code>catch</code> incondicional for encontrada, o controle é transferido para essa cláusula <code>catch</code>.</p>
+
+<p>Se utilizar uma cláusula <code>catch</code> incondicional com uma ou mais cláusulas <code>catch</code> condicionais, o catch incondicional deve ser especificado por último. Caso contrário, o catch incondicional interceptará todos os tipos de exceção antes que eles alcancem os condicionais.</p>
+
+<p>Nota: Essa funcionalidade não é parte da especificação ECMAScript.</p>
+
+<pre><code>try {
+    myroutine(); // </code>pode lançar três tipos de exceções<code>
+} catch (e if e instanceof TypeError) {
+    // declarações para manipular exceções TypeError
+} catch (e if e instanceof RangeError) {
+    // declarações para manipular exceções RangeError
+} catch (e if e instanceof EvalError) {
+    // declarações para manipular exceções EvalError
+} catch (e) {
+    // declarações para manipular quaisquer exceções não especificadas
+    logMyErrors(e); // passa o objeto de exceção para o manipulador de erro
+}</code></pre>
+
+<p>E aqui temos como implementar as mesmas "cláusulas <code>catch</code> condicionais" utilizando apenas JavaScript puro conforme a especificação ECMAScript (obviamente é mais verboso, porém, funciona em qualquer lugar):</p>
+
+<pre><code>try {
+    myroutine(); </code>// pode lançar três tipos de exceções<code>
+} catch (e) {
+    if (e instanceof TypeError) {
+        // declarações para manipular exceções TypeError
+    } else if (e instanceof RangeError) {
+        // declarações para manipular exceções RangeError
+    } else if (e instanceof EvalError) {
+        // declarações para manipular exceções EvalError
+    } else {
+       // declarações para manipular quaisquer exceções não especificadas
+       logMyErrors(e); // passa o objeto de exceção para o manipulador de erro
+    }
+}</code>
+</pre>
+
+<h3 id="The_exception_identifier" name="The_exception_identifier">O identificador de exceção</h3>
+
+<p>Quando uma exceção é lançada no bloco <code>try</code>, <em><code>exception_var</code></em> (ex. o <code>e</code> dentro de <code>catch (e)</code>) armazena o valor especificado pela declaração <code>throw</code>. Você pode usar esse identificador para conseguir informação sobre a exceção que foi lançanda.</p>
+
+<p>Esse identificador é local para a cláusula <code>catch</code>. Ou seja, é criado quando a cláusula <code>catch</code> é introduzida e após terminar sua excecução o identificador não se torna mais disponível.</p>
+
+<h3 id="The_finally_clause" name="The_finally_clause">A cláusula <code>finally</code></h3>
+
+<p>A cláusula <code>finally</code> é executada após a excecução do bloco <code>try</code> e da(s) cláusula(s) <code>catch </code>porém antes das declarações seguintes a declaração <code>try</code>. Ela sempre é executada, independente se uma exceção for lançada ou capturada.</p>
+
+<p>A cláusula <code>finally</code> contém declarações para executarem após a execução do bloco <code>try</code>  e da(s) cláusula(s) <code>catch </code> porém antes das declarações seguintes a declaração <code>try</code>. A cláusula <code>finally</code> é excutada independente se uma exceção for lançada ou não. Caso uma exceção seja lançada, as declarações no interior da cláusula <code>finally</code> são executadas mesmo que nenhum <code>catch</code> manipule a exceção.</p>
+
+<p>Você pode utilizar a cláusula <code>finally</code> para fazer seu script falhar graciosamente quando uma exceção ocorrer; por exemplo, você pode precisar liberar um recurso que seu script possui vinculado. O exemplo seguinte abre um aquivo e então executa declarações que utilizam o arquivo (server-side JavaScript permite que você acesse arquivos). Se uma exceção for lançada enquanto o arquivo estiver aberto, a cláusula <code>finally</code> fecha o arquivo antes que o script falhe.</p>
+
+<pre class="brush: js">openMyFile()
+try {
+   // vincula o recurso
+   writeMyFile(theData);
+}
+finally {
+   closeMyFile(); // sempre fecha o recurso
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Blocos_try_aninhados">Blocos try aninhados</h3>
+
+<p>Primeiro vamos ver o que acontece com isso:</p>
+
+<pre><code><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  </span><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Error</span><span class="pun">(</span><span class="str">"oops"</span><span class="brush: js">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">finally</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"finally"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+</span><span class="pun">}</span><span class="pln">
+</span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"outer"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+</span><span class="pun">}</span></code>
+
+// Resultado
+<code><span class="str">// "finally"<span class="pln">
+</span>// "outer"</span><span class="pln"> </span><span class="str">"oops"</span></code></pre>
+
+<p>Agora, caso nós já capturamos a exceção no bloco <code>try</code> interno adicionando um bloco <code>catch</code></p>
+
+<pre><code><span class="kwd"><code><span class="kwd">try {
+  try {
+    throw new Error("oops");
+  }
+  catch (ex) {
+    console.error("inner", ex.message);
+  }
+  finally {
+    console.log("finally");
+  }
+}
+catch (ex) {
+  console.error("outer", ex.message);
+}</span></code></span></code>
+
+// Resultado:
+<code><span class="str">// "inner"<span class="pln"> </span>"oops"</span><span class="pln">
+</span><span class="str">// "finally"</span></code></pre>
+
+<p>E agora, vamos relançar o erro.</p>
+
+<pre><code><span class="kwd"><code><span class="kwd"><code><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  </span><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Error</span><span class="pun">(</span><span class="str">"oops"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"inner"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> ex</span><span class="pun">;</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">finally</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"finally"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+</span><span class="pun">}</span><span class="pln">
+</span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"outer"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+</span><span class="pun">}</span></code></span></code></span>
+
+// Resultado:</code>
+<code><span class="str">// "inner"</span><span class="pln"> </span><span class="str">"oops"</span></code>
+<code><span class="str">// "finally"</span></code>
+<code><span class="str">// "outer"</span><span class="pln"> </span><span class="str">"oops"</span></code>
+</pre>
+
+<p>Qualquer exceção lançada será capturada apenas uma vez pelo bloco <code>catch</code> envolvente mais próximo, a não ser que seja relançada. Obviamente qualquer nova exceção elevada no bloco "interno" (pois código em um bloco <code>catch</code> pode fazer algo que lance), será capturado pelo bloco "externo".</p>
+
+<h3 id="Retornando_de_um_bloco_finnaly">Retornando de um bloco <code>finnaly</code></h3>
+
+<p>Caso o bloco f<code>inally</code> retorne um valor, esse valor torna-se o valor de retorno do produto de <code>try-catch-finally </code>inteiro, independente de qualquer declaração return nos blocos <code>try</code> e <code>catch</code>. Isso inclui exceções lançadas dentro do bloco <code>catch</code>:</p>
+
+<pre><code>try {
+  try {
+    throw new Error("oops");
+  }
+  catch (ex) {
+    console.error("inner", ex.message);
+    throw ex;
+  }
+  finally {
+    console.log("finally");
+    return;
+  }
+}
+catch (ex) {
+  console.error("outer", ex.message);
+}</code>
+
+// Resultado:
+// "inner" "oops"
+// "finally"</pre>
+
+<p>O "oops" externo não é lançado devido ao retorno do bloco f<code>inally</code>. O mesmo se aplicaria a qualquer valor retornado do bloco <code>catch</code>.</p>
+
+<h2 id="See_also" name="See_also">Vejam também</h2>
+
+<ul>
+ <li><a href="/en/JavaScript/Reference/Statements/throw" title="en/JavaScript/Reference/Statements/throw">throw</a></li>
+ <li><a href="/en/JavaScript/Reference/Global_Objects/Error" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error">Error</a></li>
+</ul>