diff options
Diffstat (limited to 'files/pt-br/web/javascript/reference/errors')
33 files changed, 2351 insertions, 0 deletions
diff --git a/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html b/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html new file mode 100644 index 0000000000..0b0aa34421 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html @@ -0,0 +1,61 @@ +--- +title: 'ReferenceError: can''t access lexical declaration`X'' before initialization' +slug: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init +tags: + - Erros + - JavaScript + - ReferenceError +translation_of: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">ReferenceError: Use before delaration (Edge) +ReferenceError: can't access lexical declaration `X' before initialization (Firefox) +ReferenceError: 'x' is not defined (Chrome) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("ReferenceError")}}</p> + +<h2 id="O_que_está_errado">O que está errado:</h2> + +<p>Uma variável léxica foi acessada antes de ser inicializada. Isso acontece dentro de qualquer declaração de bloco, quando as declarações <code>let</code> ou <code>const</code> são acessadas antes de serem definidas.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Errado">Errado</h3> + +<p>Neste caso, a variável "foo" é redeclarada usando <code>let</code>.</p> + +<pre class="brush: js example-bad">function test() { + let foo = 33; + if (true) { + let foo = (foo + 55); + // ReferenceError: can't access lexical + // declaration `foo' before initialization + } +} +test(); +</pre> + +<h3 id="Certo">Certo</h3> + +<p>Para mudar "foo" dentro do bloco if você precisa remover o <code>let</code> que causa a redeclaração.</p> + +<pre class="brush: js example-good">function test(){ + let foo = 33; + if (true) { + foo = (foo + 55); + } +} +test(); +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/let#Temporal_Dead_Zone_and_errors_with_let">Temporal Dead Zone e erros com let.</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html b/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html new file mode 100644 index 0000000000..7c5c9affa3 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html @@ -0,0 +1,60 @@ +--- +title: 'TypeError: can''t access property "x" of "y"' +slug: Web/JavaScript/Reference/Errors/Cant_access_property +tags: + - Erros + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Cant_access_property +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge) +TypeError: can't access property {x} of {y} (Firefox) +TypeError: {y} is undefined, can't access property {x} of it (Firefox) +TypeError: {y} is null, can't access property {x} of it (Firefox) + +Exemplos: +TypeError: x is undefined, can't access property "prop" of it +TypeError: x is null, can't access property "prop" of it +TypeError: can't access property "prop" of undefined +TypeError: can't access property "prop" of null +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>O acesso a propriedade foi realizado com um valor {{jsxref("undefined")}} ou {{jsxref("null")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<pre class="brush: js example-bad">// casos undefined e null, onde o metódo substring não irá funcionar + +var foo = undefined; +foo.substring(1); // TypeError: x is undefined, can't access property "substring" of it + +var foo = null; +foo.substring(1); // TypeError: x is null, can't access property "substring" of it +</pre> + +<h3 id="Corrigindo_o_problema">Corrigindo o problema</h3> + +<p>Para corrigir o problema de valores <code>undefined</code> ou <code>null</code>, você pode usar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a>, como no exemplo abaixo.</p> + +<pre class="brush: js">if (typeof foo !== 'undefined') { + // Agora que sabemos que <em>foo</em> está definida, podemos prosseguir +}</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html b/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html new file mode 100644 index 0000000000..83844d17b5 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html @@ -0,0 +1,38 @@ +--- +title: Erro de sintaxe falta ) depois da lista de argumentos +slug: Web/JavaScript/Reference/Errors/Fata_parênteses_após_lista_argumento +translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Erro de sintaxe: Falta ) depois da lista de argumento +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("Erro de sintaxe")}}.</p> + +<h2 id="O_que_houve_de_errado">O que houve de errado?</h2> + +<p>Ocorreu um erro quando a função foi chamada. Pode ter sido um erro de escrita, falta de operador, ou uma string fora das aspas, por exemplo.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Pela falta do operador "+" para fazer a concatenação da string, o JavaScript esperou um argumento para a função log ser "PI: ". Nesse caso, deveria ser finalizado com parênteses de fechamento ')'.</p> + +<pre class="brush: js example-bad">console.log("PI: " Math.PI); +// SyntaxError: missing ) after argument list +</pre> + +<p>Você pode corrigir a chamada do log adicionand o operador "+":</p> + +<pre class="brush: js example-good">console.log("PI: " + Math.PI); +// "PI: 3.141592653589793"</pre> + +<h2 id="Veja_também">Veja também:</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Funções</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html b/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html new file mode 100644 index 0000000000..b10562516e --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html @@ -0,0 +1,52 @@ +--- +title: 'SyntaxError: missing } after property list' +slug: Web/JavaScript/Reference/Errors/Fecha_chaves_esquecida_apos_lista_propriedades +tags: + - Erro de Sintaxe + - Erros + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: missing } after property list +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Aconteceu um engano na sintaxe do <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicializador do objeto</a> em algum lugar. Pode ser que você esqueceu de colocar uma chave, mas também pode ser uma vírgula que foi esquecida, por exemplo. Verifique também se alguma chave de finalização ou parêntesis estão em algum lugar que não deveriam estar. Indente ou formate o código de uma maneira legível pode te ajudar a enxergar no meio dessa selva.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Vírgula_esquecida">Vírgula esquecida</h3> + +<p>Muitas vezes esquecemos uma vígula no inicializador de objeto:</p> + +<pre class="brush: js example-bad">var obj = { + a: 1, + b: { minhaProp: 2 } + c: 3 +}; +</pre> + +<p>O código correto deve ser:</p> + +<pre class="brush: js example-good">var obj = { + a: 1, + b: { minhaProp: 2 }, + c: 3 +}; +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicializador de objeto</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html b/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html new file mode 100644 index 0000000000..c48e8a8294 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html @@ -0,0 +1,169 @@ +--- +title: 'Warning: JavaScript 1.6''s for-each-in loops are deprecated' +slug: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated +tags: + - Aviso + - JavaScript + - Warning +translation_of: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead +</pre> + +<h2 id="Tipo_de_mensagem">Tipo de mensagem</h2> + +<p>Warning</p> + +<h2 id="O_que_aconteceu_de_errado">O que aconteceu de errado?</h2> + +<p>A declaração {{jsxref("Statements/for_each...in", "for each (variable in obj)")}} do JavaScript 1.6 foi descontinuada e será removida num futuro próximo.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Iteração_do_objeto">Iteração do objeto</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} tem sido usada para iterar por valores específicos do objeto.</p> + +<h4 id="Sintaxe_descontinuada">Sintaxe descontinuada</h4> + +<pre class="brush: js example-bad">var object = { a: 10, b: 20 }; + +for each (var x in object) { + console.log(x); // 10 + // 20 +} +</pre> + +<h4 id="Sintaxe_padrão_alternativa">Sintaxe padrão alternativa</h4> + +<p>Agora você pode utilizar o loop padrão {{jsxref("Statements/for...in", "for...in")}}, para iterar sobre chaves específicas do objeto e receber cada valor para dentro do loop:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var key in object) { + var x = object[key]; + console.log(x); // 10 + // 20 +} +</pre> + +<p>Ou, utilizando {{jsxref("Statements/for...of", "for...of")}} (ES2015) e {{jsxref("Object.values")}} (ES2017), você pode ter um array dos valores específicos do objeto e iterar sobre o array da seguinte maneira:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var x of Object.values(object)) { + console.log(x); // 10 + // 20 +} +</pre> + +<h3 id="Iteração_sobre_o_Array">Iteração sobre o Array</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} tem sido usado para iterar sobre elementos específicos do array.</p> + +<h4 id="Sintaxe_descontinuada_2">Sintaxe descontinuada</h4> + +<pre class="brush: js example-bad">var array = [10, 20, 30]; + +for each (var x in array) { + console.log(x); // 10 + // 20 + // 30 +} +</pre> + +<h4 id="Sintaxe_padrão_alternativa_2">Sintaxe padrão alternativa</h4> + +<p>Isso agora é possível também com loops {{jsxref("Statements/for...of", "for...of")}} (ES2015).</p> + +<pre class="brush: js example-good">var array = [10, 20, 30]; + +for (var x of array) { + console.log(x); // 10 + // 20 + // 30 +} +</pre> + +<h3 id="Iterando_sobre_um_array_null-able">Iterando sobre um array null-able</h3> + +<p>{{jsxref("Statements/for_each...in", "for each...in")}} não faz nada se o valor especificado for <code>null</code> ou <code>undefined</code>, mas {{jsxref("Statements/for...of", "for...of")}} vai disparar uma exceção nestes casos.</p> + +<h4 id="Sintaxe_descontinuada_3">Sintaxe descontinuada</h4> + +<pre class="brush: js example-bad">function func(array) { + for each (var x in array) { + console.log(x); + } +} +func([10, 20]); // 10 + // 20 +func(null); // prints nothing +func(undefined); // prints nothing +</pre> + +<h4 id="Sintaxe_padrão_alternativa_3">Sintaxe padrão alternativa</h4> + +<p>Para reescrever as declarações {{jsxref("Statements/for_each...in", "for each...in")}} de modo que os valores possam ser <code>null</code> ou <code>undefined</code> com {{jsxref("Statements/for...of", "for...of")}} também, você precisa utilizar algo como {{jsxref("Statements/for...of", "for...of")}}.</p> + +<pre class="brush: js example-good">function func(array) { + if (array) { + for (var x of array) { + console.log(x); + } + } +} +func([10, 20]); // 10 + // 20 +func(null); // prints nothing +func(undefined); // prints nothing +</pre> + +<h3 id="Iterando_sobre_um_par_chave-valor_de_um_objeto">Iterando sobre um par chave-valor de um objeto</h3> + +<h4 id="Sintaxe_descontinuada_4">Sintaxe descontinuada</h4> + +<p>Existe um idioma descontinuado para iterar sobre pares chave-valor específicos de um objeto, utilizando {{jsxref("Statements/for_each...in", "for each...in")}} e o objeto descontinuado {{jsxref("Iterator")}}.</p> + +<pre class="brush: js example-bad">var object = { a: 10, b: 20 }; + +for each (var [key, value] in Iterator(object)) { + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<h4 id="Sintaxe_padrão_alternativa_4">Sintaxe padrão alternativa</h4> + +<p>Você pode utilizar agora o loop padrão {{jsxref("Statements/for...in", "for...in")}} para iterar sobre chaves específicas do objeto, e obter cada valor dentro do loop:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var key in object) { + var value = object[key]; + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<p>Ou utilizando {{jsxref("Statements/for...of", "for...of")}} (ES2015) e {{jsxref("Object.entries")}} (ES2017), você pode obter um array dos valores específicos do objeto e iterar sobre este array da seguinte maneira:</p> + +<pre class="brush: js example-good">var object = { a: 10, b: 20 }; + +for (var [key, value] of Object.entries(object)) { + console.log(key, value); // "a", 10 + // "b", 20 +} +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Statements/for...of", "for...of")}}</li> + <li>{{jsxref("Object.values")}}</li> + <li>{{jsxref("Object.entries")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/illegal_character/index.html b/files/pt-br/web/javascript/reference/errors/illegal_character/index.html new file mode 100644 index 0000000000..c36124dc8d --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/illegal_character/index.html @@ -0,0 +1,77 @@ +--- +title: 'SyntaxError: illegal character' +slug: Web/JavaScript/Reference/Errors/Illegal_character +tags: + - Erro + - ErroSintaxe + - ErrodeSintaxe + - Erros + - JavaScript +translation_of: Web/JavaScript/Reference/Errors/Illegal_character +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: Invalid character (Edge) +SyntaxError: illegal character (Firefox) +SyntaxError: Invalid or unexpected token (Chrome) +</pre> + +<h2 id="Tipo_do_erro">Tipo do erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Há um token inválido ou inesperado que não pertence a esta posição no código. Utilize um editor que realce a sintaxe e cuidadosamente verifique seu código em relação a desajustes como um sinal de menos (<code> - </code>) no lugar de um travessão (<code> – </code>) ou aspas simples (<code> " </code>) no lugar de aspas não padronizadas(<code> “ </code>).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Caracteres_desajustados">Caracteres desajustados</h3> + +<p>Alguns carateres parecem similares, mas irão impedir que o analisador interprete seu código. Exemplos famosos disso são as aspas, o sinal de menos ou o ponto e vírgula (o <a href="https://en.wikipedia.org/wiki/Question_mark#Greek_question_mark">ponto de interrogação grego (U+37e)</a> é quase igual)</p> + +<pre class="brush: js example-bad">“Isso parece uma string”; +// SyntaxError: illegal character + +42 – 13; +// SyntaxError: illegal character +</pre> + +<p>Isto deve funcionar:</p> + +<pre class="brush: js example-good">"Isso é realmente uma string"; + +42 - 13; +</pre> + +<h3 id="Caracteres_esquecidos">Caracteres esquecidos</h3> + +<p>É fácil esquecer um caractere aqui ou ali.</p> + +<pre class="brush: js example-bad">var colors = ['#000', #333', '#666']; +// SyntaxError: illegal character +</pre> + +<p>Adicione as aspas que faltam no <code><strong>'</strong>#333'</code>.</p> + +<pre class="brush: js example-good">var colors = ['#000', '#333', '#666'];</pre> + +<h3 id="Caracteres_escondidos">Caracteres escondidos</h3> + +<p>Quando copiamos e colamos código de fontes externas, pode haver caracteres inválidos. Cuidado!</p> + +<pre class="brush: js example-bad">var foo = 'bar'; +// SyntaxError: illegal character +</pre> + +<p>Quando inspeciona-se este código em um editor como o Vim, você pode ver que, na verdade, há um caractere <a href="https://en.wikipedia.org/wiki/Zero-width_space">zero-width space (ZWSP) (U+200B)</a>.</p> + +<pre class="brush: js">var foo = 'bar';<200b></pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/index.html b/files/pt-br/web/javascript/reference/errors/index.html new file mode 100644 index 0000000000..2df10baf6e --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/index.html @@ -0,0 +1,14 @@ +--- +title: JavaScript error reference +slug: Web/JavaScript/Reference/Errors +tags: + - JavaScript + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Reference/Errors +--- +<p>{{jsSidebar("Errors")}}</p> + +<p>Lista de erros "globais".</p> + +<p>{{ListSubPages("/pt-BR/docs/Web/JavaScript/Reference/Errors")}}</p> diff --git a/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html b/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html new file mode 100644 index 0000000000..fc520f9bea --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html @@ -0,0 +1,78 @@ +--- +title: 'RangeError: invalid array length' +slug: Web/JavaScript/Reference/Errors/Invalid_array_length +tags: + - Errors + - Erros + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">RangeError: invalid array length (Firefox) +RangeError: Invalid array length (Chrome) +RangeError: Invalid array buffer length (Chrome) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="O_que_houve_de_errado">O que houve de errado?</h2> + +<p>Um comprimento inválido de array pode aparecer nas seguintes situações:</p> + +<ul> + <li>Quando criamos um {{jsxref("Array")}} ou um {{jsxref("ArrayBuffer")}} que tem um comprimento que ou é negativo ou é maior ou igual a 2<sup>32</sup>, ou</li> + <li>quando configuramos a propriedade {{jsxref("Array.length")}} a um valor que é negativo, ou maior ou igual a 2<sup>32</sup>.</li> +</ul> + +<p>Porque <code>Array</code> e <code>ArrayBuffer</code> tem um comprimento limitado? A propriedade <code>length</code> de um <code>Array</code> ou um <code>ArrayBuffer</code> é representado por um inteiro 32-bit unsigned, que pode apenas armazenar valores que estão no intervalo de 0 a 2<sup>32</sup>-1.</p> + +<p>Se você está criando um <code>Array</code>, utilizando o construtor, você provavelmente quer usar a notação literal, onde o primeiro argumento é interpretado como o comprimento do <code>Array</code>.</p> + +<p>Ao contrário, você poderia querer travar o comprimento antes de ajustar a propriedade do comprimento, ou utilizá-lo com um argumento do construtor.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<pre class="brush: js example-bad">new Array(Math.pow(2, 40)) +new Array(-1) +new ArrayBuffer(Math.pow(2, 32)) +new ArrayBuffer(-1) + +let a = []; +a.length = a.length - 1; // define -1 à propriedade length + +let b = new Array(Math.pow(2, 32) - 1); +b.length = b.length + 1; // define 2^32 à propriedade length +</pre> + +<h3 id="Casos_válidos">Casos válidos</h3> + +<pre class="brush: js example-good">[ Math.pow(2, 40) ] // [ 1099511627776 ] +[ -1 ] // [ -1 ] +new ArrayBuffer(Math.pow(2, 32) - 1) +new ArrayBuffer(0) + +let a = []; +a.length = Math.max(0, a.length - 1); + +let b = new Array(Math.pow(2, 32) - 1); +b.length = Math.min(0xffffffff, b.length + 1); + +// 0xffffffff é a notação hexadecimal de 2^32 - 1 +// que também pode ser escrito como (-1 >>> 0) +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.length")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html b/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html new file mode 100644 index 0000000000..9b15ff4bf9 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html @@ -0,0 +1,50 @@ +--- +title: 'ReferenceError: invalid assignment left-hand side' +slug: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side +translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">ReferenceError: invalid assignment left-hand side +</pre> + +<h2 id="Tipo_do_erro">Tipo do erro</h2> + +<p>{{jsxref("ReferenceError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Ouve uma declaração inesperada em algum lugar. Isso pode ocorrer devido a uma confusão entre um <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operador de atribuição</a> e um <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Operador de comparação</a>, por exemplo. Enquanto um <code>"="</code> define uma variavel, <code>"=="</code> ou <code>"==="</code> são usados para fazer uma comparação entre valores.</p> + +<h2 id="Exemplos"> Exemplos</h2> + +<pre class="brush: js example-bad">if (Math.PI = 3 || Math.PI = 4) { + console.log('de modo algum!'); +} +// ReferenceError: invalid assignment left-hand side + +var str = 'Olá, ' ++= 'sou eu ' ++= 'que você está procurando?'; +// ReferenceError: invalid assignment left-hand side +</pre> + +<p>Na declaração <code>if</code> você deve usar um operador de comparação ("=="), e para a atribuição da string, apenas o operador mais ("+") é necessario</p> + +<pre class="brush: js example-good">if (Math.PI == 3 || Math.PI == 4) { + console.log('de modo algum!'); +} + +var str = 'Olá, ' ++ 'do ' ++ 'outro lado!'; +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li> <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadores de atribuição</a></li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Operadores de comparação</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html b/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html new file mode 100644 index 0000000000..cc5a4733a4 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html @@ -0,0 +1,91 @@ +--- +title: 'TypeError: atribuição inválida para const "x"' +slug: Web/JavaScript/Reference/Errors/Invalid_const_assignment +tags: + - Erro + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_const_assignment +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">TypeError: invalid assignment to const "x" (Firefox) +TypeError: Assignment to constant variable. (Chrome) +TypeError: Assignment to const (Edge) +TypeError: Redeclaration of const 'x' (IE) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Uma constante é um valor que não pode ser alterado pelo programa durante a execução normal. Ele não pode mudar através de reatribuição e não pode ser redeclarado. Em JavaScript, as constantes são declaradas usando a palavra-chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Redeclaração_inválida">Redeclaração inválida</h3> + +<p>Atribuir um valor ao mesmo nome de constante no mesmo escopo de bloco lançará o erro.</p> + +<pre class="brush: js example-bad">const COLUNAS = 80; + +// ... + +COLUNAS = 120; // TypeError: invalid assignment to const `COLUNAS'</pre> + +<h3 id="Corrigindo_o_erro">Corrigindo o erro</h3> + +<p>Existem várias opções para corrigir esse erro. Verifique o que se pretendia alcançar com a constante em questão.</p> + +<h4 id="Renomear">Renomear</h4> + +<p>Se você quis declarar outra constante, escolha outro nome e renomeie. Esse nome de constante já está sendo usado nesse escopo.</p> + +<pre class="brush: js example-good">const COLUNAS = 80; +const COLUNAS_LARGAS = 120;</pre> + +<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code>?</h4> + +<p>Não use const se você não quis declarar uma constante. Talvez você quisesse declarar uma variável com escopo de bloco com <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code> ou uma variável global com <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code>.</p> + +<pre class="brush: js example-good">let colunas = 80; + +// ... + +let colunas = 120; +</pre> + +<h4 id="Escopo">Escopo</h4> + +<p>Verifique se você está no escopo correto. Essa constante deve aparecer nesse escopo ou deveria aparecer em uma função, por exemplo?</p> + +<pre class="brush: js example-good">const COLUNAS = 80; + +function configurarAmbienteTelaGrande() { + const COLUNAS = 120; +}</pre> + +<h3 id="const_e_imutabilidade"><code>const</code> e imutabilidade</h3> + +<p>A declaração <code>const</code> cria uma referência somente leitura para um valor. Isso <strong>não significa</strong> que o valor que ela contém é imutável, apenas que o identificador da variável não pode ser reatribuído. Por exemplo, caso o conteúdo seja um objeto, isso significa que o objeto em si ainda pode ser alterado. Isso significa que você não pode alterar o valor armazenado em uma variável:</p> + +<pre class="brush: js example-bad">const obj = {foo: 'bar'}; +obj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj' +</pre> + +<p>Mas você pode alterar as propriedades em uma variável:</p> + +<pre class="brush: js example-good">obj.foo = 'baz'; +obj; // Object { foo: "baz" }</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/invalid_date/index.html b/files/pt-br/web/javascript/reference/errors/invalid_date/index.html new file mode 100644 index 0000000000..8663f67051 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/invalid_date/index.html @@ -0,0 +1,55 @@ +--- +title: 'RangeError: invalid date' +slug: Web/JavaScript/Reference/Errors/Invalid_date +tags: + - Errors + - Erros + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Invalid_date +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">RangeError: invalid date (Firefox) +RangeError: invalid time value (Chrome) +RangeError: Provided date is not in valid range (Chrome) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="O_que_houve_de_errado">O que houve de errado?</h2> + +<p>Uma string apontando para uma data inválida foi disponibilizada para {{jsxref("Date")}} ou {{jsxref("Date.parse()")}}.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<p>Strings irreconhecíveis ou data contendo elementos de strings formatadas com valores ISO ilegais, geralmente retornam {{jsxref("NaN")}}. No entanto, dependendo da implementação, strings com formatos em não conformidade ISO, também podem disparar <code>RangeError: invalid date</code>, como os seguintes casos no Firefox:</p> + +<pre class="brush: js example-bad">new Date('foo-bar 2014'); +new Date('2014-25-23').toISOString(); +new Date('foo-bar 2014').toString(); +</pre> + +<p>Isto, no entanto, retorna {{jsxref("NaN")}} no Firefox:</p> + +<pre class="brush: js example-bad">Date.parse('foo-bar 2014'); // NaN</pre> + +<p>Para mais detalhes, veja a documentação {{jsxref("Date.parse()")}}.</p> + +<h3 id="Casos_válidos">Casos válidos</h3> + +<pre class="brush: js example-good">new Date('05 October 2011 14:48 UTC');</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Date")}}</li> + <li>{{jsxref("Date.prototype.parse()")}}</li> + <li>{{jsxref("Date.prototype.toISOString()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html b/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html new file mode 100644 index 0000000000..e3d389d2f8 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html @@ -0,0 +1,105 @@ +--- +title: 'SyntaxError: JSON.parse: bad parsing' +slug: Web/JavaScript/Reference/Errors/JSON_bad_parse +translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal +SyntaxError: JSON.parse: bad control character in string literal +SyntaxError: JSON.parse: bad character in string literal +SyntaxError: JSON.parse: bad Unicode escape +SyntaxError: JSON.parse: bad escape character +SyntaxError: JSON.parse: unterminated string +SyntaxError: JSON.parse: no number after minus sign +SyntaxError: JSON.parse: unexpected non-digit +SyntaxError: JSON.parse: missing digits after decimal point +SyntaxError: JSON.parse: unterminated fractional number +SyntaxError: JSON.parse: missing digits after exponent indicator +SyntaxError: JSON.parse: missing digits after exponent sign +SyntaxError: JSON.parse: exponent part is missing a number +SyntaxError: JSON.parse: unexpected end of data +SyntaxError: JSON.parse: unexpected keyword +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: end of data while reading object contents +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: end of data when ',' or ']' was expected +SyntaxError: JSON.parse: expected ',' or ']' after array element +SyntaxError: JSON.parse: end of data when property name was expected +SyntaxError: JSON.parse: expected double-quoted property name +SyntaxError: JSON.parse: end of data after property name when ':' was expected +SyntaxError: JSON.parse: expected ':' after property name in object +SyntaxError: JSON.parse: end of data after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property value in object +SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal +SyntaxError: JSON.parse: property names must be double-quoted strings +SyntaxError: JSON.parse: expected property name or '}' +SyntaxError: JSON.parse: unexpected character +SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_ocorreu_de_errado">O que ocorreu de errado?</h2> + +<p>{{jsxref("JSON.parse()")}} converte uma string para JSON. A string precisa ser um JSON válido e retornará esse erro caso a sintaxe esteja errada.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="JSON.parse()_não_permite_vírgulas_à_direita"><code>JSON.parse()</code> não permite vírgulas à direita</h3> + +<p>As duas linhas retornarão um SyntaxError:</p> + +<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4,]'); +JSON.parse('{"foo": 1,}'); +// SyntaxError JSON.parse: unexpected character +// at line 1 column 14 of the JSON data +</pre> + +<p>Retire as virgulas sobrando para converter o JSON corretamente:</p> + +<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4]'); +JSON.parse('{"foo": 1}');</pre> + +<h3 id="Propriedades_precisão_ser_escritas_com_aspas_duplas">Propriedades precisão ser escritas com aspas duplas</h3> + +<p>Você não pode usar aspas simples em propriedades, exemplo: 'foo'.</p> + +<pre class="brush: js example-bad">JSON.parse("{'foo': 1}"); +// SyntaxError: JSON.parse: expected property name or '}' +// at line 1 column 2 of the JSON data</pre> + +<p>Em vez disso use "foo":</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}');</pre> + +<h3 id="Zeros_à_esquerda_e_pontos_decimais">Zeros à esquerda e pontos decimais</h3> + +<p>Você não pode usar zeros à esquerda, como 01, e pontos decimais precisam ser seguidos de pelo menos um digito.</p> + +<pre class="brush: js example-bad">JSON.parse('{"foo": 01}'); +// SyntaxError: JSON.parse: expected ',' or '}' after property value +// in object at line 1 column 2 of the JSON data + +JSON.parse('{"foo": 1.}'); +// SyntaxError: JSON.parse: unterminated fractional number +// at line 1 column 2 of the JSON data +</pre> + +<p>Em vez disso, use o 1 sem o zero, e pelo menos um digito após um ponto decimal:</p> + +<pre class="brush: js example-good">JSON.parse('{"foo": 1}'); +JSON.parse('{"foo": 1.0}'); +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("JSON")}}</li> + <li>{{jsxref("JSON.parse()")}}</li> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html b/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html new file mode 100644 index 0000000000..f235891169 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html @@ -0,0 +1,72 @@ +--- +title: 'Erro de Sintaxe: faltando : depois da propriedade id' +slug: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id +translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: missing : after property id +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Ao criar objetos com a sintaxe do <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">iniciador do objeto</a>, dois pontos (<code>:</code>) separam chaves e valores para as propriedades do objeto.</p> + +<pre class="brush: js">var obj = { propertyKey: 'value' }; +</pre> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Dois-pontos_contra_sinal_de_igualdade">Dois-pontos contra sinal de igualdade</h3> + +<p>Este código falha, pois o sinal de igualdade não pode ser usado dessa maneira nesta sintaxe do iniciador do objeto.</p> + +<pre class="brush: js example-bad">var obj = { propertyKey = 'value' }; +// SyntaxError: missing : after property id +</pre> + +<p>Correto seria usar um dois-pontos, ou usar colchetes para atribuir uma nova propriedade depois que o objeto já foi criado.</p> + +<pre class="brush: js example-good">var obj = { propertyKey: 'value' }; + +// or alternatively + +var obj = { }; +obj['propertyKey'] = 'value'; +</pre> + +<h3 id="Propriedades_vazia">Propriedades vazia</h3> + +<p>Você não pode criar propriedades vazias como esta:</p> + +<pre class="brush: js example-bad">var obj = { propertyKey; }; +// SyntaxError: missing : after property id +</pre> + +<p>Se você precisa definir uma propriedade sem um valor, você pode usar {{jsxref("null")}} como um valor.</p> + +<pre class="brush: js example-good">var obj = { propertyKey: null };</pre> + +<h3 id="Propriedades_computadas">Propriedades computadas</h3> + +<p>Se você criar uma chave de propriedade de uma expressão, você precisa usar colchetes. Caso contrário, o nome da propriedade não pode ser computado:</p> + +<pre class="brush: js example-bad">var obj = { 'b'+'ar': 'foo' }; +// SyntaxError: missing : after property id +</pre> + +<p>Coloque a expressão entre parênteses <code>[]</code>:</p> + +<pre class="brush: js example-good">var obj = { ['b'+'ar']: 'foo' };</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicializador de objeto</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html b/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html new file mode 100644 index 0000000000..b35ba4dfdf --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html @@ -0,0 +1,67 @@ +--- +title: 'SyntaxError: missing } after function body' +slug: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body +tags: + - PT +translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>The JavaScript exception "missing } after function body" occurs when there is a syntax mistake when creating a function somewhere. Check if any closing curly brackets or parenthesis are in the correct order.</p> + +<h2 id="Message">Message</h2> + +<pre class="syntaxbox notranslate">SyntaxError: Expected '}' (Edge) +SyntaxError: missing } after function body (Firefox) +</pre> + +<h2 id="Error_type">Error type</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="What_went_wrong">What went wrong?</h2> + +<p>There is a syntax mistake when creating a function somewhere. Also check if any closing curly brackets or parenthesis are in the correct order. Indenting or formatting the code a bit nicer might also help you to see through the jungle.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Forgotten_closing_curly_bracket">Forgotten closing curly bracket</h3> + +<p>Oftentimes, there is a missing curly bracket in your function code:</p> + +<pre class="brush: js example-bad notranslate">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); +}; +</pre> + +<p>Correct would be:</p> + +<pre class="brush: js example-good notranslate">var charge = function() { + if (sunny) { + useSolarCells(); + } else { + promptBikeRide(); + } +};</pre> + +<p>It can be more obscure when using <a href="/en-US/docs/Glossary/IIFE">IIFE</a>, <a href="/en-US/docs/Web/JavaScript/Closures">Closures</a>, or other constructs that use a lot of different parenthesis and curly brackets, for example.</p> + +<pre class="brush: js example-bad notranslate">(function() { if (true) { return false; } ); +</pre> + +<p>Oftentimes, indenting differently or double checking indentation helps to spot these errors.</p> + +<pre class="brush: js example-good notranslate">(function() { + if (true) { + return false; + } +});</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Functions</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html b/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html new file mode 100644 index 0000000000..cedc5bb71a --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html @@ -0,0 +1,80 @@ +--- +title: 'SyntaxError: missing formal parameter' +slug: Web/JavaScript/Reference/Errors/Missing_formal_parameter +tags: + - Erro + - Erros + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: missing formal parameter (Firefox) +</pre> + +<h2 id="Tipo_de_error">Tipo de error</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>"Parâmetro Formal" é uma maneira elegante de dizer "parâmetro de função". Faltam parâmetros válidos em sua função. Na declaração de uma função os parâmetros devem ser {{Glossary("Identifier", "identifiers")}}, em vez de um valor como números, strings ou objetos. Declarar funções e chamar funções são dois passos diferentes. Declarações exigem identificadores como parâmetros e é apenas ao chamar (invocar) a função que você fornece os valores que a função deve usar.</p> + +<p>Em {{glossary("JavaScript")}}, identificadores podem obter apenas caracteres alfanuméricos (ou "$" e "_"), e não podem começar com um número. Um identificador difere de uma <strong>string</strong> porque uma string é um dado, enquanto que um identificador é parte do código.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Parâmetros de função devem ser identificadores ao se configurar uma função. Todas essas declarações de função abaixo falham, pois estão fornecendo valores para seus parâmetros:</p> + +<pre class="brush: js example-bad highlight:[1,6,11]">function quadrado(3) { + return numero * numero; +}; +// SyntaxError: missing formal parameter + +function saudacao("Olá") { + return saudacao; +}; +// SyntaxError: missing formal parameter + +function log({ obj: "valor"}) { + console.log(arg) +}; +// SyntaxError: missing formal parameter +</pre> + +<p>Você terá de usar identificadores nas declarações de função:</p> + +<pre class="brush: js example-good highlight:[1,5,9]">function quadrado(numero) { + return numero * numero; +}; + +function saudar(saudacao) { + return saudacao; +}; + +function log(arg) { + console.log(arg) +};</pre> + +<p>You can then call these functions with the arguments you like:</p> + +<pre class="brush: js">quadrado(2); // 4 + +saudar("Olá"); // "Olá" + +log({obj: "valor"}); // Object { obj: "valor" } +</pre> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>Outros erros referentes a parâmetros formais: + <ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter">SyntaxError: Parâmetro formal mal formado</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter">SyntaxError: redeclaração de parâmetro formal "x"</a></li> + </ul> + </li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html b/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html new file mode 100644 index 0000000000..b44ca2aae6 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html @@ -0,0 +1,63 @@ +--- +title: 'SyntaxError: missing ; before statement' +slug: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement +translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Messagem">Messagem</h2> + +<pre class="syntaxbox">SyntaxError: falta ; antes da declaração +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Falta um ponto-e-vírgula (<code>;</code>) em algum lugar. <a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript statements</a> must be terminated with semicolons. Some of them are affected by <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">automatic semicolon insertion (ASI)</a>, but in this case you need to provide a semicolon, so that JavaScript can parse the source code correctly.</p> + +<p>However, oftentimes, this error is only a consequence of another error, like not escaping strings properly, or using <code>var</code> wrongly. You might also have too many parenthesis somewhere. Carefully check the syntax when this error is thrown.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Unescaped_strings">Unescaped strings</h3> + +<p>This error can occur easily when not escaping strings properly and the JavaScript engine is expecting the end of your string already. For example:</p> + +<pre class="brush: js example-bad">var foo = 'Tom's bar'; +// SyntaxError: missing ; before statement</pre> + +<p>You can use double quotes, or escape the apostrophe:</p> + +<pre class="brush: js example-good">var foo = "Tom's bar"; +var foo = 'Tom\'s bar'; +</pre> + +<h3 id="Declaring_properties_with_var">Declaring properties with var</h3> + +<p>You <strong>cannot</strong> declare properties of an object or array with a <code>var</code> declaration.</p> + +<pre class="brush: js example-bad">var obj = {}; +var obj.foo = 'hi'; // SyntaxError missing ; before statement + +var array = []; +var array[0] = 'there'; // SyntaxError missing ; before statement +</pre> + +<p>Instead, omit the <code>var</code> keyword:</p> + +<pre class="brush: js example-good">var obj = {}; +obj.foo = 'hi'; + +var array = []; +array[0] = 'there'; +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">Automatic semicolon insertion (ASI)</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript statements</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html b/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html new file mode 100644 index 0000000000..599e7e1271 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html @@ -0,0 +1,45 @@ +--- +title: 'RangeError: repeat count must be non-negative' +slug: Web/JavaScript/Reference/Errors/Negative_repetition_count +tags: + - Erros + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">RangeError: argument out of range +RangeError: repeat count must be non-negative (Firefox) +RangeError: Invalid count value (Chrome) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="O_que_está_errado">O que está errado?</h2> + +<p>O método {{jsxref("String.prototype.repeat()")}} foi usado. Ele tem um parâmetro <code>count</code> indicando o número de vezes para repetir a string. Esse contador deve ser maior ou igual à 0 menor que {{jsxref("Infinity")}} (infinito positivo). O intervalo de vaores permitidos pode ser descrito por: [0, +∞).</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Errado">Errado</h3> + +<pre class="brush: js example-bad">'abc'.repeat(-1); // RangeError </pre> + +<h3 id="Certo">Certo</h3> + +<pre class="brush: js example-good">'abc'.repeat(0); // '' +'abc'.repeat(1); // 'abc' +'abc'.repeat(2); // 'abcabc' +'abc'.repeat(3.5); // 'abcabcabc' (count será convertido para inteiro) +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.prototype.repeat()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html b/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html new file mode 100644 index 0000000000..5e192a15a2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html @@ -0,0 +1,79 @@ +--- +title: 'SyntaxError: missing variable name' +slug: Web/JavaScript/Reference/Errors/No_variable_name +translation_of: Web/JavaScript/Reference/Errors/No_variable_name +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: missing variable name (Firefox) +SyntaxError: Unexpected token = (Chrome)</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>O nome de uma variável está faltando. Isto é provavelmente devido a um erro de sintaxe no seu código. Provavelmente uma vírgula está errada em algum lugar. Totalmente compreensível! Nomear as coisas é tão difícil.</p> + +<h2 id="Examplos">Examplos</h2> + +<h3 id="Falta_um_nome_de_variável">Falta um nome de variável</h3> + +<pre class="brush: js example-bad">var = "foo"; +</pre> + +<p>É difícil chegar com bons nomes de variáveis. Nós todos estivemos lá.</p> + +<pre class="brush: js example-good">var ohGodWhy = "foo";</pre> + +<h3 id="Palavras-chave_reservadas_não_podem_ser_nomes_de_variáveis">Palavras-chave reservadas não podem ser nomes de variáveis</h3> + +<p>Existem alguns nomes de variáveis que são palavras-chave resevadas. Você não pode usar isso. Desculpa :(</p> + +<pre class="brush: js example-bad">var debugger = "whoop"; +// SyntaxError: missing variable name +</pre> + +<h3 id="Declarando_múltiplas_variáveis">Declarando múltiplas variáveis</h3> + +<p>Preste especial atenção às vírgulas ao declarar múltiplas variáveis. Existe um excesso de vírgula? Você acidentalmente adicionou vírgulas em vez de ponto e vírgula?</p> + +<pre class="brush: js example-bad">var x, y = "foo", +var x, = "foo" + +var first = document.getElementById('one'), +var second = document.getElementById('two'), + +// SyntaxError: missing variable name +</pre> + +<p>A versão corrigida:</p> + +<pre class="brush: js example-good">var x, y = "foo"; +var x = "foo"; + +var first = document.getElementById('one'); +var second = document.getElementById('two');</pre> + +<h3 id="Arrays">Arrays</h3> + +<p>{{jsxref("Array")}} literais em JavaScript precisam de colchetes ao redor dos valores. Isso não funcionará:</p> + +<pre class="brush: js example-bad">var arr = 1,2,3,4,5; +// SyntaxError: missing variable name +</pre> + +<p>Isso seria correto:</p> + +<pre class="brush: js example-good">var arr = [1,2,3,4,5];</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>Bons nomes de variáveis</li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> + <li>Declarações de variáveis no Guia JavaScript</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html b/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html new file mode 100644 index 0000000000..7e0c85bf8d --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html @@ -0,0 +1,56 @@ +--- +title: 'RangeError: argument is not a valid code point' +slug: Web/JavaScript/Reference/Errors/Not_a_codepoint +tags: + - Erros + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">RangeError: Invalid code point {0} (Edge) +RangeError: {0} is not a valid code point (Firefox) +RangeError: Invalid code point {0} (Chrome) +</pre> + + + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="O_que_está_errado">O que está errado?</h2> + +<p><span class="seoSummary">{{jsxref("String.fromCodePoint()")}} dispara esse erro quando são passados valores {{jsxref("NaN")}}, inteiros negativos (-1), não inteiros (5.4), ou valores maiores que 0x10FFFF (1114111).</span></p> + +<p>Um <a href="https://pt.wikipedia.org/wiki/Ponto_de_c%C3%B3digo">code point</a> é um valor Unicode; isto é,é um valor inteiro entre <code>0</code> e <code>0x10FFFF</code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Errado">Errado</h3> + +<pre class="brush: js example-bad">String.fromCodePoint('_'); // RangeError +String.fromCodePoint(Infinity); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError</pre> + +<h3 id="Certo">Certo</h3> + +<pre class="brush: js example-good">String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" +String.fromCodePoint(0x2F804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07" +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String.fromCodePoint()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/not_a_function/index.html b/files/pt-br/web/javascript/reference/errors/not_a_function/index.html new file mode 100644 index 0000000000..c98e500583 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/not_a_function/index.html @@ -0,0 +1,123 @@ +--- +title: 'TypeError: "x" is not a function' +slug: Web/JavaScript/Reference/Errors/Not_a_function +tags: + - Erros JavaScrip TypeError +translation_of: Web/JavaScript/Reference/Errors/Not_a_function +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">TypeError: Object doesn't support property or method {x} (Edge) +TypeError: "x" is not a function +</pre> + +<h2 id="Tipo_do_erro">Tipo do erro</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Houve a tentativa de obter um valor de uma função, mas o valor não é exatamente uma função. Algum código espera que você forneça uma função, mas não foi o que acontenceu.</p> + +<p>Talvez exista um erro de digitação no nome da função? Talvez o objeto no qual você está chamando o método não tenha essa função? Por exemplo, objetos no JavaScript não tem a função <code>map</code>, mas o objeto Array tem.</p> + +<p>Existem várias funções internas que precisam de uma função (callback). Você terá que prover uma função para obter esses métodos funcionando corretamente:</p> + +<ul> + <li>Quando estiver trabalhando com os objetos {{jsxref("Array")}} ou {{jsxref("TypedArray")}}: + <ul> + <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}}, {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li> + </ul> + </li> + <li>Quando estiver trabalhando com os objetos {{jsxref("Map")}} ou {{jsxref("Set")}}: + <ul> + <li>{{jsxref("Map.prototype.forEach()")}} e {{jsxref("Set.prototype.forEach()")}}</li> + </ul> + </li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Um_erro_de_digitação_no_nome_da_função">Um erro de digitação no nome da função</h3> + +<p>Nesse caso, que ocorre com bastante frequência, existe um erro de digitação no nome do método:</p> + +<pre class="brush: js example-bad">var x = document.getElementByID('foo'); +// TypeError: document.getElementByID is not a function +</pre> + +<p>O nome correto da função é <code>getElementByI<strong>d</strong></code>:</p> + +<pre class="brush: js example-good">var x = document.getElementById('foo'); +</pre> + +<h3 id="Função_chamada_no_objeto_errado">Função chamada no objeto errado</h3> + +<p>Para alguns métodos, é necessário fornecer a função (callback) que irá funcionar apenas em objetos específicos. Nesse exemplo, é utilizado {{jsxref("Array.prototype.map()")}} que irá funcionar apenas em objetos {{jsxref("Array")}}.</p> + +<pre class="brush: js example-bad">var obj = {a: 13, b: 37, c: 42}; + +obj.map(function(num) { + return num * 2; +}); + +// TypeError: obj.map is not a function</pre> + +<p>Ao invés disso, use uma array:</p> + +<pre class="brush: js example-good">var numbers = [1, 4, 9]; + +numbers.map(function(num) { + return num * 2; +}); + +// Array [2, 8, 18] +</pre> + +<h3 id="Função_compartilha_o_nome_com_uma_propriedade_pré-existente">Função compartilha o nome com uma propriedade pré-existente</h3> + +<p>Algumas vezes, ao criar uma classe, pode haver uma propriedade e função com os mesmos nomes. Ao chamar a função, o compilador não consegue identificar a função.</p> + +<pre class="brush: js example-bad">var Dog = function () { + this.age = 11; + this.color = "black"; + this.name = "Ralph"; + return this; +} + +Dog.prototype.name = function(name) { + this.name = name; + return this; +} + + +var myNewDog = new Dog(); +myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function +</pre> + +<p>Então, use um nome diferente para a propriedade</p> + +<pre class="brush: js example-good">var Dog = function () { + this.age = 11; + this.color = "black"; + this.dogName = "Ralph"; //Using this.dogName instead of .name + return this; +} + +Dog.prototype.name = function(name) { + this.dogName = name; + return this; +} + + +var myNewDog = new Dog(); +myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' } +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Funções</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/não_definido/index.html b/files/pt-br/web/javascript/reference/errors/não_definido/index.html new file mode 100644 index 0000000000..6642b81b44 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/não_definido/index.html @@ -0,0 +1,66 @@ +--- +title: 'ReferenceError: "x" não está definido' +slug: Web/JavaScript/Reference/Errors/Não_definido +translation_of: Web/JavaScript/Reference/Errors/Not_defined +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">ReferenceError: "x" is not defined +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("ReferenceError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Há uma variavel inexistente referenciada em algum lugar. Essa variável precisa ser declarada ou você precisa ter certeza que ela está disponível no seu atual script ou {{Glossary("escopo")}}.</p> + +<div class="note"> +<p><strong>Nota:</strong> Quando carregar uma biblioteca (como o JQuery) tenha certeza que ela está carregada antes que você acesse as variáveis dela, como "$". Coloque na tag {{HTMLElement("script")}} para carregar a biblioteca antes do seu código usá-lo.</p> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Variável_não_declarada">Variável não declarada</h3> + +<pre class="brush: js example-bad">foo.substring(1); // ReferenceError: foo is not defined +</pre> + +<p>A variável "foo" não está definida em lugar nenhum. Ela precisa ser uma string e assim o método {{jsxref("String.prototype.substring()")}} irá funcionar.</p> + +<pre class="brush: js example-good">var foo = "bar"; +foo.substring(1); // "ar"</pre> + +<h3 id="Escopo_Errado">Escopo Errado</h3> + +<p><span style='font-family: "Calibri",sans-serif; font-size: 11.0pt; line-height: 107%;'>Uma variável precisa estar disponível no atual contexto de execução. Variáveis definidas dentro de uma </span> <a href="/en-US/docs/Web/JavaScript/Reference/Functions">function</a> <span style='font-family: "Calibri",sans-serif; font-size: 11.0pt; line-height: 107%;'>não podem ser acessadas de outros lugares fora da função, porque a variável é definida apenas no escopo da função</span></p> + +<pre class="brush: js example-bad">function numbers () { + var num1 = 2, + num2 = 3; + return num1 + num2; +} + +console.log(num1); // ReferenceError num1 is not defined.</pre> + +<p>Entretanto, uma função pode acessar todas as variáveis e funções definidas dentro do escopo no qual elas estão definidas. Em outras palavras, uma função definida no escopo global pode acessar todas as variáveis no escopo global.</p> + +<pre class="brush: js example-good">var num1 = 2, + num2 = 3; + +function numbers () { + return num1 + num2; +} + +console.log(num1); // 2</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{Glossary("Scope")}}</li> + <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals">Declarando variáveis no JavaScript</a></li> + <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Fun%C3%A7%C3%B5es">Escopo de função no JavaScript</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html b/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html new file mode 100644 index 0000000000..6f01588059 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html @@ -0,0 +1,116 @@ +--- +title: 'Erro de sintaxe: declaração de função requer um nome' +slug: Web/JavaScript/Reference/Errors/NãoNomeado_funcão_declaração +tags: + - Erro + - Erro de Sintaxe + - JavaScript + - Statement +translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Errodesintaxe: Identificador Esperado(Edge) +Errodesintaxe: declaração de função requer um nome [Firefox] +Errodesintaxe: Token inesperado ( [Chrome] +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("Errodesintaxe")}}</p> + +<h2 id="O_que_estava_errado">O que estava errado?</h2> + +<p>Existe uma declaração no código que requer um nome. Você precisa checar como as funções são definidas e se você precisa providenciar um nome, se a função em questão precisa ser uma expressão de função, um {{Glossary("IIFE")}} ou se o código da função está colocado corretamente neste contexto.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Statements_vs_expressions">Statements vs expressions</h3> + +<p>Uma <em>declaração de função</em> (ou <em>declaração de função</em>) requer um nome, isso não vai funcionar:</p> + +<pre class="brush: js example-bad">function () { + return 'Olha mundo'; +} +// SyntaxError: function statement requires a name +</pre> + +<p>Você pode usar uma expressão de função ao invés de uma atribuição.</p> + +<pre class="brush: js example-good">var saudar = function() { + return 'Ola mundo'; +};</pre> + +<p>Ou, sua função pode ser pretendida a ser uma <a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">IIFE</a> (Immediately Invoked Function Expression), qual é uma função que será em breve definida. Você vai precisar de um pouco mais de colchetes neste caso:</p> + +<pre class="brush: js example-good">(function () { + +})();</pre> + +<h3 id="Funçoes_etiquetadas">Funçoes etiquetadas</h3> + +<p>Se usar <a href="/en-US/docs/Web/JavaScript/Reference/Statements/label">labels</a>, precisará providenciar um nome de função depois da palavra <code>function</code> . Isto não funciona:</p> + +<pre class="brush: js example-bad">function Saudacao() { + alemao: function () { + return "Moin"; + } +} +// SyntaxError: a função declaração requer um nome +</pre> + +<p>Isso funciona ,veja o exemplo:</p> + +<pre class="brush: js example-good">function Saudacao() { + alemao: function g() { + return "Moin"; + } +}</pre> + +<h3 id="Métodos_de_Objetos">Métodos de Objetos</h3> + +<p>Se pretende criar um metodo para um objeto, voce precisa-rá criar um objeto (hehehe). A seguir uma sintaxe sem nome depois de <code>function</code> é válida.</p> + +<pre class="brush: js example-good">var saudacao = { + alemao: function () { + return "Moin"; + } +};</pre> + +<h3 id="Callback_Sintaxe">Callback Sintaxe</h3> + +<p>Alem disso,cheque sua sintaxe usando callbacks. Colchetes e virgulas ficam facilmente atrapalhar e dificultar.</p> + +<pre class="brush: js example-bad">promessa.then( + function() { + console.log("sucesso"); + }); + function() { + console.log("erro"); +} +// SyntaxError: function statement requires a name +</pre> + +<p>O correto seria:</p> + +<pre class="brush: json example-good">promise.then( + function() { + console.log("success"); + }, + function() { + console.log("error"); + } +);//sempre que abrir feche(); +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Functions">Guia de funções em JavaScript</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">Funções de Declaração</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">Funções de Expressão</a></li> + <li><a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">Funções imediatas (IIFE)</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/label">Etiqueta</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/precision_range/index.html b/files/pt-br/web/javascript/reference/errors/precision_range/index.html new file mode 100644 index 0000000000..b45da23806 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/precision_range/index.html @@ -0,0 +1,101 @@ +--- +title: 'RangeError: precision is out of range' +slug: Web/JavaScript/Reference/Errors/Precision_range +tags: + - Erro + - Erros + - JavaScript + - RangeError +translation_of: Web/JavaScript/Reference/Errors/Precision_range +--- +<div>{{jsSidebar("Errors")}}</div> + +<p>A exceção JavaScript "precision is out of range" (precisão fora de alcance) ocorre quando um número que está fora do intervalo que vai de 0 à 20 (ou 21) foi passado para <code>toFixed</code> ou <code>toPrecision</code>.</p> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">RangeError: The number of fractional digits is out of range (Edge) +RangeError: The precision is out of range (Edge) +RangeError: precision {0} out of range (Firefox) +RangeError: toExponential() argument must be between 0 and 20 (Chrome) +RangeError: toFixed() digits argument must be between 0 and 20 (Chrome) +RangeError: toPrecision() argument must be between 1 and 21 (Chrome) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("RangeError")}}</p> + +<h2 id="O_que_houve_de_errado">O que houve de errado?</h2> + +<p>Existe um argumento de precisão fora do intervalo em um desses métodos:</p> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> + +<p>Po padrão, o intervalo permitido para os métodos acima é de 0 à 20 (ou 21). Todavia, a especificação ECMAScript nos permite extender o intervalo.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Método</th> + <th scope="col">Firefox (SpiderMonkey)</th> + <th scope="col">Chrome, Opera (V8)</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{jsxref("Number.prototype.toExponential()")}}</td> + <td>0 to 100</td> + <td>0 to 20</td> + </tr> + <tr> + <td>{{jsxref("Number.prototype.toFixed()")}}</td> + <td>-20 to 100</td> + <td>0 to 20</td> + </tr> + <tr> + <td>{{jsxref("Number.prototype.toPrecision()")}}</td> + <td>1 to 100</td> + <td>1 to 21</td> + </tr> + </tbody> +</table> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<pre class="brush: js example-bad">77.1234.toExponential(-1); // RangeError +77.1234.toExponential(101); // RangeError + +2.34.toFixed(-100); // RangeError +2.34.toFixed(1001); // RangeError + +1234.5.toPrecision(-1); // RangeError +1234.5.toPrecision(101); // RangeError +</pre> + +<h3 id="Casos_válidos">Casos válidos</h3> + +<pre class="brush: js example-good">77.1234.toExponential(4); // 7.7123e+1 +77.1234.toExponential(2); // 7.71e+1 + +2.34.toFixed(1); // 2.3 +2.35.toFixed(1); // 2.4 (perceba que ele foi arredondado nesse caso) + +5.123456.toPrecision(5); // 5.1235 +5.123456.toPrecision(2); // 5.1 +5.123456.toPrecision(1); // 5 +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html b/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html new file mode 100644 index 0000000000..01bcf0009b --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html @@ -0,0 +1,42 @@ +--- +title: 'Error: Permission denied to access property "x"' +slug: Web/JavaScript/Reference/Errors/Property_access_denied +translation_of: Web/JavaScript/Reference/Errors/Property_access_denied +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Error: Permission denied to access property "x" +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("Error")}}.</p> + +<h2 id="O_que_houve_de_errado">O que houve de errado?</h2> + +<p><span class="seoSummary">Tentativa de acessar um objeto no qual você não possui permissões. Provavelmente um {{HTMLElement("iframe")}} carregado de um dominio diferente no qual foi violado o <a href="/en-US/docs/Web/Security/Same-origin_policy">same-origin policy</a>.</span></p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: html"><!DOCTYPE html> +<html> + <head> + <iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"></iframe> + <script> + onload = function() { + console.log(frames[0].document); + // Error: Permission denied to access property "document" + } + </script> + </head> + <body></body> +</html></pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{HTMLElement("iframe")}}</li> + <li><a href="/en-US/docs/Web/Security/Same-origin_policy">Same-origin policy</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/read-only/index.html b/files/pt-br/web/javascript/reference/errors/read-only/index.html new file mode 100644 index 0000000000..fa7770fbcf --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/read-only/index.html @@ -0,0 +1,81 @@ +--- +title: 'TypeError: "x" is read-only' +slug: Web/JavaScript/Reference/Errors/Read-only +tags: + - Erros + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Read-only +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">TypeError: "x" is read-only (Firefox) +TypeError: 0 is read-only (Firefox) +TypeError: Cannot assign to read only property 'x' of #<Object> (Chrome) +TypeError: Cannot assign to read only property '0' of [object Array] (Chrome) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>A variável global ou propriedade do objeto foi definida como propriedade somente-leitura. (Tecnicamente, esse é um dado de <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Writable_attribute">não-escrita</a>.)</p> + +<p>Esse erro ocorre apenas em código no <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>. No modo não strict mode, essa atribuição é ignorada silenciosamente.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<p>Propriedades somente-leitura não são super comuns, mas elas podem ser criadas utilizando {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}.</p> + +<pre class="brush: js example-bad">'use strict'; +var obj = Object.freeze({nome: 'Elsa', pontuacao: 157}); +obj.pontuacao = 0; // TypeError + +'use strict'; +Object.defineProperty(this, 'CONTADOR_PULMAO', {value: 2, writable: false}); +CONTADOR_PULMAO = 3; // TypeError + +'use strict'; +var frozenArray = Object.freeze([0, 1, 2]); +frozenArray[0]++; // TypeError +</pre> + +<p>Existem também algumas propriedades somente-leitura nativas do Javascript. Talvez você já tentou redefinir um constante matemática.</p> + +<pre class="brush: js example-bad">'use strict'; +Math.PI = 4; // TypeError +</pre> + +<p>Desculpe, você não pode fazer isso.</p> + +<p>A variável global <code>undefined</code> também é somente-leitura, então você não pode silenciar o infame erro "undefined is not a function" fazendo isso:</p> + +<pre class="brush: js example-bad">'use strict'; +undefined = function() {}; // TypeError: "undefined" is read-only +</pre> + +<h3 id="Casos_válidos">Casos válidos</h3> + +<pre class="brush: js example-good">'use strict'; +var obj = Object.freeze({nome: 'Score', pontos: 157}); +obj = {nome: obj.nome, pontos: 0}; // substituindo com o novo objeto funciona + +'use strict'; +var CONTADOR_PULMAO = 2; // uma `var` funciona, porque ela não é somente-leitura +CONTADOR_PULMAO = 3; // ok (anatomicamente improvável, porém...) +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li><a href="https://www.answers.com/Q/Which_animals_have_three_lungs">"Quais animais tem três pulmões?" no answers.com</a></li> + <li><a href="https://aliens.wikia.com/wiki/Klingon">Klingons</a> (uma outra resposta para essa pergunta)</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html b/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html new file mode 100644 index 0000000000..901557d13b --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html @@ -0,0 +1,60 @@ +--- +title: 'SyntaxError: redeclaration of formal parameter "x"' +slug: Web/JavaScript/Reference/Errors/Redeclared_parameter +tags: + - Erros +translation_of: Web/JavaScript/Reference/Errors/Redeclared_parameter +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: Let/Const redeclaration (Edge) +SyntaxError: redeclaration of formal parameter "x" (Firefox) +SyntaxError: Identifier "x" has already been declared (Chrome) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>O mesmo nome de variável ocorre como parâmetro da função e é então redeclarada atribuindo <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code> no corpo da função. Redeclarando a mesma variável dentro da mesma função ou no escopo do bloco usando <code>let</code> não é permitido em JavaScript.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Neste caso, a variável "arg" redeclara o argumento.</p> + +<pre class="brush: js example-bad">function f(arg) { + let arg = 'foo'; +} + +// SyntaxError: redeclaration of formal parameter "arg" +</pre> + +<p>Se você quiser mudar o valor de "arg" no corpo da função, você pode fazer, mas você não precisa declarar novamente a mesma variável. Em outras palavras: você pode omitir a palavra chave <code>let</code>. Se você quiser criar uma nova variável, você precisa renomea-la, pois isso conflita com o parâmetro da função.</p> + +<pre class="brush: js example-good">function f(arg) { + arg = 'foo'; +} + +function f(arg) { + let bar = 'foo'; +} +</pre> + +<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2> + +<ul> + <li>Antes do Firefox 49 {{geckoRelease(49)}}, isto foi lançado como um {{jsxref("TypeError")}} ({{bug(1275240)}}).</li> +</ul> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_Types#Declarations">Declaring variables</a> in the <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html b/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html new file mode 100644 index 0000000000..6c2ad3146a --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html @@ -0,0 +1,74 @@ +--- +title: 'Warning: unreachable code after return statement' +slug: Web/JavaScript/Reference/Errors/Stmt_after_return +translation_of: Web/JavaScript/Reference/Errors/Stmt_after_return +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Warning: unreachable code after return statement (Firefox) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>Warning</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Codigo inacessível depois da declaração de retorno pode ocorrer nas seguintes situações:</p> + +<ul> + <li>Quando usado em uma expressão após a declaração de um {{jsxref("Statements/return", "return")}} , ou</li> + <li>quando usado em uma expressão <strong>return</strong> sem ponto e vírgula porém incluindo uma expressão diretamente depois.</li> +</ul> + +<p>Quando existe uma expressão após uma declaração válida de <code>return, </code>um warning é dado para indicar que o código depois da declaração <code>return</code> é inacessível, significando que ele pode nunca ser executado.</p> + +<p>Porque eu devo usar ponto-e-virgula após declarações <code>return</code>? No caso de declarações <code>return</code> sem ponto-e-vírgula, ele pode deixar obscuro se o desenvolvedor quis usar o return na proxima linha, ou parar a execução e retornar. O warning indica que há uma ambiguidade no modo que a declaração <code>return</code> foi escrita.</p> + +<p>Warnings não serão mostrado para declarações return sem ponto-e-vírgula nas seguintes situações:</p> + +<ul> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/var", "var")}}</li> + <li>{{jsxref("Statements/function", "function")}}</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_Inválidos">Casos Inválidos</h3> + +<pre class="brush: js example-bad">function f() { + var x = 3; + x += 4; + return x; // return exits the function immediately + x -= 3; // so this line will never run; it is unreachable +} + +function f() { + return // this is treated like `return;` + 3 + 4; // so the function returns, and this line is never reached +} +</pre> + +<h3 id="Casos_Válidos">Casos Válidos</h3> + +<pre class="brush: js example-good">function f() { + var x = 3; + x += 4; + x -= 3; + return x; // OK: return after all other statements +} + +function f() { + return 3 + 4 // OK: semicolon-less return with expression on the same line +} +</pre> + +<h2 id="Ver_também">Ver também</h2> + +<ul> + <li>{{jsxref("Statements/return", "Automatic Semicolon Insertion", "#Automatic_Semicolon_Insertion", 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html b/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html new file mode 100644 index 0000000000..26637da662 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html @@ -0,0 +1,66 @@ +--- +title: 'InternalError: too much recursion' +slug: Web/JavaScript/Reference/Errors/Too_much_recursion +translation_of: Web/JavaScript/Reference/Errors/Too_much_recursion +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Error: Out of stack space (Edge) +InternalError: too much recursion (Firefox) +RangeError: Maximum call stack size exceeded (Chrome) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("InternalError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Uma função que invoca a si mesma é chamada <em>função recursiva</em>. Assim que uma condição é atendida, a função para de se invocar. </p> + +<p>De certa forma, recursão é análoga a um loop. Ambos executam o mesmo código múltiplas vezes, e ambos exigem uma condição (para evitar um loop infinito ou, nesse caso, uma recursão infinita). <span class="seoSummary">Quando são feitas excessivas invocações, ou a função não possui uma condição para interromper a recursividade, este erro é lançado.</span></p> + +<h2 id="Exemplos">Exemplos</h2> + +<p>Esta função recursiva roda 10 vezes, como definido pela condição de saída.</p> + +<pre class="brush: js">function loop(x) { + if (x >= 10) // "x >= 10" é a condição de saída + return; + + loop(x + 1); // o código recursivo em si +} +loop(0);</pre> + +<p>Mudar esta condição para um valor extremamente alto não vai funcionar:</p> + +<pre class="brush: js example-bad">function loop(x) { + if (x >= 1000000000000) + return; + + loop(x + 1); +} +loop(0); + +// InternalError: too much recursion</pre> + +<p>A seguinte função recursiva não possui condição de saída. Assim, ela vai continuar se invocando indefinidamente (até que o erro seja lançado e a execução interrom).</p> + +<pre class="brush: js example-bad">function loop(x) { + // Não há condição de saída + +loop(x + 1); // Código recursivo +} + +loop(0); + +// InternalError: too much recursion</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{Glossary("Recursion")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions#Recursion">Funções recursivas</a></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html b/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html new file mode 100644 index 0000000000..a51d080828 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html @@ -0,0 +1,62 @@ +--- +title: 'ReferenceError: Atribuição à variável não declarada "x"' +slug: Web/JavaScript/Reference/Errors/Undeclared_var +translation_of: Web/JavaScript/Reference/Errors/Undeclared_var +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Message">Message</h2> + +<pre class="syntaxbox">ReferenceError: Atribuição à variável não declarada "x"(Firefox) +ReferenceError: "x" não está definido (Chrome) +ReferenceError: Variável indefinida em <em>strict mode</em> (Edge) +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("ReferenceError")}} aviso em <em><a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a></em> somente.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Um valor foi atribuído a uma variável não declarada. Em outras palavras, houve uma atribuição sem a palavra-chave var. Existem algumas diferenças entre as variáveis declaradas e não declaradas, o que pode levar a resultados inesperados e é por isso que o JavaScript apresenta um erro no modo estrito.</p> + +<p>Três coisas a observar sobre as variáveis declaradas e não declaradas:</p> + +<ul> + <li>Variáveis declaradas são limitadas no contexto de execução em que são declarados. Variáveis não declaradas são sempre globais.</li> + <li>Variáveis declaradas são criados antes de qualquer código ser executado. Variáveis não declaradas não existem até que o código atribuido for executado.</li> + <li>Variáveis declaradas são uma propriedade não-configurável de seu contexto de execução (função ou global). Variáveis não declaradas são configuráveis (por exemplo, pode ser excluído).</li> +</ul> + +<p>Para mais exemplos, veja a página de referência <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code>.</p> + +<p>Erros sobre atribuições de variáveis não declaradas ocorrem apenas em <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">código de modo estrito</a>. Em código não-estrito, eles são silenciosamente ignorados.</p> + +<h2 id="Examplos">Examplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<p>neste caso, a variavel "bar" é uma variavel não declarada.</p> + +<pre class="brush: js example-bad">function foo() { + "use strict"; + bar = true; +} +foo(); // ReferenceError: assignment to undeclared variable bar +</pre> + +<h3 id="Casos_válidos">Casos válidos</h3> + +<p>Para fazer uma variável declarada "bar", você pode adicionar a palavra-chave <a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a> na frente dele.</p> + +<pre class="brush: js example-good">function foo() { + "use strict"; + var bar = true; +} +foo();</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><em><a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a></em></li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html b/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html new file mode 100644 index 0000000000..a15985670b --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html @@ -0,0 +1,67 @@ +--- +title: 'ReferenceError: reference to undefined property "x"' +slug: Web/JavaScript/Reference/Errors/Undefined_prop +tags: + - Erros + - JavaScript + - Modo Restrito + - ReferenceError +translation_of: Web/JavaScript/Reference/Errors/Undefined_prop +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">ReferenceError: reference to undefined property "x" (Firefox) +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>(Apenas no Firefox) O aviso {{jsxref("ReferenceError")}} é reportado somente se a preferência <code>javascript.options.strict</code> está definida como <code>true</code>.</p> + +<h2 id="O_que_está_errado">O que está errado?</h2> + +<div class="oSioSc"> +<div id="tw-target"> +<div class="g9WsWb" id="kAz1tf"> +<div class="tw-ta-container tw-nfl" id="tw-target-text-container"> +<p class="tw-data-text tw-text-large tw-ta" dir="ltr" id="tw-target-text" style="text-align: left;"><span lang="pt">O script tentou acessar uma propriedade de objeto que não existe. Existem duas maneiras de acessar propriedades; veja a página de referência {{jsxref ("Operators / Property_Accessors", "property accessors", 0, 1)}} para saber mais sobre eles.</span></p> +</div> +</div> +</div> +</div> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Errado">Errado</h3> + +<p>Neste caso, a propriedade <code>bar</code> é uma propriedade não definida, assim, ocorrerá um <code>ReferenceError</code>.</p> + +<pre class="brush: js example-bad">var foo = {}; +foo.bar; // ReferenceError: reference to undefined property "bar" +</pre> + +<h3 id="Certo">Certo</h3> + +<div class="tw-ta-container tw-nfl" id="tw-target-text-container"> +<p class="tw-data-text tw-text-large tw-ta" dir="ltr" id="tw-target-text" style="text-align: left;"><span lang="pt">Para evitar o erro, você precisa adicionar uma definição de <code>bar</code> ao objeto ou verificar a existência da propriedade <code>bar</code> antes de tentar acessá-la; Uma maneira de fazer isso é usar o método {{jsxref ("Object.prototype.hasOwnProperty ()")}}, desta forma:</span></p> +</div> + +<pre class="brush: js example-good">var foo = {}; + +// Define a propriedade bar + +foo.bar = 'moon'; +console.log(foo.bar); // "moon" + +// Teste para ter certeza se bar existe antes de acessa-lo + +if (foo.hasOwnProperty('bar')) { + console.log(foo.bar); +}</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Operators/Property_Accessors", "property accessors", 0, 1)}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html b/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html new file mode 100644 index 0000000000..7455321080 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html @@ -0,0 +1,51 @@ +--- +title: 'SyntaxError: Unexpected token' +slug: Web/JavaScript/Reference/Errors/Unexpected_token +tags: + - Erro de Sintaxe + - Erros + - JavaScript + - SyntaxError +translation_of: Web/JavaScript/Reference/Errors/Unexpected_token +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: expected expression, got "x" +SyntaxError: expected property name, got "x" +SyntaxError: expected target, got "x" +SyntaxError: expected rest argument name, got "x" +SyntaxError: expected closing parenthesis, got "x" +SyntaxError: expected '=>' after argument list, got "x" +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Uma construção específica da linguagem era esperada, mas algo não foi fornecido. Isto deve ser um simples erro de digitação.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Expressão_esperada">Expressão esperada</h3> + +<p>Por exemplo, quando funções são chamadas, vírgulas sem um valor na sequência não são permitidas. O JavaScript esperarará outro argumento, como pode ser qualquer expressão.</p> + +<pre class="brush: js example-bad">Math.max(2, 42,); +// SyntaxError: expected expression, got ')' +</pre> + +<p>O correto é omitir a vírgula ou adicionar outro argumento:</p> + +<pre class="brush: js example-good">Math.max(2, 42); +Math.max(2, 42, 13 + 37); +</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html b/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html new file mode 100644 index 0000000000..8e05992723 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html @@ -0,0 +1,67 @@ +--- +title: 'TypeError: "x" is (not) "y"' +slug: Web/JavaScript/Reference/Errors/Unexpected_type +tags: + - Erros + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Unexpected_type +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">Tipo do erro: "x" é (não é) "y" + +Exemplos: +Tipo do erro: "x" é indefinido +Tipo do erro: "x" é nulo +Tipo do erro: "x" indefinido" não é um objeto +Tipo do erro: "x" não é um objeto ou é nulo +Tipo do erro: "x" não é um símbolo +</pre> + +<h2 id="Tipo_de_erro">Tipo de erro</h2> + +<p>{{jsxref("TypeError")}}.</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Houve um tipo inesperado. Isso ocorre muitas vezes com valores {{jsxref("undefined")}} ou {{jsxref("null")}}.</p> + +<p>Além disso, certos métodos, tais como {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}}, requerem um tipo específico, que deve ser fornecido.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Casos_inválidos">Casos inválidos</h3> + +<pre class="brush: js example-bad">// casos undefined e null nos quais o método substring não vai funcionar +var foo = undefined; +foo.substring(1); // TypeError: foo is undefined + +var foo = null; +foo.substring(1); // TypeError: foo is null + + +// Certos métodos podem precisar de um tipo específico +var foo = {} +Symbol.keyFor(foo); // TypeError: foo is not a symbol + +var foo = 'bar' +Object.create(foo); // TypeError: "foo" is not an object or null +</pre> + +<h3 id="Consertando_o_problema">Consertando o problema</h3> + +<p>Para consertar o pointeiro nulo para valores <code>undefined</code> ou <code>null</code>, você pode utilizar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a> , por exemplo.</p> + +<pre class="brush: js">if (typeof foo !== 'undefined') { + // Agora nós sabemos que foo está definido, então podemos prosseguir. +}</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("undefined")}}</li> + <li>{{jsxref("null")}}</li> +</ul> diff --git a/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html b/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html new file mode 100644 index 0000000000..831d9842e2 --- /dev/null +++ b/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html @@ -0,0 +1,63 @@ +--- +title: 'SyntaxError: unterminated string literal' +slug: Web/JavaScript/Reference/Errors/Unterminated_string_literal +translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Mensagem">Mensagem</h2> + +<pre class="syntaxbox">SyntaxError: unterminated string literal +</pre> + +<h2 id="Tipo_de_Erro">Tipo de Erro</h2> + +<p>{{jsxref("SyntaxError")}}</p> + +<h2 id="O_que_deu_errado">O que deu errado?</h2> + +<p>Há uma {{jsxref("String")}} não finalizada em algum lugar do código. String literais devem se fechadas com aspas simples (<code>'</code>) ou duplas (<code>"</code>) . O JavaScript não faz distinção entre strings com aspas simples ou aspas duplas. <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#Escape_notation">As sequências de escape </a>trabalham com strings criadas tanto com aspas simples, quanto com aspas duplas. Para consertar este erro, verifique se:</p> + +<ul> + <li>você abriu e fechou sua string literal com aspas (simples ou duplas),</li> + <li>você escapou sua string literal corretamente,</li> + <li>sua string funciona corretamente em várias linhas, se houver.</li> +</ul> + +<h2 id="Exemplos">Exemplos</h2> + +<h3 id="Múltiplas_linhas">Múltiplas linhas</h3> + +<p>Você não pode dividir sua string em múltiplas linhas em Javascript:</p> + +<pre class="brush: js example-bad">var longString = "This is a very long string which needs + to wrap across multiple lines because + otherwise my code is unreadable."; +// SyntaxError: unterminated string literal</pre> + +<p>Ao invés disso, você deve utilizar o operador<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition"> + operator</a>, uma barra invertida(\), ou <a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">modelos literais</a>. Uma forma de uso do operador<code> +, seria assim:</code></p> + +<pre class="brush: js example-good">var longString = "This is a very long string which needs " + + "to wrap across multiple lines because " + + "otherwise my code is unreadable."; +</pre> + +<p>Ou você pode usar uma barra invertida ("\") ao final de cada linha para indicar que a string continuará na próxima linha. Certifique-se de que não há espaço ou qualquer outro caractere após a barra invertida (excento quando for uma quebra de linha), ou como indentação; caso contrário, não funcionará. Esta forma ficaria assim:</p> + +<pre class="brush: js example-good">var longString = "This is a very long string which needs \ +to wrap across multiple lines because \ +otherwise my code is unreadable."; +</pre> + +<p>Uma outra possibilidade é usar um <a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">modelo literal</a>, que é suportado pelos ambientes ECMAScript 2015:</p> + +<pre class="brush: js example-good">var longString = `This is a very long string which needs + to wrap across multiple lines because + otherwise my code is unreadable.`;</pre> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li>{{jsxref("String")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">Modelos literais</a></li> +</ul> |