diff options
Diffstat (limited to 'files/pt-br/orphaned/web')
10 files changed, 1278 insertions, 0 deletions
diff --git a/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html b/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html new file mode 100644 index 0000000000..65fe989377 --- /dev/null +++ b/files/pt-br/orphaned/web/accessibility/jaws_issues_with_firefox/index.html @@ -0,0 +1,11 @@ +--- +title: Problemas com JAWS no Firefox +slug: Web/Acessibilidade/Problemas_com_JAWS_no_Firefox +tags: + - Acessibilidade + - Obsolento +translation_of: Web/Accessibility/JAWS_Issues_with_Firefox +--- +<h2 id="Known_JAWS_Firefox_Issues" name="Known_JAWS_Firefox_Issues">Problemas JAWS Firefox conhecidos</h2> + +<p>Esse artigo não é mais relevante. Por favor, veja o <a class="external" href="http://support.mozilla.com/en-US/kb/Firefox+3+with+Screen+Readers+FAQ" title="http://support.mozilla.com/en-US/kb/Firefox+3+with+Screen+Readers+FAQ">FAQ</a> no site de suporte Mozilla.</p> diff --git a/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html b/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html new file mode 100644 index 0000000000..a05abeae88 --- /dev/null +++ b/files/pt-br/orphaned/web/api/node/entendendo_o_uso_do_método_appendchild-javascript/index.html @@ -0,0 +1,55 @@ +--- +title: Entendendo o uso do método appendChild em javascript +slug: Web/API/Node/Entendendo_o_uso_do_método_AppendChild-javascript +--- +<div>{{ApiRef("DOM")}}</div> + +<h2 id="Summary" name="Summary">Resumo</h2> + +<p>Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.</p> + +<h2 id="Syntax" name="Syntax">Sintaxe</h2> + +<pre class="syntaxbox">var filho = <em>elemento</em>.appendChild(<em>filho</em>);</pre> + +<ul> + <li><code>elemento</code> é o <a href="/pt-BR/docs/DOM/element" title="/en-US/docs/DOM/element">elemento</a> pai.</li> + <li><code>filho</code> é o nó a ser adicionado como filho de <code>elemento</code>. Também é devolvido.</li> +</ul> + +<h2 id="Descrição">Descrição</h2> + +<p>O método <code>appendChild</code> devolve uma referência ao nó adicionado.</p> + +<h2 id="Example" name="Example">Exemplo</h2> + +<pre class="brush:js">// Cria um novo elemento de parágrafo e adiciona-o ao final do documento +var p = document.createElement("p"); +document.body.appendChild(p);</pre> + +<h2 id="Notes" name="Notes">Notas</h2> + +<p>Se <code>filho</code> é uma referência a um nó existente no documento, <code>appendChild</code> vai movê-lo de sua posição atual para a nova posição (i.e, não é necessário remover o nó de seu pai atual antes de adicioná-lo a outro nó).</p> + +<p>Isso também significa que um nó não pode estar em dois lugares do documento ao mesmo tempo. Assim, se o nó já tem um pai, ele é primeiro removido para, <em>só então</em>, ser adicionado na nova posição.</p> + +<p>Você pode usar o método {{domxref("Node.cloneNode")}} para criar uma cópia do nó antes de adicioná-lo ao novo pai. (Note que cópias feitas com o método <code>cloneNode</code> <strong>não </strong>serão mantidas sincronizadas automaticamente)</p> + +<p>Este método não permite mover nós entre documentos diferentes. Se você quiser adicionar um nó de um documento diferente (por exemplo para mostrar o resultado de uma requisição AJAX), você precisa primeiro usar o método {{domxref("document.importNode")}}.</p> + +<p><code>appendChild()</code> é um dos métodos fundamentais da programação para a web usando o DOM. O método <code>appendChild()</code> insere um novo nó na estrutura do DOM de um documento, e é a segunda parte do processo criar-e-adicionar tão importante na construção de páginas web programaticamente.</p> + +<h2 id="Specification" name="Specification">Especificação</h2> + +<ul> + <li><a class="external" href="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-184E7107" title="http://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-184E7107">DOM Level 3 Core: appendChild</a></li> +</ul> + +<h2 id="See_also" name="See_also">Ver também</h2> + +<ul> + <li>{{domxref("Node.removeChild")}}</li> + <li>{{domxref("Node.replaceChild")}}</li> + <li>{{domxref("Node.insertBefore")}}</li> + <li>{{domxref("Node.hasChildNodes")}}</li> +</ul> diff --git a/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html b/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html new file mode 100644 index 0000000000..c2f5f9f4ce --- /dev/null +++ b/files/pt-br/orphaned/web/guide/css/css_media_queries_(consultas_de_mídia_em_css)/index.html @@ -0,0 +1,20 @@ +--- +title: Usando CSS media queries (consultas de mídia em CSS) +slug: Web/Guide/CSS/CSS_media_queries_(consultas_de_mídia_em_CSS) +tags: + - CSS + - Guía + - Iniciante + - media query +--- +<p><span class="seoSummary">Uma media query (consulta de mídia) consiste de um tipo de mídia e de, ao menos, uma expressão que restringe o escopo dos estilos CSS pelo uso de propriedades de mídia, como width (largura), height (altura) e color (cor). Media queries, incluídas na especificação CSS3, permitem que a apresentação do conteúdo se adapte a uma variedade de dispositivos de exibição sem a necessidade de mudar o próprio conteúdo.</span></p> + +<h2 id="Sintaxe">Sintaxe</h2> + +<p>Consultas de mídia consistem em tipos de mídia opcional e podem, de acordo com a especificação CSS3, conter entre nenhuma ou mais expressões, declararadas como propriedades de mídia, que podem conter condições de estado verdadeiras ou falsas. O resultado de uma query (consulta) será verdadeiro se o tipo de mídia especificado nela corresponder ao tipo do dispositivo onde o documento é exibido e todas as expressões contidas na consulta forem verdadeiras.</p> + +<p>Fonte:</p> + +<p><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries">https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries</a></p> + +<p> </p> diff --git a/files/pt-br/orphaned/web/html/element/command/index.html b/files/pt-br/orphaned/web/html/element/command/index.html new file mode 100644 index 0000000000..99a42fb9db --- /dev/null +++ b/files/pt-br/orphaned/web/html/element/command/index.html @@ -0,0 +1,129 @@ +--- +title: command +slug: Web/HTML/Element/command +translation_of: Web/HTML/Element/command +--- +<h2 class="editable" id="Sumário">Sumário</h2> + +<p>O elemento <code>command </code>representa um comando que o usuário pode chamar.</p> + +<h2 id="Contexto_de_uso">Contexto de uso</h2> + +<table class="standard-table"> + <tbody> + <tr> + <td>Categorias de conteúdo</td> + <td><a href="/en/HTML/Content_categories#Flow_content" title="en/HTML/Content categories#Flow content">Flow content</a>, <a href="/en/HTML/Content_categories#Phrasing_content" title="en/HTML/Content categories#Phrasing content">phrasing content</a></td> + </tr> + <tr> + <td>Elementos permitidos</td> + <td>Nenhum, é um elemento vazio.</td> + </tr> + <tr> + <td>Omissão de tag</td> + <td>Deve ter uma tag inicial, mas não deve ter uma tag final.</td> + </tr> + <tr> + <td>Elementos pais permitidos</td> + <td>Qualquer elemento que aceite <a href="/en/HTML/Content_categories#Phrasing_content" title="https://developer.mozilla.org/en/HTML/Content_categories#Phrasing_content">phrasing content</a>.</td> + </tr> + <tr> + <td>Documento normativo</td> + <td><a class="external" href="http://dev.w3.org/html5/spec/Overview.html#the-command" title="http://dev.w3.org/html5/spec/Overview.html#the-command">HTML5, section 4.11.3</a></td> + </tr> + </tbody> +</table> + +<h2 id="Atributos">Atributos</h2> + +<p>Como todos ou outros elementos HTML, esse elemento suporta os <a href="/en/HTML/Global_attributes" title="en/HTML/Global attributes">global attributes</a>.</p> + +<dl> + <dt>{{ htmlattrdef("checked") }}</dt> + <dd>Indica se o comando está selecionado ou não. Deve ser omitido a não ser que o atributo <code>type</code> seja <code>checkbox </code>ou <code>radio</code>.</dd> + <dt>{{ htmlattrdef("disabled") }}</dt> + <dd>Indica que o elemento não está disponível.</dd> + <dt>{{ htmlattrdef("icon") }}</dt> + <dd>Atribui uma figura para representar o comando.</dd> + <dt>{{ htmlattrdef("label") }}</dt> + <dd>O nome do comando, como será mostrado para o usuário.</dd> + <dt>{{ htmlattrdef("radiogroup") }}</dt> + <dd>Esse atributo dá o nome de um grupo de comandos, com <code>type</code> sendo <code>radio</code>, que vai ser ativado quando o comando for ativado. Esse atributo deve ser omitido a não ser que o atributo <code>type</code> seja <code>radio</code>.</dd> + <dt>{{ htmlattrdef("type") }}</dt> + <dd>Esse atributo indica o tipo do comando. Pode ter somente os seguintes valores: + <ul> + <li> + <p><code>command</code> ou vazio que é o estado padrão e indica que é um comando normal.</p> + </li> + <li> + <p><code>checkbox</code> indica que o comando pode ser alternado utilizando uma caixa de seleção.</p> + </li> + <li> + <p><code>radio</code> indica que o comando pode ser alternado utilizando uma radiobutton.</p> + </li> + </ul> + </dd> +</dl> + +<h2 id="Interface_do_DOM">Interface do DOM</h2> + +<p>Esse elemetno implementa a interface <code><a href="/en/DOM/HTMLCommandElement" rel="internal">HTMLCommandElement</a></code>.</p> + +<h2 id="Exemplos">Exemplos</h2> + +<pre class="brush: html"><command type="command" label="Save" icon="icons/save.png" onclick="save()"> +</pre> + +<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Recurso</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suporte básico</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + </tr> + </tbody> +</table> +</div> + +<p> </p> + +<p>{{ languages( { "zh-cn": "zh-cn/HTML/Element/command" } ) }}</p> diff --git a/files/pt-br/orphaned/web/html/favicon/index.html b/files/pt-br/orphaned/web/html/favicon/index.html new file mode 100644 index 0000000000..6b3bef6490 --- /dev/null +++ b/files/pt-br/orphaned/web/html/favicon/index.html @@ -0,0 +1,32 @@ +--- +title: favicon +slug: Web/HTML/favicon +--- +<p> </p> + +<h3 id="sect1"> </h3> + +<h3 id="Comentário_da_revisão">Comentário da revisão <a class="revision-comment-link" href="https://developer.mozilla.org/pt-BR/docs/MDN/Contribute/Editor/Basics#The_revision_comment_box" title="Saiba como usar os comentários da revisão"> </a></h3> + +<section class="wiki-block" id="page-comment"> +<h3 id="sect2"> </h3> + +<p>Diga-nos porque fez adições e alterações. É opcional, mas irá fazer com que o histórico da página seja mais fácil de entender.</p> +<input></section> + +<div class="wiki-block"> +<h3 id="É_necessário_revisão">É necessário revisão?</h3> + +<ul id="id_review_tags"> + <li><label><input> Técnico - exemplos de código, APIs ou tecnologias</label></li> + <li><label><input> Editorial - prosa, gramática, ou conteúdo</label></li> +</ul> +</div> + +<section class="page-tags wiki-block" id="page-tags"> +<h3 id="sect3"> </h3> +</section> + +<h3 id="Tags">Tags</h3> + +<p> </p> diff --git a/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html b/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html new file mode 100644 index 0000000000..cb626865f8 --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/guide/coleções_chaveadas/index.html @@ -0,0 +1,149 @@ +--- +title: Coleções chaveadas +slug: Web/JavaScript/Guide/Coleções_chaveadas +tags: + - Coleções + - Guía + - JavaScript + - Mapas +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</div> + +<p class="summary">This chapter introduces collections of data which are ordered by a key; Map and Set objects contain elements which are iterable in the order of insertion.</p> + +<h2 id="Maps">Maps</h2> + +<h3 id="Map_object"><code>Map</code> object</h3> + +<p>ECMAScript 6 introduces a new data structure to map values to values. A {{jsxref("Map")}} object is a simple key/value map and can iterate its elements in insertion order</p> + +<p>The following code shows some basic operations with a <code>Map</code>. See also the {{jsxref("Map")}} reference page for more examples and the complete API. You can use a {{jsxref("Statements/for...of","for...of")}} loop to return an array of <code>[key, value]</code> for each iteration.</p> + +<pre class="brush: js">var sayings = new Map(); +sayings.set("dog", "woof"); +sayings.set("cat", "meow"); +sayings.set("elephant", "toot"); +sayings.size; // 3 +sayings.get("fox"); // undefined +sayings.has("bird"); // false +sayings.delete("dog"); + +for (var [key, value] of sayings) { + console.log(key + " goes " + value); +} +// "cat goes meow" +// "elephant goes toot" +</pre> + +<h3 id="Object_and_Map_compared"><code>Object</code> and <code>Map</code> compared</h3> + +<p>Traditionally, {{jsxref("Object", "objects", "", 1)}} have been used to map strings to values. Objects allow you to set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. <code>Map</code> objects, however, have a few more advantages that make them better maps.</p> + +<ul> + <li>The keys of an <code>Object</code> are {{jsxref("Global_Objects/String","Strings")}}, where they can be of any value for a <code>Map</code>.</li> + <li>You can get the size of a <code>Map</code> easily while you have to manually keep track of size for an <code>Object</code>.</li> + <li>The iteration of maps is in insertion order of the elements.</li> + <li>An <code>Object</code> has a prototype, so there are default keys in the map. (this can be bypassed using <code>map = Object.create(null)</code>).</li> +</ul> + +<p>These two tips can help you to decide whether to use a <code>Map</code> or an <code>Object</code>:</p> + +<ul> + <li>Use maps over objects when keys are unknown until run time, and when all keys are the same type and all values are the same type.</li> + <li>Use objects when there is logic that operates on individual elements.</li> +</ul> + +<h3 id="WeakMap_object"><code>WeakMap</code> object</h3> + +<p>The {{jsxref("WeakMap")}} object is a collection of key/value pairs in which the <strong>keys are objects only</strong> and the values can be arbitrary values. The object references in the keys are held <em>weakly</em> meaning that they are target of garbage collection (GC) if there is no other reference to the object anymore. The <code>WeakMap</code> API is the same as the <code>Map</code> API.</p> + +<p>One difference to <code>Map</code> objects is that <code>WeakMap</code> keys are not enumerable (i.e. there is no method giving you a list of the keys). If they were, the list would depend on the state of garbage collection, introducing non-determinism.</p> + +<p>For more information and example code, see also "Why <em>Weak</em>Map?" on the {{jsxref("WeakMap")}} reference page.</p> + +<p>One use case of <code>WeakMap</code> objects is to store private data for an object or to hide implementation details. The following example is from Nick Fitzgerald blog post <a href="http://fitzgeraldnick.com/weblog/53/">"Hiding Implementation Details with ECMAScript 6 WeakMaps"</a>. The private data and methods belong inside the object and are stored in the <code>privates</code> WeakMap object. Everything exposed on the instance and prototype is public; everything else is inaccessible from the outside world because <code>privates</code> is not exported from the module</p> + +<pre class="brush: js">const privates = new WeakMap(); + +function Public() { + const me = { + // Private data goes here + }; + privates.set(this, me); +} + +Public.prototype.method = function () { + const me = privates.get(this); + // Do stuff with private data in `me`... +}; + +module.exports = Public; +</pre> + +<h2 id="Sets">Sets</h2> + +<h3 id="Set_object"><code>Set</code> object</h3> + +<p>{{jsxref("Set")}} objects are collections of values. You can iterate its elements in insertion order. A value in a <code>Set</code> may only occur once; it is unique in the <code>Set</code>'s collection.</p> + +<p>The following code shows some basic operations with a <code>Set</code>. See also the {{jsxref("Set")}} reference page for more examples and the complete API.</p> + +<pre class="brush: js">var mySet = new Set(); +mySet.add(1); +mySet.add("some text"); +mySet.add("foo"); + +mySet.has(1); // true +mySet.delete("foo"); +mySet.size; // 2 + +for (let item of mySet) console.log(item); +// 1 +// "some text" +</pre> + +<h3 id="Converting_between_Array_and_Set">Converting between Array and Set</h3> + +<p>You can create an {{jsxref("Array")}} from a Set using {{jsxref("Array.from")}} or the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a>. Also, the <code>Set</code> constructor accepts an <code>Array</code> to convert in the other direction. Note again that <code>Set</code> objects store unique values, so any duplicate elements from an Array are deleted when converting.</p> + +<pre class="brush: js">Array.from(mySet); +[...mySet2]; + +mySet2 = new Set([1,2,3,4]); +</pre> + +<h3 id="Array_and_Set_compared"><code>Array</code> and <code>Set</code> compared</h3> + +<p>Traditionally, a set of elements has been stored in arrays in JavaScript in a lot of situations. The new <code>Set</code> object, however, has some advantages:</p> + +<ul> + <li>Checking whether an element exists in an collection using {{jsxref("Array.indexOf", "indexOf")}} for arrays is slow.</li> + <li><code>Set</code> objects let you delete elements by their value. With an array you would have to splice based on a element's index.</li> + <li>The value {{jsxref("NaN")}} can not be found with <code>indexOf</code> in array.</li> + <li><code>Set</code> objects store unique values, you don't have to keep track of duplicates by yourself.</li> +</ul> + +<h3 id="WeakSet_object"><code>WeakSet</code> object</h3> + +<p>{{jsxref("WeakSet")}} objects are collections of objects. An object in the <code>WeakSet</code> may only occur once; it is unique in the <code>WeakSet</code>'s collection and objects are not enumerable.</p> + +<p>The main differences to the {{jsxref("Set")}} object are:</p> + +<ul> + <li>In contrast to <code>Sets</code>, <code>WeakSets</code> are <strong>collections of objects only</strong> and not of arbitrary values of any type.</li> + <li>The <code>WeakSet</code> is <em>weak</em>: References to objects in the collection are held weakly. If there is no other reference to an object stored in the <code>WeakSet</code>, they can be garbage collected. That also means that there is no list of current objects stored in the collection. <code>WeakSets</code> are not enumerable.</li> +</ul> + +<p>The use cases of <code>WeakSet</code> objects are limited. They will not leak memory so it can be safe to use DOM elements as a key and mark them for tracking purposes, for example.</p> + +<h2 id="Key_and_value_equality_of_Map_and_Set">Key and value equality of <code>Map</code> and <code>Set</code></h2> + +<p>Both, the key equality of <code>Map</code> objects and the value equality of <code>Set</code> objects, are based on the "<a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero">same-value-zero algorithm</a>":</p> + +<ul> + <li>Equality works like the identity comparison operator <code>===</code>.</li> + <li><code>-0</code> and <code>+0</code> are considered equal.</li> + <li>{{jsxref("NaN")}} is considered equal to itself (contrary to <code>===</code>).</li> +</ul> + +<p>{{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</p> diff --git a/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html b/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html new file mode 100644 index 0000000000..953a9543de --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/guide/sintaxe_e_tipos/index.html @@ -0,0 +1,583 @@ +--- +title: Sintaxe e tipos +slug: Web/JavaScript/Guide/Sintaxe_e_tipos +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</div> + +<p class="summary">Este capítulo trata sobre a sintaxe básica do JavaScript, declarações de variáveis, tipos de dados e literais.</p> + +<h2 id="Basics" name="Basics">Sintaxe básica</h2> + +<p>JavaScript pega emprestado a maior parte de sua sintaxe do Java, mas também é influenciado por Awk, Perl e Python.</p> + +<p>JavaScript é <strong>case-sensitive</strong> e usa o conjunto de caracteres <strong>Unicode.</strong></p> + +<p>No JavaScript, instruções são chamadas de {{Glossary("Statement", "declarações")}} e são separadas por um ponto e vírgula (;). Espaços, tabulação e uma nova linha são chamados de espaços em branco. O código fonte dos scripts em JavaScript são lidos da esquerda para a direita e são convertidos em uma sequência de elementos de entrada como simbolos, caracteres de controle, terminadores de linha, comentários ou espaço em branco. ECMAScript também define determinadas palavras-chave e literais, e tem regras para inserção automática de ponto e vírgula (<a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">ASI</a>) para terminar as declarações. No entanto, recomenda-se sempre adicionar ponto e vírgula no final de suas declarações; isso evitará alguns imprevistos. Para obter mais informações, consulte a referência detalhada sobre a <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">gramática léxica</a> do JavaScript.</p> + +<h2 id="Comentários">Comentários</h2> + +<p>A sintaxe dos comentários em JavaScript é semelhante como em C++ e em muitas outras linguagens:</p> + +<pre class="brush: js">// comentário de uma linha + +/* isto é um comentário longo + de múltiplas linhas. + */ + +/* Você não pode, porém, /* aninhar comentários */ SyntaxError */</pre> + +<h2 id="Declarations" name="Declarations">Declarações</h2> + +<p>Existem três tipos de declarações em JavaScript.</p> + +<dl> + <dt>{{jsxref("Statements/var", "var")}}</dt> + <dd>Declara uma variável, opcionalmente, inicializando-a com um valor.</dd> + <dt>{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt> + <dd>Declara uma variável local de escopo do bloco, opcionalmente, inicializando-a com um valor.</dd> + <dt>{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt> + <dd>Declara uma constante apenas de leitura.</dd> +</dl> + +<h3 id="Variáveis">Variáveis</h3> + +<p>Você usa variáveis como nomes simbólicos para os valores em sua aplicação. O nome das variáveis, chamados de {{Glossary("Identifier", "identificadores")}}, obedecem determinadas regras.</p> + +<p>Um identificador JavaScript deve começar com uma letra, underline (<code>_</code>), ou cifrão (<code>$</code>); os caracteres subsequentes podem também ser números (0-9). Devido JavaScript ser case-sensitive, letras incluem caracteres de "A" a "Z" (maiúsculos) e caracteres de "a" a "z" (minúsculos).</p> + +<p>Você pode usar a ISO 8859-1 ou caracteres Unicode tal como os identificadores å e ü. Você pode também usar as <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a> como caracteres e identificadores.</p> + +<p>Alguns exemplos de nomes legais são <code>Numeros_visitas</code>, <code>temp99</code>, e<code> _nome</code>.</p> + +<h3 id="Declarando_variáveis">Declarando variáveis</h3> + +<p>Você pode declarar uma variável de três formas:</p> + +<ul> + <li>Com a palavra chave {{jsxref("Statements/var", "var")}}. Por exemplo, var <code>x = 42</code>. Esta sintaxe pode ser usada para declarar tanto variáveis locais como variáveis global.</li> + <li>Por simples adição de valor. Por exemplo, <code>x = 42</code>. Isso declara uma variável global. Essa declaração gera um aviso de advertência no JavaScript. Você não deve usar essa variante.</li> + <li>Com a palavra chave {{jsxref("Statements/let", "let")}}. Por exemplo, <code>let y = 13</code>. Essa sintaxe pode ser usada para declarar uma variável local de escopo de bloco. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Grammar_and_Types#Variable_scope">escopo de variável</a> abaixo.</li> +</ul> + +<h3 id="Classificando_variáveis">Classificando variáveis</h3> + +<p>Uma variável declarada usando a declaração <code>var</code> ou <code>let</code> sem especificar o valor inicial tem o valor {{jsxref("undefined")}}.</p> + +<p>Uma tentativa de acessar uma variável não declarada resultará no lançamento de uma exceção {{jsxref("ReferenceError")}}:</p> + +<pre class="brush: js">var a; +console.log("O valor de a é " + a); // saída "O valor de a é undefined" +console.log("O valor de b é " + b); // throws ReferenceError exception +</pre> + +<p>Você pode usar <code>undefined</code> para determinar se uma variável tem um valor. No código a seguir, não é atribuído um valor de entrada na variável e a declaração <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/if...else">if</a></code> será avaliada como verdadeira (<code>true</code>).</p> + +<pre class="brush: js">var input; +if(input === undefined){ + facaIsto(); +} else { + facaAquilo(); +} +</pre> + +<p>O valor <code>undefined</code> se comporta como falso (<code>false</code>), quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função <code>myFunction</code> devido o elemento <code>myArray</code> ser undefined:</p> + +<pre class="brush: js">var myArray = []; +if (!myArray[0]) myFunction(); +</pre> + +<p>O valor <code>undefined</code> converte-se para <code>NaN</code> quando usado no contexto numérico.</p> + +<pre class="brush: js">var a; +a + 2; // Avaliado como NaN +</pre> + +<p>Quando você avalia uma variável nula, o valor nulo se comporta como 0 em contextos numéricos e como falso em contextos booleanos. Por exemplo:</p> + +<pre class="brush: js">var n = null; +console.log(n * 32); // a saída para o console será 0. +</pre> + +<h3 id="Variable_scope" name="Variable_scope">Escopo de variável</h3> + +<p>Quando você declara uma váriavel fora de qualquer função, ela é chamada de variável <em>global</em>, porque está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, é chamada de variável <em>local</em>, pois ela está disponível somente dentro dessa função.</p> + +<p>JavaScript antes do ECMAScript 6 não possuía escopo de <a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Block_statement">declaração de bloco</a>; pelo contrário, uma variável declarada dentro de um bloco de uma <em>função </em>é uma variável local (ou contexto <em>global</em>) do bloco que está inserido a função. Por exemplo o código a seguir exibirá 5, porque o escopo de <code>x</code> está na função (ou contexto global) no qual <code>x</code> é declarado, não o bloco, que neste caso é a declaração <code>if</code>. </p> + +<pre class="brush: js">if (true) { + var x = 5; +} +console.log(x); // 5 +</pre> + +<p>Esse comportamento é alterado, quando usado a declaração <code>let</code> introduzida pelo ECMAScript 6.</p> + +<pre class="brush: js">if (true) { + let y = 5; +} +console.log(y); // ReferenceError: y não está definido +</pre> + +<h3 id="Variable_hoisting" name="Variable_hoisting">Hoisting</h3> + +<p>Outra coisa incomum sobre variáveis em JavaScript é que você pode utilizar a variável e declará-la depois, sem obter uma exceção. Este conceito é conhecido como <strong>hoisting</strong>; variáveis em JavaScript são num sentido "hoisted" ou lançada para o topo da função ou declaração. No entanto, as variáveis que são "hoisted" retornarão um valor <code>undefined</code>. Então, mesmo se você usar ou referir a variável e depois declará-la e inicializá-la, ela ainda retornará undefined.</p> + +<pre class="brush: js">/** + * Exemplo 1 + */ +console.log(x === undefined); // exibe "true" +var x = 3; + +/** + * Exemplo 2 + */ +// returnará um valor undefined +var myvar = "my value"; + +(function() { + console.log(myvar); // undefined + var myvar = "local value"; +})(); +</pre> + +<p>Os exemplos acima serão interpretados como:</p> + +<pre class="brush: js">/** + * Exemplo 1 + */ +var x; +console.log(x === undefined); // exibe "true" +x = 3; + +/** + * Exemplo 2 + */ +var myvar = "um valor"; + +(function() { + var myvar; + console.log(myvar); // undefined + myvar = "valor local"; +})(); +</pre> + +<p>Devido o hoisting, todas as declarações <code>var</code> em uma função devem ser colocadas no início da função. Essa recomendação de prática deixa o código mais legível.</p> + +<h3 id="Variáveis_Globais">Variáveis Globais</h3> + +<p>Variáveis globais são propriedades do <em>objeto global</em>. Em páginas web o objeto global é a {{domxref("window")}}, assim você pode configurar e acessar variáveis globais utilizando a sintaxe <code>window.variavel.</code> </p> + +<p>Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame ou frame de outra janela. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento, você pode consultar esta variável de um frame como <code>parent.phoneNumber</code>.</p> + +<h3 id="Constantes">Constantes</h3> + +<p>Você pode criar uma constante apenas de leitura por meio da palavra-chave {{jsxref("Statements/const", "const")}}. A sintaxe de um identificador de uma constante é semelhante ao identificador de uma variável: deve começar com uma letra, underline ou cifrão e pode conter caracteres alfabético, numérico ou underline.</p> + +<pre class="brush: js">const prefix = '212'; +</pre> + +<p>Uma constante não pode alterar seu valor por meio de uma atribuição ou ao ser declarada novamente enquanto o script é executado. Deve ser inicializada com um valor.</p> + +<p>As regras de escopo para as constantes são as mesmas para as váriaveis <code>let</code> de escopo de bloco. Se a palavra-chave <code>const</code> for omitida, o identificado é adotado para representar uma variável.</p> + +<p>Você não pode declarar uma constante com o mesmo nome de uma função ou variável que estão no mesmo escopo. Por exemplo: </p> + +<pre class="example-bad brush: js">// Isto irá causar um erro +function f() {}; +const f = 5; + +// Isto também irá causar um erro. +function f() { + const g = 5; + var g; + + //declarações +} +</pre> + +<h2 id="Data_structures_and_types" name="Data_structures_and_types">Estrutura de dados e tipos</h2> + +<h3 id="Tipos_de_dados">Tipos de dados</h3> + +<p>O mais recente padrão ECMAScript define sete tipos de dados:</p> + +<ul> + <li>Seis tipos de dados são os chamados {{Glossary("Primitive", "primitivos")}}: + <ul> + <li>{{Glossary("Boolean")}}. <code>true</code> e <code>false</code>.</li> + <li>{{Glossary("null")}}. Uma palavra-chave que indica valor nulo. Devido JavaScript ser case-sensitive, <code>null</code> não é o mesmo que <code>Null</code>, <code>NULL</code>, ou ainda outra variação.</li> + <li>{{Glossary("undefined")}}. Uma propriedade superior cujo valor é indefinido.</li> + <li>{{Glossary("Number")}}. <code>42</code> ou <code>3.14159</code>.</li> + <li>{{Glossary("String")}}. "Howdy"</li> + <li>{{Glossary("Symbol")}} (novo em ECMAScript 6). Um tipo de dado cuja as instâncias são únicas e imutáveis.</li> + </ul> + </li> + <li>e {{Glossary("Object")}}</li> +</ul> + +<p>Embora esses tipos de dados sejam uma quantidade relativamente pequena, eles permitem realizar funções úteis em suas aplicações. <span style="line-height: 1.5;">{{jsxref("Object", "Objetos")}} e {{jsxref("Function", "funçõess")}} são outros elementos fundamentais na linguagem. Você pode pensar em objetos como recipientes para os valores, e funções como métodos que suas aplicações podem executar.</span></p> + +<h3 id="Conversão_de_tipos_de_dados">Conversão de tipos de dados</h3> + +<p>JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável quando declará-la, e tipos de dados são convertidos automaticamente conforme a necessidade durante a execução do script. Então, por exemplo, você pode definir uma variável da seguinte forma:</p> + +<pre class="brush: js">var answer = 42; +</pre> + +<p>E depois, você pode atribuir uma string para a mesma variável, por exemplo:</p> + +<pre class="brush: js">answer = "Obrigado pelos peixes..."; +</pre> + +<p>Devido JavaScript ser dinamicamente tipado, essa declaração não gera uma mensagem de erro.</p> + +<p>Em expressões envolvendo valores numérico e string com o operador +, JavaScript converte valores numérico para strings. Por exemplo, considere a seguinte declaração:</p> + +<pre class="brush: js">x = "A resposta é " + 42 // "A resposta é 42" +y = 42 + " é a resposta" // "42 é a resposta" +</pre> + +<p>Nas declarações envolvendo outros operadores, JavaScript não converte valores numérico para strings. Por exemplo:</p> + +<pre class="brush: js">"37" - 7 // 30 +"37" + 7 // "377" +</pre> + +<h3 id="Convertendo_strings_para_números">Convertendo strings para números</h3> + +<p>No caso de um valor que representa um número está armazenado na memória como uma string, existem métodos para a conversão.</p> + +<ul> + <li id="parseInt()_and_parseFloat()">{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> +</ul> + +<p>parseInt irá retornar apenas números inteiros, então seu uso é restrito para a casa dos decimais. Além disso, é uma boa prática ao usar parseInt incluir o parâmetro da base. O parâmetro da base é usado para especificar qual sistema númerico deve ser usado.</p> + +<p><font face="Consolas, Liberation Mono, Courier, monospace">Uma método alternativo de conversão de um número em forma de string é com o operador <code>+</code> (operador soma):</font></p> + +<pre class="brush: js">"1.1" + "1.1" = "1.11.1" +(+"1.1") + (+"1.1") = 2.2 +// Nota: Os parênteses foram usados para deixar mais legível o código, ele não é requirido.</pre> + +<h2 id="Literals" name="Literals">Literais</h2> + +<p>Você usa literais para representar valores em JavaScript. Estes são valores fixados, não variáveis, que você <code>literalmente</code> insere em seu script. Esta seção descreve os seguintes tipos literais:</p> + +<ul> + <li>{{anch("Array literal")}}</li> + <li>{{anch("Literais boolean")}}</li> + <li>{{anch("Literais de ponto flutuante")}}</li> + <li>{{anch("Inteiros")}}</li> + <li>{{anch("Objeto literal")}}</li> + <li>{{anch("String literal")}}</li> +</ul> + +<h3 id="Array_literal">Array literal</h3> + +<p>Um literal de array é uma lista de zero ou mais expressões, onde cada uma delas representam um elemento do array, inseridas entre colchetes (<code>[]</code>). Quando você cria um array usando um array literal, ele é inicializado com os valores especificados como seus elementos, e seu comprimento é definido com o número de elementos especificados.</p> + +<p>O exemplo a seguir cria um array <code>coffees</code> com três elementos e um comprimento de três:</p> + +<pre class="brush: js">var coffees = ["French Roast", "Colombian", "Kona"]; +</pre> + +<div class="note"> +<p><strong>Nota :</strong> Um array literal é um tipo de inicializador de objetos. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Working_with_Objects#Using_object_initializers" title="en-US/docs/JavaScript/Guide/Working with Objects#Using Object Initializers">Usando inicializadores de Objetos</a>.</p> +</div> + +<p>Se um array é criado usando um literal no topo do script, JavaScript interpreta o array cada vez que avalia a expressão que contêm o array literal. Além disso, um literal usado em uma função é criado cada vez que a função é chamada.</p> + +<p>Array literal são também um array de objetos. Veja {{jsxref("Array")}} e <a href="/pt-BR/docs/Web/JavaScript/Guide/Indexed_collections">Coleções indexadas</a> para detalhes sobre array de objetos.</p> + +<h4 id="Vírgulas_extras_em_array_literal">Vírgulas extras em array literal</h4> + +<p>Você não precisa especificar todos os elementos em um array literal. Se você colocar duas vírgulas em uma linha, o array é criado com <code>undefined</code> para os elementos não especificados. O exemplo a seguir cria um array chamado <code>fish</code>:</p> + +<pre class="brush: js">var fish = ["Lion", , "Angel"]; +</pre> + +<p>Esse array tem dois elementos com valores e um elemento vazio (<code>fish[0]</code> é "Lion", <code>fish[1]</code> é <code>undefined</code>, e <code>fish[2]</code> é "Angel" ).</p> + +<p>Se você incluir uma vírgula à direita no final da lista dos elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento do array é três. Não há nenhum <code>myList[3]</code>. Todas as outras vírgulas na lista indicam um novo elemento.</p> + +<div class="note"> +<p><strong>Nota :</strong> Vírgulas à direita podem criar erros em algumas versões de navegadores web antigos, é recomendável removê-las.</p> +</div> + +<pre class="brush: js">var myList = ['home', , 'school', ]; +</pre> + +<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[0]</code> e <code>myList[2]</code> são <code>undefined</code>.</p> + +<pre class="brush: js">var myList = [ , 'home', , 'school']; +</pre> + +<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[1]</code> e <code>myList[3]</code> são <code>undefined</code>. Apenas a última vírgula é ignorada.</p> + +<pre class="brush: js">var myList = ['home', , 'school', , ]; +</pre> + +<p>Entender o comportamento de vírgulas extras é importante para a compreensão da linguagem JavaScript, no entanto, quando você escrever seu próprio código: declarar explicitamente os elementos em falta como <code>undefined</code> vai aumentar a clareza do código, e consequentemente na sua manutenção.</p> + +<h3 id="Literais_Boolean">Literais Boolean</h3> + +<p>O tipo Boolean tem dois valores literal: <code>true</code> e <code>false</code>.</p> + +<p>Não confunda os valores primitivos Boolean <code>true</code> e <code>false</code> com os valores <code>true</code> e <code>false</code> do objeto Boolean. O objeto Boolean é um invólucro em torno do tipo de dado primitivo. Veja {{jsxref("Boolean")}} para mais informação.</p> + +<h3 id="Inteiros">Inteiros</h3> + +<p>Inteiros podem sem expressos em decimal (base 10), hexadecimal (base 16), octal (base 8) e binário (base 2).</p> + +<ul> + <li>Decimal inteiro literal consiste em uma sequência de dígitos sem um 0 (zero).</li> + <li>0 (zero) em um inteiro literal indica que ele está em octal. Octal pode incluir somente os dígitos 0-7.</li> + <li>0x (ou 0X) indica um hexadecimal. Inteiros hexadecimais podem incluir dígitos (0-9) e as letras a-f e A-F.</li> + <li>0b (ou 0B) indica um binário. Inteiros binário podem incluir apenas os dígitos 0 e 1.</li> +</ul> + +<p>Alguns exemplos de inteiros literal são:</p> + +<pre class="eval">0, 117 and -345 (decimal, base 10) +015, 0001 and -077 (octal, base 8) +0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16) +0b11, 0b0011 and -0b11 (binário, base 2) +</pre> + +<p>Para maiores informações, veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Numeric_literals">Literais numérico na referência Léxica</a>.</p> + +<h3 id="Literais_de_ponto_flutuante">Literais de ponto flutuante</h3> + +<p>Um literal de ponto flutuante pode ter as seguintes partes:</p> + +<ul> + <li>Um inteiro decimal que pode ter sinal (precedido por "<code>+</code>" ou "<code>-</code>"),</li> + <li>Um ponto decimal ("<code>.</code>"),</li> + <li>Uma fração (outro número decimal),</li> + <li>Um expoente.</li> +</ul> + +<p>O expoente é um "e" ou "E" seguido por um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante deve ter no mínimo um dígito e um ponto decimal ou "e" (ou "E").</p> + +<p>Mais sucintamente, a sintaxe é:</p> + +<pre class="eval">[(+|-)][digitos][.digitos][(E|e)[(+|-)]digitos] +</pre> + +<p>Por exemplo:</p> + +<pre class="eval">3.1415926 +-.123456789 +-3.1E+12 +.1e-23 +</pre> + +<h3 id="Objeto_literal">Objeto literal</h3> + +<p>Um objeto literal é uma lista de zero ou mais pares de nomes de propriedades e valores associados de de um objeto, colocado entre chaves (<code>{}</code>). Você não deve usar um objeto literal no início de uma declaração. Isso levará a um erro ou não se comportará conforme o esperado, porque o <code>{</code> será interpretado como início de um bloco.</p> + +<p>Segue um exemplo de um objeto literal. O primeiro elemento do objeto <code>car </code>define uma propriedade, <code>myCar</code>, e atribui para ele uma nova string, "Saturn"; o segundo elemento, a propriedade <code>getCar</code>, é imediatamente atribuído o resultado de chamar uma função (<code>carTypes("Honda")</code>); o terceiro elemento, a propriedade especial, usa uma variável existente (<code>sales)</code>.</p> + +<pre class="brush: js">var sales = "Toyota"; + +function carTypes(name) { + if (name == "Honda") { + return name; + } else { + return "Sorry, we don't sell " + name + "."; + } +} + +var car = { myCar: "Saturn", getCar: carTypes("Honda"), special: sales }; + +console.log(car.myCar); // Saturn +console.log(car.getCar); // Honda +console.log(car.special); // Toyota +</pre> + +<p>Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade ou aninhar um objeto dentro do outro. O exemplo a seguir usar essas opções.</p> + +<pre class="brush: js">var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" }; + +console.log(car.manyCars.b); // Jeep +console.log(car[7]); // Mazda +</pre> + +<p>Nomes de propriedades de objeto podem ser qualquer string, incluindo uma string vazia. Caso o nome da propriedade não seja um {{Glossary("Identifier","identificador")}} JavaScript ou número, ele deve ser colocado entre aspas. Nomes de propriedades que não possuem identificadores válido, também não podem ser acessadas pela propriedade de ponto (<code>.</code>), mas podem ser acessadas e definidas com a notação do tipo array ("<code>[]</code>").</p> + +<pre class="brush: js">var unusualPropertyNames = { + "": "Uma string vazia", + "!": "Bang!" +} +console.log(unusualPropertyNames.""); // SyntaxError: string inesperada +console.log(unusualPropertyNames[""]); // Um string vazia +console.log(unusualPropertyNames.!); // SyntaxError: símbolo ! inesperado +console.log(unusualPropertyNames["!"]); // Bang!</pre> + +<p>Observe:</p> + +<pre class="brush: js">var foo = {a: "alpha", 2: "two"}; +console.log(foo.a); // alpha +console.log(foo[2]); // two +//console.log(foo.2); // Error: missing ) after argument list +//console.log(foo[a]); // Error: a não está definido +console.log(foo["a"]); // alpha +console.log(foo["2"]); // two +</pre> + +<h3 id="String_Literal">String Literal</h3> + +<p>Uma string literal são zero ou mais caracteres dispostos em aspas duplas (<code>"</code>) ou aspas simples (<code>'</code>). Uma sequência de caracteres deve ser delimitada por aspas do mesmo tipo; ou seja, as duas aspas simples ou ambas aspas duplas. A seguir um exemplo de strings literais.</p> + +<pre class="eval">"foo" +'bar' +"1234" +"um linha \n outra linha" +"John's cat" +</pre> + +<p>Você pode chamar qualquer um dos métodos do objeto string em uma string literal - JavaScript automaticamente converte a string literal para um objeto string temporário, chama o método, em seguida, descarta o objeto string temporário. Você também pode usar a propriedade <code>String.length</code> com uma string literal:</p> + +<pre class="brush: js">console.log("John's cat".length) +// Irá exibir a quantidade de caracteres na string incluindo o espaço em branco. +// Nesse caso, 10 caracteres. +</pre> + +<p>Você deve usar string literal, a não ser que você precise usar um objeto string. Veja {{jsxref("String")}} para detalhes sobre objetos de strings.</p> + +<h4 id="Uso_de_caracteres_especiais_em_string">Uso de caracteres especiais em string</h4> + +<p>Além dos caracteres comuns, você também pode incluir caracteres especiais em strings, como mostrado no exemplo a seguir.</p> + +<pre class="brush: js">"uma linha \n outra linha" +</pre> + +<p>A tabela a seguir lista os caracteres especiais que podem ser usados em strings no JavaScript.</p> + +<table class="standard-table"> + <caption>Tabela: Caracteres especiais no JavaScript</caption> + <thead> + <tr> + <th scope="col">Caracter</th> + <th scope="col">Descrição</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>Byte nulo</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>Backspace</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>Alimentador de formulário</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>Nova linha</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>Retorno do carro</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>Tabulação</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>Tabulação vertical</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>Apóstrofo ou aspas simples</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>Aspas dupla</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>Caractere de barra invertida</td> + </tr> + <tr> + <td><code>\<em>XXX</em></code></td> + <td> + <p>Caractere com a codificação Latin-1 especificada por três dígitos octal <em>XXX </em>entre 0 e 377. Por exemplo, \251 é sequência octal para o símbolo de direitos autorais.</p> + </td> + </tr> + <tr> + </tr> + <tr> + <td><code>\x<em>XX</em></code></td> + <td> + <p>Caractere com a codificação Latin-1 especificada por dois dígitos hexadecimal <em>XX</em> entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal para o símbolo de direitos autorais.</p> + </td> + </tr> + <tr> + </tr> + <tr> + <td><code>\u<em>XXXX</em></code></td> + <td> + <p>Caractere Unicode especificado por quatro dígitos hexadecimal <em>XXXX</em>. Por exemplo, \u00A9 é a sequência Unicode para o símbolo de direitos autorais. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a>.</p> + </td> + </tr> + </tbody> +</table> + +<h4 id="Caracteres_de_escape">Caracteres de escape</h4> + +<p>Para caracteres não listados na tabela, se precedidos de barra invertida ela é ignorada, seu uso está absoleto e deve ser ignorado.</p> + +<p>Você pode inserir uma aspa dentro de uma string precendendo-a com uma barra invertida. Isso é conhecido como <em>escaping</em> das aspas. Por exemplo:</p> + +<pre class="brush: js">var quote = "Ele lê \"The Cremation of Sam McGee\" de R.W. Service."; +console.log(quote); +</pre> + +<p>O resultado disso seria:</p> + +<pre class="eval">Ele lê "The Cremation of Sam McGee" de R.W. Service. +</pre> + +<p>Para incluir uma barra invertida dentro de uma string, você deve escapar o caractere de barra invertida. Por exemplo, para atribuir o caminho do arquivo <code>c:\temp </code>para uma string, utilize o seguinte:</p> + +<pre class="brush: js">var home = "c:\\temp"; +</pre> + +<p>Você também pode escapar quebras de linhas, precedendo-as com barra invertida. A barra invertida e a quebra de linha são ambas removidas da string.</p> + +<pre class="brush: js">var str = "esta string \ +está quebrada \ +em várias\ +linhas." +console.log(str); // esta string está quebrada em várias linhas. +</pre> + +<p>Embora JavaScript não tenha sintaxe "heredoc", você pode adicionar uma quebra de linha e um escape de quebra de linha no final de cada linha:</p> + +<pre class="brush: js">var poem = +"Rosas são vermelhas,\n\ +Violetas são azul.\n\ +Eu sou esquizofrênico,\n\ +e é isso que sou." +</pre> + +<h2 id="Mais_informação">Mais informação</h2> + +<p>Este capítulo focou na sintaxe básica das declarações e tipos. Para saber mais sobre a linguagem JavaScript, veja também os seguintes capítulos deste guia:</p> + +<ul> + <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Controle de fluxo e manipulação de erro</a></li> + <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Loops_and_iteration">Laços e iteração</a></li> + <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Functions">Funções</a></li> + <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressões e operadores</a></li> +</ul> + +<p>No próximo capítulo, veremos a construção de controle de fluxos e manipulação de erro.</p> + +<p>{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</p> diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html new file mode 100644 index 0000000000..e863d9cc69 --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/reference/global_objects/array/prototype/index.html @@ -0,0 +1,206 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Reference/Global_Objects/Array/prototype +tags: + - Array + - JavaScript + - Propriedade +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +<div>{{JSRef}}</div> + +<h2 id="Description" name="Description">Descrição</h2> + +<p>Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de <code>Array.prototype</code>. Como em todos os construtores, você pode mudar o protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.</p> + +<p>Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na <a href="https://developers.google.com/web/updates/2018/03/smooshgate">adição de novas funcionalidades ao JavaScript</a>.</p> + +<p>Um fato pouco conhecido: O próprio <code>Array.prototype </code>é um {{jsxref("Global_Objects/Array", "Array")}}</p> + +<pre class="brush: js">Array.isArray(Array.prototype); // true +</pre> + +<h2 id="Properties" name="Properties">Propriedades</h2> + +<dl> + <dt><code>Array.prototype.constructor</code></dt> + <dd>Especifica a função que cria um objeto do protótipo.<br> + </dd> + <dt>{{jsxref("Array.prototype.length")}}</dt> + <dd>Reflete o número de elementos em um array.</dd> +</dl> + +<h2 id="Methods" name="Methods">Métodos</h2> + +<h3 id="Mutator_methods" name="Mutator_methods">Métodos modificadores</h3> + +<p>Esses métodos modificam o array:</p> + +<dl> + <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt> + <dd>Copia uma sequência de elementos do array dentro do array.</dd> + <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt> + <dd>Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.</dd> + <dt>{{jsxref("Array.prototype.pop()")}}</dt> + <dd>Remove e retorna o último elemento de um array.</dd> + <dt>{{jsxref("Array.prototype.push()")}}</dt> + <dd>Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.</dd> + <dt>{{jsxref("Array.prototype.reverse()")}}</dt> + <dd>Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.</dd> + <dt>{{jsxref("Array.prototype.shift()")}}</dt> + <dd>Remove o primeiro elemento de um array e o retorna.</dd> + <dt>{{jsxref("Array.prototype.sort()")}}</dt> + <dd>Ordena os elementos do array em questão e retorna o array.</dd> + <dt>{{jsxref("Array.prototype.splice()")}}</dt> + <dd>Adiciona e/ou remove elementos de um array.</dd> + <dt>{{jsxref("Array.prototype.unshift()")}}</dt> + <dd>Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.</dd> +</dl> + +<h3 id="Accessor_methods" name="Accessor_methods">Métodos de acesso</h3> + +<p>Esses métodos não modificam o array, mas sim retornam alguma representação dele.</p> + +<dl> + <dt>{{jsxref("Array.prototype.concat()")}}</dt> + <dd>Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.</dd> + <dt>{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}</dt> + <dd>Verifica se o array possui cer, retornando<code>true</code> ou <code>false</code> apropriadamente.</dd> + <dt>{{jsxref("Array.prototype.join()")}}</dt> + <dd>Retorna uma string com todos os elementos do array</dd> + <dt>{{jsxref("Array.prototype.slice()")}}</dt> + <dd>Retorna um novo array com uma parte do array sobre o qual o método foi chamado</dd> + <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Array.prototype.toString()")}}</dt> + <dd>Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt> + <dd>Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Array.prototype.indexOf()")}}</dt> + <dd>Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.</dd> + <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt> + <dd>Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array</dd> +</dl> + +<h3 id="Iteration_methods" name="Iteration_methods">Métodos de iteração</h3> + +<p>Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `<code>length` do array</code> é amostrado e qualquer elemento adicionado além deste comprimento (length) de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.</p> + +<dl> + <dt>{{jsxref("Array.prototype.forEach()")}}</dt> + <dd>Chama a função para cada elemento no array.</dd> + <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem o par chave/valor para cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.every()")}}</dt> + <dd>Retorna true se todos elementos no array satisfizer a função de teste fornecida.</dd> + <dt>{{jsxref("Array.prototype.some()")}}</dt> + <dd>Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.</dd> + <dt>{{jsxref("Array.prototype.filter()")}}</dt> + <dd>Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.</dd> + <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt> + <dd>Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou `<code>undefined` </code>se não for encontrado.</dd> + <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt> + <dd>Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.</dd> + <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo <code>Array Iterator</code> que contem a chave para cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.map()")}}</dt> + <dd>Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.</dd> + <dt>{{jsxref("Array.prototype.reduce()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.</dd> + <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt> + <dd>Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.</dd> + <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd> + <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt> + <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd> +</dl> + +<h3 id="Generic_methods" name="Generic_methods">Métodos genéricos</h3> + +<p>Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade <code>length</code> (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato <code>array[5]</code>). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e <code>length </code>sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.</p> + +<h2 id="Specifications" name="Specifications">Especifiações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificação</th> + <th scope="col">Situação</th> + <th scope="col">Comentário</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Padrão</td> + <td>Definição inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Veja também</h2> + +<ul> + <li>{{jsxref("Global_Objects/Array", "Array")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html b/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html new file mode 100644 index 0000000000..ff8de05541 --- /dev/null +++ b/files/pt-br/orphaned/web/javascript/reference/global_objects/bigint/prototype/index.html @@ -0,0 +1,61 @@ +--- +title: BigInt.prototype +slug: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +tags: + - BigInt + - JavaScript + - Propriedade + - Prototipo + - Referencia +translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype +--- +<div>{{JSRef}}</div> + +<p>A propriedade <strong><code>BigInt.prototype</code></strong> representa o protótipo para o construtor {{JSxRef("BigInt")}} .</p> + +<p>{{JS_Property_Attributes(0, 0, 0)}}</p> + +<h2 id="Descrição">Descrição</h2> + +<p>Todas instância de {{JSxRef("BigInt")}} herdam de <code>BigInt.prototype</code>. O objeto protótipo do construtor {{JSxRef("BigInt")}} pode ser modificado para afetar todas instâncias de {{JSxRef( "BigInt")}} .</p> + +<h2 id="Propriedades">Propriedades</h2> + +<dl> + <dt><code>BigInt.prototype.constructor</code></dt> + <dd>Retorna a função que cria instâncias deste objeto. Por padrão é o objeto<br> + {{JSxRef("BigInt")}}.</dd> +</dl> + +<h2 id="Métodos">Métodos</h2> + +<dl> + <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt> + <dd>Retorna uma string com uma representação sensível ao idioma para este número. Sobrescreve o método {{JSxRef("Object.prototype.toLocaleString()")}}<br> + </dd> + <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt> + <dd>Retorna uma string respresentando o objeto específicado em um base específica. Sobrescreve o método {{JSxRef("Object.prototype.toString()")}} .</dd> + <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt> + <dd>Retorna o valor primitivo de um objeto específicado. Sobrescreve o método {{JSxRef("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Especificações">Especificações</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificações</th> + <th scope="col">Estado</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-bigint.prototype', 'BigInt.prototype')}}</td> + <td>{{Spec2('ESDraft')}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilidade">Compatibilidade</h2> + +<p class="hidden">Para contribuir para este dado de compatibilidade, por favor escreva um pull resquest para este repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.BigInt.prototype")}}</p> diff --git a/files/pt-br/orphaned/web/security/information_security_basics/index.html b/files/pt-br/orphaned/web/security/information_security_basics/index.html new file mode 100644 index 0000000000..9508b0afdb --- /dev/null +++ b/files/pt-br/orphaned/web/security/information_security_basics/index.html @@ -0,0 +1,32 @@ +--- +title: Básico de Segurança da Informação +slug: Web/Security/Básico_de_Segurança_da_Informação +tags: + - Iniciante + - Segurança +translation_of: Web/Security/Information_Security_Basics +--- +<p>Entender o básico de segurança da informação pode ajudar você a evitar que seu software ou website estejam inseguros e vulneráveis a fraquezas que podem ser exploradas para ganhos financeiros ou outros motivos maliciosos<span id="result_box" lang="pt"><span>. </span></span><span id="result_box" lang="pt"><span>Estes artigos podem ajudar você a aprender o que você precisa. Com essa informação, você estará ciente do papel e importância da segurança no ciclo de desenvolvimento de software, além da distribuição do seu conteúdo.</span></span></p> + +<p><a href="/en-US/Learn/Confidentiality,_Integrity,_and_Availability">Confidencialidade, Integridade e Disponibilidade</a></p> + +<dl> + <dd>Descreve os objetivos de segurança primários, que são absolutamente fundamentais para o entendimento de segurança</dd> + <dt><a href="/en-US/Learn/Vulnerabilities">Vulnerabilidades</a></dt> + <dd>Define as principais categorias de vulnerabilidades e discute a presença de vulnerabilidades em todo software</dd> + <dt><a href="/en-US/Learn/Threats">Ameaças</a></dt> + <dd>Introduz brevemente os principais conceitos de ameaças</dd> + <dt><a href="/en-US/Learn/Security_Controls">Controles de Segurança</a></dt> + <dd>Define as principais categorias de controle de segurança e discute suas potenciais desvantagens</dd> + <dt><a href="/en-US/Learn/TCP_IP_Security">Segurança TCP/IP</a></dt> + <dd>Uma visão geral do modelo TCP/IP, com um foco em considerações de segurança para SSL</dd> +</dl> + +<h2 id="Veja_também">Veja também</h2> + +<ul> + <li><a href="/en-US/docs/Mozilla/Security">Segurança no Browser</a></li> + <li><a href="/en-US/docs/Web/Security">Segurança na Web</a></li> + <li><a href="/en-US/docs/Web/Security/Securing_your_site">Protegendo seu site</a></li> + <li><a href="/en-US/docs/Security/Firefox_Security_Basics_For_Developers">Básico de Segurança no Firefox para Desenvolvedores</a></li> +</ul> |