From 2c2df5ea01eb5cd8b9ea226b2869337e59c5fe3e Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:50:24 +0100 Subject: unslug pt-pt: move --- .../web/javascript/data_structures/index.html | 297 ++++++++ .../web/javascript/estruturas_de_dados/index.html | 297 -------- .../pt-pt/web/javascript/gestao_memoria/index.html | 187 ----- .../guia/detalhes_do_modelo_de_objeto/index.html | 735 ------------------ .../guia/expressoes_e_operadores/index.html | 832 --------------------- .../guia/gram\303\241tica_e_tipos/index.html" | 641 ---------------- files/pt-pt/web/javascript/guia/index.html | 123 --- .../guia/introdu\303\247\303\243o/index.html" | 137 ---- .../index.html" | 47 -- files/pt-pt/web/javascript/guia/sobre/index.html | 166 ---- .../index.html" | 547 -------------- .../guide/details_of_the_object_model/index.html | 735 ++++++++++++++++++ .../javascript/guide/grammar_and_types/index.html | 641 ++++++++++++++++ files/pt-pt/web/javascript/guide/index.html | 123 +++ .../web/javascript/guide/introduction/index.html | 137 ++++ .../web/javascript/memory_management/index.html | 187 +++++ .../o_que_\303\251_o_javascript/index.html" | 13 - .../web/javascript/reference/about/index.html | 52 ++ .../deprecated_and_obsolete_features/index.html | 289 +++++++ .../index.html" | 113 --- .../errors/unnamed_function_statement/index.html | 113 +++ .../bloco/index.html" | 116 --- .../for/index.html" | 145 ---- .../index.html" | 150 ---- .../return/index.html" | 148 ---- .../throw/index.html" | 271 ------- .../reference/funcionalidades_obsoletas/index.html | 289 ------- .../reference/funcoes/arguments/index.html | 228 ------ .../reference/funcoes/funcoes_seta/index.html | 399 ---------- .../web/javascript/reference/funcoes/index.html | 594 --------------- .../reference/funcoes/parametros_rest/index.html | 234 ------ .../reference/functions/arguments/index.html | 228 ++++++ .../reference/functions/arrow_functions/index.html | 399 ++++++++++ .../web/javascript/reference/functions/index.html | 594 +++++++++++++++ .../reference/functions/rest_parameters/index.html | 234 ++++++ .../asyncfunction/prototype/index.html | 55 -- .../global_objects/number/prototype/index.html | 131 ---- .../global_objects/object/prototype/index.html | 199 ----- .../operadores/fun\303\247\303\243o/index.html" | 139 ---- .../web/javascript/reference/operadores/index.html | 309 -------- .../operadores/operador_virgula/index.html | 94 --- .../operadores/precedencia_operador/index.html | 461 ------------ .../reference/operators/comma_operator/index.html | 94 +++ .../reference/operators/function/index.html | 139 ++++ .../web/javascript/reference/operators/index.html | 309 ++++++++ .../operators/operator_precedence/index.html | 461 ++++++++++++ .../web/javascript/reference/sobre/index.html | 52 -- .../reference/statements/block/index.html | 116 +++ .../javascript/reference/statements/for/index.html | 145 ++++ .../web/javascript/reference/statements/index.html | 150 ++++ .../reference/statements/return/index.html | 148 ++++ .../reference/statements/throw/index.html | 271 +++++++ files/pt-pt/web/javascript/shells/index.html | 29 + 53 files changed, 5891 insertions(+), 7852 deletions(-) create mode 100644 files/pt-pt/web/javascript/data_structures/index.html delete mode 100644 files/pt-pt/web/javascript/estruturas_de_dados/index.html delete mode 100644 files/pt-pt/web/javascript/gestao_memoria/index.html delete mode 100644 files/pt-pt/web/javascript/guia/detalhes_do_modelo_de_objeto/index.html delete mode 100644 files/pt-pt/web/javascript/guia/expressoes_e_operadores/index.html delete mode 100644 "files/pt-pt/web/javascript/guia/gram\303\241tica_e_tipos/index.html" delete mode 100644 files/pt-pt/web/javascript/guia/index.html delete mode 100644 "files/pt-pt/web/javascript/guia/introdu\303\247\303\243o/index.html" delete mode 100644 "files/pt-pt/web/javascript/guia/introdu\303\247\303\243o_ao_javascript/index.html" delete mode 100644 files/pt-pt/web/javascript/guia/sobre/index.html delete mode 100644 "files/pt-pt/web/javascript/guia/valores,_vari\303\241veis_e_literais/index.html" create mode 100644 files/pt-pt/web/javascript/guide/details_of_the_object_model/index.html create mode 100644 files/pt-pt/web/javascript/guide/grammar_and_types/index.html create mode 100644 files/pt-pt/web/javascript/guide/index.html create mode 100644 files/pt-pt/web/javascript/guide/introduction/index.html create mode 100644 files/pt-pt/web/javascript/memory_management/index.html delete mode 100644 "files/pt-pt/web/javascript/o_que_\303\251_o_javascript/index.html" create mode 100644 files/pt-pt/web/javascript/reference/about/index.html create mode 100644 files/pt-pt/web/javascript/reference/deprecated_and_obsolete_features/index.html delete mode 100644 "files/pt-pt/web/javascript/reference/errors/declara\303\247\303\243o_fun\303\247\303\243o_sem_nome/index.html" create mode 100644 files/pt-pt/web/javascript/reference/errors/unnamed_function_statement/index.html delete mode 100644 "files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/bloco/index.html" delete mode 100644 "files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/for/index.html" delete mode 100644 "files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/index.html" delete mode 100644 "files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/return/index.html" delete mode 100644 "files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/throw/index.html" delete mode 100644 files/pt-pt/web/javascript/reference/funcionalidades_obsoletas/index.html delete mode 100644 files/pt-pt/web/javascript/reference/funcoes/arguments/index.html delete mode 100644 files/pt-pt/web/javascript/reference/funcoes/funcoes_seta/index.html delete mode 100644 files/pt-pt/web/javascript/reference/funcoes/index.html delete mode 100644 files/pt-pt/web/javascript/reference/funcoes/parametros_rest/index.html create mode 100644 files/pt-pt/web/javascript/reference/functions/arguments/index.html create mode 100644 files/pt-pt/web/javascript/reference/functions/arrow_functions/index.html create mode 100644 files/pt-pt/web/javascript/reference/functions/index.html create mode 100644 files/pt-pt/web/javascript/reference/functions/rest_parameters/index.html delete mode 100644 files/pt-pt/web/javascript/reference/global_objects/asyncfunction/prototype/index.html delete mode 100644 files/pt-pt/web/javascript/reference/global_objects/number/prototype/index.html delete mode 100644 files/pt-pt/web/javascript/reference/global_objects/object/prototype/index.html delete mode 100644 "files/pt-pt/web/javascript/reference/operadores/fun\303\247\303\243o/index.html" delete mode 100644 files/pt-pt/web/javascript/reference/operadores/index.html delete mode 100644 files/pt-pt/web/javascript/reference/operadores/operador_virgula/index.html delete mode 100644 files/pt-pt/web/javascript/reference/operadores/precedencia_operador/index.html create mode 100644 files/pt-pt/web/javascript/reference/operators/comma_operator/index.html create mode 100644 files/pt-pt/web/javascript/reference/operators/function/index.html create mode 100644 files/pt-pt/web/javascript/reference/operators/index.html create mode 100644 files/pt-pt/web/javascript/reference/operators/operator_precedence/index.html delete mode 100644 files/pt-pt/web/javascript/reference/sobre/index.html create mode 100644 files/pt-pt/web/javascript/reference/statements/block/index.html create mode 100644 files/pt-pt/web/javascript/reference/statements/for/index.html create mode 100644 files/pt-pt/web/javascript/reference/statements/index.html create mode 100644 files/pt-pt/web/javascript/reference/statements/return/index.html create mode 100644 files/pt-pt/web/javascript/reference/statements/throw/index.html create mode 100644 files/pt-pt/web/javascript/shells/index.html (limited to 'files/pt-pt/web/javascript') diff --git a/files/pt-pt/web/javascript/data_structures/index.html b/files/pt-pt/web/javascript/data_structures/index.html new file mode 100644 index 0000000000..8b8578229b --- /dev/null +++ b/files/pt-pt/web/javascript/data_structures/index.html @@ -0,0 +1,297 @@ +--- +title: Tipos de dados de JavaScript e estruturas de dados +slug: Web/JavaScript/Estruturas_de_dados +tags: + - JavaScript + - Principiante + - Tipos +translation_of: Web/JavaScript/Data_structures +--- +
{{jsSidebar("More")}}
+ +

Programming languages all have built-in data structures, but these often differ from one language to another. This article attempts to list the built-in data structures available in JavaScript and what properties they have; these can be used to build other data structures. When possible, comparisons with other languages are drawn.

+ +

Digitação dinâmica

+ +

JavaScript is a loosely typed or a dynamic language. Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned)  values of all types:

+ +
var foo = 42;    // foo is now a Number
+var foo = 'bar'; // foo is now a String
+var foo = true;  // foo is now a Boolean
+
+ +

Tipos de dados

+ +

The latest ECMAScript standard defines seven data types:

+ + + +

Valores primitivos

+ +

All types except objects define immutable values (values, which are incapable of being changed). For example and unlike to C, Strings are immutable. We refer to values of these types as "primitive values".

+ +

Tipo booleano

+ +

Boolean represents a logical entity and can have two values: true, and false.

+ +

Tipo Null

+ +

The Null type has exactly one value: null. See {{jsxref("null")}} and {{Glossary("Null")}} for more details.

+ +

Tipo indefinido

+ +

A variable that has not been assigned a value has the value undefined. See {{jsxref("undefined")}} and {{Glossary("Undefined")}} for more details.

+ +

Tipo número

+ +

According to the ECMAScript standard, there is only one number type: the double-precision 64-bit binary format IEEE 754 value (number between -(253 -1) and 253 -1). There is no specific type for integers. In addition to being able to represent floating-point numbers, the number type has three symbolic values: +Infinity, -Infinity, and NaN (not-a-number).

+ +

To check for the largest available value or smallest available value within +/-Infinity, you can use the constants {{jsxref("Number.MAX_VALUE")}} or {{jsxref("Number.MIN_VALUE")}} and starting with ECMAScript 6, you are also able to check if a number is in the double-precision floating-point number range using {{jsxref("Number.isSafeInteger()")}} as well as {{jsxref("Number.MAX_SAFE_INTEGER")}} and {{jsxref("Number.MIN_SAFE_INTEGER")}}. Beyond this range, integers in JavaScript are not safe anymore and will be a double-precision floating point approximation of the value.

+ +

The number type has only one integer that has two representations: 0 is represented as -0 and +0. ("0" is an alias for +0). In the praxis, this has almost no impact. For example +0 === -0 is true. However, you are able to notice this when you divide by zero:

+ +
> 42 / +0
+Infinity
+> 42 / -0
+-Infinity
+
+ +

Although a number often represents only its value, JavaScript provides some binary operators. These can be used to represent several Boolean values within a single number using bit masking. However, this is usually considered a bad practice, since JavaScript offers other means to represent a set of Booleans (like an array of Booleans or an object with Boolean values assigned to named properties). Bit masking also tends to make code more difficult to read, understand, and maintain. It may be necessary to use such techniques in very constrained environments, like when trying to cope with the storage limitation of local storage or in extreme cases when each bit over the network counts. This technique should only be considered when it is the last measure that can be taken to optimize size.

+ +

Tipo string

+ +

JavaScript's {{jsxref("Global_Objects/String", "String")}} type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it.

+ +

Unlike in languages like C, JavaScript strings are immutable. This means that once a string is created, it is not possible to modify it. However, it is still possible to create another string based on an operation on the original string. For example:

+ + + +

Beware of "stringly-typing" your code!

+ +

It can be tempting to use strings to represent complex data. Doing this comes with short-term benefits:

+ + + +

With conventions, it is possible to represent any data structure in a string. This does not make it a good idea. For instance, with a separator, one could emulate a list (while a JavaScript array would be more suitable). Unfortunately, when the separator is used in one of the "list" elements, then, the list is broken. An escape character can be chosen, etc. All of this requires conventions and creates an unnecessary maintenance burden.

+ +

Use strings for textual data. When representing complex data, parse strings and use the appropriate abstraction.

+ +

Tipo símbolo

+ +

Symbols are new to JavaScript in ECMAScript Edition 6. A Symbol is a unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called atoms. For more details see {{Glossary("Symbol")}} and the {{jsxref("Symbol")}} object wrapper in JavaScript.

+ +

Objetos

+ +

In computer science, an object is a value in memory which is possibly referenced by an {{Glossary("Identifier", "identifier")}}.

+ +

Propriedades

+ +

In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.

+ +

There are two types of object properties which have certain attributes: The data property and the accessor property.

+ +

Data property

+ +

Associates a key with a value and has the following attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Attributes of a data property
AttributeTypeDescriptionDefault value
[[Value]]Any JavaScript typeThe value retrieved by a get access of the property.undefined
[[Writable]]BooleanIf false, the property's [[Value]] can't be changed.false
[[Enumerable]]BooleanIf true, the property will be enumerated in for...in loops. See also Enumerability and ownership of propertiesfalse
[[Configurable]]BooleanIf false, the property can't be deleted and attributes other than [[Value]] and [[Writable]] can't be changed.false
+ + + + + + + + + + + + + + + + + + + + + + + + + +
Obsolete attributes (as of ECMAScript 3, renamed in ECMAScript 5)
AttributeTypeDescription
Read-onlyBooleanReversed state of the ES5 [[Writable]] attribute.
DontEnumBooleanReversed state of the ES5 [[Enumerable]] attribute.
DontDeleteBooleanReversed state of the ES5 [[Configurable]] attribute.
+ +

Accessor property

+ +

Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Attributes of an accessor property
AttributeTypeDescriptionDefault value
[[Get]]Function object or undefinedThe function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get.undefined
[[Set]]Function object or undefinedThe function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set.undefined
[[Enumerable]]BooleanIf true, the property will be enumerated in for...in loops.false
[[Configurable]]BooleanIf false, the property can't be deleted and can't be changed to a data property.false
+ +
+

Note: Attribute is usually used by JavaScript engine, so you can't directly access it(see more about Object.defineProperty()).That's why the attribute is put in double square brackets instead of single.

+
+ +

Objetos "Normal", e funções

+ +

A JavaScript object is a mapping between keys and values. Keys are strings (or {{jsxref("Symbol")}}s) and values can be anything. This makes objects a natural fit for hashmaps.

+ +

Functions are regular objects with the additional capability of being callable.

+ +

Dates

+ +

When representing dates, the best choice is to use the built-in Date utility in JavaScript.

+ +

Coleções indexadas: Arrays e Arrays digitados

+ +

Arrays are regular objects for which there is a particular relationship between integer-key-ed properties and the 'length' property. Additionally, arrays inherit from Array.prototype which provides to them a handful of convenient methods to manipulate arrays. For example, indexOf (searching a value in the array) or push (adding an element to the array), etc. This makes Arrays a perfect candidate to represent lists or sets.

+ +

Typed Arrays are new to JavaScript with ECMAScript Edition 6 and present an array-like view of an underlying binary data buffer. The following table helps you to find the equivalent C data types:

+ +

{{page("/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects", "", 0, 3)}}

+ +

Keyed collections: Maps, Sets, WeakMaps, WeakSets

+ +

These data structures take object references as keys and are introduced in ECMAScript Edition 6. {{jsxref("Set")}} and {{jsxref("WeakSet")}} represent a set of objects, while {{jsxref("Map")}} and {{jsxref("WeakMap")}} associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.

+ +

One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) can have look-up performance that is approximately logarithmic to constant time.

+ +

Usually, to bind data to a DOM node, one could set properties directly on the object or use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make it easy to privately bind data to an object.

+ +

Structured data: JSON

+ +

JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See {{Glossary("JSON")}} and {{jsxref("JSON")}} for more details.

+ +

More objects in the standard library

+ +

JavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.

+ +

Determining types using the typeof operator

+ +

The typeof operator can help you to find the type of your variable. Please read the reference page for more details and edge cases.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-8', 'Types')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}{{Spec2('ESDraft')}} 
+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/estruturas_de_dados/index.html b/files/pt-pt/web/javascript/estruturas_de_dados/index.html deleted file mode 100644 index 8b8578229b..0000000000 --- a/files/pt-pt/web/javascript/estruturas_de_dados/index.html +++ /dev/null @@ -1,297 +0,0 @@ ---- -title: Tipos de dados de JavaScript e estruturas de dados -slug: Web/JavaScript/Estruturas_de_dados -tags: - - JavaScript - - Principiante - - Tipos -translation_of: Web/JavaScript/Data_structures ---- -
{{jsSidebar("More")}}
- -

Programming languages all have built-in data structures, but these often differ from one language to another. This article attempts to list the built-in data structures available in JavaScript and what properties they have; these can be used to build other data structures. When possible, comparisons with other languages are drawn.

- -

Digitação dinâmica

- -

JavaScript is a loosely typed or a dynamic language. Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned)  values of all types:

- -
var foo = 42;    // foo is now a Number
-var foo = 'bar'; // foo is now a String
-var foo = true;  // foo is now a Boolean
-
- -

Tipos de dados

- -

The latest ECMAScript standard defines seven data types:

- - - -

Valores primitivos

- -

All types except objects define immutable values (values, which are incapable of being changed). For example and unlike to C, Strings are immutable. We refer to values of these types as "primitive values".

- -

Tipo booleano

- -

Boolean represents a logical entity and can have two values: true, and false.

- -

Tipo Null

- -

The Null type has exactly one value: null. See {{jsxref("null")}} and {{Glossary("Null")}} for more details.

- -

Tipo indefinido

- -

A variable that has not been assigned a value has the value undefined. See {{jsxref("undefined")}} and {{Glossary("Undefined")}} for more details.

- -

Tipo número

- -

According to the ECMAScript standard, there is only one number type: the double-precision 64-bit binary format IEEE 754 value (number between -(253 -1) and 253 -1). There is no specific type for integers. In addition to being able to represent floating-point numbers, the number type has three symbolic values: +Infinity, -Infinity, and NaN (not-a-number).

- -

To check for the largest available value or smallest available value within +/-Infinity, you can use the constants {{jsxref("Number.MAX_VALUE")}} or {{jsxref("Number.MIN_VALUE")}} and starting with ECMAScript 6, you are also able to check if a number is in the double-precision floating-point number range using {{jsxref("Number.isSafeInteger()")}} as well as {{jsxref("Number.MAX_SAFE_INTEGER")}} and {{jsxref("Number.MIN_SAFE_INTEGER")}}. Beyond this range, integers in JavaScript are not safe anymore and will be a double-precision floating point approximation of the value.

- -

The number type has only one integer that has two representations: 0 is represented as -0 and +0. ("0" is an alias for +0). In the praxis, this has almost no impact. For example +0 === -0 is true. However, you are able to notice this when you divide by zero:

- -
> 42 / +0
-Infinity
-> 42 / -0
--Infinity
-
- -

Although a number often represents only its value, JavaScript provides some binary operators. These can be used to represent several Boolean values within a single number using bit masking. However, this is usually considered a bad practice, since JavaScript offers other means to represent a set of Booleans (like an array of Booleans or an object with Boolean values assigned to named properties). Bit masking also tends to make code more difficult to read, understand, and maintain. It may be necessary to use such techniques in very constrained environments, like when trying to cope with the storage limitation of local storage or in extreme cases when each bit over the network counts. This technique should only be considered when it is the last measure that can be taken to optimize size.

- -

Tipo string

- -

JavaScript's {{jsxref("Global_Objects/String", "String")}} type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it.

- -

Unlike in languages like C, JavaScript strings are immutable. This means that once a string is created, it is not possible to modify it. However, it is still possible to create another string based on an operation on the original string. For example:

- - - -

Beware of "stringly-typing" your code!

- -

It can be tempting to use strings to represent complex data. Doing this comes with short-term benefits:

- - - -

With conventions, it is possible to represent any data structure in a string. This does not make it a good idea. For instance, with a separator, one could emulate a list (while a JavaScript array would be more suitable). Unfortunately, when the separator is used in one of the "list" elements, then, the list is broken. An escape character can be chosen, etc. All of this requires conventions and creates an unnecessary maintenance burden.

- -

Use strings for textual data. When representing complex data, parse strings and use the appropriate abstraction.

- -

Tipo símbolo

- -

Symbols are new to JavaScript in ECMAScript Edition 6. A Symbol is a unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called atoms. For more details see {{Glossary("Symbol")}} and the {{jsxref("Symbol")}} object wrapper in JavaScript.

- -

Objetos

- -

In computer science, an object is a value in memory which is possibly referenced by an {{Glossary("Identifier", "identifier")}}.

- -

Propriedades

- -

In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.

- -

There are two types of object properties which have certain attributes: The data property and the accessor property.

- -

Data property

- -

Associates a key with a value and has the following attributes:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Attributes of a data property
AttributeTypeDescriptionDefault value
[[Value]]Any JavaScript typeThe value retrieved by a get access of the property.undefined
[[Writable]]BooleanIf false, the property's [[Value]] can't be changed.false
[[Enumerable]]BooleanIf true, the property will be enumerated in for...in loops. See also Enumerability and ownership of propertiesfalse
[[Configurable]]BooleanIf false, the property can't be deleted and attributes other than [[Value]] and [[Writable]] can't be changed.false
- - - - - - - - - - - - - - - - - - - - - - - - - -
Obsolete attributes (as of ECMAScript 3, renamed in ECMAScript 5)
AttributeTypeDescription
Read-onlyBooleanReversed state of the ES5 [[Writable]] attribute.
DontEnumBooleanReversed state of the ES5 [[Enumerable]] attribute.
DontDeleteBooleanReversed state of the ES5 [[Configurable]] attribute.
- -

Accessor property

- -

Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Attributes of an accessor property
AttributeTypeDescriptionDefault value
[[Get]]Function object or undefinedThe function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get.undefined
[[Set]]Function object or undefinedThe function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set.undefined
[[Enumerable]]BooleanIf true, the property will be enumerated in for...in loops.false
[[Configurable]]BooleanIf false, the property can't be deleted and can't be changed to a data property.false
- -
-

Note: Attribute is usually used by JavaScript engine, so you can't directly access it(see more about Object.defineProperty()).That's why the attribute is put in double square brackets instead of single.

-
- -

Objetos "Normal", e funções

- -

A JavaScript object is a mapping between keys and values. Keys are strings (or {{jsxref("Symbol")}}s) and values can be anything. This makes objects a natural fit for hashmaps.

- -

Functions are regular objects with the additional capability of being callable.

- -

Dates

- -

When representing dates, the best choice is to use the built-in Date utility in JavaScript.

- -

Coleções indexadas: Arrays e Arrays digitados

- -

Arrays are regular objects for which there is a particular relationship between integer-key-ed properties and the 'length' property. Additionally, arrays inherit from Array.prototype which provides to them a handful of convenient methods to manipulate arrays. For example, indexOf (searching a value in the array) or push (adding an element to the array), etc. This makes Arrays a perfect candidate to represent lists or sets.

- -

Typed Arrays are new to JavaScript with ECMAScript Edition 6 and present an array-like view of an underlying binary data buffer. The following table helps you to find the equivalent C data types:

- -

{{page("/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects", "", 0, 3)}}

- -

Keyed collections: Maps, Sets, WeakMaps, WeakSets

- -

These data structures take object references as keys and are introduced in ECMAScript Edition 6. {{jsxref("Set")}} and {{jsxref("WeakSet")}} represent a set of objects, while {{jsxref("Map")}} and {{jsxref("WeakMap")}} associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.

- -

One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) can have look-up performance that is approximately logarithmic to constant time.

- -

Usually, to bind data to a DOM node, one could set properties directly on the object or use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make it easy to privately bind data to an object.

- -

Structured data: JSON

- -

JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See {{Glossary("JSON")}} and {{jsxref("JSON")}} for more details.

- -

More objects in the standard library

- -

JavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.

- -

Determining types using the typeof operator

- -

The typeof operator can help you to find the type of your variable. Please read the reference page for more details and edge cases.

- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-8', 'Types')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}{{Spec2('ESDraft')}} 
- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/gestao_memoria/index.html b/files/pt-pt/web/javascript/gestao_memoria/index.html deleted file mode 100644 index 56bfec0f7f..0000000000 --- a/files/pt-pt/web/javascript/gestao_memoria/index.html +++ /dev/null @@ -1,187 +0,0 @@ ---- -title: Gestão de memória -slug: Web/JavaScript/Gestao_Memoria -tags: - - Desempenho - - JavaScript - - memoria -translation_of: Web/JavaScript/Memory_Management ---- -
{{JsSidebar("Advanced")}}
- -

Introdução

- -

Linguagens de baixo nível, como o C, têm funções pimitivas de gestão de memória, como por exemplo, malloc() e free(). Por outro lado, os valores em JavaScript são alocados quando coisas (objetos, variáveis de texto, etc.) são criadas e "automaticamente" libertadas da memória quando deixam de ser utilizadas. O último processo é chamado de coleção do lixo. Este "automatismo" é uma fonte de mal entendidos e transmite aos programadores de JavaScript ( e aos de outras linguagens de alto nível ) a impressão de que podem decidir não se preocupar com a gestão da memória. Isto é uma erro.

- -

Ciclo da duração da memória

- -

Independentemente da linguagem de programação, o ciclo da duração da memória é praticamente sempre o mesmo:

- -
    -
  1. Alocação da memória necessária
    2. -
  2. Utilização da memória alocada ( leitura, escrita )
    3. -
  3. Libertar a memória alocada quando já não é necessária
    4. -
- -

A segunda etapa é explícita em todas as linguagens. A primeira e a última etapa são explícitas em linguagens de baixo nível mas são, na sua maioria, implícitas em linguagens de alto nível como o JavaScript.

- -

Alocação no JavaScript

- -

Inicialização do valor

- -

Com o intuito de não incomodar o programador com alocações, o JavaScript fá-lo juntamente com a declaração de valores.

- -
var n = 123; // alocação da memória para um número
-var s = 'azerty'; // alocação de memória para um texto
-
-var o = {
-  a: 1,
-  b: null
-}; // alocação de memória para um objeto e o seu conteúdo
-
-// (similar ao objeto) alocação de memória para a matriz e
-// os seus valores
-var a = [1, null, 'abra'];
-
-function f(a) {
-  return a + 2;
-} // alocação de uma função (que é um objeto que pode ser chamado)
-
-// Expressões de funções também alocam um objeto
-someElement.addEventListener('click', function() {
-  someElement.style.backgroundColor = 'blue';
-}, false);
-
- -

Alocação através de chamadas de funções

- -

Algumas chamadas de funções resultam na alocação de um objeto.

- -
var d = new Date(); // alocação de um objeto Date
-
-var e = document.createElement('div'); // alocação de um elemento DOM
- -

Alguns métodos alocam novos valores ou objetos:

- -
var s = 'azerty';
-var s2 = s.substr(0, 3); // s2 é uma nova variável de texto
-// Dado que as variáveis de texto são de valor imutável,
-// o JavaScript pode decidir não alocar memória,
-// mas apenas armazenar o intervalo [0, 3].
-
-var a = ['ouais ouais', 'nan nan'];
-var a2 = ['generation', 'nan nan'];
-var a3 = a.concat(a2);
-// nova matriz de 4 elementos resultando
-// da concatenação dos elementos de a e a2
-
- -

Utilização de valores

- -

Basicamente, a utilização de valores significa a leitura e a escrita na memória alocada. Isto pode ser feito através da leitura ou escrita do valor de uma variável ou uma propriedade de um objeto ou até a passagem de um argumento para uma função.

- -

Remoção quando a memória já não é necessária

- -

A maioria dos problemas de gestão de memória aparecem nesta fase. A tarefa mais difícil é descobrir quando "a memória alocada já não é necessária". Em geral, requer que o programador determine quando, no seu código, este pedaço de memória já não é necessário e a liberte.

- -

Linguagens de alto nível têm embutidas um pedaço de código chamado "coleção de lixo", cuja tarefa é rastrear a alocação e uso da memória, para detetar quando um pedaço de memória já não é necessário e neste caso, automaticamente libertá-la. Este processo é uma aproximação dado que o problema geral de se saber quando um pedaço da memória é necessário, é indecisível ( não pode ser solucionado por um algoritmo ).

- -

Coleção de lixo

- -

Como mencionado anteriormente, o problema geral de automaticamente descobrir quando alguma ocupação de memória "já não é necessária", é indecisível. Como consequência, as coleções de lixo implementam uma restrição à solução para o problema em geral. Esta seção explicará as noções necessárias para se compreender os principais algoritmos da coleção de lixo e as suas limitações.

- -

Referências

- -

A noção principal dos algoritmos de coleção de lixo baseiam-se na noção de referência. Dentro do contexto da gestão de memória, um objeto é dito referenciar outro objeto, se o primeiro tiver acesso ao segundo ( quer implicitamente quer explicitamente ). Por exemplo, um objeto JavaScript tem uma referência ao seu protótipo ( referência implícita )  e aos valores das suas propriedades ( referência explícita ).

- -

Neste contexto, a noção de "objeto" é expandida a algo mais abrangente que um objeto JavaScript e também contém âmbitos de funções ( ou âmbito léxico global ).

- -

Contagem de referências na coleção de lixo

- -

Este é o algoritmo mais simples da coleção de lixo. Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto já não é referenciado por nenhum outro objeto". Um objeto é considerado coletável para a coleção de lixo se tiver nenhuma referenciação por parte de outro objeto.

- -

Exemplo

- -
var o = {
-  a: {
-    b: 2
-  }
-};
-// 2 objetos criados. Um é referenciado por outro como sendo suas propriedades
-// O outro é referenciado por virtude ao ser assignado para a variável 'o'
-// Obviamente, nenhum podem ser coletado pela coleção de lixo
-
-
-var o2 = o; // A variável 'o2' é a segunda coisa que
-            // tem uma referência ao objeto
-o = 1;      // agora, o objeto que era originalmente o 'o' tem uma referência única
-            // corporificada pela variável 'o2'
-
-var oa = o2.a; // referência à propriedade 'a' do objeto.
-               // Este objeto tem agora 2 referências: uma como propriedade,
-               // a outra como variável 'oa'
-
-o2 = 'yo'; // O objeto que era o original 'o' tem agora zero
-           // referências a si próprio. Pode ser coletado para a coleção de lixo
-           // No entanto, a propriedade 'a' ainda é referenciada pela
-           // variável 'oa', logo não pode ser libertado
-
-oa = null; // A propriedade 'a' do objeto original 'o'
-           // tem zero referências a si próprio. Pode ser coletado para a  coleção de lixo.
-
- -

Limitação: ciclos

- -

Existe uma limitação no que se refere aos ciclos. No exemplo seguinte, dois objetos são criados e referenciam-se mutuamente, criando um ciclo. Estes sairão do âmbito depois de uma chamada a uma função e como tal, são efetivamente inúteis e podem ser libertados. No entanto, o algoritmo de contagem de referências considera que os dois objetos têm pelo menos uma referenciação; nenhum pode ser coletado para a coleção de lixo .

- -
function f() {
-  var o = {};
-  var o2 = {};
-  o.a = o2; // o referencia o2
-  o2.a = o; // o2 referencia o
-
-  return 'azerty';
-}
-
-f();
-
- -

Exemplo de aplicação real

- -

O Internet Explorer 6 e 7 são conhecidos por terem um coletor de contagem de referenciações de coleções de lixo para os objetos DOM. Os ciclos são um erro comum que podem gerar percas de memória:

- -
var div;
-window.onload = function() {
-  div = document.getElementById('myDivElement');
-  div.circularReference = div;
-  div.lotsOfData = new Array(10000).join('*');
-};
-
- -

No exemplo acima, o elemento DOM "myDivElement" tem uma referência circular a si próprio na propriedade "circularReference". Se a propriedade não for explicitamente removida ou anulada, o coletor de contagem de referências da coleção de lixo, irá sempre ter uma referenciação intacta e irá manter o elemento DOM na memória mesmo quando for removido da árvore DOM. Se o elemento DOM contém bastante dados ( ilustrado no exemplo acima com a propriedade "lotsOfData" ), a memória consumida por estes dados nunca será libertada.

- -

Algoritmo de marcação e limpeza

- -

Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto é inalcançável".

- -

Este algoritmo assume o conhecimento de um conjunto de objetos chamados "roots" ( em JavaScript, a root - raiz - é um objeto global ). Periodicamente, a coleção de lixo começará pela raíz e procurará todos os objetos que são referenciados a partir desta; depois todos os que são referenciados a partir dos seguintes, etc.. Começando pela raiz, o coletor de lixo irá localizar objetos inalcançáveis; coletando-os.

- -

Este algoritmo é melhor do que o anterior dado que "um objeto tem zero referenciações" leva a um objeto inalcançável. O contrário não é verdade como vimos nos ciclos.

- -

Desde 2012, todos os modernos navegadores de Internet contêm um coletor de marcação e limpeza. Todos os melhoramentos feitos na área da coleção de lixo no JavaScript ( generalização / incrementação / concorrência / coleção de lixo paralela ) nos últimos anos são implemetações de melhoramento deste algoritmo, mas não melhoramentos do algoritmo de coleção de lixo em si nem a sua redução à definição de que quando "um objeto já não é necessário".

- -

Os ciclos já não são um problema.

- -

No primeiro exemplo acima, depois do retorno da chamada à função, 2 objetos já não são referenciados por algo alcançável no objeto global. Consequentemente, irão ser localizados pelo coletor da coleção de lixo.

- -

Limitações: os objetos necessitam de ser explicitamente inalcançáveis

- -

Apesar disto estar marcado como uma limitação, é um caso que raramente ocorre na prática pelo que é por isto que ninguém se preocupa muito com a coleção de lixo.

- -

Ver também

- - diff --git a/files/pt-pt/web/javascript/guia/detalhes_do_modelo_de_objeto/index.html b/files/pt-pt/web/javascript/guia/detalhes_do_modelo_de_objeto/index.html deleted file mode 100644 index 01de143289..0000000000 --- a/files/pt-pt/web/javascript/guia/detalhes_do_modelo_de_objeto/index.html +++ /dev/null @@ -1,735 +0,0 @@ ---- -title: Detalhes do modelo de objeto -slug: Web/JavaScript/Guia/Detalhes_do_modelo_de_objeto -tags: - - Guia(2) - - Intermediário - - JavaScript - - Objeto -translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model ---- -
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}
- -
-

The content of this article is under discussion. Please provide feedback and help us to make this page better: {{bug(1201380)}}.

-
- -

JavaScript is an object-based language based on prototypes, rather than being class-based. Because of this different basis, it can be less apparent how JavaScript allows you to create hierarchies of objects and to have inheritance of properties and their values. This chapter attempts to clarify the situation.

- -

This chapter assumes that you are already somewhat familiar with JavaScript and that you have used JavaScript functions to create simple objects.

- -

Linguagens com base em classe versus protótipo

- -

Class-based object-oriented languages, such as Java and C++, are founded on the concept of two distinct entities: classes and instances.

- - - -

A prototype-based language, such as JavaScript, does not make this distinction: it simply has objects. A prototype-based language has the notion of a prototypical object, an object used as a template from which to get the initial properties for a new object. Any object can specify its own properties, either when you create it or at run time. In addition, any object can be associated as the prototype for another object, allowing the second object to share the first object's properties.

- -

Definição de uma classe

- -

In class-based languages, you define a class in a separate class definition. In that definition you can specify special methods, called constructors, to create instances of the class. A constructor method can specify initial values for the instance's properties and perform other processing appropriate at creation time. You use the new operator in association with the constructor method to create class instances.

- -

JavaScript follows a similar model, but does not have a class definition separate from the constructor. Instead, you define a constructor function to create objects with a particular initial set of properties and values. Any JavaScript function can be used as a constructor. You use the new operator with a constructor function to create a new object.

- -

Subclasses e sucessão

- -

In a class-based language, you create a hierarchy of classes through the class definitions. In a class definition, you can specify that the new class is a subclass of an already existing class. The subclass inherits all the properties of the superclass and additionally can add new properties or modify the inherited ones. For example, assume the Employee class includes only the name and dept properties, and Manager is a subclass of Employee that adds the reports property. In this case, an instance of the Manager class would have all three properties: name, dept, and reports.

- -

JavaScript implements inheritance by allowing you to associate a prototypical object with any constructor function. So, you can create exactly the Employee — Manager example, but you use slightly different terminology. First you define the Employee constructor function, specifying the name and dept properties. Next, you define the Manager constructor function, calling the Employee constructor and specifying the reports property. Finally, you assign a new object derived from Employee.prototype as the prototype for the Manager constructor function. Then, when you create a new Manager, it inherits the name and dept properties from the Employee object.

- -

Adição e remoção de propriedades

- -

In class-based languages, you typically create a class at compile time and then you instantiate instances of the class either at compile time or at run time. You cannot change the number or the type of properties of a class after you define the class. In JavaScript, however, at run time you can add or remove properties of any object. If you add a property to an object that is used as the prototype for a set of objects, the objects for which it is the prototype also get the new property.

- -

Resumo das diferenças

- -

The following table gives a short summary of some of these differences. The rest of this chapter describes the details of using JavaScript constructors and prototypes to create an object hierarchy and compares this to how you would do it in Java.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Comparison of class-based (Java) and prototype-based (JavaScript) object systems
Com base em Classe (Java)Com base em Protótipo (JavaScript)
Class and instance are distinct entities.All objects can inherit from another object.
Define a class with a class definition; instantiate a class with constructor methods.Define and create a set of objects with constructor functions.
Create a single object with the new operator.Same.
Construct an object hierarchy by using class definitions to define subclasses of existing classes.Construct an object hierarchy by assigning an object as the prototype associated with a constructor function.
Inherit properties by following the class chain.Inherit properties by following the prototype chain.
Class definition specifies all properties of all instances of a class. Cannot add properties dynamically at run time.Constructor function or prototype specifies an initial set of properties. Can add or remove properties dynamically to individual objects or to the entire set of objects.
- -

The employee example

- -

The remainder of this chapter uses the employee hierarchy shown in the following figure.

- -
-
-

A simple object hierarchy with the following objects:

- -

-
- -
-
    -
  • Employee has the properties name (whose value defaults to the empty string) and dept (whose value defaults to "general").
    • -
  • Manager is based on Employee. It adds the reports property (whose value defaults to an empty array, intended to have an array of Employee objects as its value).
    • -
  • WorkerBee is also based on Employee. It adds the projects property (whose value defaults to an empty array, intended to have an array of strings as its value).
    • -
  • SalesPerson is based on WorkerBee. It adds the quota property (whose value defaults to 100). It also overrides the dept property with the value "sales", indicating that all salespersons are in the same department.
    • -
  • Engineer is based on WorkerBee. It adds the machine property (whose value defaults to the empty string) and also overrides the dept property with the value "engineering".
    • -
-
-
- -

Criação de hierarquia

- -

There are several ways to define appropriate constructor functions to implement the Employee hierarchy. How you choose to define them depends largely on what you want to be able to do in your application.

- -

This section shows how to use very simple (and comparatively inflexible) definitions to demonstrate how to get the inheritance to work. In these definitions, you cannot specify any property values when you create an object. The newly-created object simply gets the default values, which you can change at a later time.

- -

In a real application, you would probably define constructors that allow you to provide property values at object creation time (see More flexible constructors for information). For now, these simple definitions demonstrate how the inheritance occurs.

- -

The following Java and JavaScript Employee definitions are similar. The only difference is that you need to specify the type for each property in Java but not in JavaScript (this is due to Java being a strongly typed language while JavaScript is a weakly typed language).

- -
-

JavaScript

- -
function Employee() {
-  this.name = "";
-  this.dept = "general";
-}
-
- -

Java

- -
public class Employee {
-   public String name = "";
-   public String dept = "general";
-}
-
-
- -

The Manager and WorkerBee definitions show the difference in how to specify the next object higher in the inheritance chain. In JavaScript, you add a prototypical instance as the value of the prototype property of the constructor function. You can do so at any time after you define the constructor. In Java, you specify the superclass within the class definition. You cannot change the superclass outside the class definition.

- -
-

JavaScript

- -
function Manager() {
-  Employee.call(this);
-  this.reports = [];
-}
-Manager.prototype = Object.create(Employee.prototype);
-
-function WorkerBee() {
-  Employee.call(this);
-  this.projects = [];
-}
-WorkerBee.prototype = Object.create(Employee.prototype);
-
- -

Java

- -
public class Manager extends Employee {
-   public Employee[] reports = new Employee[0];
-}
-
-
-
-public class WorkerBee extends Employee {
-   public String[] projects = new String[0];
-}
-
-
-
-
- -

The Engineer and SalesPerson definitions create objects that descend from WorkerBee and hence from Employee. An object of these types has properties of all the objects above it in the chain. In addition, these definitions override the inherited value of the dept property with new values specific to these objects.

- -
-

JavaScript

- -
function SalesPerson() {
-   WorkerBee.call(this);
-   this.dept = "sales";
-   this.quota = 100;
-}
-SalesPerson.prototype = Object.create(WorkerBee.prototype);
-
-function Engineer() {
-   WorkerBee.call(this);
-   this.dept = "engineering";
-   this.machine = "";
-}
-Engineer.prototype = Object.create(WorkerBee.prototype);
-
- -

Java

- -
public class SalesPerson extends WorkerBee {
-   public double quota;
-   public dept = "sales";
-   public quota = 100.0;
-}
-
-
-public class Engineer extends WorkerBee {
-   public String machine;
-   public dept = "engineering";
-   public machine = "";
-}
-
-
-
- -

Using these definitions, you can create instances of these objects that get the default values for their properties. The next figure illustrates using these JavaScript definitions to create new objects and shows the property values for the new objects.

- -
-

Nota: The term instance has a specific technical meaning in class-based languages. In these languages, an instance is an individual instantiation of a class and is fundamentally different from a class. In JavaScript, "instance" does not have this technical meaning because JavaScript does not have this difference between classes and instances. However, in talking about JavaScript, "instance" can be used informally to mean an object created using a particular constructor function. So, in this example, you could informally say that jane is an instance of Engineer. Similarly, although the terms parent, child, ancestor, and descendant do not have formal meanings in JavaScript; you can use them informally to refer to objects higher or lower in the prototype chain.

-
- -

Criação de objetos com definições simples

- -
-

Hierarquia do objeto

- -

The following hierarchy is created using the code on the right side.

- -

- -

 

- -

individual objects

- -
var jim = new Employee;
-// jim.name is ''
-// jim.dept is 'general'
-
-var sally = new Manager;
-// sally.name is ''
-// sally.dept is 'general'
-// sally.reports is []
-
-var mark = new WorkerBee;
-// mark.name is ''
-// mark.dept is 'general'
-// mark.projects is []
-
-var fred = new SalesPerson;
-// fred.name is ''
-// fred.dept is 'sales'
-// fred.projects is []
-// fred.quota is 100
-
-var jane = new Engineer;
-// jane.name is ''
-// jane.dept is 'engineering'
-// jane.projects is []
-// jane.machine is ''
-
-
- -

Propriedades do objeto

- -

This section discusses how objects inherit properties from other objects in the prototype chain and what happens when you add a property at run time.

- -

Propriedades de sucessão

- -

Suppose you create the mark object as a WorkerBee with the following statement:

- -
var mark = new WorkerBee;
-
- -

When JavaScript sees the new operator, it creates a new generic object and passes this new object as the value of the this keyword to the WorkerBee constructor function. The constructor function explicitly sets the value of the projects property, and implicitly sets the value of the internal __proto__ property to the value of WorkerBee.prototype. (That property name has two underscore characters at the front and two at the end.) The __proto__ property determines the prototype chain used to return property values. Once these properties are set, JavaScript returns the new object and the assignment statement sets the variable mark to that object.

- -

This process does not explicitly put values in the mark object (local values) for the properties that mark inherits from the prototype chain. When you ask for the value of a property, JavaScript first checks to see if the value exists in that object. If it does, that value is returned. If the value is not there locally, JavaScript checks the prototype chain (using the __proto__ property). If an object in the prototype chain has a value for the property, that value is returned. If no such property is found, JavaScript says the object does not have the property. In this way, the mark object has the following properties and values:

- -
mark.name = "";
-mark.dept = "general";
-mark.projects = [];
-
- -

The mark object inherits values for the name and dept properties from the prototypical object in mark.__proto__. It is assigned a local value for the projects property by the WorkerBee constructor. This gives you inheritance of properties and their values in JavaScript. Some subtleties of this process are discussed in Property inheritance revisited.

- -

Because these constructors do not let you supply instance-specific values, this information is generic. The property values are the default ones shared by all new objects created from WorkerBee. You can, of course, change the values of any of these properties. So, you could give specific information for mark as follows:

- -
mark.name = "Doe, Mark";
-mark.dept = "admin";
-mark.projects = ["navigator"];
- -

Adição de propriedades

- -

In JavaScript, you can add properties to any object at run time. You are not constrained to use only the properties provided by the constructor function. To add a property that is specific to a single object, you assign a value to the object, as follows:

- -
mark.bonus = 3000;
-
- -

Now, the mark object has a bonus property, but no other WorkerBee has this property.

- -

If you add a new property to an object that is being used as the prototype for a constructor function, you add that property to all objects that inherit properties from the prototype. For example, you can add a specialty property to all employees with the following statement:

- -
Employee.prototype.specialty = "none";
-
- -

As soon as JavaScript executes this statement, the mark object also has the specialty property with the value of "none". The following figure shows the effect of adding this property to the Employee prototype and then overriding it for the Engineer prototype.

- -


- Adding properties

- -

Mais construtores flexíveis

- -

The constructor functions shown so far do not let you specify property values when you create an instance. As with Java, you can provide arguments to constructors to initialize property values for instances. The following figure shows one way to do this.

- -


- Specifying properties in a constructor, take 1

- -

The following table shows the Java and JavaScript definitions for these objects.

- -
-

JavaScript

- -

Java

-
- -
-
function Employee (name, dept) {
-  this.name = name || "";
-  this.dept = dept || "general";
-}
-
- -

 

- -

 

- -

 

- -

 

- -

 

- -
public class Employee {
-   public String name;
-   public String dept;
-   public Employee () {
-      this("", "general");
-   }
-   public Employee (String name) {
-      this(name, "general");
-   }
-   public Employee (String name, String dept) {
-      this.name = name;
-      this.dept = dept;
-   }
-}
-
-
- -
-
function WorkerBee (projs) {
-
- this.projects = projs || [];
-}
-WorkerBee.prototype = new Employee;
-
- -

 

- -

 

- -

 

- -
public class WorkerBee extends Employee {
-   public String[] projects;
-   public WorkerBee () {
-      this(new String[0]);
-   }
-   public WorkerBee (String[] projs) {
-      projects = projs;
-   }
-}
-
-
- -
-
-function Engineer (mach) {
-   this.dept = "engineering";
-   this.machine = mach || "";
-}
-Engineer.prototype = new WorkerBee;
-
- -

 

- -

 

- -

 

- -
public class Engineer extends WorkerBee {
-   public String machine;
-   public Engineer () {
-      dept = "engineering";
-      machine = "";
-   }
-   public Engineer (String mach) {
-      dept = "engineering";
-      machine = mach;
-   }
-}
-
-
- -

These JavaScript definitions use a special idiom for setting default values:

- -
this.name = name || "";
-
- -

The JavaScript logical OR operator (||) evaluates its first argument. If that argument converts to true, the operator returns it. Otherwise, the operator returns the value of the second argument. Therefore, this line of code tests to see if name has a useful value for the name property. If it does, it sets this.name to that value. Otherwise, it sets this.name to the empty string. This chapter uses this idiom for brevity; however, it can be puzzling at first glance.

- -
-

Note: This may not work as expected if the constructor function is called with arguments which convert to false (like 0 (zero) and empty string (""). In this case the default value will be chosen.

-
- -

With these definitions, when you create an instance of an object, you can specify values for the locally defined properties. You can use the following statement to create a new Engineer:

- -
var jane = new Engineer("belau");
-
- -

Jane's properties are now:

- -
jane.name == "";
-jane.dept == "engineering";
-jane.projects == [];
-jane.machine == "belau"
-
- -

Notice that with these definitions, you cannot specify an initial value for an inherited property such as name. If you want to specify an initial value for inherited properties in JavaScript, you need to add more code to the constructor function.

- -

So far, the constructor function has created a generic object and then specified local properties and values for the new object. You can have the constructor add more properties by directly calling the constructor function for an object higher in the prototype chain. The following figure shows these new definitions.

- -


- Specifying properties in a constructor, take 2

- -

Let's look at one of these definitions in detail. Here's the new definition for the Engineer constructor:

- -
function Engineer (name, projs, mach) {
-  this.base = WorkerBee;
-  this.base(name, "engineering", projs);
-  this.machine = mach || "";
-}
-
- -

Suppose you create a new Engineer object as follows:

- -
var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
-
- -

JavaScript follows these steps:

- -
    -
  1. The new operator creates a generic object and sets its __proto__ property to Engineer.prototype.
    2. -
  2. The new operator passes the new object to the Engineer constructor as the value of the this keyword.
    3. -
  3. The constructor creates a new property called base for that object and assigns the value of the WorkerBee constructor to the base property. This makes the WorkerBee constructor a method of the Engineer object.The name of the base property is not special. You can use any legal property name; base is simply evocative of its purpose.
    4. -
  4. -

    The constructor calls the base method, passing as its arguments two of the arguments passed to the constructor ("Doe, Jane" and ["navigator", "javascript"]) and also the string "engineering". Explicitly using "engineering" in the constructor indicates that all Engineer objects have the same value for the inherited dept property, and this value overrides the value inherited from Employee.

    -
    5. -
  5. Because base is a method of Engineer, within the call to base, JavaScript binds the this keyword to the object created in Step 1. Thus, the WorkerBee function in turn passes the "Doe, Jane" and "engineering" arguments to the Employee constructor function. Upon return from the Employee constructor function, the WorkerBee function uses the remaining argument to set the projects property.
    6. -
  6. Upon return from the base method, the Engineer constructor initializes the object's machine property to "belau".
    7. -
  7. Upon return from the constructor, JavaScript assigns the new object to the jane variable.
    8. -
- -

You might think that, having called the WorkerBee constructor from inside the Engineer constructor, you have set up inheritance appropriately for Engineer objects. This is not the case. Calling the WorkerBee constructor ensures that an Engineer object starts out with the properties specified in all constructor functions that are called. However, if you later add properties to the Employee or WorkerBee prototypes, those properties are not inherited by the Engineer object. For example, assume you have the following statements:

- -
function Engineer (name, projs, mach) {
-  this.base = WorkerBee;
-  this.base(name, "engineering", projs);
-  this.machine = mach || "";
-}
-var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
-Employee.prototype.specialty = "none";
-
- -

The jane object does not inherit the specialty property. You still need to explicitly set up the prototype to ensure dynamic inheritance. Assume instead you have these statements:

- -
function Engineer (name, projs, mach) {
-  this.base = WorkerBee;
-  this.base(name, "engineering", projs);
-  this.machine = mach || "";
-}
-Engineer.prototype = new WorkerBee;
-var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
-Employee.prototype.specialty = "none";
-
- -

Now the value of the jane object's specialty property is "none".

- -

Another way of inheriting is by using the call() / apply() methods. Below are equivalent:

- -
-
function Engineer (name, projs, mach) {
-  this.base = WorkerBee;
-  this.base(name, "engineering", projs);
-  this.machine = mach || "";
-}
-
- -
function Engineer (name, projs, mach) {
-  WorkerBee.call(this, name, "engineering", projs);
-  this.machine = mach || "";
-}
-
-
- -

Using the javascript call() method makes a cleaner implementation because the base is not needed anymore.

- -

Sucessão de propriedade revisitada

- -

The preceding sections described how JavaScript constructors and prototypes provide hierarchies and inheritance. This section discusses some subtleties that were not necessarily apparent in the earlier discussions.

- -

Valores locais versus sucedidos

- -

When you access an object property, JavaScript performs these steps, as described earlier in this chapter:

- -
    -
  1. Check to see if the value exists locally. If it does, return that value.
    2. -
  2. If there is not a local value, check the prototype chain (using the __proto__ property).
    3. -
  3. If an object in the prototype chain has a value for the specified property, return that value.
    4. -
  4. If no such property is found, the object does not have the property.
    5. -
- -

The outcome of these steps depends on how you define things along the way. The original example had these definitions:

- -
function Employee () {
-  this.name = "";
-  this.dept = "general";
-}
-
-function WorkerBee () {
-  this.projects = [];
-}
-WorkerBee.prototype = new Employee;
-
- -

With these definitions, suppose you create amy as an instance of WorkerBee with the following statement:

- -
var amy = new WorkerBee;
-
- -

The amy object has one local property, projects. The values for the name and dept properties are not local to amy and so derive from the amy object's __proto__ property. Thus, amy has these property values:

- -
amy.name == "";
-amy.dept == "general";
-amy.projects == [];
-
- -

Now suppose you change the value of the name property in the prototype associated with Employee:

- -
Employee.prototype.name = "Unknown"
-
- -

At first glance, you might expect that new value to propagate down to all the instances of Employee. However, it does not.

- -

When you create any instance of the Employee object, that instance gets a local value for the name property (the empty string). This means that when you set the WorkerBee prototype by creating a new Employee object, WorkerBee.prototype has a local value for the name property. Therefore, when JavaScript looks up the name property of the amy object (an instance of WorkerBee), JavaScript finds the local value for that property in WorkerBee.prototype. It therefore does not look further up the chain to Employee.prototype.

- -

If you want to change the value of an object property at run time and have the new value be inherited by all descendants of the object, you cannot define the property in the object's constructor function. Instead, you add it to the constructor's associated prototype. For example, assume you change the preceding code to the following:

- -
function Employee () {
-  this.dept = "general";
-}
-Employee.prototype.name = "";
-
-function WorkerBee () {
-  this.projects = [];
-}
-WorkerBee.prototype = new Employee;
-
-var amy = new WorkerBee;
-
-Employee.prototype.name = "Unknown";
-
- -

In this case, the name property of amy becomes "Unknown".

- -

As these examples show, if you want to have default values for object properties and you want to be able to change the default values at run time, you should set the properties in the constructor's prototype, not in the constructor function itself.

- -

Determining instance relationships

- -

Property lookup in JavaScript looks within an object's own properties and, if the property name is not found, it looks within the special object property __proto__. This continues recursively; the process is called "lookup in the prototype chain".

- -

The special property __proto__ is set when an object is constructed; it is set to the value of the constructor's prototype property. So the expression new Foo() creates an object with __proto__ == Foo.prototype. Consequently, changes to the properties of Foo.prototype alters the property lookup for all objects that were created by new Foo().

- -

Every object has a __proto__ object property (except Object); every function has a prototype object property. So objects can be related by 'prototype inheritance' to other objects. You can test for inheritance by comparing an object's __proto__ to a function's prototype object. JavaScript provides a shortcut: the instanceof operator tests an object against a function and returns true if the object inherits from the function prototype. For example,

- -
var f = new Foo();
-var isTrue = (f instanceof Foo);
- -

For a more detailed example, suppose you have the same set of definitions shown in Inheriting properties. Create an Engineer object as follows:

- -
var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
-
- -

With this object, the following statements are all true:

- -
chris.__proto__ == Engineer.prototype;
-chris.__proto__.__proto__ == WorkerBee.prototype;
-chris.__proto__.__proto__.__proto__ == Employee.prototype;
-chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
-chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
-
- -

Given this, you could write an instanceOf function as follows:

- -
function instanceOf(object, constructor) {
-   object = object.__proto__;
-   while (object != null) {
-      if (object == constructor.prototype)
-         return true;
-      if (typeof object == 'xml') {
-        return constructor.prototype == XML.prototype;
-      }
-      object = object.__proto__;
-   }
-   return false;
-}
-
- -
Note: The implementation above checks the type of the object against "xml" in order to work around a quirk of how XML objects are represented in recent versions of JavaScript. See {{ bug(634150) }} if you want the nitty-gritty details.
- -

Using the instanceOf function defined above, these expressions are true:

- -
instanceOf (chris, Engineer)
-instanceOf (chris, WorkerBee)
-instanceOf (chris, Employee)
-instanceOf (chris, Object)
-
- -

But the following expression is false:

- -
instanceOf (chris, SalesPerson)
-
- -

Informação global nos construtores

- -

When you create constructors, you need to be careful if you set global information in the constructor. For example, assume that you want a unique ID to be automatically assigned to each new employee. You could use the following definition for Employee:

- -
var idCounter = 1;
-
-function Employee (name, dept) {
-   this.name = name || "";
-   this.dept = dept || "general";
-   this.id = idCounter++;
-}
-
- -

With this definition, when you create a new Employee, the constructor assigns it the next ID in sequence and then increments the global ID counter. So, if your next statement is the following, victoria.id is 1 and harry.id is 2:

- -
var victoria = new Employee("Pigbert, Victoria", "pubs")
-var harry = new Employee("Tschopik, Harry", "sales")
-
- -

At first glance that seems fine. However, idCounter gets incremented every time an Employee object is created, for whatever purpose. If you create the entire Employee hierarchy shown in this chapter, the Employee constructor is called every time you set up a prototype. Suppose you have the following code:

- -
var idCounter = 1;
-
-function Employee (name, dept) {
-   this.name = name || "";
-   this.dept = dept || "general";
-   this.id = idCounter++;
-}
-
-function Manager (name, dept, reports) {...}
-Manager.prototype = new Employee;
-
-function WorkerBee (name, dept, projs) {...}
-WorkerBee.prototype = new Employee;
-
-function Engineer (name, projs, mach) {...}
-Engineer.prototype = new WorkerBee;
-
-function SalesPerson (name, projs, quota) {...}
-SalesPerson.prototype = new WorkerBee;
-
-var mac = new Engineer("Wood, Mac");
-
- -

Further assume that the definitions omitted here have the base property and call the constructor above them in the prototype chain. In this case, by the time the mac object is created, mac.id is 5.

- -

Depending on the application, it may or may not matter that the counter has been incremented these extra times. If you care about the exact value of this counter, one possible solution involves instead using the following constructor:

- -
function Employee (name, dept) {
-   this.name = name || "";
-   this.dept = dept || "general";
-   if (name)
-      this.id = idCounter++;
-}
-
- -

When you create an instance of Employee to use as a prototype, you do not supply arguments to the constructor. Using this definition of the constructor, when you do not supply arguments, the constructor does not assign a value to the id and does not update the counter. Therefore, for an Employee to get an assigned id, you must specify a name for the employee. In this example, mac.id would be 1.

- -

No multiple inheritance

- -

Some object-oriented languages allow multiple inheritance. That is, an object can inherit the properties and values from unrelated parent objects. JavaScript does not support multiple inheritance.

- -

Inheritance of property values occurs at run time by JavaScript searching the prototype chain of an object to find a value. Because an object has a single associated prototype, JavaScript cannot dynamically inherit from more than one prototype chain.

- -

In JavaScript, you can have a constructor function call more than one other constructor function within it. This gives the illusion of multiple inheritance. For example, consider the following statements:

- -
function Hobbyist (hobby) {
-   this.hobby = hobby || "scuba";
-}
-
-function Engineer (name, projs, mach, hobby) {
-   this.base1 = WorkerBee;
-   this.base1(name, "engineering", projs);
-   this.base2 = Hobbyist;
-   this.base2(hobby);
-   this.machine = mach || "";
-}
-Engineer.prototype = new WorkerBee;
-
-var dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")
-
- -

Further assume that the definition of WorkerBee is as used earlier in this chapter. In this case, the dennis object has these properties:

- -
dennis.name == "Doe, Dennis"
-dennis.dept == "engineering"
-dennis.projects == ["collabra"]
-dennis.machine == "hugo"
-dennis.hobby == "scuba"
-
- -

So dennis does get the hobby property from the Hobbyist constructor. However, assume you then add a property to the Hobbyist constructor's prototype:

- -
Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
-
- -

The dennis object does not inherit this new property.

- -
{{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}
diff --git a/files/pt-pt/web/javascript/guia/expressoes_e_operadores/index.html b/files/pt-pt/web/javascript/guia/expressoes_e_operadores/index.html deleted file mode 100644 index d0c815aac5..0000000000 --- a/files/pt-pt/web/javascript/guia/expressoes_e_operadores/index.html +++ /dev/null @@ -1,832 +0,0 @@ ---- -title: Expressoes e Operadores -slug: Web/JavaScript/Guia/Expressoes_e_Operadores ---- -
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}
-

Este capítulo descreve expressões e operadores JavaScript, incluindo atribuição, comparação, aritmética, bit a bit, lógico, string, e operadores especiais.

- -

Expressões

- -

Uma expressão é qualquer unidade de código válida que resolve um valor.

- -

Conceitualmente, há dois tipos de expressões: aqueles que atribui um valor para uma variável, e aqueles que simplesmente tem um valor. Por exemplo, a expressão x = 7 é uma expressão que atribui a x o valor sete. Esta expressão avalia-se a sete. Tais expressões usam operadores de atribuição. Por outro lado, a expressão de 3 + 4 simplesmente avalia a sete; ele não realiza uma atribuição. Os operadores usados ​​em tais expressões são referidos simplesmente como operadores.

- -

JavaScript tem os seguintes tipos de expressões:

- - - -

Operadores

- -

JavaScript tem os seguintes tipos de operadores. Esta seção descreve os operadores e contém informações sobre a precedência do operador.

- - - -

JavaScript has both binary and unary operators, and one special ternary operator, the conditional operator. A binary operator requires two operands, one before the operator and one after the operator:

- -
operand1 operator operand2
-
- -

For example, 3+4 or x*y.

- -

A unary operator requires a single operand, either before or after the operator:

- -
operator operand
-
- -

or

- -
operand operator
-
- -

For example, x++ or ++x.

- -

Assignment operators

- -

An assignment operator assigns a value to its left operand based on the value of its right operand. The basic assignment operator is equal (=), which assigns the value of its right operand to its left operand. That is, x = y assigns the value of y to x.

- -

The other assignment operators are shorthand for standard operations, as shown in the following table.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.1 Assignment operators
Shorthand operatorMeaning
x += yx = x + y
x -= yx = x - y
x *= yx = x * y
x /= yx = x / y
x %= yx = x % y
x <<= yx = x << y
x >>= yx = x >> y
x >>>= yx = x >>> y
x &= yx = x & y
x ^= yx = x ^ y
x |= yx = x | y
- -

Comparison operators

- -

This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="... A comparison operator compares its operands and returns a logical value based on whether the comparison is true. The operands can be numerical, string, logical, or object values. Strings are compared based on standard lexicographical ordering, using Unicode values. In most cases, if the two operands are not of the same type, JavaScript attempts to convert the operands to an appropriate type for the comparison. (The sole exceptions to this rule are === and !==, which perform "strict" equality and inequality and which do not attempt to convert the operands to compatible types before checking equality.) This generally results in a numerical comparison being performed. The following table describes the comparison operators, assuming the following code:

- -
var var1 = 3, var2 = 4;
-
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.2 Comparison operators
OperatorDescriptionExamples returning true
Equal (==)Returns true if the operands are equal.3 == var1 -

"3" == var1

- 3 == '3'
Not equal (!=)Returns true if the operands are not equal.var1 != 4
- var2 != "3"
Strict equal (===)Returns true if the operands are equal and of the same type.3 === var1
Strict not equal (!==)Returns true if the operands are not equal and/or not of the same type.var1 !== "3"
- 3 !== '3'
Greater than (>)Returns true if the left operand is greater than the right operand.var2 > var1
- "12" > 2
Greater than or equal (>=)Returns true if the left operand is greater than or equal to the right operand.var2 >= var1
- var1 >= 3
Less than (<)Returns true if the left operand is less than the right operand.var1 < var2
- "12" < "2"
Less than or equal (<=)Returns true if the left operand is less than or equal to the right operand.var1 <= var2
- var2 <= 5
- -

Arithmetic operators

- -

Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/). These operators work as they do in most other programming languages when used with floating point numbers (in particular, note that division by zero produces NaN). For example:

- -
console.log(1 / 2); /* prints 0.5 */
-console.log(1 / 2 == 1.0 / 2.0); /* also this is true */
-
- -

In addition, JavaScript provides the arithmetic operators listed in the following table.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.3 Arithmetic operators
OperatorDescriptionExample
%
- (Modulus)		Binary operator. Returns the integer remainder of dividing the two operands.12 % 5 returns 2.
++
- (Increment)		Unary operator. Adds one to its operand. If used as a prefix operator (++x), returns the value of its operand after adding one; if used as a postfix operator (x++), returns the value of its operand before adding one.If x is 3, then ++x sets x to 4 and returns 4, whereas x++ returns 3 and, only then, sets x to 4.
--
- (Decrement)		Unary operator. Subtracts one from its operand. The return value is analogous to that for the increment operator.If x is 3, then --x sets x to 2 and returns 2, whereas x-- returns 3 and, only then, sets x to 2.
-
- (Unary negation)		Unary operator. Returns the negation of its operand.If x is 3, then -x returns -3.
- -

Bitwise operators

- -

Bitwise operators treat their operands as a set of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the decimal number nine has a binary representation of 1001. Bitwise operators perform their operations on such binary representations, but they return standard JavaScript numerical values.

- -

The following table summarizes JavaScript's bitwise operators.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.4 Bitwise operators
OperatorUsageDescription
Bitwise ANDa & bReturns a one in each bit position for which the corresponding bits of both operands are ones.
Bitwise ORa | bReturns a one in each bit position for which the corresponding bits of either or both operands are ones.
Bitwise XORa ^ bReturns a one in each bit position for which the corresponding bits of either but not both operands are ones.
Bitwise NOT~ aInverts the bits of its operand.
Left shifta << bShifts a in binary representation b bits to the left, shifting in zeros from the right.
Sign-propagating right shifta >> bShifts a in binary representation b bits to the right, discarding bits shifted off.
Zero-fill right shifta >>> bShifts a in binary representation b bits to the right, discarding bits shifted off, and shifting in zeros from the left.
- -

Bitwise logical operators

- -

Conceptually, the bitwise logical operators work as follows:

- - - -

For example, the binary representation of nine is 1001, and the binary representation of fifteen is 1111. So, when the bitwise operators are applied to these values, the results are as follows:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.5 Bitwise operator examples
ExpressionResultBinary Description
15 & 991111 & 1001 = 1001
15 | 9151111 | 1001 = 1111
15 ^ 961111 ^ 1001 = 0110
~150~1111 = 0000
~96~1001 = 0110
- -

 

- -

Bitwise shift operators

- -

The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.

- -

Shift operators convert their operands to thirty-two-bit integers and return a result of the same type as the left operand.

- -

The shift operators are listed in the following table.

- - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.6 Bitwise shift operators
OperatorDescriptionExample
<<
- (Left shift)		This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right.9<<2 yields 36, because 1001 shifted 2 bits to the left becomes 100100, which is 36.
>>
- (Sign-propagating right shift)		This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left.9>>2 yields 2, because 1001 shifted 2 bits to the right becomes 10, which is 2. Likewise, -9>>2 yields -3, because the sign is preserved.
>>>
- (Zero-fill right shift)		This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left.19>>>2 yields 4, because 10011 shifted 2 bits to the right becomes 100, which is 4. For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result.
- -

Logical operators

- -

Logical operators are typically used with Boolean (logical) values; when they are, they return a Boolean value. However, the && and || operators actually return the value of one of the specified operands, so if these operators are used with non-Boolean values, they may return a non-Boolean value. The logical operators are described in the following table.

- - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.6 Logical operators
OperatorUsageDescription
&&expr1 && expr2(Logical AND) Returns expr1 if it can be converted to false; otherwise, returns expr2. Thus, when used with Boolean values, && returns true if both operands are true; otherwise, returns false.
||expr1 || expr2(Logical OR) Returns expr1 if it can be converted to true; otherwise, returns expr2. Thus, when used with Boolean values, || returns true if either operand is true; if both are false, returns false.
!!expr(Logical NOT) Returns false if its single operand can be converted to true; otherwise, returns true.
- -

Examples of expressions that can be converted to false are those that evaluate to null, 0, the empty string (""), or undefined.

- -

The following code shows examples of the && (logical AND) operator.

- -
var a1 =  true && true;     // t && t returns true
-var a2 =  true && false;    // t && f returns false
-var a3 = false && true;     // f && t returns false
-var a4 = false && (3 == 4); // f && f returns false
-var a5 = "Cat" && "Dog";    // t && t returns Dog
-var a6 = false && "Cat";    // f && t returns false
-var a7 = "Cat" && false;    // t && f returns false
-
- -

The following code shows examples of the || (logical OR) operator.

- -
var o1 =  true || true;     // t || t returns true
-var o2 = false || true;     // f || t returns true
-var o3 =  true || false;    // t || f returns true
-var o4 = false || (3 == 4); // f || f returns false
-var o5 = "Cat" || "Dog";    // t || t returns Cat
-var o6 = false || "Cat";    // f || t returns Cat
-var o7 = "Cat" || false;    // t || f returns Cat
-
- -

The following code shows examples of the ! (logical NOT) operator.

- -
var n1 = !true;  // !t returns false
-var n2 = !false; // !f returns true
-var n3 = !"Cat"; // !t returns false
-
- -

Short-circuit evaluation

- -

As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:

- - - -

The rules of logic guarantee that these evaluations are always correct. Note that the anything part of the above expressions is not evaluated, so any side effects of doing so do not take effect.

- -

String operators

- -

In addition to the comparison operators, which can be used on string values, the concatenation operator (+) concatenates two string values together, returning another string that is the union of the two operand strings. For example, "my " + "string" returns the string "my string".

- -

The shorthand assignment operator += can also be used to concatenate strings. For example, if the variable mystring has the value "alpha", then the expression mystring += "bet" evaluates to "alphabet" and assigns this value to mystring.

- -

Special operators

- -

JavaScript provides the following special operators:

- - - -

Conditional operator

- -

The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is:

- -
condition ? val1 : val2
-
- -

If condition is true, the operator has the value of val1. Otherwise it has the value of val2. You can use the conditional operator anywhere you would use a standard operator.

- -

For example,

- -
var status = (age >= 18) ? "adult" : "minor";
-
- -

This statement assigns the value "adult" to the variable status if age is eighteen or more. Otherwise, it assigns the value "minor" to status.

- -

Comma operator

- -

The comma operator (,) simply evaluates both of its operands and returns the value of the second operand. This operator is primarily used inside a for loop, to allow multiple variables to be updated each time through the loop.

- -

For example, if a is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to increment two variables at once. The code prints the values of the diagonal elements in the array:

- -
for (var i = 0, j = 9; i <= 9; i++, j--)
-  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
-
- -

delete

- -

The delete operator deletes an object, an object's property, or an element at a specified index in an array. The syntax is:

- -
delete objectName;
-delete objectName.property;
-delete objectName[index];
-delete property; // legal only within a with statement
-
- -

where objectName is the name of an object, property is an existing property, and index is an integer representing the location of an element in an array.

- -

The fourth form is legal only within a with statement, to delete a property from an object.

- -

You can use the delete operator to delete variables declared implicitly but not those declared with the var statement.

- -

If the delete operator succeeds, it sets the property or element to undefined. The delete operator returns true if the operation is possible; it returns false if the operation is not possible.

- -
x = 42;
-var y = 43;
-myobj = new Number();
-myobj.h = 4;    // create property h
-delete x;       // returns true (can delete if declared implicitly)
-delete y;       // returns false (cannot delete if declared with var)
-delete Math.PI; // returns false (cannot delete predefined properties)
-delete myobj.h; // returns true (can delete user-defined properties)
-delete myobj;   // returns true (can delete if declared implicitly)
-
- -
Deleting array elements
- -

When you delete an array element, the array length is not affected. For example, if you delete a[3], a[4] is still a[4] and a[3] is undefined.

- -

When the delete operator removes an array element, that element is no longer in the array. In the following example, trees[3] is removed with delete. However, trees[3] is still addressable and returns undefined.

- -
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
-delete trees[3];
-if (3 in trees) {
-  // this does not get executed
-}
-
- -

If you want an array element to exist but have an undefined value, use the undefined keyword instead of the delete operator. In the following example, trees[3] is assigned the value undefined, but the array element still exists:

- -
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
-trees[3] = undefined;
-if (3 in trees) {
-  // this gets executed
-}
-
- -

in

- -

The in operator returns true if the specified property is in the specified object. The syntax is:

- -
propNameOrNumber in objectName
-
- -

where propNameOrNumber is a string or numeric expression representing a property name or array index, and objectName is the name of an object.

- -

The following examples show some uses of the in operator.

- -
// Arrays
-var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
-0 in trees;        // returns true
-3 in trees;        // returns true
-6 in trees;        // returns false
-"bay" in trees;    // returns false (you must specify the index number,
-                   // not the value at that index)
-"length" in trees; // returns true (length is an Array property)
-
-// Predefined objects
-"PI" in Math;          // returns true
-var myString = new String("coral");
-"length" in myString;  // returns true
-
-// Custom objects
-var mycar = {make: "Honda", model: "Accord", year: 1998};
-"make" in mycar;  // returns true
-"model" in mycar; // returns true
-
- -

instanceof

- -

The instanceof operator returns true if the specified object is of the specified object type. The syntax is:

- -
objectName instanceof objectType
-
- -

where objectName is the name of the object to compare to objectType, and objectType is an object type, such as Date or Array.

- -

Use instanceof when you need to confirm the type of an object at runtime. For example, when catching exceptions, you can branch to different exception-handling code depending on the type of exception thrown.

- -

For example, the following code uses instanceof to determine whether theDay is a Date object. Because theDay is a Date object, the statements in the if statement execute.

- -
var theDay = new Date(1995, 12, 17);
-if (theDay instanceof Date) {
-  // statements to execute
-}
-
- -

new

- -

You can use the new operator to create an instance of a user-defined object type or of one of the predefined object types Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, or String. On the server, you can also use it with DbPool, Lock, File, or SendMail. Use new as follows:

- -
var objectName = new objectType([param1, param2, ..., paramN]);
-
- -

You can also create objects using object initializers, as described in {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }}.

- -

See the new operator page in the Core JavaScript Reference for more information.

- -

this

- -

Use the this keyword to refer to the current object. In general, this refers to the calling object in a method. Use this as follows:

- -
this["propertyName"]
-
- -
this.propertyName
-
- -

Example 1.
- Suppose a function called validate validates an object's value property, given the object and the high and low values:

- -
function validate(obj, lowval, hival){
-  if ((obj.value < lowval) || (obj.value > hival))
-    alert("Invalid Value!");
-}
-
- -

You could call validate in each form element's onChange event handler, using this to pass it the form element, as in the following example:

- -
<B>Enter a number between 18 and 99:</B>
-<INPUT TYPE="text" NAME="age" SIZE=3
-   onChange="validate(this, 18, 99);">
-
- -

Example 2.
- When combined with the form property, this can refer to the current object's parent form. In the following example, the form myForm contains a Text object and a button. When the user clicks the button, the value of the Text object is set to the form's name. The button's onClick event handler uses this.form to refer to the parent form, myForm.

- -
<FORM NAME="myForm">
-Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
-<P>
-<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
-   onClick="this.form.text1.value = this.form.name;">
-</FORM>
-
- -

typeof

- -

The typeof operator is used in either of the following ways:

- -
    -
  1. - 
    typeof operand
-
    -
    2. -
  2. - 
    typeof (operand)
-
    -
    3. -
- -

The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.

- -

Suppose you define the following variables:

- -
var myFun = new Function("5 + 2");
-var shape = "round";
-var size = 1;
-var today = new Date();
-
- -

The typeof operator returns the following results for these variables:

- -
typeof myFun;     // returns "function"
-typeof shape;     // returns "string"
-typeof size;      // returns "number"
-typeof today;     // returns "object"
-typeof dontExist; // returns "undefined"
-
- -

For the keywords true and null, the typeof operator returns the following results:

- -
typeof true; // returns "boolean"
-typeof null; // returns "object"
-
- -

For a number or string, the typeof operator returns the following results:

- -
typeof 62;            // returns "number"
-typeof 'Hello world'; // returns "string"
-
- -

For property values, the typeof operator returns the type of value the property contains:

- -
typeof document.lastModified; // returns "string"
-typeof window.length;         // returns "number"
-typeof Math.LN2;              // returns "number"
-
- -

For methods and functions, the typeof operator returns results as follows:

- -
typeof blur;        // returns "function"
-typeof eval;        // returns "function"
-typeof parseInt;    // returns "function"
-typeof shape.split; // returns "function"
-
- -

For predefined objects, the typeof operator returns results as follows:

- -
typeof Date;     // returns "function"
-typeof Function; // returns "function"
-typeof Math;     // returns "object"
-typeof Option;   // returns "function"
-typeof String;   // returns "function"
-
- -

void

- -

The void operator is used in either of the following ways:

- -
    -
  1. - 
    void (expression)
-
    -
    2. -
  2. - 
    void expression
-
    -
    3. -
- -

The void operator specifies an expression to be evaluated without returning a value. expression is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.

- -

You can use the void operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.

- -

The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, void(0) evaluates to undefined, which has no effect in JavaScript.

- -
<A HREF="javascript:void(0)">Click here to do nothing</A>
-
- -

The following code creates a hypertext link that submits a form when the user clicks it.

- -
<A HREF="javascript:void(document.form.submit())">
-Click here to submit</A>
- -

Operator precedence

- -

The precedence of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.

- -

The following table describes the precedence of operators, from highest to lowest.

- -

In accordance with relevant discussion, this table was reversed to list operators in decreasing order of priority.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3.7 Operator precedence
Operator typeIndividual operators
member. []
call / create instance() new
negation/increment! ~ - + ++ -- typeof void delete
multiply/divide* / %
addition/subtraction+ -
bitwise shift<< >> >>>
relational< <= > >= in instanceof
equality== != === !==
bitwise-and&
bitwise-xor^
bitwise-or|
logical-and&&
logical-or||
conditional?:
assignment= += -= *= /= %= <<= >>= >>>= &= ^= |=
comma,
- -

A more detailed version of this table, complete with links to additional details about each operator, may be found in JavaScript Reference.

diff --git "a/files/pt-pt/web/javascript/guia/gram\303\241tica_e_tipos/index.html" "b/files/pt-pt/web/javascript/guia/gram\303\241tica_e_tipos/index.html" deleted file mode 100644 index 109bd99fe4..0000000000 --- "a/files/pt-pt/web/javascript/guia/gram\303\241tica_e_tipos/index.html" +++ /dev/null @@ -1,641 +0,0 @@ ---- -title: Gramática e tipos -slug: Web/JavaScript/Guia/Gramática_e_tipos -tags: - - Guia(2) - - JavaScript -translation_of: Web/JavaScript/Guide/Grammar_and_types ---- -
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}
- -

Este capítulo discute a gramática básica do JavaScript, declarações de variáveis, tipos de dados e literais.

- -

Básicos

- -

JavaScript borrows most of its syntax from Java, but is also influenced by Awk, Perl and Python.

- -

JavaScript is case-sensitive and uses the Unicode character set.

- -

In JavaScript, instructions are called {{Glossary("Statement", "statements")}} and are separated by a semicolon (;). Spaces, tabs and newline characters are called whitespace. The source text of JavaScript scripts gets scanned from left to right and is converted into a sequence of input elements which are tokens, control characters, line terminators, comments or whitespace. ECMAScript also defines certain keywords and literals and has rules for automatic insertion of semicolons (ASI) to end statements. However, it is recommended to always add semicolons to end your statements; it will avoid side effects. For more information, see the detailed reference about JavaScript's lexical grammar.

- -

Comentários

- -

The syntax of comments is the same as in C++ and in many other languages:

- -
// a one line comment
-
-/* this is a longer,
-   multi-line comment
- */
-
-/* You can't, however, /* nest comments */ SyntaxError */
- -

Declarações

- -

There are three kinds of declarations in JavaScript.

- -
-
{{jsxref("Statements/var", "var")}}
-
Declares a variable, optionally initializing it to a value.
-
{{experimental_inline}} {{jsxref("Statements/let", "let")}}
-
Declares a block scope local variable, optionally initializing it to a value.
-
{{experimental_inline}} {{jsxref("Statements/const", "const")}}
-
Declares a read-only named constant.
-
- -

Variáveis

- -

You use variables as symbolic names for values in your application. The names of variables, called {{Glossary("Identifier", "identifiers")}}, conform to certain rules.

- -

A JavaScript identifier must start with a letter, underscore (_), or dollar sign ($); subsequent characters can also be digits (0-9). Because JavaScript is case sensitive, letters include the characters "A" through "Z" (uppercase) and the characters "a" through "z" (lowercase).

- -

You can use ISO 8859-1 or Unicode letters such as å and ü in identifiers. You can also use the Unicode escape sequences as characters in identifiers.

- -

Some examples of legal names are Number_hits, temp99, and _name.

- -

Declararação de variáveis

- -

You can declare a variable in three ways:

- - - -

Avaliação de variáveis

- -

A variable declared using the var statement with no initial value specified has the value {{jsxref("undefined")}}.

- -

An attempt to access an undeclared variable or an attempt to access an identifier declared with let statement before initialization will result in a {{jsxref("ReferenceError")}} exception being thrown:

- -
var a;
-console.log("The value of a is " + a); // logs "The value of a is undefined"
-console.log("The value of b is " + b); // throws ReferenceError exception
-
-console.log("The value of x is " + x); // throws ReferenceError exception
-let x;
- -

You can use undefined to determine whether a variable has a value. In the following code, the variable input is not assigned a value, and the if statement evaluates to true.

- -
var input;
-if(input === undefined){
-  doThis();
-} else {
-  doThat();
-}
-
- -

The undefined value behaves as false when used in a boolean context. For example, the following code executes the function myFunction because the myArray element is undefined:

- -
var myArray = [];
-if (!myArray[0]) myFunction();
-
- -

The undefined value converts to NaN when used in numeric context.

- -
var a;
-a + 2;  // Evaluates to NaN
- -

When you evaluate a {{jsxref("null")}} variable, the null value behaves as 0 in numeric contexts and as false in boolean contexts. For example:

- -
var n = null;
-console.log(n * 32); // Will log 0 to the console
-
- -

Variable scope

- -

When you declare a variable outside of any function, it is called a global variable, because it is available to any other code in the current document. When you declare a variable within a function, it is called a local variable, because it is available only within that function.

- -

JavaScript before ECMAScript 2015 does not have block statement scope; rather, a variable declared within a block is local to the function (or global scope) that the block resides within. For example the following code will log 5, because the scope of x is the function (or global context) within which x is declared, not the block, which in this case is an if statement.

- -
if (true) {
-  var x = 5;
-}
-console.log(x);  // 5
-
- -

This behavior changes, when using the let declaration introduced in ECMAScript 2015.

- -
if (true) {
-  let y = 5;
-}
-console.log(y);  // ReferenceError: y is not defined
-
- -

Variable hoisting

- -

Another unusual thing about variables in JavaScript is that you can refer to a variable declared later, without getting an exception. This concept is known as hoisting; variables in JavaScript are in a sense "hoisted" or lifted to the top of the function or statement. However, variables that are hoisted will return a value of undefined. So even if you declare and initialize after you use or refer to this variable, it will still return undefined.

- -
/**
- * Example 1
- */
-console.log(x === undefined); // true
-var x = 3;
-
-/**
- * Example 2
- */
-// will return a value of undefined
-var myvar = "my value";
-
-(function() {
-  console.log(myvar); // undefined
-  var myvar = "local value";
-})();
-
- -

The above examples will be interpreted the same as:

- -
/**
- * Example 1
- */
-var x;
-console.log(x === undefined); // true
-x = 3;
-
-/**
- * Example 2
- */
-var myvar = "my value";
-
-(function() {
-  var myvar;
-  console.log(myvar); // undefined
-  myvar = "local value";
-})();
-
- -

Because of hoisting, all var statements in a function should be placed as near to the top of the function as possible. This best practice increases the clarity of the code.

- -

In ECMAScript 2015, let (const) will not hoist the variable to the top of the block. However, referencing the variable in the block before the variable declaration results in a ReferenceError. The variable is in a "temporal dead zone" from the start of the block until the declaration is processed.

- -
console.log(x); // ReferenceError
-let x = 3;
- -

Variáveis gGlobais

- -

Global variables are in fact properties of the global object. In web pages the global object is {{domxref("window")}}, so you can set and access global variables using the window.variable syntax.

- -

Consequently, you can access global variables declared in one window or frame from another window or frame by specifying the window or frame name. For example, if a variable called phoneNumber is declared in a document, you can refer to this variable from an iframe as parent.phoneNumber.

- -

Constantes

- -

You can create a read-only, named constant with the {{jsxref("Statements/const", "const")}} keyword. The syntax of a constant identifier is the same as for a variable identifier: it must start with a letter, underscore or dollar sign and can contain alphabetic, numeric, or underscore characters.

- -
const PI = 3.14;
-
- -

A constant cannot change value through assignment or be re-declared while the script is running. It has to be initialized to a value.

- -

The scope rules for constants are the same as those for let block scope variables. If the const keyword is omitted, the identifier is assumed to represent a variable.

- -

You cannot declare a constant with the same name as a function or variable in the same scope. For example:

- -
// THIS WILL CAUSE AN ERROR
-function f() {};
-const f = 5;
-
-// THIS WILL CAUSE AN ERROR ALSO
-function f() {
-  const g = 5;
-  var g;
-
-  //statements
-}
-
- -

However, object attributes are not protected, so the following statement is executed without problems.

- -
const MY_OBJECT = {"key": "value"};
-MY_OBJECT.key = "otherValue";
- -

Estruturas e tipode dados

- -

tipos de dados

- -

The latest ECMAScript standard defines seven data types:

- - - -

Although these data types are a relatively small amount, they enable you to perform useful functions with your applications. {{jsxref("Object", "Objects")}} and {{jsxref("Function", "functions")}} are the other fundamental elements in the language. You can think of objects as named containers for values, and functions as procedures that your application can perform.

- -

Conversão de tipo de dados

- -

JavaScript is a dynamically typed language. That means you don't have to specify the data type of a variable when you declare it, and data types are converted automatically as needed during script execution. So, for example, you could define a variable as follows:

- -
var answer = 42;
-
- -

And later, you could assign the same variable a string value, for example:

- -
answer = "Thanks for all the fish...";
-
- -

Because JavaScript is dynamically typed, this assignment does not cause an error message.

- -

In expressions involving numeric and string values with the + operator, JavaScript converts numeric values to strings. For example, consider the following statements:

- -
x = "The answer is " + 42 // "The answer is 42"
-y = 42 + " is the answer" // "42 is the answer"
-
- -

In statements involving other operators, JavaScript does not convert numeric values to strings. For example:

- -
"37" - 7 // 30
-"37" + 7 // "377"
-
- -

Conversão de strings para números

- -

In the case that a value representing a number is in memory as a string, there are methods for conversion.

- - - -

parseInt will only return whole numbers, so its use is diminished for decimals. Additionally, a best practice for parseInt is to always include the radix parameter. The radix parameter is used to specify which numerical system is to be used.

- -

An alternative method of retrieving a number from a string is with the + (unary plus) operator:

- -
"1.1" + "1.1" = "1.11.1"
-(+"1.1") + (+"1.1") = 2.2
-// Note: the parentheses are added for clarity, not required.
- -

Literais

- -

You use literals to represent values in JavaScript. These are fixed values, not variables, that you literally provide in your script. This section describes the following types of literals:

- - - -

Literais de tabela

- -

An array literal is a list of zero or more expressions, each of which represents an array element, enclosed in square brackets ([]). When you create an array using an array literal, it is initialized with the specified values as its elements, and its length is set to the number of arguments specified.

- -

The following example creates the coffees array with three elements and a length of three:

- -
var coffees = ["French Roast", "Colombian", "Kona"];
-
- -
-

Note : An array literal is a type of object initializer. See Using Object Initializers.

-
- -

If an array is created using a literal in a top-level script, JavaScript interprets the array each time it evaluates the expression containing the array literal. In addition, a literal used in a function is created each time the function is called.

- -

Array literals are also Array objects. See {{jsxref("Array")}} and Indexed collections for details on Array objects.

- -

Extra commas in array literals

- -

You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with undefined for the unspecified elements. The following example creates the fish array:

- -
var fish = ["Lion", , "Angel"];
-
- -

This array has two elements with values and one empty element (fish[0] is "Lion", fish[1] is undefined, and fish[2] is "Angel").

- -

If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no myList[3]. All other commas in the list indicate a new element.

- -
-

Nota : Trailing commas can create errors in older browser versions and it is a best practice to remove them.

-
- -
var myList = ['home', , 'school', ];
-
- -

In the following example, the length of the array is four, and myList[0] and myList[2] are missing.

- -
var myList = [ , 'home', , 'school'];
-
- -

In the following example, the length of the array is four, and myList[1] and myList[3] are missing. Only the last comma is ignored.

- -
var myList = ['home', , 'school', , ];
-
- -

Understanding the behavior of extra commas is important to understanding JavaScript as a language, however when writing your own code: explicitly declaring the missing elements as undefined will increase your code's clarity and maintainability.

- -

Lietrais boolianas

- -

The Boolean type has two literal values: true and false.

- -

Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. See {{jsxref("Boolean")}} for more information.

- -

Íntegros

- -

Integers can be expressed in decimal (base 10), hexadecimal (base 16), octal (base 8) and binary (base 2).

- - - -

Some examples of integer literals are:

- -
0, 117 and -345 (decimal, base 10)
-015, 0001 and -0o77 (octal, base 8)
-0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
-0b11, 0b0011 and -0b11 (binary, base 2)
-
- -

For more information, see Numeric literals in the Lexical grammar reference.

- -

Literais de ponto flutuante

- -

A floating-point literal can have the following parts:

- - - -

The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E").

- -

More succinctly, the syntax is:

- -
[(+|-)][digits][.digits][(E|e)[(+|-)]digits]
-
- -

For example:

- -
3.1415926
--.123456789
--3.1E+12
-.1e-23
-
- -

Literais de objeto

- -

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.

- -

The following is an example of an object literal. The first element of the car object defines a property, myCar, and assigns to it a new string, "Saturn"; the second element, the getCar property, is immediately assigned the result of invoking the function (carTypes("Honda")); the third element, the special property, uses an existing variable (sales).

- -
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
-
- -

Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

- -
var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
-
-console.log(car.manyCars.b); // Jeep
-console.log(car[7]); // Mazda
-
- -

Object property names can be any string, including the empty string. If the property name would not be a valid JavaScript {{Glossary("Identifier","identifier")}} or number, it must be enclosed in quotes. Property names that are not valid identifiers also cannot be accessed as a dot (.) property, but can be accessed and set with the array-like notation("[]").

- -
var unusualPropertyNames = {
-  "": "An empty string",
-  "!": "Bang!"
-}
-console.log(unusualPropertyNames."");   // SyntaxError: Unexpected string
-console.log(unusualPropertyNames[""]);  // An empty string
-console.log(unusualPropertyNames.!);    // SyntaxError: Unexpected token !
-console.log(unusualPropertyNames["!"]); // Bang!
- -

In ES2015, object literals are extended to support setting the prototype at construction, shorthand for foo: foo assignments, defining methods, making super calls, and computing property names with expressions. Together, these also bring object literals and class declarations closer together, and let object-based design benefit from some of the same conveniences.

- -
var obj = {
-    // __proto__
-    __proto__: theProtoObj,
-    // Shorthand for ‘handler: handler’
-    handler,
-    // Methods
-    toString() {
-     // Super calls
-     return "d " + super.toString();
-    },
-    // Computed (dynamic) property names
-    [ 'prop_' + (() => 42)() ]: 42
-};
- -

Por favor, note:

- -
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 is not defined
-console.log(foo["a"]); // alpha
-console.log(foo["2"]); // two
-
- -

RegExp literals

- -

A regex literal is a pattern enclosed between slashes. The following is an example of an regex literal.

- -
var re = /ab+c/;
- -

Lietrais de string

- -

A string literal is zero or more characters enclosed in double (") or single (') quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:

- -
"foo"
-'bar'
-"1234"
-"one line \n another line"
-"John's cat"
-
- -

You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal:

- -
console.log("John's cat".length)
-// Will print the number of symbols in the string including whitespace.
-// In this case, 10.
-
- -

In ES2015, template literals are also available. Template strings provide syntactic sugar for constructing strings. This is similar to string interpolation features in Perl, Python and more. Optionally, a tag can be added to allow the string construction to be customized, avoiding injection attacks or constructing higher level data structures from string contents.

- -
// Basic literal string creation
-`In JavaScript '\n' is a line-feed.`
-
-// Multiline strings
-`In JavaScript this is
- not legal.`
-
-// String interpolation
-var name = "Bob", time = "today";
-`Hello ${name}, how are you ${time}?`
-
-// Construct an HTTP request prefix is used to interpret the replacements and construction
-POST`http://foo.org/bar?a=${a}&b=${b}
-     Content-Type: application/json
-     X-Credentials: ${credentials}
-     { "foo": ${foo},
-       "bar": ${bar}}`(myOnReadyStateChangeHandler);
- -

You should use string literals unless you specifically need to use a String object. See {{jsxref("String")}} for details on String objects.

- -

Using special characters in strings

- -

In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.

- -
"one line \n another line"
-
- -

The following table lists the special characters that you can use in JavaScript strings.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table: JavaScript special characters
CáraterSignificado
\0Null Byte
\bBackspace
\fForm feed
\nNew line
\rCarriage return
\tTab
\vVertical tab
\'Apostrophe or single quote
\"Double quote
\\Backslash character
\XXXThe character with the Latin-1 encoding specified by up to three octal digits XXX between 0 and 377. For example, \251 is the octal sequence for the copyright symbol.
\xXXThe character with the Latin-1 encoding specified by the two hexadecimal digits XX between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol.
\uXXXXThe Unicode character specified by the four hexadecimal digits XXXX. For example, \u00A9 is the Unicode sequence for the copyright symbol. See Unicode escape sequences.
\u{XXXXX}Unicode code point escapes. For example, \u{2F804} is the same as the simple Unicode escapes \uD87E\uDC04.
- -

Escaping characters

- -

For characters not listed in the table, a preceding backslash is ignored, but this usage is deprecated and should be avoided.

- -

You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example:

- -
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
-console.log(quote);
-
- -

The result of this would be:

- -
He read "The Cremation of Sam McGee" by R.W. Service.
-
- -

To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following:

- -
var home = "c:\\temp";
-
- -

You can also escape line breaks by preceding them with backslash. The backslash and line break are both removed from the value of the string.

- -
var str = "this string \
-is broken \
-across multiple\
-lines."
-console.log(str);   // this string is broken across multiplelines.
-
- -

Although JavaScript does not have "heredoc" syntax, you can get close by adding a line break escape and an escaped line break at the end of each line:

- -
var poem =
-"Roses are red,\n\
-Violets are blue.\n\
-Sugar is sweet,\n\
-and so is foo."
-
- -

Mais informação

- -

This chapter focuses on basic syntax for declarations and types. To learn more about JavaScript's language constructs, see also the following chapters in this guide:

- - - -

In the next chapter, we will have a look at control flow constructs and error handling.

- -

{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}

diff --git a/files/pt-pt/web/javascript/guia/index.html b/files/pt-pt/web/javascript/guia/index.html deleted file mode 100644 index aec08fb7ad..0000000000 --- a/files/pt-pt/web/javascript/guia/index.html +++ /dev/null @@ -1,123 +0,0 @@ ---- -title: Guia de JavaScript -slug: Web/JavaScript/Guia -tags: - - Guía - - JavaScript - - 'l10n:prioridade' -translation_of: Web/JavaScript/Guide ---- -
{{jsSidebar("JavaScript Guide")}}
- -

The JavaScript Guide shows you how to use JavaScript and gives an overview of the language. If you want to get started with JavaScript or programming in general, consult the articles in the learning area. If you need exhaustive information about a language feature, have a look at the JavaScript reference.

- -

Capítulos

- -

This Guide is divided into several chapters:

- - - - - - - - - -

{{Next("Web/JavaScript/Guide/Introduction")}}

diff --git "a/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o/index.html" "b/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o/index.html" deleted file mode 100644 index f77bb74379..0000000000 --- "a/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o/index.html" +++ /dev/null @@ -1,137 +0,0 @@ ---- -title: Introdução -slug: Web/JavaScript/Guia/Introdução -tags: - - Guía - - JavaScript -translation_of: Web/JavaScript/Guide/Introduction ---- -
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}
- -

Este capítulo apresenta a linguagem JavaScript e discuste alguns dos seus conceitos fundamentais.

- -

O que você já deveria saber

- -

Este guia assume que você possuí os seguintes conhecimentos:

- - - -

Onde encontrar informação sobre JavaScript?

- -

A documentação de JavaScript no MDN incluí o seguinte:

- - - -

Se for iniciante em JavaScript, comece lendo alguns dos artigos na área de aprendizagem e o  Guia de JavaScript. Assim que compreender os fundamentos da linguagem, pode consultar a Referência de JavaScript para obter mais detalhes sobre objetos individuais e declarações.

- -

O que é JavaScript?

- -

JavaScript é uma linguagem de script orientada a objetos e que funciona entre plataformas. É uma linguagem pequena e simples. Ela pode ser rodada num ambiente anfitrião (por exemplo, o browser),  o código JavaScript pode estar ligado a objetos do ambiente e  fornece controle programático sobre os mesmos.

- -

O JavaScript contém uma biblioteca padrão de objetos, tais como Array, Date, Math, e um conjunto fundamental de elementos da linguagem tais como operadores, estruturas de controle, e statements. Os elementos básicos do JavaScript podem ser extendidos com objetos adicionais para uma variedade de propósitos, por exemplo:

- - - -

JavaScript e Java

- -

JavaScript e Java são linguagens similares em alguns aspetos mas fundamentalmente diferentes noutros. A linguagem JavaScript assemelha-se ao Java mas não tem o static typing nem a validação strong type. O JavaScsript segue a sintaxe de expressões do Java, convenções de nomenclatura e os construtores básicos de controlo de fluxo. Esta última foi a razão pelo qual a linguagem foi renomeada de LiveScript para JavaScript.

- -

In contrast to Java's compile-time system of classes built by declarations, JavaScript supports a runtime system based on a small number of data types representing numeric, Boolean, and string values. JavaScript has a prototype-based object model instead of the more common class-based object model. The prototype-based model provides dynamic inheritance; that is, what is inherited can vary for individual objects. JavaScript also supports functions without any special declarative requirements. Functions can be properties of objects, executing as loosely typed methods.

- -

JavaScript is a very free-form language compared to Java. You do not have to declare all variables, classes, and methods. You do not have to be concerned with whether methods are public, private, or protected, and you do not have to implement interfaces. Variables, parameters, and function return types are not explicitly typed.

- -

Java is a class-based programming language designed for fast execution and type safety. Type safety means, for instance, that you can't cast a Java integer into an object reference or access private memory by corrupting Java bytecodes. Java's class-based model means that programs consist exclusively of classes and their methods. Java's class inheritance and strong typing generally require tightly coupled object hierarchies. These requirements make Java programming more complex than JavaScript programming.

- -

In contrast, JavaScript descends in spirit from a line of smaller, dynamically typed languages such as HyperTalk and dBASE. These scripting languages offer programming tools to a much wider audience because of their easier syntax, specialized built-in functionality, and minimal requirements for object creation.

- - - - - - - - - - - - - - - - - - - - - - - -
JavaScript comparado com Java
JavaScriptJava
Object-oriented. No distinction between types of objects. Inheritance is through the prototype mechanism, and properties and methods can be added to any object dynamically.Class-based. Objects are divided into classes and instances with all inheritance through the class hierarchy. Classes and instances cannot have properties or methods added dynamically.
Variable data types are not declared (dynamic typing).Variable data types must be declared (static typing).
Cannot automatically write to hard disk.Can automatically write to hard disk.
- -

For more information on the differences between JavaScript and Java, see the chapter Details of the object model.

- -

JavaScript e a especificação ECMAScript

- -

JavaScript is standardized at Ecma International — the European association for standardizing information and communication systems (ECMA was formerly an acronym for the European Computer Manufacturers Association) to deliver a standardized, international programming language based on JavaScript. This standardized version of JavaScript, called ECMAScript, behaves the same way in all applications that support the standard. Companies can use the open standard language to develop their implementation of JavaScript. The ECMAScript standard is documented in the ECMA-262 specification. See New in JavaScript to learn more about different versions of JavaScript and ECMAScript specification editions.

- -

The ECMA-262 standard is also approved by the ISO (International Organization for Standardization) as ISO-16262. You can also find the specification on the Ecma International website. The ECMAScript specification does not describe the Document Object Model (DOM), which is standardized by the World Wide Web Consortium (W3C) and/or WHATWG (Web Hypertext Application Technology Working Group). The DOM defines the way in which HTML document objects are exposed to your script. To get a better idea about the different technologies that are used when programming with JavaScript, consult the article JavaScript technologies overview.

- -

Documentação JavaScript versus especificação  ECMAScript

- -

The ECMAScript specification is a set of requirements for implementing ECMAScript; it is useful if you want to implement standards-compliant language features in your ECMAScript implementation or engine (such as SpiderMonkey in Firefox, or v8 in Chrome).

- -

The ECMAScript document is not intended to help script programmers; use the JavaScript documentation for information on writing scripts.

- -

The ECMAScript specification uses terminology and syntax that may be unfamiliar to a JavaScript programmer. Although the description of the language may differ in ECMAScript, the language itself remains the same. JavaScript supports all functionality outlined in the ECMAScript specification.

- -

The JavaScript documentation describes aspects of the language that are appropriate for a JavaScript programmer.

- -

Começar com JavaScript

- -

Getting started with JavaScript is easy: all you need is a modern Web browser. This guide includes some JavaScript features which are only currently available in the latest versions of Firefox, so using the most recent version of Firefox is recommended.

- -

There are two tools built into Firefox that are useful for experimenting with JavaScript: the Web Console and Scratchpad.

- -

A Consola da Web

- -

A Consola da Web shows you information about the currently loaded Web page, and also includes a command line that you can use to execute JavaScript expressions in the current page.

- -

To open the Web Console (Ctrl+Shift+K), select "Web Console" from the "Developer" menu, which is under the "Tools" menu in Firefox. It appears at the bottom of the browser window. Along the bottom of the console is a command line that you can use to enter JavaScript, and the output appears in the pane above:

- -

- -

Scratchpad

- -

The Web Console is great for executing single lines of JavaScript, but although you can execute multiple lines, it's not very convenient for that, and you can't save your code samples using the Web Console. So for more complex examples Scratchpad is a better tool.

- -

To open Scratchpad (Shift+F4), select "Scratchpad" from the "Developer" menu, which is under the menu in Firefox. It opens in a separate window and is an editor that you can use to write and execute JavaScript in the browser. You can also save scripts to disk and load them from disk.

- -

- -

Olá mundo

- -

To get started with writing JavaScript, open the Scratchpad and write your first "Hello world" JavaScript code:

- -
function greetMe(yourName) {
-  alert("Hello " + yourName);
-}
-
-greetMe("World");
-
- -

Select the code in the pad and hit Ctrl+R to watch it unfold in your browser!

- -

In the following pages, this guide will introduce you to the JavaScript syntax and language features, so that you will be able to write more complex applications.

- -

{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}

diff --git "a/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o_ao_javascript/index.html" "b/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o_ao_javascript/index.html" deleted file mode 100644 index 549ecbe331..0000000000 --- "a/files/pt-pt/web/javascript/guia/introdu\303\247\303\243o_ao_javascript/index.html" +++ /dev/null @@ -1,47 +0,0 @@ ---- -title: Introdução ao JavaScript -slug: Web/JavaScript/Guia/Introdução_ao_JavaScript ---- -

Este capítulo introduz o JavaScript e discute alguns de seus conceitos fundamentais.

-

O que é o JavaScript?

-

O JavaScript é uma linguagem de script multiplataforma, orientada a objetos. O JavaScript é uma linguagem pequena e leve; não é útil como uma linguagem de uso isolado, mas é projetada para fácil integração em outros produtos e aplicações, tais como navegadores web. Dentro de um ambiente de hospedagem, o JavaScript pode ser conectado aos objetos de seu ambiente para proporcionar um controle programático sobre elas.

-

O núcleo do JavaScript contém um  núcleo de objetos, como Array, Date, e Math, e um núcleo de elementos de linguagem como operadores, estruturas de controle, e declarações. O núcleo do JavaScript pode ser extendido para uma variedade de propósitos complementando-o com objetos adicionais; por exemplo:

- -

Através da funcionalidade JavaScript's LiveConnect, pode-se permitir que códigos em Java e em JavaScript comuniquem-se. É possível instanciar objetos Java e acessar seus métodos e campos públicos a partir do JavaScript. A partir do Java, por sua vez, pode-se acessar objetos, propriedades e métodos do JavaScript.

-

O Netscape inventou o JavaScript e o JavaScript foi inicialmente usado em navegadores Netscape.

-

JavaScript e Java

-

O JavaScript e o Java são similares em algumas coisas, mas fundamentalmente diferentes em outras. A linguagem JavaScript assemelha-se ao Java, mas não possui a checagem de tipos forte e digitação estática do Java. O JavaScript suport a maioria das sintaxes de expressões em Java e um construtor básico de controles de fluxo.

-

Em contraste com o sistema em tempo de compilação do Java, de classes construídas por declarações, o JavaScript suporta um sistema de tempo de execução baseado em um pequeno número de tipos de dados representando números, booleanos, e valores de strings. O JavaScript possui um modelo de objetos baseado em protótipos, ao invés do mais comum, modelo de objetos baseado em classes. O modelo baseado em protótipos provê a herança dinâmica; isto é, o que é herdado pode variar para objetos individuais. O JavaScript também suporta funções sem requisições especiais de declaração. Funções podem ser propriedades de objetos, executando métodos fracamente tipados.

-

O JavaScript é uma linguagem com forma bastante livre comparada ao Java. Você não precisa declarar todas as variáveis, classes e métodos. Você não precisa se preocupar se os métodos são públicos, privados ou protegidos, e você não precisa implementar interfaces. Tipos de variáveis, parâmetros e retornos de funções não são explicitados.

-

O Java é uma linguagem de programação baseada em classes e projetava para rápida execução e tipagem segura. Tipagem segura significa, por exemplo, que você não pode converter um inteiro do Java para uma referência de um objeto ou acessar a memória privada, corrompendo bytecodes do Java. O modelo baseado em classes do Java significa que o programa consiste exclusivamente de classes e seus métodos. A herança das classes no Java e a tipagem forte, geralmente requerem objetos com hierarquias firmemente acopladas. Estes requisitos fazem do Java uma linguagem de programação mais complexa que a autoria do JavaScript.

-

Em contraste, o JavaScript descende em espírito de uma linha menor, linguagens tipadas dinamicamente, tais como HyperTalk e dBASE. Estas linguagens de stript oferecem ferramentas de programação para um público muito maior, devido a simplicidade de sua sintaxe, funcionalidades especializadas integradas e requisitos mínimos para criação de objetos.

- -
Tabela 1.1 JavaScript em comparação ao Java
JavaScript Java
Orientação a objetos. Sem distinção entre tipos de objetos. A herança ocorre através do mecanismo de protótipos e os métodos e propriedades podem ser adicionados a qualquer objeto dinamicamente. Baseada em classes. Objetos são divididos em classes e instâncias com toda a herança através da hierarquia da classe. Classes e instâncias não podem ter métodos e propriedades adicionados dinamicamente.
Tipos de dados variáveis não são declarados (tipagem dinâmica). Tipos de dados variáveis precisam ser declarados (tipagem estática).
Não pode escrever automaticamente no disco rígido. Não pode escrever automaticamente no disco rígido.
-

Para mais informações sobre as diferenças entre o JavaScript e o Java, veja o capítulo Details of the Object Model.

JavaScript e a especificação ECMAScript

-

O Netscape inventou o JavaScript e o JavaScript foi primeiramente usado nos navegadores Netscape. Entretanto, a Netscape está trabalhando com a Ecma International — a associação européia para padronizão de informação e sistemas de comunicação (formalmente conhecida como ECMA - European Computer Manufacturers Association, em português: Associação de Fabricantes de Computadores Europeus) — para entregar uma linguagem de programação internacional padronizada, baseada no JavaScript. Esta versão padronizada do JavaScript, chamada de ECMAScript, comporta-se da mesma maneira em todas as aplicações que suportem o padrão. Empresas podem usar a linguagem padrão aberta para desenvolver sua implementação do JavaScript. O ECMAScript padrão é documentado na especificação ECMA-262.

-

O padrão ECMA-262 é também aprovado pela ISO (International Organization for Standardization, em português: Organização Internacional para Padronização) como ISO-16262. Você pode encontrar uma versão PDF do ECMA-262 (en) no site da Mozilla. Você pode também encontrar a especificação em the Ecma International website (en). A especificação do ECMAScript não descreve o Document Object Model (DOM), o qual é padronizado pelo World Wide Web Consortium (W3C). O DOM define a maneira com a qual os objetos do documento HTML são expostos ao seu script.

-

Relação entre as versões do JavaScript e as edições do ECMAScript

-

O Netscape trabalhou próximo a Ecma International para produzir a Especificação ECMAScript (ECMA-262). A tabela seguinte descreve a relação entre as versões do JavaScript e as edições do ECMAScript.

- -
Tabela 1.2 Versões do JavaScript e edições do ECMAScript
Versão do JavaScript Relação com a edição do ECMAScript
JavaScript 1.1 O ECMA-262, Edição 1 é baseado no JavaScript 1.1.
JavaScript 1.2 O ECMA-262 não estava completo quando o JavaScript 1.2 foi lançado. O JavaScript 1.2 não é totalmente compatível com o ECMA-262, Edição 1, pelas seguintes razões:
  • O Netscape desenvolveu características adicionais no JavaScript 1.2 que não foram consideradas no ECMA-262.
  • O ECMA-262 adiciona duas novas características: internacionalização usando Unicode e comportamento uniforme em todas as plataformas. Muitas características do JavaScript 1.2, tais com o objeto Date, eram dependentes de plataforma e usavam um comportamento específico da plataforma.

JavaScript 1.3

O JavaScript 1.3 é totalmente compatível com o ECMA-262, Edição 1.

O JavaScript 1.3 corrigiu as inconsistências que o JavaScript 1.2 tinha com o ECMA-262, mantendo todas as características adicionais do JavaScript 1.2 com a exceção de  == e !=, os quais foram mudados conforme o ECMA-262.

JavaScript 1.4

O JavaScript 1.4 é totalmente comatível com o ECMA-262, Edição 1.

A terceira versão da especificação ECMAScript não estava finalizada quando o JavaScript 1.4 foi lançado.
JavaScript 1.5 O JavaScript 1.5 é totalmente compatível com o ECMA-262, Edição 3.
-
Nota: O ECMA-262, Edição 2 consistiu de mudanças editoriais pequenas e correções de bugs da especificação da Edição 1. O grupo de trabalho TC39 da Ecma International está atualmente trabalhando no ECMAScript Edição 4, o qual corresponderá a um lançamento futuro do JavaScript, o JavaScript 2.0.
-

A Referência de JavaScript (en) indica quais características da linguagem estão em conformidade com o ECMAScript.

-

O JavaScript sempre permite incluir características que não fazem parte da Especificação do ECMAScript; O JavaScript é compatível com o ECMASCript; mesmo provendo características adicionais.

Documentação do JavaScript versus a especificação do ECMAScript

-

A especificação do ECMAScript é um conjunto de requisitos para a implementação do ECMAScript; ela é útil caso deseje-se determinar, se uma característica do JavaScript é suportada em outras implementações do ECMAScript. Caso planeje-se escrever código JavaScript usando somente características suportadas pelo ECMAScript, então é interessante checar a especificação ECMAScript.

-

O documento ECMAScript não pretende ajudar programadores de scripts; para informações sobre escrita de scripts, deve-se usar a documentação do JavaScript.

Terminologia do JavaScript e do ECMAScript

-

A especificação do ECMAScript utiliza a terminologia e sintaxe que pode ser desconhecida para um programador JavaScript. Embora a descrição da linguagem possa diferir, a linguagem em si, é a mesma. O JavaScript suporta todas as funcionalidades descritas na especificação ECMAScript.

-

A documentação do JavaScript descreve aspectos da linguagem que são apropriados para um programador JavaScript. Por exemplo:

- -
autoPreviousNext("JSGChapters");
-wiki.languages({
-  "en": "en/JavaScript/Guide/JavaScript_Overview",
-  "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript",
-  "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript",
-  "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview",
-  "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview",
-  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu",
-  "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8",
-  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/JavaScript_概要"
-});
diff --git a/files/pt-pt/web/javascript/guia/sobre/index.html b/files/pt-pt/web/javascript/guia/sobre/index.html deleted file mode 100644 index 6957645a40..0000000000 --- a/files/pt-pt/web/javascript/guia/sobre/index.html +++ /dev/null @@ -1,166 +0,0 @@ ---- -title: Sobre este guia -slug: Web/JavaScript/Guia/Sobre ---- -

JavaScript é uma linguagem de scripts multiplataforma, baseada em objetos. Este guia explica tudo que é necessário saber sobre como utilizar o JavaScript.

- -

Novas caraterísticas em versões do JavaScript

- -
/* Nota: Para adicionar um link na descrição de uma nova versão do JavaScript,
-adicione o número da variável versionList abaixo. A página ligada deve
-residir em /en/JavaScript/New_in_JavaScript/N, onde N é o número da versão. */
-
-var versionList = ["1.5", "1.6", "1.7", "1.8", "1.8.1", "1.8.5"];
-var s = "";
-<ul>
-  foreach (var i in versionList){
-    let s = "/en/JavaScript/New_in_JavaScript/" .. i;
-    <li>web.link(s, wiki.getPage(s).title)</li>;
-  }
-</ul>;
- -

O que já é necessário saber

- -

Este guia assume que já possui os seguintes conhecimentos como base:

- - - -

Alguma experiência de programação com uma linguagem como C ou Visual Basic é útil, mas não necessária.

- -

Versões do JavaScript

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Tabela 1 Versões do JavaScript e do Navigator
versão JavaScriptversão Navigator
JavaScript 1.0Navigator 2.0
JavaScript 1.1Navigator 3.0
JavaScript 1.2Navigator 4.0-4.05
JavaScript 1.3Navigator 4.06-4.7x
JavaScript 1.4 
JavaScript 1.5Navigator 6.0
- Mozilla (navegador open source)
JavaScript 1.6Firefox 1.5, outros produtos baseados no Mozilla 1.8
JavaScript 1.7Firefox 2, outros produtos baseados no Mozilla 1.8.1
JavaScript 1.8Firefox 3, outros produtos baseados no Gecko 1.9
- -

Cada versão do Netscape Enterprise Server também suporta diferentes versões do JavaScript. Para ajudar na escrita de scripts compatíveis com múltiplas versões do Enterprise Server, este manual usa uma abreviação para indicar a versão do servidor na qual cada característica foi implementada.

- - - - - - - - - - - - - - - - - - - -
Tabela 2 Abreviações das versões do Netscape Enterprise Server
Abreviaçãoversão Enterprise Server
NES 2.0Netscape Enterprise Server 2.0
NES 3.0Netscape Enterprise Server 3.0
- -

Onde encontrar informações sobre JavaScript

- -

A documentação do JavaScript inclui os seguintes livros:

- - - -

Se você é novo no JavaScript, comece com o Guia de JavaScript. Uma vez que você tenha uma boa compreensão dos fundamentos, você pode usar a Referência JavaScript para obter mais detalhes sobre objetos e declarações.

- -

Dicas para aprender JavaScript

- -

Começar com o JavaScript é fácil: é necessário apenas um navegador web moderno. Este guia inclui algumas características do JavaScript que estão atualmente disponíveis nas últimas versões do Firefox (e outros navegadores baseados no Gecko), é recomendado, portanto, o uso da versão mais recente do Firefox.

- -

Um interpretador interativo

- -

Uma linha de comando interativa com JavaScript é inestimável para o aprendizado da linguagem, pois permite experimentar código de forma interativa sem ter que salvar um arquivo e recarregar a página. O Console de erros do Firefox, acessível através do menu de Ferramentas, fornece uma maneira simples de testar JavaScript interativamente: Basta entrar uma linha de código e clicar no botão "Executar".

- -

Image:ErrorConsole.png

- -

Firebug

- -

Uma linha de comando interativa mais avançada está disponível com o uso do Firebug, uma extensão de terceiros para o Firefox. O Firebug também fornece um inspetor DOM avançado, um depurador de JavaScript, uma ferramenta de análise e vários outros utilitários.

- -

Image:Firebug.png

- -

Um dos mais úteis benefícios proporcionados pelo Firebug é console.log(), uma função que imprime seus argumentos no console do Firebug. Diferentemente de outras linguagens de programação, o JavaScript não possui um conceito de impressão para a saída padrão. O console.log() fornece uma alternativa útil, tornando mais fácil ver o que seu programa está fazendo.

- -

Muitos dos exemplos neste guia usam alert() para exibir mensagens conforme são executados. Tendo o Firebug instalado, pode ser usando console.log() ao invés de alert() ao rodar estes exemplos.

- -

Convenções de documento

- -

Aplicações JavaScript rodam em muitos sistemas operacionais; a informação neste livro aplica-se a todas as versões. Os caminhos de arquivos e diretórios são dados no formato Windows (com contrabarras separando os nomes dos diretórios). Para versões Unix, os caminhos são os mesmo, exceto por serem usadas barras ao invés de contrabarras para separar os diretórios.

- -

Este guia usa localizador padrão de recursos (uniform resource locators (URL)) da seguinte forma:

- -

http://server.domain/path/file.html

- -

Nestas URL, server representa o nome do servidor no qual a aplicação é rodada, tal como research1 ou www; domain representa seu domínio de internet, como netscape.com ou uiuc.edu; path representa a estrutura do diretório no servidor; e file.html representa o nome de um arquivo individual. No geral, itens em itálico em são placeholders e itens em fonte monoespaçada normal são literais. Se o servidor possuir Secure Sockets Layer (SSL) habilitado, pode ser usado https ao invés de http na URL.

- -

Este guia utiliza as seguintes convenções de fontes:

- - - -
autoPreviousNext("JSGChapters");
-wiki.languages({
-  "en": "en/JavaScript/Guide/About",
-  "es": "es/Gu\u00eda_JavaScript_1.5/Acerca_de_esta_gu\u00eda",
-  "fr": "fr/Guide_JavaScript_1.5/\u00c0_propos",
-  "ja": "ja/Core_JavaScript_1.5_Guide/About",
-  "ko": "ko/Core_JavaScript_1.5_Guide/About",
-  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/O_tym_przewodniku",
-  "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u5173\u4e8e",
-  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/關於"
-})
-
diff --git "a/files/pt-pt/web/javascript/guia/valores,_vari\303\241veis_e_literais/index.html" "b/files/pt-pt/web/javascript/guia/valores,_vari\303\241veis_e_literais/index.html" deleted file mode 100644 index c2cbc7f3db..0000000000 --- "a/files/pt-pt/web/javascript/guia/valores,_vari\303\241veis_e_literais/index.html" +++ /dev/null @@ -1,547 +0,0 @@ ---- -title: 'Valores, Variáveis e Literais' -slug: 'Web/JavaScript/Guia/Valores,_Variáveis_e_Literais' ---- -

Este capítulo discute valores reconhecidos pelo JavaScript e descreve a construção de blocos fundamentais de expressões em JavaScript: variáveis, constantes e literais.

- -

Valores

- -

O JavaScript reconhece os seguintes tipos de valores:

- - - -

Este conjunto de tipos de valores relativamente pequeno, permite realizar funções úteis com suas aplicações. Não há distinção explícita entre números inteiros e reais. Nem existe um tipo de dados de datas explícito em JavaScript. Entretanto, é possível utilizar o objeto Date (en) e seus métodos para lidar com datas.

- -

Objetos (en) e funções (en) são os outros elementos fundamentias da linguagem. Pode-se pensar em objetos como nomes nos quais podem ser guardados valores, e funções como procedimentos que sua aplicação pode executar.

- -

Conversão de tipos de dados

- -

O JavaScript é uma linguagem de tipagem dinâmica. Isto significa que não é necessário especificar o tipo de dado de uma variável quando ela for declarada, e tipos de dados são automaticamento convertidos conforme necessário durante a execução do script. Então, por exemplo, pode-se definir uma variável como:

- -
var resposta = 42;
-
- -

E depois, pode-se atribuir para a mesma variável um valor de string, por exemplo:

- -
resposta = "Obrigado pelos peixes...";
-
- -

Como o JavaScript possui tipagem dinâmica, esta atribuição não gera uma mensagem de erro.

- -

Em expressões envolvendo valores numéricos e strings com o operador +, o JavaScript converte valores numérios para string. Por exemplo, considere as seguintes declarações:

- -
x = "A resposta é " + 42 // retorna "A resposta é 42"
-y = 42 + " é a resposta" // retorna "42 é a resposta"
-
- -

Em declarações envolvendo outros operadores, o JavaScript não converte valores numérico para strings. Por exemplo:

- -
"37" - 7 // retorna 30
-"37" + 7 // retorna "377"
- -

Variáveis

- -

Variáveis são usadas como nomes simbólicos para valores em sua aplicação. Os nomes das variáveis, chamadas identificadores, de acordo com certas regras.

- -

Um identificador JavaScript deve começar com uma letra, sublinhado (_), ou cifrão ($); caracteres subsequentes podem também ser dígitos (0-9). Como o JavaScript é sensível a maiúsculas, as letras incluem os caracteres de "A" até "Z" (maiúsculas) e os caracteres de "a" até "z" (minúsculas).

- -

A partir do JavaScript 1.5 é possível usar letras em ISO 8859-1 ou Unicode tais como å e ü nos identificadores. Também é possível usar as Sequências de escape em Unicode \uXXXX como caracteres nos identificadores.

- -

Alguns exemplos de nomes possíveis são: Number_hits, temp99 e _name.

- -

Declaração de variáveis

- -

Você pode declarar uma variável de duas maneiras:

- - - -

Avaliação de variáveis

- -

Uma variável declarada usando-se a declaração var sem possuir um valor inicial especificado possui o valor undefined.

- -

Uma tentativa de acesso a uma variável não declarada resultará no lançamento de uma exceção ReferenceError:

- -
var a;
-print("O valor de a é " + a); // imprime "O valor de a é undefined"
-print("O valor de b é " + b); // lança a exceção ReferenceError
-
- -

Você pode usar undefined para determinar quando uma variável possui um valor. No código a seguir, a variável input não possui um valor atribuido e a declaração if é avaliada como true.

- -
var input;
-if(input === undefined){
-  doThis();
-} else {
-  doThat();
-}
-
- -

O valor undefined comporta-se como false quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função myFunction porque o elemento myArray não está definido:

- -
var myArray = new Array();
-if (!myArray[0]) myFunction();
-
- -

Quando você avalia uma variável nula, o valor nulo comporta-se como um 0 no contexto numérico e como falso em contextos booleanos. Por exemplo

- -
var n = null;
-print(n * 32); // imprime 0
-
- -

Escopo de variáveis

- -

Quando uma variável é declarada de fora de qualquer função, ele é chamada de variável global, pois ela está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, ela é chamada de variável local, pois ela está disponível somente dentro dessa função.

- -

O JavaScript não possui um escopo de declaração de blocos (en); ao contrário, será local para o código interno ao bloco. Por exemplo, o código a seguir imprimirá 0 ao invés de lançar a exceção ReferenceError se condition é false:

- -
if (condition) {
-  var x = 5;
-}
-print(x ? x : 0);
-
- -

Outra coisa não usual sobre variáveis em JavaScript é que é possível referir-se a uma variável declarada depois, sem receber uma exceção. Este conceito é conhecido como hoisting; as variáveis no JavaScript são levadas para o topo da função ou da declaração.  Entretanto, as variáveis não inicializadas retornarão um valor undefined.

- -
print(x === undefined); // prints "true"
-var x = 3;
-
-//will return a value of undefined
-var myvar = "my value";
-
-(function() {
-  alert(myvar);//undefined
-  var myvar = "local value"
-})();
-
- -

Variáveis globais

- -

necessário links para as páginas discutindo cadeias no âmbito do objeto global Variáveis globais são, na verdade, propriedade de um objeto global. Em páginas web o objeto global é window, então você pode configurar e acessar variáveis globais usando a sintaxe window.variable.

- -

Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou quadro de alguma outra janela ou quadro, especificando o nome do mesmo. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento FRAMESET, você pode referir-se a esta variável a partir de um frame herdeiro como parent.phoneNumber.

- -

Veja também

- -

Sharp variables in JavaScript (en)

- -

Constantes

- -

Você pode criar elementos "somente leitura", nomeados constantes com a palavra chave const. A sintaxe de um identificador constante é a mesma para um identificador de variáveis: deve começar com uma letra ou sublinhado e pode conter caracteres alfabéticos, numéricos ou sublinhado.

- -
const prefix = '212';
-
- -

Uma constante não pode ter seu valor mudado através de uma atribuição ou ser declarada novamente enquanto o script estiver rodando.

- -

As regras de escopo para constantes são as mesmas que as das variáveis, exceto que a palavra chave const é sempre necessária, mesmo para constantes globais. Se uma palavra chave é omitida, o identificador é assumido como uma variável.

- -

Você não pode declarar uma constante com o mesmo nome de uma função ou variável no mesmo escopo. Por exemplo:

- -
// ISTO CAUSARA UM ERRO
-function f() {};
-const f = 5;
-
-// ISTO TAMBEM CAUSARA UM ERRO
-function f() {
-  const g = 5;
-  var g;
-
-  // declaracoes
-}
-
- -

Literais

- -

Você usa literais para representar valores em JavaScript. Estes valores são fixos, não variáveis, que você fornece literalmente no seu script. Esta seção descreve os seguintes tipos de literais:

- - - -

Ordenação de literais

- -

Um literal ordenado é uma lista de zero ou mais expressões, cada qual representando um elemento ordenado, armazenado em colchetes ([]). Quando você cria uma ordenação usando um literal ordenado, ele é inicializado com os valores especificados como seus elementos e seu comprimento configurado para o número de argumentos especificados.

- -

O exemplo a seguir cria uma ordenação coffees com três elementos e o comprimento de três:

- -
var coffees = ["French Roast", "Colombian", "Kona"];
-
- -

Nota Uma ordenação literal é um tipo de inicializador de objeto. Veja Using Object Initializers (en).

- -

Se uma ordenação é criada usando um literal em um alto nível de script, o JavaScript interpreta a ordenação cada vez que uma expressão contendo a ordenação literal é avaliada. Adicionalmente, um literal usado em uma função é criado cada vez que a função é chamada.

- -

Ordenações literais são também objetos Array.  Veja Array Object (en) para detalhes sobre objetos Array.

- -

Vírgulas extras em literais ordenados

- -

Não é necessário especificar todos os elementos de um literal ordenado. Se forem colocadas duas vírgulas em uma coluna, a ordenação é criada com espaços para elementos não especificados. O exemplo seguinte mostra a ordenação fish:

- -
var fish = ["Lion", , "Angel"];
-
- -

Esta ordenação possui dois elementos com valores e um elemento vazio (fish[0] é "Lion", fish[1] é undefined e fish[2] é "Angel").

- -

Caso seja inserida uma última vírgula ao fim da lista de elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento da ordenação é três. Não há myList[3]. Todas as outras vírgulas da lista indicam um novo elemento.

- -
var myList = ['home', , 'school', ];
-
- -

No exemplo a seguir, o comprimento da ordenação é quatro, e myList[0] e myList[2] estão faltando.

- -
var myList = [ , 'home', , 'school'];
-
- -

No exemplo seguinte, o comprimento da ordenação é quatro, e  myList[1] e myList[3] estão faltando. Somente a última vírgula é ignorada.

- -
var myList = ['home', , 'school', , ];
-
- -

Booleanos literais

- -

O tipo Booleano possui dois valores literais: true e false.

- -

Não confunda-os com os valores Booleanos primitivos true e false com os valores verdadeiro e falso do objeto Booleano. O objeto Booleano é um invólucro ao redor do tipo de dado Booleano. Veja Boolean Object (en) para mais informações.

- -

Inteiros

- -

Inteiros podem ser expressos na base decimal (base 10), hexadecimal (base 16) e octal (base 8). Um inteiro decimal literal consiste em uma sequência de dígitos sem um 0 (zero) no início. Um 0 (zero) no início de um inteiro literal indica que se trata de um octal; um 0x (ou 0X) indica hexadecimal. Inteiros hexadecimais podem incluir dígitos (0-9) e as letras de a-f e A-F. Inteiros octais podem incluir somente dígitos 0-7.

- -

Inteiros octais literais são obsoletos e foram removidos do padrão ECMA-262, Edição 3. O JavaScript 1.5 ainda os suporta para compatibilidade com versões anteriores.

- -

Alguns exemplo de inteiros literais são:

- -
0, 117 e -345 (decimal, base 10)
-015, 0001 e -077 (octal, base 8)
-0x1123, 0x00111 e -0xF1A7 (hexadecimal, "hex" ou base 16)
-
- -

Pontos flutuantes literais

- -

Um literal de ponto flutuante pode possuir as seguintes partes:

- - - -

A parte do expoente é um "e" ou "E" seguido por um inteiro, o qual pode ser assinado (precedido por "+" ou "-"). Um literal de ponto flutuante deve ter ao menos um dígito e um ponto decimal ou "e" (ou "E").

- -

Alguns exemplos de pontos flutuantes literais são 3.1415, -3.1E12, .1e12, and 2E-12.

- -

Mais claramente, a sintaxe é:

- -
[digitos][.digitos][(E|e)[(+|-)]digitos]
-
- -

Por exemplo:

- -
3.14
-2345.789
-.3333333333333333333
-
- -

Objetos literais

- -

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.

- -

The following is an example of an object literal. The first element of the car object defines a property, myCar; the second element, the getCar property, invokes a function (CarTypes("Honda")); the third element, the special property, uses an existing variable (Sales).

- -
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 };
-
-document.write(car.myCar);   // Saturn
-document.write(car.getCar);  // Honda
-document.write(car.special); // Toyota
-
- -

Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

- -
var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
-
-document.write(car.manyCars.b); // Jeep
-document.write(car[7]); // Mazda
-
- -

Please note:

- -
var foo = {a: "alpha", 2: "two"};
-document.write(foo.a);    // alpha
-document.write(foo[2]);   // two
-//document.write(foo.2);  // Error: missing ) after argument list
-//document.write(foo[a]); // Error: a is not defined
-document.write(foo["a"]); // alpha
-document.write(foo["2"]); // two
-
- -

Strings literais

- -

A string literal is zero or more characters enclosed in double (") or single (') quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:

- - - -

You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal:

- -
"John's cat".length
-
- -

You should use string literals unless you specifically need to use a String object. See String Object for details on String objects.

- -

Usando caracteres especiais em strings

- -

In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.

- -
"one line \n another line"
-
- -

The following table lists the special characters that you can use in JavaScript strings.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 2.1 JavaScript special characters
CharacterMeaning
\bBackspace
\fForm feed
\nNew line
\rCarriage return
\tTab
\vVertical tab
\'Apostrophe or single quote
\"Double quote
\\Backslash character (\).
\XXXThe character with the Latin-1 encoding specified by up to three octal digits XXX between 0 and 377. For example, \251 is the octal sequence for the copyright symbol.
\xXXThe character with the Latin-1 encoding specified by the two hexadecimal digits XX between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol.
\uXXXXThe Unicode character specified by the four hexadecimal digits XXXX. For example, \u00A9 is the Unicode sequence for the copyright symbol. See Unicode Escape Sequences.
- -

Caracteres de escape

- -

For characters not listed in Table 2.1, a preceding backslash is ignored, but this usage is deprecated and should be avoided.

- -

You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example:

- -
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
-document.write(quote);
-
- -

The result of this would be:

- -
He read "The Cremation of Sam McGee" by R.W. Service.
-
- -

To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following:

- -
var home = "c:\\temp";
-
- -

You can also escape line breaks by preceding them with backslash.  The backslash and line break are both removed from the value of the string.

- -
var str = "this string \
-is broken \
-across multiple\
-lines."
- -

Although JavaScript does not have "heredoc" syntax, you can get close by adding a linebreak escape and an escaped linebreak at the end of each line:

- -
var poem =
-"Roses are red,\n\
-Violets are blue.\n\
-I'm schizophrenic,\n\
-And so am I."
-
- -

Unicode

- -

Unicode is a universal character-coding standard for the interchange and display of principal written languages. It covers the languages of the Americas, Europe, Middle East, Africa, India, Asia, and Pacifica, as well as historic scripts and technical symbols. Unicode allows for the exchange, processing, and display of multilingual texts, as well as the use of common technical and mathematical symbols. It hopes to resolve internationalization problems of multilingual computing, such as different national character standards. Not all modern or archaic scripts, however, are currently supported.

- -

The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.

- -

Unicode is not supported in versions of JavaScript prior to 1.3.

- -

Compatibilidade do Unicode com ASCII e ISO

- -

Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646.

- -

Several encoding standards (including UTF-8, UTF-16 and ISO UCS-2) are used to physically represent Unicode as actual bits.

- -

The UTF-8 encoding of Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses a 7-bit character set, UTF-8 uses between one and four octets for each character ("octet" meaning a byte, or 8 bits.) This allows for several million characters. An alternative encoding standard, UTF-16, uses two octets to represent Unicode characters. An escape sequence allows UTF-16 to represent the whole Unicode range by using four octets. The ISO UCS-2 (Universal Character Set) uses two octets.

- -

JavaScript and Navigator support for UTF-8/Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since the UTF-8 encoding of Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments, string literals, identifiers, and regular expressions of JavaScript.

- -

Sequências de escape em Unicode

- -

You can use the Unicode escape sequence in string literals, regular expressions, and identifiers. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.

- -

The following code returns the copyright symbol and the string "Netscape Communications".

- -
var x = "\u00A9 Netscape Communications";
- -

The following table lists frequently used special characters and their Unicode value.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 2.2 Unicode values for special characters
CategoryUnicode valueNameFormat name
White space values
-  
-  
-  		\u0009Tab<TAB>
\u000BVertical Tab<VT>
\u000CForm Feed<FF>
\u0020Space<SP>
Line terminator values
-  		\u000ALine Feed<LF>
\u000DCarriage Return<CR>
Additional Unicode escape sequence values
-  
-  
-  
-  		\u0008Backspace<BS>
\u0009Horizontal Tab<HT>
\u0022Double Quote"
\u0027Single Quote'
\u005CBackslash\
- -

The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (e.g., \u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.

- -

Caracteres Unicode em arquivos JavaScript

- -

Earlier versions of Gecko assumed the Latin-1 character encoding for JavaScript files loaded from XUL. Starting with Gecko 1.8, the character encoding is inferred from the XUL file's encoding. Please see International characters in XUL JavaScript for more information.

- -

Exibindo caracteres com Unicode

- -

You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Mozilla Firefox or Netscape needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide partial support for Unicode.

- -

To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Sometimes, the only way to input Unicode characters is by using Unicode escape sequences.

- -

For more information on Unicode, see the Unicode Home Page and The Unicode Standard, Version 2.0, published by Addison-Wesley, 1996.

- -
autoPreviousNext("JSGChapters");
diff --git a/files/pt-pt/web/javascript/guide/details_of_the_object_model/index.html b/files/pt-pt/web/javascript/guide/details_of_the_object_model/index.html new file mode 100644 index 0000000000..01de143289 --- /dev/null +++ b/files/pt-pt/web/javascript/guide/details_of_the_object_model/index.html @@ -0,0 +1,735 @@ +--- +title: Detalhes do modelo de objeto +slug: Web/JavaScript/Guia/Detalhes_do_modelo_de_objeto +tags: + - Guia(2) + - Intermediário + - JavaScript + - Objeto +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +--- +
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}
+ +
+

The content of this article is under discussion. Please provide feedback and help us to make this page better: {{bug(1201380)}}.

+
+ +

JavaScript is an object-based language based on prototypes, rather than being class-based. Because of this different basis, it can be less apparent how JavaScript allows you to create hierarchies of objects and to have inheritance of properties and their values. This chapter attempts to clarify the situation.

+ +

This chapter assumes that you are already somewhat familiar with JavaScript and that you have used JavaScript functions to create simple objects.

+ +

Linguagens com base em classe versus protótipo

+ +

Class-based object-oriented languages, such as Java and C++, are founded on the concept of two distinct entities: classes and instances.

+ + + +

A prototype-based language, such as JavaScript, does not make this distinction: it simply has objects. A prototype-based language has the notion of a prototypical object, an object used as a template from which to get the initial properties for a new object. Any object can specify its own properties, either when you create it or at run time. In addition, any object can be associated as the prototype for another object, allowing the second object to share the first object's properties.

+ +

Definição de uma classe

+ +

In class-based languages, you define a class in a separate class definition. In that definition you can specify special methods, called constructors, to create instances of the class. A constructor method can specify initial values for the instance's properties and perform other processing appropriate at creation time. You use the new operator in association with the constructor method to create class instances.

+ +

JavaScript follows a similar model, but does not have a class definition separate from the constructor. Instead, you define a constructor function to create objects with a particular initial set of properties and values. Any JavaScript function can be used as a constructor. You use the new operator with a constructor function to create a new object.

+ +

Subclasses e sucessão

+ +

In a class-based language, you create a hierarchy of classes through the class definitions. In a class definition, you can specify that the new class is a subclass of an already existing class. The subclass inherits all the properties of the superclass and additionally can add new properties or modify the inherited ones. For example, assume the Employee class includes only the name and dept properties, and Manager is a subclass of Employee that adds the reports property. In this case, an instance of the Manager class would have all three properties: name, dept, and reports.

+ +

JavaScript implements inheritance by allowing you to associate a prototypical object with any constructor function. So, you can create exactly the Employee — Manager example, but you use slightly different terminology. First you define the Employee constructor function, specifying the name and dept properties. Next, you define the Manager constructor function, calling the Employee constructor and specifying the reports property. Finally, you assign a new object derived from Employee.prototype as the prototype for the Manager constructor function. Then, when you create a new Manager, it inherits the name and dept properties from the Employee object.

+ +

Adição e remoção de propriedades

+ +

In class-based languages, you typically create a class at compile time and then you instantiate instances of the class either at compile time or at run time. You cannot change the number or the type of properties of a class after you define the class. In JavaScript, however, at run time you can add or remove properties of any object. If you add a property to an object that is used as the prototype for a set of objects, the objects for which it is the prototype also get the new property.

+ +

Resumo das diferenças

+ +

The following table gives a short summary of some of these differences. The rest of this chapter describes the details of using JavaScript constructors and prototypes to create an object hierarchy and compares this to how you would do it in Java.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Comparison of class-based (Java) and prototype-based (JavaScript) object systems
Com base em Classe (Java)Com base em Protótipo (JavaScript)
Class and instance are distinct entities.All objects can inherit from another object.
Define a class with a class definition; instantiate a class with constructor methods.Define and create a set of objects with constructor functions.
Create a single object with the new operator.Same.
Construct an object hierarchy by using class definitions to define subclasses of existing classes.Construct an object hierarchy by assigning an object as the prototype associated with a constructor function.
Inherit properties by following the class chain.Inherit properties by following the prototype chain.
Class definition specifies all properties of all instances of a class. Cannot add properties dynamically at run time.Constructor function or prototype specifies an initial set of properties. Can add or remove properties dynamically to individual objects or to the entire set of objects.
+ +

The employee example

+ +

The remainder of this chapter uses the employee hierarchy shown in the following figure.

+ +
+
+

A simple object hierarchy with the following objects:

+ +

+
+ +
+
    +
  • Employee has the properties name (whose value defaults to the empty string) and dept (whose value defaults to "general").
    • +
  • Manager is based on Employee. It adds the reports property (whose value defaults to an empty array, intended to have an array of Employee objects as its value).
    • +
  • WorkerBee is also based on Employee. It adds the projects property (whose value defaults to an empty array, intended to have an array of strings as its value).
    • +
  • SalesPerson is based on WorkerBee. It adds the quota property (whose value defaults to 100). It also overrides the dept property with the value "sales", indicating that all salespersons are in the same department.
    • +
  • Engineer is based on WorkerBee. It adds the machine property (whose value defaults to the empty string) and also overrides the dept property with the value "engineering".
    • +
+
+
+ +

Criação de hierarquia

+ +

There are several ways to define appropriate constructor functions to implement the Employee hierarchy. How you choose to define them depends largely on what you want to be able to do in your application.

+ +

This section shows how to use very simple (and comparatively inflexible) definitions to demonstrate how to get the inheritance to work. In these definitions, you cannot specify any property values when you create an object. The newly-created object simply gets the default values, which you can change at a later time.

+ +

In a real application, you would probably define constructors that allow you to provide property values at object creation time (see More flexible constructors for information). For now, these simple definitions demonstrate how the inheritance occurs.

+ +

The following Java and JavaScript Employee definitions are similar. The only difference is that you need to specify the type for each property in Java but not in JavaScript (this is due to Java being a strongly typed language while JavaScript is a weakly typed language).

+ +
+

JavaScript

+ +
function Employee() {
+  this.name = "";
+  this.dept = "general";
+}
+
+ +

Java

+ +
public class Employee {
+   public String name = "";
+   public String dept = "general";
+}
+
+
+ +

The Manager and WorkerBee definitions show the difference in how to specify the next object higher in the inheritance chain. In JavaScript, you add a prototypical instance as the value of the prototype property of the constructor function. You can do so at any time after you define the constructor. In Java, you specify the superclass within the class definition. You cannot change the superclass outside the class definition.

+ +
+

JavaScript

+ +
function Manager() {
+  Employee.call(this);
+  this.reports = [];
+}
+Manager.prototype = Object.create(Employee.prototype);
+
+function WorkerBee() {
+  Employee.call(this);
+  this.projects = [];
+}
+WorkerBee.prototype = Object.create(Employee.prototype);
+
+ +

Java

+ +
public class Manager extends Employee {
+   public Employee[] reports = new Employee[0];
+}
+
+
+
+public class WorkerBee extends Employee {
+   public String[] projects = new String[0];
+}
+
+
+
+
+ +

The Engineer and SalesPerson definitions create objects that descend from WorkerBee and hence from Employee. An object of these types has properties of all the objects above it in the chain. In addition, these definitions override the inherited value of the dept property with new values specific to these objects.

+ +
+

JavaScript

+ +
function SalesPerson() {
+   WorkerBee.call(this);
+   this.dept = "sales";
+   this.quota = 100;
+}
+SalesPerson.prototype = Object.create(WorkerBee.prototype);
+
+function Engineer() {
+   WorkerBee.call(this);
+   this.dept = "engineering";
+   this.machine = "";
+}
+Engineer.prototype = Object.create(WorkerBee.prototype);
+
+ +

Java

+ +
public class SalesPerson extends WorkerBee {
+   public double quota;
+   public dept = "sales";
+   public quota = 100.0;
+}
+
+
+public class Engineer extends WorkerBee {
+   public String machine;
+   public dept = "engineering";
+   public machine = "";
+}
+
+
+
+ +

Using these definitions, you can create instances of these objects that get the default values for their properties. The next figure illustrates using these JavaScript definitions to create new objects and shows the property values for the new objects.

+ +
+

Nota: The term instance has a specific technical meaning in class-based languages. In these languages, an instance is an individual instantiation of a class and is fundamentally different from a class. In JavaScript, "instance" does not have this technical meaning because JavaScript does not have this difference between classes and instances. However, in talking about JavaScript, "instance" can be used informally to mean an object created using a particular constructor function. So, in this example, you could informally say that jane is an instance of Engineer. Similarly, although the terms parent, child, ancestor, and descendant do not have formal meanings in JavaScript; you can use them informally to refer to objects higher or lower in the prototype chain.

+
+ +

Criação de objetos com definições simples

+ +
+

Hierarquia do objeto

+ +

The following hierarchy is created using the code on the right side.

+ +

+ +

 

+ +

individual objects

+ +
var jim = new Employee;
+// jim.name is ''
+// jim.dept is 'general'
+
+var sally = new Manager;
+// sally.name is ''
+// sally.dept is 'general'
+// sally.reports is []
+
+var mark = new WorkerBee;
+// mark.name is ''
+// mark.dept is 'general'
+// mark.projects is []
+
+var fred = new SalesPerson;
+// fred.name is ''
+// fred.dept is 'sales'
+// fred.projects is []
+// fred.quota is 100
+
+var jane = new Engineer;
+// jane.name is ''
+// jane.dept is 'engineering'
+// jane.projects is []
+// jane.machine is ''
+
+
+ +

Propriedades do objeto

+ +

This section discusses how objects inherit properties from other objects in the prototype chain and what happens when you add a property at run time.

+ +

Propriedades de sucessão

+ +

Suppose you create the mark object as a WorkerBee with the following statement:

+ +
var mark = new WorkerBee;
+
+ +

When JavaScript sees the new operator, it creates a new generic object and passes this new object as the value of the this keyword to the WorkerBee constructor function. The constructor function explicitly sets the value of the projects property, and implicitly sets the value of the internal __proto__ property to the value of WorkerBee.prototype. (That property name has two underscore characters at the front and two at the end.) The __proto__ property determines the prototype chain used to return property values. Once these properties are set, JavaScript returns the new object and the assignment statement sets the variable mark to that object.

+ +

This process does not explicitly put values in the mark object (local values) for the properties that mark inherits from the prototype chain. When you ask for the value of a property, JavaScript first checks to see if the value exists in that object. If it does, that value is returned. If the value is not there locally, JavaScript checks the prototype chain (using the __proto__ property). If an object in the prototype chain has a value for the property, that value is returned. If no such property is found, JavaScript says the object does not have the property. In this way, the mark object has the following properties and values:

+ +
mark.name = "";
+mark.dept = "general";
+mark.projects = [];
+
+ +

The mark object inherits values for the name and dept properties from the prototypical object in mark.__proto__. It is assigned a local value for the projects property by the WorkerBee constructor. This gives you inheritance of properties and their values in JavaScript. Some subtleties of this process are discussed in Property inheritance revisited.

+ +

Because these constructors do not let you supply instance-specific values, this information is generic. The property values are the default ones shared by all new objects created from WorkerBee. You can, of course, change the values of any of these properties. So, you could give specific information for mark as follows:

+ +
mark.name = "Doe, Mark";
+mark.dept = "admin";
+mark.projects = ["navigator"];
+ +

Adição de propriedades

+ +

In JavaScript, you can add properties to any object at run time. You are not constrained to use only the properties provided by the constructor function. To add a property that is specific to a single object, you assign a value to the object, as follows:

+ +
mark.bonus = 3000;
+
+ +

Now, the mark object has a bonus property, but no other WorkerBee has this property.

+ +

If you add a new property to an object that is being used as the prototype for a constructor function, you add that property to all objects that inherit properties from the prototype. For example, you can add a specialty property to all employees with the following statement:

+ +
Employee.prototype.specialty = "none";
+
+ +

As soon as JavaScript executes this statement, the mark object also has the specialty property with the value of "none". The following figure shows the effect of adding this property to the Employee prototype and then overriding it for the Engineer prototype.

+ +


+ Adding properties

+ +

Mais construtores flexíveis

+ +

The constructor functions shown so far do not let you specify property values when you create an instance. As with Java, you can provide arguments to constructors to initialize property values for instances. The following figure shows one way to do this.

+ +


+ Specifying properties in a constructor, take 1

+ +

The following table shows the Java and JavaScript definitions for these objects.

+ +
+

JavaScript

+ +

Java

+
+ +
+
function Employee (name, dept) {
+  this.name = name || "";
+  this.dept = dept || "general";
+}
+
+ +

 

+ +

 

+ +

 

+ +

 

+ +

 

+ +
public class Employee {
+   public String name;
+   public String dept;
+   public Employee () {
+      this("", "general");
+   }
+   public Employee (String name) {
+      this(name, "general");
+   }
+   public Employee (String name, String dept) {
+      this.name = name;
+      this.dept = dept;
+   }
+}
+
+
+ +
+
function WorkerBee (projs) {
+
+ this.projects = projs || [];
+}
+WorkerBee.prototype = new Employee;
+
+ +

 

+ +

 

+ +

 

+ +
public class WorkerBee extends Employee {
+   public String[] projects;
+   public WorkerBee () {
+      this(new String[0]);
+   }
+   public WorkerBee (String[] projs) {
+      projects = projs;
+   }
+}
+
+
+ +
+
+function Engineer (mach) {
+   this.dept = "engineering";
+   this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+
+ +

 

+ +

 

+ +

 

+ +
public class Engineer extends WorkerBee {
+   public String machine;
+   public Engineer () {
+      dept = "engineering";
+      machine = "";
+   }
+   public Engineer (String mach) {
+      dept = "engineering";
+      machine = mach;
+   }
+}
+
+
+ +

These JavaScript definitions use a special idiom for setting default values:

+ +
this.name = name || "";
+
+ +

The JavaScript logical OR operator (||) evaluates its first argument. If that argument converts to true, the operator returns it. Otherwise, the operator returns the value of the second argument. Therefore, this line of code tests to see if name has a useful value for the name property. If it does, it sets this.name to that value. Otherwise, it sets this.name to the empty string. This chapter uses this idiom for brevity; however, it can be puzzling at first glance.

+ +
+

Note: This may not work as expected if the constructor function is called with arguments which convert to false (like 0 (zero) and empty string (""). In this case the default value will be chosen.

+
+ +

With these definitions, when you create an instance of an object, you can specify values for the locally defined properties. You can use the following statement to create a new Engineer:

+ +
var jane = new Engineer("belau");
+
+ +

Jane's properties are now:

+ +
jane.name == "";
+jane.dept == "engineering";
+jane.projects == [];
+jane.machine == "belau"
+
+ +

Notice that with these definitions, you cannot specify an initial value for an inherited property such as name. If you want to specify an initial value for inherited properties in JavaScript, you need to add more code to the constructor function.

+ +

So far, the constructor function has created a generic object and then specified local properties and values for the new object. You can have the constructor add more properties by directly calling the constructor function for an object higher in the prototype chain. The following figure shows these new definitions.

+ +


+ Specifying properties in a constructor, take 2

+ +

Let's look at one of these definitions in detail. Here's the new definition for the Engineer constructor:

+ +
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+
+ +

Suppose you create a new Engineer object as follows:

+ +
var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+
+ +

JavaScript follows these steps:

+ +
    +
  1. The new operator creates a generic object and sets its __proto__ property to Engineer.prototype.
    2. +
  2. The new operator passes the new object to the Engineer constructor as the value of the this keyword.
    3. +
  3. The constructor creates a new property called base for that object and assigns the value of the WorkerBee constructor to the base property. This makes the WorkerBee constructor a method of the Engineer object.The name of the base property is not special. You can use any legal property name; base is simply evocative of its purpose.
    4. +
  4. +

    The constructor calls the base method, passing as its arguments two of the arguments passed to the constructor ("Doe, Jane" and ["navigator", "javascript"]) and also the string "engineering". Explicitly using "engineering" in the constructor indicates that all Engineer objects have the same value for the inherited dept property, and this value overrides the value inherited from Employee.

    +
    5. +
  5. Because base is a method of Engineer, within the call to base, JavaScript binds the this keyword to the object created in Step 1. Thus, the WorkerBee function in turn passes the "Doe, Jane" and "engineering" arguments to the Employee constructor function. Upon return from the Employee constructor function, the WorkerBee function uses the remaining argument to set the projects property.
    6. +
  6. Upon return from the base method, the Engineer constructor initializes the object's machine property to "belau".
    7. +
  7. Upon return from the constructor, JavaScript assigns the new object to the jane variable.
    8. +
+ +

You might think that, having called the WorkerBee constructor from inside the Engineer constructor, you have set up inheritance appropriately for Engineer objects. This is not the case. Calling the WorkerBee constructor ensures that an Engineer object starts out with the properties specified in all constructor functions that are called. However, if you later add properties to the Employee or WorkerBee prototypes, those properties are not inherited by the Engineer object. For example, assume you have the following statements:

+ +
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+Employee.prototype.specialty = "none";
+
+ +

The jane object does not inherit the specialty property. You still need to explicitly set up the prototype to ensure dynamic inheritance. Assume instead you have these statements:

+ +
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+Employee.prototype.specialty = "none";
+
+ +

Now the value of the jane object's specialty property is "none".

+ +

Another way of inheriting is by using the call() / apply() methods. Below are equivalent:

+ +
+
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+
+ +
function Engineer (name, projs, mach) {
+  WorkerBee.call(this, name, "engineering", projs);
+  this.machine = mach || "";
+}
+
+
+ +

Using the javascript call() method makes a cleaner implementation because the base is not needed anymore.

+ +

Sucessão de propriedade revisitada

+ +

The preceding sections described how JavaScript constructors and prototypes provide hierarchies and inheritance. This section discusses some subtleties that were not necessarily apparent in the earlier discussions.

+ +

Valores locais versus sucedidos

+ +

When you access an object property, JavaScript performs these steps, as described earlier in this chapter:

+ +
    +
  1. Check to see if the value exists locally. If it does, return that value.
    2. +
  2. If there is not a local value, check the prototype chain (using the __proto__ property).
    3. +
  3. If an object in the prototype chain has a value for the specified property, return that value.
    4. +
  4. If no such property is found, the object does not have the property.
    5. +
+ +

The outcome of these steps depends on how you define things along the way. The original example had these definitions:

+ +
function Employee () {
+  this.name = "";
+  this.dept = "general";
+}
+
+function WorkerBee () {
+  this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+ +

With these definitions, suppose you create amy as an instance of WorkerBee with the following statement:

+ +
var amy = new WorkerBee;
+
+ +

The amy object has one local property, projects. The values for the name and dept properties are not local to amy and so derive from the amy object's __proto__ property. Thus, amy has these property values:

+ +
amy.name == "";
+amy.dept == "general";
+amy.projects == [];
+
+ +

Now suppose you change the value of the name property in the prototype associated with Employee:

+ +
Employee.prototype.name = "Unknown"
+
+ +

At first glance, you might expect that new value to propagate down to all the instances of Employee. However, it does not.

+ +

When you create any instance of the Employee object, that instance gets a local value for the name property (the empty string). This means that when you set the WorkerBee prototype by creating a new Employee object, WorkerBee.prototype has a local value for the name property. Therefore, when JavaScript looks up the name property of the amy object (an instance of WorkerBee), JavaScript finds the local value for that property in WorkerBee.prototype. It therefore does not look further up the chain to Employee.prototype.

+ +

If you want to change the value of an object property at run time and have the new value be inherited by all descendants of the object, you cannot define the property in the object's constructor function. Instead, you add it to the constructor's associated prototype. For example, assume you change the preceding code to the following:

+ +
function Employee () {
+  this.dept = "general";
+}
+Employee.prototype.name = "";
+
+function WorkerBee () {
+  this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+var amy = new WorkerBee;
+
+Employee.prototype.name = "Unknown";
+
+ +

In this case, the name property of amy becomes "Unknown".

+ +

As these examples show, if you want to have default values for object properties and you want to be able to change the default values at run time, you should set the properties in the constructor's prototype, not in the constructor function itself.

+ +

Determining instance relationships

+ +

Property lookup in JavaScript looks within an object's own properties and, if the property name is not found, it looks within the special object property __proto__. This continues recursively; the process is called "lookup in the prototype chain".

+ +

The special property __proto__ is set when an object is constructed; it is set to the value of the constructor's prototype property. So the expression new Foo() creates an object with __proto__ == Foo.prototype. Consequently, changes to the properties of Foo.prototype alters the property lookup for all objects that were created by new Foo().

+ +

Every object has a __proto__ object property (except Object); every function has a prototype object property. So objects can be related by 'prototype inheritance' to other objects. You can test for inheritance by comparing an object's __proto__ to a function's prototype object. JavaScript provides a shortcut: the instanceof operator tests an object against a function and returns true if the object inherits from the function prototype. For example,

+ +
var f = new Foo();
+var isTrue = (f instanceof Foo);
+ +

For a more detailed example, suppose you have the same set of definitions shown in Inheriting properties. Create an Engineer object as follows:

+ +
var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
+
+ +

With this object, the following statements are all true:

+ +
chris.__proto__ == Engineer.prototype;
+chris.__proto__.__proto__ == WorkerBee.prototype;
+chris.__proto__.__proto__.__proto__ == Employee.prototype;
+chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
+chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
+
+ +

Given this, you could write an instanceOf function as follows:

+ +
function instanceOf(object, constructor) {
+   object = object.__proto__;
+   while (object != null) {
+      if (object == constructor.prototype)
+         return true;
+      if (typeof object == 'xml') {
+        return constructor.prototype == XML.prototype;
+      }
+      object = object.__proto__;
+   }
+   return false;
+}
+
+ +
Note: The implementation above checks the type of the object against "xml" in order to work around a quirk of how XML objects are represented in recent versions of JavaScript. See {{ bug(634150) }} if you want the nitty-gritty details.
+ +

Using the instanceOf function defined above, these expressions are true:

+ +
instanceOf (chris, Engineer)
+instanceOf (chris, WorkerBee)
+instanceOf (chris, Employee)
+instanceOf (chris, Object)
+
+ +

But the following expression is false:

+ +
instanceOf (chris, SalesPerson)
+
+ +

Informação global nos construtores

+ +

When you create constructors, you need to be careful if you set global information in the constructor. For example, assume that you want a unique ID to be automatically assigned to each new employee. You could use the following definition for Employee:

+ +
var idCounter = 1;
+
+function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   this.id = idCounter++;
+}
+
+ +

With this definition, when you create a new Employee, the constructor assigns it the next ID in sequence and then increments the global ID counter. So, if your next statement is the following, victoria.id is 1 and harry.id is 2:

+ +
var victoria = new Employee("Pigbert, Victoria", "pubs")
+var harry = new Employee("Tschopik, Harry", "sales")
+
+ +

At first glance that seems fine. However, idCounter gets incremented every time an Employee object is created, for whatever purpose. If you create the entire Employee hierarchy shown in this chapter, the Employee constructor is called every time you set up a prototype. Suppose you have the following code:

+ +
var idCounter = 1;
+
+function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   this.id = idCounter++;
+}
+
+function Manager (name, dept, reports) {...}
+Manager.prototype = new Employee;
+
+function WorkerBee (name, dept, projs) {...}
+WorkerBee.prototype = new Employee;
+
+function Engineer (name, projs, mach) {...}
+Engineer.prototype = new WorkerBee;
+
+function SalesPerson (name, projs, quota) {...}
+SalesPerson.prototype = new WorkerBee;
+
+var mac = new Engineer("Wood, Mac");
+
+ +

Further assume that the definitions omitted here have the base property and call the constructor above them in the prototype chain. In this case, by the time the mac object is created, mac.id is 5.

+ +

Depending on the application, it may or may not matter that the counter has been incremented these extra times. If you care about the exact value of this counter, one possible solution involves instead using the following constructor:

+ +
function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   if (name)
+      this.id = idCounter++;
+}
+
+ +

When you create an instance of Employee to use as a prototype, you do not supply arguments to the constructor. Using this definition of the constructor, when you do not supply arguments, the constructor does not assign a value to the id and does not update the counter. Therefore, for an Employee to get an assigned id, you must specify a name for the employee. In this example, mac.id would be 1.

+ +

No multiple inheritance

+ +

Some object-oriented languages allow multiple inheritance. That is, an object can inherit the properties and values from unrelated parent objects. JavaScript does not support multiple inheritance.

+ +

Inheritance of property values occurs at run time by JavaScript searching the prototype chain of an object to find a value. Because an object has a single associated prototype, JavaScript cannot dynamically inherit from more than one prototype chain.

+ +

In JavaScript, you can have a constructor function call more than one other constructor function within it. This gives the illusion of multiple inheritance. For example, consider the following statements:

+ +
function Hobbyist (hobby) {
+   this.hobby = hobby || "scuba";
+}
+
+function Engineer (name, projs, mach, hobby) {
+   this.base1 = WorkerBee;
+   this.base1(name, "engineering", projs);
+   this.base2 = Hobbyist;
+   this.base2(hobby);
+   this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+
+var dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")
+
+ +

Further assume that the definition of WorkerBee is as used earlier in this chapter. In this case, the dennis object has these properties:

+ +
dennis.name == "Doe, Dennis"
+dennis.dept == "engineering"
+dennis.projects == ["collabra"]
+dennis.machine == "hugo"
+dennis.hobby == "scuba"
+
+ +

So dennis does get the hobby property from the Hobbyist constructor. However, assume you then add a property to the Hobbyist constructor's prototype:

+ +
Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
+
+ +

The dennis object does not inherit this new property.

+ +
{{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}
diff --git a/files/pt-pt/web/javascript/guide/grammar_and_types/index.html b/files/pt-pt/web/javascript/guide/grammar_and_types/index.html new file mode 100644 index 0000000000..109bd99fe4 --- /dev/null +++ b/files/pt-pt/web/javascript/guide/grammar_and_types/index.html @@ -0,0 +1,641 @@ +--- +title: Gramática e tipos +slug: Web/JavaScript/Guia/Gramática_e_tipos +tags: + - Guia(2) + - JavaScript +translation_of: Web/JavaScript/Guide/Grammar_and_types +--- +
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}
+ +

Este capítulo discute a gramática básica do JavaScript, declarações de variáveis, tipos de dados e literais.

+ +

Básicos

+ +

JavaScript borrows most of its syntax from Java, but is also influenced by Awk, Perl and Python.

+ +

JavaScript is case-sensitive and uses the Unicode character set.

+ +

In JavaScript, instructions are called {{Glossary("Statement", "statements")}} and are separated by a semicolon (;). Spaces, tabs and newline characters are called whitespace. The source text of JavaScript scripts gets scanned from left to right and is converted into a sequence of input elements which are tokens, control characters, line terminators, comments or whitespace. ECMAScript also defines certain keywords and literals and has rules for automatic insertion of semicolons (ASI) to end statements. However, it is recommended to always add semicolons to end your statements; it will avoid side effects. For more information, see the detailed reference about JavaScript's lexical grammar.

+ +

Comentários

+ +

The syntax of comments is the same as in C++ and in many other languages:

+ +
// a one line comment
+
+/* this is a longer,
+   multi-line comment
+ */
+
+/* You can't, however, /* nest comments */ SyntaxError */
+ +

Declarações

+ +

There are three kinds of declarations in JavaScript.

+ +
+
{{jsxref("Statements/var", "var")}}
+
Declares a variable, optionally initializing it to a value.
+
{{experimental_inline}} {{jsxref("Statements/let", "let")}}
+
Declares a block scope local variable, optionally initializing it to a value.
+
{{experimental_inline}} {{jsxref("Statements/const", "const")}}
+
Declares a read-only named constant.
+
+ +

Variáveis

+ +

You use variables as symbolic names for values in your application. The names of variables, called {{Glossary("Identifier", "identifiers")}}, conform to certain rules.

+ +

A JavaScript identifier must start with a letter, underscore (_), or dollar sign ($); subsequent characters can also be digits (0-9). Because JavaScript is case sensitive, letters include the characters "A" through "Z" (uppercase) and the characters "a" through "z" (lowercase).

+ +

You can use ISO 8859-1 or Unicode letters such as å and ü in identifiers. You can also use the Unicode escape sequences as characters in identifiers.

+ +

Some examples of legal names are Number_hits, temp99, and _name.

+ +

Declararação de variáveis

+ +

You can declare a variable in three ways:

+ + + +

Avaliação de variáveis

+ +

A variable declared using the var statement with no initial value specified has the value {{jsxref("undefined")}}.

+ +

An attempt to access an undeclared variable or an attempt to access an identifier declared with let statement before initialization will result in a {{jsxref("ReferenceError")}} exception being thrown:

+ +
var a;
+console.log("The value of a is " + a); // logs "The value of a is undefined"
+console.log("The value of b is " + b); // throws ReferenceError exception
+
+console.log("The value of x is " + x); // throws ReferenceError exception
+let x;
+ +

You can use undefined to determine whether a variable has a value. In the following code, the variable input is not assigned a value, and the if statement evaluates to true.

+ +
var input;
+if(input === undefined){
+  doThis();
+} else {
+  doThat();
+}
+
+ +

The undefined value behaves as false when used in a boolean context. For example, the following code executes the function myFunction because the myArray element is undefined:

+ +
var myArray = [];
+if (!myArray[0]) myFunction();
+
+ +

The undefined value converts to NaN when used in numeric context.

+ +
var a;
+a + 2;  // Evaluates to NaN
+ +

When you evaluate a {{jsxref("null")}} variable, the null value behaves as 0 in numeric contexts and as false in boolean contexts. For example:

+ +
var n = null;
+console.log(n * 32); // Will log 0 to the console
+
+ +

Variable scope

+ +

When you declare a variable outside of any function, it is called a global variable, because it is available to any other code in the current document. When you declare a variable within a function, it is called a local variable, because it is available only within that function.

+ +

JavaScript before ECMAScript 2015 does not have block statement scope; rather, a variable declared within a block is local to the function (or global scope) that the block resides within. For example the following code will log 5, because the scope of x is the function (or global context) within which x is declared, not the block, which in this case is an if statement.

+ +
if (true) {
+  var x = 5;
+}
+console.log(x);  // 5
+
+ +

This behavior changes, when using the let declaration introduced in ECMAScript 2015.

+ +
if (true) {
+  let y = 5;
+}
+console.log(y);  // ReferenceError: y is not defined
+
+ +

Variable hoisting

+ +

Another unusual thing about variables in JavaScript is that you can refer to a variable declared later, without getting an exception. This concept is known as hoisting; variables in JavaScript are in a sense "hoisted" or lifted to the top of the function or statement. However, variables that are hoisted will return a value of undefined. So even if you declare and initialize after you use or refer to this variable, it will still return undefined.

+ +
/**
+ * Example 1
+ */
+console.log(x === undefined); // true
+var x = 3;
+
+/**
+ * Example 2
+ */
+// will return a value of undefined
+var myvar = "my value";
+
+(function() {
+  console.log(myvar); // undefined
+  var myvar = "local value";
+})();
+
+ +

The above examples will be interpreted the same as:

+ +
/**
+ * Example 1
+ */
+var x;
+console.log(x === undefined); // true
+x = 3;
+
+/**
+ * Example 2
+ */
+var myvar = "my value";
+
+(function() {
+  var myvar;
+  console.log(myvar); // undefined
+  myvar = "local value";
+})();
+
+ +

Because of hoisting, all var statements in a function should be placed as near to the top of the function as possible. This best practice increases the clarity of the code.

+ +

In ECMAScript 2015, let (const) will not hoist the variable to the top of the block. However, referencing the variable in the block before the variable declaration results in a ReferenceError. The variable is in a "temporal dead zone" from the start of the block until the declaration is processed.

+ +
console.log(x); // ReferenceError
+let x = 3;
+ +

Variáveis gGlobais

+ +

Global variables are in fact properties of the global object. In web pages the global object is {{domxref("window")}}, so you can set and access global variables using the window.variable syntax.

+ +

Consequently, you can access global variables declared in one window or frame from another window or frame by specifying the window or frame name. For example, if a variable called phoneNumber is declared in a document, you can refer to this variable from an iframe as parent.phoneNumber.

+ +

Constantes

+ +

You can create a read-only, named constant with the {{jsxref("Statements/const", "const")}} keyword. The syntax of a constant identifier is the same as for a variable identifier: it must start with a letter, underscore or dollar sign and can contain alphabetic, numeric, or underscore characters.

+ +
const PI = 3.14;
+
+ +

A constant cannot change value through assignment or be re-declared while the script is running. It has to be initialized to a value.

+ +

The scope rules for constants are the same as those for let block scope variables. If the const keyword is omitted, the identifier is assumed to represent a variable.

+ +

You cannot declare a constant with the same name as a function or variable in the same scope. For example:

+ +
// THIS WILL CAUSE AN ERROR
+function f() {};
+const f = 5;
+
+// THIS WILL CAUSE AN ERROR ALSO
+function f() {
+  const g = 5;
+  var g;
+
+  //statements
+}
+
+ +

However, object attributes are not protected, so the following statement is executed without problems.

+ +
const MY_OBJECT = {"key": "value"};
+MY_OBJECT.key = "otherValue";
+ +

Estruturas e tipode dados

+ +

tipos de dados

+ +

The latest ECMAScript standard defines seven data types:

+ + + +

Although these data types are a relatively small amount, they enable you to perform useful functions with your applications. {{jsxref("Object", "Objects")}} and {{jsxref("Function", "functions")}} are the other fundamental elements in the language. You can think of objects as named containers for values, and functions as procedures that your application can perform.

+ +

Conversão de tipo de dados

+ +

JavaScript is a dynamically typed language. That means you don't have to specify the data type of a variable when you declare it, and data types are converted automatically as needed during script execution. So, for example, you could define a variable as follows:

+ +
var answer = 42;
+
+ +

And later, you could assign the same variable a string value, for example:

+ +
answer = "Thanks for all the fish...";
+
+ +

Because JavaScript is dynamically typed, this assignment does not cause an error message.

+ +

In expressions involving numeric and string values with the + operator, JavaScript converts numeric values to strings. For example, consider the following statements:

+ +
x = "The answer is " + 42 // "The answer is 42"
+y = 42 + " is the answer" // "42 is the answer"
+
+ +

In statements involving other operators, JavaScript does not convert numeric values to strings. For example:

+ +
"37" - 7 // 30
+"37" + 7 // "377"
+
+ +

Conversão de strings para números

+ +

In the case that a value representing a number is in memory as a string, there are methods for conversion.

+ + + +

parseInt will only return whole numbers, so its use is diminished for decimals. Additionally, a best practice for parseInt is to always include the radix parameter. The radix parameter is used to specify which numerical system is to be used.

+ +

An alternative method of retrieving a number from a string is with the + (unary plus) operator:

+ +
"1.1" + "1.1" = "1.11.1"
+(+"1.1") + (+"1.1") = 2.2
+// Note: the parentheses are added for clarity, not required.
+ +

Literais

+ +

You use literals to represent values in JavaScript. These are fixed values, not variables, that you literally provide in your script. This section describes the following types of literals:

+ + + +

Literais de tabela

+ +

An array literal is a list of zero or more expressions, each of which represents an array element, enclosed in square brackets ([]). When you create an array using an array literal, it is initialized with the specified values as its elements, and its length is set to the number of arguments specified.

+ +

The following example creates the coffees array with three elements and a length of three:

+ +
var coffees = ["French Roast", "Colombian", "Kona"];
+
+ +
+

Note : An array literal is a type of object initializer. See Using Object Initializers.

+
+ +

If an array is created using a literal in a top-level script, JavaScript interprets the array each time it evaluates the expression containing the array literal. In addition, a literal used in a function is created each time the function is called.

+ +

Array literals are also Array objects. See {{jsxref("Array")}} and Indexed collections for details on Array objects.

+ +

Extra commas in array literals

+ +

You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with undefined for the unspecified elements. The following example creates the fish array:

+ +
var fish = ["Lion", , "Angel"];
+
+ +

This array has two elements with values and one empty element (fish[0] is "Lion", fish[1] is undefined, and fish[2] is "Angel").

+ +

If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no myList[3]. All other commas in the list indicate a new element.

+ +
+

Nota : Trailing commas can create errors in older browser versions and it is a best practice to remove them.

+
+ +
var myList = ['home', , 'school', ];
+
+ +

In the following example, the length of the array is four, and myList[0] and myList[2] are missing.

+ +
var myList = [ , 'home', , 'school'];
+
+ +

In the following example, the length of the array is four, and myList[1] and myList[3] are missing. Only the last comma is ignored.

+ +
var myList = ['home', , 'school', , ];
+
+ +

Understanding the behavior of extra commas is important to understanding JavaScript as a language, however when writing your own code: explicitly declaring the missing elements as undefined will increase your code's clarity and maintainability.

+ +

Lietrais boolianas

+ +

The Boolean type has two literal values: true and false.

+ +

Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. See {{jsxref("Boolean")}} for more information.

+ +

Íntegros

+ +

Integers can be expressed in decimal (base 10), hexadecimal (base 16), octal (base 8) and binary (base 2).

+ + + +

Some examples of integer literals are:

+ +
0, 117 and -345 (decimal, base 10)
+015, 0001 and -0o77 (octal, base 8)
+0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
+0b11, 0b0011 and -0b11 (binary, base 2)
+
+ +

For more information, see Numeric literals in the Lexical grammar reference.

+ +

Literais de ponto flutuante

+ +

A floating-point literal can have the following parts:

+ + + +

The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E").

+ +

More succinctly, the syntax is:

+ +
[(+|-)][digits][.digits][(E|e)[(+|-)]digits]
+
+ +

For example:

+ +
3.1415926
+-.123456789
+-3.1E+12
+.1e-23
+
+ +

Literais de objeto

+ +

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.

+ +

The following is an example of an object literal. The first element of the car object defines a property, myCar, and assigns to it a new string, "Saturn"; the second element, the getCar property, is immediately assigned the result of invoking the function (carTypes("Honda")); the third element, the special property, uses an existing variable (sales).

+ +
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
+
+ +

Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

+ +
var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
+
+console.log(car.manyCars.b); // Jeep
+console.log(car[7]); // Mazda
+
+ +

Object property names can be any string, including the empty string. If the property name would not be a valid JavaScript {{Glossary("Identifier","identifier")}} or number, it must be enclosed in quotes. Property names that are not valid identifiers also cannot be accessed as a dot (.) property, but can be accessed and set with the array-like notation("[]").

+ +
var unusualPropertyNames = {
+  "": "An empty string",
+  "!": "Bang!"
+}
+console.log(unusualPropertyNames."");   // SyntaxError: Unexpected string
+console.log(unusualPropertyNames[""]);  // An empty string
+console.log(unusualPropertyNames.!);    // SyntaxError: Unexpected token !
+console.log(unusualPropertyNames["!"]); // Bang!
+ +

In ES2015, object literals are extended to support setting the prototype at construction, shorthand for foo: foo assignments, defining methods, making super calls, and computing property names with expressions. Together, these also bring object literals and class declarations closer together, and let object-based design benefit from some of the same conveniences.

+ +
var obj = {
+    // __proto__
+    __proto__: theProtoObj,
+    // Shorthand for ‘handler: handler’
+    handler,
+    // Methods
+    toString() {
+     // Super calls
+     return "d " + super.toString();
+    },
+    // Computed (dynamic) property names
+    [ 'prop_' + (() => 42)() ]: 42
+};
+ +

Por favor, note:

+ +
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 is not defined
+console.log(foo["a"]); // alpha
+console.log(foo["2"]); // two
+
+ +

RegExp literals

+ +

A regex literal is a pattern enclosed between slashes. The following is an example of an regex literal.

+ +
var re = /ab+c/;
+ +

Lietrais de string

+ +

A string literal is zero or more characters enclosed in double (") or single (') quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:

+ +
"foo"
+'bar'
+"1234"
+"one line \n another line"
+"John's cat"
+
+ +

You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal:

+ +
console.log("John's cat".length)
+// Will print the number of symbols in the string including whitespace.
+// In this case, 10.
+
+ +

In ES2015, template literals are also available. Template strings provide syntactic sugar for constructing strings. This is similar to string interpolation features in Perl, Python and more. Optionally, a tag can be added to allow the string construction to be customized, avoiding injection attacks or constructing higher level data structures from string contents.

+ +
// Basic literal string creation
+`In JavaScript '\n' is a line-feed.`
+
+// Multiline strings
+`In JavaScript this is
+ not legal.`
+
+// String interpolation
+var name = "Bob", time = "today";
+`Hello ${name}, how are you ${time}?`
+
+// Construct an HTTP request prefix is used to interpret the replacements and construction
+POST`http://foo.org/bar?a=${a}&b=${b}
+     Content-Type: application/json
+     X-Credentials: ${credentials}
+     { "foo": ${foo},
+       "bar": ${bar}}`(myOnReadyStateChangeHandler);
+ +

You should use string literals unless you specifically need to use a String object. See {{jsxref("String")}} for details on String objects.

+ +

Using special characters in strings

+ +

In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.

+ +
"one line \n another line"
+
+ +

The following table lists the special characters that you can use in JavaScript strings.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table: JavaScript special characters
CáraterSignificado
\0Null Byte
\bBackspace
\fForm feed
\nNew line
\rCarriage return
\tTab
\vVertical tab
\'Apostrophe or single quote
\"Double quote
\\Backslash character
\XXXThe character with the Latin-1 encoding specified by up to three octal digits XXX between 0 and 377. For example, \251 is the octal sequence for the copyright symbol.
\xXXThe character with the Latin-1 encoding specified by the two hexadecimal digits XX between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol.
\uXXXXThe Unicode character specified by the four hexadecimal digits XXXX. For example, \u00A9 is the Unicode sequence for the copyright symbol. See Unicode escape sequences.
\u{XXXXX}Unicode code point escapes. For example, \u{2F804} is the same as the simple Unicode escapes \uD87E\uDC04.
+ +

Escaping characters

+ +

For characters not listed in the table, a preceding backslash is ignored, but this usage is deprecated and should be avoided.

+ +

You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example:

+ +
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
+console.log(quote);
+
+ +

The result of this would be:

+ +
He read "The Cremation of Sam McGee" by R.W. Service.
+
+ +

To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following:

+ +
var home = "c:\\temp";
+
+ +

You can also escape line breaks by preceding them with backslash. The backslash and line break are both removed from the value of the string.

+ +
var str = "this string \
+is broken \
+across multiple\
+lines."
+console.log(str);   // this string is broken across multiplelines.
+
+ +

Although JavaScript does not have "heredoc" syntax, you can get close by adding a line break escape and an escaped line break at the end of each line:

+ +
var poem =
+"Roses are red,\n\
+Violets are blue.\n\
+Sugar is sweet,\n\
+and so is foo."
+
+ +

Mais informação

+ +

This chapter focuses on basic syntax for declarations and types. To learn more about JavaScript's language constructs, see also the following chapters in this guide:

+ + + +

In the next chapter, we will have a look at control flow constructs and error handling.

+ +

{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}

diff --git a/files/pt-pt/web/javascript/guide/index.html b/files/pt-pt/web/javascript/guide/index.html new file mode 100644 index 0000000000..aec08fb7ad --- /dev/null +++ b/files/pt-pt/web/javascript/guide/index.html @@ -0,0 +1,123 @@ +--- +title: Guia de JavaScript +slug: Web/JavaScript/Guia +tags: + - Guía + - JavaScript + - 'l10n:prioridade' +translation_of: Web/JavaScript/Guide +--- +
{{jsSidebar("JavaScript Guide")}}
+ +

The JavaScript Guide shows you how to use JavaScript and gives an overview of the language. If you want to get started with JavaScript or programming in general, consult the articles in the learning area. If you need exhaustive information about a language feature, have a look at the JavaScript reference.

+ +

Capítulos

+ +

This Guide is divided into several chapters:

+ + + + + + + + + +

{{Next("Web/JavaScript/Guide/Introduction")}}

diff --git a/files/pt-pt/web/javascript/guide/introduction/index.html b/files/pt-pt/web/javascript/guide/introduction/index.html new file mode 100644 index 0000000000..f77bb74379 --- /dev/null +++ b/files/pt-pt/web/javascript/guide/introduction/index.html @@ -0,0 +1,137 @@ +--- +title: Introdução +slug: Web/JavaScript/Guia/Introdução +tags: + - Guía + - JavaScript +translation_of: Web/JavaScript/Guide/Introduction +--- +
{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}
+ +

Este capítulo apresenta a linguagem JavaScript e discuste alguns dos seus conceitos fundamentais.

+ +

O que você já deveria saber

+ +

Este guia assume que você possuí os seguintes conhecimentos:

+ + + +

Onde encontrar informação sobre JavaScript?

+ +

A documentação de JavaScript no MDN incluí o seguinte:

+ + + +

Se for iniciante em JavaScript, comece lendo alguns dos artigos na área de aprendizagem e o  Guia de JavaScript. Assim que compreender os fundamentos da linguagem, pode consultar a Referência de JavaScript para obter mais detalhes sobre objetos individuais e declarações.

+ +

O que é JavaScript?

+ +

JavaScript é uma linguagem de script orientada a objetos e que funciona entre plataformas. É uma linguagem pequena e simples. Ela pode ser rodada num ambiente anfitrião (por exemplo, o browser),  o código JavaScript pode estar ligado a objetos do ambiente e  fornece controle programático sobre os mesmos.

+ +

O JavaScript contém uma biblioteca padrão de objetos, tais como Array, Date, Math, e um conjunto fundamental de elementos da linguagem tais como operadores, estruturas de controle, e statements. Os elementos básicos do JavaScript podem ser extendidos com objetos adicionais para uma variedade de propósitos, por exemplo:

+ + + +

JavaScript e Java

+ +

JavaScript e Java são linguagens similares em alguns aspetos mas fundamentalmente diferentes noutros. A linguagem JavaScript assemelha-se ao Java mas não tem o static typing nem a validação strong type. O JavaScsript segue a sintaxe de expressões do Java, convenções de nomenclatura e os construtores básicos de controlo de fluxo. Esta última foi a razão pelo qual a linguagem foi renomeada de LiveScript para JavaScript.

+ +

In contrast to Java's compile-time system of classes built by declarations, JavaScript supports a runtime system based on a small number of data types representing numeric, Boolean, and string values. JavaScript has a prototype-based object model instead of the more common class-based object model. The prototype-based model provides dynamic inheritance; that is, what is inherited can vary for individual objects. JavaScript also supports functions without any special declarative requirements. Functions can be properties of objects, executing as loosely typed methods.

+ +

JavaScript is a very free-form language compared to Java. You do not have to declare all variables, classes, and methods. You do not have to be concerned with whether methods are public, private, or protected, and you do not have to implement interfaces. Variables, parameters, and function return types are not explicitly typed.

+ +

Java is a class-based programming language designed for fast execution and type safety. Type safety means, for instance, that you can't cast a Java integer into an object reference or access private memory by corrupting Java bytecodes. Java's class-based model means that programs consist exclusively of classes and their methods. Java's class inheritance and strong typing generally require tightly coupled object hierarchies. These requirements make Java programming more complex than JavaScript programming.

+ +

In contrast, JavaScript descends in spirit from a line of smaller, dynamically typed languages such as HyperTalk and dBASE. These scripting languages offer programming tools to a much wider audience because of their easier syntax, specialized built-in functionality, and minimal requirements for object creation.

+ + + + + + + + + + + + + + + + + + + + + + + +
JavaScript comparado com Java
JavaScriptJava
Object-oriented. No distinction between types of objects. Inheritance is through the prototype mechanism, and properties and methods can be added to any object dynamically.Class-based. Objects are divided into classes and instances with all inheritance through the class hierarchy. Classes and instances cannot have properties or methods added dynamically.
Variable data types are not declared (dynamic typing).Variable data types must be declared (static typing).
Cannot automatically write to hard disk.Can automatically write to hard disk.
+ +

For more information on the differences between JavaScript and Java, see the chapter Details of the object model.

+ +

JavaScript e a especificação ECMAScript

+ +

JavaScript is standardized at Ecma International — the European association for standardizing information and communication systems (ECMA was formerly an acronym for the European Computer Manufacturers Association) to deliver a standardized, international programming language based on JavaScript. This standardized version of JavaScript, called ECMAScript, behaves the same way in all applications that support the standard. Companies can use the open standard language to develop their implementation of JavaScript. The ECMAScript standard is documented in the ECMA-262 specification. See New in JavaScript to learn more about different versions of JavaScript and ECMAScript specification editions.

+ +

The ECMA-262 standard is also approved by the ISO (International Organization for Standardization) as ISO-16262. You can also find the specification on the Ecma International website. The ECMAScript specification does not describe the Document Object Model (DOM), which is standardized by the World Wide Web Consortium (W3C) and/or WHATWG (Web Hypertext Application Technology Working Group). The DOM defines the way in which HTML document objects are exposed to your script. To get a better idea about the different technologies that are used when programming with JavaScript, consult the article JavaScript technologies overview.

+ +

Documentação JavaScript versus especificação  ECMAScript

+ +

The ECMAScript specification is a set of requirements for implementing ECMAScript; it is useful if you want to implement standards-compliant language features in your ECMAScript implementation or engine (such as SpiderMonkey in Firefox, or v8 in Chrome).

+ +

The ECMAScript document is not intended to help script programmers; use the JavaScript documentation for information on writing scripts.

+ +

The ECMAScript specification uses terminology and syntax that may be unfamiliar to a JavaScript programmer. Although the description of the language may differ in ECMAScript, the language itself remains the same. JavaScript supports all functionality outlined in the ECMAScript specification.

+ +

The JavaScript documentation describes aspects of the language that are appropriate for a JavaScript programmer.

+ +

Começar com JavaScript

+ +

Getting started with JavaScript is easy: all you need is a modern Web browser. This guide includes some JavaScript features which are only currently available in the latest versions of Firefox, so using the most recent version of Firefox is recommended.

+ +

There are two tools built into Firefox that are useful for experimenting with JavaScript: the Web Console and Scratchpad.

+ +

A Consola da Web

+ +

A Consola da Web shows you information about the currently loaded Web page, and also includes a command line that you can use to execute JavaScript expressions in the current page.

+ +

To open the Web Console (Ctrl+Shift+K), select "Web Console" from the "Developer" menu, which is under the "Tools" menu in Firefox. It appears at the bottom of the browser window. Along the bottom of the console is a command line that you can use to enter JavaScript, and the output appears in the pane above:

+ +

+ +

Scratchpad

+ +

The Web Console is great for executing single lines of JavaScript, but although you can execute multiple lines, it's not very convenient for that, and you can't save your code samples using the Web Console. So for more complex examples Scratchpad is a better tool.

+ +

To open Scratchpad (Shift+F4), select "Scratchpad" from the "Developer" menu, which is under the menu in Firefox. It opens in a separate window and is an editor that you can use to write and execute JavaScript in the browser. You can also save scripts to disk and load them from disk.

+ +

+ +

Olá mundo

+ +

To get started with writing JavaScript, open the Scratchpad and write your first "Hello world" JavaScript code:

+ +
function greetMe(yourName) {
+  alert("Hello " + yourName);
+}
+
+greetMe("World");
+
+ +

Select the code in the pad and hit Ctrl+R to watch it unfold in your browser!

+ +

In the following pages, this guide will introduce you to the JavaScript syntax and language features, so that you will be able to write more complex applications.

+ +

{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}

diff --git a/files/pt-pt/web/javascript/memory_management/index.html b/files/pt-pt/web/javascript/memory_management/index.html new file mode 100644 index 0000000000..56bfec0f7f --- /dev/null +++ b/files/pt-pt/web/javascript/memory_management/index.html @@ -0,0 +1,187 @@ +--- +title: Gestão de memória +slug: Web/JavaScript/Gestao_Memoria +tags: + - Desempenho + - JavaScript + - memoria +translation_of: Web/JavaScript/Memory_Management +--- +
{{JsSidebar("Advanced")}}
+ +

Introdução

+ +

Linguagens de baixo nível, como o C, têm funções pimitivas de gestão de memória, como por exemplo, malloc() e free(). Por outro lado, os valores em JavaScript são alocados quando coisas (objetos, variáveis de texto, etc.) são criadas e "automaticamente" libertadas da memória quando deixam de ser utilizadas. O último processo é chamado de coleção do lixo. Este "automatismo" é uma fonte de mal entendidos e transmite aos programadores de JavaScript ( e aos de outras linguagens de alto nível ) a impressão de que podem decidir não se preocupar com a gestão da memória. Isto é uma erro.

+ +

Ciclo da duração da memória

+ +

Independentemente da linguagem de programação, o ciclo da duração da memória é praticamente sempre o mesmo:

+ +
    +
  1. Alocação da memória necessária
    2. +
  2. Utilização da memória alocada ( leitura, escrita )
    3. +
  3. Libertar a memória alocada quando já não é necessária
    4. +
+ +

A segunda etapa é explícita em todas as linguagens. A primeira e a última etapa são explícitas em linguagens de baixo nível mas são, na sua maioria, implícitas em linguagens de alto nível como o JavaScript.

+ +

Alocação no JavaScript

+ +

Inicialização do valor

+ +

Com o intuito de não incomodar o programador com alocações, o JavaScript fá-lo juntamente com a declaração de valores.

+ +
var n = 123; // alocação da memória para um número
+var s = 'azerty'; // alocação de memória para um texto
+
+var o = {
+  a: 1,
+  b: null
+}; // alocação de memória para um objeto e o seu conteúdo
+
+// (similar ao objeto) alocação de memória para a matriz e
+// os seus valores
+var a = [1, null, 'abra'];
+
+function f(a) {
+  return a + 2;
+} // alocação de uma função (que é um objeto que pode ser chamado)
+
+// Expressões de funções também alocam um objeto
+someElement.addEventListener('click', function() {
+  someElement.style.backgroundColor = 'blue';
+}, false);
+
+ +

Alocação através de chamadas de funções

+ +

Algumas chamadas de funções resultam na alocação de um objeto.

+ +
var d = new Date(); // alocação de um objeto Date
+
+var e = document.createElement('div'); // alocação de um elemento DOM
+ +

Alguns métodos alocam novos valores ou objetos:

+ +
var s = 'azerty';
+var s2 = s.substr(0, 3); // s2 é uma nova variável de texto
+// Dado que as variáveis de texto são de valor imutável,
+// o JavaScript pode decidir não alocar memória,
+// mas apenas armazenar o intervalo [0, 3].
+
+var a = ['ouais ouais', 'nan nan'];
+var a2 = ['generation', 'nan nan'];
+var a3 = a.concat(a2);
+// nova matriz de 4 elementos resultando
+// da concatenação dos elementos de a e a2
+
+ +

Utilização de valores

+ +

Basicamente, a utilização de valores significa a leitura e a escrita na memória alocada. Isto pode ser feito através da leitura ou escrita do valor de uma variável ou uma propriedade de um objeto ou até a passagem de um argumento para uma função.

+ +

Remoção quando a memória já não é necessária

+ +

A maioria dos problemas de gestão de memória aparecem nesta fase. A tarefa mais difícil é descobrir quando "a memória alocada já não é necessária". Em geral, requer que o programador determine quando, no seu código, este pedaço de memória já não é necessário e a liberte.

+ +

Linguagens de alto nível têm embutidas um pedaço de código chamado "coleção de lixo", cuja tarefa é rastrear a alocação e uso da memória, para detetar quando um pedaço de memória já não é necessário e neste caso, automaticamente libertá-la. Este processo é uma aproximação dado que o problema geral de se saber quando um pedaço da memória é necessário, é indecisível ( não pode ser solucionado por um algoritmo ).

+ +

Coleção de lixo

+ +

Como mencionado anteriormente, o problema geral de automaticamente descobrir quando alguma ocupação de memória "já não é necessária", é indecisível. Como consequência, as coleções de lixo implementam uma restrição à solução para o problema em geral. Esta seção explicará as noções necessárias para se compreender os principais algoritmos da coleção de lixo e as suas limitações.

+ +

Referências

+ +

A noção principal dos algoritmos de coleção de lixo baseiam-se na noção de referência. Dentro do contexto da gestão de memória, um objeto é dito referenciar outro objeto, se o primeiro tiver acesso ao segundo ( quer implicitamente quer explicitamente ). Por exemplo, um objeto JavaScript tem uma referência ao seu protótipo ( referência implícita )  e aos valores das suas propriedades ( referência explícita ).

+ +

Neste contexto, a noção de "objeto" é expandida a algo mais abrangente que um objeto JavaScript e também contém âmbitos de funções ( ou âmbito léxico global ).

+ +

Contagem de referências na coleção de lixo

+ +

Este é o algoritmo mais simples da coleção de lixo. Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto já não é referenciado por nenhum outro objeto". Um objeto é considerado coletável para a coleção de lixo se tiver nenhuma referenciação por parte de outro objeto.

+ +

Exemplo

+ +
var o = {
+  a: {
+    b: 2
+  }
+};
+// 2 objetos criados. Um é referenciado por outro como sendo suas propriedades
+// O outro é referenciado por virtude ao ser assignado para a variável 'o'
+// Obviamente, nenhum podem ser coletado pela coleção de lixo
+
+
+var o2 = o; // A variável 'o2' é a segunda coisa que
+            // tem uma referência ao objeto
+o = 1;      // agora, o objeto que era originalmente o 'o' tem uma referência única
+            // corporificada pela variável 'o2'
+
+var oa = o2.a; // referência à propriedade 'a' do objeto.
+               // Este objeto tem agora 2 referências: uma como propriedade,
+               // a outra como variável 'oa'
+
+o2 = 'yo'; // O objeto que era o original 'o' tem agora zero
+           // referências a si próprio. Pode ser coletado para a coleção de lixo
+           // No entanto, a propriedade 'a' ainda é referenciada pela
+           // variável 'oa', logo não pode ser libertado
+
+oa = null; // A propriedade 'a' do objeto original 'o'
+           // tem zero referências a si próprio. Pode ser coletado para a  coleção de lixo.
+
+ +

Limitação: ciclos

+ +

Existe uma limitação no que se refere aos ciclos. No exemplo seguinte, dois objetos são criados e referenciam-se mutuamente, criando um ciclo. Estes sairão do âmbito depois de uma chamada a uma função e como tal, são efetivamente inúteis e podem ser libertados. No entanto, o algoritmo de contagem de referências considera que os dois objetos têm pelo menos uma referenciação; nenhum pode ser coletado para a coleção de lixo .

+ +
function f() {
+  var o = {};
+  var o2 = {};
+  o.a = o2; // o referencia o2
+  o2.a = o; // o2 referencia o
+
+  return 'azerty';
+}
+
+f();
+
+ +

Exemplo de aplicação real

+ +

O Internet Explorer 6 e 7 são conhecidos por terem um coletor de contagem de referenciações de coleções de lixo para os objetos DOM. Os ciclos são um erro comum que podem gerar percas de memória:

+ +
var div;
+window.onload = function() {
+  div = document.getElementById('myDivElement');
+  div.circularReference = div;
+  div.lotsOfData = new Array(10000).join('*');
+};
+
+ +

No exemplo acima, o elemento DOM "myDivElement" tem uma referência circular a si próprio na propriedade "circularReference". Se a propriedade não for explicitamente removida ou anulada, o coletor de contagem de referências da coleção de lixo, irá sempre ter uma referenciação intacta e irá manter o elemento DOM na memória mesmo quando for removido da árvore DOM. Se o elemento DOM contém bastante dados ( ilustrado no exemplo acima com a propriedade "lotsOfData" ), a memória consumida por estes dados nunca será libertada.

+ +

Algoritmo de marcação e limpeza

+ +

Este algoritmo reduz a definição de "um objeto já não é necessário" para "um objeto é inalcançável".

+ +

Este algoritmo assume o conhecimento de um conjunto de objetos chamados "roots" ( em JavaScript, a root - raiz - é um objeto global ). Periodicamente, a coleção de lixo começará pela raíz e procurará todos os objetos que são referenciados a partir desta; depois todos os que são referenciados a partir dos seguintes, etc.. Começando pela raiz, o coletor de lixo irá localizar objetos inalcançáveis; coletando-os.

+ +

Este algoritmo é melhor do que o anterior dado que "um objeto tem zero referenciações" leva a um objeto inalcançável. O contrário não é verdade como vimos nos ciclos.

+ +

Desde 2012, todos os modernos navegadores de Internet contêm um coletor de marcação e limpeza. Todos os melhoramentos feitos na área da coleção de lixo no JavaScript ( generalização / incrementação / concorrência / coleção de lixo paralela ) nos últimos anos são implemetações de melhoramento deste algoritmo, mas não melhoramentos do algoritmo de coleção de lixo em si nem a sua redução à definição de que quando "um objeto já não é necessário".

+ +

Os ciclos já não são um problema.

+ +

No primeiro exemplo acima, depois do retorno da chamada à função, 2 objetos já não são referenciados por algo alcançável no objeto global. Consequentemente, irão ser localizados pelo coletor da coleção de lixo.

+ +

Limitações: os objetos necessitam de ser explicitamente inalcançáveis

+ +

Apesar disto estar marcado como uma limitação, é um caso que raramente ocorre na prática pelo que é por isto que ninguém se preocupa muito com a coleção de lixo.

+ +

Ver também

+ + diff --git "a/files/pt-pt/web/javascript/o_que_\303\251_o_javascript/index.html" "b/files/pt-pt/web/javascript/o_que_\303\251_o_javascript/index.html" deleted file mode 100644 index 4145f9dc58..0000000000 --- "a/files/pt-pt/web/javascript/o_que_\303\251_o_javascript/index.html" +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: O que é o JavaScript -slug: Web/JavaScript/O_que_é_o_JavaScript ---- -

O JavaScript é uma linguagem de programação do lado cliente, ou seja, é processada pelo próprio navegador. -Com o JavaScript podemos criar efeitos especiais para nossas páginas na Web, além -de podermos proporcionar uma maior interatividade com nossos usuários. -O JavaScript é uma linguagem orientada a objetos, ou seja, ela trata todos os elementos da página -como objetos distintos, fascilitando a tarefa da programação. -

Resumindo, o JavaScript é uma poderosa linguagem que deve ser dominada por quem deseja criar páginas Web dinamicas e interativas. -


---rafael.marcondes92@gmail.com 12:39, 14 Julho 2008 (PDT) -

diff --git a/files/pt-pt/web/javascript/reference/about/index.html b/files/pt-pt/web/javascript/reference/about/index.html new file mode 100644 index 0000000000..3b2a79ac32 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/about/index.html @@ -0,0 +1,52 @@ +--- +title: Sobre a referência de JavaScript +slug: Web/JavaScript/Reference/Sobre +tags: + - JavaScript +translation_of: Web/JavaScript/Reference/About +--- +
{{JsSidebar}}
+ +

The JavaScript reference serves as a repository of facts about the JavaScript language. The entire language is described here in detail. As you write JavaScript code, you'll refer to these pages often (thus the title "JavaScript reference"). If you're learning JavaScript, or need help understanding some of its capabilities or features, check out the JavaScript guide.

+ +

The JavaScript language is intended to be used within some larger environment, be it a browser, server-side scripts, or similar. For the most part, this reference attempts to be environment-agnostic and does not target a web browser environment.

+ +

Onde encontrar informação sobre JavaScript

+ +

JavaScript documentation of core language features (pure ECMAScript, for the most part) includes the following:

+ + + +

If you are new to JavaScript, start with the guide. Once you have a firm grasp of the fundamentals, you can use the reference to get more details on individual objects and language constructs.

+ +

Estrutura da referência

+ +

In the JavaScript reference you can find the following chapters:

+ +
+
Standard built-in objects
+
This chapter documents all the JavaScript standard built-in objects, along with their methods and properties.
+
Statements and declarations
+
JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.
+
Expressions and operators
+
This chapter documents all the JavaScript language operators, expressions and keywords.
+
Functions
+
Chapter about JavaScript functions.
+
Classes
+
Chapter about JavaScript classes introduced in ECMAScript 6.
+
Errors
+
Chapter about specific errors, exceptions and warnings thrown by JavaScript.
+
New in JavaScript
+
Chapter about JavaScript version history.
+
+ +

Mais páginas de referência

+ + diff --git a/files/pt-pt/web/javascript/reference/deprecated_and_obsolete_features/index.html b/files/pt-pt/web/javascript/reference/deprecated_and_obsolete_features/index.html new file mode 100644 index 0000000000..9d0ae63c62 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/deprecated_and_obsolete_features/index.html @@ -0,0 +1,289 @@ +--- +title: Funcionalidades obsoletas +slug: Web/JavaScript/Reference/Funcionalidades_obsoletas +tags: + - JavaScript + - Obsoleto +translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features +--- +
{{JsSidebar("More")}}
+ +

Esta página lista as funcionalidades de JavaScript que estão obsoletas (ou seja, ainda disponíveis, mas planeadas para remoção) e obsoletas (isto é, não são mais utilizáveis).

+ +

Funcionalidades obsoletas

+ +

Estas funcionalidades obsoletas ainda podem ser utilziadas, mas devem ser utilizadas ​​com cuidado, pois espera-se que estas sejam removidas inteiramente no futuro. Deverá trabalhar para remover a utilização das mesmas do seu código..

+ +

Propriedades de RegExp

+ +

The following properties are deprecated. This does not affect their use in {{jsxref("String.replace", "replacement strings", "", 1)}}:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropriedadesDescrição
{{jsxref("RegExp.n", "$1-$9")}} +

Parenthesized substring matches, if any.
+ Warning: Using these properties can result in problems, since browser extensions can modify them. Avoid them!

+
{{jsxref("RegExp.input", "$_")}}See input.
{{jsxref("RegExp.multiline", "$*")}}See multiline.
{{jsxref("RegExp.lastMatch", "$&")}}See lastMatch.
{{jsxref("RegExp.lastParen", "$+")}}See lastParen.
{{jsxref("RegExp.leftContext", "$`")}}See leftContext.
{{jsxref("RegExp.rightContext", "$'")}}See rightContext.
{{jsxref("RegExp.input", "input")}}The string against which a regular expression is matched.
{{jsxref("RegExp.lastMatch", "lastMatch")}}The last matched characters.
{{jsxref("RegExp.lastParen", "lastParen")}}The last parenthesized substring match, if any.
{{jsxref("RegExp.leftContext", "leftContext")}}The substring preceding the most recent match.
{{jsxref("RegExp.rightContext", "rightContext")}}The substring following the most recent match.
+ +

The following are now properties of RegExp instances, no longer of the RegExp object:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropriedadesDescrição
{{jsxref("RegExp.global", "global")}}Whether or not to test the regular expression against all possible matches in a string, or only against the first.
{{jsxref("RegExp.ignoreCase", "ignoreCase")}}Whether or not to ignore case while attempting a match in a string.
{{jsxref("RegExp.lastIndex", "lastIndex")}}The index at which to start the next match.
{{jsxref("RegExp.multiline", "multiline")}}Whether or not to search in strings across multiple lines.
{{jsxref("RegExp.source", "source")}}The text of the pattern.
+ +

Métodos de egExp

+ + + +

Propriedades de Function

+ + + +

Gerador de Legacy

+ + + +

Iterator

+ + + +

Métodos de Object

+ + + +

Métodos de Date

+ + + +

Functions

+ + + +

Proxy

+ + + +

Sequências de Escape

+ + + +

Métodos de String

+ + + +

Funcionalidades removidas

+ +

Estas funcionalidades obsoletas foram totalmente removidas do JavaScript e não podem mais ser utilizadas a partir da versão indicada do JavaScript.

+ +

Object

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PropertyDescription
{{jsxref("Global_Objects/Object/count", "__count__")}}Returns the number of enumerable properties directly on a user-defined object.
{{jsxref("Global_Objects/Object/Parent", "__parent__")}}Points to an object's context.
{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}Evaluates a string of JavaScript code in the context of the specified object.
{{jsxref("Object.observe()")}}Asynchronously observing the changes to an object.
{{jsxref("Object.unobserve()")}}Remove observers.
{{jsxref("Object.getNotifier()")}}Creates an object that allows to synthetically trigger a change.
+ +

Function

+ + + + + + + + + + + + +
PropertyDescription
{{jsxref("Global_Objects/Function/arity", "arity")}}Number of formal arguments.
+ +

Array

+ + + + + + + + + + + + + + + + +
PropertyDescription
{{jsxref("Array.observe()")}}Asynchronously observing changes to Arrays.
{{jsxref("Array.unobserve()")}}Remove observers.
+ +

Number

+ + + +

ParallelArray

+ + + +

Statements

+ + + +

E4X

+ +

See E4X for more information.

+ +

Variáveis Sharp

+ +

Consulte Sharp variables in JavaScript para mais informação.

diff --git "a/files/pt-pt/web/javascript/reference/errors/declara\303\247\303\243o_fun\303\247\303\243o_sem_nome/index.html" "b/files/pt-pt/web/javascript/reference/errors/declara\303\247\303\243o_fun\303\247\303\243o_sem_nome/index.html" deleted file mode 100644 index a747257379..0000000000 --- "a/files/pt-pt/web/javascript/reference/errors/declara\303\247\303\243o_fun\303\247\303\243o_sem_nome/index.html" +++ /dev/null @@ -1,113 +0,0 @@ ---- -title: 'Erro de sintaxe: declaração de função precisa de um nome' -slug: Web/JavaScript/Reference/Errors/declaração_função_sem_nome -translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement ---- -
{{jsSidebar("Errors")}}
- -

Mensagem

- -
Syntax Error: Expected identifier (Edge)
-SyntaxError: function statement requires a name [Firefox]
-SyntaxError: Unexpected token ( [Chrome]
-
- -

Tipo de erro

- -

{{jsxref("SyntaxError")}}

- -

O que correu mal?

- -

Existe uma declaração de função no código que precisa de um nome. Você deve verficiar como as funções são definidas e se é necessário indicar um nome para a função

- -

Existe uma declaração de função no código que requer um nome. Você precisará verificar como as funções são definidas e se você precisa fornecer um nome para a função, ou 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 esta colocado corretamente neste contexto.

- -

Exemplos

- -

Declarações vs Expressões

- -

Uma declaração de função precisa de um nome, o código seguinte não funciona:

- -
function () {
-  return 'Hello world';
-}
-// SyntaxError: function statement requires a name
-
- -

É possível usar uma expressão de função (atribuição) como alternativa:

- -
var greet = function() {
-  return 'Hello world';
-};
- -

Ou, a sua função é talvez destinada a ser uma IIFE (Expressão de Função Invocada Imediatamente), que é uma função que é executada assim que é definida. Serão precisos mais alguns parêntises neste caso:

- -
(function () {
-
-})();
- -

Funções com nome

- -

Se você está a usar uma função com identificador, ainda precisará fornecer um nome de função após a palavra-chave da função. O código seguinte não funciona:

- -
function Greeter() {
-  german: function () {
-    return "Moin";
-  }
-}
-// SyntaxError: function statement requires a name
-
- -

O código seguinte irá funcionar por exemplo:

- -
function Greeter() {
-  german: function g() {
-    return "Moin";
-  }
-}
- -

Métodos de objectos

- -

Se você pretendia criar um método de um objeto, você precisará criar um objeto. A sintaxe a seguir sem um nome após a palavra-chave function é válida.

- -
var greeter = {
-  german: function () {
-    return "Moin";
-  }
-};
- -

Sintaxe de Callback

- -

Além disso, verifique a sintaxe ao usar callbacks. Parêntisis e virgurlas podem facilmente se tornar complicados.

- -
promise.then(
-  function() {
-    console.log("success");
-  });
-  function() {
-    console.log("error");
-}
-// SyntaxError: function statement requires a name
-
- -

:

- -
promise.then(
-  function() {
-    console.log("success");
-  },
-  function() {
-    console.log("error");
-  }
-);
-
- -

Veja também

- - diff --git a/files/pt-pt/web/javascript/reference/errors/unnamed_function_statement/index.html b/files/pt-pt/web/javascript/reference/errors/unnamed_function_statement/index.html new file mode 100644 index 0000000000..a747257379 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/errors/unnamed_function_statement/index.html @@ -0,0 +1,113 @@ +--- +title: 'Erro de sintaxe: declaração de função precisa de um nome' +slug: Web/JavaScript/Reference/Errors/declaração_função_sem_nome +translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement +--- +
{{jsSidebar("Errors")}}
+ +

Mensagem

+ +
Syntax Error: Expected identifier (Edge)
+SyntaxError: function statement requires a name [Firefox]
+SyntaxError: Unexpected token ( [Chrome]
+
+ +

Tipo de erro

+ +

{{jsxref("SyntaxError")}}

+ +

O que correu mal?

+ +

Existe uma declaração de função no código que precisa de um nome. Você deve verficiar como as funções são definidas e se é necessário indicar um nome para a função

+ +

Existe uma declaração de função no código que requer um nome. Você precisará verificar como as funções são definidas e se você precisa fornecer um nome para a função, ou 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 esta colocado corretamente neste contexto.

+ +

Exemplos

+ +

Declarações vs Expressões

+ +

Uma declaração de função precisa de um nome, o código seguinte não funciona:

+ +
function () {
+  return 'Hello world';
+}
+// SyntaxError: function statement requires a name
+
+ +

É possível usar uma expressão de função (atribuição) como alternativa:

+ +
var greet = function() {
+  return 'Hello world';
+};
+ +

Ou, a sua função é talvez destinada a ser uma IIFE (Expressão de Função Invocada Imediatamente), que é uma função que é executada assim que é definida. Serão precisos mais alguns parêntises neste caso:

+ +
(function () {
+
+})();
+ +

Funções com nome

+ +

Se você está a usar uma função com identificador, ainda precisará fornecer um nome de função após a palavra-chave da função. O código seguinte não funciona:

+ +
function Greeter() {
+  german: function () {
+    return "Moin";
+  }
+}
+// SyntaxError: function statement requires a name
+
+ +

O código seguinte irá funcionar por exemplo:

+ +
function Greeter() {
+  german: function g() {
+    return "Moin";
+  }
+}
+ +

Métodos de objectos

+ +

Se você pretendia criar um método de um objeto, você precisará criar um objeto. A sintaxe a seguir sem um nome após a palavra-chave function é válida.

+ +
var greeter = {
+  german: function () {
+    return "Moin";
+  }
+};
+ +

Sintaxe de Callback

+ +

Além disso, verifique a sintaxe ao usar callbacks. Parêntisis e virgurlas podem facilmente se tornar complicados.

+ +
promise.then(
+  function() {
+    console.log("success");
+  });
+  function() {
+    console.log("error");
+}
+// SyntaxError: function statement requires a name
+
+ +

:

+ +
promise.then(
+  function() {
+    console.log("success");
+  },
+  function() {
+    console.log("error");
+  }
+);
+
+ +

Veja também

+ + diff --git "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/bloco/index.html" "b/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/bloco/index.html" deleted file mode 100644 index a3104dbeae..0000000000 --- "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/bloco/index.html" +++ /dev/null @@ -1,116 +0,0 @@ ---- -title: Bloco (block) -slug: Web/JavaScript/Reference/Extratos_e_declarações/bloco -tags: - - Declaração - - Funcionalidade de Linguagem - - JavaScript - - Referencia -translation_of: Web/JavaScript/Reference/Statements/block ---- -
Bloco {{jsSidebar("Statements")}}
- -

Uma declaralção bloco (ou declaração composto em outras linguagens) é utilizada para agrupar zero ou mais declarações. O bloco é delimitado por um par de chavetas (“chavetas { }”) e opcionalmente poderá ser {{jsxref("Statements/label", "labelled", "", 1)}}:

- -
{{EmbedInteractiveExample("pages/js/statement-block.html", "taller")}}
- - - -

Sintaxe

- -

Declaração de Bloco

- -
{
-  StatementList
-}
-
- -

Declaração de Bloco Etiquetado

- -
LabelIdentifier: {
-  StatementList
-}
-
- -
-
StatementList
-
Statements grouped within the block statement.
-
LabelIdentifier
-
An optional {{jsxref("Statements/label", "label", "", 1)}} for visual identification or as a target for {{jsxref("Statements/break", "break")}}.
-
- -

Descrição

- -

The block statement is often called compound statement in other languages. It allows you to use multiple statements where JavaScript expects only one statement. Combining statements into blocks is a common practice in JavaScript. The opposite behavior is possible using an empty statement, where you provide no statement, although one is required.

- -

Blocks are commonly used in association with {{jsxref("Statements/if...else", "if...else")}} and {{jsxref("Statements/for", "for")}} statements.

- -

Block Scoping Rules

- -

With var or function declaration in non-strict mode

- -

Variables declared with var or created by function declarations in non-strict mode do not have block scope. Variables introduced within a block are scoped to the containing function or script, and the effects of setting them persist beyond the block itself. In other words, block statements do not introduce a scope. For example:

- -
var x = 1;
-{
-  var x = 2;
-}
-console.log(x); // logs 2
-
- -

This logs 2 because the var x statement within the block is in the same scope as the var x statement before the block.

- -

In non-strict code, function declarations inside blocks behave strangely. Do not use them.

- -

With let, const or function declaration in strict mode

- -

By contrast, identifiers declared with {{jsxref("Statements/let", "let")}} and {{jsxref("Statements/const", "const")}} do have block scope:

- -
let x = 1;
-{
-  let x = 2;
-}
-console.log(x); // logs 1
- -

The x = 2 is limited in scope to the block in which it was defined.

- -

The same is true of const:

- -
const c = 1;
-{
-  const c = 2;
-}
-console.log(c); // logs 1 and does not throw SyntaxError...
- -

Note that the block-scoped const c = 2 does not throw a SyntaxError: Identifier 'c' has already been declared because it can be declared uniquely within the block.

- -

In strict mode, starting with ES2015, functions inside blocks are scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.

- -

Especificações

- - - - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-block', 'Block statement')}}
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.statements.block")}}

- -

Consulte também

- - diff --git "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/for/index.html" "b/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/for/index.html" deleted file mode 100644 index ac7586e98b..0000000000 --- "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/for/index.html" +++ /dev/null @@ -1,145 +0,0 @@ ---- -title: for -slug: Web/JavaScript/Reference/Extratos_e_declarações/for -tags: - - Declaração - - Funcionalidade de Linguagem - - JavaScript - - Loop - - Referencia - - Repetição - - for -translation_of: Web/JavaScript/Reference/Statements/for ---- -
{{jsSidebar("Statements")}}
- -

A declaração "for" cria uma repetição (loop) que consiste de três expressões opcionais, entre parênteses e separados por ponto e vírgula, seguido de uma declaração (normalmente bdeclaraçãod e bloco (block)) para ser executada na repetição.

- -
{{EmbedInteractiveExample("pages/js/statement-for.html")}}
- - - -

Sintaxe

- -
for ([initialization]; [condition]; [final-expression])
-   statement
- -
-
initialization
-
An expression (including assignment expressions) or variable declaration evaluated once before the loop begins. Typically used to initialize a counter variable. This expression may optionally declare new variables with var or let keywords. Variables declared with var are not local to the loop, i.e. they are in the same scope the for loop is in. Variables declared with let are local to the statement.
-
The result of this expression is discarded.
-
condition
-
An expression to be evaluated before each loop iteration. If this expression evaluates to true, statement is executed. This conditional test is optional. If omitted, the condition always evaluates to true. If the expression evaluates to false, execution skips to the first expression following the for construct.
-
final-expression
-
An expression to be evaluated at the end of each loop iteration. This occurs before the next evaluation of condition. Generally used to update or increment the counter variable.
-
statement
-
A statement that is executed as long as the condition evaluates to true. To execute multiple statements within the loop, use a {{jsxref("Statements/block", "block", "", 0)}} statement ({ ... }) to group those statements. To execute no statement within the loop, use an {{jsxref("Statements/empty", "empty", "", 0)}} statement (;).
-
- -

Exemplos

- -

Using for

- -

The following for statement starts by declaring the variable i and initializing it to 0. It checks that i is less than nine, performs the two succeeding statements, and increments i by 1 after each pass through the loop.

- -
for (let i = 0; i < 9; i++) {
-   console.log(i);
-   // more statements
-}
-
- -

Optional for expressions

- -

All three expressions in the head of the for loop are optional.

- -

For example, in the initialization block it is not required to initialize variables:

- -
var i = 0;
-for (; i < 9; i++) {
-    console.log(i);
-    // more statements
-}
-
- -

Like the initialization block, the condition block is also optional. If you are omitting this expression, you must make sure to break the loop in the body in order to not create an infinite loop.

- -
for (let i = 0;; i++) {
-   console.log(i);
-   if (i > 3) break;
-   // more statements
-}
- -

You can also omit all three blocks. Again, make sure to use a {{jsxref("Statements/break", "break")}} statement to end the loop and also modify (increase) a variable, so that the condition for the break statement is true at some point.

- -
var i = 0;
-
-for (;;) {
-  if (i > 3) break;
-  console.log(i);
-  i++;
-}
-
- -

Using for without a statement

- -

The following for cycle calculates the offset position of a node in the final-expression section, and therefore it does not require the use of a statement section, a semicolon is used instead.

- -
function showOffsetPos(sId) {
-
-  var nLeft = 0, nTop = 0;
-
-  for (
-
-    var oItNode = document.getElementById(sId); /* initialization */
-
-    oItNode; /* condition */
-
-    nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent /* final-expression */
-
-  ); /* semicolon */
-
-  console.log('Offset position of \'' + sId + '\' element:\n left: ' + nLeft + 'px;\n top: ' + nTop + 'px;');
-
-}
-
-/* Example call: */
-
-showOffsetPos('content');
-
-// Output:
-// "Offset position of "content" element:
-// left: 0px;
-// top: 153px;"
- -
Note: This is one of the few cases in JavaScript where the semicolon is mandatory. Indeed, without the semicolon the line that follows the cycle declaration will be considered a statement.
- -

Especificações

- - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-for-statement', 'for statement')}}
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.statements.for")}}

- -

Consulte também

- - diff --git "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/index.html" "b/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/index.html" deleted file mode 100644 index af841906a1..0000000000 --- "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/index.html" +++ /dev/null @@ -1,150 +0,0 @@ ---- -title: Declarações e instruções -slug: Web/JavaScript/Reference/Extratos_e_declarações -tags: - - JavaScript - - Referencia - - declarações - - instruções -translation_of: Web/JavaScript/Reference/Statements ---- -
{{jsSidebar("Statements")}}
- -

JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.

- -

Declarações e instruções por categoria

- -

For an alphabetical listing see the sidebar on the left.

- -

Controlo de Fluxo

- -
-
{{jsxref("Statements/block", "Block")}}
-
A block statement is used to group zero or more statements. The block is delimited by a pair of curly brackets.
-
{{jsxref("Statements/break", "break")}}
-
Terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.
-
{{jsxref("Statements/continue", "continue")}}
-
Terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.
-
{{jsxref("Statements/Empty", "Empty")}}
-
An empty statement is used to provide no statement, although the JavaScript syntax would expect one.
-
{{jsxref("Statements/if...else", "if...else")}}
-
Executes a statement if a specified condition is true. If the condition is false, another statement can be executed.
-
{{jsxref("Statements/switch", "switch")}}
-
Evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case.
-
{{jsxref("Statements/throw", "throw")}}
-
Throws a user-defined exception.
-
{{jsxref("Statements/try...catch", "try...catch")}}
-
Marks a block of statements to try, and specifies a response, should an exception be thrown.
-
- -

Declarações

- -
-
{{jsxref("Statements/var", "var")}}
-
Declares a variable, optionally initializing it to a value.
-
{{jsxref("Statements/let", "let")}}
-
Declares a block scope local variable, optionally initializing it to a value.
-
{{jsxref("Statements/const", "const")}}
-
Declares a read-only named constant.
-
- -

Funções e classes

- -
-
{{jsxref("Statements/function", "function")}}
-
Declara as funções com parâmetros especificados.
-
{{jsxref("Statements/function*", "function*")}}
-
Generators functions enable writing iterators more easily.
-
{{jsxref("Statements/async_function", "async function")}}
-
Declares an async function with the specified parameters.
-
{{jsxref("Statements/return", "return")}}
-
Specifies the value to be returned by a function.
-
{{jsxref("Statements/class", "class")}}
-
Declara uma Classe.
-
- -

Iterações

- -
-
{{jsxref("Statements/do...while", "do...while")}}
-
Creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.
-
{{jsxref("Statements/for", "for")}}
-
Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.
-
{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}
-
Iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.
-
{{jsxref("Statements/for...in", "for...in")}}
-
Iterates over the enumerable properties of an object, in arbitrary order. For each distinct property, statements can be executed.
-
{{jsxref("Statements/for...of", "for...of")}}
-
Iterates over iterable objects (including {{jsxref("Global_Objects/Array","arrays","","true")}}, array-like objects, iterators and generators), invoking a custom iteration hook with statements to be executed for the value of each distinct property.
-
{{jsxref("Statements/while", "while")}}
-
Creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.
-
- -

Outros

- -
-
{{jsxref("Statements/debugger", "debugger")}}
-
Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.
-
{{jsxref("Statements/export", "export")}}
-
Used to export functions to make them available for imports in external modules, another scripts.
-
{{jsxref("Statements/import", "import")}}
-
Used to import functions exported from an external module, another script.
-
import.meta
-
A meta-property exposing context-specific metadata to a JavaScript module.
-
{{jsxref("Statements/label", "label")}}
-
Provides a statement with an identifier that you can refer to using a break or continue statement.
-
- -
-
{{deprecated_inline}} {{jsxref("Statements/with", "with")}}
-
Extends the scope chain for a statement.
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES1', '#sec-12', 'Statements')}}{{Spec2('ES1')}}Initial definition
{{SpecName('ES3', '#sec-12', 'Statements')}}{{Spec2('ES3')}} 
{{SpecName('ES5.1', '#sec-12', 'Statements')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ES6')}}New: function*, let, for...of, yield, class
{{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.statements")}}

- -

Consultar também

- - diff --git "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/return/index.html" "b/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/return/index.html" deleted file mode 100644 index 6cec134992..0000000000 --- "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/return/index.html" +++ /dev/null @@ -1,148 +0,0 @@ ---- -title: return -slug: Web/JavaScript/Reference/Extratos_e_declarações/return -tags: - - Declaração - - JavaScript -translation_of: Web/JavaScript/Reference/Statements/return ---- -
{{jsSidebar("Statements")}}
- -

The return statement ends function execution and specifies a value to be returned to the function caller.

- -

Sintaxe

- -
return [[expression]];
- -
-
expression
-
The expression whose value is to be returned. If omitted, undefined is returned instead.
-
- -

Descrição

- -

When a return statement is used in a function body, the execution of the function is stopped. If specified, a given value is returned to the function caller. For example, the following function returns the square of its argument, x, where x is a number.

- -
function square(x) {
-   return x * x;
-}
-var demo = square(3);
-// demo will equal 9
-
- -

If the value is omitted, undefined is returned instead.

- -

The following return statements all break the function execution:

- -
return;
-return true;
-return false;
-return x;
-return x + y / 3;
-
- -

Inserção Automática de Ponto e Vírgula

- -

The return statement is affected by automatic semicolon insertion (ASI). No line terminator is allowed between the return keyword and the expression.

- -
return
-a + b;
-
- -

is transformed by ASI into:

- -
return;
-a + b;
-
- -

The console will warn "unreachable code after return statement".

- -
Starting with Gecko 40 {{geckoRelease(40)}}, a warning is shown in the console if unreachable code is found after a return statement.
- -

Exemplos

- -

Interromper uma função

- -

A function immediately stops at the point where return is called.

- -
function counter() {
-  for (var count = 1; ; count++) {  // infinite loop
-    console.log(count + 'A'); // until 5
-      if (count === 5) {
-        return;
-      }
-      console.log(count + 'B');  // until 4
-    }
-  console.log(count + 'C');  // never appears
-}
-
-counter();
-
-// Output:
-// 1A
-// 1B
-// 2A
-// 2B
-// 3A
-// 3B
-// 4A
-// 4B
-// 5A
-
- -

Devolver uma função

- -

See also the article about Closures.

- -
function magic(x) {
-  return function calc(x) { return x * 42; };
-}
-
-var answer = magic();
-answer(1337); // 56154
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.statements.return")}}

- -

Consulte também

- - diff --git "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/throw/index.html" "b/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/throw/index.html" deleted file mode 100644 index 9e7a8bf54e..0000000000 --- "a/files/pt-pt/web/javascript/reference/extratos_e_declara\303\247\303\265es/throw/index.html" +++ /dev/null @@ -1,271 +0,0 @@ ---- -title: throw -slug: Web/JavaScript/Reference/Extratos_e_declarações/throw -tags: - - Comando - - Declaração - - JavaScript -translation_of: Web/JavaScript/Reference/Statements/throw ---- -
{{jsSidebar("Statements")}}
- -

A declaração throw lança uma exeção definida pelo utilizador. A execução da função atual irá parar (os comandos depois de throw não serão executados), e o controle será passado para o primeiro bloco catch no conjunto de chamadas. Se não existir nenhum bloco catch entre as funções de caller, o programa irá terminar.

- -

Sintaxe

- -
expressão throw;
- -
-
expressão
-
A expressão para throw.
-
- -

Descrição

- -

Use the throw statement to throw an exception. When you throw an exception, expression specifies the value of the exception. Each of the following throws an exception:

- -
throw 'Error2'; // generates an exception with a string value
-throw 42;       // generates an exception with the value 42
-throw true;     // generates an exception with the value true
- -

Also note that the throw statement is affected by automatic semicolon insertion (ASI) as no line terminator between the throw keyword and the expression is allowed.

- -

Exemplos

- -

Throw um objeto

- -

You can specify an object when you throw an exception. You can then reference the object's properties in the catch block. The following example creates an object of type UserException and uses it in a throw statement.

- -
function UserException(message) {
-   this.message = message;
-   this.name = 'UserException';
-}
-function getMonthName(mo) {
-   mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)
-   var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
-      'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-   if (months[mo] !== undefined) {
-      return months[mo];
-   } else {
-      throw new UserException('InvalidMonthNo');
-   }
-}
-
-try {
-   // statements to try
-   var myMonth = 15; // 15 is out of bound to raise the exception
-   var monthName = getMonthName(myMonth);
-} catch (e) {
-   monthName = 'unknown';
-   console.log(e.message, e.name); // pass exception object to err handler
-}
-
- -

Outro exemplo de throwing um objeto

- -

The following example tests an input string for a U.S. zip code. If the zip code uses an invalid format, the throw statement throws an exception by creating an object of type ZipCodeFormatException.

- -
/*
- * Creates a ZipCode object.
- *
- * Accepted formats for a zip code are:
- *    12345
- *    12345-6789
- *    123456789
- *    12345 6789
- *
- * If the argument passed to the ZipCode constructor does not
- * conform to one of these patterns, an exception is thrown.
- */
-
-function ZipCode(zip) {
-   zip = new String(zip);
-   pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
-   if (pattern.test(zip)) {
-      // zip code value will be the first match in the string
-      this.value = zip.match(pattern)[0];
-      this.valueOf = function() {
-         return this.value
-      };
-      this.toString = function() {
-         return String(this.value)
-      };
-   } else {
-      throw new ZipCodeFormatException(zip);
-   }
-}
-
-function ZipCodeFormatException(value) {
-   this.value = value;
-   this.message = 'does not conform to the expected format for a zip code';
-   this.toString = function() {
-      return this.value + this.message;
-   };
-}
-
-/*
- * This could be in a script that validates address data
- * for US addresses.
- */
-
-const ZIPCODE_INVALID = -1;
-const ZIPCODE_UNKNOWN_ERROR = -2;
-
-function verifyZipCode(z) {
-   try {
-      z = new ZipCode(z);
-   } catch (e) {
-      if (e instanceof ZipCodeFormatException) {
-         return ZIPCODE_INVALID;
-      } else {
-         return ZIPCODE_UNKNOWN_ERROR;
-      }
-   }
-   return z;
-}
-
-a = verifyZipCode(95060);         // returns 95060
-b = verifyZipCode(9560);          // returns -1
-c = verifyZipCode('a');           // returns -1
-d = verifyZipCode('95060');       // returns 95060
-e = verifyZipCode('95060 1234');  // returns 95060 1234
-
- -

Rethrow uma exceção

- -

You can use throw to rethrow an exception after you catch it. The following example catches an exception with a numeric value and rethrows it if the value is over 50. The rethrown exception propagates up to the enclosing function or to the top level so that the user sees it.

- -
try {
-   throw n; // throws an exception with a numeric value
-} catch (e) {
-   if (e <= 50) {
-      // statements to handle exceptions 1-50
-   } else {
-      // cannot handle this exception, so rethrow
-      throw e;
-   }
-}
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.statements.throw")}}

- -

Consulte também

- - - -
- - - - - -
diff --git a/files/pt-pt/web/javascript/reference/funcionalidades_obsoletas/index.html b/files/pt-pt/web/javascript/reference/funcionalidades_obsoletas/index.html deleted file mode 100644 index 9d0ae63c62..0000000000 --- a/files/pt-pt/web/javascript/reference/funcionalidades_obsoletas/index.html +++ /dev/null @@ -1,289 +0,0 @@ ---- -title: Funcionalidades obsoletas -slug: Web/JavaScript/Reference/Funcionalidades_obsoletas -tags: - - JavaScript - - Obsoleto -translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features ---- -
{{JsSidebar("More")}}
- -

Esta página lista as funcionalidades de JavaScript que estão obsoletas (ou seja, ainda disponíveis, mas planeadas para remoção) e obsoletas (isto é, não são mais utilizáveis).

- -

Funcionalidades obsoletas

- -

Estas funcionalidades obsoletas ainda podem ser utilziadas, mas devem ser utilizadas ​​com cuidado, pois espera-se que estas sejam removidas inteiramente no futuro. Deverá trabalhar para remover a utilização das mesmas do seu código..

- -

Propriedades de RegExp

- -

The following properties are deprecated. This does not affect their use in {{jsxref("String.replace", "replacement strings", "", 1)}}:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PropriedadesDescrição
{{jsxref("RegExp.n", "$1-$9")}} -

Parenthesized substring matches, if any.
- Warning: Using these properties can result in problems, since browser extensions can modify them. Avoid them!

-
{{jsxref("RegExp.input", "$_")}}See input.
{{jsxref("RegExp.multiline", "$*")}}See multiline.
{{jsxref("RegExp.lastMatch", "$&")}}See lastMatch.
{{jsxref("RegExp.lastParen", "$+")}}See lastParen.
{{jsxref("RegExp.leftContext", "$`")}}See leftContext.
{{jsxref("RegExp.rightContext", "$'")}}See rightContext.
{{jsxref("RegExp.input", "input")}}The string against which a regular expression is matched.
{{jsxref("RegExp.lastMatch", "lastMatch")}}The last matched characters.
{{jsxref("RegExp.lastParen", "lastParen")}}The last parenthesized substring match, if any.
{{jsxref("RegExp.leftContext", "leftContext")}}The substring preceding the most recent match.
{{jsxref("RegExp.rightContext", "rightContext")}}The substring following the most recent match.
- -

The following are now properties of RegExp instances, no longer of the RegExp object:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PropriedadesDescrição
{{jsxref("RegExp.global", "global")}}Whether or not to test the regular expression against all possible matches in a string, or only against the first.
{{jsxref("RegExp.ignoreCase", "ignoreCase")}}Whether or not to ignore case while attempting a match in a string.
{{jsxref("RegExp.lastIndex", "lastIndex")}}The index at which to start the next match.
{{jsxref("RegExp.multiline", "multiline")}}Whether or not to search in strings across multiple lines.
{{jsxref("RegExp.source", "source")}}The text of the pattern.
- -

Métodos de egExp

- - - -

Propriedades de Function

- - - -

Gerador de Legacy

- - - -

Iterator

- - - -

Métodos de Object

- - - -

Métodos de Date

- - - -

Functions

- - - -

Proxy

- - - -

Sequências de Escape

- - - -

Métodos de String

- - - -

Funcionalidades removidas

- -

Estas funcionalidades obsoletas foram totalmente removidas do JavaScript e não podem mais ser utilizadas a partir da versão indicada do JavaScript.

- -

Object

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PropertyDescription
{{jsxref("Global_Objects/Object/count", "__count__")}}Returns the number of enumerable properties directly on a user-defined object.
{{jsxref("Global_Objects/Object/Parent", "__parent__")}}Points to an object's context.
{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}Evaluates a string of JavaScript code in the context of the specified object.
{{jsxref("Object.observe()")}}Asynchronously observing the changes to an object.
{{jsxref("Object.unobserve()")}}Remove observers.
{{jsxref("Object.getNotifier()")}}Creates an object that allows to synthetically trigger a change.
- -

Function

- - - - - - - - - - - - -
PropertyDescription
{{jsxref("Global_Objects/Function/arity", "arity")}}Number of formal arguments.
- -

Array

- - - - - - - - - - - - - - - - -
PropertyDescription
{{jsxref("Array.observe()")}}Asynchronously observing changes to Arrays.
{{jsxref("Array.unobserve()")}}Remove observers.
- -

Number

- - - -

ParallelArray

- - - -

Statements

- - - -

E4X

- -

See E4X for more information.

- -

Variáveis Sharp

- -

Consulte Sharp variables in JavaScript para mais informação.

diff --git a/files/pt-pt/web/javascript/reference/funcoes/arguments/index.html b/files/pt-pt/web/javascript/reference/funcoes/arguments/index.html deleted file mode 100644 index c7ac84a4b9..0000000000 --- a/files/pt-pt/web/javascript/reference/funcoes/arguments/index.html +++ /dev/null @@ -1,228 +0,0 @@ ---- -title: O objeto arguments -slug: Web/JavaScript/Reference/Funcoes/arguments -tags: - - Class - - Funções - - JavaScript - - Referencia - - arguments -translation_of: Web/JavaScript/Reference/Functions/arguments ---- -

{{JSSidebar("Functions")}}

- -

arguments é um objeto semelhante a uma "Matiz" acessível dentro de functions que contém os valores dos argumentos passados ​​para essa função.

- -
-

Nota: If you're writing ES6 compatible code, then rest parameters should be preferred.

-
- -
-

Nota: “Array-like” means that arguments has a length property and properties indexed from zero, but it doesn't have {{JSxRef("Array")}}'s built-in methods like forEach and map. See §Description for details.

-
- -
{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}
- - - -

Sintaxe

- -
arguments
- -

Descrição

- -

The arguments object is a local variable available within all non-arrow functions. You can refer to a function's arguments inside that function by using its arguments object. It has entries for each argument the function was called with, with the first entry's index at 0.

- -

For example, if a function is passed 3 arguments, you can access them as follows:

- -
arguments[0] // first argument
-arguments[1] // second argument
-arguments[2] // third argument
-
- -

Each argument can also be set or reassigned:

- -
arguments[1] = 'new value';
-
- -

The arguments object is not an {{JSxRef("Array")}}. It is similar, but does not have any Array properties except length. For example, it does not have the pop method. However, it can be converted to a real Array:

- -
var args = Array.prototype.slice.call(arguments);
-// Using an array literal is shorter than above but allocates an empty array
-var args = [].slice.call(arguments);
-
- -

As you can do with any Array-like object, you can use ES2015's {{JSxRef("Array.from()")}} method or spread operator to convert arguments to a real Array:

- -
let args = Array.from(arguments);
-// or
-let args = [...arguments];
- -

The arguments object is useful for functions called with more arguments than they are formally declared to accept. This technique is useful for functions that can be passed a variable number of arguments, such as Math.min(). This example function accepts any number of string arguments and returns the longest one:

- -
function longestString() {
-  var longest = '';
-  for (var i=0; i < arguments.length; i++) {
-    if (arguments[i].length > longest.length) {
-      longest = arguments[i];
-    }
-  }
-  return longest;
-}
-
- -

You can use arguments.length to count how many arguments the function was called with. If you instead want to count how many parameters a function is declared to accept, inspect that function's length property.

- -

Utilizar typeof com Arguments

- -

The typeof operator returns 'object' when used with arguments

- -
console.log(typeof arguments); // 'object'
- -

The type of individual arguments can be determined by indexing arguments:

- -
console.log(typeof arguments[0]); // returns the type of the first argument
- -

Propriedades

- -
-
-
{{jsxref("Functions/arguments/callee", "arguments.callee")}}
-
Reference to the currently executing function that the arguments belong to.
-
{{jsxref("Functions/arguments/length", "arguments.length")}}
-
The number of arguments that were passed to the function.
-
{{jsxref("Functions/arguments/@@iterator", "arguments[@@iterator]")}}
-
Returns a new {{jsxref("Array/@@iterator", "Array iterator", "", 0)}} object that contains the values for each index in arguments.
-
- -

Exemplos

- -

Definir uma function que concatena várias strings

- -

This example defines a function that concatenates several strings. The function's only formal argument is a string containing the characters that separate the items to concatenate.

- -
function myConcat(separator) {
-  var args = Array.prototype.slice.call(arguments, 1);
-  return args.join(separator);
-}
- -

You can pass as many arguments as you like to this function. It returns a string list using each argument in the list:

- -
// returns "red, orange, blue"
-myConcat(', ', 'red', 'orange', 'blue');
-
-// returns "elephant; giraffe; lion; cheetah"
-myConcat('; ', 'elephant', 'giraffe', 'lion', 'cheetah');
-
-// returns "sage. basil. oregano. pepper. parsley"
-myConcat('. ', 'sage', 'basil', 'oregano', 'pepper', 'parsley');
- -

Definir uma function que cria listas HTML

- -

This example defines a function that creates a string containing HTML for a list. The only formal argument for the function is a string that is "u" if the list is to be unordered (bulleted), or "o" if the list is to be ordered (numbered). The function is defined as follows:

- -
function list(type) {
-  var html = '<' + type + 'l><li>';
-  var args = Array.prototype.slice.call(arguments, 1);
-  html += args.join('</li><li>');
-  html += '</li></' + type + 'l>'; // end list
-
-  return html;
-}
- -

You can pass any number of arguments to this function, and it adds each argument as a list item to a list of the type indicated. For example:

- -
var listHTML = list('u', 'One', 'Two', 'Three');
-
-/* listHTML is:
-"<ul><li>One</li><li>Two</li><li>Three</li></ul>"
-*/
- -

Parâmetros Rest, predefinição, e desestruturados

- -

The arguments object can be used in conjunction with rest, default, and destructured parameters.

- -
function foo(...args) {
-  return args;
-}
-foo(1, 2, 3); // [1,2,3]
-
- -

While the presence of rest, default, or destructured parameters does not alter the behavior of the arguments object in strict mode code, there is a subtle difference for non-strict code.

- -

In strict-mode code, the arguments object behaves the same whether or not a function is passed rest, default, or destructured parameters. That is, assigning new values to variables in the body of the function will not affect the arguments object. Nor will assigning new variables to the arguments object affect the value of variables.

- -
-

Nota: You cannot write a "use strict"; directive in the body of a function definition that accepts rest, default, or destructured parameters. Doing so will throw a syntax error.

-
- -

Non-strict functions that are passed only simple parameters (that is, not rest, default, or restructured parameters) will sync the value of variables new values in the body of the function with the arguments object, and vice versa:

- -
function func(a) {
-  arguments[0] = 99; // updating arguments[0] also updates a
-  console.log(a);
-}
-func(10); // 99
-
- -

And also:

- -
function func(a) {
-  a = 99; // updating a also updates arguments[0]
-  console.log(arguments[0]);
-}
-func(10); // 99
-
- -

Conversely, non-strict functions that are passed rest, default, or destructured parameters will not sync new values assigned to argument variables in the function body with the arguments object. Instead, the arguments object in non-strict functions with complex parameters will always reflect the values passed to the function when the function was called (this is the same behavior as exhibited by all strict-mode functions, regardless of the type of variables they are passed):

- -
function func(a = 55) {
-  arguments[0] = 99; // updating arguments[0] does not also update a
-  console.log(a);
-}
-func(10); // 10
- -

E também:

- -
function func(a = 55) {
-  a = 99; // updating a does not also update arguments[0]
-  console.log(arguments[0]);
-}
-func(10); // 10
-
- -

E também:

- -
// An untracked default parameter
-function func(a = 55) {
-  console.log(arguments[0]);
-}
-func(); // undefined
- -

Especificações

- - - - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}
- -

Compatibildiade de navegador

- - - -

{{Compat("javascript.functions.arguments")}}

- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/reference/funcoes/funcoes_seta/index.html b/files/pt-pt/web/javascript/reference/funcoes/funcoes_seta/index.html deleted file mode 100644 index aa7b7b3121..0000000000 --- a/files/pt-pt/web/javascript/reference/funcoes/funcoes_seta/index.html +++ /dev/null @@ -1,399 +0,0 @@ ---- -title: Expressões da função "Seta" -slug: Web/JavaScript/Reference/Funcoes/Funcoes_seta -translation_of: Web/JavaScript/Reference/Functions/Arrow_functions ---- -
{{jsSidebar("Functions")}}
- -

Uma expressão da função seta é uma alternativa sintaticamente compacta a uma expressão de expressão de função regular, embora sem as suas próprias associações às palavras-chave this, arguments, super, ou new.target. As expressões de função (function) de seta são inadequadas como métodos, e não podem ser utilziadas como construtores.

- -
{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}
- -

Sintaxe

- -

Basic syntax

- -
(param1, param2, …, paramN) => { statements }
-(param1, param2, …, paramN) => expression
-// equivalent to: => { return expression; }
-
-// Parentheses are optional when there's only one parameter name:
-(singleParam) => { statements }
-singleParam => { statements }
-
-// The parameter list for a function with no parameters should be written with a pair of parentheses.
-() => { statements }
-
- -

Advanced syntax

- -
// Parenthesize the body of a function to return an object literal expression:
-params => ({foo: bar})
-
-// Rest parameters and default parameters are supported
-(param1, param2, ...rest) => { statements }
-(param1 = defaultValue1, param2, …, paramN = defaultValueN) => {
-statements }
-
-// Destructuring within the parameter list is also supported
-var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
-f(); // 6
-
- -

Descrição

- -

See also "ES6 In Depth: Arrow functions" on hacks.mozilla.org.

- -

Two factors influenced the introduction of arrow functions: the need for shorter functions and the behavior of the this keyword.

- -

Funções curtas

- -
var elements = [
-  'Hydrogen',
-  'Helium',
-  'Lithium',
-  'Beryllium'
-];
-
-// This statement returns the array: [8, 6, 7, 9]
-elements.map(function(element) {
-  return element.length;
-});
-
-// The regular function above can be written as the arrow function below
-elements.map((element) => {
-  return element.length;
-}); // [8, 6, 7, 9]
-
-// When there is only one parameter, we can remove the surrounding parentheses
-elements.map(element => {
-  return element.length;
-}); // [8, 6, 7, 9]
-
-// When the only statement in an arrow function is `return`, we can remove `return` and remove
-// the surrounding curly brackets
-elements.map(element => element.length); // [8, 6, 7, 9]
-
-// In this case, because we only need the length property, we can use destructuring parameter:
-// Notice that the `length` corresponds to the property we want to get whereas the
-// obviously non-special `lengthFooBArX` is just the name of a variable which can be changed
-// to any valid variable name you want
-elements.map(({ length: lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]
-
-// This destructuring parameter assignment can also be written as seen below. However, note that in
-// this example we are not assigning `length` value to the made up property. Instead, the literal name
-// itself of the variable `length` is used as the property we want to retrieve from the object.
-elements.map(({ length }) => length); // [8, 6, 7, 9]
-
- -

No separate this

- -

Before arrow functions, every new function defined its own this value based on how the function was called:

- - - -

This proved to be less than ideal with an object-oriented style of programming.

- -
function Person() {
-  // The Person() constructor defines `this` as an instance of itself.
-  this.age = 0;
-
-  setInterval(function growUp() {
-    // In non-strict mode, the growUp() function defines `this`
-    // as the global object (because it's where growUp() is executed.),
-    // which is different from the `this`
-    // defined by the Person() constructor.
-    this.age++;
-  }, 1000);
-}
-
-var p = new Person();
- -

In ECMAScript 3/5, the this issue was fixable by assigning the value in this to a variable that could be closed over.

- -
function Person() {
-  var that = this;
-  that.age = 0;
-
-  setInterval(function growUp() {
-    // The callback refers to the `that` variable of which
-    // the value is the expected object.
-    that.age++;
-  }, 1000);
-}
- -

Alternatively, a bound function could be created so that a preassigned this value would be passed to the bound target function (the growUp() function in the example above).

- -

An arrow function does not have its own this. The this value of the enclosing lexical scope is used; arrow functions follow the normal variable lookup rules. So while searching for this which is not present in current scope, an arrow function ends up finding the this from its enclosing scope.

- -

Thus, in the following code, the this within the function that is passed to setInterval has the same value as the this in the lexically enclosing function:

- -
function Person(){
-  this.age = 0;
-
-  setInterval(() => {
-    this.age++; // |this| properly refers to the Person object
-  }, 1000);
-}
-
-var p = new Person();
- -

Relation with strict mode

- -

Given that this comes from the surrounding lexical context, strict mode rules with regard to this are ignored.

- -
var f = () => { 'use strict'; return this; };
-f() === window; // or the global object
- -

All other strict mode rules apply normally.

- -

Invoked through call or apply

- -

Since arrow functions do not have their own this, the methods call() and apply() can only pass in parameters. Any this argument is ignored.

- -
var adder = {
-  base: 1,
-
-  add: function(a) {
-    var f = v => v + this.base;
-    return f(a);
-  },
-
-  addThruCall: function(a) {
-    var f = v => v + this.base;
-    var b = {
-      base: 2
-    };
-
-    return f.call(b, a);
-  }
-};
-
-console.log(adder.add(1));         // This would log 2
-console.log(adder.addThruCall(1)); // This would log 2 still
- -

No binding of arguments

- -

Arrow functions do not have their own arguments object. Thus, in this example, arguments is simply a reference to the arguments of the enclosing scope:

- -
var arguments = [1, 2, 3];
-var arr = () => arguments[0];
-
-arr(); // 1
-
-function foo(n) {
-  var f = () => arguments[0] + n; // foo's implicit arguments binding. arguments[0] is n
-  return f();
-}
-
-foo(3); // 6
- -

In most cases, using rest parameters is a good alternative to using an arguments object.

- -
function foo(n) {
-  var f = (...args) => args[0] + n;
-  return f(10);
-}
-
-foo(1); // 11
- -

Arrow functions used as methods

- -

As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:

- -
'use strict';
-
-var obj = { // does not create a new scope
-  i: 10,
-  b: () => console.log(this.i, this),
-  c: function() {
-    console.log(this.i, this);
-  }
-}
-
-obj.b(); // prints undefined, Window {...} (or the global object)
-obj.c(); // prints 10, Object {...}
- -

Arrow functions do not have their own this. Another example involving {{jsxref("Object.defineProperty()")}}:

- -
'use strict';
-
-var obj = {
-  a: 10
-};
-
-Object.defineProperty(obj, 'b', {
-  get: () => {
-    console.log(this.a, typeof this.a, this); // undefined 'undefined' Window {...} (or the global object)
-    return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined'
-  }
-});
-
- -

Use of the new operator

- -

Arrow functions cannot be used as constructors and will throw an error when used with new.

- -
var Foo = () => {};
-var foo = new Foo(); // TypeError: Foo is not a constructor
- -

Use of prototype property

- -

Arrow functions do not have a prototype property.

- -
var Foo = () => {};
-console.log(Foo.prototype); // undefined
-
- -

Use of the yield keyword

- -

The yield keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.

- -

Function body

- -

Arrow functions can have either a "concise body" or the usual "block body".

- -

In a concise body, only an expression is specified, which becomes the implicit return value. In a block body, you must use an explicit return statement.

- -
var func = x => x * x;
-// concise body syntax, implied "return"
-
-var func = (x, y) => { return x + y; };
-// with block body, explicit "return" needed
-
- -

Returning object literals

- -

Keep in mind that returning object literals using the concise body syntax params => {object:literal} will not work as expected.

- -
var func = () => { foo: 1 };
-// Calling func() returns undefined!
-
-var func = () => { foo: function() {} };
-// SyntaxError: function statement requires a name
- -

This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. foo is treated like a label, not a key in an object literal).

- -

You must wrap the object literal in parentheses:

- -
var func = () => ({ foo: 1 });
- -

Line breaks

- -

An arrow function cannot contain a line break between its parameters and its arrow.

- -
var func = (a, b, c)
-  => 1;
-// SyntaxError: expected expression, got '=>'
- -

However, this can be amended by putting the line break after the arrow or using parentheses/braces as seen below to ensure that the code stays pretty and fluffy. You can also put line breaks between arguments.

- -
var func = (a, b, c) =>
-  1;
-
-var func = (a, b, c) => (
-  1
-);
-
-var func = (a, b, c) => {
-  return 1
-};
-
-var func = (
-  a,
-  b,
-  c
-) => 1;
-
-// no SyntaxError thrown
- -

Parsing order

- -

Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with operator precedence compared to regular functions.

- -
let callback;
-
-callback = callback || function() {}; // ok
-
-callback = callback || () => {};
-// SyntaxError: invalid arrow-function arguments
-
-callback = callback || (() => {});    // ok
-
- -

More examples

- -
// An empty arrow function returns undefined
-let empty = () => {};
-
-(() => 'foobar')();
-// Returns "foobar"
-// (this is an Immediately Invoked Function Expression)
-
-var simple = a => a > 15 ? 15 : a;
-simple(16); // 15
-simple(10); // 10
-
-let max = (a, b) => a > b ? a : b;
-
-// Easy array filtering, mapping, ...
-
-var arr = [5, 6, 13, 0, 1, 18, 23];
-
-var sum = arr.reduce((a, b) => a + b);
-// 66
-
-var even = arr.filter(v => v % 2 == 0);
-// [6, 0, 18]
-
-var double = arr.map(v => v * 2);
-// [10, 12, 26, 0, 2, 36, 46]
-
-// More concise promise chains
-promise.then(a => {
-  // ...
-}).then(b => {
-  // ...
-});
-
-// Parameterless arrow functions that are visually easier to parse
-setTimeout( () => {
-  console.log('I happen sooner');
-  setTimeout( () => {
-    // deeper code
-    console.log('I happen later');
-  }, 1);
-}, 1);
-
- -

Specifications

- - - - - - - - - - -
Specification
{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}
- -

Browser compatibility

- -
- - -

{{Compat("javascript.functions.arrow_functions")}}

-
- -

See also

- - diff --git a/files/pt-pt/web/javascript/reference/funcoes/index.html b/files/pt-pt/web/javascript/reference/funcoes/index.html deleted file mode 100644 index 02b35fc7bd..0000000000 --- a/files/pt-pt/web/javascript/reference/funcoes/index.html +++ /dev/null @@ -1,594 +0,0 @@ ---- -title: Funções -slug: Web/JavaScript/Reference/Funcoes -tags: - - Constructor - - Função - - Funções - - JavaScript - - Parâmetro - - parâmetros -translation_of: Web/JavaScript/Reference/Functions ---- -
{{jsSidebar("Functions")}}
- -

Generally speaking, a function is a "subprogram" that can be called by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the function body. Values can be passed to a function, and the function will return a value.

- -

In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are Function objects.

- -

For more examples and explanations, see also the JavaScript guide about functions.

- -

Descrição

- -

Every function in JavaScript is a Function object. See {{jsxref("Function")}} for information on properties and methods of Function objects.

- -

To return a value other than the default, a function must have a return statement that specifies the value to return. A function without a return statement will return a default value. In the case of a constructor called with the new keyword, the default value is the value of its this parameter. For all other functions, the default return value is {{jsxref("undefined")}}.

- -

The parameters of a function call are the function's arguments. Arguments are passed to functions by value. If the function changes the value of an argument, this change is not reflected globally or in the calling function. However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:

- -
/* Declare the function 'myFunc' */
-function myFunc(theObject) {
-  theObject.brand = "Toyota";
-}
-
-/*
- * Declare variable 'mycar';
- * create and initialize a new Object;
- * assign reference to it to 'mycar'
- */
-var mycar = {
-  brand: "Honda",
-  model: "Accord",
-  year: 1998
-};
-
-/* Logs 'Honda' */
-console.log(mycar.brand);
-
-/* Pass object reference to the function */
-myFunc(mycar);
-
-/*
- * Logs 'Toyota' as the value of the 'brand' property
- * of the object, as changed to by the function.
- */
-console.log(mycar.brand);
-
- -

The this keyword does not refer to the currently executing function, so you must refer to Function objects by name, even within the function body.

- -

Definindo funções

- -

There are several ways to define functions:

- -

The function declaration (function statement)

- -

There is a special syntax for declaring functions (see function statement for details):

- -
function name([param[, param[, ... param]]]) {
-   statements
-}
-
- -
-
name
-
The function name.
-
- -
-
param
-
The name of an argument to be passed to the function. A function can have up to 255 arguments.
-
- -
-
statements
-
The statements comprising the body of the function.
-
- -

The function expression (function expression)

- -

A function expression is similar to and has the same syntax as a function declaration (see function expression for details). A function expression may be a part of a larger expression. One can define "named" function expressions (where the name of the expression might be used in the call stack for example) or "anonymous" function expressions. Function expressions are not hoisted onto the beginning of the scope, therefore they cannot be used before they appear in the code.

- -
function [name]([param[, param[, ... param]]]) {
-   statements
-}
-
- -
-
name
-
The function name. Can be omitted, in which case the function becomes known as an anonymous function.
-
- -
-
param
-
The name of an argument to be passed to the function. A function can have up to 255 arguments.
-
statements
-
The statements comprising the body of the function.
-
- -

Here is an example of an anonymous function expression (the name is not used):

- -
var myFunction = function() {
-    statements
-}
- -

It is also possible to provide a name inside the definition in order to create a named function expression:

- -
var myFunction = function namedFunction(){
-    statements
-}
-
- -

One of the benefit of creating a named function expression is that in case we encounted an error, the stack trace will contain the name of the function, making it easier to find the origin of the error.

- -

As we can see, both examples do not start with the function keyword. Statements involving functions which do not start with function are function expressions.

- -

When functions are used only once, a common pattern is an IIFE (Immediately Invokable Function Expression).

- -
(function() {
-    statements
-})();
- -

IIFE are function expressions that are invoked as soon as the function is declared.

- -

The generator function declaration (function* statement)

- -

There is a special syntax for generator function declarations (see {{jsxref('Statements/function*', 'function* statement')}} for details):

- -
function* name([param[, param[, ... param]]]) {
-   statements
-}
-
- -
-
name
-
The function name.
-
- -
-
param
-
The name of an argument to be passed to the function. A function can have up to 255 arguments.
-
- -
-
statements
-
The statements comprising the body of the function.
-
- -

The generator function expression (function* expression)

- -

A generator function expression is similar to and has the same syntax as a generator function declaration (see {{jsxref('Operators/function*', 'function* expression')}} for details):

- -
function* [name]([param[, param[, ... param]]]) {
-   statements
-}
-
- -
-
name
-
The function name. Can be omitted, in which case the function becomes known as an anonymous function.
-
- -
-
param
-
The name of an argument to be passed to the function. A function can have up to 255 arguments.
-
statements
-
The statements comprising the body of the function.
-
- -

The arrow function expression (=>)

- -

An arrow function expression has a shorter syntax and lexically binds its this value (see arrow functions for details):

- -
([param[, param]]) => {
-   statements
-}
-
-param => expression
-
- -
-
param
-
The name of an argument. Zero arguments need to be indicated with ().  For only one argument, the parentheses are not required. (like foo => 1)
-
statements or expression
-
Multiple statements need to be enclosed in brackets. A single expression requires no brackets. The expression is also the implicit return value of the function.
-
- -

The Function constructor

- -
-

Note: Using the Function constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

-
- -

As all other objects, {{jsxref("Function")}} objects can be created using the new operator:

- -
new Function (arg1, arg2, ... argN, functionBody)
-
- -
-
arg1, arg2, ... argN
-
Zero or more names to be used by the function as formal parameters. Each must be a proper JavaScript identifier.
-
- -
-
functionBody
-
A string containing the JavaScript statements comprising the function body.
-
- -

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

- -

The GeneratorFunction constructor

- -
-

Note: GeneratorFunction is not a global object, but could be obtained from generator function instance (see {{jsxref("GeneratorFunction")}} for more detail).

-
- -
-

Note: Using the GeneratorFunction constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

-
- -

As all other objects, {{jsxref("GeneratorFunction")}} objects can be created using the new operator:

- -
new GeneratorFunction (arg1, arg2, ... argN, functionBody)
-
- -
-
arg1, arg2, ... argN
-
Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "x", "theValue", or "a,b".
-
- -
-
functionBody
-
A string containing the JavaScript statements comprising the function definition.
-
- -

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

- -

Parâmetros de função

- -

Parâmetros predefinidos

- -

Default function parameters allow formal parameters to be initialized with default values if no value or undefined is passed. For more details, see default parameters.

- -

Parâmetros Rest

- -

The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see rest parameters.

- -

O objeto arguments

- -

You can refer to a function's arguments within the function by using the arguments object. See arguments.

- - - -

Definindo funções de método

- -

Getter and setter functions

- -

You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.

- -
-
get
-
-

Binds an object property to a function that will be called when that property is looked up.

-
-
set
-
Binds an object property to a function to be called when there is an attempt to set that property.
-
- -

Method definition syntax

- -

Starting with ECMAScript 2015, you are able to define own methods in a shorter syntax, similar to the getters and setters. See method definitions for more information.

- -
var obj = {
-  foo() {},
-  bar() {}
-};
- -

Constructor vs. declaration vs. expression

- -

Compare the following:

- -

A function defined with the Function constructor assigned to the variable multiply:

- -
var multiply = new Function('x', 'y', 'return x * y');
- -

A function declaration of a function named multiply:

- -
function multiply(x, y) {
-   return x * y;
-} // there is no semicolon here
-
- -

A function expression of an anonymous function assigned to the variable multiply:

- -
var multiply = function(x, y) {
-   return x * y;
-};
-
- -

A function expression of a function named func_name assigned to the variable multiply:

- -
var multiply = function func_name(x, y) {
-   return x * y;
-};
-
- -

Differences

- -

All do approximately the same thing, with a few subtle differences:

- -

There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or undefined if the function name was previously declared via a var statement). For example:

- -
var y = function x() {};
-alert(x); // throws an error
-
- -

The function name also appears when the function is serialized via Function's toString method.

- -

On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope in which the function is declared.

- -

As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other. A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:

- -

A function defined by 'new Function' does not have a function name. However, in the SpiderMonkey JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, alert(new Function()) outputs:

- -
function anonymous() {
-}
-
- -

Since the function actually does not have a name, anonymous is not a variable that can be accessed within the function. For example, the following would result in an error:

- -
var foo = new Function("alert(anonymous);");
-foo();
-
- -

Unlike functions defined by function expressions or by the Function constructor, a function defined by a function declaration can be used before the function declaration itself. For example:

- -
foo(); // alerts FOO!
-function foo() {
-   alert('FOO!');
-}
-
- -

A function defined by a function expression or by a function declaration inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a Function constructor does not inherit any scope other than the global scope (which all functions inherit).

- -
/*
- * Declare and initialize a variable 'p' (global)
- * and a function 'myFunc' (to change the scope) inside which
- * declare a varible with same name 'p' (current) and
- * define three functions using three different ways:-
- *     1. function declaration
- *     2. function expression
- *     3. function constructor
- * each of which will log 'p'
- */
-var p = 5;
-function myFunc() {
-    var p = 9;
-
-    function decl() {
-        console.log(p);
-    }
-    var expr = function() {
-        console.log(p);
-    };
-    var cons = new Function('\tconsole.log(p);');
-
-    decl();
-    expr();
-    cons();
-}
-myFunc();
-
-/*
- * Logs:-
- * 9  - for 'decl' by function declaration (current scope)
- * 9  - for 'expr' by function expression (current scope)
- * 5  - for 'cons' by Function constructor (global scope)
- */
-
- -

Functions defined by function expressions and function declarations are parsed only once, while those defined by the Function constructor are not. That is, the function body string passed to the Function constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "new Function(...)". Therefore the Function constructor should generally be avoided whenever possible.

- -

It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a Function constructor 's string aren't parsed repeatedly. For example:

- -
var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
-foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.
- -

A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:

- - - -
var x = 0;               // source element
-if (x === 0) {           // source element
-   x = 10;               // not a source element
-   function boo() {}     // not a source element
-}
-function foo() {         // source element
-   var y = 20;           // source element
-   function bar() {}     // source element
-   while (y === 10) {    // source element
-      function blah() {} // not a source element
-      y++;               // not a source element
-   }
-}
-
- -

Examples

- -
// function declaration
-function foo() {}
-
-// function expression
-(function bar() {})
-
-// function expression
-x = function hello() {}
-
-
-if (x) {
-   // function expression
-   function world() {}
-}
-
-
-// function declaration
-function a() {
-   // function declaration
-   function b() {}
-   if (0) {
-      // function expression
-      function c() {}
-   }
-}
-
- -

Block-level functions

- -

In strict mode, starting with ES2015, functions inside blocks are now scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.

- -
'use strict';
-
-function f() {
-  return 1;
-}
-
-{
-  function f() {
-    return 2;
-  }
-}
-
-f() === 1; // true
-
-// f() === 2 in non-strict mode
-
- -

Block-level functions in non-strict code

- -

In a word: Don't.

- -

In non-strict code, function declarations inside blocks behave strangely. For example:

- -
if (shouldDefineZero) {
-   function zero() {     // DANGER: compatibility risk
-      console.log("This is zero.");
-   }
-}
-
- -

ES2015 says that if shouldDefineZero is false, then zero should never be defined, since the block never executes. However, it's a new part of the standard. Historically, this was left unspecified, and some browsers would define zero whether the block executed or not.

- -

In strict mode, all browsers that support ES2015 handle this the same way: zero is defined only if shouldDefineZero is true, and only in the scope of the if-block.

- -

A safer way to define functions conditionally is to assign a function expression to a variable:

- -
var zero;
-if (shouldDefineZero) {
-   zero = function() {
-      console.log("This is zero.");
-   };
-}
-
- -

Exemplos

- -

Returning a formatted number

- -

The following function returns a string containing the formatted representation of a number padded with leading zeros.

- -
// This function returns a string padded with leading zeros
-function padZeros(num, totalLen) {
-   var numStr = num.toString();             // Initialize return value as string
-   var numZeros = totalLen - numStr.length; // Calculate no. of zeros
-   for (var i = 1; i <= numZeros; i++) {
-      numStr = "0" + numStr;
-   }
-   return numStr;
-}
-
- -

The following statements call the padZeros function.

- -
var result;
-result = padZeros(42,4); // returns "0042"
-result = padZeros(42,2); // returns "42"
-result = padZeros(5,4);  // returns "0005"
-
- -

Determining whether a function exists

- -

You can determine whether a function exists by using the typeof operator. In the following example, a test is performed to determine if the window object has a property called noFunc that is a function. If so, it is used; otherwise some other action is taken.

- -
 if ('function' === typeof window.noFunc) {
-   // use noFunc()
- } else {
-   // do something else
- }
-
- -

Note that in the if test, a reference to noFunc is used—there are no brackets "()" after the function name so the actual function is not called.

- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0
{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ES6')}}New: Arrow functions, Generator functions, default parameters, rest parameters.
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.functions")}}

- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/reference/funcoes/parametros_rest/index.html b/files/pt-pt/web/javascript/reference/funcoes/parametros_rest/index.html deleted file mode 100644 index a21cb25ed6..0000000000 --- a/files/pt-pt/web/javascript/reference/funcoes/parametros_rest/index.html +++ /dev/null @@ -1,234 +0,0 @@ ---- -title: Parâmetros Rest -slug: Web/JavaScript/Reference/Funcoes/parametros_rest -tags: - - Funcionalidade Linguagem - - Funções - - JavaScript - - Parametros Rest - - Rest -translation_of: Web/JavaScript/Reference/Functions/rest_parameters ---- -
Parâmetrois {{jsSidebar("Functions")}}
- -

A sintaxe do parâmetro "rest" permite-nos representar um número indefinido de argumentoscomo um array.

- -
{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}
- - - -

Sintaxe

- -
function f(a, b, ...theArgs) {
-  // ...
-}
- -

Descrição

- -

A function's last parameter can be prefixed with ... which will cause all remaining (user supplied) arguments to be placed within a "standard" Javascript array.

- -

Only the last parameter can be a "rest parameter".

- -
function myFun(a, b, ...manyMoreArgs) {
-  console.log("a", a)
-  console.log("b", b)
-  console.log("manyMoreArgs", manyMoreArgs)
-}
-
-myFun("one", "two", "three", "four", "five", "six")
-
-// Console Output:
-// a, one
-// b, two
-// manyMoreArgs, [three, four, five, six]
-
- -

Difference between rest parameters and the arguments object

- -

There are three main differences between rest parameters and the {{jsxref("Functions/arguments", "arguments")}} object:

- - - -

From arguments to an array

- -

Rest parameters have been introduced to reduce the boilerplate code that was induced by the arguments

- -
// Before rest parameters, "arguments" could be converted to a normal array using:
-
-function f(a, b) {
-
-  let normalArray = Array.prototype.slice.call(arguments)
-  // -- or --
-  let normalArray = [].slice.call(arguments)
-  // -- or --
-  let normalArray = Array.from(arguments)
-
-  let first = normalArray.shift()  // OK, gives the first argument
-  let first = arguments.shift()    // ERROR (arguments is not a normal array)
-}
-
-// Now, you can easily gain access to a normal array using a rest parameter
-
-function f(...args) {
-  let normalArray = args
-  let first = normalArray.shift() // OK, gives the first argument
-}
-
- -

Destructuring rest parameters

- -

Rest parameters can be destructured Arrays only (though objects will soon be supported). That means that their data can be unpacked into distinct variables. (See Destructuring assignment.)

- -
function f(...[a, b, c]) {
-  return a + b + c;
-}
-
-f(1)          // NaN (b and c are undefined)
-f(1, 2, 3)    // 6
-f(1, 2, 3, 4) // 6 (the fourth parameter is not destructured)
-
- -
-

Fixme

- -

Doing this is possible, but (afaik) there's no use-case, so it's just confusing the junior audience. The following code does exactly the same. There should at least be a note, that in theory you can do something like this, but there is no point in doing so. The example is contrived, but imagine that [a, b, c] were the return value of some function. Then the utility is clear.

- -

Also, since Function arguments will never have named parameters (this is not Python), the statement "objects will soon be supported" is wrong. The preceding example may be mixing up destructuring with rest parameters. Please see the page on destructuring assignment for an example with object destructuring applied in the parameters area.

- -
function f(a, b, c) {
-  return a + b + c
-}
-
-f(1)          // NaN (b and c are undefined)
-f(1, 2, 3)    // 6
-f(1, 2, 3, 4) // 6 (the fourth parameter is not ...)
-
-
- -

Exemplos

- -

In this example, the first argument is mapped to a and the second to b, so these named arguments are used like normal.

- -

However, the third argument, manyMoreArgs, will be an array that contains the 3rd, 4th, 5th, 6th ... nth — as many arguments that the user includes.

- -
function myFun(a, b, ...manyMoreArgs) {
-  console.log("a", a)
-  console.log("b", b)
-  console.log("manyMoreArgs", manyMoreArgs)
-}
-
-myFun("one", "two", "three", "four", "five", "six")
-
-// a, one
-// b, two
-// manyMoreArgs, [three, four, five, six]
-
- -

Below... even though there is just one value, the last argument still gets put into an array.

- -
// using the same function definition from example above
-
-myFun("one", "two", "three")
-
-// a, one
-// b, two
-// manyMoreArgs, [three]
- -

Below, the third argument isn't provided, but manyMoreArgs is still an array (albeit an empty one).

- -
// using the same function definition from example above
-
-myFun("one", "two")
-
-// a, one
-// b, two
-// manyMoreArgs, []
- -

Since theArgs is an array, a count of its elements is given by the length property:

- -
function fun1(...theArgs) {
-  console.log(theArgs.length)
-}
-
-fun1()         // 0
-fun1(5)        // 1
-fun1(5, 6, 7)  // 3
-
- -

In the next example, a rest parameter is used to collect all parameters after the first into an array. Each one of them is then multiplied by the first parameter, and the array is returned:

- -
function multiply(multiplier, ...theArgs) {
-  return theArgs.map(function(element) {
-    return multiplier * element
-  })
-}
-
-let arr = multiply(2, 1, 2, 3)
-console.log(arr)  // [2, 4, 6]
-
- -

Array methods can be used on rest parameters, but not on the arguments object:

- -
function sortRestArgs(...theArgs) {
-  let sortedArgs = theArgs.sort()
-  return sortedArgs
-}
-
-console.log(sortRestArgs(5, 3, 7, 1)) // 1, 3, 5, 7
-
-function sortArguments() {
-  let sortedArgs = arguments.sort()
-  return sortedArgs  // this will never happen
-}
-
-
-console.log(sortArguments(5, 3, 7, 1))
-// throws a TypeError (arguments.sort is not a function)
-
- -

To use Array methods on the arguments object, it must be converted to a real array first.

- -
function sortArguments() {
-  let args = Array.from(arguments)
-  let sortedArgs = args.sort()
-  return sortedArgs
-}
-console.log(sortArguments(5, 3, 7, 1))  // 1, 3, 5, 7
-
- -

Especificações

- - - - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}
- -

Compatibildiade de navegador

- - - -

{{Compat("javascript.functions.rest_parameters")}}

- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/reference/functions/arguments/index.html b/files/pt-pt/web/javascript/reference/functions/arguments/index.html new file mode 100644 index 0000000000..c7ac84a4b9 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/functions/arguments/index.html @@ -0,0 +1,228 @@ +--- +title: O objeto arguments +slug: Web/JavaScript/Reference/Funcoes/arguments +tags: + - Class + - Funções + - JavaScript + - Referencia + - arguments +translation_of: Web/JavaScript/Reference/Functions/arguments +--- +

{{JSSidebar("Functions")}}

+ +

arguments é um objeto semelhante a uma "Matiz" acessível dentro de functions que contém os valores dos argumentos passados ​​para essa função.

+ +
+

Nota: If you're writing ES6 compatible code, then rest parameters should be preferred.

+
+ +
+

Nota: “Array-like” means that arguments has a length property and properties indexed from zero, but it doesn't have {{JSxRef("Array")}}'s built-in methods like forEach and map. See §Description for details.

+
+ +
{{EmbedInteractiveExample("pages/js/functions-arguments.html")}}
+ + + +

Sintaxe

+ +
arguments
+ +

Descrição

+ +

The arguments object is a local variable available within all non-arrow functions. You can refer to a function's arguments inside that function by using its arguments object. It has entries for each argument the function was called with, with the first entry's index at 0.

+ +

For example, if a function is passed 3 arguments, you can access them as follows:

+ +
arguments[0] // first argument
+arguments[1] // second argument
+arguments[2] // third argument
+
+ +

Each argument can also be set or reassigned:

+ +
arguments[1] = 'new value';
+
+ +

The arguments object is not an {{JSxRef("Array")}}. It is similar, but does not have any Array properties except length. For example, it does not have the pop method. However, it can be converted to a real Array:

+ +
var args = Array.prototype.slice.call(arguments);
+// Using an array literal is shorter than above but allocates an empty array
+var args = [].slice.call(arguments);
+
+ +

As you can do with any Array-like object, you can use ES2015's {{JSxRef("Array.from()")}} method or spread operator to convert arguments to a real Array:

+ +
let args = Array.from(arguments);
+// or
+let args = [...arguments];
+ +

The arguments object is useful for functions called with more arguments than they are formally declared to accept. This technique is useful for functions that can be passed a variable number of arguments, such as Math.min(). This example function accepts any number of string arguments and returns the longest one:

+ +
function longestString() {
+  var longest = '';
+  for (var i=0; i < arguments.length; i++) {
+    if (arguments[i].length > longest.length) {
+      longest = arguments[i];
+    }
+  }
+  return longest;
+}
+
+ +

You can use arguments.length to count how many arguments the function was called with. If you instead want to count how many parameters a function is declared to accept, inspect that function's length property.

+ +

Utilizar typeof com Arguments

+ +

The typeof operator returns 'object' when used with arguments

+ +
console.log(typeof arguments); // 'object'
+ +

The type of individual arguments can be determined by indexing arguments:

+ +
console.log(typeof arguments[0]); // returns the type of the first argument
+ +

Propriedades

+ +
+
+
{{jsxref("Functions/arguments/callee", "arguments.callee")}}
+
Reference to the currently executing function that the arguments belong to.
+
{{jsxref("Functions/arguments/length", "arguments.length")}}
+
The number of arguments that were passed to the function.
+
{{jsxref("Functions/arguments/@@iterator", "arguments[@@iterator]")}}
+
Returns a new {{jsxref("Array/@@iterator", "Array iterator", "", 0)}} object that contains the values for each index in arguments.
+
+ +

Exemplos

+ +

Definir uma function que concatena várias strings

+ +

This example defines a function that concatenates several strings. The function's only formal argument is a string containing the characters that separate the items to concatenate.

+ +
function myConcat(separator) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return args.join(separator);
+}
+ +

You can pass as many arguments as you like to this function. It returns a string list using each argument in the list:

+ +
// returns "red, orange, blue"
+myConcat(', ', 'red', 'orange', 'blue');
+
+// returns "elephant; giraffe; lion; cheetah"
+myConcat('; ', 'elephant', 'giraffe', 'lion', 'cheetah');
+
+// returns "sage. basil. oregano. pepper. parsley"
+myConcat('. ', 'sage', 'basil', 'oregano', 'pepper', 'parsley');
+ +

Definir uma function que cria listas HTML

+ +

This example defines a function that creates a string containing HTML for a list. The only formal argument for the function is a string that is "u" if the list is to be unordered (bulleted), or "o" if the list is to be ordered (numbered). The function is defined as follows:

+ +
function list(type) {
+  var html = '<' + type + 'l><li>';
+  var args = Array.prototype.slice.call(arguments, 1);
+  html += args.join('</li><li>');
+  html += '</li></' + type + 'l>'; // end list
+
+  return html;
+}
+ +

You can pass any number of arguments to this function, and it adds each argument as a list item to a list of the type indicated. For example:

+ +
var listHTML = list('u', 'One', 'Two', 'Three');
+
+/* listHTML is:
+"<ul><li>One</li><li>Two</li><li>Three</li></ul>"
+*/
+ +

Parâmetros Rest, predefinição, e desestruturados

+ +

The arguments object can be used in conjunction with rest, default, and destructured parameters.

+ +
function foo(...args) {
+  return args;
+}
+foo(1, 2, 3); // [1,2,3]
+
+ +

While the presence of rest, default, or destructured parameters does not alter the behavior of the arguments object in strict mode code, there is a subtle difference for non-strict code.

+ +

In strict-mode code, the arguments object behaves the same whether or not a function is passed rest, default, or destructured parameters. That is, assigning new values to variables in the body of the function will not affect the arguments object. Nor will assigning new variables to the arguments object affect the value of variables.

+ +
+

Nota: You cannot write a "use strict"; directive in the body of a function definition that accepts rest, default, or destructured parameters. Doing so will throw a syntax error.

+
+ +

Non-strict functions that are passed only simple parameters (that is, not rest, default, or restructured parameters) will sync the value of variables new values in the body of the function with the arguments object, and vice versa:

+ +
function func(a) {
+  arguments[0] = 99; // updating arguments[0] also updates a
+  console.log(a);
+}
+func(10); // 99
+
+ +

And also:

+ +
function func(a) {
+  a = 99; // updating a also updates arguments[0]
+  console.log(arguments[0]);
+}
+func(10); // 99
+
+ +

Conversely, non-strict functions that are passed rest, default, or destructured parameters will not sync new values assigned to argument variables in the function body with the arguments object. Instead, the arguments object in non-strict functions with complex parameters will always reflect the values passed to the function when the function was called (this is the same behavior as exhibited by all strict-mode functions, regardless of the type of variables they are passed):

+ +
function func(a = 55) {
+  arguments[0] = 99; // updating arguments[0] does not also update a
+  console.log(a);
+}
+func(10); // 10
+ +

E também:

+ +
function func(a = 55) {
+  a = 99; // updating a does not also update arguments[0]
+  console.log(arguments[0]);
+}
+func(10); // 10
+
+ +

E também:

+ +
// An untracked default parameter
+function func(a = 55) {
+  console.log(arguments[0]);
+}
+func(); // undefined
+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}
+ +

Compatibildiade de navegador

+ + + +

{{Compat("javascript.functions.arguments")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/functions/arrow_functions/index.html b/files/pt-pt/web/javascript/reference/functions/arrow_functions/index.html new file mode 100644 index 0000000000..aa7b7b3121 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/functions/arrow_functions/index.html @@ -0,0 +1,399 @@ +--- +title: Expressões da função "Seta" +slug: Web/JavaScript/Reference/Funcoes/Funcoes_seta +translation_of: Web/JavaScript/Reference/Functions/Arrow_functions +--- +
{{jsSidebar("Functions")}}
+ +

Uma expressão da função seta é uma alternativa sintaticamente compacta a uma expressão de expressão de função regular, embora sem as suas próprias associações às palavras-chave this, arguments, super, ou new.target. As expressões de função (function) de seta são inadequadas como métodos, e não podem ser utilziadas como construtores.

+ +
{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}
+ +

Sintaxe

+ +

Basic syntax

+ +
(param1, param2, …, paramN) => { statements }
+(param1, param2, …, paramN) => expression
+// equivalent to: => { return expression; }
+
+// Parentheses are optional when there's only one parameter name:
+(singleParam) => { statements }
+singleParam => { statements }
+
+// The parameter list for a function with no parameters should be written with a pair of parentheses.
+() => { statements }
+
+ +

Advanced syntax

+ +
// Parenthesize the body of a function to return an object literal expression:
+params => ({foo: bar})
+
+// Rest parameters and default parameters are supported
+(param1, param2, ...rest) => { statements }
+(param1 = defaultValue1, param2, …, paramN = defaultValueN) => {
+statements }
+
+// Destructuring within the parameter list is also supported
+var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
+f(); // 6
+
+ +

Descrição

+ +

See also "ES6 In Depth: Arrow functions" on hacks.mozilla.org.

+ +

Two factors influenced the introduction of arrow functions: the need for shorter functions and the behavior of the this keyword.

+ +

Funções curtas

+ +
var elements = [
+  'Hydrogen',
+  'Helium',
+  'Lithium',
+  'Beryllium'
+];
+
+// This statement returns the array: [8, 6, 7, 9]
+elements.map(function(element) {
+  return element.length;
+});
+
+// The regular function above can be written as the arrow function below
+elements.map((element) => {
+  return element.length;
+}); // [8, 6, 7, 9]
+
+// When there is only one parameter, we can remove the surrounding parentheses
+elements.map(element => {
+  return element.length;
+}); // [8, 6, 7, 9]
+
+// When the only statement in an arrow function is `return`, we can remove `return` and remove
+// the surrounding curly brackets
+elements.map(element => element.length); // [8, 6, 7, 9]
+
+// In this case, because we only need the length property, we can use destructuring parameter:
+// Notice that the `length` corresponds to the property we want to get whereas the
+// obviously non-special `lengthFooBArX` is just the name of a variable which can be changed
+// to any valid variable name you want
+elements.map(({ length: lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]
+
+// This destructuring parameter assignment can also be written as seen below. However, note that in
+// this example we are not assigning `length` value to the made up property. Instead, the literal name
+// itself of the variable `length` is used as the property we want to retrieve from the object.
+elements.map(({ length }) => length); // [8, 6, 7, 9]
+
+ +

No separate this

+ +

Before arrow functions, every new function defined its own this value based on how the function was called:

+ + + +

This proved to be less than ideal with an object-oriented style of programming.

+ +
function Person() {
+  // The Person() constructor defines `this` as an instance of itself.
+  this.age = 0;
+
+  setInterval(function growUp() {
+    // In non-strict mode, the growUp() function defines `this`
+    // as the global object (because it's where growUp() is executed.),
+    // which is different from the `this`
+    // defined by the Person() constructor.
+    this.age++;
+  }, 1000);
+}
+
+var p = new Person();
+ +

In ECMAScript 3/5, the this issue was fixable by assigning the value in this to a variable that could be closed over.

+ +
function Person() {
+  var that = this;
+  that.age = 0;
+
+  setInterval(function growUp() {
+    // The callback refers to the `that` variable of which
+    // the value is the expected object.
+    that.age++;
+  }, 1000);
+}
+ +

Alternatively, a bound function could be created so that a preassigned this value would be passed to the bound target function (the growUp() function in the example above).

+ +

An arrow function does not have its own this. The this value of the enclosing lexical scope is used; arrow functions follow the normal variable lookup rules. So while searching for this which is not present in current scope, an arrow function ends up finding the this from its enclosing scope.

+ +

Thus, in the following code, the this within the function that is passed to setInterval has the same value as the this in the lexically enclosing function:

+ +
function Person(){
+  this.age = 0;
+
+  setInterval(() => {
+    this.age++; // |this| properly refers to the Person object
+  }, 1000);
+}
+
+var p = new Person();
+ +

Relation with strict mode

+ +

Given that this comes from the surrounding lexical context, strict mode rules with regard to this are ignored.

+ +
var f = () => { 'use strict'; return this; };
+f() === window; // or the global object
+ +

All other strict mode rules apply normally.

+ +

Invoked through call or apply

+ +

Since arrow functions do not have their own this, the methods call() and apply() can only pass in parameters. Any this argument is ignored.

+ +
var adder = {
+  base: 1,
+
+  add: function(a) {
+    var f = v => v + this.base;
+    return f(a);
+  },
+
+  addThruCall: function(a) {
+    var f = v => v + this.base;
+    var b = {
+      base: 2
+    };
+
+    return f.call(b, a);
+  }
+};
+
+console.log(adder.add(1));         // This would log 2
+console.log(adder.addThruCall(1)); // This would log 2 still
+ +

No binding of arguments

+ +

Arrow functions do not have their own arguments object. Thus, in this example, arguments is simply a reference to the arguments of the enclosing scope:

+ +
var arguments = [1, 2, 3];
+var arr = () => arguments[0];
+
+arr(); // 1
+
+function foo(n) {
+  var f = () => arguments[0] + n; // foo's implicit arguments binding. arguments[0] is n
+  return f();
+}
+
+foo(3); // 6
+ +

In most cases, using rest parameters is a good alternative to using an arguments object.

+ +
function foo(n) {
+  var f = (...args) => args[0] + n;
+  return f(10);
+}
+
+foo(1); // 11
+ +

Arrow functions used as methods

+ +

As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:

+ +
'use strict';
+
+var obj = { // does not create a new scope
+  i: 10,
+  b: () => console.log(this.i, this),
+  c: function() {
+    console.log(this.i, this);
+  }
+}
+
+obj.b(); // prints undefined, Window {...} (or the global object)
+obj.c(); // prints 10, Object {...}
+ +

Arrow functions do not have their own this. Another example involving {{jsxref("Object.defineProperty()")}}:

+ +
'use strict';
+
+var obj = {
+  a: 10
+};
+
+Object.defineProperty(obj, 'b', {
+  get: () => {
+    console.log(this.a, typeof this.a, this); // undefined 'undefined' Window {...} (or the global object)
+    return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined'
+  }
+});
+
+ +

Use of the new operator

+ +

Arrow functions cannot be used as constructors and will throw an error when used with new.

+ +
var Foo = () => {};
+var foo = new Foo(); // TypeError: Foo is not a constructor
+ +

Use of prototype property

+ +

Arrow functions do not have a prototype property.

+ +
var Foo = () => {};
+console.log(Foo.prototype); // undefined
+
+ +

Use of the yield keyword

+ +

The yield keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.

+ +

Function body

+ +

Arrow functions can have either a "concise body" or the usual "block body".

+ +

In a concise body, only an expression is specified, which becomes the implicit return value. In a block body, you must use an explicit return statement.

+ +
var func = x => x * x;
+// concise body syntax, implied "return"
+
+var func = (x, y) => { return x + y; };
+// with block body, explicit "return" needed
+
+ +

Returning object literals

+ +

Keep in mind that returning object literals using the concise body syntax params => {object:literal} will not work as expected.

+ +
var func = () => { foo: 1 };
+// Calling func() returns undefined!
+
+var func = () => { foo: function() {} };
+// SyntaxError: function statement requires a name
+ +

This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. foo is treated like a label, not a key in an object literal).

+ +

You must wrap the object literal in parentheses:

+ +
var func = () => ({ foo: 1 });
+ +

Line breaks

+ +

An arrow function cannot contain a line break between its parameters and its arrow.

+ +
var func = (a, b, c)
+  => 1;
+// SyntaxError: expected expression, got '=>'
+ +

However, this can be amended by putting the line break after the arrow or using parentheses/braces as seen below to ensure that the code stays pretty and fluffy. You can also put line breaks between arguments.

+ +
var func = (a, b, c) =>
+  1;
+
+var func = (a, b, c) => (
+  1
+);
+
+var func = (a, b, c) => {
+  return 1
+};
+
+var func = (
+  a,
+  b,
+  c
+) => 1;
+
+// no SyntaxError thrown
+ +

Parsing order

+ +

Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with operator precedence compared to regular functions.

+ +
let callback;
+
+callback = callback || function() {}; // ok
+
+callback = callback || () => {};
+// SyntaxError: invalid arrow-function arguments
+
+callback = callback || (() => {});    // ok
+
+ +

More examples

+ +
// An empty arrow function returns undefined
+let empty = () => {};
+
+(() => 'foobar')();
+// Returns "foobar"
+// (this is an Immediately Invoked Function Expression)
+
+var simple = a => a > 15 ? 15 : a;
+simple(16); // 15
+simple(10); // 10
+
+let max = (a, b) => a > b ? a : b;
+
+// Easy array filtering, mapping, ...
+
+var arr = [5, 6, 13, 0, 1, 18, 23];
+
+var sum = arr.reduce((a, b) => a + b);
+// 66
+
+var even = arr.filter(v => v % 2 == 0);
+// [6, 0, 18]
+
+var double = arr.map(v => v * 2);
+// [10, 12, 26, 0, 2, 36, 46]
+
+// More concise promise chains
+promise.then(a => {
+  // ...
+}).then(b => {
+  // ...
+});
+
+// Parameterless arrow functions that are visually easier to parse
+setTimeout( () => {
+  console.log('I happen sooner');
+  setTimeout( () => {
+    // deeper code
+    console.log('I happen later');
+  }, 1);
+}, 1);
+
+ +

Specifications

+ + + + + + + + + + +
Specification
{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}
+ +

Browser compatibility

+ +
+ + +

{{Compat("javascript.functions.arrow_functions")}}

+
+ +

See also

+ + diff --git a/files/pt-pt/web/javascript/reference/functions/index.html b/files/pt-pt/web/javascript/reference/functions/index.html new file mode 100644 index 0000000000..02b35fc7bd --- /dev/null +++ b/files/pt-pt/web/javascript/reference/functions/index.html @@ -0,0 +1,594 @@ +--- +title: Funções +slug: Web/JavaScript/Reference/Funcoes +tags: + - Constructor + - Função + - Funções + - JavaScript + - Parâmetro + - parâmetros +translation_of: Web/JavaScript/Reference/Functions +--- +
{{jsSidebar("Functions")}}
+ +

Generally speaking, a function is a "subprogram" that can be called by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the function body. Values can be passed to a function, and the function will return a value.

+ +

In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are Function objects.

+ +

For more examples and explanations, see also the JavaScript guide about functions.

+ +

Descrição

+ +

Every function in JavaScript is a Function object. See {{jsxref("Function")}} for information on properties and methods of Function objects.

+ +

To return a value other than the default, a function must have a return statement that specifies the value to return. A function without a return statement will return a default value. In the case of a constructor called with the new keyword, the default value is the value of its this parameter. For all other functions, the default return value is {{jsxref("undefined")}}.

+ +

The parameters of a function call are the function's arguments. Arguments are passed to functions by value. If the function changes the value of an argument, this change is not reflected globally or in the calling function. However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:

+ +
/* Declare the function 'myFunc' */
+function myFunc(theObject) {
+  theObject.brand = "Toyota";
+}
+
+/*
+ * Declare variable 'mycar';
+ * create and initialize a new Object;
+ * assign reference to it to 'mycar'
+ */
+var mycar = {
+  brand: "Honda",
+  model: "Accord",
+  year: 1998
+};
+
+/* Logs 'Honda' */
+console.log(mycar.brand);
+
+/* Pass object reference to the function */
+myFunc(mycar);
+
+/*
+ * Logs 'Toyota' as the value of the 'brand' property
+ * of the object, as changed to by the function.
+ */
+console.log(mycar.brand);
+
+ +

The this keyword does not refer to the currently executing function, so you must refer to Function objects by name, even within the function body.

+ +

Definindo funções

+ +

There are several ways to define functions:

+ +

The function declaration (function statement)

+ +

There is a special syntax for declaring functions (see function statement for details):

+ +
function name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
The function name.
+
+ +
+
param
+
The name of an argument to be passed to the function. A function can have up to 255 arguments.
+
+ +
+
statements
+
The statements comprising the body of the function.
+
+ +

The function expression (function expression)

+ +

A function expression is similar to and has the same syntax as a function declaration (see function expression for details). A function expression may be a part of a larger expression. One can define "named" function expressions (where the name of the expression might be used in the call stack for example) or "anonymous" function expressions. Function expressions are not hoisted onto the beginning of the scope, therefore they cannot be used before they appear in the code.

+ +
function [name]([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
The function name. Can be omitted, in which case the function becomes known as an anonymous function.
+
+ +
+
param
+
The name of an argument to be passed to the function. A function can have up to 255 arguments.
+
statements
+
The statements comprising the body of the function.
+
+ +

Here is an example of an anonymous function expression (the name is not used):

+ +
var myFunction = function() {
+    statements
+}
+ +

It is also possible to provide a name inside the definition in order to create a named function expression:

+ +
var myFunction = function namedFunction(){
+    statements
+}
+
+ +

One of the benefit of creating a named function expression is that in case we encounted an error, the stack trace will contain the name of the function, making it easier to find the origin of the error.

+ +

As we can see, both examples do not start with the function keyword. Statements involving functions which do not start with function are function expressions.

+ +

When functions are used only once, a common pattern is an IIFE (Immediately Invokable Function Expression).

+ +
(function() {
+    statements
+})();
+ +

IIFE are function expressions that are invoked as soon as the function is declared.

+ +

The generator function declaration (function* statement)

+ +

There is a special syntax for generator function declarations (see {{jsxref('Statements/function*', 'function* statement')}} for details):

+ +
function* name([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
The function name.
+
+ +
+
param
+
The name of an argument to be passed to the function. A function can have up to 255 arguments.
+
+ +
+
statements
+
The statements comprising the body of the function.
+
+ +

The generator function expression (function* expression)

+ +

A generator function expression is similar to and has the same syntax as a generator function declaration (see {{jsxref('Operators/function*', 'function* expression')}} for details):

+ +
function* [name]([param[, param[, ... param]]]) {
+   statements
+}
+
+ +
+
name
+
The function name. Can be omitted, in which case the function becomes known as an anonymous function.
+
+ +
+
param
+
The name of an argument to be passed to the function. A function can have up to 255 arguments.
+
statements
+
The statements comprising the body of the function.
+
+ +

The arrow function expression (=>)

+ +

An arrow function expression has a shorter syntax and lexically binds its this value (see arrow functions for details):

+ +
([param[, param]]) => {
+   statements
+}
+
+param => expression
+
+ +
+
param
+
The name of an argument. Zero arguments need to be indicated with ().  For only one argument, the parentheses are not required. (like foo => 1)
+
statements or expression
+
Multiple statements need to be enclosed in brackets. A single expression requires no brackets. The expression is also the implicit return value of the function.
+
+ +

The Function constructor

+ +
+

Note: Using the Function constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

+
+ +

As all other objects, {{jsxref("Function")}} objects can be created using the new operator:

+ +
new Function (arg1, arg2, ... argN, functionBody)
+
+ +
+
arg1, arg2, ... argN
+
Zero or more names to be used by the function as formal parameters. Each must be a proper JavaScript identifier.
+
+ +
+
functionBody
+
A string containing the JavaScript statements comprising the function body.
+
+ +

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

+ +

The GeneratorFunction constructor

+ +
+

Note: GeneratorFunction is not a global object, but could be obtained from generator function instance (see {{jsxref("GeneratorFunction")}} for more detail).

+
+ +
+

Note: Using the GeneratorFunction constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

+
+ +

As all other objects, {{jsxref("GeneratorFunction")}} objects can be created using the new operator:

+ +
new GeneratorFunction (arg1, arg2, ... argN, functionBody)
+
+ +
+
arg1, arg2, ... argN
+
Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "x", "theValue", or "a,b".
+
+ +
+
functionBody
+
A string containing the JavaScript statements comprising the function definition.
+
+ +

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

+ +

Parâmetros de função

+ +

Parâmetros predefinidos

+ +

Default function parameters allow formal parameters to be initialized with default values if no value or undefined is passed. For more details, see default parameters.

+ +

Parâmetros Rest

+ +

The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see rest parameters.

+ +

O objeto arguments

+ +

You can refer to a function's arguments within the function by using the arguments object. See arguments.

+ + + +

Definindo funções de método

+ +

Getter and setter functions

+ +

You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.

+ +
+
get
+
+

Binds an object property to a function that will be called when that property is looked up.

+
+
set
+
Binds an object property to a function to be called when there is an attempt to set that property.
+
+ +

Method definition syntax

+ +

Starting with ECMAScript 2015, you are able to define own methods in a shorter syntax, similar to the getters and setters. See method definitions for more information.

+ +
var obj = {
+  foo() {},
+  bar() {}
+};
+ +

Constructor vs. declaration vs. expression

+ +

Compare the following:

+ +

A function defined with the Function constructor assigned to the variable multiply:

+ +
var multiply = new Function('x', 'y', 'return x * y');
+ +

A function declaration of a function named multiply:

+ +
function multiply(x, y) {
+   return x * y;
+} // there is no semicolon here
+
+ +

A function expression of an anonymous function assigned to the variable multiply:

+ +
var multiply = function(x, y) {
+   return x * y;
+};
+
+ +

A function expression of a function named func_name assigned to the variable multiply:

+ +
var multiply = function func_name(x, y) {
+   return x * y;
+};
+
+ +

Differences

+ +

All do approximately the same thing, with a few subtle differences:

+ +

There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or undefined if the function name was previously declared via a var statement). For example:

+ +
var y = function x() {};
+alert(x); // throws an error
+
+ +

The function name also appears when the function is serialized via Function's toString method.

+ +

On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope in which the function is declared.

+ +

As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other. A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:

+ +

A function defined by 'new Function' does not have a function name. However, in the SpiderMonkey JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, alert(new Function()) outputs:

+ +
function anonymous() {
+}
+
+ +

Since the function actually does not have a name, anonymous is not a variable that can be accessed within the function. For example, the following would result in an error:

+ +
var foo = new Function("alert(anonymous);");
+foo();
+
+ +

Unlike functions defined by function expressions or by the Function constructor, a function defined by a function declaration can be used before the function declaration itself. For example:

+ +
foo(); // alerts FOO!
+function foo() {
+   alert('FOO!');
+}
+
+ +

A function defined by a function expression or by a function declaration inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a Function constructor does not inherit any scope other than the global scope (which all functions inherit).

+ +
/*
+ * Declare and initialize a variable 'p' (global)
+ * and a function 'myFunc' (to change the scope) inside which
+ * declare a varible with same name 'p' (current) and
+ * define three functions using three different ways:-
+ *     1. function declaration
+ *     2. function expression
+ *     3. function constructor
+ * each of which will log 'p'
+ */
+var p = 5;
+function myFunc() {
+    var p = 9;
+
+    function decl() {
+        console.log(p);
+    }
+    var expr = function() {
+        console.log(p);
+    };
+    var cons = new Function('\tconsole.log(p);');
+
+    decl();
+    expr();
+    cons();
+}
+myFunc();
+
+/*
+ * Logs:-
+ * 9  - for 'decl' by function declaration (current scope)
+ * 9  - for 'expr' by function expression (current scope)
+ * 5  - for 'cons' by Function constructor (global scope)
+ */
+
+ +

Functions defined by function expressions and function declarations are parsed only once, while those defined by the Function constructor are not. That is, the function body string passed to the Function constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "new Function(...)". Therefore the Function constructor should generally be avoided whenever possible.

+ +

It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a Function constructor 's string aren't parsed repeatedly. For example:

+ +
var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
+foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.
+ +

A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:

+ + + +
var x = 0;               // source element
+if (x === 0) {           // source element
+   x = 10;               // not a source element
+   function boo() {}     // not a source element
+}
+function foo() {         // source element
+   var y = 20;           // source element
+   function bar() {}     // source element
+   while (y === 10) {    // source element
+      function blah() {} // not a source element
+      y++;               // not a source element
+   }
+}
+
+ +

Examples

+ +
// function declaration
+function foo() {}
+
+// function expression
+(function bar() {})
+
+// function expression
+x = function hello() {}
+
+
+if (x) {
+   // function expression
+   function world() {}
+}
+
+
+// function declaration
+function a() {
+   // function declaration
+   function b() {}
+   if (0) {
+      // function expression
+      function c() {}
+   }
+}
+
+ +

Block-level functions

+ +

In strict mode, starting with ES2015, functions inside blocks are now scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.

+ +
'use strict';
+
+function f() {
+  return 1;
+}
+
+{
+  function f() {
+    return 2;
+  }
+}
+
+f() === 1; // true
+
+// f() === 2 in non-strict mode
+
+ +

Block-level functions in non-strict code

+ +

In a word: Don't.

+ +

In non-strict code, function declarations inside blocks behave strangely. For example:

+ +
if (shouldDefineZero) {
+   function zero() {     // DANGER: compatibility risk
+      console.log("This is zero.");
+   }
+}
+
+ +

ES2015 says that if shouldDefineZero is false, then zero should never be defined, since the block never executes. However, it's a new part of the standard. Historically, this was left unspecified, and some browsers would define zero whether the block executed or not.

+ +

In strict mode, all browsers that support ES2015 handle this the same way: zero is defined only if shouldDefineZero is true, and only in the scope of the if-block.

+ +

A safer way to define functions conditionally is to assign a function expression to a variable:

+ +
var zero;
+if (shouldDefineZero) {
+   zero = function() {
+      console.log("This is zero.");
+   };
+}
+
+ +

Exemplos

+ +

Returning a formatted number

+ +

The following function returns a string containing the formatted representation of a number padded with leading zeros.

+ +
// This function returns a string padded with leading zeros
+function padZeros(num, totalLen) {
+   var numStr = num.toString();             // Initialize return value as string
+   var numZeros = totalLen - numStr.length; // Calculate no. of zeros
+   for (var i = 1; i <= numZeros; i++) {
+      numStr = "0" + numStr;
+   }
+   return numStr;
+}
+
+ +

The following statements call the padZeros function.

+ +
var result;
+result = padZeros(42,4); // returns "0042"
+result = padZeros(42,2); // returns "42"
+result = padZeros(5,4);  // returns "0005"
+
+ +

Determining whether a function exists

+ +

You can determine whether a function exists by using the typeof operator. In the following example, a test is performed to determine if the window object has a property called noFunc that is a function. If so, it is used; otherwise some other action is taken.

+ +
 if ('function' === typeof window.noFunc) {
+   // use noFunc()
+ } else {
+   // do something else
+ }
+
+ +

Note that in the if test, a reference to noFunc is used—there are no brackets "()" after the function name so the actual function is not called.

+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0
{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ES6')}}New: Arrow functions, Generator functions, default parameters, rest parameters.
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.functions")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/functions/rest_parameters/index.html b/files/pt-pt/web/javascript/reference/functions/rest_parameters/index.html new file mode 100644 index 0000000000..a21cb25ed6 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/functions/rest_parameters/index.html @@ -0,0 +1,234 @@ +--- +title: Parâmetros Rest +slug: Web/JavaScript/Reference/Funcoes/parametros_rest +tags: + - Funcionalidade Linguagem + - Funções + - JavaScript + - Parametros Rest + - Rest +translation_of: Web/JavaScript/Reference/Functions/rest_parameters +--- +
Parâmetrois {{jsSidebar("Functions")}}
+ +

A sintaxe do parâmetro "rest" permite-nos representar um número indefinido de argumentoscomo um array.

+ +
{{EmbedInteractiveExample("pages/js/functions-restparameters.html")}}
+ + + +

Sintaxe

+ +
function f(a, b, ...theArgs) {
+  // ...
+}
+ +

Descrição

+ +

A function's last parameter can be prefixed with ... which will cause all remaining (user supplied) arguments to be placed within a "standard" Javascript array.

+ +

Only the last parameter can be a "rest parameter".

+ +
function myFun(a, b, ...manyMoreArgs) {
+  console.log("a", a)
+  console.log("b", b)
+  console.log("manyMoreArgs", manyMoreArgs)
+}
+
+myFun("one", "two", "three", "four", "five", "six")
+
+// Console Output:
+// a, one
+// b, two
+// manyMoreArgs, [three, four, five, six]
+
+ +

Difference between rest parameters and the arguments object

+ +

There are three main differences between rest parameters and the {{jsxref("Functions/arguments", "arguments")}} object:

+ + + +

From arguments to an array

+ +

Rest parameters have been introduced to reduce the boilerplate code that was induced by the arguments

+ +
// Before rest parameters, "arguments" could be converted to a normal array using:
+
+function f(a, b) {
+
+  let normalArray = Array.prototype.slice.call(arguments)
+  // -- or --
+  let normalArray = [].slice.call(arguments)
+  // -- or --
+  let normalArray = Array.from(arguments)
+
+  let first = normalArray.shift()  // OK, gives the first argument
+  let first = arguments.shift()    // ERROR (arguments is not a normal array)
+}
+
+// Now, you can easily gain access to a normal array using a rest parameter
+
+function f(...args) {
+  let normalArray = args
+  let first = normalArray.shift() // OK, gives the first argument
+}
+
+ +

Destructuring rest parameters

+ +

Rest parameters can be destructured Arrays only (though objects will soon be supported). That means that their data can be unpacked into distinct variables. (See Destructuring assignment.)

+ +
function f(...[a, b, c]) {
+  return a + b + c;
+}
+
+f(1)          // NaN (b and c are undefined)
+f(1, 2, 3)    // 6
+f(1, 2, 3, 4) // 6 (the fourth parameter is not destructured)
+
+ +
+

Fixme

+ +

Doing this is possible, but (afaik) there's no use-case, so it's just confusing the junior audience. The following code does exactly the same. There should at least be a note, that in theory you can do something like this, but there is no point in doing so. The example is contrived, but imagine that [a, b, c] were the return value of some function. Then the utility is clear.

+ +

Also, since Function arguments will never have named parameters (this is not Python), the statement "objects will soon be supported" is wrong. The preceding example may be mixing up destructuring with rest parameters. Please see the page on destructuring assignment for an example with object destructuring applied in the parameters area.

+ +
function f(a, b, c) {
+  return a + b + c
+}
+
+f(1)          // NaN (b and c are undefined)
+f(1, 2, 3)    // 6
+f(1, 2, 3, 4) // 6 (the fourth parameter is not ...)
+
+
+ +

Exemplos

+ +

In this example, the first argument is mapped to a and the second to b, so these named arguments are used like normal.

+ +

However, the third argument, manyMoreArgs, will be an array that contains the 3rd, 4th, 5th, 6th ... nth — as many arguments that the user includes.

+ +
function myFun(a, b, ...manyMoreArgs) {
+  console.log("a", a)
+  console.log("b", b)
+  console.log("manyMoreArgs", manyMoreArgs)
+}
+
+myFun("one", "two", "three", "four", "five", "six")
+
+// a, one
+// b, two
+// manyMoreArgs, [three, four, five, six]
+
+ +

Below... even though there is just one value, the last argument still gets put into an array.

+ +
// using the same function definition from example above
+
+myFun("one", "two", "three")
+
+// a, one
+// b, two
+// manyMoreArgs, [three]
+ +

Below, the third argument isn't provided, but manyMoreArgs is still an array (albeit an empty one).

+ +
// using the same function definition from example above
+
+myFun("one", "two")
+
+// a, one
+// b, two
+// manyMoreArgs, []
+ +

Since theArgs is an array, a count of its elements is given by the length property:

+ +
function fun1(...theArgs) {
+  console.log(theArgs.length)
+}
+
+fun1()         // 0
+fun1(5)        // 1
+fun1(5, 6, 7)  // 3
+
+ +

In the next example, a rest parameter is used to collect all parameters after the first into an array. Each one of them is then multiplied by the first parameter, and the array is returned:

+ +
function multiply(multiplier, ...theArgs) {
+  return theArgs.map(function(element) {
+    return multiplier * element
+  })
+}
+
+let arr = multiply(2, 1, 2, 3)
+console.log(arr)  // [2, 4, 6]
+
+ +

Array methods can be used on rest parameters, but not on the arguments object:

+ +
function sortRestArgs(...theArgs) {
+  let sortedArgs = theArgs.sort()
+  return sortedArgs
+}
+
+console.log(sortRestArgs(5, 3, 7, 1)) // 1, 3, 5, 7
+
+function sortArguments() {
+  let sortedArgs = arguments.sort()
+  return sortedArgs  // this will never happen
+}
+
+
+console.log(sortArguments(5, 3, 7, 1))
+// throws a TypeError (arguments.sort is not a function)
+
+ +

To use Array methods on the arguments object, it must be converted to a real array first.

+ +
function sortArguments() {
+  let args = Array.from(arguments)
+  let sortedArgs = args.sort()
+  return sortedArgs
+}
+console.log(sortArguments(5, 3, 7, 1))  // 1, 3, 5, 7
+
+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}
+ +

Compatibildiade de navegador

+ + + +

{{Compat("javascript.functions.rest_parameters")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/prototype/index.html b/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/prototype/index.html deleted file mode 100644 index 8a085d6986..0000000000 --- a/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/prototype/index.html +++ /dev/null @@ -1,55 +0,0 @@ ---- -title: AsyncFunction.prototype -slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype -translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype ---- -
{{JSRef}}
- -

A propriedade AsyncFunction.prototype representa o objecto prototype {{jsxref("AsyncFunction")}}.

- -

Description

- -

Os objectos {{jsxref("AsyncFunction")}} são herdados de AsyncFunction.prototype e não podem ser modificados.

- -

Propriedades

- -
-
AsyncFunction.constructor
-
O valor inicial é {{jsxref("AsyncFunction")}}.
-
AsyncFunction.prototype[@@toStringTag]
-
Retorna "AsyncFunction".
-
- -

Especificações

- - - - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ESDraft', '#sec-async-function-constructor-prototype', 'AsyncFunction.prototype')}}{{Spec2('ESDraft')}}Definição inicial ES2017.
- -

Compatibilidade entre navegadores

- -
- - -

{{Compat("javascript.builtins.AsyncFunction.prototype")}}

-
- -

Ver também

- - diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/prototype/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/prototype/index.html deleted file mode 100644 index 9014ecdb24..0000000000 --- a/files/pt-pt/web/javascript/reference/global_objects/number/prototype/index.html +++ /dev/null @@ -1,131 +0,0 @@ ---- -title: Number.prototype -slug: Web/JavaScript/Reference/Global_Objects/Number/prototype -tags: - - JavaScript - - Number - - Property - - Prototype -translation_of: Web/JavaScript/Reference/Global_Objects/Number -translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype ---- -
{{JSRef}}
- -

A propriedade Number.prototype representa o protótipo (prototype) para o constructor de {{jsxref("Number")}}.

- -
{{js_property_attributes(0, 0, 0)}}
- -

Descrição

- -

Todas as instâncias de {{jsxref("Number")}} herdam de Number.prototype. O objecto protótipo (prototype) do constructor de {{jsxref("Number")}} pode ser modificado para afectar todas as instâncias de {{jsxref( "Number")}}.

- -

Propriedades

- -
-
Number.prototype.constructor
-
Retorna a função criadora das instâncias deste objecto. Por predifinição este é o objecto {{jsxref("Number")}}.
-
- -

Métodos

- -
-
{{jsxref("Number.prototype.toExponential()")}}
-
Retorna uma representação em string do número em notação científica.
-
{{jsxref("Number.prototype.toFixed()")}}
-
Retorna uma representação em string do número em notação de ponto fixo.
-
{{jsxref("Number.prototype.toLocaleString()")}}
-
Retorna uma string do número numa representação sensível à linguagem. Faz override do método {{jsxref("Object.prototype.toLocaleString()")}}.
-
{{jsxref("Number.prototype.toPrecision()")}}
-
Retorna uma representação em string do número numa precisão especificada em ponto fixo ou notação científica.
-
{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}
-
Retorna um objecto literal representando o objecto {{jsxref("Number")}} especificado; podes usar este valor para criar um novo objecto. Faz override ao método {{jsxref("Object.prototype.toSource()")}}.
-
{{jsxref("Number.prototype.toString()")}}
-
Retorna uma representação em string do objecto especificado na base especificada. Faz override ao método {{jsxref("Object.prototype.toString()")}}.
-
{{jsxref("Number.prototype.valueOf()")}}
-
Retorna o valor primitivo do objecto especificado. Faz override ao método {{jsxref("Object.prototype.valueOf()")}}.
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Definição Inicial. Implementado em  JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ES6')}} 
- -

Compatibilidade dos browsers

- -
{{CompatibilityTable}}
- -
- - - - - - - - - - - - - - - - - - - -
FuncionalidadeChromeFirefox (Gecko)Internet ExplorerOperaSafari
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FuncionalidadeAndroidChrome para AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Suporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
-
- -

Ver também

- - diff --git a/files/pt-pt/web/javascript/reference/global_objects/object/prototype/index.html b/files/pt-pt/web/javascript/reference/global_objects/object/prototype/index.html deleted file mode 100644 index 411832665a..0000000000 --- a/files/pt-pt/web/javascript/reference/global_objects/object/prototype/index.html +++ /dev/null @@ -1,199 +0,0 @@ ---- -title: Object.prototype -slug: Web/JavaScript/Reference/Global_Objects/Object/prototype -tags: - - JavaScript - - Object - - Objeto - - Propriedade -translation_of: Web/JavaScript/Reference/Global_Objects/Object -translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype ---- -
{{JSRef}}
- -

A propriedade Object.prototype representa o prototype object {{jsxref("Object","Objeto")}} .

- -
{{js_property_attributes(0, 0, 0)}}
- -

Descrição

- -

Nearly all objects in JavaScript are instances of {{jsxref("Object")}}; a typical object inherits properties (including methods) from Object.prototype, although these properties may be shadowed (a.k.a. overridden). However, an Object may be deliberately created for which this is not true (e.g. by {{jsxref("Object.create", "Object.create(null)")}}), or it may be altered so that this is no longer true (e.g. with {{jsxref("Object.setPrototypeOf")}}).

- -

Changes to the Object prototype object are seen by all objects through prototype chaining, unless the properties and methods subject to those changes are overridden further along the prototype chain.  This provides a very powerful although potentially dangerous mechanism to override or extend object behavior.

- -

Propriedades

- -
-
{{jsxref("Object.prototype.constructor")}}
-
Specifies the function that creates an object's prototype.
-
{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}
-
Points to the object which was used as prototype when the object was instantiated.
-
{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}
-
Allows a function to be defined that will be executed when an undefined object member is called as a method.
-
{{jsxref("Object.prototype.count","Object.prototype.__count__")}} {{obsolete_inline}}
-
Used to return the number of enumerable properties directly on a user-defined object, but has been removed.
-
{{jsxref("Object.prototype.parent","Object.prototype.__parent__")}} {{obsolete_inline}}
-
Used to point to an object's context, but has been removed.
-
- -

Métodos

- -
-
{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Associates a function with a property that, when accessed, executes that function and returns its return value.
-
{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Associates a function with a property that, when set, executes that function which modifies the property.
-
{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Returns the function associated with the specified property by the {{jsxref("Object.prototype.__defineGetter__()", "__defineGetter__()")}} method.
-
{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
-
Returns the function associated with the specified property by the {{jsxref("Object.prototype.__defineSetter__()", "__defineSetter__()")}} method.
-
{{jsxref("Object.prototype.hasOwnProperty()")}}
-
Returns a boolean indicating whether an object contains the specified property as a direct property of that object and not inherited through the prototype chain.
-
{{jsxref("Object.prototype.isPrototypeOf()")}}
-
Returns a boolean indicating whether the object this method is called upon is in the prototype chain of the specified object.
-
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
-
Returns a boolean indicating if the internal ECMAScript [[Enumerable]] attribute is set.
-
{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
-
Returns string containing the source of an object literal representing the object that this method is called upon; you can use this value to create a new object.
-
{{jsxref("Object.prototype.toLocaleString()")}}
-
Calls {{jsxref("Object.toString", "toString()")}}.
-
{{jsxref("Object.prototype.toString()")}}
-
Returns a string representation of the object.
-
{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}
-
Removes a watchpoint from a property of the object.
-
{{jsxref("Object.prototype.valueOf()")}}
-
Returns the primitive value of the specified object.
-
{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}
-
Adds a watchpoint to a property of the object.
-
{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}
-
Used to evaluate a string of JavaScript code in the context of the specified object, but has been removed.
-
- -

Exemplos

- -

When altering the behavior of existing Object.prototype methods, consider injecting code by wrapping your extension before or after the existing logic.  For example, this (untested) code will pre-conditionally execute custom logic before the built-in logic or someone else's extension is executed.

- -

When a function is called, the arguments to the call are held in the array-like "variable" arguments. For example, in the call "myFn(a, b, c)", the arguments within myFn's body will contain 3 array-like elements corresponding to (a, b, c).  When modifying prototypes with hooks, simply pass this & the arguments (the call state) to the current behavior by calling apply() on the function.  This pattern can be used for any prototype, such as Node.prototype, Function.prototype, etc.

- -
var current = Object.prototype.valueOf;
-
-// Since my property "-prop-value" is cross-cutting and isn't always
-// on the same prototype chain, I want to modify Object.prototype:
-Object.prototype.valueOf = function() {
-  if (this.hasOwnProperty('-prop-value')) {
-    return this['-prop-value'];
-  } else {
-    // It doesn't look like one of my objects, so let's fall back on
-    // the default behavior by reproducing the current behavior as best we can.
-    // The apply behaves like "super" in some other languages.
-    // Even though valueOf() doesn't take arguments, some other hook may.
-    return current.apply(this, arguments);
-  }
-}
-
- -

Since JavaScript doesn't exactly have sub-class objects, prototype is a useful workaround to make a “base class” object of certain functions that act as objects. For example:

- -
var Person = function(name) {
-  this.name = name;
-  this.canTalk = true;
-};
-
-Person.prototype.greet = function() {
-  if (this.canTalk) {
-    console.log('Hi, I am ' + this.name);
-  }
-};
-
-var Employee = function(name, title) {
-  Person.call(this, name);
-  this.title = title;
-};
-
-Employee.prototype = Object.create(Person.prototype);
-
-Employee.prototype.greet = function() {
-  if (this.canTalk) {
-    console.log('Hi, I am ' + this.name + ', the ' + this.title);
-  }
-};
-
-var Customer = function(name) {
-  Person.call(this, name);
-};
-
-Customer.prototype = Object.create(Person.prototype);
-
-var Mime = function(name) {
-  Person.call(this, name);
-  this.canTalk = false;
-};
-
-Mime.prototype = Object.create(Person.prototype);
-
-var bob = new Employee('Bob', 'Builder');
-var joe = new Customer('Joe');
-var rg = new Employee('Red Green', 'Handyman');
-var mike = new Customer('Mike');
-var mime = new Mime('Mime');
-
-bob.greet();
-// Hi, I am Bob, the Builder
-
-joe.greet();
-// Hi, I am Joe
-
-rg.greet();
-// Hi, I am Red Green, the Handyman
-
-mike.greet();
-// Hi, I am Mike
-
-mime.greet();
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ESDraft')}} 
- -

Compatibilidade de navegador

- -
- - -

{{Compat("javascript.builtins.Object.prototype")}}

-
- -

Consultar também

- - diff --git "a/files/pt-pt/web/javascript/reference/operadores/fun\303\247\303\243o/index.html" "b/files/pt-pt/web/javascript/reference/operadores/fun\303\247\303\243o/index.html" deleted file mode 100644 index 450183b727..0000000000 --- "a/files/pt-pt/web/javascript/reference/operadores/fun\303\247\303\243o/index.html" +++ /dev/null @@ -1,139 +0,0 @@ ---- -title: Expressão função (Function expression) -slug: Web/JavaScript/Reference/Operadores/função -tags: - - Expressões Primárias - - Funiconaldiade de Linguagem - - Função - - JavaScript - - Operador -translation_of: Web/JavaScript/Reference/Operators/function ---- -
{{jsSidebar("Operators")}}
- -

A palavra-chave function  pode ser utilziada para definir uma função dentro de uma expressão.

- -

You can also define functions using the Function constructor and a function declaration.

- -
{{EmbedInteractiveExample("pages/js/expressions-functionexpression.html", "shorter")}}
- - - -

Sintaxe

- -
let myFunction = function [name]([param1[, param2[, ..., paramN]]]) {
-   statements
-};
- -

As of ES2015, you can also use {{jsxref("Functions/Arrow_functions", "arrow functions")}}.

- -

Parâmetros

- -
-
name {{optional_inline}}
-
The function name. Can be omitted, in which case the function is anonymous. The name is only local to the function body.
-
paramN {{optional_inline}}
-
The name of an argument to be passed to the function.
-
statements {{optional_inline}}
-
The statements which comprise the body of the function.
-
- -

Descrição

- -

A function expression is very similar to and has almost the same syntax as a function declaration (see {{jsxref("Statements/function", "function statement")}} for details). The main difference between a function expression and a function declaration is the function name, which can be omitted in function expressions to create anonymous functions. A function expression can be used as an IIFE (Immediately Invoked Function Expression) which runs as soon as it is defined. See also the chapter about {{jsxref("Functions", "functions")}} for more information.

- -

Function expression hoisting

- -

Function expressions in JavaScript are not hoisted, unlike {{jsxref("Statements/function", "function declarations", "#Function_declaration_hoisting")}}. You can't use function expressions before you define them:

- -
console.log(notHoisted) // undefined
-//  even though the variable name is hoisted, the definition isn't. so it's undefined.
-notHoisted(); // TypeError: notHoisted is not a function
-
-var notHoisted = function() {
-   console.log('bar');
-};
-
- -

Named function expression

- -

If you want to refer to the current function inside the function body, you need to create a named function expression. This name is then local only to the function body (scope). This also avoids using the non-standard {{jsxref("Functions/arguments/callee", "arguments.callee")}} property.

- -
let math = {
-  'factit': function factorial(n) {
-    console.log(n)
-    if (n <= 1) {
-      return 1;
-    }
-    return n * factorial(n - 1);
-  }
-};
-
-math.factit(3) //3;2;1;
-
- -

The variable the function expression is assigned to will have a name property. The name doesn't change if it's assigned to a different variable. If function name is omitted, it will be the variable name (implicit name). If function name is present, it will be the function name (explicit name). This also applies to {{jsxref("Functions/Arrow_functions", "arrow functions")}} (arrows don't have a name so you can only give the variable an implicit name).

- -
var foo = function() {}
-foo.name // "foo"
-
-var foo2 = foo
-foo2.name // "foo"
-
-var bar = function baz() {}
-bar.name // "baz"
-
-console.log(foo === foo2); // true
-console.log(typeof baz); // undefined
-console.log(bar === baz); // false (errors because baz == undefined)
-
- -

Exemplos

- -

The following example defines an unnamed function and assigns it to x. The function returns the square of its argument:

- -
var x = function(y) {
-   return y * y;
-};
-
- -

More commonly it is used as a callback:

- -
button.addEventListener('click', function(event) {
-    console.log('button is clicked!')
-})
- -

Especificações

- - - - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.operators.function")}}

- -

Consulte também 

- - diff --git a/files/pt-pt/web/javascript/reference/operadores/index.html b/files/pt-pt/web/javascript/reference/operadores/index.html deleted file mode 100644 index 02a550b7b0..0000000000 --- a/files/pt-pt/web/javascript/reference/operadores/index.html +++ /dev/null @@ -1,309 +0,0 @@ ---- -title: Expressões e operadores -slug: Web/JavaScript/Reference/Operadores -tags: - - JavaScript - - Operadores - - Página Landing - - Resumo - - Sinopse -translation_of: Web/JavaScript/Reference/Operators ---- -
{{jsSidebar("Operators")}}
- -

Este capítulo documenta todos os operadores, expressões e palavras-chave da linguagem JavaScript.

- -

Expressões e operadores por categoria

- -

For an alphabetical listing see the sidebar on the left.

- -

Expressões primárias

- -

Basic keywords and general expressions in JavaScript.

- -
-
{{JSxRef("Operators/this", "this")}}
-
The this keyword refers to a special property of an execution context.
-
{{JSxRef("Operators/function", "function")}}
-
The function keyword defines a function expression.
-
{{JSxRef("Operators/class", "class")}}
-
The class keyword defines a class expression.
-
{{JSxRef("Operators/function*", "function*")}}
-
The function* keyword defines a generator function expression.
-
{{JSxRef("Operators/yield", "yield")}}
-
Pause and resume a generator function.
-
{{JSxRef("Operators/yield*", "yield*")}}
-
Delegate to another generator function or iterable object.
-
{{JSxRef("Operators/async_function", "async function")}}
-
The async function defines an async function expression.
-
{{JSxRef("Operators/await", "await")}}
-
Pause and resume an async function and wait for the promise's resolution/rejection.
-
{{JSxRef("Global_Objects/Array", "[]")}}
-
Array initializer/literal syntax.
-
{{JSxRef("Operators/Object_initializer", "{}")}}
-
Object initializer/literal syntax.
-
{{JSxRef("Global_Objects/RegExp", "/ab+c/i")}}
-
Regular expression literal syntax.
-
{{JSxRef("Operators/Grouping", "( )")}}
-
Grouping operator.
-
- -

Expressões "Left-hand-side"

- -

Left values are the destination of an assignment.

- -
-
{{jsxref("Operators/Property_accessors", "Property accessors", "", 1)}}
-
Member operators provide access to a property or method of an object
- (object.property and object["property"]).
-
{{jsxref("Operators/new", "new")}}
-
The new operator creates an instance of a constructor.
-
new.target
-
In constructors, new.target refers to the constructor that was invoked by {{jsxref("Operators/new", "new")}}.
-
{{jsxref("Operators/super", "super")}}
-
The super keyword calls the parent constructor.
-
{{jsxref("Operators/Spread_operator", "...obj")}}
-
The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.
-
- -

Aumento e diminuição

- -

Postfix/prefix increment and postfix/prefix decrement operators.

- -
-
{{jsxref("Operators/Arithmetic_Operators", "A++", "#Increment")}}
-
Postfix increment operator.
-
{{jsxref("Operators/Arithmetic_Operators", "A--", "#Decrement")}}
-
Postfix decrement operator.
-
{{jsxref("Operators/Arithmetic_Operators", "++A", "#Increment")}}
-
Prefix increment operator.
-
{{jsxref("Operators/Arithmetic_Operators", "--A", "#Decrement")}}
-
Prefix decrement operator.
-
- -

Operadores unários

- -

A unary operation is operation with only one operand.

- -
-
{{jsxref("Operators/delete", "delete")}}
-
The delete operator deletes a property from an object.
-
{{jsxref("Operators/void", "void")}}
-
The void operator discards an expression's return value.
-
{{jsxref("Operators/typeof", "typeof")}}
-
The typeof operator determines the type of a given object.
-
{{jsxref("Operators/Arithmetic_Operators", "+", "#Unary_plus")}}
-
The unary plus operator converts its operand to Number type.
-
{{jsxref("Operators/Arithmetic_Operators", "-", "#Unary_negation")}}
-
The unary negation operator converts its operand to Number type and then negates it.
-
{{jsxref("Operators/Bitwise_Operators", "~", "#Bitwise_NOT")}}
-
Bitwise NOT operator.
-
{{jsxref("Operators/Logical_Operators", "!", "#Logical_NOT")}}
-
Logical NOT operator.
-
- -

Operadores de aritmética

- -

Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.

- -
-
{{jsxref("Operators/Arithmetic_Operators", "+", "#Addition")}}
-
Addition operator.
-
{{jsxref("Operators/Arithmetic_Operators", "-", "#Subtraction")}}
-
Subtraction operator.
-
{{jsxref("Operators/Arithmetic_Operators", "/", "#Division")}}
-
Division operator.
-
{{jsxref("Operators/Arithmetic_Operators", "*", "#Multiplication")}}
-
Multiplication operator.
-
{{jsxref("Operators/Arithmetic_Operators", "%", "#Remainder")}}
-
Remainder operator.
-
- -
-
{{JSxRef("Operators/Arithmetic_Operators", "**", "#Exponentiation")}}
-
Exponentiation operator.
-
- -

Operadores relacionais

- -

A comparison operator compares its operands and returns a Boolean value based on whether the comparison is true.

- -
-
{{jsxref("Operators/in", "in")}}
-
The in operator determines whether an object has a given property.
-
{{jsxref("Operators/instanceof", "instanceof")}}
-
The instanceof operator determines whether an object is an instance of another object.
-
{{jsxref("Operators/Comparison_Operators", "<", "#Less_than_operator")}}
-
Less than operator.
-
{{jsxref("Operators/Comparison_Operators", ">", "#Greater_than_operator")}}
-
Greater than operator.
-
{{jsxref("Operators/Comparison_Operators", "<=", "#Less_than_or_equal_operator")}}
-
Less than or equal operator.
-
{{jsxref("Operators/Comparison_Operators", ">=", "#Greater_than_or_equal_operator")}}
-
Greater than or equal operator.
-
- -
-

Nota: => não é um operador, mas a notação para funções seta (arrow).

-
- -

Operadores de equality

- -

The result of evaluating an equality operator is always of type Boolean based on whether the comparison is true.

- -
-
{{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}
-
Equality operator.
-
{{jsxref("Operators/Comparison_Operators", "!=", "#Inequality")}}
-
Inequality operator.
-
{{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}
-
Identity operator.
-
{{jsxref("Operators/Comparison_Operators", "!==", "#Nonidentity")}}
-
Nonidentity operator.
-
- -

Bitwise shift operators

- -

Operations to shift all bits of the operand.

- -
-
{{jsxref("Operators/Bitwise_Operators", "<<", "#Left_shift")}}
-
Bitwise left shift operator.
-
{{jsxref("Operators/Bitwise_Operators", ">>", "#Right_shift")}}
-
Bitwise right shift operator.
-
{{jsxref("Operators/Bitwise_Operators", ">>>", "#Unsigned_right_shift")}}
-
Bitwise unsigned right shift operator.
-
- -

Operadores de binário bitwise

- -

Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.

- -
-
{{jsxref("Operators/Bitwise_Operators", "&", "#Bitwise_AND")}}
-
Bitwise AND.
-
{{jsxref("Operators/Bitwise_Operators", "|", "#Bitwise_OR")}}
-
Bitwise OR.
-
{{jsxref("Operators/Bitwise_Operators", "^", "#Bitwise_XOR")}}
-
Bitwise XOR.
-
- -

Operadores de binário logical

- -

Logical operators are typically used with boolean (logical) values, and when they are, they return a boolean value.

- -
-
{{jsxref("Operators/Logical_Operators", "&&", "#Logical_AND")}}
-
Logical AND.
-
{{jsxref("Operators/Logical_Operators", "||", "#Logical_OR")}}
-
Logical OR.
-
- -

Operdor condicional (ternário)

- -
-
{{jsxref("Operators/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}
-
-

The conditional operator returns one of two values based on the logical value of the condition.

-
-
- -

Operadores de Assignment

- -

An assignment operator assigns a value to its left operand based on the value of its right operand.

- -
-
{{jsxref("Operators/Assignment_Operators", "=", "#Assignment")}}
-
Assignment operator.
-
{{jsxref("Operators/Assignment_Operators", "*=", "#Multiplication_assignment")}}
-
Multiplication assignment.
-
{{jsxref("Operators/Assignment_Operators", "/=", "#Division_assignment")}}
-
Division assignment.
-
{{jsxref("Operators/Assignment_Operators", "%=", "#Remainder_assignment")}}
-
Remainder assignment.
-
{{jsxref("Operators/Assignment_Operators", "+=", "#Addition_assignment")}}
-
Addition assignment.
-
{{jsxref("Operators/Assignment_Operators", "-=", "#Subtraction_assignment")}}
-
Subtraction assignment
-
{{jsxref("Operators/Assignment_Operators", "<<=", "#Left_shift_assignment")}}
-
Left shift assignment.
-
{{jsxref("Operators/Assignment_Operators", ">>=", "#Right_shift_assignment")}}
-
Right shift assignment.
-
{{jsxref("Operators/Assignment_Operators", ">>>=", "#Unsigned_right_shift_assignment")}}
-
Unsigned right shift assignment.
-
{{jsxref("Operators/Assignment_Operators", "&=", "#Bitwise_AND_assignment")}}
-
Bitwise AND assignment.
-
{{jsxref("Operators/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}
-
Bitwise XOR assignment.
-
{{jsxref("Operators/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}
-
Bitwise OR assignment.
-
{{jsxref("Operators/Destructuring_assignment", "[a, b] = [1, 2]")}}
- {{jsxref("Operators/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}
-
-

Destructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.

-
-
- -

Operador de aspas

- -
-
{{jsxref("Operators/Comma_Operator", ",")}}
-
The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.
-
- -

Funcionalidades não padrão

- -
-
{{non-standard_inline}} {{jsxref("Operators/Legacy_generator_function", "Legacy generator function", "", 1)}}
-
The function keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one {{jsxref("Operators/yield", "yield")}} expression.
-
{{non-standard_inline}} {{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}}
-
The expression closure syntax is a shorthand for writing simple function.
-
{{non-standard_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}
-
Array comprehensions.
-
{{non-standard_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}
-
Generator comprehensions.
-
- -

Especificações

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EspecificaçãoEstadoComentário
{{SpecName('ES1', '#sec-11', 'Expressions')}}{{Spec2('ES1')}}Initial definition
{{SpecName('ES5.1', '#sec-11', 'Expressions')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ES6')}}New: Spread operator, destructuring assignment, super keyword.
{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ESDraft')}}
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.operators")}}

- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/reference/operadores/operador_virgula/index.html b/files/pt-pt/web/javascript/reference/operadores/operador_virgula/index.html deleted file mode 100644 index e797f92953..0000000000 --- a/files/pt-pt/web/javascript/reference/operadores/operador_virgula/index.html +++ /dev/null @@ -1,94 +0,0 @@ ---- -title: Operador Vírgula -slug: Web/JavaScript/Reference/Operadores/Operador_virgula -tags: - - Composto - - Expressão - - Funcionalidade de Linguagem - - JavaScript - - Operador - - Referencia - - Vírgula -translation_of: Web/JavaScript/Reference/Operators/Comma_Operator ---- -
Operador {{jsSidebar("Operators")}}
- -

O operador vírgula (,) avalia cada um dos seus operandos (da esquerda para a direita) e devolve o valor do último operando. This lets you create a compound expression in which multiple expressions are evaluated, with the compound expression's final value being the value of the rightmost of its member expressions. This is commonly used to provide multiple parameters to a for loop.

- -
{{EmbedInteractiveExample("pages/js/expressions-commaoperators.html")}}
- - - -

Sintaxe

- -
expr1, expr2, expr3...
- -

Parâmetros

- -
-
expr1, expr2, expr3...
-
One or more expressions, the last of which is returned as the value of the compound expression.
-
- -

Notas de utilização

- -

You can use the comma operator when you want to include multiple expressions in a location that requires a single expression. The most common usage of this operator is to supply multiple parameters in a for loop.

- -

The comma operator is fully different from the comma within arrays, objects, and function arguments and parameters.

- -

Exemplos

- -

If a is a 2-dimensional array with 10 elements on each side, the following code uses the comma operator to increment i and decrement j at once.

- -

The following code prints the values of the diagonal elements in the array:

- -
for (var i = 0, j = 9; i <= 9; i++, j--)
-  console.log('a[' + i + '][' + j + '] = ' + a[i][j]);
- -

Note that the comma operators in assignments may appear not to have the normal effect of comma operators because they don't exist within an expression. In the following example, a is set to the value of b = 3 (which is 3), but the c = 4 expression still evaluates and its result returned to console (i.e., 4). This is due to operator precedence and associativity.

- -
var a, b, c;
-
-a = b = 3, c = 4; // Returns 4 in console
-console.log(a); // 3 (left-most)
-
-var x, y, z;
-
-x = (y = 5, z = 6); // Returns 6 in console
-console.log(x); // 6 (right-most)
-
- -

Processing and then returning

- -

Another example that one could make with comma operator is processing before returning. As stated, only the last element will be returned but all others are going to be evaluated as well. So, one could do:

- -
function myFunc() {
-  var x = 0;
-
-  return (x += 1, x); // the same as return ++x;
-}
- -

Especificações

- - - - - - - - - - -
Especificação
{{SpecName('ESDraft', '#sec-comma-operator', 'Comma operator')}}
- -

Compatibilidade de navegador

- - - -

{{Compat("javascript.operators.comma")}}

- -

Consulte também

- - diff --git a/files/pt-pt/web/javascript/reference/operadores/precedencia_operador/index.html b/files/pt-pt/web/javascript/reference/operadores/precedencia_operador/index.html deleted file mode 100644 index 03d4345410..0000000000 --- a/files/pt-pt/web/javascript/reference/operadores/precedencia_operador/index.html +++ /dev/null @@ -1,461 +0,0 @@ ---- -title: Precedência de operador -slug: Web/JavaScript/Reference/Operadores/Precedencia_operador -tags: - - Guía - - JavaScript - - precedência -translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence ---- -
{{jsSidebar("Operators")}}
- -

A precedência de operador determina a maneira pela qual os operadores são analisados ​​em relação a cada um. Os operadores com maior precedência tornam-se operandos dos operadores com menor precedência..

- -
{{EmbedInteractiveExample("pages/js/expressions-operatorprecedence.html")}}
- - - -

Precedência e Associabilidade

- -

Consider an expression describable by the representation below. Note that both OP1 and OP2 are fill-in-the-blanks for OPerators.

- -
a OP b OP c
-
- -

If OP1 and OP2 have different precedence levels (see the table below), the operator with the highest precedence goes first and associativity does not matter. Observe how multiplication has higher associativity than addition and executed first, even though addition is written first in the code.

- -
console.log(3 + 10 * 2);   // logs 23
-console.log(3 + (10 * 2)); // logs 23 because parentheses here are superfluous
-console.log((3 + 10) * 2); // logs 26 because the parentheses change the order
- -

Left-associativity (left-to-right) means that it is processed as (a OP1 b) OP2 c, while right-associativity (right-to-left) means it is interpreted as a OP1 (b OP2 c). Assignment operators are right-associative, so you can write:

- -
a = b = 5; // same as writing a = (b = 5);
-
- -

with the expected result that a and b get the value 5. This is because the assignment operator returns the value that is assigned. First, b is set to 5. Then the a is also set to 5, the return value of b = 5, aka right operand of the assignment.

- -

As another example, the unique exponentiation operator has right-associativity, whereas other arithmetic operators have left-associativity. It is interesting to note that, the order of evaluation is always left-to-right irregardless of associativity.

- - - - - - - - - - - - - - - - -
CódigoResultado
- 
-function echo(name, num) {
-    console.log("Evaluating the " + name + " side");
-    return num;
-}
-// Notice the division operator (/)
-console.log(echo("left", 6) / echo("right", 2));
-
- 		- 
-Evaluating the left side
-Evaluating the right side
-3
-
-
- 
-function echo(name, num) {
-    console.log("Evaluating the " + name + " side");
-    return num;
-}
-// Notice the exponentiation operator (**)
-console.log(echo("left", 2) ** echo("right", 3));
- 		- 
-Evaluating the left side
-Evaluating the right side
-8
-
- -

The difference in associativity comes into play when there are multiple operators of the same precedence. With only one operator or operators of different precedences, associativity does affect the output, as seen in the example above. In the example below, observe how associativity affects the output when multiple of the same operator are used.

- - - - - - - - - - - - - - - - - - - - -
CódigoResultado
- 
-function echo(name, num) {
-    console.log("Evaluating the " + name + " side");
-    return num;
-}
-// Notice the division operator (/)
-console.log(echo("left", 6) / echo("middle", 2) / echo("right", 3));
-
- 		- 
-Evaluating the left side
-Evaluating the middle side
-Evaluating the right side
-1
-
-
- 
-function echo(name, num) {
-    console.log("Evaluating the " + name + " side");
-    return num;
-}
-// Notice the exponentiation operator (**)
-console.log(echo("left", 2) ** echo("middle", 3) ** echo("right", 2));
-
- 		- 
-Evaluating the left side
-Evaluating the middle side
-Evaluating the right side
-512
-
-
- 
-function echo(name, num) {
-    console.log("Evaluating the " + name + " side");
-    return num;
-}
-// Notice the parentheses around the left and middle exponentiation
-console.log((echo("left", 2) ** echo("middle", 3)) ** echo("right", 2));
- 		- 
-Evaluating the left side
-Evaluating the middle side
-Evaluating the right side
-64
-
- -

Looking at the code snippets above, 6 / 3 / 2 is the same as (6 / 3) / 2 because division is left-associative. Exponentiation, on the other hand, is right-associative, so 2 ** 3 ** 2 is the same as 2 ** (3 ** 2). Thus, doing (2 ** 3) ** 2 changes the order and results in the 64 seen in the table above.

- -

Remember that precedence comes before associativity. So, mixing division and exponentiation, the exponentiation comes before the division. For example, 2 ** 3 / 3 ** 2 results in 0.8888888888888888 because it is the same as (2 ** 3) / (3 ** 2).

- -

Note on Grouping and Short-Circuiting

- -

In the table below, Grouping is listed as having the highest precedence. However, that does not always mean the expression within the grouping symbols ( … ) is evaluated first, especially when it comes to short-circuiting.

- -

Short-circuiting is jargon for conditional evaluation. For example, in the expression a && (b + c), if a is “falsy”, then the sub-expression (b + c) will not even get evaluated, even if it is in parentheses. We could say that the logical disjunction operator (“OR”) is “short-circuited”. Along with logical disjunction, other short-circuited operators include logical conjunction (“AND”), nullish-coalescing, optional chaining, and the conditional operator. Some more examples follow.

- -
a || (b * c);  // evaluate `a` first, then produce `a` if `a` is “truthy”
-a && (b < c);  // evaluate `a` first, then produce `a` if `a` is “falsy”
-a ?? (b || c); // evaluate `a` first, then produce `a` if `a` is not `null` and not `undefined`
-a?.b.c;        // evaluate `a` first, then produce `a` if `a` is `null` or `undefined`
-
- -

Exemplos

- -
3 > 2 && 2 > 1
-// returns true
-
-3 > 2 > 1
-// Returns false because 3 > 2 is true, then true is converted to 1 in inequality operators, therefore true > 1 becomes 1 > 1, which
-//  is false. Adding parentheses makes things clear: (3 > 2) > 1.
-
-
- -

Tabela

- -

The following table is ordered from highest (20) to lowest (1) precedence.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
PrecedênciaTipo de operador (Operator)AssociatividadeOperadores individuais
20{{jsxref("Operators/Grouping", "Grouping")}}n/a( … )
19{{jsxref("Operators/Property_Accessors", "Member Access", "#Dot_notation")}}left-to-right… . …
{{jsxref("Operators/Property_Accessors", "Computed Member Access","#Bracket_notation")}}left-to-right… [ … ]
{{jsxref("Operators/new","new")}} (with argument list)n/anew … ( … )
Function Callleft-to-right… ( … )
18{{jsxref("Operators/new","new")}} (without argument list)right-to-leftnew …
17{{jsxref("Operators/Arithmetic_Operators","Postfix Increment","#Increment")}}n/a… ++
{{jsxref("Operators/Arithmetic_Operators","Postfix Decrement","#Decrement")}}… --
16Logical NOTright-to-left! …
Bitwise NOT~ …
Unary Plus+ …
Unary Negation- …
Prefix Increment++ …
Prefix Decrement-- …
typeoftypeof …
voidvoid …
deletedelete …
awaitawait …
15Exponentiationright-to-left… ** …
14Multiplicationleft-to-right… * …
Division… / …
Remainder… % …
13Additionleft-to-right… + …
Subtraction… - …
12Bitwise Left Shiftleft-to-right… << …
Bitwise Right Shift… >> …
Bitwise Unsigned Right Shift… >>> …
11Less Thanleft-to-right… < …
Less Than Or Equal… <= …
Greater Than… > …
Greater Than Or Equal… >= …
in… in …
instanceof… instanceof …
10Equalityleft-to-right… == …
Inequality… != …
Strict Equality… === …
Strict Inequality… !== …
9Bitwise ANDleft-to-right… & …
8Bitwise XORleft-to-right… ^ …
7Bitwise ORleft-to-right… | …
6Logical ANDleft-to-right… && …
5Logical ORleft-to-right… || …
4Conditionalright-to-left… ? … : …
3Assignmentright-to-left… = …
… += …
… -= …
… **= …
… *= …
… /= …
… %= …
… <<= …
… >>= …
… >>>= …
… &= …
… ^= …
… |= …
2{{jsxref("Operators/yield", "yield")}}right-to-leftyield …
{{jsxref("Operators/yield*", "yield*")}}yield* …
1Vírgula / Sequêncialeft-to-right… , …
diff --git a/files/pt-pt/web/javascript/reference/operators/comma_operator/index.html b/files/pt-pt/web/javascript/reference/operators/comma_operator/index.html new file mode 100644 index 0000000000..e797f92953 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/operators/comma_operator/index.html @@ -0,0 +1,94 @@ +--- +title: Operador Vírgula +slug: Web/JavaScript/Reference/Operadores/Operador_virgula +tags: + - Composto + - Expressão + - Funcionalidade de Linguagem + - JavaScript + - Operador + - Referencia + - Vírgula +translation_of: Web/JavaScript/Reference/Operators/Comma_Operator +--- +
Operador {{jsSidebar("Operators")}}
+ +

O operador vírgula (,) avalia cada um dos seus operandos (da esquerda para a direita) e devolve o valor do último operando. This lets you create a compound expression in which multiple expressions are evaluated, with the compound expression's final value being the value of the rightmost of its member expressions. This is commonly used to provide multiple parameters to a for loop.

+ +
{{EmbedInteractiveExample("pages/js/expressions-commaoperators.html")}}
+ + + +

Sintaxe

+ +
expr1, expr2, expr3...
+ +

Parâmetros

+ +
+
expr1, expr2, expr3...
+
One or more expressions, the last of which is returned as the value of the compound expression.
+
+ +

Notas de utilização

+ +

You can use the comma operator when you want to include multiple expressions in a location that requires a single expression. The most common usage of this operator is to supply multiple parameters in a for loop.

+ +

The comma operator is fully different from the comma within arrays, objects, and function arguments and parameters.

+ +

Exemplos

+ +

If a is a 2-dimensional array with 10 elements on each side, the following code uses the comma operator to increment i and decrement j at once.

+ +

The following code prints the values of the diagonal elements in the array:

+ +
for (var i = 0, j = 9; i <= 9; i++, j--)
+  console.log('a[' + i + '][' + j + '] = ' + a[i][j]);
+ +

Note that the comma operators in assignments may appear not to have the normal effect of comma operators because they don't exist within an expression. In the following example, a is set to the value of b = 3 (which is 3), but the c = 4 expression still evaluates and its result returned to console (i.e., 4). This is due to operator precedence and associativity.

+ +
var a, b, c;
+
+a = b = 3, c = 4; // Returns 4 in console
+console.log(a); // 3 (left-most)
+
+var x, y, z;
+
+x = (y = 5, z = 6); // Returns 6 in console
+console.log(x); // 6 (right-most)
+
+ +

Processing and then returning

+ +

Another example that one could make with comma operator is processing before returning. As stated, only the last element will be returned but all others are going to be evaluated as well. So, one could do:

+ +
function myFunc() {
+  var x = 0;
+
+  return (x += 1, x); // the same as return ++x;
+}
+ +

Especificações

+ + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-comma-operator', 'Comma operator')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.operators.comma")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/operators/function/index.html b/files/pt-pt/web/javascript/reference/operators/function/index.html new file mode 100644 index 0000000000..450183b727 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/operators/function/index.html @@ -0,0 +1,139 @@ +--- +title: Expressão função (Function expression) +slug: Web/JavaScript/Reference/Operadores/função +tags: + - Expressões Primárias + - Funiconaldiade de Linguagem + - Função + - JavaScript + - Operador +translation_of: Web/JavaScript/Reference/Operators/function +--- +
{{jsSidebar("Operators")}}
+ +

A palavra-chave function  pode ser utilziada para definir uma função dentro de uma expressão.

+ +

You can also define functions using the Function constructor and a function declaration.

+ +
{{EmbedInteractiveExample("pages/js/expressions-functionexpression.html", "shorter")}}
+ + + +

Sintaxe

+ +
let myFunction = function [name]([param1[, param2[, ..., paramN]]]) {
+   statements
+};
+ +

As of ES2015, you can also use {{jsxref("Functions/Arrow_functions", "arrow functions")}}.

+ +

Parâmetros

+ +
+
name {{optional_inline}}
+
The function name. Can be omitted, in which case the function is anonymous. The name is only local to the function body.
+
paramN {{optional_inline}}
+
The name of an argument to be passed to the function.
+
statements {{optional_inline}}
+
The statements which comprise the body of the function.
+
+ +

Descrição

+ +

A function expression is very similar to and has almost the same syntax as a function declaration (see {{jsxref("Statements/function", "function statement")}} for details). The main difference between a function expression and a function declaration is the function name, which can be omitted in function expressions to create anonymous functions. A function expression can be used as an IIFE (Immediately Invoked Function Expression) which runs as soon as it is defined. See also the chapter about {{jsxref("Functions", "functions")}} for more information.

+ +

Function expression hoisting

+ +

Function expressions in JavaScript are not hoisted, unlike {{jsxref("Statements/function", "function declarations", "#Function_declaration_hoisting")}}. You can't use function expressions before you define them:

+ +
console.log(notHoisted) // undefined
+//  even though the variable name is hoisted, the definition isn't. so it's undefined.
+notHoisted(); // TypeError: notHoisted is not a function
+
+var notHoisted = function() {
+   console.log('bar');
+};
+
+ +

Named function expression

+ +

If you want to refer to the current function inside the function body, you need to create a named function expression. This name is then local only to the function body (scope). This also avoids using the non-standard {{jsxref("Functions/arguments/callee", "arguments.callee")}} property.

+ +
let math = {
+  'factit': function factorial(n) {
+    console.log(n)
+    if (n <= 1) {
+      return 1;
+    }
+    return n * factorial(n - 1);
+  }
+};
+
+math.factit(3) //3;2;1;
+
+ +

The variable the function expression is assigned to will have a name property. The name doesn't change if it's assigned to a different variable. If function name is omitted, it will be the variable name (implicit name). If function name is present, it will be the function name (explicit name). This also applies to {{jsxref("Functions/Arrow_functions", "arrow functions")}} (arrows don't have a name so you can only give the variable an implicit name).

+ +
var foo = function() {}
+foo.name // "foo"
+
+var foo2 = foo
+foo2.name // "foo"
+
+var bar = function baz() {}
+bar.name // "baz"
+
+console.log(foo === foo2); // true
+console.log(typeof baz); // undefined
+console.log(bar === baz); // false (errors because baz == undefined)
+
+ +

Exemplos

+ +

The following example defines an unnamed function and assigns it to x. The function returns the square of its argument:

+ +
var x = function(y) {
+   return y * y;
+};
+
+ +

More commonly it is used as a callback:

+ +
button.addEventListener('click', function(event) {
+    console.log('button is clicked!')
+})
+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.operators.function")}}

+ +

Consulte também 

+ + diff --git a/files/pt-pt/web/javascript/reference/operators/index.html b/files/pt-pt/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..02a550b7b0 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/operators/index.html @@ -0,0 +1,309 @@ +--- +title: Expressões e operadores +slug: Web/JavaScript/Reference/Operadores +tags: + - JavaScript + - Operadores + - Página Landing + - Resumo + - Sinopse +translation_of: Web/JavaScript/Reference/Operators +--- +
{{jsSidebar("Operators")}}
+ +

Este capítulo documenta todos os operadores, expressões e palavras-chave da linguagem JavaScript.

+ +

Expressões e operadores por categoria

+ +

For an alphabetical listing see the sidebar on the left.

+ +

Expressões primárias

+ +

Basic keywords and general expressions in JavaScript.

+ +
+
{{JSxRef("Operators/this", "this")}}
+
The this keyword refers to a special property of an execution context.
+
{{JSxRef("Operators/function", "function")}}
+
The function keyword defines a function expression.
+
{{JSxRef("Operators/class", "class")}}
+
The class keyword defines a class expression.
+
{{JSxRef("Operators/function*", "function*")}}
+
The function* keyword defines a generator function expression.
+
{{JSxRef("Operators/yield", "yield")}}
+
Pause and resume a generator function.
+
{{JSxRef("Operators/yield*", "yield*")}}
+
Delegate to another generator function or iterable object.
+
{{JSxRef("Operators/async_function", "async function")}}
+
The async function defines an async function expression.
+
{{JSxRef("Operators/await", "await")}}
+
Pause and resume an async function and wait for the promise's resolution/rejection.
+
{{JSxRef("Global_Objects/Array", "[]")}}
+
Array initializer/literal syntax.
+
{{JSxRef("Operators/Object_initializer", "{}")}}
+
Object initializer/literal syntax.
+
{{JSxRef("Global_Objects/RegExp", "/ab+c/i")}}
+
Regular expression literal syntax.
+
{{JSxRef("Operators/Grouping", "( )")}}
+
Grouping operator.
+
+ +

Expressões "Left-hand-side"

+ +

Left values are the destination of an assignment.

+ +
+
{{jsxref("Operators/Property_accessors", "Property accessors", "", 1)}}
+
Member operators provide access to a property or method of an object
+ (object.property and object["property"]).
+
{{jsxref("Operators/new", "new")}}
+
The new operator creates an instance of a constructor.
+
new.target
+
In constructors, new.target refers to the constructor that was invoked by {{jsxref("Operators/new", "new")}}.
+
{{jsxref("Operators/super", "super")}}
+
The super keyword calls the parent constructor.
+
{{jsxref("Operators/Spread_operator", "...obj")}}
+
The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.
+
+ +

Aumento e diminuição

+ +

Postfix/prefix increment and postfix/prefix decrement operators.

+ +
+
{{jsxref("Operators/Arithmetic_Operators", "A++", "#Increment")}}
+
Postfix increment operator.
+
{{jsxref("Operators/Arithmetic_Operators", "A--", "#Decrement")}}
+
Postfix decrement operator.
+
{{jsxref("Operators/Arithmetic_Operators", "++A", "#Increment")}}
+
Prefix increment operator.
+
{{jsxref("Operators/Arithmetic_Operators", "--A", "#Decrement")}}
+
Prefix decrement operator.
+
+ +

Operadores unários

+ +

A unary operation is operation with only one operand.

+ +
+
{{jsxref("Operators/delete", "delete")}}
+
The delete operator deletes a property from an object.
+
{{jsxref("Operators/void", "void")}}
+
The void operator discards an expression's return value.
+
{{jsxref("Operators/typeof", "typeof")}}
+
The typeof operator determines the type of a given object.
+
{{jsxref("Operators/Arithmetic_Operators", "+", "#Unary_plus")}}
+
The unary plus operator converts its operand to Number type.
+
{{jsxref("Operators/Arithmetic_Operators", "-", "#Unary_negation")}}
+
The unary negation operator converts its operand to Number type and then negates it.
+
{{jsxref("Operators/Bitwise_Operators", "~", "#Bitwise_NOT")}}
+
Bitwise NOT operator.
+
{{jsxref("Operators/Logical_Operators", "!", "#Logical_NOT")}}
+
Logical NOT operator.
+
+ +

Operadores de aritmética

+ +

Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.

+ +
+
{{jsxref("Operators/Arithmetic_Operators", "+", "#Addition")}}
+
Addition operator.
+
{{jsxref("Operators/Arithmetic_Operators", "-", "#Subtraction")}}
+
Subtraction operator.
+
{{jsxref("Operators/Arithmetic_Operators", "/", "#Division")}}
+
Division operator.
+
{{jsxref("Operators/Arithmetic_Operators", "*", "#Multiplication")}}
+
Multiplication operator.
+
{{jsxref("Operators/Arithmetic_Operators", "%", "#Remainder")}}
+
Remainder operator.
+
+ +
+
{{JSxRef("Operators/Arithmetic_Operators", "**", "#Exponentiation")}}
+
Exponentiation operator.
+
+ +

Operadores relacionais

+ +

A comparison operator compares its operands and returns a Boolean value based on whether the comparison is true.

+ +
+
{{jsxref("Operators/in", "in")}}
+
The in operator determines whether an object has a given property.
+
{{jsxref("Operators/instanceof", "instanceof")}}
+
The instanceof operator determines whether an object is an instance of another object.
+
{{jsxref("Operators/Comparison_Operators", "<", "#Less_than_operator")}}
+
Less than operator.
+
{{jsxref("Operators/Comparison_Operators", ">", "#Greater_than_operator")}}
+
Greater than operator.
+
{{jsxref("Operators/Comparison_Operators", "<=", "#Less_than_or_equal_operator")}}
+
Less than or equal operator.
+
{{jsxref("Operators/Comparison_Operators", ">=", "#Greater_than_or_equal_operator")}}
+
Greater than or equal operator.
+
+ +
+

Nota: => não é um operador, mas a notação para funções seta (arrow).

+
+ +

Operadores de equality

+ +

The result of evaluating an equality operator is always of type Boolean based on whether the comparison is true.

+ +
+
{{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}
+
Equality operator.
+
{{jsxref("Operators/Comparison_Operators", "!=", "#Inequality")}}
+
Inequality operator.
+
{{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}
+
Identity operator.
+
{{jsxref("Operators/Comparison_Operators", "!==", "#Nonidentity")}}
+
Nonidentity operator.
+
+ +

Bitwise shift operators

+ +

Operations to shift all bits of the operand.

+ +
+
{{jsxref("Operators/Bitwise_Operators", "<<", "#Left_shift")}}
+
Bitwise left shift operator.
+
{{jsxref("Operators/Bitwise_Operators", ">>", "#Right_shift")}}
+
Bitwise right shift operator.
+
{{jsxref("Operators/Bitwise_Operators", ">>>", "#Unsigned_right_shift")}}
+
Bitwise unsigned right shift operator.
+
+ +

Operadores de binário bitwise

+ +

Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.

+ +
+
{{jsxref("Operators/Bitwise_Operators", "&", "#Bitwise_AND")}}
+
Bitwise AND.
+
{{jsxref("Operators/Bitwise_Operators", "|", "#Bitwise_OR")}}
+
Bitwise OR.
+
{{jsxref("Operators/Bitwise_Operators", "^", "#Bitwise_XOR")}}
+
Bitwise XOR.
+
+ +

Operadores de binário logical

+ +

Logical operators are typically used with boolean (logical) values, and when they are, they return a boolean value.

+ +
+
{{jsxref("Operators/Logical_Operators", "&&", "#Logical_AND")}}
+
Logical AND.
+
{{jsxref("Operators/Logical_Operators", "||", "#Logical_OR")}}
+
Logical OR.
+
+ +

Operdor condicional (ternário)

+ +
+
{{jsxref("Operators/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}
+
+

The conditional operator returns one of two values based on the logical value of the condition.

+
+
+ +

Operadores de Assignment

+ +

An assignment operator assigns a value to its left operand based on the value of its right operand.

+ +
+
{{jsxref("Operators/Assignment_Operators", "=", "#Assignment")}}
+
Assignment operator.
+
{{jsxref("Operators/Assignment_Operators", "*=", "#Multiplication_assignment")}}
+
Multiplication assignment.
+
{{jsxref("Operators/Assignment_Operators", "/=", "#Division_assignment")}}
+
Division assignment.
+
{{jsxref("Operators/Assignment_Operators", "%=", "#Remainder_assignment")}}
+
Remainder assignment.
+
{{jsxref("Operators/Assignment_Operators", "+=", "#Addition_assignment")}}
+
Addition assignment.
+
{{jsxref("Operators/Assignment_Operators", "-=", "#Subtraction_assignment")}}
+
Subtraction assignment
+
{{jsxref("Operators/Assignment_Operators", "<<=", "#Left_shift_assignment")}}
+
Left shift assignment.
+
{{jsxref("Operators/Assignment_Operators", ">>=", "#Right_shift_assignment")}}
+
Right shift assignment.
+
{{jsxref("Operators/Assignment_Operators", ">>>=", "#Unsigned_right_shift_assignment")}}
+
Unsigned right shift assignment.
+
{{jsxref("Operators/Assignment_Operators", "&=", "#Bitwise_AND_assignment")}}
+
Bitwise AND assignment.
+
{{jsxref("Operators/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}
+
Bitwise XOR assignment.
+
{{jsxref("Operators/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}
+
Bitwise OR assignment.
+
{{jsxref("Operators/Destructuring_assignment", "[a, b] = [1, 2]")}}
+ {{jsxref("Operators/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}
+
+

Destructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.

+
+
+ +

Operador de aspas

+ +
+
{{jsxref("Operators/Comma_Operator", ",")}}
+
The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.
+
+ +

Funcionalidades não padrão

+ +
+
{{non-standard_inline}} {{jsxref("Operators/Legacy_generator_function", "Legacy generator function", "", 1)}}
+
The function keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one {{jsxref("Operators/yield", "yield")}} expression.
+
{{non-standard_inline}} {{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}}
+
The expression closure syntax is a shorthand for writing simple function.
+
{{non-standard_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}
+
Array comprehensions.
+
{{non-standard_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}
+
Generator comprehensions.
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES1', '#sec-11', 'Expressions')}}{{Spec2('ES1')}}Initial definition
{{SpecName('ES5.1', '#sec-11', 'Expressions')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ES6')}}New: Spread operator, destructuring assignment, super keyword.
{{SpecName('ESDraft', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}{{Spec2('ESDraft')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.operators")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/operators/operator_precedence/index.html b/files/pt-pt/web/javascript/reference/operators/operator_precedence/index.html new file mode 100644 index 0000000000..03d4345410 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/operators/operator_precedence/index.html @@ -0,0 +1,461 @@ +--- +title: Precedência de operador +slug: Web/JavaScript/Reference/Operadores/Precedencia_operador +tags: + - Guía + - JavaScript + - precedência +translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence +--- +
{{jsSidebar("Operators")}}
+ +

A precedência de operador determina a maneira pela qual os operadores são analisados ​​em relação a cada um. Os operadores com maior precedência tornam-se operandos dos operadores com menor precedência..

+ +
{{EmbedInteractiveExample("pages/js/expressions-operatorprecedence.html")}}
+ + + +

Precedência e Associabilidade

+ +

Consider an expression describable by the representation below. Note that both OP1 and OP2 are fill-in-the-blanks for OPerators.

+ +
a OP b OP c
+
+ +

If OP1 and OP2 have different precedence levels (see the table below), the operator with the highest precedence goes first and associativity does not matter. Observe how multiplication has higher associativity than addition and executed first, even though addition is written first in the code.

+ +
console.log(3 + 10 * 2);   // logs 23
+console.log(3 + (10 * 2)); // logs 23 because parentheses here are superfluous
+console.log((3 + 10) * 2); // logs 26 because the parentheses change the order
+ +

Left-associativity (left-to-right) means that it is processed as (a OP1 b) OP2 c, while right-associativity (right-to-left) means it is interpreted as a OP1 (b OP2 c). Assignment operators are right-associative, so you can write:

+ +
a = b = 5; // same as writing a = (b = 5);
+
+ +

with the expected result that a and b get the value 5. This is because the assignment operator returns the value that is assigned. First, b is set to 5. Then the a is also set to 5, the return value of b = 5, aka right operand of the assignment.

+ +

As another example, the unique exponentiation operator has right-associativity, whereas other arithmetic operators have left-associativity. It is interesting to note that, the order of evaluation is always left-to-right irregardless of associativity.

+ + + + + + + + + + + + + + + + +
CódigoResultado
+ 
+function echo(name, num) {
+    console.log("Evaluating the " + name + " side");
+    return num;
+}
+// Notice the division operator (/)
+console.log(echo("left", 6) / echo("right", 2));
+
+ 		+ 
+Evaluating the left side
+Evaluating the right side
+3
+
+
+ 
+function echo(name, num) {
+    console.log("Evaluating the " + name + " side");
+    return num;
+}
+// Notice the exponentiation operator (**)
+console.log(echo("left", 2) ** echo("right", 3));
+ 		+ 
+Evaluating the left side
+Evaluating the right side
+8
+
+ +

The difference in associativity comes into play when there are multiple operators of the same precedence. With only one operator or operators of different precedences, associativity does affect the output, as seen in the example above. In the example below, observe how associativity affects the output when multiple of the same operator are used.

+ + + + + + + + + + + + + + + + + + + + +
CódigoResultado
+ 
+function echo(name, num) {
+    console.log("Evaluating the " + name + " side");
+    return num;
+}
+// Notice the division operator (/)
+console.log(echo("left", 6) / echo("middle", 2) / echo("right", 3));
+
+ 		+ 
+Evaluating the left side
+Evaluating the middle side
+Evaluating the right side
+1
+
+
+ 
+function echo(name, num) {
+    console.log("Evaluating the " + name + " side");
+    return num;
+}
+// Notice the exponentiation operator (**)
+console.log(echo("left", 2) ** echo("middle", 3) ** echo("right", 2));
+
+ 		+ 
+Evaluating the left side
+Evaluating the middle side
+Evaluating the right side
+512
+
+
+ 
+function echo(name, num) {
+    console.log("Evaluating the " + name + " side");
+    return num;
+}
+// Notice the parentheses around the left and middle exponentiation
+console.log((echo("left", 2) ** echo("middle", 3)) ** echo("right", 2));
+ 		+ 
+Evaluating the left side
+Evaluating the middle side
+Evaluating the right side
+64
+
+ +

Looking at the code snippets above, 6 / 3 / 2 is the same as (6 / 3) / 2 because division is left-associative. Exponentiation, on the other hand, is right-associative, so 2 ** 3 ** 2 is the same as 2 ** (3 ** 2). Thus, doing (2 ** 3) ** 2 changes the order and results in the 64 seen in the table above.

+ +

Remember that precedence comes before associativity. So, mixing division and exponentiation, the exponentiation comes before the division. For example, 2 ** 3 / 3 ** 2 results in 0.8888888888888888 because it is the same as (2 ** 3) / (3 ** 2).

+ +

Note on Grouping and Short-Circuiting

+ +

In the table below, Grouping is listed as having the highest precedence. However, that does not always mean the expression within the grouping symbols ( … ) is evaluated first, especially when it comes to short-circuiting.

+ +

Short-circuiting is jargon for conditional evaluation. For example, in the expression a && (b + c), if a is “falsy”, then the sub-expression (b + c) will not even get evaluated, even if it is in parentheses. We could say that the logical disjunction operator (“OR”) is “short-circuited”. Along with logical disjunction, other short-circuited operators include logical conjunction (“AND”), nullish-coalescing, optional chaining, and the conditional operator. Some more examples follow.

+ +
a || (b * c);  // evaluate `a` first, then produce `a` if `a` is “truthy”
+a && (b < c);  // evaluate `a` first, then produce `a` if `a` is “falsy”
+a ?? (b || c); // evaluate `a` first, then produce `a` if `a` is not `null` and not `undefined`
+a?.b.c;        // evaluate `a` first, then produce `a` if `a` is `null` or `undefined`
+
+ +

Exemplos

+ +
3 > 2 && 2 > 1
+// returns true
+
+3 > 2 > 1
+// Returns false because 3 > 2 is true, then true is converted to 1 in inequality operators, therefore true > 1 becomes 1 > 1, which
+//  is false. Adding parentheses makes things clear: (3 > 2) > 1.
+
+
+ +

Tabela

+ +

The following table is ordered from highest (20) to lowest (1) precedence.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PrecedênciaTipo de operador (Operator)AssociatividadeOperadores individuais
20{{jsxref("Operators/Grouping", "Grouping")}}n/a( … )
19{{jsxref("Operators/Property_Accessors", "Member Access", "#Dot_notation")}}left-to-right… . …
{{jsxref("Operators/Property_Accessors", "Computed Member Access","#Bracket_notation")}}left-to-right… [ … ]
{{jsxref("Operators/new","new")}} (with argument list)n/anew … ( … )
Function Callleft-to-right… ( … )
18{{jsxref("Operators/new","new")}} (without argument list)right-to-leftnew …
17{{jsxref("Operators/Arithmetic_Operators","Postfix Increment","#Increment")}}n/a… ++
{{jsxref("Operators/Arithmetic_Operators","Postfix Decrement","#Decrement")}}… --
16Logical NOTright-to-left! …
Bitwise NOT~ …
Unary Plus+ …
Unary Negation- …
Prefix Increment++ …
Prefix Decrement-- …
typeoftypeof …
voidvoid …
deletedelete …
awaitawait …
15Exponentiationright-to-left… ** …
14Multiplicationleft-to-right… * …
Division… / …
Remainder… % …
13Additionleft-to-right… + …
Subtraction… - …
12Bitwise Left Shiftleft-to-right… << …
Bitwise Right Shift… >> …
Bitwise Unsigned Right Shift… >>> …
11Less Thanleft-to-right… < …
Less Than Or Equal… <= …
Greater Than… > …
Greater Than Or Equal… >= …
in… in …
instanceof… instanceof …
10Equalityleft-to-right… == …
Inequality… != …
Strict Equality… === …
Strict Inequality… !== …
9Bitwise ANDleft-to-right… & …
8Bitwise XORleft-to-right… ^ …
7Bitwise ORleft-to-right… | …
6Logical ANDleft-to-right… && …
5Logical ORleft-to-right… || …
4Conditionalright-to-left… ? … : …
3Assignmentright-to-left… = …
… += …
… -= …
… **= …
… *= …
… /= …
… %= …
… <<= …
… >>= …
… >>>= …
… &= …
… ^= …
… |= …
2{{jsxref("Operators/yield", "yield")}}right-to-leftyield …
{{jsxref("Operators/yield*", "yield*")}}yield* …
1Vírgula / Sequêncialeft-to-right… , …
diff --git a/files/pt-pt/web/javascript/reference/sobre/index.html b/files/pt-pt/web/javascript/reference/sobre/index.html deleted file mode 100644 index 3b2a79ac32..0000000000 --- a/files/pt-pt/web/javascript/reference/sobre/index.html +++ /dev/null @@ -1,52 +0,0 @@ ---- -title: Sobre a referência de JavaScript -slug: Web/JavaScript/Reference/Sobre -tags: - - JavaScript -translation_of: Web/JavaScript/Reference/About ---- -
{{JsSidebar}}
- -

The JavaScript reference serves as a repository of facts about the JavaScript language. The entire language is described here in detail. As you write JavaScript code, you'll refer to these pages often (thus the title "JavaScript reference"). If you're learning JavaScript, or need help understanding some of its capabilities or features, check out the JavaScript guide.

- -

The JavaScript language is intended to be used within some larger environment, be it a browser, server-side scripts, or similar. For the most part, this reference attempts to be environment-agnostic and does not target a web browser environment.

- -

Onde encontrar informação sobre JavaScript

- -

JavaScript documentation of core language features (pure ECMAScript, for the most part) includes the following:

- - - -

If you are new to JavaScript, start with the guide. Once you have a firm grasp of the fundamentals, you can use the reference to get more details on individual objects and language constructs.

- -

Estrutura da referência

- -

In the JavaScript reference you can find the following chapters:

- -
-
Standard built-in objects
-
This chapter documents all the JavaScript standard built-in objects, along with their methods and properties.
-
Statements and declarations
-
JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.
-
Expressions and operators
-
This chapter documents all the JavaScript language operators, expressions and keywords.
-
Functions
-
Chapter about JavaScript functions.
-
Classes
-
Chapter about JavaScript classes introduced in ECMAScript 6.
-
Errors
-
Chapter about specific errors, exceptions and warnings thrown by JavaScript.
-
New in JavaScript
-
Chapter about JavaScript version history.
-
- -

Mais páginas de referência

- - diff --git a/files/pt-pt/web/javascript/reference/statements/block/index.html b/files/pt-pt/web/javascript/reference/statements/block/index.html new file mode 100644 index 0000000000..a3104dbeae --- /dev/null +++ b/files/pt-pt/web/javascript/reference/statements/block/index.html @@ -0,0 +1,116 @@ +--- +title: Bloco (block) +slug: Web/JavaScript/Reference/Extratos_e_declarações/bloco +tags: + - Declaração + - Funcionalidade de Linguagem + - JavaScript + - Referencia +translation_of: Web/JavaScript/Reference/Statements/block +--- +
Bloco {{jsSidebar("Statements")}}
+ +

Uma declaralção bloco (ou declaração composto em outras linguagens) é utilizada para agrupar zero ou mais declarações. O bloco é delimitado por um par de chavetas (“chavetas { }”) e opcionalmente poderá ser {{jsxref("Statements/label", "labelled", "", 1)}}:

+ +
{{EmbedInteractiveExample("pages/js/statement-block.html", "taller")}}
+ + + +

Sintaxe

+ +

Declaração de Bloco

+ +
{
+  StatementList
+}
+
+ +

Declaração de Bloco Etiquetado

+ +
LabelIdentifier: {
+  StatementList
+}
+
+ +
+
StatementList
+
Statements grouped within the block statement.
+
LabelIdentifier
+
An optional {{jsxref("Statements/label", "label", "", 1)}} for visual identification or as a target for {{jsxref("Statements/break", "break")}}.
+
+ +

Descrição

+ +

The block statement is often called compound statement in other languages. It allows you to use multiple statements where JavaScript expects only one statement. Combining statements into blocks is a common practice in JavaScript. The opposite behavior is possible using an empty statement, where you provide no statement, although one is required.

+ +

Blocks are commonly used in association with {{jsxref("Statements/if...else", "if...else")}} and {{jsxref("Statements/for", "for")}} statements.

+ +

Block Scoping Rules

+ +

With var or function declaration in non-strict mode

+ +

Variables declared with var or created by function declarations in non-strict mode do not have block scope. Variables introduced within a block are scoped to the containing function or script, and the effects of setting them persist beyond the block itself. In other words, block statements do not introduce a scope. For example:

+ +
var x = 1;
+{
+  var x = 2;
+}
+console.log(x); // logs 2
+
+ +

This logs 2 because the var x statement within the block is in the same scope as the var x statement before the block.

+ +

In non-strict code, function declarations inside blocks behave strangely. Do not use them.

+ +

With let, const or function declaration in strict mode

+ +

By contrast, identifiers declared with {{jsxref("Statements/let", "let")}} and {{jsxref("Statements/const", "const")}} do have block scope:

+ +
let x = 1;
+{
+  let x = 2;
+}
+console.log(x); // logs 1
+ +

The x = 2 is limited in scope to the block in which it was defined.

+ +

The same is true of const:

+ +
const c = 1;
+{
+  const c = 2;
+}
+console.log(c); // logs 1 and does not throw SyntaxError...
+ +

Note that the block-scoped const c = 2 does not throw a SyntaxError: Identifier 'c' has already been declared because it can be declared uniquely within the block.

+ +

In strict mode, starting with ES2015, functions inside blocks are scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.

+ +

Especificações

+ + + + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-block', 'Block statement')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.statements.block")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/statements/for/index.html b/files/pt-pt/web/javascript/reference/statements/for/index.html new file mode 100644 index 0000000000..ac7586e98b --- /dev/null +++ b/files/pt-pt/web/javascript/reference/statements/for/index.html @@ -0,0 +1,145 @@ +--- +title: for +slug: Web/JavaScript/Reference/Extratos_e_declarações/for +tags: + - Declaração + - Funcionalidade de Linguagem + - JavaScript + - Loop + - Referencia + - Repetição + - for +translation_of: Web/JavaScript/Reference/Statements/for +--- +
{{jsSidebar("Statements")}}
+ +

A declaração "for" cria uma repetição (loop) que consiste de três expressões opcionais, entre parênteses e separados por ponto e vírgula, seguido de uma declaração (normalmente bdeclaraçãod e bloco (block)) para ser executada na repetição.

+ +
{{EmbedInteractiveExample("pages/js/statement-for.html")}}
+ + + +

Sintaxe

+ +
for ([initialization]; [condition]; [final-expression])
+   statement
+ +
+
initialization
+
An expression (including assignment expressions) or variable declaration evaluated once before the loop begins. Typically used to initialize a counter variable. This expression may optionally declare new variables with var or let keywords. Variables declared with var are not local to the loop, i.e. they are in the same scope the for loop is in. Variables declared with let are local to the statement.
+
The result of this expression is discarded.
+
condition
+
An expression to be evaluated before each loop iteration. If this expression evaluates to true, statement is executed. This conditional test is optional. If omitted, the condition always evaluates to true. If the expression evaluates to false, execution skips to the first expression following the for construct.
+
final-expression
+
An expression to be evaluated at the end of each loop iteration. This occurs before the next evaluation of condition. Generally used to update or increment the counter variable.
+
statement
+
A statement that is executed as long as the condition evaluates to true. To execute multiple statements within the loop, use a {{jsxref("Statements/block", "block", "", 0)}} statement ({ ... }) to group those statements. To execute no statement within the loop, use an {{jsxref("Statements/empty", "empty", "", 0)}} statement (;).
+
+ +

Exemplos

+ +

Using for

+ +

The following for statement starts by declaring the variable i and initializing it to 0. It checks that i is less than nine, performs the two succeeding statements, and increments i by 1 after each pass through the loop.

+ +
for (let i = 0; i < 9; i++) {
+   console.log(i);
+   // more statements
+}
+
+ +

Optional for expressions

+ +

All three expressions in the head of the for loop are optional.

+ +

For example, in the initialization block it is not required to initialize variables:

+ +
var i = 0;
+for (; i < 9; i++) {
+    console.log(i);
+    // more statements
+}
+
+ +

Like the initialization block, the condition block is also optional. If you are omitting this expression, you must make sure to break the loop in the body in order to not create an infinite loop.

+ +
for (let i = 0;; i++) {
+   console.log(i);
+   if (i > 3) break;
+   // more statements
+}
+ +

You can also omit all three blocks. Again, make sure to use a {{jsxref("Statements/break", "break")}} statement to end the loop and also modify (increase) a variable, so that the condition for the break statement is true at some point.

+ +
var i = 0;
+
+for (;;) {
+  if (i > 3) break;
+  console.log(i);
+  i++;
+}
+
+ +

Using for without a statement

+ +

The following for cycle calculates the offset position of a node in the final-expression section, and therefore it does not require the use of a statement section, a semicolon is used instead.

+ +
function showOffsetPos(sId) {
+
+  var nLeft = 0, nTop = 0;
+
+  for (
+
+    var oItNode = document.getElementById(sId); /* initialization */
+
+    oItNode; /* condition */
+
+    nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent /* final-expression */
+
+  ); /* semicolon */
+
+  console.log('Offset position of \'' + sId + '\' element:\n left: ' + nLeft + 'px;\n top: ' + nTop + 'px;');
+
+}
+
+/* Example call: */
+
+showOffsetPos('content');
+
+// Output:
+// "Offset position of "content" element:
+// left: 0px;
+// top: 153px;"
+ +
Note: This is one of the few cases in JavaScript where the semicolon is mandatory. Indeed, without the semicolon the line that follows the cycle declaration will be considered a statement.
+ +

Especificações

+ + + + + + + + + + +
Especificação
{{SpecName('ESDraft', '#sec-for-statement', 'for statement')}}
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.statements.for")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/statements/index.html b/files/pt-pt/web/javascript/reference/statements/index.html new file mode 100644 index 0000000000..af841906a1 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/statements/index.html @@ -0,0 +1,150 @@ +--- +title: Declarações e instruções +slug: Web/JavaScript/Reference/Extratos_e_declarações +tags: + - JavaScript + - Referencia + - declarações + - instruções +translation_of: Web/JavaScript/Reference/Statements +--- +
{{jsSidebar("Statements")}}
+ +

JavaScript applications consist of statements with an appropriate syntax. A single statement may span multiple lines. Multiple statements may occur on a single line if each statement is separated by a semicolon. This isn't a keyword, but a group of keywords.

+ +

Declarações e instruções por categoria

+ +

For an alphabetical listing see the sidebar on the left.

+ +

Controlo de Fluxo

+ +
+
{{jsxref("Statements/block", "Block")}}
+
A block statement is used to group zero or more statements. The block is delimited by a pair of curly brackets.
+
{{jsxref("Statements/break", "break")}}
+
Terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.
+
{{jsxref("Statements/continue", "continue")}}
+
Terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.
+
{{jsxref("Statements/Empty", "Empty")}}
+
An empty statement is used to provide no statement, although the JavaScript syntax would expect one.
+
{{jsxref("Statements/if...else", "if...else")}}
+
Executes a statement if a specified condition is true. If the condition is false, another statement can be executed.
+
{{jsxref("Statements/switch", "switch")}}
+
Evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case.
+
{{jsxref("Statements/throw", "throw")}}
+
Throws a user-defined exception.
+
{{jsxref("Statements/try...catch", "try...catch")}}
+
Marks a block of statements to try, and specifies a response, should an exception be thrown.
+
+ +

Declarações

+ +
+
{{jsxref("Statements/var", "var")}}
+
Declares a variable, optionally initializing it to a value.
+
{{jsxref("Statements/let", "let")}}
+
Declares a block scope local variable, optionally initializing it to a value.
+
{{jsxref("Statements/const", "const")}}
+
Declares a read-only named constant.
+
+ +

Funções e classes

+ +
+
{{jsxref("Statements/function", "function")}}
+
Declara as funções com parâmetros especificados.
+
{{jsxref("Statements/function*", "function*")}}
+
Generators functions enable writing iterators more easily.
+
{{jsxref("Statements/async_function", "async function")}}
+
Declares an async function with the specified parameters.
+
{{jsxref("Statements/return", "return")}}
+
Specifies the value to be returned by a function.
+
{{jsxref("Statements/class", "class")}}
+
Declara uma Classe.
+
+ +

Iterações

+ +
+
{{jsxref("Statements/do...while", "do...while")}}
+
Creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.
+
{{jsxref("Statements/for", "for")}}
+
Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.
+
{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}
+
Iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.
+
{{jsxref("Statements/for...in", "for...in")}}
+
Iterates over the enumerable properties of an object, in arbitrary order. For each distinct property, statements can be executed.
+
{{jsxref("Statements/for...of", "for...of")}}
+
Iterates over iterable objects (including {{jsxref("Global_Objects/Array","arrays","","true")}}, array-like objects, iterators and generators), invoking a custom iteration hook with statements to be executed for the value of each distinct property.
+
{{jsxref("Statements/while", "while")}}
+
Creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.
+
+ +

Outros

+ +
+
{{jsxref("Statements/debugger", "debugger")}}
+
Invokes any available debugging functionality. If no debugging functionality is available, this statement has no effect.
+
{{jsxref("Statements/export", "export")}}
+
Used to export functions to make them available for imports in external modules, another scripts.
+
{{jsxref("Statements/import", "import")}}
+
Used to import functions exported from an external module, another script.
+
import.meta
+
A meta-property exposing context-specific metadata to a JavaScript module.
+
{{jsxref("Statements/label", "label")}}
+
Provides a statement with an identifier that you can refer to using a break or continue statement.
+
+ +
+
{{deprecated_inline}} {{jsxref("Statements/with", "with")}}
+
Extends the scope chain for a statement.
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES1', '#sec-12', 'Statements')}}{{Spec2('ES1')}}Initial definition
{{SpecName('ES3', '#sec-12', 'Statements')}}{{Spec2('ES3')}} 
{{SpecName('ES5.1', '#sec-12', 'Statements')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ES6')}}New: function*, let, for...of, yield, class
{{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.statements")}}

+ +

Consultar também

+ + diff --git a/files/pt-pt/web/javascript/reference/statements/return/index.html b/files/pt-pt/web/javascript/reference/statements/return/index.html new file mode 100644 index 0000000000..6cec134992 --- /dev/null +++ b/files/pt-pt/web/javascript/reference/statements/return/index.html @@ -0,0 +1,148 @@ +--- +title: return +slug: Web/JavaScript/Reference/Extratos_e_declarações/return +tags: + - Declaração + - JavaScript +translation_of: Web/JavaScript/Reference/Statements/return +--- +
{{jsSidebar("Statements")}}
+ +

The return statement ends function execution and specifies a value to be returned to the function caller.

+ +

Sintaxe

+ +
return [[expression]];
+ +
+
expression
+
The expression whose value is to be returned. If omitted, undefined is returned instead.
+
+ +

Descrição

+ +

When a return statement is used in a function body, the execution of the function is stopped. If specified, a given value is returned to the function caller. For example, the following function returns the square of its argument, x, where x is a number.

+ +
function square(x) {
+   return x * x;
+}
+var demo = square(3);
+// demo will equal 9
+
+ +

If the value is omitted, undefined is returned instead.

+ +

The following return statements all break the function execution:

+ +
return;
+return true;
+return false;
+return x;
+return x + y / 3;
+
+ +

Inserção Automática de Ponto e Vírgula

+ +

The return statement is affected by automatic semicolon insertion (ASI). No line terminator is allowed between the return keyword and the expression.

+ +
return
+a + b;
+
+ +

is transformed by ASI into:

+ +
return;
+a + b;
+
+ +

The console will warn "unreachable code after return statement".

+ +
Starting with Gecko 40 {{geckoRelease(40)}}, a warning is shown in the console if unreachable code is found after a return statement.
+ +

Exemplos

+ +

Interromper uma função

+ +

A function immediately stops at the point where return is called.

+ +
function counter() {
+  for (var count = 1; ; count++) {  // infinite loop
+    console.log(count + 'A'); // until 5
+      if (count === 5) {
+        return;
+      }
+      console.log(count + 'B');  // until 4
+    }
+  console.log(count + 'C');  // never appears
+}
+
+counter();
+
+// Output:
+// 1A
+// 1B
+// 2A
+// 2B
+// 3A
+// 3B
+// 4A
+// 4B
+// 5A
+
+ +

Devolver uma função

+ +

See also the article about Closures.

+ +
function magic(x) {
+  return function calc(x) { return x * 42; };
+}
+
+var answer = magic();
+answer(1337); // 56154
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.statements.return")}}

+ +

Consulte também

+ + diff --git a/files/pt-pt/web/javascript/reference/statements/throw/index.html b/files/pt-pt/web/javascript/reference/statements/throw/index.html new file mode 100644 index 0000000000..9e7a8bf54e --- /dev/null +++ b/files/pt-pt/web/javascript/reference/statements/throw/index.html @@ -0,0 +1,271 @@ +--- +title: throw +slug: Web/JavaScript/Reference/Extratos_e_declarações/throw +tags: + - Comando + - Declaração + - JavaScript +translation_of: Web/JavaScript/Reference/Statements/throw +--- +
{{jsSidebar("Statements")}}
+ +

A declaração throw lança uma exeção definida pelo utilizador. A execução da função atual irá parar (os comandos depois de throw não serão executados), e o controle será passado para o primeiro bloco catch no conjunto de chamadas. Se não existir nenhum bloco catch entre as funções de caller, o programa irá terminar.

+ +

Sintaxe

+ +
expressão throw;
+ +
+
expressão
+
A expressão para throw.
+
+ +

Descrição

+ +

Use the throw statement to throw an exception. When you throw an exception, expression specifies the value of the exception. Each of the following throws an exception:

+ +
throw 'Error2'; // generates an exception with a string value
+throw 42;       // generates an exception with the value 42
+throw true;     // generates an exception with the value true
+ +

Also note that the throw statement is affected by automatic semicolon insertion (ASI) as no line terminator between the throw keyword and the expression is allowed.

+ +

Exemplos

+ +

Throw um objeto

+ +

You can specify an object when you throw an exception. You can then reference the object's properties in the catch block. The following example creates an object of type UserException and uses it in a throw statement.

+ +
function UserException(message) {
+   this.message = message;
+   this.name = 'UserException';
+}
+function getMonthName(mo) {
+   mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)
+   var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',
+      'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+   if (months[mo] !== undefined) {
+      return months[mo];
+   } else {
+      throw new UserException('InvalidMonthNo');
+   }
+}
+
+try {
+   // statements to try
+   var myMonth = 15; // 15 is out of bound to raise the exception
+   var monthName = getMonthName(myMonth);
+} catch (e) {
+   monthName = 'unknown';
+   console.log(e.message, e.name); // pass exception object to err handler
+}
+
+ +

Outro exemplo de throwing um objeto

+ +

The following example tests an input string for a U.S. zip code. If the zip code uses an invalid format, the throw statement throws an exception by creating an object of type ZipCodeFormatException.

+ +
/*
+ * Creates a ZipCode object.
+ *
+ * Accepted formats for a zip code are:
+ *    12345
+ *    12345-6789
+ *    123456789
+ *    12345 6789
+ *
+ * If the argument passed to the ZipCode constructor does not
+ * conform to one of these patterns, an exception is thrown.
+ */
+
+function ZipCode(zip) {
+   zip = new String(zip);
+   pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
+   if (pattern.test(zip)) {
+      // zip code value will be the first match in the string
+      this.value = zip.match(pattern)[0];
+      this.valueOf = function() {
+         return this.value
+      };
+      this.toString = function() {
+         return String(this.value)
+      };
+   } else {
+      throw new ZipCodeFormatException(zip);
+   }
+}
+
+function ZipCodeFormatException(value) {
+   this.value = value;
+   this.message = 'does not conform to the expected format for a zip code';
+   this.toString = function() {
+      return this.value + this.message;
+   };
+}
+
+/*
+ * This could be in a script that validates address data
+ * for US addresses.
+ */
+
+const ZIPCODE_INVALID = -1;
+const ZIPCODE_UNKNOWN_ERROR = -2;
+
+function verifyZipCode(z) {
+   try {
+      z = new ZipCode(z);
+   } catch (e) {
+      if (e instanceof ZipCodeFormatException) {
+         return ZIPCODE_INVALID;
+      } else {
+         return ZIPCODE_UNKNOWN_ERROR;
+      }
+   }
+   return z;
+}
+
+a = verifyZipCode(95060);         // returns 95060
+b = verifyZipCode(9560);          // returns -1
+c = verifyZipCode('a');           // returns -1
+d = verifyZipCode('95060');       // returns 95060
+e = verifyZipCode('95060 1234');  // returns 95060 1234
+
+ +

Rethrow uma exceção

+ +

You can use throw to rethrow an exception after you catch it. The following example catches an exception with a numeric value and rethrows it if the value is over 50. The rethrown exception propagates up to the enclosing function or to the top level so that the user sees it.

+ +
try {
+   throw n; // throws an exception with a numeric value
+} catch (e) {
+   if (e <= 50) {
+      // statements to handle exceptions 1-50
+   } else {
+      // cannot handle this exception, so rethrow
+      throw e;
+   }
+}
+
+ +

Especificações

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaçãoEstadoComentário
{{SpecName('ES3')}}{{Spec2('ES3')}}Initial definition. Implemented in JavaScript 1.4
{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidade de navegador

+ + + +

{{Compat("javascript.statements.throw")}}

+ +

Consulte também

+ + + +
+ + + + + +
diff --git a/files/pt-pt/web/javascript/shells/index.html b/files/pt-pt/web/javascript/shells/index.html new file mode 100644 index 0000000000..b773a327dc --- /dev/null +++ b/files/pt-pt/web/javascript/shells/index.html @@ -0,0 +1,29 @@ +--- +title: JavaScript Shells +slug: JavaScript_Shells +tags: + - 'Extensões:Ferramentas' + - Ferramentas + - JavaScript + - 'JavaScript:Ferramentas' +--- +

Um shell JavaScript permite a você rapidamente testar partes de código JavaScript sem ter que atualizar a página web. Eles são extremamente úteis para desenvolvimento e depuração de código.

+ +

Lista de shells JavaScript

+ +

Os seguintes shells JavaScript trabalham com o Mozilla:

+ + + +

Categorias

+ +

Add Interwiki Languages

-- cgit v1.2.3-54-g00ecf From 8519a85da1acd5b7863268b6cf6f9e4fd14bcf31 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:50:25 +0100 Subject: unslug pt-pt: modify --- files/pt-pt/_redirects.txt | 727 ++- files/pt-pt/_wikihistory.json | 5694 ++++++++++---------- files/pt-pt/conflicting/glossary/api/index.html | 3 +- .../learn/css/first_steps/how_css_works/index.html | 5 +- .../index.html | 6 +- files/pt-pt/conflicting/mdn/contribute/index.html | 3 +- files/pt-pt/conflicting/web/api/index.html | 3 +- .../conflicting/web/api/web_storage_api/index.html | 3 +- .../conflicting/web/api/xmlhttprequest/index.html | 5 +- .../reference/global_objects/number/index.html | 3 +- .../reference/global_objects/object/index.html | 3 +- .../web/progressive_web_apps/index.html | 3 +- .../responsive_design_building_blocks/index.html | 4 +- .../index.html | 3 +- files/pt-pt/games/index.html | 3 +- files/pt-pt/games/tutorials/index.html | 3 +- files/pt-pt/glossary/404/index.html | 3 +- files/pt-pt/glossary/502/index.html | 3 +- files/pt-pt/glossary/accessibility/index.html | 3 +- files/pt-pt/glossary/ajax/index.html | 5 +- files/pt-pt/glossary/argument/index.html | 3 +- files/pt-pt/glossary/aria/index.html | 3 +- files/pt-pt/glossary/bigint/index.html | 3 +- .../block_cipher_mode_of_operation/index.html | 3 +- files/pt-pt/glossary/boolean/index.html | 3 +- files/pt-pt/glossary/browser/index.html | 3 +- files/pt-pt/glossary/cache/index.html | 3 +- files/pt-pt/glossary/cia/index.html | 3 +- files/pt-pt/glossary/compile/index.html | 3 +- files/pt-pt/glossary/crlf/index.html | 3 +- files/pt-pt/glossary/cross_axis/index.html | 3 +- files/pt-pt/glossary/crud/index.html | 3 +- files/pt-pt/glossary/dhtml/index.html | 3 +- files/pt-pt/glossary/dom/index.html | 3 +- files/pt-pt/glossary/ecma/index.html | 3 +- files/pt-pt/glossary/element/index.html | 3 +- files/pt-pt/glossary/engine/index.html | 3 +- files/pt-pt/glossary/entity_header/index.html | 3 +- files/pt-pt/glossary/favicon/index.html | 3 +- files/pt-pt/glossary/flexbox/index.html | 3 +- files/pt-pt/glossary/git/index.html | 3 +- files/pt-pt/glossary/gzip_compression/index.html | 3 +- files/pt-pt/glossary/html/index.html | 5 +- files/pt-pt/glossary/hypertext/index.html | 3 +- files/pt-pt/glossary/iana/index.html | 3 +- files/pt-pt/glossary/idempotent/index.html | 3 +- files/pt-pt/glossary/index.html | 3 +- files/pt-pt/glossary/indexeddb/index.html | 3 +- files/pt-pt/glossary/isp/index.html | 3 +- files/pt-pt/glossary/lazy_load/index.html | 3 +- files/pt-pt/glossary/localization/index.html | 3 +- files/pt-pt/glossary/main_axis/index.html | 3 +- files/pt-pt/glossary/metadata/index.html | 3 +- files/pt-pt/glossary/mitm/index.html | 3 +- files/pt-pt/glossary/node.js/index.html | 3 +- files/pt-pt/glossary/object/index.html | 3 +- files/pt-pt/glossary/object_reference/index.html | 3 +- files/pt-pt/glossary/oop/index.html | 3 +- files/pt-pt/glossary/ota/index.html | 3 +- files/pt-pt/glossary/polyfill/index.html | 3 +- .../prototype-based_programming/index.html | 3 +- files/pt-pt/glossary/scm/index.html | 3 +- files/pt-pt/glossary/server/index.html | 3 +- files/pt-pt/glossary/signature/index.html | 3 +- files/pt-pt/glossary/tag/index.html | 3 +- files/pt-pt/glossary/utf-8/index.html | 3 +- files/pt-pt/glossary/value/index.html | 3 +- files/pt-pt/glossary/viewport/index.html | 3 +- files/pt-pt/glossary/visual_viewport/index.html | 3 +- files/pt-pt/glossary/webextensions/index.html | 3 +- files/pt-pt/glossary/webrtc/index.html | 3 +- files/pt-pt/glossary/webvtt/index.html | 3 +- files/pt-pt/glossary/whatwg/index.html | 3 +- files/pt-pt/glossary/world_wide_web/index.html | 3 +- files/pt-pt/glossary/wrapper/index.html | 3 +- files/pt-pt/glossary/xhtml/index.html | 3 +- files/pt-pt/glossary/xml/index.html | 5 +- files/pt-pt/learn/accessibility/index.html | 3 +- .../how_does_the_internet_work/index.html | 3 +- files/pt-pt/learn/common_questions/index.html | 3 +- .../index.html | 5 +- .../set_up_a_local_testing_server/index.html | 3 +- .../what_is_a_domain_name/index.html | 3 +- .../common_questions/what_is_a_url/index.html | 3 +- .../what_is_a_web_server/index.html | 3 +- .../cascade_and_inheritance/index.html | 5 +- files/pt-pt/learn/css/building_blocks/index.html | 5 +- .../learn/css/building_blocks/selectors/index.html | 5 +- .../css/building_blocks/styling_tables/index.html | 5 +- .../building_blocks/values_and_units/index.html | 5 +- files/pt-pt/learn/css/css_layout/index.html | 5 +- .../first_steps/how_css_is_structured/index.html | 5 +- .../learn/css/first_steps/how_css_works/index.html | 5 +- files/pt-pt/learn/css/first_steps/index.html | 5 +- files/pt-pt/learn/css/howto/css_faq/index.html | 3 +- .../learn/css/howto/generated_content/index.html | 5 +- .../learn/css/styling_text/fundamentals/index.html | 5 +- files/pt-pt/learn/css/styling_text/index.html | 3 +- .../css/styling_text/styling_lists/index.html | 5 +- .../css_basics/index.html | 5 +- .../dealing_with_files/index.html | 5 +- .../how_the_web_works/index.html | 5 +- .../html_basics/index.html | 5 +- .../learn/getting_started_with_the_web/index.html | 5 +- .../installing_basic_software/index.html | 5 +- .../javascript_basics/index.html | 5 +- .../publishing_your_website/index.html | 3 +- .../the_web_and_web_standards/index.html | 3 +- .../what_will_your_website_look_like/index.html | 5 +- .../add_a_hit_map_on_top_of_an_image/index.html | 3 +- files/pt-pt/learn/html/howto/index.html | 3 +- .../advanced_text_formatting/index.html | 3 +- .../creating_hyperlinks/index.html | 3 +- .../introduction_to_html/debugging_html/index.html | 3 +- .../document_and_website_structure/index.html | 3 +- .../getting_started/index.html | 3 +- .../learn/html/introduction_to_html/index.html | 3 +- .../marking_up_a_letter/index.html | 3 +- .../structuring_a_page_of_content/index.html | 3 +- .../the_head_metadata_in_html/index.html | 3 +- .../learn/html/multimedia_and_embedding/index.html | 3 +- .../mozilla_splash_page/index.html | 3 +- .../video_and_audio_content/index.html | 3 +- files/pt-pt/learn/html/tables/advanced/index.html | 3 +- files/pt-pt/learn/html/tables/basics/index.html | 3 +- .../html/tables/structuring_planet_data/index.html | 3 +- .../manipulating_documents/index.html | 5 +- .../pt-pt/learn/javascript/first_steps/index.html | 5 +- files/pt-pt/learn/server-side/django/index.html | 3 +- .../development_environment/index.html | 3 +- .../learn/server-side/express_nodejs/index.html | 3 +- .../express_nodejs/introduction/index.html | 3 +- files/pt-pt/learn/server-side/index.html | 3 +- .../node_server_without_framework/index.html | 3 +- .../cross_browser_testing/accessibility/index.html | 3 +- .../cross_browser_testing/index.html | 3 +- files/pt-pt/mdn/about/index.html | 3 +- files/pt-pt/mdn/at_ten/history_of_mdn/index.html | 3 +- files/pt-pt/mdn/at_ten/index.html | 3 +- .../convert_code_samples_to_be_live/index.html | 3 +- .../howto/create_and_edit_pages/index.html | 3 +- .../contribute/howto/report_a_problem/index.html | 3 +- files/pt-pt/mdn/contribute/howto/tag/index.html | 3 +- .../write_a_new_entry_in_the_glossary/index.html | 3 +- .../write_an_api_reference/sidebars/index.html | 3 +- .../guidelines/conventions_definitions/index.html | 3 +- .../guidelines/does_this_belong_on_mdn/index.html | 3 +- .../mdn/guidelines/writing_style_guide/index.html | 3 +- files/pt-pt/mdn/structures/live_samples/index.html | 3 +- files/pt-pt/mdn/yari/index.html | 3 +- .../anatomy_of_a_webextension/index.html | 3 +- .../webextensions/api/devtools/panels/index.html | 3 +- .../add-ons/webextensions/api/storage/index.html | 3 +- .../browser_support_for_javascript_apis/index.html | 3 +- .../webextensions/content_scripts/index.html | 3 +- .../add-ons/webextensions/examples/index.html | 3 +- .../extending_the_developer_tools/index.html | 3 +- .../intercept_http_requests/index.html | 3 +- .../webextensions/manifest.json/icons/index.html | 3 +- .../webextensions/match_patterns/index.html | 3 +- .../user_interface/browser_action/index.html | 3 +- .../user_interface/browser_styles/index.html | 3 +- .../user_interface/context_menu_items/index.html | 5 +- .../user_interface/devtools_panels/index.html | 3 +- .../user_interface/extension_pages/index.html | 3 +- .../webextensions/user_interface/index.html | 3 +- .../user_interface/notifications/index.html | 3 +- .../user_interface/omnibox/index.html | 3 +- .../user_interface/options_pages/index.html | 3 +- .../user_interface/page_actions/index.html | 3 +- .../webextensions/user_interface/popups/index.html | 3 +- .../user_interface/sidebars/index.html | 3 +- .../what_are_webextensions/index.html | 3 +- .../add-ons/webextensions/what_next_/index.html | 3 +- .../your_first_webextension/index.html | 3 +- .../your_second_webextension/index.html | 3 +- files/pt-pt/mozilla/developer_guide/index.html | 3 +- .../pt-pt/mozilla/firefox/releases/1.5/index.html | 3 +- files/pt-pt/mozilla/firefox/releases/2/index.html | 3 +- .../pt-pt/mozilla/firefox/releases/3.5/index.html | 3 +- .../releases/3.5/updating_extensions/index.html | 3 +- .../pt-pt/mozilla/firefox/releases/3.6/index.html | 3 +- .../releases/3/site_compatibility/index.html | 3 +- .../releases/3/updating_extensions/index.html | 3 +- files/pt-pt/mozilla/firefox/releases/4/index.html | 3 +- files/pt-pt/mozilla/firefox/releases/5/index.html | 3 +- files/pt-pt/mozilla/firefox/releases/6/index.html | 3 +- .../index.html" | 5 +- files/pt-pt/orphaned/componentes/index.html | 3 +- .../index.html" | 3 +- .../construir_uma_extens\303\243o/index.html" | 3 +- files/pt-pt/orphaned/controles_xul/index.html | 3 +- .../criando_um_visual_para_o_firefox/index.html | 3 +- .../criar_uma_pele_para_o_firefox/index.html | 3 +- .../desenhando_texto_usando_canvas/index.html | 5 +- .../orphaned/faq_extens\303\265es/index.html" | 3 +- .../firefox_3_para_desenvolvedores/index.html | 3 +- .../index.html" | 3 +- .../javascript_orientado_a_objetos/index.html | 3 +- .../learn/html/forms/html5_updates/index.html | 3 +- .../index.html" | 3 +- .../manipuladores_de_protocolo_web/index.html | 3 +- .../mdn/community/conversations/index.html | 3 +- .../orphaned/mdn/community/doc_sprints/index.html | 3 +- files/pt-pt/orphaned/mdn/community/index.html | 3 +- .../mdn/community/whats_happening/index.html | 3 +- .../mdn/community/working_in_community/index.html | 3 +- .../contribute/howto/be_a_beta_tester/index.html | 3 +- .../howto/create_an_mdn_account/index.html | 3 +- .../howto/do_a_technical_review/index.html | 3 +- .../howto/do_an_editorial_review/index.html | 3 +- .../howto/set_the_summary_for_a_page/index.html | 3 +- .../howto/tag_javascript_pages/index.html | 3 +- .../index.html | 5 +- files/pt-pt/orphaned/mdn/editor/basics/index.html | 3 +- files/pt-pt/orphaned/mdn/editor/index.html | 3 +- .../mdn/structures/api_references/index.html | 3 +- .../what_does_an_api_reference_need/index.html | 3 +- .../orphaned/mdn/tools/page_watching/index.html | 3 +- .../orphaned/mdn/tools/template_editing/index.html | 3 +- .../pt-pt/orphaned/mdn/troubleshooting/index.html | 3 +- .../index.html | 3 +- .../getting_started_with_web-ext/index.html | 3 +- .../package_your_extension_/index.html | 3 +- .../porting_a_google_chrome_extension/index.html | 3 +- .../porting_a_legacy_firefox_add-on/index.html | 3 +- .../temporary_installation_in_firefox/index.html | 3 +- .../user_experience_best_practices/index.html | 5 +- .../webextensions_and_the_add-on_id/index.html | 3 +- .../pt-pt/orphaned/o_dom_e_o_javascript/index.html | 3 +- .../index.html | 5 +- .../pref\303\241cio/index.html" | 3 +- .../refer\303\252ncia_jsdbgapi/index.html" | 3 +- .../sobre_o_document_object_model/index.html | 3 +- files/pt-pt/orphaned/tinderbox/index.html | 5 +- files/pt-pt/orphaned/toolkit_api/index.html | 3 +- .../tools/add-ons/dom_inspector/index.html | 13 +- .../introduction_to_dom_inspector/index.html | 3 +- files/pt-pt/orphaned/tools/add-ons/index.html | 3 +- .../orphaned/transformar_xml_com_xslt/index.html | 3 +- .../para_leitura_adicional/index.html | 3 +- .../formas_de_desenho/index.html | 3 +- files/pt-pt/orphaned/tutorial_do_canvas/index.html | 5 +- .../index.html" | 3 +- .../adicionando_bot\303\265es/index.html" | 3 +- .../tutorial_xul/criando_uma_janela/index.html | 3 +- files/pt-pt/orphaned/tutorial_xul/index.html | 3 +- .../introdu\303\247\303\243o/index.html" | 3 +- .../um_pequeno_exemplo_usando_ajax/index.html | 5 +- .../index.html" | 3 +- .../index.html" | 3 +- .../pt-pt/orphaned/utilizando_meta_tags/index.html | 3 +- files/pt-pt/orphaned/venkman/index.html | 9 +- .../o_que_\303\251_css_question_/index.html" | 5 +- .../guia/expressoes_e_operadores/index.html | 3 +- .../index.html" | 3 +- .../orphaned/web/javascript/guia/sobre/index.html | 3 +- .../index.html" | 5 +- .../o_que_\303\251_o_javascript/index.html" | 3 +- .../asyncfunction/prototype/index.html | 3 +- .../pt-pt/orphaned/web/xslt/comunidade/index.html | 3 +- files/pt-pt/orphaned/web/xslt/elementos/index.html | 3 +- .../xforms/controles_customizados/index.html | 3 +- files/pt-pt/orphaned/xforms/index.html | 3 +- .../xforms_especiais_para_mozilla/index.html | 3 +- files/pt-pt/orphaned/xml_no_mozilla/index.html | 3 +- files/pt-pt/orphaned/xpath/eixos/index.html | 3 +- .../xpath/fun\303\247\303\265es/index.html" | 3 +- files/pt-pt/plugins/flash_to_html5/index.html | 3 +- .../debugger/how_to/open_the_debugger/index.html | 3 +- files/pt-pt/tools/debugger/ui_tour/index.html | 3 +- files/pt-pt/tools/keyboard_shortcuts/index.html | 5 +- files/pt-pt/tools/memory/index.html | 3 +- .../page_inspector/how_to/edit_fonts/index.html | 3 +- .../how_to/examine_and_edit_css/index.html | 3 +- .../examine_and_edit_the_box_model/index.html | 3 +- .../how_to/inspect_and_select_colors/index.html | 3 +- .../how_to/open_the_inspector/index.html | 3 +- .../reposition_elements_in_the_page/index.html | 3 +- .../how_to/use_the_inspector_api/index.html | 3 +- .../how_to/work_with_animations/index.html | 3 +- .../page_inspector/keyboard_shortcuts/index.html | 3 +- .../pt-pt/tools/page_inspector/ui_tour/index.html | 3 +- files/pt-pt/tools/performance/call_tree/index.html | 3 +- .../pt-pt/tools/performance/frame_rate/index.html | 3 +- files/pt-pt/tools/performance/how_to/index.html | 3 +- files/pt-pt/tools/performance/index.html | 3 +- files/pt-pt/tools/performance/ui_tour/index.html | 3 +- files/pt-pt/tools/performance/waterfall/index.html | 3 +- .../tools/remote_debugging/thunderbird/index.html | 3 +- .../pt-pt/tools/responsive_design_mode/index.html | 5 +- files/pt-pt/tools/settings/index.html | 3 +- files/pt-pt/tools/storage_inspector/index.html | 3 +- files/pt-pt/tools/style_editor/index.html | 3 +- files/pt-pt/tools/taking_screenshots/index.html | 3 +- files/pt-pt/tools/web_audio_editor/index.html | 3 +- .../tools/web_console/console_messages/index.html | 3 +- files/pt-pt/tools/web_console/helpers/index.html | 3 +- files/pt-pt/tools/web_console/index.html | 5 +- .../web_console/keyboard_shortcuts/index.html | 3 +- .../pt-pt/tools/web_console/rich_output/index.html | 3 +- .../tools/web_console/split_console/index.html | 3 +- .../the_command_line_interpreter/index.html | 3 +- files/pt-pt/tools/web_console/ui_tour/index.html | 3 +- .../using_the_status_role/index.html | 3 +- files/pt-pt/web/accessibility/aria/index.html | 3 +- files/pt-pt/web/accessibility/index.html | 3 +- .../pt-pt/web/api/ambient_light_events/index.html | 3 +- files/pt-pt/web/api/battery_status_api/index.html | 3 +- files/pt-pt/web/api/canvas_api/index.html | 3 +- files/pt-pt/web/api/canvas_api/tutorial/index.html | 3 +- files/pt-pt/web/api/document/alinkcolor/index.html | 3 +- files/pt-pt/web/api/document/bgcolor/index.html | 3 +- files/pt-pt/web/api/document/cookie/index.html | 3 +- files/pt-pt/web/api/document/dir/index.html | 3 +- .../api/document/getelementsbyclassname/index.html | 3 +- .../pt-pt/web/api/document_object_model/index.html | 3 +- .../using_the_w3c_dom_level_1_core/index.html | 3 +- files/pt-pt/web/api/element/clientleft/index.html | 3 +- files/pt-pt/web/api/element/clienttop/index.html | 3 +- files/pt-pt/web/api/element/index.html | 3 +- .../api/file_and_directory_entries_api/index.html | 3 +- files/pt-pt/web/api/filesystem/index.html | 3 +- files/pt-pt/web/api/geolocation_api/index.html | 3 +- files/pt-pt/web/api/media_streams_api/index.html | 3 +- files/pt-pt/web/api/metadata/index.html | 3 +- .../online_and_offline_events/index.html | 3 +- files/pt-pt/web/api/node/appendchild/index.html | 3 +- files/pt-pt/web/api/node/clonenode/index.html | 3 +- files/pt-pt/web/api/node/insertbefore/index.html | 3 +- .../using_the_notifications_api/index.html | 3 +- files/pt-pt/web/api/selection/index.html | 3 +- files/pt-pt/web/api/storage_api/index.html | 3 +- .../web_audio_api/using_web_audio_api/index.html | 3 +- .../web/api/web_authentication_api/index.html | 3 +- files/pt-pt/web/api/web_storage_api/index.html | 3 +- .../web_workers_api/using_web_workers/index.html | 3 +- files/pt-pt/web/api/webgl_api/constants/index.html | 3 +- files/pt-pt/web/api/webgl_api/data/index.html | 3 +- files/pt-pt/web/api/webgl_api/types/index.html | 3 +- .../web/api/webgl_api/using_extensions/index.html | 3 +- files/pt-pt/web/api/webrtc_api/index.html | 3 +- .../api/webrtc_api/taking_still_photos/index.html | 3 +- .../writing_a_websocket_server_in_java/index.html | 3 +- .../index.html | 3 +- .../writing_websocket_server/index.html | 3 +- .../writing_websocket_servers/index.html | 3 +- files/pt-pt/web/api/window/sidebar/index.html | 3 +- files/pt-pt/web/css/_doublecolon_after/index.html | 5 +- files/pt-pt/web/css/_doublecolon_before/index.html | 5 +- .../web/css/alternative_style_sheets/index.html | 3 +- .../web/css/css_backgrounds_and_borders/index.html | 3 +- .../using_multiple_backgrounds/index.html | 3 +- .../introduction_to_the_css_box_model/index.html | 3 +- .../css/css_colors/color_picker_tool/index.html | 3 +- .../aligning_items_in_a_flex_container/index.html | 3 +- .../ordering_flex_items/index.html | 3 +- .../index.html | 4 +- .../typical_use_cases_of_flexbox/index.html | 3 +- files/pt-pt/web/css/css_grid_layout/index.html | 3 +- .../css_transforms/using_css_transforms/index.html | 3 +- files/pt-pt/web/css/css_types/index.html | 3 +- files/pt-pt/web/css/gap/index.html | 3 +- files/pt-pt/web/css/media_queries/index.html | 3 +- .../media_queries/using_media_queries/index.html | 3 +- files/pt-pt/web/css/paged_media/index.html | 3 +- files/pt-pt/web/css/pseudo-classes/index.html | 3 +- files/pt-pt/web/css/pseudo-elements/index.html | 3 +- files/pt-pt/web/css/reference/index.html | 5 +- files/pt-pt/web/events/index.html | 3 +- files/pt-pt/web/guide/ajax/community/index.html | 3 +- .../web/guide/ajax/getting_started/index.html | 3 +- files/pt-pt/web/guide/events/index.html | 3 +- files/pt-pt/web/guide/graphics/index.html | 3 +- .../web/guide/html/content_categories/index.html | 3 +- .../web/guide/html/html5/html5_parser/index.html | 3 +- files/pt-pt/web/guide/html/html5/index.html | 3 +- .../html/html5/introduction_to_html5/index.html | 3 +- .../using_html_sections_and_outlines/index.html | 3 +- files/pt-pt/web/html/applying_color/index.html | 3 +- .../web/html/attributes/crossorigin/index.html | 3 +- files/pt-pt/web/html/attributes/index.html | 3 +- files/pt-pt/web/html/attributes/rel/index.html | 3 +- files/pt-pt/web/html/element/audio/index.html | 3 +- files/pt-pt/web/html/element/fieldset/index.html | 3 +- files/pt-pt/web/html/element/figcaption/index.html | 3 +- files/pt-pt/web/html/element/figure/index.html | 3 +- files/pt-pt/web/html/element/head/index.html | 5 +- files/pt-pt/web/html/element/index.html | 5 +- files/pt-pt/web/html/element/nav/index.html | 3 +- files/pt-pt/web/html/element/progress/index.html | 3 +- files/pt-pt/web/html/element/video/index.html | 3 +- files/pt-pt/web/html/global_attributes/index.html | 3 +- files/pt-pt/web/html/link_types/index.html | 3 +- files/pt-pt/web/html/reference/index.html | 3 +- .../html/using_the_application_cache/index.html | 3 +- .../web/javascript/data_structures/index.html | 3 +- .../guide/details_of_the_object_model/index.html | 3 +- .../javascript/guide/grammar_and_types/index.html | 3 +- files/pt-pt/web/javascript/guide/index.html | 5 +- .../web/javascript/guide/introduction/index.html | 3 +- .../web/javascript/memory_management/index.html | 3 +- .../web/javascript/reference/about/index.html | 3 +- .../deprecated_and_obsolete_features/index.html | 3 +- .../errors/unnamed_function_statement/index.html | 3 +- .../reference/functions/arguments/index.html | 3 +- .../reference/functions/arrow_functions/index.html | 3 +- .../web/javascript/reference/functions/index.html | 3 +- .../reference/functions/rest_parameters/index.html | 3 +- .../reference/operators/comma_operator/index.html | 3 +- .../reference/operators/function/index.html | 3 +- .../web/javascript/reference/operators/index.html | 3 +- .../operators/operator_precedence/index.html | 3 +- .../reference/statements/block/index.html | 3 +- .../javascript/reference/statements/for/index.html | 3 +- .../web/javascript/reference/statements/index.html | 3 +- .../reference/statements/return/index.html | 3 +- .../reference/statements/throw/index.html | 3 +- files/pt-pt/web/javascript/shells/index.html | 7 +- files/pt-pt/web/mathml/attribute/values/index.html | 3 +- .../deriving_the_quadratic_formula/index.html | 3 +- .../examples/mathml_pythagorean_theorem/index.html | 3 +- files/pt-pt/web/opensearch/index.html | 3 +- .../developer_guide/index.html | 3 +- .../responsive/media_types/index.html | 5 +- .../responsive_design_building_blocks/index.html | 3 +- files/pt-pt/web/security/index.html | 3 +- .../web/security/insecure_passwords/index.html | 3 +- .../index.html | 5 +- files/pt-pt/web/security/mixed_content/index.html | 3 +- .../web/security/same-origin_policy/index.html | 3 +- .../index.html | 3 +- .../svg/namespaces_crash_course/example/index.html | 3 +- .../web/svg/svg_animation_with_smil/index.html | 3 +- .../pt-pt/web/svg/tutorial/introduction/index.html | 3 +- .../pt-pt/web/svg/tutorial/svg_and_css/index.html | 5 +- .../tutorial/svg_in_html_introduction/index.html | 3 +- files/pt-pt/web/tutorials/index.html | 3 +- files/pt-pt/web/web_components/index.html | 3 +- files/pt-pt/web/xml/xml_introduction/index.html | 3 +- .../using_the_javascript_api/index.html | 3 +- 441 files changed, 4371 insertions(+), 3494 deletions(-) (limited to 'files/pt-pt/web/javascript') diff --git a/files/pt-pt/_redirects.txt b/files/pt-pt/_redirects.txt index d53089a7cd..0fd78a0a0c 100644 --- a/files/pt-pt/_redirects.txt +++ b/files/pt-pt/_redirects.txt @@ -1,39 +1,42 @@ # FROM-URL TO-URL /pt-PT/docs/AJAX /pt-PT/docs/Web/Guide/AJAX -/pt-PT/docs/AJAX/Como_começar /pt-PT/docs/Web/Guide/AJAX/Como_começar -/pt-PT/docs/AJAX:Como_começar /pt-PT/docs/Web/Guide/AJAX/Como_começar -/pt-PT/docs/Acessibilidade /pt-PT/docs/Web/Acessibilidade +/pt-PT/docs/AJAX/Como_começar /pt-PT/docs/Web/Guide/AJAX/Getting_Started +/pt-PT/docs/AJAX:Como_começar /pt-PT/docs/Web/Guide/AJAX/Getting_Started +/pt-PT/docs/Acentuação_para_conteúdos_carregados_por_AJAX /pt-PT/docs/orphaned/Acentuação_para_conteúdos_carregados_por_AJAX +/pt-PT/docs/Acessibilidade /pt-PT/docs/Web/Accessibility +/pt-PT/docs/Atualizando_extensões_para_o_Firefox_3 /pt-PT/docs/Mozilla/Firefox/Releases/3/Updating_extensions +/pt-PT/docs/Atualizando_extensões_para_o_Firefox_3.5 /pt-PT/docs/Mozilla/Firefox/Releases/3.5/Updating_extensions /pt-PT/docs/CSS /pt-PT/docs/Web/CSS -/pt-PT/docs/CSS/:after /pt-PT/docs/Web/CSS/:after -/pt-PT/docs/CSS/:before /pt-PT/docs/Web/CSS/:before +/pt-PT/docs/CSS/:after /pt-PT/docs/Web/CSS/::after +/pt-PT/docs/CSS/:before /pt-PT/docs/Web/CSS/::before /pt-PT/docs/CSS/@font-face /pt-PT/docs/Web/CSS/@font-face /pt-PT/docs/CSS/@import /pt-PT/docs/Web/CSS/@import /pt-PT/docs/CSS/@media /pt-PT/docs/Web/CSS/@media -/pt-PT/docs/CSS/Como_começar /pt-PT/docs/Web/CSS/Como_começar -/pt-PT/docs/CSS/Como_começar/CSS_legível /pt-PT/docs/Web/CSS/Como_começar/CSS_legível -/pt-PT/docs/CSS/Como_começar/Caixas /pt-PT/docs/Web/CSS/Como_começar/Caixas -/pt-PT/docs/CSS/Como_começar/Cascata_e_herança /pt-PT/docs/Web/CSS/Como_começar/Cascata_e_herança -/pt-PT/docs/CSS/Como_começar/Como_o_CSS_trabalha /pt-PT/docs/Web/CSS/Como_começar/Como_o_CSS_trabalha -/pt-PT/docs/CSS/Como_começar/Conteúdo /pt-PT/docs/Web/CSS/Como_começar/Conteúdo -/pt-PT/docs/CSS/Como_começar/Cor /pt-PT/docs/Web/CSS/Como_começar/Cor +/pt-PT/docs/CSS/Como_começar /pt-PT/docs/Learn/CSS/First_steps +/pt-PT/docs/CSS/Como_começar/CSS_legível /pt-PT/docs/Learn/CSS/First_steps/How_CSS_is_structured +/pt-PT/docs/CSS/Como_começar/Caixas /pt-PT/docs/Learn/CSS/Building_blocks +/pt-PT/docs/CSS/Como_começar/Cascata_e_herança /pt-PT/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance +/pt-PT/docs/CSS/Como_começar/Como_o_CSS_trabalha /pt-PT/docs/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/CSS/Como_começar/Conteúdo /pt-PT/docs/Learn/CSS/Howto/Generated_content +/pt-PT/docs/CSS/Como_começar/Cor /pt-PT/docs/Learn/CSS/Building_blocks/Values_and_units /pt-PT/docs/CSS/Como_começar/Dados_XML /pt-PT/docs/Web/CSS/Como_começar/Dados_XML -/pt-PT/docs/CSS/Como_começar/Disposição /pt-PT/docs/Web/CSS/Como_começar/Disposição -/pt-PT/docs/CSS/Como_começar/Estilos_de_texto /pt-PT/docs/Web/CSS/Como_começar/Estilos_de_texto -/pt-PT/docs/CSS/Como_começar/Gráficos_SVG /pt-PT/docs/Web/CSS/Como_começar/Gráficos_SVG +/pt-PT/docs/CSS/Como_começar/Disposição /pt-PT/docs/Learn/CSS/CSS_layout +/pt-PT/docs/CSS/Como_começar/Estilos_de_texto /pt-PT/docs/Learn/CSS/Styling_text/Fundamentals +/pt-PT/docs/CSS/Como_começar/Gráficos_SVG /pt-PT/docs/Web/SVG/Tutorial/SVG_and_CSS /pt-PT/docs/CSS/Como_começar/Interfaces_de_usuário_XUL /pt-PT/docs/Web/CSS/Como_começar/Interfaces_de_usuário_XUL -/pt-PT/docs/CSS/Como_começar/JavaScript /pt-PT/docs/Web/CSS/Como_começar/JavaScript -/pt-PT/docs/CSS/Como_começar/Listas /pt-PT/docs/Web/CSS/Como_começar/Listas -/pt-PT/docs/CSS/Como_começar/Mídia /pt-PT/docs/Web/CSS/Como_começar/Mídia -/pt-PT/docs/CSS/Como_começar/O_que_é_CSS /pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS -/pt-PT/docs/CSS/Como_começar/O_que_é_CSS? /pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS? -/pt-PT/docs/CSS/Como_começar/Porque_usar_CSS /pt-PT/docs/Web/CSS/Como_começar/Porque_usar_CSS -/pt-PT/docs/CSS/Como_começar/Seletores /pt-PT/docs/Web/CSS/Como_começar/Seletores -/pt-PT/docs/CSS/Como_começar/Tabelas /pt-PT/docs/Web/CSS/Como_começar/Tabelas -/pt-PT/docs/CSS/Consulta_de_mídia /pt-PT/docs/Web/CSS/Consulta_de_mídia -/pt-PT/docs/CSS/Getting_Started/JavaScript /pt-PT/docs/Web/CSS/Como_começar/JavaScript -/pt-PT/docs/CSS/Múltiplos_fundos /pt-PT/docs/Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo -/pt-PT/docs/CSS/Múltiplos_planos_de_fundo /pt-PT/docs/Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo -/pt-PT/docs/CSS/Usando_transformações_CSS /pt-PT/docs/Web/CSS/Usando_transformações_CSS +/pt-PT/docs/CSS/Como_começar/JavaScript /pt-PT/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents +/pt-PT/docs/CSS/Como_começar/Listas /pt-PT/docs/Learn/CSS/Styling_text/Styling_lists +/pt-PT/docs/CSS/Como_começar/Mídia /pt-PT/docs/Web/Progressive_web_apps/Responsive/Media_types +/pt-PT/docs/CSS/Como_começar/O_que_é_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/CSS/Como_começar/O_que_é_CSS? /pt-PT/docs/orphaned/Web/CSS/Como_começar/O_que_é_CSS? +/pt-PT/docs/CSS/Como_começar/Porque_usar_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works_0767812f50daab83155d62da97c6e460 +/pt-PT/docs/CSS/Como_começar/Seletores /pt-PT/docs/Learn/CSS/Building_blocks/Selectors +/pt-PT/docs/CSS/Como_começar/Tabelas /pt-PT/docs/Learn/CSS/Building_blocks/Styling_tables +/pt-PT/docs/CSS/Consulta_de_mídia /pt-PT/docs/Web/CSS/Media_Queries/Using_media_queries +/pt-PT/docs/CSS/Getting_Started/JavaScript /pt-PT/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents +/pt-PT/docs/CSS/Múltiplos_fundos /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds +/pt-PT/docs/CSS/Múltiplos_planos_de_fundo /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds +/pt-PT/docs/CSS/Usando_transformações_CSS /pt-PT/docs/Web/CSS/CSS_Transforms/Using_CSS_transforms /pt-PT/docs/CSS/azimuth /pt-PT/docs/Web/CSS/azimuth /pt-PT/docs/CSS/background /pt-PT/docs/Web/CSS/background /pt-PT/docs/CSS/background-attachment /pt-PT/docs/Web/CSS/background-attachment @@ -83,30 +86,30 @@ /pt-PT/docs/CSS/top /pt-PT/docs/Web/CSS/top /pt-PT/docs/CSS/width /pt-PT/docs/Web/CSS/width /pt-PT/docs/CSS/z-index /pt-PT/docs/Web/CSS/z-index -/pt-PT/docs/CSS::after /pt-PT/docs/Web/CSS/:after -/pt-PT/docs/CSS::before /pt-PT/docs/Web/CSS/:before +/pt-PT/docs/CSS::after /pt-PT/docs/Web/CSS/::after +/pt-PT/docs/CSS::before /pt-PT/docs/Web/CSS/::before /pt-PT/docs/CSS:@import /pt-PT/docs/Web/CSS/@import /pt-PT/docs/CSS:@media /pt-PT/docs/Web/CSS/@media -/pt-PT/docs/CSS:Como_começar /pt-PT/docs/Web/CSS/Como_começar -/pt-PT/docs/CSS:Como_começar:CSS_legível /pt-PT/docs/Web/CSS/Como_começar/CSS_legível -/pt-PT/docs/CSS:Como_começar:Caixas /pt-PT/docs/Web/CSS/Como_começar/Caixas -/pt-PT/docs/CSS:Como_começar:Cascata_e_herança /pt-PT/docs/Web/CSS/Como_começar/Cascata_e_herança -/pt-PT/docs/CSS:Como_começar:Como_o_CSS_trabalha /pt-PT/docs/Web/CSS/Como_começar/Como_o_CSS_trabalha -/pt-PT/docs/CSS:Como_começar:Conteúdo /pt-PT/docs/Web/CSS/Como_começar/Conteúdo -/pt-PT/docs/CSS:Como_começar:Cor /pt-PT/docs/Web/CSS/Como_começar/Cor +/pt-PT/docs/CSS:Como_começar /pt-PT/docs/Learn/CSS/First_steps +/pt-PT/docs/CSS:Como_começar:CSS_legível /pt-PT/docs/Learn/CSS/First_steps/How_CSS_is_structured +/pt-PT/docs/CSS:Como_começar:Caixas /pt-PT/docs/Learn/CSS/Building_blocks +/pt-PT/docs/CSS:Como_começar:Cascata_e_herança /pt-PT/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance +/pt-PT/docs/CSS:Como_começar:Como_o_CSS_trabalha /pt-PT/docs/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/CSS:Como_começar:Conteúdo /pt-PT/docs/Learn/CSS/Howto/Generated_content +/pt-PT/docs/CSS:Como_começar:Cor /pt-PT/docs/Learn/CSS/Building_blocks/Values_and_units /pt-PT/docs/CSS:Como_começar:Dados_XML /pt-PT/docs/Web/CSS/Como_começar/Dados_XML -/pt-PT/docs/CSS:Como_começar:Disposição /pt-PT/docs/Web/CSS/Como_começar/Disposição -/pt-PT/docs/CSS:Como_começar:Estilos_de_texto /pt-PT/docs/Web/CSS/Como_começar/Estilos_de_texto -/pt-PT/docs/CSS:Como_começar:Gráficos_SVG /pt-PT/docs/Web/CSS/Como_começar/Gráficos_SVG +/pt-PT/docs/CSS:Como_começar:Disposição /pt-PT/docs/Learn/CSS/CSS_layout +/pt-PT/docs/CSS:Como_começar:Estilos_de_texto /pt-PT/docs/Learn/CSS/Styling_text/Fundamentals +/pt-PT/docs/CSS:Como_começar:Gráficos_SVG /pt-PT/docs/Web/SVG/Tutorial/SVG_and_CSS /pt-PT/docs/CSS:Como_começar:Interfaces_de_usuário_XUL /pt-PT/docs/Web/CSS/Como_começar/Interfaces_de_usuário_XUL -/pt-PT/docs/CSS:Como_começar:JavaScript /pt-PT/docs/Web/CSS/Como_começar/JavaScript -/pt-PT/docs/CSS:Como_começar:Listas /pt-PT/docs/Web/CSS/Como_começar/Listas -/pt-PT/docs/CSS:Como_começar:Mídia /pt-PT/docs/Web/CSS/Como_começar/Mídia -/pt-PT/docs/CSS:Como_começar:O_que_é_CSS /pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS -/pt-PT/docs/CSS:Como_começar:O_que_é_CSS? /pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS? -/pt-PT/docs/CSS:Como_começar:Porque_usar_CSS /pt-PT/docs/Web/CSS/Como_começar/Porque_usar_CSS -/pt-PT/docs/CSS:Como_começar:Seletores /pt-PT/docs/Web/CSS/Como_começar/Seletores -/pt-PT/docs/CSS:Como_começar:Tabelas /pt-PT/docs/Web/CSS/Como_começar/Tabelas +/pt-PT/docs/CSS:Como_começar:JavaScript /pt-PT/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents +/pt-PT/docs/CSS:Como_começar:Listas /pt-PT/docs/Learn/CSS/Styling_text/Styling_lists +/pt-PT/docs/CSS:Como_começar:Mídia /pt-PT/docs/Web/Progressive_web_apps/Responsive/Media_types +/pt-PT/docs/CSS:Como_começar:O_que_é_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/CSS:Como_começar:O_que_é_CSS? /pt-PT/docs/orphaned/Web/CSS/Como_começar/O_que_é_CSS? +/pt-PT/docs/CSS:Como_começar:Porque_usar_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works_0767812f50daab83155d62da97c6e460 +/pt-PT/docs/CSS:Como_começar:Seletores /pt-PT/docs/Learn/CSS/Building_blocks/Selectors +/pt-PT/docs/CSS:Como_começar:Tabelas /pt-PT/docs/Learn/CSS/Building_blocks/Styling_tables /pt-PT/docs/CSS:azimuth /pt-PT/docs/Web/CSS/azimuth /pt-PT/docs/CSS:background /pt-PT/docs/Web/CSS/background /pt-PT/docs/CSS:background-attachment /pt-PT/docs/Web/CSS/background-attachment @@ -154,75 +157,169 @@ /pt-PT/docs/CSS:list-style /pt-PT/docs/Web/CSS/list-style /pt-PT/docs/CSS:width /pt-PT/docs/Web/CSS/width /pt-PT/docs/CSS:z-index /pt-PT/docs/Web/CSS/z-index +/pt-PT/docs/Componentes /pt-PT/docs/orphaned/Componentes /pt-PT/docs/Compressão_de_Temas /pt-PT/docs/Empacotando_Temas -/pt-PT/docs/Controles_Customizados /pt-PT/docs/XForms/Controles_Customizados +/pt-PT/docs/Configurando_um_servidor_de_atualização /pt-PT/docs/orphaned/Configurando_um_servidor_de_atualização +/pt-PT/docs/Construir_uma_Extensão /pt-PT/docs/orphaned/Construir_uma_Extensão +/pt-PT/docs/Controles_Customizados /pt-PT/docs/orphaned/XForms/Controles_Customizados +/pt-PT/docs/Controles_XUL /pt-PT/docs/orphaned/Controles_XUL +/pt-PT/docs/Criando_plugins_OpenSearch_para_o_Firefox /pt-PT/docs/Web/OpenSearch +/pt-PT/docs/Criando_um_visual_para_o_Firefox /pt-PT/docs/orphaned/Criando_um_visual_para_o_Firefox /pt-PT/docs/Criando_um_visual_para_o_Firefox:Iniciando /pt-PT/docs/Criando_um_visual_para_o_Firefox/Iniciando /pt-PT/docs/Criando_um_visual_para_o_Firefox:UUID /pt-PT/docs/Criando_um_visual_para_o_Firefox/UUID /pt-PT/docs/Criando_um_visual_para_o_Firefox:contents.rdf /pt-PT/docs/Criando_um_visual_para_o_Firefox/contents.rdf /pt-PT/docs/Criando_um_visual_para_o_Firefox:install.rdf /pt-PT/docs/Criando_um_visual_para_o_Firefox/install.rdf -/pt-PT/docs/DOM /pt-PT/docs/DOM/DOM_Reference -/pt-PT/docs/DOM/DOM_Storage /pt-PT/docs/DOM/Storage -/pt-PT/docs/DOM:document.getElementsByClassName /pt-PT/docs/DOM/document.getElementsByClassName -/pt-PT/docs/DOM:element /pt-PT/docs/DOM/element -/pt-PT/docs/DOM:element.appendChild /pt-PT/docs/DOM/element.appendChild -/pt-PT/docs/DOM:element.clientLeft /pt-PT/docs/DOM/element.clientLeft -/pt-PT/docs/DOM:element.clientTop /pt-PT/docs/DOM/element.clientTop -/pt-PT/docs/DOM:element.cloneNode /pt-PT/docs/DOM/element.cloneNode -/pt-PT/docs/DOM:element.insertBefore /pt-PT/docs/DOM/element.insertBefore -/pt-PT/docs/Desenvolver_Mozilla /pt-PT/docs/Guia_do_desenvolvedor -/pt-PT/docs/Desenvolvimento_Mozilla /pt-PT/docs/Guia_do_desenvolvedor +/pt-PT/docs/Criar_uma_pele_para_o_Firefox /pt-PT/docs/orphaned/Criar_uma_pele_para_o_Firefox +/pt-PT/docs/DHTML /pt-PT/docs/Glossary/DHTML +/pt-PT/docs/DOM /pt-PT/docs/Web/API/Document_Object_Model +/pt-PT/docs/DOM/DOM_Reference /pt-PT/docs/Web/API/Document_Object_Model +/pt-PT/docs/DOM/DOM_Storage /pt-PT/docs/Web/API/Web_Storage_API +/pt-PT/docs/DOM/Selection /pt-PT/docs/Web/API/Selection +/pt-PT/docs/DOM/Storage /pt-PT/docs/Web/API/Web_Storage_API +/pt-PT/docs/DOM/document.alinkColor /pt-PT/docs/Web/API/Document/alinkColor +/pt-PT/docs/DOM/document.bgColor /pt-PT/docs/Web/API/Document/bgColor +/pt-PT/docs/DOM/document.cookie /pt-PT/docs/Web/API/Document/cookie +/pt-PT/docs/DOM/document.getElementsByClassName /pt-PT/docs/Web/API/Document/getElementsByClassName +/pt-PT/docs/DOM/element /pt-PT/docs/Web/API/Element +/pt-PT/docs/DOM/element.appendChild /pt-PT/docs/Web/API/Node/appendChild +/pt-PT/docs/DOM/element.clientLeft /pt-PT/docs/Web/API/Element/clientLeft +/pt-PT/docs/DOM/element.clientTop /pt-PT/docs/Web/API/Element/clientTop +/pt-PT/docs/DOM/element.cloneNode /pt-PT/docs/Web/API/Node/cloneNode +/pt-PT/docs/DOM/element.insertBefore /pt-PT/docs/Web/API/Node/insertBefore +/pt-PT/docs/DOM:document.getElementsByClassName /pt-PT/docs/Web/API/Document/getElementsByClassName +/pt-PT/docs/DOM:element /pt-PT/docs/Web/API/Element +/pt-PT/docs/DOM:element.appendChild /pt-PT/docs/Web/API/Node/appendChild +/pt-PT/docs/DOM:element.clientLeft /pt-PT/docs/Web/API/Element/clientLeft +/pt-PT/docs/DOM:element.clientTop /pt-PT/docs/Web/API/Element/clientTop +/pt-PT/docs/DOM:element.cloneNode /pt-PT/docs/Web/API/Node/cloneNode +/pt-PT/docs/DOM:element.insertBefore /pt-PT/docs/Web/API/Node/insertBefore +/pt-PT/docs/DOM_Inspector /pt-PT/docs/orphaned/Tools/Add-ons/DOM_Inspector +/pt-PT/docs/DOM_Inspector/Introduction_to_DOM_Inspector /pt-PT/docs/orphaned/Tools/Add-ons/DOM_Inspector/Introduction_to_DOM_Inspector +/pt-PT/docs/Desenhando_texto_usando_canvas /pt-PT/docs/orphaned/Desenhando_texto_usando_canvas +/pt-PT/docs/Desenvolver_Mozilla /pt-PT/docs/Mozilla/Developer_guide +/pt-PT/docs/Desenvolvimento_Mozilla /pt-PT/docs/Mozilla/Developer_guide /pt-PT/docs/Desenvolvimento_Web /pt-PT/docs/Web/Guide -/pt-PT/docs/Eventos_online_e_offline /pt-PT/docs/Web/API/NavigatorOnLine/Eventos_online_e_offline -/pt-PT/docs/Folhas_de_estilo_alternativas /pt-PT/docs/Web/CSS/Folhas_de_estilo_alternativas +/pt-PT/docs/Eventos_online_e_offline /pt-PT/docs/Web/API/NavigatorOnLine/Online_and_offline_events +/pt-PT/docs/FAQ_Extensões /pt-PT/docs/orphaned/FAQ_Extensões +/pt-PT/docs/Firefox_1.5_para_Desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/1.5 +/pt-PT/docs/Firefox_2_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/2 +/pt-PT/docs/Firefox_3.5_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/3.5 +/pt-PT/docs/Firefox_3.6_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/3.6 +/pt-PT/docs/Firefox_3_para_desenvolvedores /pt-PT/docs/orphaned/Firefox_3_para_desenvolvedores +/pt-PT/docs/Firefox_4_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/4 +/pt-PT/docs/Firefox_5_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/5 +/pt-PT/docs/Firefox_6_para_desenvolvedores /pt-PT/docs/Mozilla/Firefox/Releases/6 +/pt-PT/docs/Folhas_de_estilo_alternativas /pt-PT/docs/Web/CSS/Alternative_style_sheets +/pt-PT/docs/Glossário /pt-PT/docs/Glossary +/pt-PT/docs/Glossário/404 /pt-PT/docs/Glossary/404 +/pt-PT/docs/Glossário/502 /pt-PT/docs/Glossary/502 +/pt-PT/docs/Glossário/AJAX /pt-PT/docs/Glossary/AJAX +/pt-PT/docs/Glossário/API /pt-PT/docs/conflicting/Glossary/API +/pt-PT/docs/Glossário/ARIA /pt-PT/docs/Glossary/ARIA +/pt-PT/docs/Glossário/Acessibilidade /pt-PT/docs/Glossary/Accessibility +/pt-PT/docs/Glossário/Argumento /pt-PT/docs/Glossary/Argument +/pt-PT/docs/Glossário/Assinatura /pt-PT/docs/Glossary/Signature +/pt-PT/docs/Glossário/BigInt /pt-PT/docs/Glossary/BigInt +/pt-PT/docs/Glossário/CIA /pt-PT/docs/Glossary/CIA +/pt-PT/docs/Glossário/CRLF /pt-PT/docs/Glossary/CRLF +/pt-PT/docs/Glossário/CRUD /pt-PT/docs/Glossary/CRUD +/pt-PT/docs/Glossário/Cabeçalho_de_entidade /pt-PT/docs/Glossary/Entity_header +/pt-PT/docs/Glossário/Cache /pt-PT/docs/Glossary/Cache +/pt-PT/docs/Glossário/Compilar /pt-PT/docs/Glossary/Compile +/pt-PT/docs/Glossário/Compressao_GZip /pt-PT/docs/Glossary/GZip_compression +/pt-PT/docs/Glossário/DOM /pt-PT/docs/Glossary/DOM +/pt-PT/docs/Glossário/ECMA /pt-PT/docs/Glossary/ECMA +/pt-PT/docs/Glossário/Eixo_principal /pt-PT/docs/Glossary/Main_Axis +/pt-PT/docs/Glossário/Eixo_transversal /pt-PT/docs/Glossary/Cross_Axis +/pt-PT/docs/Glossário/Elemento /pt-PT/docs/Glossary/Element +/pt-PT/docs/Glossário/Etiqueta /pt-PT/docs/Glossary/Tag +/pt-PT/docs/Glossário/Extensoes_da_Web /pt-PT/docs/Glossary/WebExtensions +/pt-PT/docs/Glossário/Favicon /pt-PT/docs/Glossary/Favicon +/pt-PT/docs/Glossário/Flexbox /pt-PT/docs/Glossary/Flexbox +/pt-PT/docs/Glossário/GCS /pt-PT/docs/Glossary/SCM +/pt-PT/docs/Glossário/Git /pt-PT/docs/Glossary/Git +/pt-PT/docs/Glossário/HTML /pt-PT/docs/Glossary/HTML +/pt-PT/docs/Glossário/Hipertexto /pt-PT/docs/Glossary/Hypertext +/pt-PT/docs/Glossário/IANA /pt-PT/docs/Glossary/IANA +/pt-PT/docs/Glossário/ISP /pt-PT/docs/Glossary/ISP +/pt-PT/docs/Glossário/Idempotent /pt-PT/docs/Glossary/Idempotent +/pt-PT/docs/Glossário/IndexedDB /pt-PT/docs/Glossary/IndexedDB +/pt-PT/docs/Glossário/Lazy_load /pt-PT/docs/Glossary/Lazy_load +/pt-PT/docs/Glossário/Metadados /pt-PT/docs/Glossary/Metadata +/pt-PT/docs/Glossário/MitM /pt-PT/docs/Glossary/MitM +/pt-PT/docs/Glossário/Modo_de_operação_de_cifra_de_bloco /pt-PT/docs/Glossary/Block_cipher_mode_of_operation +/pt-PT/docs/Glossário/Motor /pt-PT/docs/Glossary/Engine +/pt-PT/docs/Glossário/Navegador /pt-PT/docs/Glossary/Browser +/pt-PT/docs/Glossário/Node.js /pt-PT/docs/Glossary/Node.js +/pt-PT/docs/Glossário/OOP /pt-PT/docs/Glossary/OOP +/pt-PT/docs/Glossário/OTA /pt-PT/docs/Glossary/OTA +/pt-PT/docs/Glossário/Objeto /pt-PT/docs/Glossary/Object +/pt-PT/docs/Glossário/Polyfill /pt-PT/docs/Glossary/Polyfill +/pt-PT/docs/Glossário/Prototype-based_programming /pt-PT/docs/Glossary/Prototype-based_programming +/pt-PT/docs/Glossário/Referencia_de_objeto /pt-PT/docs/Glossary/Object_reference +/pt-PT/docs/Glossário/Servidor /pt-PT/docs/Glossary/Server +/pt-PT/docs/Glossário/UTF-8 /pt-PT/docs/Glossary/UTF-8 +/pt-PT/docs/Glossário/Valor /pt-PT/docs/Glossary/Value +/pt-PT/docs/Glossário/Viewport /pt-PT/docs/Glossary/Viewport +/pt-PT/docs/Glossário/Viewport_Visual /pt-PT/docs/Glossary/Visual_Viewport +/pt-PT/docs/Glossário/WHATWG /pt-PT/docs/Glossary/WHATWG +/pt-PT/docs/Glossário/WebRTC /pt-PT/docs/Glossary/WebRTC +/pt-PT/docs/Glossário/WebVTT /pt-PT/docs/Glossary/WebVTT +/pt-PT/docs/Glossário/World_Wide_Web /pt-PT/docs/Glossary/World_Wide_Web +/pt-PT/docs/Glossário/Wrapper /pt-PT/docs/Glossary/Wrapper +/pt-PT/docs/Glossário/XML /pt-PT/docs/Glossary/XML +/pt-PT/docs/Glossário/booliano /pt-PT/docs/Glossary/Boolean +/pt-PT/docs/Guia_do_desenvolvedor /pt-PT/docs/Mozilla/Developer_guide /pt-PT/docs/HTML /pt-PT/docs/Web/HTML -/pt-PT/docs/HTML/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Aplicar_cor_elementos_HTML_utilizando_CSS -/pt-PT/docs/HTML/Atributos /pt-PT/docs/Web/HTML/Atributos -/pt-PT/docs/HTML/Atributos_globais /pt-PT/docs/Web/HTML/Atributos_globais -/pt-PT/docs/HTML/Element /pt-PT/docs/Web/HTML/Elemento -/pt-PT/docs/HTML/Element/Audio /pt-PT/docs/Web/HTML/Elemento/Audio -/pt-PT/docs/HTML/Element/figcaption /pt-PT/docs/Web/HTML/Elemento/figcaption -/pt-PT/docs/HTML/Element/figure /pt-PT/docs/HTMLToDelete/Element/figure -/pt-PT/docs/HTML/Element/progress /pt-PT/docs/Web/HTML/Elemento/progress -/pt-PT/docs/HTML/Elemento /pt-PT/docs/Web/HTML/Elemento -/pt-PT/docs/HTML/Elemento/Audio /pt-PT/docs/Web/HTML/Elemento/Audio -/pt-PT/docs/HTML/Elemento/Video /pt-PT/docs/Web/HTML/Elemento/Video -/pt-PT/docs/HTML/Elemento/figcaption /pt-PT/docs/Web/HTML/Elemento/figcaption -/pt-PT/docs/HTML/Elemento/head /pt-PT/docs/Web/HTML/Elemento/head -/pt-PT/docs/HTML/Elemento/nav /pt-PT/docs/Web/HTML/Elemento/nav -/pt-PT/docs/HTML/Elemento/progress /pt-PT/docs/Web/HTML/Elemento/progress -/pt-PT/docs/HTML/Elemento/progress/progress /pt-PT/docs/Web/HTML/Elemento/progress -/pt-PT/docs/HTML/HTML5 /pt-PT/docs/Web/HTML/HTML5 -/pt-PT/docs/HTML/HTML5/Forms_no_HTML5 /pt-PT/docs/Web/HTML/HTML5/Forms_no_HTML5 -/pt-PT/docs/HTML/HTML5/Introdução_ao_HTML5 /pt-PT/docs/Web/HTML/HTML5/Introdução_ao_HTML5 -/pt-PT/docs/HTML/HTML5/Parser_HTML5 /pt-PT/docs/Web/HTML/HTML5/Parser_HTML5 -/pt-PT/docs/HTML/Referencia /pt-PT/docs/Web/HTML/Referencia -/pt-PT/docs/HTML/Tipos_de_hiperligacao /pt-PT/docs/Web/HTML/Tipos_de_hiperligacao +/pt-PT/docs/HTML/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Applying_color +/pt-PT/docs/HTML/Atributos /pt-PT/docs/Web/HTML/Attributes +/pt-PT/docs/HTML/Atributos_globais /pt-PT/docs/Web/HTML/Global_attributes +/pt-PT/docs/HTML/Element /pt-PT/docs/Web/HTML/Element +/pt-PT/docs/HTML/Element/Audio /pt-PT/docs/Web/HTML/Element/audio +/pt-PT/docs/HTML/Element/figcaption /pt-PT/docs/Web/HTML/Element/figcaption +/pt-PT/docs/HTML/Element/figure /pt-PT/docs/Web/HTML/Element/figure +/pt-PT/docs/HTML/Element/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/HTML/Elemento /pt-PT/docs/Web/HTML/Element +/pt-PT/docs/HTML/Elemento/Audio /pt-PT/docs/Web/HTML/Element/audio +/pt-PT/docs/HTML/Elemento/Video /pt-PT/docs/Web/HTML/Element/video +/pt-PT/docs/HTML/Elemento/figcaption /pt-PT/docs/Web/HTML/Element/figcaption +/pt-PT/docs/HTML/Elemento/head /pt-PT/docs/Web/HTML/Element/head +/pt-PT/docs/HTML/Elemento/nav /pt-PT/docs/Web/HTML/Element/nav +/pt-PT/docs/HTML/Elemento/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/HTML/Elemento/progress/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/HTML/HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5 +/pt-PT/docs/HTML/HTML5/Forms_no_HTML5 /pt-PT/docs/orphaned/Learn/HTML/Forms/HTML5_updates +/pt-PT/docs/HTML/HTML5/Introdução_ao_HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5/Introduction_to_HTML5 +/pt-PT/docs/HTML/HTML5/Parser_HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5/HTML5_Parser +/pt-PT/docs/HTML/Referencia /pt-PT/docs/Web/HTML/Reference +/pt-PT/docs/HTML/Tipos_de_hiperligacao /pt-PT/docs/Web/HTML/Link_types /pt-PT/docs/HTMLToDelete /en-US/docs/Web/HTML -/pt-PT/docs/HTMLToDelete/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Aplicar_cor_elementos_HTML_utilizando_CSS -/pt-PT/docs/HTMLToDelete/Atributos /pt-PT/docs/Web/HTML/Atributos -/pt-PT/docs/HTMLToDelete/Atributos_globais /pt-PT/docs/Web/HTML/Atributos_globais -/pt-PT/docs/HTMLToDelete/Element /pt-PT/docs/Web/HTML/Elemento -/pt-PT/docs/HTMLToDelete/Element/Audio /pt-PT/docs/Web/HTML/Elemento/Audio -/pt-PT/docs/HTMLToDelete/Element/progress /pt-PT/docs/Web/HTML/Elemento/progress -/pt-PT/docs/HTMLToDelete/Elemento /pt-PT/docs/Web/HTML/Elemento -/pt-PT/docs/HTMLToDelete/Elemento/Audio /pt-PT/docs/Web/HTML/Elemento/Audio -/pt-PT/docs/HTMLToDelete/Elemento/Video /pt-PT/docs/Web/HTML/Elemento/Video -/pt-PT/docs/HTMLToDelete/Elemento/figcaption /pt-PT/docs/Web/HTML/Elemento/figcaption -/pt-PT/docs/HTMLToDelete/Elemento/head /pt-PT/docs/Web/HTML/Elemento/head -/pt-PT/docs/HTMLToDelete/Elemento/nav /pt-PT/docs/Web/HTML/Elemento/nav -/pt-PT/docs/HTMLToDelete/Elemento/progress /pt-PT/docs/Web/HTML/Elemento/progress -/pt-PT/docs/HTMLToDelete/Referencia /pt-PT/docs/Web/HTML/Referencia -/pt-PT/docs/HTMLToDelete/Tipos_de_hiperligacao /pt-PT/docs/Web/HTML/Tipos_de_hiperligacao -/pt-PT/docs/Introducao_a_XML /pt-PT/docs/Web/XML/Introducao_a_XML +/pt-PT/docs/HTMLToDelete/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Applying_color +/pt-PT/docs/HTMLToDelete/Atributos /pt-PT/docs/Web/HTML/Attributes +/pt-PT/docs/HTMLToDelete/Atributos_globais /pt-PT/docs/Web/HTML/Global_attributes +/pt-PT/docs/HTMLToDelete/Element /pt-PT/docs/Web/HTML/Element +/pt-PT/docs/HTMLToDelete/Element/Audio /pt-PT/docs/Web/HTML/Element/audio +/pt-PT/docs/HTMLToDelete/Element/figure /pt-PT/docs/Web/HTML/Element/figure +/pt-PT/docs/HTMLToDelete/Element/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/HTMLToDelete/Elemento /pt-PT/docs/Web/HTML/Element +/pt-PT/docs/HTMLToDelete/Elemento/Audio /pt-PT/docs/Web/HTML/Element/audio +/pt-PT/docs/HTMLToDelete/Elemento/Video /pt-PT/docs/Web/HTML/Element/video +/pt-PT/docs/HTMLToDelete/Elemento/figcaption /pt-PT/docs/Web/HTML/Element/figcaption +/pt-PT/docs/HTMLToDelete/Elemento/head /pt-PT/docs/Web/HTML/Element/head +/pt-PT/docs/HTMLToDelete/Elemento/nav /pt-PT/docs/Web/HTML/Element/nav +/pt-PT/docs/HTMLToDelete/Elemento/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/HTMLToDelete/Referencia /pt-PT/docs/Web/HTML/Reference +/pt-PT/docs/HTMLToDelete/Tipos_de_hiperligacao /pt-PT/docs/Web/HTML/Link_types +/pt-PT/docs/Introducao_a_XML /pt-PT/docs/Web/XML/XML_introduction /pt-PT/docs/JavaScript /pt-PT/docs/Web/JavaScript -/pt-PT/docs/JavaScript/Guia /pt-PT/docs/Web/JavaScript/Guia -/pt-PT/docs/JavaScript/Guia/Expressoes_e_Operadores /pt-PT/docs/Web/JavaScript/Guia/Expressoes_e_Operadores -/pt-PT/docs/JavaScript/Guia/Introdução_ao_JavaScript /pt-PT/docs/Web/JavaScript/Guia/Introdução_ao_JavaScript -/pt-PT/docs/JavaScript/Guia/Sobre /pt-PT/docs/Web/JavaScript/Guia/Sobre -/pt-PT/docs/JavaScript/Guia/Valores,_Variáveis_e_Literais /pt-PT/docs/Web/JavaScript/Guia/Valores,_Variáveis_e_Literais +/pt-PT/docs/JavaScript/Guia /pt-PT/docs/Web/JavaScript/Guide +/pt-PT/docs/JavaScript/Guia/Expressoes_e_Operadores /pt-PT/docs/orphaned/Web/JavaScript/Guia/Expressoes_e_Operadores +/pt-PT/docs/JavaScript/Guia/Introdução_ao_JavaScript /pt-PT/docs/orphaned/Web/JavaScript/Guia/Introdução_ao_JavaScript +/pt-PT/docs/JavaScript/Guia/Sobre /pt-PT/docs/orphaned/Web/JavaScript/Guia/Sobre +/pt-PT/docs/JavaScript/Guia/Valores,_Variáveis_e_Literais /pt-PT/docs/orphaned/Web/JavaScript/Guia/Valores,_Variáveis_e_Literais /pt-PT/docs/JavaScript/Novidades_no_JavaScript /pt-PT/docs/Web/JavaScript/Novidades_no_JavaScript /pt-PT/docs/JavaScript/Novidades_no_JavaScript/Novidades_no_Javascript_1.8 /pt-PT/docs/Web/JavaScript/Novidades_no_JavaScript/Novidades_no_Javascript_1.8 -/pt-PT/docs/JavaScript/O_que_é_o_JavaScript /pt-PT/docs/Web/JavaScript/O_que_é_o_JavaScript +/pt-PT/docs/JavaScript/O_que_é_o_JavaScript /pt-PT/docs/orphaned/Web/JavaScript/O_que_é_o_JavaScript /pt-PT/docs/JavaScript/Referência/About /en-US/docs/Web/JavaScript/Reference/About /pt-PT/docs/JavaScript/Referência/Code_comments /en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Comments /pt-PT/docs/JavaScript/Referência/Deprecated_and_obsolete_features /en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features @@ -529,68 +626,406 @@ /pt-PT/docs/JavaScript/Referência/Statements/while /en-US/docs/Web/JavaScript/Reference/Statements/while /pt-PT/docs/JavaScript/Referência/Statements/with /en-US/docs/Web/JavaScript/Reference/Statements/with /pt-PT/docs/JavaScript/Referência/Symbols /en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol -/pt-PT/docs/JavaScript:O_que_é_o_JavaScript /pt-PT/docs/Web/JavaScript/O_que_é_o_JavaScript +/pt-PT/docs/JavaScript:O_que_é_o_JavaScript /pt-PT/docs/orphaned/Web/JavaScript/O_que_é_o_JavaScript +/pt-PT/docs/JavaScript_Shells /pt-PT/docs/Web/JavaScript/Shells +/pt-PT/docs/Java_em_Extensões_do_Firefox /pt-PT/docs/orphaned/Java_em_Extensões_do_Firefox +/pt-PT/docs/Javascript_orientado_a_objetos /pt-PT/docs/orphaned/Javascript_orientado_a_objetos +/pt-PT/docs/Jogos /pt-PT/docs/Games +/pt-PT/docs/Jogos/Tutoriais /pt-PT/docs/Games/Tutorials +/pt-PT/docs/Learn/Acessibilidade /pt-PT/docs/Learn/Accessibility /pt-PT/docs/Learn/CSS/Estilo_de_caixas /en-US/docs/Learn/CSS/Building_blocks +/pt-PT/docs/Learn/CSS/Estilo_de_texto /pt-PT/docs/Learn/CSS/Styling_text +/pt-PT/docs/Learn/CSS/Howto/FAQ_de_CSS /pt-PT/docs/Learn/CSS/Howto/CSS_FAQ /pt-PT/docs/Learn/CSS/Introduction_to_CSS /en-US/docs/Learn/CSS/First_steps /pt-PT/docs/Learn/CSS/Introduction_to_CSS/Seletores /en-US/docs/Learn/CSS/Building_blocks/Selectors -/pt-PT/docs/MDN/Contribute/Editor /pt-PT/docs/MDN/Editor -/pt-PT/docs/MDN/Contribute/Editor/Basicos /pt-PT/docs/MDN/Editor/Basicos +/pt-PT/docs/Learn/Comecar_com_a_Web /pt-PT/docs/Learn/Getting_started_with_the_web +/pt-PT/docs/Learn/Comecar_com_a_Web/A_web_e_os_padroes_da_web /pt-PT/docs/Learn/Getting_started_with_the_web/The_web_and_web_standards +/pt-PT/docs/Learn/Comecar_com_a_Web/Apresentacao_do_meu_site /pt-PT/docs/Learn/Getting_started_with_the_web/What_will_your_website_look_like +/pt-PT/docs/Learn/Comecar_com_a_Web/CSS_basico /pt-PT/docs/Learn/Getting_started_with_the_web/CSS_basics +/pt-PT/docs/Learn/Comecar_com_a_Web/Como_funciona_a_Web /pt-PT/docs/Learn/Getting_started_with_the_web/How_the_Web_works +/pt-PT/docs/Learn/Comecar_com_a_Web/Elementar_de_JavaScript /pt-PT/docs/Learn/Getting_started_with_the_web/JavaScript_basics +/pt-PT/docs/Learn/Comecar_com_a_Web/HTML_basicos /pt-PT/docs/Learn/Getting_started_with_the_web/HTML_basics +/pt-PT/docs/Learn/Comecar_com_a_Web/Installing_basic_software /pt-PT/docs/Learn/Getting_started_with_the_web/Installing_basic_software +/pt-PT/docs/Learn/Comecar_com_a_Web/Lidar_com_ficheiros /pt-PT/docs/Learn/Getting_started_with_the_web/Dealing_with_files +/pt-PT/docs/Learn/Comecar_com_a_Web/Publicar_o_seu_site_da_Web /pt-PT/docs/Learn/Getting_started_with_the_web/Publishing_your_website +/pt-PT/docs/Learn/HTML/Como /pt-PT/docs/Learn/HTML/Howto +/pt-PT/docs/Learn/HTML/Como/Adicionar_um_mapa_de_zona_clicavel_numa_imagem /pt-PT/docs/Learn/HTML/Howto/Add_a_hit_map_on_top_of_an_image +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML /pt-PT/docs/Learn/HTML/Introduction_to_HTML +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Criar_hiperligacoes /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Creating_hyperlinks +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Depurar_HTML /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Debugging_HTML +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Estrutura_documento_website /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Document_and_website_structure +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Estruturar_pagina_de_conteudo /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Structuring_a_page_of_content +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Formatacao_avancada_texto /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Advanced_text_formatting +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Iniciacao_HTML /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Getting_started +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/Os_metadados_de_head_em_HTML /pt-PT/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML +/pt-PT/docs/Learn/HTML/Introducao_ao_HTML/demarcar_uma_carta /pt-PT/docs/Learn/HTML/Introduction_to_HTML/Marking_up_a_letter +/pt-PT/docs/Learn/HTML/Multimedia_and_embedding/Pagina_de_boas_vindas_da_Mozilla /pt-PT/docs/Learn/HTML/Multimedia_and_embedding/Mozilla_splash_page +/pt-PT/docs/Learn/HTML/Multimedia_e_integracao /pt-PT/docs/Learn/HTML/Multimedia_and_embedding +/pt-PT/docs/Learn/HTML/Multimedia_e_integracao/Conteudo_de_audio_e_vídeo /pt-PT/docs/Learn/HTML/Multimedia_and_embedding/Video_and_audio_content +/pt-PT/docs/Learn/HTML/Tables/Avaliacao_Estruturar_os_dados_dos_planetas /pt-PT/docs/Learn/HTML/Tables/Structuring_planet_data +/pt-PT/docs/Learn/HTML/Tables/Avancada /pt-PT/docs/Learn/HTML/Tables/Advanced +/pt-PT/docs/Learn/HTML/Tables/Basicos /pt-PT/docs/Learn/HTML/Tables/Basics +/pt-PT/docs/Learn/JavaScript/Primeiros_passos /pt-PT/docs/Learn/JavaScript/First_steps +/pt-PT/docs/Learn/No-servidor /pt-PT/docs/Learn/Server-side +/pt-PT/docs/Learn/No-servidor/Django /pt-PT/docs/Learn/Server-side/Django +/pt-PT/docs/Learn/No-servidor/Express_Nodejs /pt-PT/docs/Learn/Server-side/Express_Nodejs +/pt-PT/docs/Learn/No-servidor/Express_Nodejs/Configurar_um_meio_de_desenvolvimento_Node /pt-PT/docs/Learn/Server-side/Express_Nodejs/development_environment +/pt-PT/docs/Learn/No-servidor/Express_Nodejs/Introduction /pt-PT/docs/Learn/Server-side/Express_Nodejs/Introduction +/pt-PT/docs/Learn/No-servidor/Servidor_node_sem_framework /pt-PT/docs/Learn/Server-side/Node_server_without_framework +/pt-PT/docs/Learn/Questoes_comuns /pt-PT/docs/Learn/Common_questions +/pt-PT/docs/Learn/Questoes_comuns/Como_funciona_a_Internet /pt-PT/docs/Learn/Common_questions/How_does_the_Internet_work +/pt-PT/docs/Learn/Questoes_comuns/Congiurar_um_servidor_de_testes_local /pt-PT/docs/Learn/Common_questions/set_up_a_local_testing_server +/pt-PT/docs/Learn/Questoes_comuns/O_que_e_um_URL /pt-PT/docs/Learn/Common_questions/What_is_a_URL +/pt-PT/docs/Learn/Questoes_comuns/O_que_e_um_nome_de_dominio /pt-PT/docs/Learn/Common_questions/What_is_a_domain_name +/pt-PT/docs/Learn/Questoes_comuns/O_que_e_um_servidor_da_Web /pt-PT/docs/Learn/Common_questions/What_is_a_web_server +/pt-PT/docs/Learn/Questoes_comuns/Qual_e_a_diferenca_entre_pagina_site_servidor_da_web_e_mecanismo_pesquisa /pt-PT/docs/Learn/Common_questions/Pages_sites_servers_and_search_engines +/pt-PT/docs/Learn/Tools_and_testing/Teste_cruzado_de_navegador /pt-PT/docs/Learn/Tools_and_testing/Cross_browser_testing +/pt-PT/docs/Learn/Tools_and_testing/Teste_cruzado_de_navegador/Acessibilidade /pt-PT/docs/Learn/Tools_and_testing/Cross_browser_testing/Accessibility +/pt-PT/docs/Localizar_descrições_de_extensões /pt-PT/docs/orphaned/Localizar_descrições_de_extensões +/pt-PT/docs/Localização /pt-PT/docs/Glossary/Localization +/pt-PT/docs/MDN/Comunidade /pt-PT/docs/orphaned/MDN/Community +/pt-PT/docs/MDN/Comunidade/Conversações /pt-PT/docs/orphaned/MDN/Community/Conversations +/pt-PT/docs/MDN/Comunidade/Doc_sprints /pt-PT/docs/orphaned/MDN/Community/Doc_sprints +/pt-PT/docs/MDN/Comunidade/O_que_está_a_acontecer /pt-PT/docs/orphaned/MDN/Community/Whats_happening +/pt-PT/docs/MDN/Comunidade/Trabalhar_em_comunidade /pt-PT/docs/orphaned/MDN/Community/Working_in_community +/pt-PT/docs/MDN/Contribute/Editor /pt-PT/docs/orphaned/MDN/Editor +/pt-PT/docs/MDN/Contribute/Editor/Basicos /pt-PT/docs/orphaned/MDN/Editor/Basics +/pt-PT/docs/MDN/Contribute/Howto/Como_converter_exemplos_de_codigo_para_ficarem_live /pt-PT/docs/MDN/Contribute/Howto/Convert_code_samples_to_be_live +/pt-PT/docs/MDN/Contribute/Howto/Como_definir_o_resumo_para_uma_pagina /pt-PT/docs/orphaned/MDN/Contribute/Howto/Set_the_summary_for_a_page +/pt-PT/docs/MDN/Contribute/Howto/Como_efetuar_revisao_tecnica /pt-PT/docs/orphaned/MDN/Contribute/Howto/Do_a_technical_review +/pt-PT/docs/MDN/Contribute/Howto/Como_escrever_um_artigo_para_ajudar_as_pessoas_a_aprenderem_sobre_a_Web /pt-PT/docs/orphaned/MDN/Contribute/Howto/Write_an_article_to_help_learn_about_the_Web +/pt-PT/docs/MDN/Contribute/Howto/Como_escrever_uma_nova_entrada_no_Glossario /pt-PT/docs/MDN/Contribute/Howto/Write_a_new_entry_in_the_Glossary +/pt-PT/docs/MDN/Contribute/Howto/Comunicar_um_problema /pt-PT/docs/MDN/Contribute/Howto/Report_a_problem +/pt-PT/docs/MDN/Contribute/Howto/Criar_e_editar_paginas /pt-PT/docs/MDN/Contribute/Howto/Create_and_edit_pages +/pt-PT/docs/MDN/Contribute/Howto/Criar_uma_conta_MDN /pt-PT/docs/orphaned/MDN/Contribute/Howto/Create_an_MDN_account +/pt-PT/docs/MDN/Contribute/Howto/Etiqueta /pt-PT/docs/MDN/Contribute/Howto/Tag +/pt-PT/docs/MDN/Contribute/Howto/Marcar_paginas_JavaScript /pt-PT/docs/orphaned/MDN/Contribute/Howto/Tag_JavaScript_pages +/pt-PT/docs/MDN/Contribute/Howto/Participar_testes_beta /pt-PT/docs/orphaned/MDN/Contribute/Howto/Be_a_beta_tester +/pt-PT/docs/MDN/Contribute/Howto/fazer_revisão_editorial /pt-PT/docs/orphaned/MDN/Contribute/Howto/Do_an_editorial_review /pt-PT/docs/MDN/Contribute/Structures /pt-PT/docs/MDN/Structures -/pt-PT/docs/MDN/Contribute/Structures/API_references /pt-PT/docs/MDN/Structures/API_references -/pt-PT/docs/MDN/Contribute/Structures/API_references/Barras_laterais_de_referencia_da_API /pt-PT/docs/MDN/Structures/API_references/Barras_laterais_de_referencia_da_API -/pt-PT/docs/MDN/Contribute/Structures/API_references/O_que_e_que_uma_referencia_de_API_precisa /pt-PT/docs/MDN/Structures/API_references/O_que_e_que_uma_referencia_de_API_precisa -/pt-PT/docs/MDN/Contribute/Structures/Exemplos_live /pt-PT/docs/MDN/Structures/Exemplos_live +/pt-PT/docs/MDN/Contribute/Structures/API_references /pt-PT/docs/orphaned/MDN/Structures/API_references +/pt-PT/docs/MDN/Contribute/Structures/API_references/Barras_laterais_de_referencia_da_API /pt-PT/docs/MDN/Contribute/Howto/Write_an_API_reference/Sidebars +/pt-PT/docs/MDN/Contribute/Structures/API_references/O_que_e_que_uma_referencia_de_API_precisa /pt-PT/docs/orphaned/MDN/Structures/API_references/What_does_an_API_reference_need +/pt-PT/docs/MDN/Contribute/Structures/Exemplos_live /pt-PT/docs/MDN/Structures/Live_samples /pt-PT/docs/MDN/Contribute/Structures/Macros /pt-PT/docs/MDN/Structures/Macros /pt-PT/docs/MDN/Contribute/Tools /pt-PT/docs/MDN/Tools -/pt-PT/docs/MDN/Contribute/Tools/Edição_de_modelo /pt-PT/docs/MDN/Tools/Edição_de_modelo +/pt-PT/docs/MDN/Contribute/Tools/Edição_de_modelo /pt-PT/docs/orphaned/MDN/Tools/Template_editing /pt-PT/docs/MDN/Contribute/Tools/KumaScript /pt-PT/docs/MDN/Tools/KumaScript -/pt-PT/docs/MDN/Contribute/Tools/Vigiar_pagina /pt-PT/docs/MDN/Tools/Vigiar_pagina +/pt-PT/docs/MDN/Contribute/Tools/Vigiar_pagina /pt-PT/docs/orphaned/MDN/Tools/Page_watching /pt-PT/docs/MDN/Contribute/linhas_diretrizes /pt-PT/docs/MDN/Guidelines -/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Convencoes_definicoes /pt-PT/docs/MDN/Guidelines/Convencoes_definicoes -/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Guia_de_estilo_de_escrita /pt-PT/docs/MDN/Guidelines/Guia_de_estilo_de_escrita -/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Isto_pertence_a_MDN /pt-PT/docs/MDN/Guidelines/Isto_pertence_a_MDN -/pt-PT/docs/MDN/Contribute/resolucao_de_problemas /pt-PT/docs/MDN/Troubleshooting +/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Convencoes_definicoes /pt-PT/docs/MDN/Guidelines/Conventions_definitions +/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Guia_de_estilo_de_escrita /pt-PT/docs/MDN/Guidelines/Writing_style_guide +/pt-PT/docs/MDN/Contribute/linhas_diretrizes/Isto_pertence_a_MDN /pt-PT/docs/MDN/Guidelines/Does_this_belong_on_MDN +/pt-PT/docs/MDN/Contribute/resolucao_de_problemas /pt-PT/docs/orphaned/MDN/Troubleshooting +/pt-PT/docs/MDN/Editor /pt-PT/docs/orphaned/MDN/Editor +/pt-PT/docs/MDN/Editor/Basicos /pt-PT/docs/orphaned/MDN/Editor/Basics +/pt-PT/docs/MDN/Guidelines/Convencoes_definicoes /pt-PT/docs/MDN/Guidelines/Conventions_definitions +/pt-PT/docs/MDN/Guidelines/Guia_de_estilo_de_escrita /pt-PT/docs/MDN/Guidelines/Writing_style_guide +/pt-PT/docs/MDN/Guidelines/Isto_pertence_a_MDN /pt-PT/docs/MDN/Guidelines/Does_this_belong_on_MDN /pt-PT/docs/MDN/Intrudução /pt-PT/docs/MDN/Contribute/Getting_started +/pt-PT/docs/MDN/Kuma /pt-PT/docs/MDN/Yari /pt-PT/docs/MDN/Opiniao /pt-PT/docs/MDN/Contribute/Feedback +/pt-PT/docs/MDN/Sobre /pt-PT/docs/MDN/About +/pt-PT/docs/MDN/Structures/API_references /pt-PT/docs/orphaned/MDN/Structures/API_references +/pt-PT/docs/MDN/Structures/API_references/Barras_laterais_de_referencia_da_API /pt-PT/docs/MDN/Contribute/Howto/Write_an_API_reference/Sidebars +/pt-PT/docs/MDN/Structures/API_references/O_que_e_que_uma_referencia_de_API_precisa /pt-PT/docs/orphaned/MDN/Structures/API_references/What_does_an_API_reference_need +/pt-PT/docs/MDN/Structures/Exemplos_live /pt-PT/docs/MDN/Structures/Live_samples +/pt-PT/docs/MDN/Tools/Edição_de_modelo /pt-PT/docs/orphaned/MDN/Tools/Template_editing +/pt-PT/docs/MDN/Tools/Vigiar_pagina /pt-PT/docs/orphaned/MDN/Tools/Page_watching +/pt-PT/docs/MDN/Troubleshooting /pt-PT/docs/orphaned/MDN/Troubleshooting +/pt-PT/docs/MDN_at_ten /pt-PT/docs/MDN/At_ten +/pt-PT/docs/MDN_at_ten/Contribuir_para_MDN /pt-PT/docs/conflicting/MDN/Contribute +/pt-PT/docs/MDN_at_ten/Historia_da_MDN /pt-PT/docs/MDN/At_ten/History_of_MDN +/pt-PT/docs/Manipuladores_de_protocolo_web /pt-PT/docs/orphaned/Manipuladores_de_protocolo_web +/pt-PT/docs/Melhorias_do_Gerenciador_de_Downloads_no_Firefox_3 /pt-PT/docs/orphaned/Melhorias_do_Gerenciador_de_Downloads_no_Firefox_3 +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/API/Armazenamento /pt-PT/docs/Mozilla/Add-ons/WebExtensions/API/storage +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/API/devtools.panels /pt-PT/docs/Mozilla/Add-ons/WebExtensions/API/devtools/panels +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/A_sua_primeira_extensao /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Your_first_WebExtension +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/A_sua_segunda_extensao /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Your_second_WebExtension +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Anatomia_de_uma_extensao /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/As_melhores_praticas_de_experiencia_do_utilizador /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/User_experience_best_practices +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Conversao_de_uma_extensao_legada_do_firefox /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/Porting_a_legacy_Firefox_add-on +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/E_a_seguir /pt-PT/docs/Mozilla/Add-ons/WebExtensions/What_next_ +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Exemplos_extensoes /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Examples +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/ExtennsoesWeb_e_a_id_do_extra /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/WebExtensions_and_the_Add-on_ID +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Extensão_das_ferramentas_de_desenvolvimento /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Instalacao_temporaria_no_Firefox /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/Temporary_Installation_in_Firefox +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Interceptar_Pedidos_HTTP /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Intercept_HTTP_requests +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/O_que_sao_WebExtensions /pt-PT/docs/Mozilla/Add-ons/WebExtensions/What_are_WebExtensions +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Primeiros_passos_com_web-ext /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/Getting_started_with_web-ext +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Publicar_a_sua_extensao /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/Package_your_extension_ +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Scripts_Conteudo /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Content_scripts +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Suporte_navegador_APIs_JavaScript /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/Trasnsferir_extensao_Google_Chrome /pt-PT/docs/orphaned/Mozilla/Add-ons/WebExtensions/Porting_a_Google_Chrome_extension +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/dubla_padrões /pt-PT/docs/Mozilla/Add-ons/WebExtensions/Match_patterns +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Acoes_pagina /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Page_actions +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Ação_navegador /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Browser_action +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Barras_laterais /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Sidebars +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Estilos_de_navegador /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Browser_styles +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Itens_do_menu_de_contexto /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Context_menu_items +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Notificacoes /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Notifications +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Omnibox /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Omnibox +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Options_pages /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Options_pages +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Paginas_de_extensão /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Extension_pages +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Popups /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/Popups +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/interface_do_utilizador/devtools_panels /pt-PT/docs/Mozilla/Add-ons/WebExtensions/user_interface/devtools_panels /pt-PT/docs/Mozilla/Add-ons/WebExtensions/manifest.json/applications /pt-PT/docs/Mozilla/Add-ons/WebExtensions/manifest.json/browser_specific_settings +/pt-PT/docs/Mozilla/Add-ons/WebExtensions/manifest.json/icones /pt-PT/docs/Mozilla/Add-ons/WebExtensions/manifest.json/icons +/pt-PT/docs/Mudanças_no_Gecko_1.9_que_afetam_websites /pt-PT/docs/Mozilla/Firefox/Releases/3/Site_compatibility /pt-PT/docs/Novidades_no_Javascript_1.8 /pt-PT/docs/Web/JavaScript/Novidades_no_JavaScript/Novidades_no_Javascript_1.8 +/pt-PT/docs/O_DOM_e_o_JavaScript /pt-PT/docs/orphaned/O_DOM_e_o_JavaScript +/pt-PT/docs/Plugins/Ativacao_de_Flash:_comparacao_de_navegador /pt-PT/docs/orphaned/Plugins/Flash_Activation:_Browser_Comparison +/pt-PT/docs/Plugins/Flash_para_HTML5 /pt-PT/docs/Plugins/Flash_to_HTML5 /pt-PT/docs/Página_principal /pt-PT/docs/Web -/pt-PT/docs/Referência_CSS /pt-PT/docs/Web/CSS/Referência_CSS -/pt-PT/docs/Referência_do_DOM_Gecko:Prefácio /pt-PT/docs/Referência_do_DOM_Gecko/Prefácio +/pt-PT/docs/Referência_CSS /pt-PT/docs/Web/CSS/Reference +/pt-PT/docs/Referência_JSDBGAPI /pt-PT/docs/orphaned/Referência_JSDBGAPI +/pt-PT/docs/Referência_do_DOM_Gecko/Prefácio /pt-PT/docs/orphaned/Referência_do_DOM_Gecko/Prefácio +/pt-PT/docs/Referência_do_DOM_Gecko:Prefácio /pt-PT/docs/orphaned/Referência_do_DOM_Gecko/Prefácio /pt-PT/docs/SVG /pt-PT/docs/Web/SVG /pt-PT/docs/SVG/Tutorial /pt-PT/docs/Web/SVG/Tutorial -/pt-PT/docs/Transformar_XML_com_XSLT:Para_leitura_adicional /pt-PT/docs/Transformar_XML_com_XSLT/Para_leitura_adicional -/pt-PT/docs/Tutorial_XUL:Adicionando_botões /pt-PT/docs/Tutorial_XUL/Adicionando_botões -/pt-PT/docs/Tutorial_XUL:Criando_uma_janela /pt-PT/docs/Tutorial_XUL/Criando_uma_janela -/pt-PT/docs/Tutorial_XUL:Introdução /pt-PT/docs/Tutorial_XUL/Introdução -/pt-PT/docs/Tutorial_do_Canvas:_Utilização_básica /pt-PT/docs/Tutorial_do_Canvas/Utilização_básica -/pt-PT/docs/Usando_o_Núcleo_DOM_Nível_1_do_W3C /pt-PT/docs/Using_the_W3C_DOM_Level_1_Core +/pt-PT/docs/Sobre_o_Document_Object_Model /pt-PT/docs/orphaned/Sobre_o_Document_Object_Model +/pt-PT/docs/Tinderbox /pt-PT/docs/orphaned/Tinderbox +/pt-PT/docs/Toolkit_API /pt-PT/docs/orphaned/Toolkit_API +/pt-PT/docs/Tools/Add-ons /pt-PT/docs/orphaned/Tools/Add-ons +/pt-PT/docs/Tools/Capturas_de_ecra /pt-PT/docs/Tools/Taking_screenshots +/pt-PT/docs/Tools/Configurações /pt-PT/docs/Tools/Settings +/pt-PT/docs/Tools/Consola_da_Web /pt-PT/docs/Tools/Web_Console +/pt-PT/docs/Tools/Consola_da_Web/Abertura_Consola_Web /pt-PT/docs/Tools/Web_Console/UI_Tour +/pt-PT/docs/Tools/Consola_da_Web/Ajuda /pt-PT/docs/Tools/Web_Console/Helpers +/pt-PT/docs/Tools/Consola_da_Web/Atalhos_teclado /pt-PT/docs/Tools/Web_Console/Keyboard_shortcuts +/pt-PT/docs/Tools/Consola_da_Web/Dividir_consola /pt-PT/docs/Tools/Web_Console/Split_console +/pt-PT/docs/Tools/Consola_da_Web/Mensagens_consola /pt-PT/docs/Tools/Web_Console/Console_messages +/pt-PT/docs/Tools/Consola_da_Web/O_interprete_da_linha_de_comandos /pt-PT/docs/Tools/Web_Console/The_command_line_interpreter +/pt-PT/docs/Tools/Consola_da_Web/Rich_output /pt-PT/docs/Tools/Web_Console/Rich_output +/pt-PT/docs/Tools/Debugger/Demonstracao_IU /pt-PT/docs/Tools/Debugger/UI_Tour +/pt-PT/docs/Tools/Debugger/How_to/Abrir_o_depurador /pt-PT/docs/Tools/Debugger/How_to/Open_the_debugger +/pt-PT/docs/Tools/Desempenho /pt-PT/docs/Tools/Performance +/pt-PT/docs/Tools/Desempenho/Arvore_de_Chamada /pt-PT/docs/Tools/Performance/Call_Tree +/pt-PT/docs/Tools/Desempenho/Cascata /pt-PT/docs/Tools/Performance/Waterfall +/pt-PT/docs/Tools/Desempenho/Como_fazer /pt-PT/docs/Tools/Performance/How_to +/pt-PT/docs/Tools/Desempenho/Frame_rate /pt-PT/docs/Tools/Performance/Frame_rate +/pt-PT/docs/Tools/Editor_de_audio_da_Web /pt-PT/docs/Tools/Web_Audio_Editor +/pt-PT/docs/Tools/Editor_de_estilo /pt-PT/docs/Tools/Style_Editor +/pt-PT/docs/Tools/Inspetor_de_armazenamento /pt-PT/docs/Tools/Storage_Inspector +/pt-PT/docs/Tools/Memoria /pt-PT/docs/Tools/Memory +/pt-PT/docs/Tools/Modo_de_Desenho_Adaptavel /pt-PT/docs/Tools/Responsive_Design_Mode +/pt-PT/docs/Tools/Page_Inspector/Guia_de_IU /pt-PT/docs/Tools/Page_Inspector/UI_Tour +/pt-PT/docs/Tools/Page_Inspector/How_to/Abrir_o_inspetor /pt-PT/docs/Tools/Page_Inspector/How_to/Open_the_Inspector +/pt-PT/docs/Tools/Page_Inspector/How_to/Examinar_e_editar_CSS /pt-PT/docs/Tools/Page_Inspector/How_to/Examine_and_edit_CSS +/pt-PT/docs/Tools/Page_Inspector/How_to/Examinar_e_editar_o_modelo_de_caixa /pt-PT/docs/Tools/Page_Inspector/How_to/Examine_and_edit_the_box_model +/pt-PT/docs/Tools/Page_Inspector/How_to/Inspecionar_e_selecionar_cores /pt-PT/docs/Tools/Page_Inspector/How_to/Inspect_and_select_colors +/pt-PT/docs/Tools/Page_Inspector/How_to/Reposicao_de_elementos_na_pagina /pt-PT/docs/Tools/Page_Inspector/How_to/Reposition_elements_in_the_page +/pt-PT/docs/Tools/Page_Inspector/How_to/Trabalhar_com_animacoes /pt-PT/docs/Tools/Page_Inspector/How_to/Work_with_animations +/pt-PT/docs/Tools/Page_Inspector/How_to/Utilizar_a_API_do_Inspetor /pt-PT/docs/Tools/Page_Inspector/How_to/Use_the_Inspector_API +/pt-PT/docs/Tools/Page_Inspector/How_to/Visualizar_tipos_de_letra /pt-PT/docs/Tools/Page_Inspector/How_to/Edit_fonts +/pt-PT/docs/Tools/Page_Inspector/atalhos_de_teclado /pt-PT/docs/Tools/Page_Inspector/Keyboard_shortcuts +/pt-PT/docs/Tools/Performance/Guia_da_IU /pt-PT/docs/Tools/Performance/UI_Tour +/pt-PT/docs/Tools/Remote_Debugging/Depuracao_remota_Thunderbird /pt-PT/docs/Tools/Remote_Debugging/Thunderbird +/pt-PT/docs/Tools/atalhos_de_teclado /pt-PT/docs/Tools/Keyboard_shortcuts +/pt-PT/docs/Transformar_XML_com_XSLT /pt-PT/docs/orphaned/Transformar_XML_com_XSLT +/pt-PT/docs/Transformar_XML_com_XSLT/Para_leitura_adicional /pt-PT/docs/orphaned/Transformar_XML_com_XSLT/Para_leitura_adicional +/pt-PT/docs/Transformar_XML_com_XSLT:Para_leitura_adicional /pt-PT/docs/orphaned/Transformar_XML_com_XSLT/Para_leitura_adicional +/pt-PT/docs/Tutorial_XUL /pt-PT/docs/orphaned/Tutorial_XUL +/pt-PT/docs/Tutorial_XUL/Adicionando_botões /pt-PT/docs/orphaned/Tutorial_XUL/Adicionando_botões +/pt-PT/docs/Tutorial_XUL/Criando_uma_janela /pt-PT/docs/orphaned/Tutorial_XUL/Criando_uma_janela +/pt-PT/docs/Tutorial_XUL/Introdução /pt-PT/docs/orphaned/Tutorial_XUL/Introdução +/pt-PT/docs/Tutorial_XUL:Adicionando_botões /pt-PT/docs/orphaned/Tutorial_XUL/Adicionando_botões +/pt-PT/docs/Tutorial_XUL:Criando_uma_janela /pt-PT/docs/orphaned/Tutorial_XUL/Criando_uma_janela +/pt-PT/docs/Tutorial_XUL:Introdução /pt-PT/docs/orphaned/Tutorial_XUL/Introdução +/pt-PT/docs/Tutorial_do_Canvas /pt-PT/docs/orphaned/Tutorial_do_Canvas +/pt-PT/docs/Tutorial_do_Canvas/Formas_de_desenho /pt-PT/docs/orphaned/Tutorial_do_Canvas/Formas_de_desenho +/pt-PT/docs/Tutorial_do_Canvas/Utilização_básica /pt-PT/docs/orphaned/Tutorial_do_Canvas/Utilização_básica +/pt-PT/docs/Tutorial_do_Canvas:_Utilização_básica /pt-PT/docs/orphaned/Tutorial_do_Canvas/Utilização_básica +/pt-PT/docs/Um_pequeno_exemplo_usando_AJAX /pt-PT/docs/orphaned/Um_pequeno_exemplo_usando_AJAX +/pt-PT/docs/Usando_o_Núcleo_DOM_Nível_1_do_W3C /pt-PT/docs/Web/API/Document_object_model/Using_the_W3C_DOM_Level_1_Core +/pt-PT/docs/Usando_privilégios_expandidos_em_navegadores_Mozilla /pt-PT/docs/orphaned/Usando_privilégios_expandidos_em_navegadores_Mozilla +/pt-PT/docs/Usando_áudio_e_vídeo_no_Firefox /pt-PT/docs/orphaned/Usando_áudio_e_vídeo_no_Firefox +/pt-PT/docs/Using_the_W3C_DOM_Level_1_Core /pt-PT/docs/Web/API/Document_object_model/Using_the_W3C_DOM_Level_1_Core +/pt-PT/docs/Utilizando_meta_tags /pt-PT/docs/orphaned/Utilizando_meta_tags /pt-PT/docs/Utilização_CXX_no_código_da_Mozilla /pt-PT/docs/Mozilla/Utilização_CXX_no_código_da_Mozilla +/pt-PT/docs/Venkman /pt-PT/docs/orphaned/Venkman +/pt-PT/docs/Web/API/API_Autenticacao_Web /pt-PT/docs/Web/API/Web_Authentication_API +/pt-PT/docs/Web/API/API_Entradas_de_Diretoria_e_Ficheiro /pt-PT/docs/Web/API/File_and_Directory_Entries_API +/pt-PT/docs/Web/API/API_WebRTC /pt-PT/docs/Web/API/WebRTC_API +/pt-PT/docs/Web/API/API_WebRTC/Tirar_fotografias /pt-PT/docs/Web/API/WebRTC_API/Taking_still_photos +/pt-PT/docs/Web/API/API_armazenamento /pt-PT/docs/Web/API/Storage_API +/pt-PT/docs/Web/API/API_de_Armazenamento_da_Web /pt-PT/docs/conflicting/Web/API/Web_Storage_API +/pt-PT/docs/Web/API/API_de_canvas /pt-PT/docs/Web/API/Canvas_API +/pt-PT/docs/Web/API/API_de_canvas/Tutorial /pt-PT/docs/Web/API/Canvas_API/Tutorial +/pt-PT/docs/Web/API/API_do_Estado_da_Bateria /pt-PT/docs/Web/API/Battery_Status_API +/pt-PT/docs/Web/API/API_transmissoes_multimedia /pt-PT/docs/Web/API/Media_Streams_API +/pt-PT/docs/Web/API/Document.dir /pt-PT/docs/Web/API/Document/dir +/pt-PT/docs/Web/API/Eventos_de_Luz_Ambiente /pt-PT/docs/Web/API/Ambient_Light_Events +/pt-PT/docs/Web/API/Geolocation/Utilizacao_da_geolocalizacao /pt-PT/docs/Web/API/Geolocation_API +/pt-PT/docs/Web/API/Metadados /pt-PT/docs/Web/API/Metadata +/pt-PT/docs/Web/API/NavigatorOnLine/Eventos_online_e_offline /pt-PT/docs/Web/API/NavigatorOnLine/Online_and_offline_events +/pt-PT/docs/Web/API/Notifications_API/Utilizar_API_Notificações /pt-PT/docs/Web/API/Notifications_API/Using_the_Notifications_API +/pt-PT/docs/Web/API/Sistema_de_ficheiros /pt-PT/docs/Web/API/FileSystem +/pt-PT/docs/Web/API/WebGL_API/Constantes /pt-PT/docs/Web/API/WebGL_API/Constants +/pt-PT/docs/Web/API/WebGL_API/Dados /pt-PT/docs/Web/API/WebGL_API/Data +/pt-PT/docs/Web/API/WebGL_API/Tipos /pt-PT/docs/Web/API/WebGL_API/Types +/pt-PT/docs/Web/API/WebGL_API/Utilizar_Extensões /pt-PT/docs/Web/API/WebGL_API/Using_Extensions +/pt-PT/docs/Web/API/WebSockets_API/Escrever_aplicação_cliente_de_WebSocket /pt-PT/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications +/pt-PT/docs/Web/API/WebSockets_API/Escrever_servidores_de_WebSocket /pt-PT/docs/Web/API/WebSockets_API/Writing_WebSocket_servers +/pt-PT/docs/Web/API/WebSockets_API/Escrever_um_servidor_WebSocket_em_C /pt-PT/docs/Web/API/WebSockets_API/Writing_WebSocket_server +/pt-PT/docs/Web/API/WebSockets_API/Escrever_um_servidor_WebSocket_em_Java /pt-PT/docs/Web/API/WebSockets_API/Writing_a_WebSocket_server_in_Java +/pt-PT/docs/Web/API/Web_Audio_API/Utilizar_api_audio_web /pt-PT/docs/Web/API/Web_Audio_API/Using_Web_Audio_API +/pt-PT/docs/Web/API/Web_Workers_API/Utilizacao_de_web_workers /pt-PT/docs/Web/API/Web_Workers_API/Using_web_workers +/pt-PT/docs/Web/API/Window/barra_lateral /pt-PT/docs/Web/API/Window/sidebar +/pt-PT/docs/Web/Accessibility/ARIA/ARIA_Techniques/Usando_o_role_status /pt-PT/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_status_role +/pt-PT/docs/Web/Acessibilidade /pt-PT/docs/Web/Accessibility +/pt-PT/docs/Web/Acessibilidade/ARIA /pt-PT/docs/Web/Accessibility/ARIA /pt-PT/docs/Web/Apps/Progressiva /pt-PT/docs/Web/Progressive_web_apps -/pt-PT/docs/Web/Apps/Progressiva/Identificavel /pt-PT/docs/Web/Progressive_web_apps/Identificavel -/pt-PT/docs/Web/Apps/Progressiva/Responsivo /pt-PT/docs/Web/Progressive_web_apps/Responsivo -/pt-PT/docs/Web/Apps/Progressive/Seguro /pt-PT/docs/Web/Progressive_web_apps/Seguro +/pt-PT/docs/Web/Apps/Progressiva/Identificavel /pt-PT/docs/conflicting/Web/Progressive_web_apps +/pt-PT/docs/Web/Apps/Progressiva/Responsivo /pt-PT/docs/conflicting/Web/Progressive_web_apps/Responsive/responsive_design_building_blocks +/pt-PT/docs/Web/Apps/Progressive/Seguro /pt-PT/docs/conflicting/Web/Progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a +/pt-PT/docs/Web/CSS/:after /pt-PT/docs/Web/CSS/::after +/pt-PT/docs/Web/CSS/:before /pt-PT/docs/Web/CSS/::before +/pt-PT/docs/Web/CSS/CSS_Background_and_Borders /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders +/pt-PT/docs/Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds +/pt-PT/docs/Web/CSS/CSS_Box_Model/Introducao_modelo_caixa_CSS /pt-PT/docs/Web/CSS/CSS_Box_Model/Introduction_to_the_CSS_box_model /pt-PT/docs/Web/CSS/CSS_Colors /en-US/docs/Web/CSS/CSS_Color -/pt-PT/docs/Web/CSS/Múltiplos_fundos /pt-PT/docs/Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo -/pt-PT/docs/Web/CSS/Múltiplos_planos_de_fundo /pt-PT/docs/Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo +/pt-PT/docs/Web/CSS/CSS_Colors/Ferramenta_selecao_cor /pt-PT/docs/Web/CSS/CSS_Colors/Color_picker_tool +/pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/alinhamento_de_itens_num_recipiente_flex /pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/Aligning_Items_in_a_Flex_Container +/pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/casos_de_utilizacao_tipicos_do_flexbox /pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/Typical_Use_Cases_of_Flexbox +/pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/ordenacao_dos_itens_flex /pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/Ordering_Flex_Items +/pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/relação_do_flexbox_com_outros_métodos_de_layout /pt-PT/docs/Web/CSS/CSS_Flexible_Box_Layout/Relationship_of_Flexbox_to_Other_Layout_Methods +/pt-PT/docs/Web/CSS/CSS_Tipos /pt-PT/docs/Web/CSS/CSS_Types +/pt-PT/docs/Web/CSS/Como_começar /pt-PT/docs/Learn/CSS/First_steps +/pt-PT/docs/Web/CSS/Como_começar/CSS_legível /pt-PT/docs/Learn/CSS/First_steps/How_CSS_is_structured +/pt-PT/docs/Web/CSS/Como_começar/Caixas /pt-PT/docs/Learn/CSS/Building_blocks +/pt-PT/docs/Web/CSS/Como_começar/Cascata_e_herança /pt-PT/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance +/pt-PT/docs/Web/CSS/Como_começar/Como_o_CSS_trabalha /pt-PT/docs/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/Web/CSS/Como_começar/Conteúdo /pt-PT/docs/Learn/CSS/Howto/Generated_content +/pt-PT/docs/Web/CSS/Como_começar/Cor /pt-PT/docs/Learn/CSS/Building_blocks/Values_and_units +/pt-PT/docs/Web/CSS/Como_começar/Disposição /pt-PT/docs/Learn/CSS/CSS_layout +/pt-PT/docs/Web/CSS/Como_começar/Estilos_de_texto /pt-PT/docs/Learn/CSS/Styling_text/Fundamentals +/pt-PT/docs/Web/CSS/Como_começar/Gráficos_SVG /pt-PT/docs/Web/SVG/Tutorial/SVG_and_CSS +/pt-PT/docs/Web/CSS/Como_começar/JavaScript /pt-PT/docs/Learn/JavaScript/Client-side_web_APIs/Manipulating_documents +/pt-PT/docs/Web/CSS/Como_começar/Listas /pt-PT/docs/Learn/CSS/Styling_text/Styling_lists +/pt-PT/docs/Web/CSS/Como_começar/Mídia /pt-PT/docs/Web/Progressive_web_apps/Responsive/Media_types +/pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works +/pt-PT/docs/Web/CSS/Como_começar/O_que_é_CSS? /pt-PT/docs/orphaned/Web/CSS/Como_começar/O_que_é_CSS? +/pt-PT/docs/Web/CSS/Como_começar/Porque_usar_CSS /pt-PT/docs/conflicting/Learn/CSS/First_steps/How_CSS_works_0767812f50daab83155d62da97c6e460 +/pt-PT/docs/Web/CSS/Como_começar/Seletores /pt-PT/docs/Learn/CSS/Building_blocks/Selectors +/pt-PT/docs/Web/CSS/Como_começar/Tabelas /pt-PT/docs/Learn/CSS/Building_blocks/Styling_tables +/pt-PT/docs/Web/CSS/Consulta_de_mídia /pt-PT/docs/Web/CSS/Media_Queries/Using_media_queries +/pt-PT/docs/Web/CSS/Consultas_de_media /pt-PT/docs/Web/CSS/Media_Queries +/pt-PT/docs/Web/CSS/Folhas_de_estilo_alternativas /pt-PT/docs/Web/CSS/Alternative_style_sheets +/pt-PT/docs/Web/CSS/Média_paginada /pt-PT/docs/Web/CSS/Paged_Media +/pt-PT/docs/Web/CSS/Múltiplos_fundos /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds +/pt-PT/docs/Web/CSS/Múltiplos_planos_de_fundo /pt-PT/docs/Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds +/pt-PT/docs/Web/CSS/Pseudoclasses /pt-PT/docs/Web/CSS/Pseudo-classes +/pt-PT/docs/Web/CSS/Pseudoelementos /pt-PT/docs/Web/CSS/Pseudo-elements +/pt-PT/docs/Web/CSS/Referência_CSS /pt-PT/docs/Web/CSS/Reference +/pt-PT/docs/Web/CSS/Usando_transformações_CSS /pt-PT/docs/Web/CSS/CSS_Transforms/Using_CSS_transforms +/pt-PT/docs/Web/CSS/grid-gap /pt-PT/docs/Web/CSS/gap +/pt-PT/docs/Web/CSS/layout_de_grelha_css /pt-PT/docs/Web/CSS/CSS_Grid_Layout +/pt-PT/docs/Web/Componentes_Web /pt-PT/docs/Web/Web_Components +/pt-PT/docs/Web/Eventos /pt-PT/docs/Web/Events /pt-PT/docs/Web/Eventos/visibilitychange /pt-PT/docs/Web/API/Document/visibilitychange_event +/pt-PT/docs/Web/Guide/AJAX/Como_começar /pt-PT/docs/Web/Guide/AJAX/Getting_Started +/pt-PT/docs/Web/Guide/AJAX/Comunidade /pt-PT/docs/Web/Guide/AJAX/Community /pt-PT/docs/Web/Guide/CSS /pt-PT/docs/Learn/CSS +/pt-PT/docs/Web/Guide/Eventos /pt-PT/docs/Web/Guide/Events +/pt-PT/docs/Web/Guide/Gráficos /pt-PT/docs/Web/Guide/Graphics /pt-PT/docs/Web/Guide/HTML /pt-PT/docs/Learn/HTML -/pt-PT/docs/Web/Guide/HTML/Introduction /pt-PT/docs/Learn/HTML/Introducao_ao_HTML -/pt-PT/docs/Web/HTML/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Aplicar_cor_elementos_HTML_utilizando_CSS -/pt-PT/docs/Web/HTML/Element /pt-PT/docs/Web/HTML/Elemento -/pt-PT/docs/Web/HTML/Element/Audio /pt-PT/docs/Web/HTML/Elemento/Audio -/pt-PT/docs/Web/HTML/Element/figure /pt-PT/docs/HTMLToDelete/Element/figure -/pt-PT/docs/Web/HTML/Element/progress /pt-PT/docs/Web/HTML/Elemento/progress +/pt-PT/docs/Web/Guide/HTML/Categorias_de_conteudo /pt-PT/docs/Web/Guide/HTML/Content_categories +/pt-PT/docs/Web/Guide/HTML/Introduction /pt-PT/docs/Learn/HTML/Introduction_to_HTML +/pt-PT/docs/Web/Guide/HTML/Utilizar_estruturas_e_seccoes_de_HTML /pt-PT/docs/Web/Guide/HTML/Using_HTML_sections_and_outlines +/pt-PT/docs/Web/HTML/Aplicar_cor__elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Applying_color +/pt-PT/docs/Web/HTML/Aplicar_cor_elementos_HTML_utilizando_CSS /pt-PT/docs/Web/HTML/Applying_color +/pt-PT/docs/Web/HTML/Atributos /pt-PT/docs/Web/HTML/Attributes +/pt-PT/docs/Web/HTML/Atributos/rel /pt-PT/docs/Web/HTML/Attributes/rel +/pt-PT/docs/Web/HTML/Atributos_globais /pt-PT/docs/Web/HTML/Global_attributes +/pt-PT/docs/Web/HTML/CORS_settings_attributes /pt-PT/docs/Web/HTML/Attributes/crossorigin +/pt-PT/docs/Web/HTML/Elemento /pt-PT/docs/Web/HTML/Element +/pt-PT/docs/Web/HTML/Elemento/Audio /pt-PT/docs/Web/HTML/Element/audio +/pt-PT/docs/Web/HTML/Elemento/Video /pt-PT/docs/Web/HTML/Element/video +/pt-PT/docs/Web/HTML/Elemento/fieldset /pt-PT/docs/Web/HTML/Element/fieldset +/pt-PT/docs/Web/HTML/Elemento/figcaption /pt-PT/docs/Web/HTML/Element/figcaption +/pt-PT/docs/Web/HTML/Elemento/head /pt-PT/docs/Web/HTML/Element/head +/pt-PT/docs/Web/HTML/Elemento/nav /pt-PT/docs/Web/HTML/Element/nav +/pt-PT/docs/Web/HTML/Elemento/progress /pt-PT/docs/Web/HTML/Element/progress +/pt-PT/docs/Web/HTML/HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5 +/pt-PT/docs/Web/HTML/HTML5/Forms_no_HTML5 /pt-PT/docs/orphaned/Learn/HTML/Forms/HTML5_updates +/pt-PT/docs/Web/HTML/HTML5/Introdução_ao_HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5/Introduction_to_HTML5 +/pt-PT/docs/Web/HTML/HTML5/Parser_HTML5 /pt-PT/docs/Web/Guide/HTML/HTML5/HTML5_Parser +/pt-PT/docs/Web/HTML/Referencia /pt-PT/docs/Web/HTML/Reference +/pt-PT/docs/Web/HTML/Tipos_de_hiperligacao /pt-PT/docs/Web/HTML/Link_types +/pt-PT/docs/Web/HTML/Utilizar_a_cache_de_aplicacao /pt-PT/docs/Web/HTML/Using_the_application_cache /pt-PT/docs/Web/HTML_Linguagem_de_marcacao_de_hipertexto /pt-PT/docs/Web/HTML +/pt-PT/docs/Web/JavaScript/Estruturas_de_dados /pt-PT/docs/Web/JavaScript/Data_structures +/pt-PT/docs/Web/JavaScript/Gestao_Memoria /pt-PT/docs/Web/JavaScript/Memory_Management +/pt-PT/docs/Web/JavaScript/Guia /pt-PT/docs/Web/JavaScript/Guide +/pt-PT/docs/Web/JavaScript/Guia/Detalhes_do_modelo_de_objeto /pt-PT/docs/Web/JavaScript/Guide/Details_of_the_Object_Model +/pt-PT/docs/Web/JavaScript/Guia/Expressoes_e_Operadores /pt-PT/docs/orphaned/Web/JavaScript/Guia/Expressoes_e_Operadores +/pt-PT/docs/Web/JavaScript/Guia/Gramática_e_tipos /pt-PT/docs/Web/JavaScript/Guide/Grammar_and_types +/pt-PT/docs/Web/JavaScript/Guia/Introdução /pt-PT/docs/Web/JavaScript/Guide/Introduction +/pt-PT/docs/Web/JavaScript/Guia/Introdução_ao_JavaScript /pt-PT/docs/orphaned/Web/JavaScript/Guia/Introdução_ao_JavaScript +/pt-PT/docs/Web/JavaScript/Guia/Sobre /pt-PT/docs/orphaned/Web/JavaScript/Guia/Sobre +/pt-PT/docs/Web/JavaScript/Guia/Valores,_Variáveis_e_Literais /pt-PT/docs/orphaned/Web/JavaScript/Guia/Valores,_Variáveis_e_Literais /pt-PT/docs/Web/JavaScript/New_in_JavaScript /pt-PT/docs/Web/JavaScript/Novidades_no_JavaScript -/pt-PT/docs/XForms:Controles_Customizados /pt-PT/docs/XForms/Controles_Customizados -/pt-PT/docs/XPath:Eixos /pt-PT/docs/XPath/Eixos -/pt-PT/docs/XPath:Funções /pt-PT/docs/XPath/Funções +/pt-PT/docs/Web/JavaScript/O_que_é_o_JavaScript /pt-PT/docs/orphaned/Web/JavaScript/O_que_é_o_JavaScript +/pt-PT/docs/Web/JavaScript/Reference/Errors/declaração_função_sem_nome /pt-PT/docs/Web/JavaScript/Reference/Errors/Unnamed_function_statement +/pt-PT/docs/Web/JavaScript/Reference/Extratos_e_declarações /pt-PT/docs/Web/JavaScript/Reference/Statements +/pt-PT/docs/Web/JavaScript/Reference/Extratos_e_declarações/bloco /pt-PT/docs/Web/JavaScript/Reference/Statements/block +/pt-PT/docs/Web/JavaScript/Reference/Extratos_e_declarações/for /pt-PT/docs/Web/JavaScript/Reference/Statements/for +/pt-PT/docs/Web/JavaScript/Reference/Extratos_e_declarações/return /pt-PT/docs/Web/JavaScript/Reference/Statements/return +/pt-PT/docs/Web/JavaScript/Reference/Extratos_e_declarações/throw /pt-PT/docs/Web/JavaScript/Reference/Statements/throw +/pt-PT/docs/Web/JavaScript/Reference/Funcionalidades_obsoletas /pt-PT/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features +/pt-PT/docs/Web/JavaScript/Reference/Funcoes /pt-PT/docs/Web/JavaScript/Reference/Functions +/pt-PT/docs/Web/JavaScript/Reference/Funcoes/Funcoes_seta /pt-PT/docs/Web/JavaScript/Reference/Functions/Arrow_functions +/pt-PT/docs/Web/JavaScript/Reference/Funcoes/arguments /pt-PT/docs/Web/JavaScript/Reference/Functions/arguments +/pt-PT/docs/Web/JavaScript/Reference/Funcoes/parametros_rest /pt-PT/docs/Web/JavaScript/Reference/Functions/rest_parameters +/pt-PT/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype /pt-PT/docs/orphaned/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype +/pt-PT/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype /pt-PT/docs/conflicting/Web/JavaScript/Reference/Global_Objects/Number +/pt-PT/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype /pt-PT/docs/conflicting/Web/JavaScript/Reference/Global_Objects/Object +/pt-PT/docs/Web/JavaScript/Reference/Operadores /pt-PT/docs/Web/JavaScript/Reference/Operators +/pt-PT/docs/Web/JavaScript/Reference/Operadores/Operador_virgula /pt-PT/docs/Web/JavaScript/Reference/Operators/Comma_Operator +/pt-PT/docs/Web/JavaScript/Reference/Operadores/Precedencia_operador /pt-PT/docs/Web/JavaScript/Reference/Operators/Operator_Precedence +/pt-PT/docs/Web/JavaScript/Reference/Operadores/função /pt-PT/docs/Web/JavaScript/Reference/Operators/function +/pt-PT/docs/Web/JavaScript/Reference/Sobre /pt-PT/docs/Web/JavaScript/Reference/About +/pt-PT/docs/Web/MathML/Attribute/Valores /pt-PT/docs/Web/MathML/Attribute/Values +/pt-PT/docs/Web/MathML/Examples/Derivar_a_Formula_Resolvente /pt-PT/docs/Web/MathML/Examples/Deriving_the_Quadratic_Formula +/pt-PT/docs/Web/MathML/Examples/MathML_teorema_de_Pitagoras /pt-PT/docs/Web/MathML/Examples/MathML_Pythagorean_Theorem +/pt-PT/docs/Web/Progressive_web_apps/Guia_de_programacao /pt-PT/docs/Web/Progressive_web_apps/Developer_guide +/pt-PT/docs/Web/Progressive_web_apps/Identificavel /pt-PT/docs/conflicting/Web/Progressive_web_apps +/pt-PT/docs/Web/Progressive_web_apps/Responsivo /pt-PT/docs/conflicting/Web/Progressive_web_apps/Responsive/responsive_design_building_blocks +/pt-PT/docs/Web/Progressive_web_apps/Responsivo/Elementos_base_desenho_adaptavel /pt-PT/docs/Web/Progressive_web_apps/Responsive/responsive_design_building_blocks +/pt-PT/docs/Web/Progressive_web_apps/Seguro /pt-PT/docs/conflicting/Web/Progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a +/pt-PT/docs/Web/SVG/Aplicar_efeitos_SVG_conteudo_HTML /pt-PT/docs/Web/SVG/Applying_SVG_effects_to_HTML_content +/pt-PT/docs/Web/SVG/Namespaces_Crash_Course/Exemplo /pt-PT/docs/Web/SVG/Namespaces_Crash_Course/Example +/pt-PT/docs/Web/SVG/SVG_animacao_com_SMIL /pt-PT/docs/Web/SVG/SVG_animation_with_SMIL +/pt-PT/docs/Web/SVG/Tutorial/Introducao /pt-PT/docs/Web/SVG/Tutorial/Introduction +/pt-PT/docs/Web/SVG/Tutorial/SVG_na_Introducao_HTML /pt-PT/docs/Web/SVG/Tutorial/SVG_In_HTML_Introduction +/pt-PT/docs/Web/Security/Conteudo_misto /pt-PT/docs/Web/Security/Mixed_content +/pt-PT/docs/Web/Security/Mixed_content/Como_corrigir_um_site_da_Web_com_conteudo_misto_bloqueado /pt-PT/docs/Web/Security/Mixed_content/How_to_fix_website_with_mixed_content +/pt-PT/docs/Web/Seguranca /pt-PT/docs/Web/Security +/pt-PT/docs/Web/Seguranca/Palavras-passe_inseguras /pt-PT/docs/Web/Security/Insecure_passwords +/pt-PT/docs/Web/Seguranca/Same-origin_policy /pt-PT/docs/Web/Security/Same-origin_policy +/pt-PT/docs/Web/Tutoriais /pt-PT/docs/Web/Tutorials +/pt-PT/docs/Web/WebAPI /pt-PT/docs/conflicting/Web/API +/pt-PT/docs/Web/XML/Introducao_a_XML /pt-PT/docs/Web/XML/XML_introduction +/pt-PT/docs/Web/XSLT/Comunidade /pt-PT/docs/orphaned/Web/XSLT/Comunidade +/pt-PT/docs/Web/XSLT/Elementos /pt-PT/docs/orphaned/Web/XSLT/Elementos +/pt-PT/docs/WebAssembly/Utilizar_API_JavaScript_WebAssembly /pt-PT/docs/WebAssembly/Using_the_JavaScript_API +/pt-PT/docs/XForms /pt-PT/docs/orphaned/XForms +/pt-PT/docs/XForms/Controles_Customizados /pt-PT/docs/orphaned/XForms/Controles_Customizados +/pt-PT/docs/XForms:Controles_Customizados /pt-PT/docs/orphaned/XForms/Controles_Customizados +/pt-PT/docs/XForms_especiais_para_Mozilla /pt-PT/docs/orphaned/XForms_especiais_para_Mozilla +/pt-PT/docs/XHTML /pt-PT/docs/Glossary/XHTML +/pt-PT/docs/XMLHttpRequest /pt-PT/docs/conflicting/Web/API/XMLHttpRequest +/pt-PT/docs/XML_no_Mozilla /pt-PT/docs/orphaned/XML_no_Mozilla +/pt-PT/docs/XPath/Eixos /pt-PT/docs/orphaned/XPath/Eixos +/pt-PT/docs/XPath/Funções /pt-PT/docs/orphaned/XPath/Funções +/pt-PT/docs/XPath:Eixos /pt-PT/docs/orphaned/XPath/Eixos +/pt-PT/docs/XPath:Funções /pt-PT/docs/orphaned/XPath/Funções /pt-PT/docs/XSLT /pt-PT/docs/Web/XSLT -/pt-PT/docs/XSLT/Comunidade /pt-PT/docs/Web/XSLT/Comunidade -/pt-PT/docs/XSLT/Elementos /pt-PT/docs/Web/XSLT/Elementos -/pt-PT/docs/XSLT:Comunidade /pt-PT/docs/Web/XSLT/Comunidade -/pt-PT/docs/XSLT:Elementos /pt-PT/docs/Web/XSLT/Elementos +/pt-PT/docs/XSLT/Comunidade /pt-PT/docs/orphaned/Web/XSLT/Comunidade +/pt-PT/docs/XSLT/Elementos /pt-PT/docs/orphaned/Web/XSLT/Elementos +/pt-PT/docs/XSLT:Comunidade /pt-PT/docs/orphaned/Web/XSLT/Comunidade +/pt-PT/docs/XSLT:Elementos /pt-PT/docs/orphaned/Web/XSLT/Elementos /pt-PT/docs/en /en-US/ -/pt-PT/docs/manipuladores_de_protocolos_baseados_na_web /pt-PT/docs/Manipuladores_de_protocolo_web +/pt-PT/docs/manipuladores_de_protocolos_baseados_na_web /pt-PT/docs/orphaned/Manipuladores_de_protocolo_web diff --git a/files/pt-pt/_wikihistory.json b/files/pt-pt/_wikihistory.json index 5fdcdf5741..fdcc9562e9 100644 --- a/files/pt-pt/_wikihistory.json +++ b/files/pt-pt/_wikihistory.json @@ -1,5192 +1,5192 @@ { - "Acentuação_para_conteúdos_carregados_por_AJAX": { - "modified": "2019-03-23T23:50:32.509Z", - "contributors": [ - "Leandro Mercês Xavier", - "JulioGreff", - "Micox", - "Douglas", - "Pfsergio1968" - ] - }, - "Atualizando_extensões_para_o_Firefox_3": { - "modified": "2019-12-13T20:33:32.517Z", + "Games/Tutorials/2D_breakout_game_Phaser": { + "modified": "2019-03-18T21:30:42.706Z", "contributors": [ "wbamberg", - "fscholz", - "SphinxKnight", - "Anonymous", - "teoli", - "Sheppy", - "Leandro Mercês Xavier", - "Verruckt" + "chrisdavidmills" ] }, - "Atualizando_extensões_para_o_Firefox_3.5": { - "modified": "2019-03-24T00:00:34.452Z", + "Glossary/API": { + "modified": "2019-03-23T22:32:07.433Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Componentes": { - "modified": "2019-03-23T23:40:02.292Z", + "Learn": { + "modified": "2020-07-21T13:37:41.344Z", "contributors": [ + "joaonunomota", + "VITOR77777", + "PRigter", "SphinxKnight", - "GrandeBuzina" + "svarlamov", + "Anonymous", + "DoviMaj", + "joao-neves95", + "albertocastro", + "mrmorais", + "Jeremie" ] }, - "Configurando_um_servidor_de_atualização": { - "modified": "2019-01-16T14:51:09.548Z", + "Learn/CSS": { + "modified": "2020-07-16T22:25:36.875Z", "contributors": [ - "Leandro Mercês Xavier" + "joaonunomota", + "Anonymous" ] }, - "Construir_uma_Extensão": { - "modified": "2019-03-24T00:04:05.919Z", + "Learn/CSS/Howto": { + "modified": "2020-07-16T22:25:44.063Z", "contributors": [ - "teoli", - "fscholz", - "Rhuanbarros", - "Rsjuliao", - "Horyuu1", - "Leandro Mercês Xavier", - "Dudaott", - "Ecocam", - "Toyux", - "Verruckt", - "Luis Henrique Sousa", - "Mr.leal", - "Joker pt", - "Brunnolou", - "Bermonruf" + "Anonymous", + "chrisdavidmills" ] }, - "Controles_XUL": { - "modified": "2019-03-24T00:03:56.894Z", + "Learn/Front-end_web_developer": { + "modified": "2020-12-12T20:48:26.981Z", "contributors": [ - "fscholz", - "Luis Henrique Sousa", - "Verruckt" + "polonia", + "nuruldecarvalho", + "VITOR77777" ] }, - "Criando_plugins_OpenSearch_para_o_Firefox": { - "modified": "2019-03-24T00:00:54.849Z", + "Learn/HTML": { + "modified": "2020-07-16T22:22:22.937Z", "contributors": [ - "tregagnon", - "Verruckt", - "Rodrigoknascimento" + "Anonymous", + "RicardoLovatel", + "chrisdavidmills" ] }, - "Criando_um_visual_para_o_Firefox": { - "modified": "2019-03-23T23:51:38.630Z", + "Learn/HTML/Tables": { + "modified": "2020-07-16T22:25:15.032Z", "contributors": [ - "SphinxKnight", - "Milona87", - "Thestrongergod", - "Verruckt", - "Camaleaun" + "Anonymous", + "thetoni" ] }, - "Criar_uma_pele_para_o_Firefox": { - "modified": "2019-01-16T16:12:28.704Z", + "Learn/Index": { + "modified": "2020-07-16T22:33:40.763Z", "contributors": [ - "MarceloGhelman", - "Leandro Mercês Xavier", - "Amrlima" + "Anonymous" ] }, - "DHTML": { - "modified": "2019-01-16T16:23:46.538Z", + "Learn/JavaScript": { + "modified": "2020-07-16T22:29:43.788Z", "contributors": [ - "SphinxKnight", - "RuiMaciel" + "Anonymous", + "Japroriple" ] }, - "DOM/DOM_Reference": { - "modified": "2019-03-23T23:25:55.220Z", + "Learn/Tools_and_testing": { + "modified": "2020-07-16T22:38:57.196Z", "contributors": [ "Anonymous", - "Brettz9" + "Navin77" ] }, - "DOM/Selection": { - "modified": "2019-03-24T00:02:03.808Z", + "MDN": { + "modified": "2020-02-19T18:55:27.012Z", "contributors": [ + "jswisher", "SphinxKnight", - "danielwebsistemas" - ] - }, - "DOM/Storage": { - "modified": "2019-03-24T00:00:51.877Z", - "contributors": [ - "khalid32", - "Verruckt", - "Leandro Mercês Xavier" - ] - }, - "DOM/document.alinkColor": { - "modified": "2019-03-24T00:04:44.971Z", - "contributors": [ - "teoli", - "italo" + "Anonymous", + "wbamberg", + "Jeremie", + "davempso", + "Sheppy" ] }, - "DOM/document.bgColor": { - "modified": "2019-03-24T00:04:41.203Z", + "MDN/Contribute": { + "modified": "2019-03-23T23:03:08.251Z", "contributors": [ - "teoli", - "italo" + "Anonymous", + "wbamberg", + "alispivak" ] }, - "DOM/document.cookie": { - "modified": "2019-03-19T14:20:57.798Z", + "MDN/Contribute/Feedback": { + "modified": "2020-09-30T17:52:26.093Z", "contributors": [ - "lucasrenod", + "chrisdavidmills", + "jswisher", "SphinxKnight", - "gadelhas", - "teoli", - "italo" - ] - }, - "DOM/document.getElementsByClassName": { - "modified": "2019-12-02T03:58:42.536Z", - "contributors": [ - "jestevespereira", - "khalid32", - "teoli", - "Leandro Mercês Xavier", - "Verruckt" - ] - }, - "DOM/element": { - "modified": "2020-10-15T21:16:02.585Z", - "contributors": [ "Anonymous", - "MauroBonucci", - "khalid32", - "Leandro Mercês Xavier", - "Davis.peixoto", - "Codigo13" + "wbamberg" ] }, - "DOM/element.appendChild": { - "modified": "2019-03-23T23:43:33.351Z", + "MDN/Contribute/Getting_started": { + "modified": "2020-09-30T17:15:31.197Z", "contributors": [ - "khalid32", - "teoli", - "Leandro Mercês Xavier", - "Wingedx" + "chrisdavidmills", + "joaonunomota", + "Anonymous", + "wbamberg", + "riagva", + "davempso" ] }, - "DOM/element.clientLeft": { - "modified": "2019-03-23T23:49:26.792Z", + "MDN/Contribute/Howto": { + "modified": "2019-01-16T21:51:27.704Z", "contributors": [ - "khalid32", - "teoli", - "Leandro Mercês Xavier", - "Verruckt" + "wbamberg", + "Anonymous", + "jswisher" ] }, - "DOM/element.clientTop": { - "modified": "2019-03-23T23:49:30.994Z", + "MDN/Guidelines": { + "modified": "2020-09-30T15:31:28.524Z", "contributors": [ - "AshfaqHossain", - "teoli", - "Leandro Mercês Xavier", - "Verruckt" + "chrisdavidmills", + "wbamberg", + "Anonymous" ] }, - "DOM/element.cloneNode": { - "modified": "2019-09-30T14:07:35.240Z", + "MDN/Structures": { + "modified": "2020-09-30T12:57:09.511Z", "contributors": [ - "semisse", - "SphinxKnight", - "guerreirogabriel", - "Diogok", - "Glauco.basilio", - "Codigo13", - "Leandro Mercês Xavier" + "chrisdavidmills", + "wbamberg", + "jswisher" ] }, - "DOM/element.insertBefore": { - "modified": "2019-03-23T23:46:00.401Z", + "MDN/Structures/Macros": { + "modified": "2020-09-30T12:57:10.153Z", "contributors": [ - "jsx", - "Codigo13" + "chrisdavidmills", + "wbamberg", + "Anonymous" ] }, - "DOM_Inspector": { - "modified": "2020-07-16T22:36:24.733Z", + "MDN/Tools": { + "modified": "2020-09-30T16:53:22.697Z", "contributors": [ + "chrisdavidmills", "wbamberg", - "SphinxKnight", - "Anonymous", - "teoli", - "Verruckt" + "jswisher" ] }, - "DOM_Inspector/Introduction_to_DOM_Inspector": { - "modified": "2020-07-16T22:36:26.057Z", + "MDN/Tools/KumaScript": { + "modified": "2020-09-30T16:53:22.999Z", "contributors": [ + "chrisdavidmills", "wbamberg", "Anonymous" ] }, - "Desenhando_texto_usando_canvas": { - "modified": "2019-03-23T23:59:25.399Z", + "Mozilla": { + "modified": "2019-03-24T00:17:35.290Z", "contributors": [ - "Wladimir_Palant", - "maicon", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous", + "billhiba", + "Beria" ] }, - "FAQ_Extensões": { - "modified": "2019-01-16T14:39:04.547Z", + "Mozilla/Add-ons": { + "modified": "2019-03-18T21:08:20.167Z", "contributors": [ - "fscholz", - "Luis Henrique Sousa", - "Toyux", - "Verruckt", - "Calebeaires" + "Anonymous", + "nportugal", + "Anomitro_Munshi" ] }, - "Firefox_1.5_para_Desenvolvedores": { - "modified": "2019-03-24T00:02:26.260Z", + "Mozilla/Add-ons/WebExtensions": { + "modified": "2019-03-18T20:49:08.711Z", "contributors": [ - "wbamberg", - "SphinxKnight", - "fscholz", - "Takenbot", - "Leandro Mercês Xavier" + "Anonymous", + "wbamberg" ] }, - "Firefox_2_para_desenvolvedores": { - "modified": "2019-03-24T00:02:35.537Z", + "Mozilla/Add-ons/WebExtensions/API": { + "modified": "2019-11-26T22:19:55.515Z", "contributors": [ "wbamberg", - "SphinxKnight", - "fscholz", - "Leandro Mercês Xavier", - "Kayalemao" + "Anonymous" ] }, - "Firefox_3.5_para_desenvolvedores": { - "modified": "2019-03-24T00:00:50.782Z", + "Mozilla/Add-ons/WebExtensions/API/browserAction": { + "modified": "2020-10-15T21:59:49.630Z", "contributors": [ "wbamberg", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Firefox_3.6_para_desenvolvedores": { - "modified": "2019-12-13T20:33:40.975Z", + "Mozilla/Add-ons/WebExtensions/API/browsingData": { + "modified": "2020-10-15T22:14:48.933Z", "contributors": [ - "wbamberg", - "SphinxKnight", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "ExE-Boss" ] }, - "Firefox_3_para_desenvolvedores": { - "modified": "2019-01-16T14:32:08.166Z", + "Mozilla/Add-ons/WebExtensions/API/browsingData/removePluginData": { + "modified": "2020-10-15T22:14:40.836Z", "contributors": [ - "teoli", - "fscholz", - "Verruckt", - "Fernandopsilveira", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Firefox_4_para_desenvolvedores": { - "modified": "2019-11-21T00:43:18.363Z", + "Mozilla/Add-ons/WebExtensions/API/i18n": { + "modified": "2020-10-15T22:14:41.219Z", "contributors": [ - "wbamberg", - "Sebastianz", - "Prinz_Rana", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Firefox_5_para_desenvolvedores": { - "modified": "2019-03-24T00:09:30.352Z", + "Mozilla/Add-ons/WebExtensions/API/pageAction": { + "modified": "2020-10-15T21:59:47.365Z", "contributors": [ "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Firefox_6_para_desenvolvedores": { - "modified": "2019-11-21T00:43:07.958Z", + "Mozilla/Add-ons/WebExtensions/API/sidebarAction": { + "modified": "2020-10-15T22:06:57.394Z", "contributors": [ "wbamberg", - "Anonymous", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Games/Tutorials/2D_breakout_game_Phaser": { - "modified": "2019-03-18T21:30:42.706Z", + "Mozilla/Add-ons/WebExtensions/Internationalization": { + "modified": "2019-03-18T20:56:21.219Z", "contributors": [ - "wbamberg", - "chrisdavidmills" + "Anonymous" ] }, - "Glossary/API": { - "modified": "2019-03-23T22:32:07.433Z", + "Mozilla/Add-ons/WebExtensions/Tips": { + "modified": "2019-03-18T21:01:44.598Z", "contributors": [ - "Anonymous" + "SphinxKnight" ] }, - "Glossário": { - "modified": "2020-10-07T11:13:28.151Z", + "Mozilla/Add-ons/WebExtensions/manifest.json": { + "modified": "2020-10-15T21:59:48.039Z", "contributors": [ - "peterbe", - "joaonunomota", - "SphinxKnight", - "Anonymous", + "Painatalman", "wbamberg" ] }, - "Glossário/404": { - "modified": "2020-06-25T18:13:41.660Z", + "Mozilla/Add-ons/WebExtensions/manifest.json/browser_action": { + "modified": "2020-10-15T21:59:47.236Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Glossário/502": { - "modified": "2020-06-25T18:28:46.890Z", + "Mozilla/Add-ons/WebExtensions/manifest.json/browser_specific_settings": { + "modified": "2020-10-15T22:07:31.462Z", "contributors": [ - "joaonunomota" + "wbamberg", + "ExE-Boss", + "Anonymous" ] }, - "Glossário/AJAX": { - "modified": "2020-06-09T08:11:59.760Z", + "Mozilla/Add-ons/WebExtensions/manifest.json/devtools_page": { + "modified": "2020-10-15T21:59:47.989Z", "contributors": [ - "joaonunomota" + "wbamberg", + "Anonymous" ] }, - "Glossário/API": { - "modified": "2020-10-25T11:15:06.759Z", + "Mozilla/Developer_guide/Source_Code": { + "modified": "2019-03-18T21:45:30.638Z", "contributors": [ - "Zamalor", - "joaonunomota", - "Anonymous" + "ntim" ] }, - "Glossário/ARIA": { - "modified": "2020-06-11T20:31:33.120Z", + "Mozilla/Firefox": { + "modified": "2019-09-10T15:01:27.677Z", "contributors": [ - "joaonunomota" + "SphinxKnight", + "Anonymous", + "wbamberg", + "albertocastro", + "Sheppy" ] }, - "Glossário/Acessibilidade": { - "modified": "2019-03-18T21:47:01.702Z", + "Mozilla/Firefox/Releases": { + "modified": "2019-03-18T21:15:03.747Z", "contributors": [ - "Anonymous" + "Anonymous", + "wbamberg", + "Sheppy" ] }, - "Glossário/Argumento": { - "modified": "2019-03-18T21:17:57.812Z", + "Mozilla/Firefox/Releases/3": { + "modified": "2019-03-23T23:19:50.195Z", "contributors": [ - "Anonymous" + "wbamberg", + "ethertank" ] }, - "Glossário/Assinatura": { - "modified": "2019-03-23T22:12:54.952Z", + "Mozilla/Firefox/Releases/70": { + "modified": "2019-10-01T09:44:22.188Z", "contributors": [ "Anonymous" ] }, - "Glossário/BigInt": { - "modified": "2020-06-12T14:16:25.328Z", + "Tools": { + "modified": "2020-07-16T22:44:17.493Z", "contributors": [ - "joaonunomota" + "SphinxKnight", + "Anonymous", + "wbamberg", + "robert882", + "Leite", + "caobarbosa", + "Timmi" ] }, - "Glossário/CIA": { - "modified": "2020-06-11T20:33:04.482Z", + "Tools/Debugger": { + "modified": "2020-07-16T22:35:06.168Z", "contributors": [ - "joaonunomota" + "Anonymous", + "wbamberg" ] }, - "Glossário/CRLF": { - "modified": "2020-06-12T13:10:14.562Z", + "Tools/Debugger/How_to": { + "modified": "2020-07-16T22:35:08.333Z" + }, + "Tools/Debugger/How_to/Use_a_source_map": { + "modified": "2020-09-11T09:41:20.649Z", "contributors": [ - "joaonunomota" + "pedro-surf", + "Anonymous" ] }, - "Glossário/CRUD": { - "modified": "2020-06-11T20:38:17.457Z", + "Tools/Debugger/Source_map_errors": { + "modified": "2020-07-16T22:35:19.577Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Glossário/Cabeçalho_de_entidade": { - "modified": "2020-07-25T18:10:04.388Z", + "Tools/Network_Monitor": { + "modified": "2020-07-16T22:35:31.240Z", "contributors": [ - "joaonunomota" + "Anonymous", + "wbamberg" ] }, - "Glossário/Cache": { - "modified": "2020-06-07T12:38:40.205Z", + "Tools/Page_Inspector": { + "modified": "2020-07-16T22:34:29.429Z", "contributors": [ - "joaonunomota" + "wbamberg", + "Anonymous", + "DevAsh" ] }, - "Glossário/Compilar": { - "modified": "2019-03-23T22:01:24.745Z", + "Tools/Page_Inspector/How_to": { + "modified": "2020-07-16T22:34:31.978Z", "contributors": [ - "Anonymous" + "wbamberg", + "Anonymous", + "sidgan" ] }, - "Glossário/Compressao_GZip": { - "modified": "2019-03-18T21:46:58.480Z", + "Tools/Page_Inspector/How_to/Visualize_transforms": { + "modified": "2020-07-16T22:34:39.722Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Glossário/DOM": { - "modified": "2019-10-08T09:31:32.173Z", + "Tools/Remote_Debugging": { + "modified": "2020-07-16T22:35:37.988Z", "contributors": [ "Anonymous", - "GoToLoop" + "wbamberg", + "Joao_Silva27" ] }, - "Glossário/ECMA": { - "modified": "2019-03-23T22:30:19.413Z", + "Tools/Remote_Debugging/Debugging_Firefox_Desktop": { + "modified": "2020-07-16T22:35:41.262Z", "contributors": [ - "GoToLoop" + "Anonymous" ] }, - "Glossário/Eixo_principal": { - "modified": "2019-04-08T06:57:09.138Z", + "Tools/Tools_Toolbox": { + "modified": "2020-07-16T22:35:28.091Z", "contributors": [ - "diogo-panaca" + "wbamberg", + "Anonymous" ] }, - "Glossário/Eixo_transversal": { - "modified": "2019-04-08T06:58:12.600Z", + "Tools/about:debugging": { + "modified": "2020-07-16T22:36:33.106Z", "contributors": [ - "diogo-panaca" + "Anonymous", + "wbamberg" ] }, - "Glossário/Elemento": { - "modified": "2019-03-18T21:18:07.800Z", + "Web": { + "modified": "2020-05-03T13:08:13.142Z", "contributors": [ - "Anonymous" + "Anonymous", + "polonia", + "didi9999", + "joao-neves95", + "carlosrainhaaraujo", + "ethertank" ] }, - "Glossário/Etiqueta": { - "modified": "2019-03-23T22:01:42.150Z", + "Web/API": { + "modified": "2019-03-23T22:39:25.827Z", "contributors": [ - "Anonymous" + "Anonymous", + "teoli", + "carlosrainhaaraujo" ] }, - "Glossário/Extensoes_da_Web": { - "modified": "2019-03-18T21:37:24.767Z", + "Web/API/Animation": { + "modified": "2020-10-15T22:09:54.586Z", "contributors": [ "Anonymous" ] }, - "Glossário/Favicon": { - "modified": "2020-04-30T05:49:13.226Z", + "Web/API/AudioNode": { + "modified": "2019-03-23T22:12:47.243Z", "contributors": [ - "adilsonmandlate" + "trusktr" ] }, - "Glossário/Flexbox": { - "modified": "2019-04-08T06:38:43.855Z", + "Web/API/Blob": { + "modified": "2020-10-15T22:32:41.617Z", "contributors": [ - "diogo-panaca" + "Yayure" ] }, - "Glossário/GCS": { - "modified": "2020-06-13T09:32:48.386Z", + "Web/API/Blob/Blob": { + "modified": "2020-11-16T10:19:01.877Z", "contributors": [ "joaonunomota" ] }, - "Glossário/Git": { - "modified": "2020-06-13T09:39:03.707Z", + "Web/API/Blob/size": { + "modified": "2020-10-15T22:32:50.862Z", "contributors": [ "joaonunomota" ] }, - "Glossário/HTML": { - "modified": "2019-03-23T22:13:01.389Z", + "Web/API/Blob/type": { + "modified": "2020-10-15T22:33:10.637Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Hipertexto": { - "modified": "2019-03-23T22:01:40.877Z", + "Web/API/Client": { + "modified": "2020-10-15T22:03:06.133Z", "contributors": [ "Anonymous" ] }, - "Glossário/IANA": { - "modified": "2020-06-07T13:01:45.679Z", + "Web/API/CloseEvent": { + "modified": "2020-10-15T22:32:54.165Z", "contributors": [ "joaonunomota" ] }, - "Glossário/ISP": { - "modified": "2020-07-16T14:02:41.646Z", + "Web/API/CloseEvent/CloseEvent": { + "modified": "2020-10-15T22:32:51.831Z", "contributors": [ "joaonunomota" ] }, - "Glossário/Idempotent": { - "modified": "2019-07-11T10:59:59.365Z", + "Web/API/DOMString": { + "modified": "2020-08-12T17:28:52.261Z", "contributors": [ - "FilipePintoReis" + "joaonunomota" ] }, - "Glossário/IndexedDB": { - "modified": "2019-03-23T22:30:22.618Z", + "Web/API/Document": { + "modified": "2019-07-02T18:26:33.145Z", "contributors": [ - "GoToLoop" + "Anonymous", + "chrisdavidmills" ] }, - "Glossário/Lazy_load": { - "modified": "2020-06-09T04:59:38.616Z", + "Web/API/Document/querySelector": { + "modified": "2020-10-15T22:32:00.428Z", "contributors": [ "joaonunomota" ] }, - "Glossário/Metadados": { - "modified": "2019-03-18T21:46:57.702Z", + "Web/API/Document/visibilitychange_event": { + "modified": "2019-04-08T07:39:14.855Z", "contributors": [ + "irenesmith", "Anonymous" ] }, - "Glossário/MitM": { - "modified": "2019-03-18T21:29:48.838Z", + "Web/API/File": { + "modified": "2020-10-15T22:32:24.351Z", "contributors": [ - "Anonymous" + "Yayure" ] }, - "Glossário/Modo_de_operação_de_cifra_de_bloco": { - "modified": "2020-07-19T20:41:55.171Z", + "Web/API/File/File": { + "modified": "2020-10-15T22:33:11.221Z", "contributors": [ "joaonunomota" ] }, - "Glossário/Motor": { - "modified": "2019-03-23T22:24:10.538Z", + "Web/API/File/fileName": { + "modified": "2020-08-08T18:37:05.171Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Navegador": { - "modified": "2019-03-23T22:01:42.054Z", + "Web/API/File/fileSize": { + "modified": "2020-08-08T18:32:45.995Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Node.js": { - "modified": "2019-03-23T22:30:21.428Z", + "Web/API/File/getAsBinary": { + "modified": "2020-08-11T04:16:46.870Z", "contributors": [ - "Anonymous", - "GoToLoop" + "joaonunomota" ] }, - "Glossário/OOP": { - "modified": "2019-03-18T21:47:01.837Z", + "Web/API/File/getAsDataURL": { + "modified": "2020-08-08T18:57:17.906Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/OTA": { - "modified": "2019-03-23T22:30:21.528Z", + "Web/API/File/getAsText": { + "modified": "2020-08-11T05:01:57.694Z", "contributors": [ - "GoToLoop" + "joaonunomota" ] }, - "Glossário/Objeto": { - "modified": "2019-03-18T21:46:57.221Z", + "Web/API/File/lastModified": { + "modified": "2020-10-17T08:26:52.375Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Polyfill": { - "modified": "2019-03-23T22:04:04.730Z", + "Web/API/File/lastModifiedDate": { + "modified": "2020-10-15T22:32:46.653Z", "contributors": [ - "pedrodfcosta" + "joaonunomota" ] }, - "Glossário/Prototype-based_programming": { - "modified": "2019-03-18T21:47:01.974Z", + "Web/API/File/mozFullPath": { + "modified": "2020-08-08T18:43:12.882Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Referencia_de_objeto": { - "modified": "2019-03-18T21:18:01.122Z", + "Web/API/File/name": { + "modified": "2020-10-15T22:32:23.452Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Servidor": { - "modified": "2019-03-23T22:30:25.987Z", + "Web/API/File/type": { + "modified": "2020-10-15T22:32:40.925Z", "contributors": [ - "GoToLoop" + "joaonunomota" ] }, - "Glossário/UTF-8": { - "modified": "2019-03-18T20:40:41.143Z", + "Web/API/File/webkitRelativePath": { + "modified": "2020-11-17T19:01:45.948Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Valor": { - "modified": "2019-03-18T21:18:07.651Z", + "Web/API/FileReader": { + "modified": "2019-03-18T21:16:40.698Z", "contributors": [ - "Anonymous" + "Sheppy" ] }, - "Glossário/Viewport": { - "modified": "2020-06-10T11:59:40.452Z", + "Web/API/FileReader/abort": { + "modified": "2020-10-15T22:32:42.433Z", "contributors": [ "joaonunomota" ] }, - "Glossário/Viewport_Visual": { - "modified": "2020-06-10T13:52:57.763Z", + "Web/API/FileReader/error": { + "modified": "2020-10-15T22:32:24.839Z", "contributors": [ "joaonunomota" ] }, - "Glossário/WHATWG": { - "modified": "2020-06-12T08:44:24.569Z", + "Web/API/FileReader/readAsArrayBuffer": { + "modified": "2020-10-15T22:33:15.086Z", "contributors": [ "joaonunomota" ] }, - "Glossário/WebRTC": { - "modified": "2020-06-07T12:24:38.989Z", + "Web/API/FileReader/readAsBinaryString": { + "modified": "2020-10-15T21:37:25.343Z", "contributors": [ - "joaonunomota" + "joaonunomota", + "DouglasValdo" ] }, - "Glossário/WebVTT": { - "modified": "2020-06-12T12:26:29.739Z", + "Web/API/FileReader/readAsDataURL": { + "modified": "2020-10-15T22:34:36.565Z", "contributors": [ "joaonunomota" ] }, - "Glossário/World_Wide_Web": { - "modified": "2019-03-18T21:46:52.018Z", + "Web/API/FileReader/readAsText": { + "modified": "2020-10-15T22:34:36.289Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/Wrapper": { - "modified": "2019-03-18T21:17:53.688Z", + "Web/API/FileReader/readyState": { + "modified": "2020-11-15T12:35:45.700Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/XML": { - "modified": "2019-03-23T22:01:48.146Z", + "Web/API/FileReader/result": { + "modified": "2020-10-15T22:33:14.048Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Glossário/booliano": { - "modified": "2019-03-18T21:45:55.769Z", + "Web/API/Geolocation": { + "modified": "2019-03-23T22:01:56.989Z", "contributors": [ "Anonymous" ] }, - "Guia_do_desenvolvedor": { - "modified": "2019-03-24T00:00:34.143Z", - "contributors": [ - "SphinxKnight", - "teoli", - "Leandro Mercês Xavier" - ] - }, - "HTMLToDelete/Element/figure": { - "modified": "2019-03-24T00:07:13.574Z", - "contributors": [ - "wbamberg", - "jwhitlock", - "teoli", - "f.sanxz" - ] - }, - "JavaScript_Shells": { - "modified": "2019-03-23T23:49:32.077Z", + "Web/API/MathMLElement": { + "modified": "2020-10-15T22:33:03.137Z", "contributors": [ - "SphinxKnight", - "Verruckt" + "joaonunomota" ] }, - "Java_em_Extensões_do_Firefox": { - "modified": "2019-03-23T23:44:51.954Z", + "Web/API/MediaDevices": { + "modified": "2019-03-23T22:01:16.705Z", "contributors": [ - "SphinxKnight", - "RuiMaciel" + "jpmedley" ] }, - "Javascript_orientado_a_objetos": { - "modified": "2019-03-24T00:11:38.222Z", + "Web/API/MessageEvent": { + "modified": "2020-10-15T22:32:51.894Z", "contributors": [ - "flowck", - "Leandro Mercês Xavier" + "joaonunomota" ] }, - "Jogos": { - "modified": "2019-09-09T15:34:18.541Z", + "Web/API/NavigatorOnLine": { + "modified": "2019-03-23T22:01:59.308Z", "contributors": [ - "SphinxKnight", - "Aschlla", - "wbamberg", - "rPetas", - "fscholz", - "Anonymous" + "chrisdavidmills" ] }, - "Jogos/Tutoriais": { - "modified": "2019-03-18T21:30:51.808Z", + "Web/API/Node": { + "modified": "2019-03-23T23:22:11.442Z", "contributors": [ - "wbamberg", - "Anonymous" + "khalid32", + "carlosrainhaaraujo" ] }, - "Learn": { - "modified": "2020-07-21T13:37:41.344Z", + "Web/API/Notifications_API": { + "modified": "2019-03-23T22:42:31.459Z", "contributors": [ - "joaonunomota", - "VITOR77777", - "PRigter", - "SphinxKnight", - "svarlamov", - "Anonymous", - "DoviMaj", - "joao-neves95", - "albertocastro", - "mrmorais", - "Jeremie" + "Sebastianz" ] }, - "Learn/Acessibilidade": { - "modified": "2020-07-21T16:29:40.277Z", + "Web/API/Page_Visibility_API": { + "modified": "2019-03-18T21:42:30.274Z", "contributors": [ - "joaonunomota", "Anonymous" ] }, - "Learn/CSS": { - "modified": "2020-07-16T22:25:36.875Z", + "Web/API/Push_API": { + "modified": "2019-03-18T21:38:04.203Z", "contributors": [ - "joaonunomota", "Anonymous" ] }, - "Learn/CSS/Estilo_de_texto": { - "modified": "2020-07-16T22:26:00.007Z", + "Web/API/Service_Worker_API": { + "modified": "2019-10-08T09:27:10.284Z", "contributors": [ "Anonymous" ] }, - "Learn/CSS/Howto": { - "modified": "2020-07-16T22:25:44.063Z", + "Web/API/Service_Worker_API/Using_Service_Workers": { + "modified": "2019-10-08T09:25:19.208Z", "contributors": [ - "Anonymous", - "chrisdavidmills" + "Anonymous" ] }, - "Learn/CSS/Howto/FAQ_de_CSS": { - "modified": "2020-07-16T22:25:45.869Z", + "Web/API/SharedWorker": { + "modified": "2020-10-15T21:59:02.760Z", "contributors": [ + "joaonunomota", "Anonymous" ] }, - "Learn/Comecar_com_a_Web": { - "modified": "2020-11-09T11:59:04.208Z", + "Web/API/URLSearchParams": { + "modified": "2019-10-16T11:18:10.261Z", "contributors": [ - "joaonunomota", - "Anonymous" + "NunoJSantos", + "goldyteam" ] }, - "Learn/Comecar_com_a_Web/A_web_e_os_padroes_da_web": { - "modified": "2020-08-15T18:38:33.155Z", + "Web/API/WebGLRenderingContext": { + "modified": "2020-10-15T21:59:21.576Z", "contributors": [ - "joaonunomota", "Anonymous" ] }, - "Learn/Comecar_com_a_Web/Apresentacao_do_meu_site": { - "modified": "2020-07-16T22:34:19.154Z", + "Web/API/WebGL_API": { + "modified": "2020-10-15T21:46:44.276Z", "contributors": [ - "joaonunomota", - "diogo-panaca", "Anonymous" ] }, - "Learn/Comecar_com_a_Web/CSS_basico": { - "modified": "2020-08-17T15:28:30.827Z", + "Web/API/WebSocket": { + "modified": "2020-10-15T22:32:53.586Z", "contributors": [ - "joaonunomota", - "diogo-panaca", - "Anonymous" + "joaonunomota" ] }, - "Learn/Comecar_com_a_Web/Como_funciona_a_Web": { - "modified": "2020-07-21T16:44:13.094Z", + "Web/API/WebSocket/WebSocket": { + "modified": "2020-10-15T22:33:03.555Z", "contributors": [ - "joaonunomota", - "gabodin", - "Anonymous" + "joaonunomota" ] }, - "Learn/Comecar_com_a_Web/Elementar_de_JavaScript": { - "modified": "2020-08-17T15:31:44.919Z", + "Web/API/WebSockets_API": { + "modified": "2020-10-15T22:32:45.764Z", "contributors": [ - "joaonunomota", - "diogo-panaca", - "Anonymous" + "joaonunomota" ] }, - "Learn/Comecar_com_a_Web/HTML_basicos": { - "modified": "2020-08-15T18:37:16.181Z", + "Web/API/Web_Audio_API": { + "modified": "2019-03-23T22:12:41.433Z", "contributors": [ - "joaonunomota", - "diogo-panaca", "Anonymous", - "mrsilvino" + "erikadoyle" ] }, - "Learn/Comecar_com_a_Web/Installing_basic_software": { - "modified": "2020-07-23T08:51:53.513Z", + "Web/API/Web_Workers_API": { + "modified": "2019-03-23T22:02:18.370Z", "contributors": [ - "joaonunomota", - "diogo-panaca", - "Jacgrillon", - "Anonymous" + "VsevolodGolovanov" ] }, - "Learn/Comecar_com_a_Web/Lidar_com_ficheiros": { - "modified": "2020-07-20T16:01:08.653Z", + "Web/API/Web_Workers_API/Functions_and_classes_available_to_workers": { + "modified": "2019-03-23T22:02:20.388Z", "contributors": [ - "joaonunomota", - "diogo-panaca", "Anonymous" ] }, - "Learn/Comecar_com_a_Web/Publicar_o_seu_site_da_Web": { - "modified": "2020-08-17T15:33:14.323Z", + "Web/API/Window": { + "modified": "2019-03-23T22:01:06.730Z", "contributors": [ - "joaonunomota" + "Anonymous", + "goeffthomas" ] }, - "Learn/Front-end_web_developer": { - "modified": "2020-12-12T20:48:26.981Z", + "Web/API/Window/console": { + "modified": "2019-03-18T21:44:07.205Z", "contributors": [ - "polonia", - "nuruldecarvalho", - "VITOR77777" + "Anonymous" ] }, - "Learn/HTML": { - "modified": "2020-07-16T22:22:22.937Z", + "Web/API/Window/open": { + "modified": "2019-03-23T22:01:10.139Z", "contributors": [ - "Anonymous", - "RicardoLovatel", - "chrisdavidmills" + "SphinxKnight", + "Anonymous" ] }, - "Learn/HTML/Como": { - "modified": "2020-07-16T22:22:30.740Z", + "Web/API/Window/postMessage": { + "modified": "2019-06-04T14:57:56.992Z", "contributors": [ "Anonymous" ] }, - "Learn/HTML/Como/Adicionar_um_mapa_de_zona_clicavel_numa_imagem": { - "modified": "2020-07-16T22:22:43.567Z", + "Web/API/Worker": { + "modified": "2019-03-23T22:02:29.683Z", "contributors": [ "Anonymous" ] }, - "Learn/HTML/Introducao_ao_HTML": { - "modified": "2020-07-16T22:22:52.576Z", + "Web/API/XMLHttpRequest": { + "modified": "2020-10-15T21:59:27.066Z", "contributors": [ - "diogo-panaca", - "joaomc", + "fscholz", "Anonymous" ] }, - "Learn/HTML/Introducao_ao_HTML/Criar_hiperligacoes": { - "modified": "2020-07-16T22:23:46.700Z", + "Web/API/notification": { + "modified": "2019-03-23T22:51:36.861Z", "contributors": [ - "diogo-panaca" + "Anonymous", + "Japroriple" ] }, - "Learn/HTML/Introducao_ao_HTML/Depurar_HTML": { - "modified": "2020-07-16T22:24:15.706Z", + "Web/Accessibility/ARIA/ARIA_Techniques": { + "modified": "2020-09-18T21:14:54.007Z", "contributors": [ - "diogo-panaca" + "Wind1808" ] }, - "Learn/HTML/Introducao_ao_HTML/Estrutura_documento_website": { - "modified": "2020-07-16T22:24:08.727Z", + "Web/CSS": { + "modified": "2020-06-10T07:53:42.003Z", "contributors": [ - "diogo-panaca" + "joaonunomota", + "SphinxKnight", + "Anonymous", + "Fernando-SilvaBR", + "albertocastro", + "teoli", + "Verruckt", + "Leandro Mercês Xavier", + "Takenbot", + "RuiMaciel" ] }, - "Learn/HTML/Introducao_ao_HTML/Estruturar_pagina_de_conteudo": { - "modified": "2020-07-16T22:24:20.585Z", + "Web/CSS/@font-face": { + "modified": "2019-03-23T23:13:15.857Z", "contributors": [ - "diogo-panaca" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Learn/HTML/Introducao_ao_HTML/Formatacao_avancada_texto": { - "modified": "2020-07-16T22:23:57.791Z", + "Web/CSS/@import": { + "modified": "2019-03-23T23:47:07.977Z", "contributors": [ - "diogo-panaca" + "Anonymous", + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "Learn/HTML/Introducao_ao_HTML/Iniciacao_HTML": { - "modified": "2020-07-16T22:23:06.412Z", + "Web/CSS/@media": { + "modified": "2020-04-25T11:58:21.640Z", "contributors": [ - "cmccarreiro", - "Anonymous" + "myspeleo", + "diogo-panaca", + "Anonymous", + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "Learn/HTML/Introducao_ao_HTML/Os_metadados_de_head_em_HTML": { - "modified": "2020-07-16T22:23:23.598Z", + "Web/CSS/At-rule": { + "modified": "2019-03-23T22:24:56.828Z", "contributors": [ "Anonymous" ] }, - "Learn/HTML/Introducao_ao_HTML/demarcar_uma_carta": { - "modified": "2020-07-16T22:23:13.979Z", + "Web/CSS/CSS_Box_Model": { + "modified": "2019-03-23T22:12:41.880Z", "contributors": [ - "diogo-panaca" + "Sebastianz" ] }, - "Learn/HTML/Multimedia_and_embedding/Pagina_de_boas_vindas_da_Mozilla": { - "modified": "2020-07-16T22:25:08.049Z", + "Web/CSS/CSS_Columns": { + "modified": "2019-03-18T21:38:41.627Z", "contributors": [ - "diegobarcelar", - "Anonymous" + "mfluehr" ] }, - "Learn/HTML/Multimedia_e_integracao": { - "modified": "2020-07-16T22:24:28.825Z", + "Web/CSS/CSS_Flexible_Box_Layout": { + "modified": "2019-03-18T21:44:02.737Z", "contributors": [ - "Anonymous", - "chrisdavidmills" + "rachelandrew" ] }, - "Learn/HTML/Multimedia_e_integracao/Conteudo_de_audio_e_vídeo": { - "modified": "2020-07-16T22:24:56.333Z", + "Web/CSS/Replaced_element": { + "modified": "2019-03-23T22:32:04.311Z", + "contributors": [ + "andrekutianski", + "josketres" + ] + }, + "Web/CSS/Shorthand_properties": { + "modified": "2019-03-18T21:44:05.610Z", "contributors": [ "Anonymous" ] }, - "Learn/HTML/Tables": { - "modified": "2020-07-16T22:25:15.032Z", + "Web/CSS/background": { + "modified": "2019-03-23T23:46:35.449Z", "contributors": [ - "Anonymous", - "thetoni" + "SphinxKnight", + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "Learn/HTML/Tables/Avaliacao_Estruturar_os_dados_dos_planetas": { - "modified": "2020-07-16T22:25:30.543Z", + "Web/CSS/background-attachment": { + "modified": "2019-03-23T23:12:53.495Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "teoli", + "Verruckt" ] }, - "Learn/HTML/Tables/Avancada": { - "modified": "2020-07-16T22:25:27.234Z", + "Web/CSS/background-color": { + "modified": "2019-03-23T22:16:20.029Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "teoli", + "Verruckt", + "ethertank" ] }, - "Learn/HTML/Tables/Basicos": { - "modified": "2020-07-16T22:25:22.105Z", + "Web/CSS/background-image": { + "modified": "2019-03-23T23:47:07.090Z", "contributors": [ - "diogo-panaca", - "Anonymous" + "SphinxKnight", + "teoli", + "Verruckt" ] }, - "Learn/Index": { - "modified": "2020-07-16T22:33:40.763Z", + "Web/CSS/background-position": { + "modified": "2019-03-23T23:47:05.241Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" + ] + }, + "Web/CSS/background-repeat": { + "modified": "2019-03-18T21:15:14.751Z", + "contributors": [ + "SphinxKnight", + "teoli", + "Verruckt" + ] + }, + "Web/CSS/border": { + "modified": "2019-01-16T15:59:54.146Z", + "contributors": [ + "teoli", + "Verruckt", + "Luis Henrique Sousa" + ] + }, + "Web/CSS/border-bottom": { + "modified": "2019-03-23T23:47:10.248Z", + "contributors": [ + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/JavaScript": { - "modified": "2020-07-16T22:29:43.788Z", + "Web/CSS/border-bottom-color": { + "modified": "2019-03-23T23:47:06.644Z", "contributors": [ - "Anonymous", - "Japroriple" + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/JavaScript/Primeiros_passos": { - "modified": "2020-07-16T22:29:54.837Z", + "Web/CSS/border-bottom-style": { + "modified": "2019-03-23T23:47:07.572Z", "contributors": [ - "Anonymous", - "Elllenn" + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/No-servidor": { - "modified": "2020-07-16T22:36:01.831Z", + "Web/CSS/border-bottom-width": { + "modified": "2019-03-23T23:47:10.824Z", "contributors": [ - "Anonymous", - "joao-neves95" + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/No-servidor/Django": { - "modified": "2020-07-16T22:36:35.255Z", + "Web/CSS/border-collapse": { + "modified": "2019-03-23T23:47:06.488Z", "contributors": [ - "Anonymous" + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/No-servidor/Express_Nodejs": { - "modified": "2020-07-16T22:37:54.969Z", + "Web/CSS/border-color": { + "modified": "2019-03-24T00:02:05.127Z", "contributors": [ - "Anonymous", - "joao-neves95" + "wbamberg", + "teoli", + "gerson23", + "Verruckt" ] }, - "Learn/No-servidor/Express_Nodejs/Configurar_um_meio_de_desenvolvimento_Node": { - "modified": "2020-07-16T22:38:00.728Z", + "Web/CSS/border-left": { + "modified": "2019-01-16T15:59:39.346Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/No-servidor/Express_Nodejs/Introduction": { - "modified": "2020-07-16T22:38:13.187Z", + "Web/CSS/border-left-color": { + "modified": "2019-01-16T19:20:48.785Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/No-servidor/Servidor_node_sem_framework": { - "modified": "2020-07-16T22:36:06.037Z", + "Web/CSS/border-left-style": { + "modified": "2019-01-16T15:59:50.769Z", "contributors": [ - "Anonymous", - "joao-neves95" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns": { - "modified": "2020-07-16T22:35:26.594Z", + "Web/CSS/border-left-width": { + "modified": "2019-01-16T16:00:08.928Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/Como_funciona_a_Internet": { - "modified": "2020-07-16T22:35:37.920Z", + "Web/CSS/border-right": { + "modified": "2019-01-16T15:59:50.709Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/Congiurar_um_servidor_de_testes_local": { - "modified": "2020-07-16T22:35:53.519Z", + "Web/CSS/border-right-color": { + "modified": "2019-01-16T15:59:44.072Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/O_que_e_um_URL": { - "modified": "2020-07-16T22:35:30.214Z", + "Web/CSS/border-right-style": { + "modified": "2019-01-16T15:59:50.407Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/O_que_e_um_nome_de_dominio": { - "modified": "2020-07-16T22:35:44.710Z", + "Web/CSS/border-right-width": { + "modified": "2019-01-16T16:00:01.042Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/O_que_e_um_servidor_da_Web": { - "modified": "2020-07-16T22:35:31.962Z", + "Web/CSS/border-spacing": { + "modified": "2019-03-23T23:47:07.851Z", "contributors": [ - "Anonymous" + "wbamberg", + "teoli", + "Verruckt" ] }, - "Learn/Questoes_comuns/Qual_e_a_diferenca_entre_pagina_site_servidor_da_web_e_mecanismo_pesquisa": { - "modified": "2020-07-16T22:35:40.437Z", + "Web/CSS/border-top": { + "modified": "2019-01-17T10:27:59.370Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Tools_and_testing": { - "modified": "2020-07-16T22:38:57.196Z", + "Web/CSS/border-top-color": { + "modified": "2019-01-16T19:20:46.774Z", "contributors": [ - "Anonymous", - "Navin77" + "teoli", + "Verruckt" ] }, - "Learn/Tools_and_testing/Teste_cruzado_de_navegador": { - "modified": "2020-07-16T22:39:01.215Z", + "Web/CSS/border-top-style": { + "modified": "2019-01-16T15:59:52.923Z", "contributors": [ - "wbamberg", - "Anonymous" + "teoli", + "Verruckt" ] }, - "Learn/Tools_and_testing/Teste_cruzado_de_navegador/Acessibilidade": { - "modified": "2020-09-24T09:24:04.432Z", + "Web/CSS/border-top-width": { + "modified": "2019-01-16T16:00:01.372Z", "contributors": [ - "Painatalman" + "teoli", + "Verruckt" ] }, - "Localizar_descrições_de_extensões": { - "modified": "2019-03-24T00:02:35.408Z", + "Web/CSS/border-width": { + "modified": "2019-03-23T23:12:52.902Z", "contributors": [ - "SphinxKnight", - "fscholz", + "wbamberg", + "teoli", "Verruckt" ] }, - "Localização": { - "modified": "2019-03-24T00:03:56.319Z", + "Web/CSS/bottom": { + "modified": "2019-01-16T16:00:22.463Z", "contributors": [ - "Anonymous", - "fscholz", - "Verruckt", - "Kayalemao", - "Tagl" + "teoli", + "Verruckt" ] }, - "MDN": { - "modified": "2020-02-19T18:55:27.012Z", + "Web/CSS/clear": { + "modified": "2019-03-23T23:35:13.332Z", "contributors": [ - "jswisher", - "SphinxKnight", - "Anonymous", "wbamberg", - "Jeremie", - "davempso", - "Sheppy" + "teoli", + "Luis Henrique Sousa", + "Verruckt" ] }, - "MDN/Comunidade": { - "modified": "2019-09-11T08:01:31.979Z", + "Web/CSS/color": { + "modified": "2019-01-16T19:20:48.419Z", "contributors": [ - "SphinxKnight", - "Anonymous", - "wbamberg" + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "MDN/Comunidade/Conversações": { - "modified": "2019-01-16T21:51:19.575Z", + "Web/CSS/content": { + "modified": "2019-03-24T00:02:07.101Z", "contributors": [ - "wbamberg", - "Anonymous" + "teoli", + "Half-blood" ] }, - "MDN/Comunidade/Doc_sprints": { - "modified": "2019-03-18T21:19:58.227Z", + "Web/CSS/counter-increment": { + "modified": "2019-03-23T23:47:04.420Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "MDN/Comunidade/O_que_está_a_acontecer": { - "modified": "2019-03-23T22:42:12.854Z", + "Web/CSS/counter-reset": { + "modified": "2019-03-23T23:47:10.117Z", "contributors": [ - "wbamberg", - "Anonymous" + "teoli", + "Verruckt" ] }, - "MDN/Comunidade/Trabalhar_em_comunidade": { - "modified": "2020-02-19T19:07:51.992Z", + "Web/CSS/cursor": { + "modified": "2019-03-24T00:02:03.227Z", "contributors": [ - "jswisher", "wbamberg", - "Anonymous" + "teoli", + "Half-blood", + "Verruckt" ] }, - "MDN/Contribute": { - "modified": "2019-03-23T23:03:08.251Z", + "Web/CSS/direction": { + "modified": "2019-01-16T16:56:47.948Z", "contributors": [ - "Anonymous", - "wbamberg", - "alispivak" + "teoli", + "Verruckt" ] }, - "MDN/Contribute/Feedback": { - "modified": "2020-09-30T17:52:26.093Z", + "Web/CSS/display": { + "modified": "2019-03-23T23:49:28.516Z", "contributors": [ - "chrisdavidmills", - "jswisher", - "SphinxKnight", + "wbamberg", "Anonymous", - "wbamberg" + "teoli", + "ethertank", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "MDN/Contribute/Getting_started": { - "modified": "2020-09-30T17:15:31.197Z", + "Web/CSS/float": { + "modified": "2019-03-23T23:47:04.610Z", "contributors": [ - "chrisdavidmills", - "joaonunomota", - "Anonymous", "wbamberg", - "riagva", - "davempso" + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "MDN/Contribute/Howto": { - "modified": "2019-01-16T21:51:27.704Z", + "Web/CSS/font": { + "modified": "2019-03-23T23:47:10.686Z", "contributors": [ "wbamberg", - "Anonymous", - "jswisher" + "teoli", + "Verruckt" ] }, - "MDN/Contribute/Howto/Como_converter_exemplos_de_codigo_para_ficarem_live": { - "modified": "2020-03-02T17:27:21.266Z", + "Web/CSS/font-size": { + "modified": "2019-03-23T23:47:15.600Z", "contributors": [ - "carlostojal", "wbamberg", - "Anonymous" + "RCat", + "teoli", + "Verruckt" ] }, - "MDN/Contribute/Howto/Como_definir_o_resumo_para_uma_pagina": { - "modified": "2019-03-23T22:08:19.737Z", + "Web/CSS/font-size-adjust": { + "modified": "2019-03-23T23:47:06.762Z", "contributors": [ "wbamberg", - "Saconte", - "Anonymous" + "teoli", + "Verruckt" ] }, - "MDN/Contribute/Howto/Como_efetuar_revisao_tecnica": { - "modified": "2019-05-13T07:55:49.326Z", + "Web/CSS/font-smooth": { + "modified": "2020-10-15T22:20:31.703Z", "contributors": [ - "Anonymous" + "LPJFilho" ] }, - "MDN/Contribute/Howto/Como_escrever_um_artigo_para_ajudar_as_pessoas_a_aprenderem_sobre_a_Web": { - "modified": "2020-02-28T22:23:56.590Z", + "Web/CSS/font-style": { + "modified": "2019-03-23T23:51:37.862Z", "contributors": [ "wbamberg", - "Anonymous" + "fscholz", + "teoli", + "Luis Henrique Sousa" ] }, - "MDN/Contribute/Howto/Como_escrever_uma_nova_entrada_no_Glossario": { - "modified": "2019-03-23T22:12:45.769Z", + "Web/CSS/font-weight": { + "modified": "2019-03-23T23:47:17.771Z", "contributors": [ - "wbamberg", - "maarysantos", - "Anonymous" + "gusbemacbe", + "SphinxKnight", + "teoli", + "Verruckt" ] }, - "MDN/Contribute/Howto/Comunicar_um_problema": { - "modified": "2020-01-07T12:19:34.416Z", + "Web/CSS/height": { + "modified": "2019-03-23T23:47:57.733Z", "contributors": [ - "peterbe", "wbamberg", - "Anonymous" + "teoli", + "Luis Henrique Sousa" ] }, - "MDN/Contribute/Howto/Criar_e_editar_paginas": { - "modified": "2019-04-04T11:57:15.432Z", + "Web/CSS/inherit": { + "modified": "2019-01-16T15:39:13.615Z", "contributors": [ - "diogo-panaca" + "teoli", + "Hillus" ] }, - "MDN/Contribute/Howto/Criar_uma_conta_MDN": { - "modified": "2019-03-23T22:42:11.494Z", + "Web/CSS/list-style": { + "modified": "2019-03-23T23:47:53.661Z", "contributors": [ - "Anonymous", - "wbamberg" + "SphinxKnight", + "teoli", + "Luis Henrique Sousa" ] }, - "MDN/Contribute/Howto/Etiqueta": { - "modified": "2019-11-13T11:32:17.983Z", + "Web/CSS/top": { + "modified": "2019-01-16T14:40:15.687Z", "contributors": [ - "Anonymous", - "wbamberg" + "teoli", + "Half-blood" ] }, - "MDN/Contribute/Howto/Marcar_paginas_JavaScript": { - "modified": "2019-01-17T01:35:48.693Z", + "Web/CSS/transform": { + "modified": "2019-03-23T22:12:47.007Z", "contributors": [ - "wbamberg", "Anonymous" ] }, - "MDN/Contribute/Howto/Participar_testes_beta": { - "modified": "2019-03-23T22:09:29.860Z", + "Web/CSS/width": { + "modified": "2019-03-23T23:47:51.459Z", "contributors": [ "wbamberg", - "Anonymous" + "Redeagle48", + "teoli", + "Luis Henrique Sousa", + "Verruckt" ] }, - "MDN/Contribute/Howto/fazer_revisão_editorial": { - "modified": "2019-03-23T22:20:12.878Z", + "Web/CSS/z-index": { + "modified": "2019-01-17T04:06:04.605Z", "contributors": [ - "Anonymous", - "wbamberg", - "samlopes_br" + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "MDN/Editor": { - "modified": "2020-09-30T15:43:23.702Z", + "Web/Guide": { + "modified": "2020-11-12T11:23:45.364Z", "contributors": [ - "chrisdavidmills", + "nuruldecarvalho", "Anonymous", - "wbamberg" + "Onsteroids" ] }, - "MDN/Editor/Basicos": { - "modified": "2020-09-30T15:43:23.869Z", + "Web/Guide/AJAX": { + "modified": "2019-03-23T23:43:06.644Z", "contributors": [ + "Anonymous", "chrisdavidmills", + "Leandro Mercês Xavier", + "Takenbot", + "Dria", + "RuiMaciel" + ] + }, + "Web/HTML": { + "modified": "2020-07-22T17:12:42.326Z", + "contributors": [ + "joaonunomota", + "SphinxKnight", + "duduindo", + "tyreecruz6", "Anonymous", - "wbamberg" + "Devenancio", + "didi9999", + "jwhitlock" ] }, - "MDN/Guidelines": { - "modified": "2020-09-30T15:31:28.524Z", + "Web/HTTP": { + "modified": "2019-05-08T19:34:36.815Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "wellick53", + "Joao-Henrique", + "CarlosAlbertoSzygalski", + "fscholz" ] }, - "MDN/Guidelines/Convencoes_definicoes": { - "modified": "2020-09-30T15:31:29.524Z", + "Web/HTTP/CORS": { + "modified": "2020-10-15T22:15:14.685Z", "contributors": [ - "chrisdavidmills", - "jswisher", - "Anonymous", - "wbamberg" + "mfuji09" ] }, - "MDN/Guidelines/Guia_de_estilo_de_escrita": { - "modified": "2020-09-30T15:31:29.280Z", + "Web/HTTP/CORS/Errors": { + "modified": "2019-03-18T20:48:04.840Z", "contributors": [ - "chrisdavidmills", - "joaonunomota", - "jswisher", - "wbamberg", - "Anonymous" + "nchevobbe" ] }, - "MDN/Guidelines/Isto_pertence_a_MDN": { - "modified": "2020-09-30T15:31:29.806Z", + "Web/HTTP/CORS/Errors/CORSDidNotSucceed": { + "modified": "2019-07-29T10:54:39.520Z", "contributors": [ - "chrisdavidmills", - "jswisher", - "Anonymous" + "duduindo", + "emagombe" ] }, - "MDN/Kuma": { - "modified": "2019-09-09T15:53:50.658Z", + "Web/HTTP/Headers": { + "modified": "2019-03-23T22:13:14.622Z", "contributors": [ - "SphinxKnight", - "Anonymous", - "wbamberg" + "fscholz" ] }, - "MDN/Sobre": { - "modified": "2019-09-10T08:55:19.644Z", + "Web/HTTP/Headers/Allow": { + "modified": "2020-07-25T17:41:28.755Z", "contributors": [ - "SphinxKnight", - "Anonymous", - "wbamberg", - "Dilson", - "jswisher" + "joaonunomota" ] }, - "MDN/Structures": { - "modified": "2020-09-30T12:57:09.511Z", + "Web/HTTP/Headers/X-Content-Type-Options": { + "modified": "2020-10-15T21:53:51.221Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "jswisher" + "tjgfernandes" ] }, - "MDN/Structures/API_references": { - "modified": "2020-09-30T12:57:10.288Z", + "Web/HTTP/Proxy_servers_and_tunneling": { + "modified": "2020-06-30T09:55:24.162Z", "contributors": [ - "chrisdavidmills", - "wbamberg" + "lutzleonardo15" ] }, - "MDN/Structures/API_references/Barras_laterais_de_referencia_da_API": { - "modified": "2020-09-30T12:57:10.465Z", + "Web/HTTP/Status": { + "modified": "2020-10-15T22:17:14.857Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "zhouqichao" ] }, - "MDN/Structures/API_references/O_que_e_que_uma_referencia_de_API_precisa": { - "modified": "2020-09-30T12:57:10.634Z", + "Web/HTTP/Status/205": { + "modified": "2019-04-07T10:34:18.946Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "preira" ] }, - "MDN/Structures/Exemplos_live": { - "modified": "2020-09-30T12:57:10.000Z", + "Web/HTTP/Status/405": { + "modified": "2020-07-25T17:18:32.968Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "MDN/Structures/Macros": { - "modified": "2020-09-30T12:57:10.153Z", + "Web/HTTP/Status/502": { + "modified": "2020-10-15T22:31:56.172Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "MDN/Tools": { - "modified": "2020-09-30T16:53:22.697Z", + "Web/HTTP/Status/504": { + "modified": "2020-10-15T22:32:01.046Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "jswisher" + "joaonunomota" ] }, - "MDN/Tools/Edição_de_modelo": { - "modified": "2020-09-30T16:53:23.123Z", + "Web/JavaScript": { + "modified": "2020-09-29T15:05:06.845Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "jnascimentogcc", + "Anonymous", + "SphinxKnight", + "diogo-panaca", + "ruiribeiro97", + "teoli", + "jaydson", + "Charleno Pires", + "leobalter", + "Verruckt", + "Leandro Mercês Xavier", + "Enigma", + "RuiMaciel" ] }, - "MDN/Tools/KumaScript": { - "modified": "2020-09-30T16:53:22.999Z", + "Web/JavaScript/Reference": { + "modified": "2020-07-11T02:27:11.550Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "KINGRANDOLPH", + "Anonymous", + "dd-pardal", + "LJHarb" ] }, - "MDN/Tools/Vigiar_pagina": { - "modified": "2020-09-30T16:53:22.646Z", + "Web/JavaScript/Reference/Classes": { + "modified": "2020-10-15T22:00:39.801Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "preira", + "peter.kehl" ] }, - "MDN/Troubleshooting": { - "modified": "2020-09-30T16:58:33.426Z", + "Web/JavaScript/Reference/Classes/static": { + "modified": "2020-10-15T22:00:38.342Z", "contributors": [ - "chrisdavidmills", - "wbamberg", - "Anonymous" + "Painatalman" ] }, - "MDN_at_ten": { - "modified": "2019-03-23T22:50:14.757Z", + "Web/JavaScript/Reference/Errors": { + "modified": "2020-03-12T19:47:09.947Z", "contributors": [ - "Anonymous", - "Matoplays" + "Sheppy" ] }, - "MDN_at_ten/Contribuir_para_MDN": { - "modified": "2020-02-19T18:51:00.800Z", + "Web/JavaScript/Reference/Errors/Not_a_function": { + "modified": "2020-07-25T16:58:44.866Z", "contributors": [ - "jswisher", - "Anonymous" + "joaonunomota" ] }, - "MDN_at_ten/Historia_da_MDN": { - "modified": "2019-03-23T22:09:33.028Z", + "Web/JavaScript/Reference/Errors/Stmt_after_return": { + "modified": "2020-03-12T19:47:09.548Z", "contributors": [ - "Anonymous" + "Anonymous", + "joao-neves95", + "PANC" ] }, - "Manipuladores_de_protocolo_web": { - "modified": "2019-03-23T23:52:53.802Z", + "Web/JavaScript/Reference/Errors/Unexpected_token": { + "modified": "2020-03-12T19:47:17.066Z", "contributors": [ - "Verruckt", - "Fernandopsilveira", - "Leandro Mercês Xavier" + "pedlima" ] }, - "Melhorias_do_Gerenciador_de_Downloads_no_Firefox_3": { - "modified": "2019-01-16T14:39:25.788Z", + "Web/JavaScript/Reference/Global_Objects": { + "modified": "2020-03-12T19:39:49.774Z", "contributors": [ - "fscholz", - "Verruckt" + "Anonymous", + "Redeagle48", + "SphinxKnight", + "fscholz" ] }, - "Mozilla": { - "modified": "2019-03-24T00:17:35.290Z", + "Web/JavaScript/Reference/Global_Objects/Array": { + "modified": "2020-10-15T21:54:01.173Z", "contributors": [ - "Anonymous", - "billhiba", - "Beria" + "joaonunomota", + "claudepache" ] }, - "Mozilla/Add-ons": { - "modified": "2019-03-18T21:08:20.167Z", + "Web/JavaScript/Reference/Global_Objects/Array/concat": { + "modified": "2019-03-23T22:13:06.712Z", "contributors": [ - "Anonymous", - "nportugal", - "Anomitro_Munshi" + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions": { - "modified": "2019-03-18T20:49:08.711Z", + "Web/JavaScript/Reference/Global_Objects/Array/find": { + "modified": "2020-10-15T22:02:06.522Z", "contributors": [ - "Anonymous", - "wbamberg" + "JMoreira93" ] }, - "Mozilla/Add-ons/WebExtensions/API": { - "modified": "2019-11-26T22:19:55.515Z", + "Web/JavaScript/Reference/Global_Objects/Array/forEach": { + "modified": "2020-10-15T22:13:53.352Z", "contributors": [ - "wbamberg", - "Anonymous" + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions/API/Armazenamento": { - "modified": "2020-10-15T21:59:48.396Z", + "Web/JavaScript/Reference/Global_Objects/Array/includes": { + "modified": "2020-10-15T22:04:42.050Z", "contributors": [ - "wbamberg", - "Anonymous" + "SandroMiguel" ] }, - "Mozilla/Add-ons/WebExtensions/API/browserAction": { - "modified": "2020-10-15T21:59:49.630Z", + "Web/JavaScript/Reference/Global_Objects/Array/join": { + "modified": "2020-10-15T21:54:14.959Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota", + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions/API/browsingData": { - "modified": "2020-10-15T22:14:48.933Z", + "Web/JavaScript/Reference/Global_Objects/Array/map": { + "modified": "2020-10-15T22:33:11.742Z", "contributors": [ - "ExE-Boss" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/API/browsingData/removePluginData": { - "modified": "2020-10-15T22:14:40.836Z", + "Web/JavaScript/Reference/Global_Objects/Array/pop": { + "modified": "2020-10-15T21:58:52.123Z", "contributors": [ - "Anonymous" + "kapz" ] }, - "Mozilla/Add-ons/WebExtensions/API/devtools.panels": { - "modified": "2020-10-15T21:59:48.885Z", + "Web/JavaScript/Reference/Global_Objects/Array/reverse": { + "modified": "2019-03-23T22:12:30.952Z", "contributors": [ - "Anonymous" + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions/API/i18n": { - "modified": "2020-10-15T22:14:41.219Z", + "Web/JavaScript/Reference/Global_Objects/Array/slice": { + "modified": "2020-10-15T22:31:52.359Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/API/pageAction": { - "modified": "2020-10-15T21:59:47.365Z", + "Web/JavaScript/Reference/Global_Objects/ArrayBuffer": { + "modified": "2019-03-23T22:16:35.915Z", "contributors": [ - "wbamberg", - "Anonymous" + "anguelov" ] }, - "Mozilla/Add-ons/WebExtensions/API/sidebarAction": { - "modified": "2020-10-15T22:06:57.394Z", + "Web/JavaScript/Reference/Global_Objects/AsyncFunction": { + "modified": "2020-10-15T22:14:28.403Z", "contributors": [ - "wbamberg", - "Anonymous" + "ramongr" ] }, - "Mozilla/Add-ons/WebExtensions/A_sua_primeira_extensao": { - "modified": "2019-03-18T21:04:11.435Z", + "Web/JavaScript/Reference/Global_Objects/Boolean": { + "modified": "2020-10-15T21:59:47.399Z", "contributors": [ "Anonymous" ] }, - "Mozilla/Add-ons/WebExtensions/A_sua_segunda_extensao": { - "modified": "2019-03-18T21:03:02.346Z", + "Web/JavaScript/Reference/Global_Objects/Function": { + "modified": "2019-03-23T22:14:25.079Z", "contributors": [ - "Anonymous" + "nmve" ] }, - "Mozilla/Add-ons/WebExtensions/Anatomia_de_uma_extensao": { - "modified": "2019-03-18T21:03:04.427Z", + "Web/JavaScript/Reference/Global_Objects/Function/arguments": { + "modified": "2020-10-15T22:14:27.893Z", "contributors": [ - "Anonymous" + "ramongr" ] }, - "Mozilla/Add-ons/WebExtensions/As_melhores_praticas_de_experiencia_do_utilizador": { - "modified": "2019-03-18T21:02:27.071Z", + "Web/JavaScript/Reference/Global_Objects/Function/call": { + "modified": "2020-10-15T21:53:17.055Z", "contributors": [ - "Anonymous" + "joaonunomota", + "JuniorDiasOliveira", + "waveiro", + "Mega85" ] }, - "Mozilla/Add-ons/WebExtensions/Conversao_de_uma_extensao_legada_do_firefox": { - "modified": "2019-03-18T20:56:20.829Z", + "Web/JavaScript/Reference/Global_Objects/Infinity": { + "modified": "2020-10-15T22:31:55.049Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/E_a_seguir": { - "modified": "2019-03-18T21:01:48.060Z", + "Web/JavaScript/Reference/Global_Objects/Math": { + "modified": "2019-03-23T22:12:29.962Z", "contributors": [ - "Anonymous" + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions/Exemplos_extensoes": { - "modified": "2019-03-18T21:03:01.761Z", + "Web/JavaScript/Reference/Global_Objects/Math/ceil": { + "modified": "2020-10-15T21:58:11.563Z", "contributors": [ - "Anonymous" + "carlos-menezes", + "MarcioFonseca" ] }, - "Mozilla/Add-ons/WebExtensions/ExtennsoesWeb_e_a_id_do_extra": { - "modified": "2019-03-18T20:47:01.907Z", + "Web/JavaScript/Reference/Global_Objects/Number": { + "modified": "2019-03-23T22:49:01.559Z", "contributors": [ - "Anonymous" + "Redeagle48", + "fscholz" ] }, - "Mozilla/Add-ons/WebExtensions/Extensão_das_ferramentas_de_desenvolvimento": { - "modified": "2019-03-18T21:04:10.244Z", + "Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE": { + "modified": "2019-03-23T22:49:07.538Z", "contributors": [ - "Anonymous" + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Instalacao_temporaria_no_Firefox": { - "modified": "2019-03-18T21:03:04.634Z", + "Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE": { + "modified": "2019-03-23T22:49:09.973Z", "contributors": [ - "Anonymous" + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Interceptar_Pedidos_HTTP": { - "modified": "2019-03-18T21:03:59.316Z", + "Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY": { + "modified": "2020-10-15T21:38:19.186Z", "contributors": [ - "carlosteixeiraa" + "joaonunomota", + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Internationalization": { - "modified": "2019-03-18T20:56:21.219Z", + "Web/JavaScript/Reference/Global_Objects/Number/NaN": { + "modified": "2019-03-23T22:49:09.414Z", "contributors": [ - "Anonymous" + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/O_que_sao_WebExtensions": { - "modified": "2019-03-18T21:05:19.046Z", + "Web/JavaScript/Reference/Global_Objects/Number/isFinite": { + "modified": "2019-03-23T22:49:12.149Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Primeiros_passos_com_web-ext": { - "modified": "2019-03-18T21:03:10.522Z", + "Web/JavaScript/Reference/Global_Objects/Number/isInteger": { + "modified": "2019-03-23T22:49:17.052Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Publicar_a_sua_extensao": { - "modified": "2019-03-18T21:04:14.402Z", + "Web/JavaScript/Reference/Global_Objects/Number/isNaN": { + "modified": "2019-03-23T22:49:10.417Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Scripts_Conteudo": { - "modified": "2019-07-29T11:08:46.237Z", + "Web/JavaScript/Reference/Global_Objects/Number/toString": { + "modified": "2019-03-23T22:49:00.338Z", "contributors": [ - "duduindo", - "Anonymous" + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/Suporte_navegador_APIs_JavaScript": { - "modified": "2020-10-15T20:55:03.457Z", + "Web/JavaScript/Reference/Global_Objects/Object": { + "modified": "2020-10-15T21:30:54.647Z", "contributors": [ - "Anonymous" + "Anonymous", + "wbamberg", + "fscholz" ] }, - "Mozilla/Add-ons/WebExtensions/Tips": { - "modified": "2019-03-18T21:01:44.598Z", + "Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty": { + "modified": "2019-03-23T22:42:57.159Z", "contributors": [ - "SphinxKnight" + "gabrielpconceicao" ] }, - "Mozilla/Add-ons/WebExtensions/Trasnsferir_extensao_Google_Chrome": { - "modified": "2019-03-18T21:05:15.395Z", + "Web/JavaScript/Reference/Global_Objects/String": { + "modified": "2020-10-15T21:38:27.657Z", "contributors": [ + "erickbRodrigues", "Anonymous", - "Nunonmac101" + "ricardomartins", + "lpimenta-ptc", + "Sheppy" ] }, - "Mozilla/Add-ons/WebExtensions/dubla_padrões": { - "modified": "2020-10-15T22:25:44.918Z", + "Web/JavaScript/Reference/Global_Objects/String/Trim": { + "modified": "2019-03-23T22:13:05.964Z", "contributors": [ - "martimafonso" + "ricardomartins" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador": { - "modified": "2019-03-18T21:04:19.885Z", + "Web/JavaScript/Reference/Global_Objects/String/indexOf": { + "modified": "2019-03-23T22:49:09.792Z", "contributors": [ - "Anonymous" + "SandroMiguel", + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Acoes_pagina": { - "modified": "2019-03-18T21:04:17.709Z", + "Web/JavaScript/Reference/Global_Objects/String/length": { + "modified": "2019-03-23T22:49:00.693Z", "contributors": [ - "Anonymous" + "Redeagle48" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Ação_navegador": { - "modified": "2019-03-18T21:04:05.718Z", + "Web/JavaScript/Reference/Global_Objects/Symbol": { + "modified": "2019-03-23T22:24:48.766Z", "contributors": [ - "Anonymous" + "ZeikJT" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Barras_laterais": { - "modified": "2019-03-18T21:04:06.139Z", + "Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance": { + "modified": "2019-03-23T22:24:53.893Z", "contributors": [ - "Anonymous" + "GoToLoop" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Estilos_de_navegador": { - "modified": "2020-10-15T22:07:31.177Z", + "Web/JavaScript/Reference/Global_Objects/encodeURI": { + "modified": "2020-03-12T19:42:17.895Z", "contributors": [ - "Anonymous" + "kempcarlos" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Itens_do_menu_de_contexto": { - "modified": "2019-03-18T21:04:09.803Z", + "Web/Manifest": { + "modified": "2020-10-15T22:23:27.262Z", "contributors": [ + "nersofiripi", "Anonymous" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Notificacoes": { - "modified": "2019-03-18T21:04:17.481Z", + "Web/MathML": { + "modified": "2020-11-09T15:01:38.012Z", "contributors": [ + "joaonunomota", + "Joao_Ledo_Fonseca", "Anonymous" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Omnibox": { - "modified": "2019-03-18T21:01:59.411Z", + "Web/MathML/Attribute": { + "modified": "2020-08-21T12:44:51.026Z", "contributors": [ - "Anonymous" + "joaonunomota", + "fscholz" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Options_pages": { - "modified": "2019-03-18T21:04:14.023Z", + "Web/MathML/Authoring": { + "modified": "2020-08-15T14:39:49.860Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Paginas_de_extensão": { - "modified": "2019-03-18T21:03:04.123Z", + "Web/MathML/Element": { + "modified": "2020-08-16T17:33:47.904Z", "contributors": [ - "Anonymous" + "joaonunomota", + "fscholz" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Popups": { - "modified": "2019-08-10T13:56:46.929Z", + "Web/MathML/Element/maction": { + "modified": "2020-10-15T22:32:30.845Z", "contributors": [ - "pedrosino", - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/interface_do_utilizador/devtools_panels": { - "modified": "2019-03-18T21:04:02.641Z", + "Web/MathML/Element/math": { + "modified": "2020-10-15T22:32:00.988Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/manifest.json": { - "modified": "2020-10-15T21:59:48.039Z", + "Web/MathML/Element/menclose": { + "modified": "2020-10-15T22:31:58.519Z", "contributors": [ - "Painatalman", - "wbamberg" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/manifest.json/browser_action": { - "modified": "2020-10-15T21:59:47.236Z", + "Web/MathML/Element/merror": { + "modified": "2020-10-15T22:31:57.892Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/manifest.json/browser_specific_settings": { - "modified": "2020-10-15T22:07:31.462Z", + "Web/MathML/Element/mfenced": { + "modified": "2020-10-15T22:32:16.693Z", "contributors": [ - "wbamberg", - "ExE-Boss", - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/manifest.json/devtools_page": { - "modified": "2020-10-15T21:59:47.989Z", + "Web/MathML/Element/mfrac": { + "modified": "2020-10-15T22:32:37.302Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Add-ons/WebExtensions/manifest.json/icones": { - "modified": "2020-10-15T21:59:47.019Z", + "Web/MathML/Element/mglyph": { + "modified": "2020-10-15T22:32:17.025Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "Mozilla/Developer_guide/Source_Code": { - "modified": "2019-03-18T21:45:30.638Z", + "Web/MathML/Element/mi": { + "modified": "2020-10-15T22:32:20.399Z", "contributors": [ - "ntim" + "joaonunomota" ] }, - "Mozilla/Firefox": { - "modified": "2019-09-10T15:01:27.677Z", + "Web/MathML/Element/mlabeledtr": { + "modified": "2020-10-15T22:32:27.553Z", "contributors": [ - "SphinxKnight", - "Anonymous", - "wbamberg", - "albertocastro", - "Sheppy" + "joaonunomota" ] }, - "Mozilla/Firefox/Releases": { - "modified": "2019-03-18T21:15:03.747Z", + "Web/MathML/Element/mmultiscripts": { + "modified": "2020-10-15T22:32:37.118Z", "contributors": [ - "Anonymous", - "wbamberg", - "Sheppy" + "joaonunomota" ] }, - "Mozilla/Firefox/Releases/3": { - "modified": "2019-03-23T23:19:50.195Z", + "Web/MathML/Element/mn": { + "modified": "2020-10-15T22:32:26.157Z", "contributors": [ - "wbamberg", - "ethertank" + "joaonunomota" ] }, - "Mozilla/Firefox/Releases/70": { - "modified": "2019-10-01T09:44:22.188Z", + "Web/MathML/Element/mo": { + "modified": "2020-10-15T22:32:19.754Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Mudanças_no_Gecko_1.9_que_afetam_websites": { - "modified": "2019-03-23T23:47:04.199Z", + "Web/MathML/Element/mover": { + "modified": "2020-10-15T22:32:19.618Z", "contributors": [ - "wbamberg", - "Sheppy", - "Verruckt" + "joaonunomota" ] }, - "O_DOM_e_o_JavaScript": { - "modified": "2019-12-13T21:10:33.944Z", + "Web/MathML/Element/mpadded": { + "modified": "2020-10-15T22:32:28.264Z", "contributors": [ - "wbamberg", - "fferracioli" + "joaonunomota" ] }, - "Plugins/Ativacao_de_Flash:_comparacao_de_navegador": { - "modified": "2019-03-18T20:56:19.824Z", + "Web/MathML/Element/mphantom": { + "modified": "2020-10-15T22:32:22.218Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Plugins/Flash_para_HTML5": { - "modified": "2019-03-18T20:56:20.182Z", + "Web/MathML/Element/mroot": { + "modified": "2020-10-15T22:32:22.430Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Referência_JSDBGAPI": { - "modified": "2019-03-23T23:44:44.830Z", + "Web/MathML/Element/mrow": { + "modified": "2020-10-15T22:31:58.300Z", "contributors": [ - "SphinxKnight", - "RuiMaciel" + "joaonunomota" ] }, - "Referência_do_DOM_Gecko/Prefácio": { - "modified": "2019-03-23T23:51:50.810Z", + "Web/MathML/Element/ms": { + "modified": "2020-10-15T22:32:22.427Z", "contributors": [ - "khalid32", - "Leandro Mercês Xavier", - "Davis.peixoto" + "joaonunomota" ] }, - "Sobre_o_Document_Object_Model": { - "modified": "2019-03-23T23:46:25.664Z", + "Web/MathML/Element/mspace": { + "modified": "2020-10-15T22:31:55.582Z", "contributors": [ - "SphinxKnight", - "Verruckt" + "joaonunomota" ] }, - "Tinderbox": { - "modified": "2019-03-23T23:45:30.178Z", + "Web/MathML/Element/msqrt": { + "modified": "2020-10-15T22:32:22.151Z", "contributors": [ - "SphinxKnight", - "Verruckt" + "joaonunomota" ] }, - "Toolkit_API": { - "modified": "2019-01-16T16:23:47.926Z", + "Web/MathML/Element/mstyle": { + "modified": "2020-10-15T22:33:04.564Z", "contributors": [ - "Tagl" + "joaonunomota" ] }, - "Tools": { - "modified": "2020-07-16T22:44:17.493Z", + "Web/MathML/Element/msub": { + "modified": "2020-10-15T22:32:21.086Z", "contributors": [ - "SphinxKnight", - "Anonymous", - "wbamberg", - "robert882", - "Leite", - "caobarbosa", - "Timmi" + "joaonunomota" ] }, - "Tools/Add-ons": { - "modified": "2020-07-16T22:36:23.718Z", + "Web/MathML/Element/msubsup": { + "modified": "2020-10-15T22:32:22.170Z", "contributors": [ - "wbamberg" + "joaonunomota" ] }, - "Tools/Capturas_de_ecra": { - "modified": "2020-07-16T22:36:38.620Z", + "Web/MathML/Element/msup": { + "modified": "2020-10-15T22:32:20.360Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "Tools/Configurações": { - "modified": "2020-07-16T22:36:35.515Z", + "Web/MathML/Element/mtable": { + "modified": "2020-10-15T22:33:04.410Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "Tools/Consola_da_Web": { - "modified": "2020-07-16T22:34:07.526Z", + "Web/MathML/Element/mtd": { + "modified": "2020-10-15T22:32:00.353Z", "contributors": [ - "Anonymous", - "wbamberg" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Abertura_Consola_Web": { - "modified": "2020-07-16T22:34:17.467Z", + "Web/MathML/Element/mtext": { + "modified": "2020-10-15T22:31:59.109Z", "contributors": [ - "Anonymous", - "wbamberg" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Ajuda": { - "modified": "2020-07-16T22:34:13.111Z", + "Web/MathML/Element/mtr": { + "modified": "2020-10-15T22:31:55.409Z", "contributors": [ - "Anonymous", - "wbamberg" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Atalhos_teclado": { - "modified": "2020-07-16T22:34:23.988Z", + "Web/MathML/Element/munder": { + "modified": "2020-10-15T22:32:18.823Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Dividir_consola": { - "modified": "2020-07-16T22:34:21.158Z", + "Web/MathML/Element/munderover": { + "modified": "2020-10-15T22:32:21.240Z", "contributors": [ - "Anonymous", - "wbamberg" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Mensagens_consola": { - "modified": "2020-07-16T22:34:16.005Z", + "Web/MathML/Element/semantics": { + "modified": "2020-10-15T22:32:26.955Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota" ] }, - "Tools/Consola_da_Web/O_interprete_da_linha_de_comandos": { - "modified": "2020-07-16T22:34:19.541Z", + "Web/MathML/Examples": { + "modified": "2020-08-18T09:59:11.744Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Tools/Consola_da_Web/Rich_output": { - "modified": "2020-07-16T22:34:20.453Z", + "Web/MathML/Index": { + "modified": "2020-08-16T17:30:38.516Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Tools/Debugger": { - "modified": "2020-07-16T22:35:06.168Z", + "Web/Progressive_web_apps": { + "modified": "2020-04-23T09:44:00.269Z", "contributors": [ "Anonymous", - "wbamberg" + "chrisdavidmills" ] }, - "Tools/Debugger/Demonstracao_IU": { - "modified": "2020-07-16T22:35:16.876Z", + "Web/Reference": { + "modified": "2020-07-20T13:13:52.229Z", "contributors": [ - "wbamberg", - "Anonymous" + "joaonunomota", + "Anonymous", + "carlosrainhaaraujo", + "kscarfone" ] }, - "Tools/Debugger/How_to": { - "modified": "2020-07-16T22:35:08.333Z" - }, - "Tools/Debugger/How_to/Abrir_o_depurador": { - "modified": "2020-07-16T22:35:09.351Z", + "Web/Reference/API": { + "modified": "2019-03-23T23:22:11.761Z", "contributors": [ - "Anonymous" + "Anonymous", + "carlosrainhaaraujo" ] }, - "Tools/Debugger/How_to/Use_a_source_map": { - "modified": "2020-09-11T09:41:20.649Z", + "Web/SVG": { + "modified": "2020-04-23T09:30:08.420Z", "contributors": [ - "pedro-surf", - "Anonymous" + "Anonymous", + "teoli", + "guerreirogabriel", + "fscholz", + "Verruckt", + "RuiMaciel" ] }, - "Tools/Debugger/Source_map_errors": { - "modified": "2020-07-16T22:35:19.577Z", + "Web/SVG/Element": { + "modified": "2020-04-23T09:28:28.562Z", "contributors": [ - "Anonymous" + "Anonymous", + "ricardomartins" ] }, - "Tools/Desempenho": { - "modified": "2020-07-16T22:36:13.622Z", + "Web/SVG/Namespaces_Crash_Course": { + "modified": "2019-03-23T22:01:50.555Z", "contributors": [ "Anonymous", - "wbamberg" + "somascope" ] }, - "Tools/Desempenho/Arvore_de_Chamada": { - "modified": "2020-07-16T22:36:20.006Z", + "Web/SVG/Tutorial": { + "modified": "2019-01-16T14:01:46.161Z", "contributors": [ - "wbamberg", - "Anonymous" + "Anonymous", + "teoli", + "guerreirogabriel" ] }, - "Tools/Desempenho/Cascata": { - "modified": "2020-07-16T22:36:18.250Z", + "Web/Security/Secure_Contexts": { + "modified": "2019-03-23T22:01:19.367Z", "contributors": [ - "wbamberg", - "Anonymous" + "Anonymous", + "Sheppy" ] }, - "Tools/Desempenho/Como_fazer": { - "modified": "2020-07-16T22:36:21.955Z", + "Web/XML": { + "modified": "2020-04-23T08:26:21.649Z", "contributors": [ "Anonymous", - "wbamberg" + "ExE-Boss" ] }, - "Tools/Desempenho/Frame_rate": { - "modified": "2020-07-16T22:36:19.201Z", + "Web/XSLT": { + "modified": "2019-03-24T00:03:57.070Z", "contributors": [ - "wbamberg", - "Anonymous" + "ExE-Boss", + "Anonymous", + "fscholz", + "Verruckt", + "RuiMaciel" ] }, - "Tools/Editor_de_audio_da_Web": { - "modified": "2020-07-16T22:36:08.692Z", + "WebAssembly": { + "modified": "2020-10-15T22:07:45.071Z", "contributors": [ - "wbamberg", "Anonymous" ] }, - "Tools/Editor_de_estilo": { - "modified": "2020-07-16T22:35:01.029Z", + "orphaned/Acentuação_para_conteúdos_carregados_por_AJAX": { + "modified": "2019-03-23T23:50:32.509Z", "contributors": [ - "wbamberg", - "Anonymous" + "Leandro Mercês Xavier", + "JulioGreff", + "Micox", + "Douglas", + "Pfsergio1968" ] }, - "Tools/Inspetor_de_armazenamento": { - "modified": "2020-07-16T22:36:10.303Z", + "Mozilla/Firefox/Releases/3.5/Updating_extensions": { + "modified": "2019-03-24T00:00:34.452Z", "contributors": [ "wbamberg", - "Anonymous" + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Tools/Memoria": { - "modified": "2020-07-16T22:36:27.341Z", + "Mozilla/Firefox/Releases/3/Updating_extensions": { + "modified": "2019-12-13T20:33:32.517Z", "contributors": [ "wbamberg", - "Anonymous" - ] - }, - "Tools/Modo_de_Desenho_Adaptavel": { - "modified": "2020-07-16T22:35:22.282Z", - "contributors": [ - "Anonymous" - ] - }, - "Tools/Network_Monitor": { - "modified": "2020-07-16T22:35:31.240Z", - "contributors": [ + "fscholz", + "SphinxKnight", "Anonymous", - "wbamberg" + "teoli", + "Sheppy", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Tools/Page_Inspector": { - "modified": "2020-07-16T22:34:29.429Z", + "orphaned/Componentes": { + "modified": "2019-03-23T23:40:02.292Z", "contributors": [ - "wbamberg", - "Anonymous", - "DevAsh" + "SphinxKnight", + "GrandeBuzina" ] }, - "Tools/Page_Inspector/Guia_de_IU": { - "modified": "2020-07-16T22:34:49.596Z", + "orphaned/Configurando_um_servidor_de_atualização": { + "modified": "2019-01-16T14:51:09.548Z", "contributors": [ - "wbamberg", - "Anonymous" + "Leandro Mercês Xavier" ] }, - "Tools/Page_Inspector/How_to": { - "modified": "2020-07-16T22:34:31.978Z", + "orphaned/Construir_uma_Extensão": { + "modified": "2019-03-24T00:04:05.919Z", "contributors": [ - "wbamberg", - "Anonymous", - "sidgan" + "teoli", + "fscholz", + "Rhuanbarros", + "Rsjuliao", + "Horyuu1", + "Leandro Mercês Xavier", + "Dudaott", + "Ecocam", + "Toyux", + "Verruckt", + "Luis Henrique Sousa", + "Mr.leal", + "Joker pt", + "Brunnolou", + "Bermonruf" ] }, - "Tools/Page_Inspector/How_to/Abrir_o_inspetor": { - "modified": "2020-07-16T22:34:33.099Z", + "orphaned/Controles_XUL": { + "modified": "2019-03-24T00:03:56.894Z", "contributors": [ - "Anonymous", - "wbamberg" + "fscholz", + "Luis Henrique Sousa", + "Verruckt" ] }, - "Tools/Page_Inspector/How_to/Examinar_e_editar_CSS": { - "modified": "2020-07-16T22:34:43.588Z", + "Web/OpenSearch": { + "modified": "2019-03-24T00:00:54.849Z", "contributors": [ - "wbamberg", - "Anonymous" + "tregagnon", + "Verruckt", + "Rodrigoknascimento" ] }, - "Tools/Page_Inspector/How_to/Examinar_e_editar_o_modelo_de_caixa": { - "modified": "2020-07-16T22:34:34.516Z", + "orphaned/Criando_um_visual_para_o_Firefox": { + "modified": "2019-03-23T23:51:38.630Z", "contributors": [ - "wbamberg", - "Anonymous" + "SphinxKnight", + "Milona87", + "Thestrongergod", + "Verruckt", + "Camaleaun" ] }, - "Tools/Page_Inspector/How_to/Inspecionar_e_selecionar_cores": { - "modified": "2020-07-16T22:34:35.181Z", + "orphaned/Criar_uma_pele_para_o_Firefox": { + "modified": "2019-01-16T16:12:28.704Z", "contributors": [ - "wbamberg", - "Anonymous" + "MarceloGhelman", + "Leandro Mercês Xavier", + "Amrlima" ] }, - "Tools/Page_Inspector/How_to/Reposicao_de_elementos_na_pagina": { - "modified": "2020-07-16T22:34:46.213Z", + "orphaned/Desenhando_texto_usando_canvas": { + "modified": "2019-03-23T23:59:25.399Z", "contributors": [ - "wbamberg", - "Anonymous" + "Wladimir_Palant", + "maicon", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Tools/Page_Inspector/How_to/Trabalhar_com_animacoes": { - "modified": "2020-07-16T22:34:37.073Z", + "Glossary/DHTML": { + "modified": "2019-01-16T16:23:46.538Z", "contributors": [ - "wbamberg", - "Anonymous" + "SphinxKnight", + "RuiMaciel" ] }, - "Tools/Page_Inspector/How_to/Utilizar_a_API_do_Inspetor": { - "modified": "2020-07-16T22:34:45.056Z", + "orphaned/Tools/Add-ons/DOM_Inspector": { + "modified": "2020-07-16T22:36:24.733Z", "contributors": [ "wbamberg", - "Anonymous" + "SphinxKnight", + "Anonymous", + "teoli", + "Verruckt" ] }, - "Tools/Page_Inspector/How_to/Visualizar_tipos_de_letra": { - "modified": "2020-07-16T22:34:39.170Z", + "orphaned/Tools/Add-ons/DOM_Inspector/Introduction_to_DOM_Inspector": { + "modified": "2020-07-16T22:36:26.057Z", "contributors": [ "wbamberg", "Anonymous" ] }, - "Tools/Page_Inspector/How_to/Visualize_transforms": { - "modified": "2020-07-16T22:34:39.722Z", + "Web/API/Document/alinkColor": { + "modified": "2019-03-24T00:04:44.971Z", "contributors": [ - "wbamberg", - "Anonymous" + "teoli", + "italo" ] }, - "Tools/Page_Inspector/atalhos_de_teclado": { - "modified": "2020-07-16T22:34:52.351Z", + "Web/API/Document/bgColor": { + "modified": "2019-03-24T00:04:41.203Z", "contributors": [ - "wbamberg", - "Anonymous" + "teoli", + "italo" ] }, - "Tools/Performance/Guia_da_IU": { - "modified": "2020-07-16T22:36:15.326Z", + "Web/API/Document/cookie": { + "modified": "2019-03-19T14:20:57.798Z", "contributors": [ - "wbamberg", - "Anonymous" + "lucasrenod", + "SphinxKnight", + "gadelhas", + "teoli", + "italo" ] }, - "Tools/Remote_Debugging": { - "modified": "2020-07-16T22:35:37.988Z", + "Web/API/Document/getElementsByClassName": { + "modified": "2019-12-02T03:58:42.536Z", "contributors": [ - "Anonymous", - "wbamberg", - "Joao_Silva27" + "jestevespereira", + "khalid32", + "teoli", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Tools/Remote_Debugging/Debugging_Firefox_Desktop": { - "modified": "2020-07-16T22:35:41.262Z", + "Web/API/Document_Object_Model": { + "modified": "2019-03-23T23:25:55.220Z", "contributors": [ - "Anonymous" + "Anonymous", + "Brettz9" ] }, - "Tools/Remote_Debugging/Depuracao_remota_Thunderbird": { - "modified": "2020-07-16T22:35:40.059Z", + "Web/API/Node/appendChild": { + "modified": "2019-03-23T23:43:33.351Z", "contributors": [ - "wbamberg", - "Anonymous" + "khalid32", + "teoli", + "Leandro Mercês Xavier", + "Wingedx" ] }, - "Tools/Tools_Toolbox": { - "modified": "2020-07-16T22:35:28.091Z", + "Web/API/Element/clientLeft": { + "modified": "2019-03-23T23:49:26.792Z", "contributors": [ - "wbamberg", - "Anonymous" + "khalid32", + "teoli", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Tools/about:debugging": { - "modified": "2020-07-16T22:36:33.106Z", + "Web/API/Element/clientTop": { + "modified": "2019-03-23T23:49:30.994Z", "contributors": [ - "Anonymous", - "wbamberg" + "AshfaqHossain", + "teoli", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Tools/atalhos_de_teclado": { - "modified": "2020-07-16T22:35:50.422Z", + "Web/API/Node/cloneNode": { + "modified": "2019-09-30T14:07:35.240Z", "contributors": [ - "Anonymous", - "wbamberg" + "semisse", + "SphinxKnight", + "guerreirogabriel", + "Diogok", + "Glauco.basilio", + "Codigo13", + "Leandro Mercês Xavier" ] }, - "Transformar_XML_com_XSLT": { - "modified": "2019-03-23T23:45:21.155Z", + "Web/API/Node/insertBefore": { + "modified": "2019-03-23T23:46:00.401Z", "contributors": [ - "SphinxKnight", - "Verruckt" + "jsx", + "Codigo13" ] }, - "Transformar_XML_com_XSLT/Para_leitura_adicional": { - "modified": "2019-03-23T23:52:21.068Z", + "Web/API/Element": { + "modified": "2020-10-15T21:16:02.585Z", "contributors": [ - "SphinxKnight", + "Anonymous", + "MauroBonucci", + "khalid32", "Leandro Mercês Xavier", - "Pilinio", - "Verruckt" + "Davis.peixoto", + "Codigo13" ] }, - "Tutorial_XUL": { - "modified": "2019-03-23T23:45:36.792Z", + "Web/API/Selection": { + "modified": "2019-03-24T00:02:03.808Z", "contributors": [ "SphinxKnight", - "Leandro Mercês Xavier" + "danielwebsistemas" ] }, - "Tutorial_XUL/Adicionando_botões": { - "modified": "2019-03-23T23:46:29.323Z", + "Web/API/Web_Storage_API": { + "modified": "2019-03-24T00:00:51.877Z", "contributors": [ + "khalid32", "Verruckt", - "Leandro Mercês Xavier", - "Rodmalkav" + "Leandro Mercês Xavier" ] }, - "Tutorial_XUL/Criando_uma_janela": { - "modified": "2019-03-23T23:45:36.338Z", + "orphaned/FAQ_Extensões": { + "modified": "2019-01-16T14:39:04.547Z", "contributors": [ - "SphinxKnight", - "jigs12", - "Leandro Mercês Xavier", + "fscholz", "Luis Henrique Sousa", + "Toyux", "Verruckt", - "Rodmalkav" + "Calebeaires" ] }, - "Tutorial_XUL/Introdução": { - "modified": "2019-03-23T23:46:27.723Z", + "Mozilla/Firefox/Releases/1.5": { + "modified": "2019-03-24T00:02:26.260Z", "contributors": [ + "wbamberg", "SphinxKnight", - "Verruckt", + "fscholz", + "Takenbot", "Leandro Mercês Xavier" ] }, - "Tutorial_do_Canvas": { - "modified": "2019-01-16T14:32:07.975Z", + "Mozilla/Firefox/Releases/2": { + "modified": "2019-03-24T00:02:35.537Z", "contributors": [ + "wbamberg", + "SphinxKnight", "fscholz", - "Verruckt", - "RuiMaciel" + "Leandro Mercês Xavier", + "Kayalemao" ] }, - "Tutorial_do_Canvas/Formas_de_desenho": { - "modified": "2019-01-16T14:01:56.255Z", + "orphaned/Firefox_3_para_desenvolvedores": { + "modified": "2019-01-16T14:32:08.166Z", "contributors": [ - "guerreirogabriel" + "teoli", + "fscholz", + "Verruckt", + "Fernandopsilveira", + "Leandro Mercês Xavier" ] }, - "Tutorial_do_Canvas/Utilização_básica": { - "modified": "2019-03-24T00:10:34.537Z", + "Mozilla/Firefox/Releases/3.5": { + "modified": "2019-03-24T00:00:50.782Z", "contributors": [ - "guerreirogabriel", - "Edgarlaguiar", - "Luiz Carlos Moraes", - "Jes", - "Vitor.blacks" + "wbamberg", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Um_pequeno_exemplo_usando_AJAX": { - "modified": "2019-01-17T03:48:56.314Z", + "Mozilla/Firefox/Releases/3.6": { + "modified": "2019-12-13T20:33:40.975Z", "contributors": [ + "wbamberg", + "SphinxKnight", + "teoli", + "Verruckt", "Leandro Mercês Xavier" ] }, - "Usando_privilégios_expandidos_em_navegadores_Mozilla": { - "modified": "2019-03-23T23:48:48.468Z", + "Mozilla/Firefox/Releases/4": { + "modified": "2019-11-21T00:43:18.363Z", "contributors": [ - "Leandro Mercês Xavier", - "Verruckt" + "wbamberg", + "Sebastianz", + "Prinz_Rana", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Usando_áudio_e_vídeo_no_Firefox": { - "modified": "2019-03-24T00:00:33.796Z", + "Mozilla/Firefox/Releases/5": { + "modified": "2019-03-24T00:09:30.352Z", "contributors": [ - "Leandro Mercês Xavier", + "wbamberg", + "teoli", "Verruckt" ] }, - "Using_the_W3C_DOM_Level_1_Core": { - "modified": "2019-12-13T21:06:18.400Z", + "Mozilla/Firefox/Releases/6": { + "modified": "2019-11-21T00:43:07.958Z", "contributors": [ "wbamberg", "Anonymous", - "ethertank", - "fferracioli" + "teoli", + "Verruckt" ] }, - "Utilizando_meta_tags": { - "modified": "2019-03-23T23:45:18.005Z", + "Glossary/404": { + "modified": "2020-06-25T18:13:41.660Z", "contributors": [ - "eduardoungaratto", - "AndreGazola", - "Fleury" + "joaonunomota" ] }, - "Venkman": { - "modified": "2019-03-24T00:02:38.559Z", + "Glossary/502": { + "modified": "2020-06-25T18:28:46.890Z", "contributors": [ - "SphinxKnight", - "fscholz", - "Verruckt" + "joaonunomota" ] }, - "Web": { - "modified": "2020-05-03T13:08:13.142Z", + "Glossary/Accessibility": { + "modified": "2019-03-18T21:47:01.702Z", "contributors": [ - "Anonymous", - "polonia", - "didi9999", - "joao-neves95", - "carlosrainhaaraujo", - "ethertank" + "Anonymous" ] }, - "Web/API": { - "modified": "2019-03-23T22:39:25.827Z", + "Glossary/AJAX": { + "modified": "2020-06-09T08:11:59.760Z", "contributors": [ - "Anonymous", - "teoli", - "carlosrainhaaraujo" + "joaonunomota" ] }, - "Web/API/API_Autenticacao_Web": { - "modified": "2020-10-15T22:03:06.934Z", + "conflicting/Glossary/API": { + "modified": "2020-10-25T11:15:06.759Z", "contributors": [ - "fscholz", + "Zamalor", + "joaonunomota", "Anonymous" ] }, - "Web/API/API_Entradas_de_Diretoria_e_Ficheiro": { - "modified": "2019-03-18T21:46:51.385Z", + "Glossary/Argument": { + "modified": "2019-03-18T21:17:57.812Z", "contributors": [ "Anonymous" ] }, - "Web/API/API_WebRTC": { - "modified": "2019-03-23T22:12:46.226Z", + "Glossary/ARIA": { + "modified": "2020-06-11T20:31:33.120Z", "contributors": [ - "Anonymous", - "Gurigraphics" + "joaonunomota" ] }, - "Web/API/API_WebRTC/Tirar_fotografias": { - "modified": "2019-03-23T22:12:45.154Z", + "Glossary/Signature": { + "modified": "2019-03-23T22:12:54.952Z", "contributors": [ - "fscholz", - "wbamberg", "Anonymous" ] }, - "Web/API/API_armazenamento": { - "modified": "2020-10-15T22:08:44.199Z", + "Glossary/BigInt": { + "modified": "2020-06-12T14:16:25.328Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/API/API_de_Armazenamento_da_Web": { - "modified": "2019-03-18T21:46:00.224Z", + "Glossary/Boolean": { + "modified": "2019-03-18T21:45:55.769Z", "contributors": [ "Anonymous" ] }, - "Web/API/API_de_canvas": { - "modified": "2019-03-23T22:01:56.072Z", + "Glossary/Entity_header": { + "modified": "2020-07-25T18:10:04.388Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/API/API_de_canvas/Tutorial": { - "modified": "2019-03-18T21:24:18.272Z", + "Glossary/Cache": { + "modified": "2020-06-07T12:38:40.205Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/API/API_do_Estado_da_Bateria": { - "modified": "2019-03-18T21:29:01.750Z", + "Glossary/CIA": { + "modified": "2020-06-11T20:33:04.482Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/API/API_transmissoes_multimedia": { - "modified": "2019-03-23T22:12:44.463Z", + "Glossary/Compile": { + "modified": "2019-03-23T22:01:24.745Z", "contributors": [ "Anonymous" ] }, - "Web/API/Animation": { - "modified": "2020-10-15T22:09:54.586Z", + "Glossary/GZip_compression": { + "modified": "2019-03-18T21:46:58.480Z", "contributors": [ "Anonymous" ] }, - "Web/API/AudioNode": { - "modified": "2019-03-23T22:12:47.243Z", + "Glossary/CRLF": { + "modified": "2020-06-12T13:10:14.562Z", "contributors": [ - "trusktr" + "joaonunomota" ] }, - "Web/API/Blob": { - "modified": "2020-10-15T22:32:41.617Z", + "Glossary/CRUD": { + "modified": "2020-06-11T20:38:17.457Z", "contributors": [ - "Yayure" + "joaonunomota" ] }, - "Web/API/Blob/Blob": { - "modified": "2020-11-16T10:19:01.877Z", + "Glossary/DOM": { + "modified": "2019-10-08T09:31:32.173Z", "contributors": [ - "joaonunomota" + "Anonymous", + "GoToLoop" ] }, - "Web/API/Blob/size": { - "modified": "2020-10-15T22:32:50.862Z", + "Glossary/ECMA": { + "modified": "2019-03-23T22:30:19.413Z", "contributors": [ - "joaonunomota" + "GoToLoop" ] }, - "Web/API/Blob/type": { - "modified": "2020-10-15T22:33:10.637Z", + "Glossary/Main_Axis": { + "modified": "2019-04-08T06:57:09.138Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/Client": { - "modified": "2020-10-15T22:03:06.133Z", + "Glossary/Cross_Axis": { + "modified": "2019-04-08T06:58:12.600Z", + "contributors": [ + "diogo-panaca" + ] + }, + "Glossary/Element": { + "modified": "2019-03-18T21:18:07.800Z", "contributors": [ "Anonymous" ] }, - "Web/API/CloseEvent": { - "modified": "2020-10-15T22:32:54.165Z", + "Glossary/Tag": { + "modified": "2019-03-23T22:01:42.150Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/CloseEvent/CloseEvent": { - "modified": "2020-10-15T22:32:51.831Z", + "Glossary/WebExtensions": { + "modified": "2019-03-18T21:37:24.767Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/DOMString": { - "modified": "2020-08-12T17:28:52.261Z", + "Glossary/Favicon": { + "modified": "2020-04-30T05:49:13.226Z", "contributors": [ - "joaonunomota" + "adilsonmandlate" ] }, - "Web/API/Document": { - "modified": "2019-07-02T18:26:33.145Z", + "Glossary/Flexbox": { + "modified": "2019-04-08T06:38:43.855Z", "contributors": [ - "Anonymous", - "chrisdavidmills" + "diogo-panaca" ] }, - "Web/API/Document.dir": { - "modified": "2019-03-23T23:22:09.179Z", + "Glossary/SCM": { + "modified": "2020-06-13T09:32:48.386Z", "contributors": [ - "khalid32", - "carlosrainhaaraujo" + "joaonunomota" ] }, - "Web/API/Document/querySelector": { - "modified": "2020-10-15T22:32:00.428Z", + "Glossary/Git": { + "modified": "2020-06-13T09:39:03.707Z", "contributors": [ "joaonunomota" ] }, - "Web/API/Document/visibilitychange_event": { - "modified": "2019-04-08T07:39:14.855Z", + "Glossary/Hypertext": { + "modified": "2019-03-23T22:01:40.877Z", "contributors": [ - "irenesmith", "Anonymous" ] }, - "Web/API/Eventos_de_Luz_Ambiente": { - "modified": "2020-10-15T22:07:41.555Z", + "Glossary/HTML": { + "modified": "2019-03-23T22:13:01.389Z", "contributors": [ "Anonymous" ] }, - "Web/API/File": { - "modified": "2020-10-15T22:32:24.351Z", + "Glossary/IANA": { + "modified": "2020-06-07T13:01:45.679Z", "contributors": [ - "Yayure" + "joaonunomota" ] }, - "Web/API/File/File": { - "modified": "2020-10-15T22:33:11.221Z", + "Glossary/Idempotent": { + "modified": "2019-07-11T10:59:59.365Z", + "contributors": [ + "FilipePintoReis" + ] + }, + "Glossary": { + "modified": "2020-10-07T11:13:28.151Z", + "contributors": [ + "peterbe", + "joaonunomota", + "SphinxKnight", + "Anonymous", + "wbamberg" + ] + }, + "Glossary/IndexedDB": { + "modified": "2019-03-23T22:30:22.618Z", + "contributors": [ + "GoToLoop" + ] + }, + "Glossary/ISP": { + "modified": "2020-07-16T14:02:41.646Z", "contributors": [ "joaonunomota" ] }, - "Web/API/File/fileName": { - "modified": "2020-08-08T18:37:05.171Z", + "Glossary/Lazy_load": { + "modified": "2020-06-09T04:59:38.616Z", "contributors": [ "joaonunomota" ] }, - "Web/API/File/fileSize": { - "modified": "2020-08-08T18:32:45.995Z", + "Glossary/Metadata": { + "modified": "2019-03-18T21:46:57.702Z", + "contributors": [ + "Anonymous" + ] + }, + "Glossary/MitM": { + "modified": "2019-03-18T21:29:48.838Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/File/getAsBinary": { - "modified": "2020-08-11T04:16:46.870Z", + "Glossary/Block_cipher_mode_of_operation": { + "modified": "2020-07-19T20:41:55.171Z", "contributors": [ "joaonunomota" ] }, - "Web/API/File/getAsDataURL": { - "modified": "2020-08-08T18:57:17.906Z", + "Glossary/Engine": { + "modified": "2019-03-23T22:24:10.538Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/File/getAsText": { - "modified": "2020-08-11T05:01:57.694Z", + "Glossary/Browser": { + "modified": "2019-03-23T22:01:42.054Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/File/lastModified": { - "modified": "2020-10-17T08:26:52.375Z", + "Glossary/Node.js": { + "modified": "2019-03-23T22:30:21.428Z", "contributors": [ - "joaonunomota" + "Anonymous", + "GoToLoop" ] }, - "Web/API/File/lastModifiedDate": { - "modified": "2020-10-15T22:32:46.653Z", + "Glossary/Object": { + "modified": "2019-03-18T21:46:57.221Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/File/mozFullPath": { - "modified": "2020-08-08T18:43:12.882Z", + "Glossary/OOP": { + "modified": "2019-03-18T21:47:01.837Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/File/name": { - "modified": "2020-10-15T22:32:23.452Z", + "Glossary/OTA": { + "modified": "2019-03-23T22:30:21.528Z", "contributors": [ - "joaonunomota" + "GoToLoop" ] }, - "Web/API/File/type": { - "modified": "2020-10-15T22:32:40.925Z", + "Glossary/Polyfill": { + "modified": "2019-03-23T22:04:04.730Z", "contributors": [ - "joaonunomota" + "pedrodfcosta" ] }, - "Web/API/File/webkitRelativePath": { - "modified": "2020-11-17T19:01:45.948Z", + "Glossary/Prototype-based_programming": { + "modified": "2019-03-18T21:47:01.974Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/FileReader": { - "modified": "2019-03-18T21:16:40.698Z", + "Glossary/Object_reference": { + "modified": "2019-03-18T21:18:01.122Z", "contributors": [ - "Sheppy" + "Anonymous" ] }, - "Web/API/FileReader/abort": { - "modified": "2020-10-15T22:32:42.433Z", + "Glossary/Server": { + "modified": "2019-03-23T22:30:25.987Z", "contributors": [ - "joaonunomota" + "GoToLoop" ] }, - "Web/API/FileReader/error": { - "modified": "2020-10-15T22:32:24.839Z", + "Glossary/UTF-8": { + "modified": "2019-03-18T20:40:41.143Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/FileReader/readAsArrayBuffer": { - "modified": "2020-10-15T22:33:15.086Z", + "Glossary/Value": { + "modified": "2019-03-18T21:18:07.651Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/FileReader/readAsBinaryString": { - "modified": "2020-10-15T21:37:25.343Z", + "Glossary/Visual_Viewport": { + "modified": "2020-06-10T13:52:57.763Z", "contributors": [ - "joaonunomota", - "DouglasValdo" + "joaonunomota" ] }, - "Web/API/FileReader/readAsDataURL": { - "modified": "2020-10-15T22:34:36.565Z", + "Glossary/Viewport": { + "modified": "2020-06-10T11:59:40.452Z", "contributors": [ "joaonunomota" ] }, - "Web/API/FileReader/readAsText": { - "modified": "2020-10-15T22:34:36.289Z", + "Glossary/WebRTC": { + "modified": "2020-06-07T12:24:38.989Z", "contributors": [ "joaonunomota" ] }, - "Web/API/FileReader/readyState": { - "modified": "2020-11-15T12:35:45.700Z", + "Glossary/WebVTT": { + "modified": "2020-06-12T12:26:29.739Z", "contributors": [ "joaonunomota" ] }, - "Web/API/FileReader/result": { - "modified": "2020-10-15T22:33:14.048Z", + "Glossary/WHATWG": { + "modified": "2020-06-12T08:44:24.569Z", "contributors": [ "joaonunomota" ] }, - "Web/API/Geolocation": { - "modified": "2019-03-23T22:01:56.989Z", + "Glossary/World_Wide_Web": { + "modified": "2019-03-18T21:46:52.018Z", "contributors": [ "Anonymous" ] }, - "Web/API/Geolocation/Utilizacao_da_geolocalizacao": { - "modified": "2020-10-15T21:59:09.308Z", + "Glossary/Wrapper": { + "modified": "2019-03-18T21:17:53.688Z", "contributors": [ "Anonymous" ] }, - "Web/API/MathMLElement": { - "modified": "2020-10-15T22:33:03.137Z", + "Glossary/XML": { + "modified": "2019-03-23T22:01:48.146Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/MediaDevices": { - "modified": "2019-03-23T22:01:16.705Z", + "Mozilla/Developer_guide": { + "modified": "2019-03-24T00:00:34.143Z", "contributors": [ - "jpmedley" + "SphinxKnight", + "teoli", + "Leandro Mercês Xavier" ] }, - "Web/API/MessageEvent": { - "modified": "2020-10-15T22:32:51.894Z", + "Web/HTML/Element/figure": { + "modified": "2019-03-24T00:07:13.574Z", "contributors": [ - "joaonunomota" + "wbamberg", + "jwhitlock", + "teoli", + "f.sanxz" ] }, - "Web/API/Metadados": { - "modified": "2019-03-18T21:46:51.094Z", + "orphaned/Java_em_Extensões_do_Firefox": { + "modified": "2019-03-23T23:44:51.954Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "RuiMaciel" ] }, - "Web/API/NavigatorOnLine": { - "modified": "2019-03-23T22:01:59.308Z", + "orphaned/Javascript_orientado_a_objetos": { + "modified": "2019-03-24T00:11:38.222Z", "contributors": [ - "chrisdavidmills" + "flowck", + "Leandro Mercês Xavier" ] }, - "Web/API/NavigatorOnLine/Eventos_online_e_offline": { - "modified": "2019-03-23T23:49:32.329Z", + "Web/JavaScript/Shells": { + "modified": "2019-03-23T23:49:32.077Z", "contributors": [ "SphinxKnight", - "chrisdavidmills", - "Leandro Mercês Xavier", - "Roli", "Verruckt" ] }, - "Web/API/Node": { - "modified": "2019-03-23T23:22:11.442Z", + "Games": { + "modified": "2019-09-09T15:34:18.541Z", "contributors": [ - "khalid32", - "carlosrainhaaraujo" + "SphinxKnight", + "Aschlla", + "wbamberg", + "rPetas", + "fscholz", + "Anonymous" ] }, - "Web/API/Notifications_API": { - "modified": "2019-03-23T22:42:31.459Z", + "Games/Tutorials": { + "modified": "2019-03-18T21:30:51.808Z", "contributors": [ - "Sebastianz" + "wbamberg", + "Anonymous" ] }, - "Web/API/Notifications_API/Utilizar_API_Notificações": { - "modified": "2019-03-23T22:42:28.564Z", + "Learn/Accessibility": { + "modified": "2020-07-21T16:29:40.277Z", "contributors": [ + "joaonunomota", "Anonymous" ] }, - "Web/API/Page_Visibility_API": { - "modified": "2019-03-18T21:42:30.274Z", + "Learn/Getting_started_with_the_web/The_web_and_web_standards": { + "modified": "2020-08-15T18:38:33.155Z", "contributors": [ + "joaonunomota", "Anonymous" ] }, - "Web/API/Push_API": { - "modified": "2019-03-18T21:38:04.203Z", + "Learn/Getting_started_with_the_web/What_will_your_website_look_like": { + "modified": "2020-07-16T22:34:19.154Z", "contributors": [ + "joaonunomota", + "diogo-panaca", "Anonymous" ] }, - "Web/API/Service_Worker_API": { - "modified": "2019-10-08T09:27:10.284Z", + "Learn/Getting_started_with_the_web/How_the_Web_works": { + "modified": "2020-07-21T16:44:13.094Z", "contributors": [ + "joaonunomota", + "gabodin", "Anonymous" ] }, - "Web/API/Service_Worker_API/Using_Service_Workers": { - "modified": "2019-10-08T09:25:19.208Z", + "Learn/Getting_started_with_the_web/CSS_basics": { + "modified": "2020-08-17T15:28:30.827Z", "contributors": [ + "joaonunomota", + "diogo-panaca", "Anonymous" ] }, - "Web/API/SharedWorker": { - "modified": "2020-10-15T21:59:02.760Z", + "Learn/Getting_started_with_the_web/JavaScript_basics": { + "modified": "2020-08-17T15:31:44.919Z", "contributors": [ "joaonunomota", + "diogo-panaca", "Anonymous" ] }, - "Web/API/Sistema_de_ficheiros": { - "modified": "2020-10-15T21:46:44.138Z", + "Learn/Getting_started_with_the_web/HTML_basics": { + "modified": "2020-08-15T18:37:16.181Z", "contributors": [ "joaonunomota", - "Anonymous" + "diogo-panaca", + "Anonymous", + "mrsilvino" ] }, - "Web/API/URLSearchParams": { - "modified": "2019-10-16T11:18:10.261Z", + "Learn/Getting_started_with_the_web": { + "modified": "2020-11-09T11:59:04.208Z", "contributors": [ - "NunoJSantos", - "goldyteam" + "joaonunomota", + "Anonymous" ] }, - "Web/API/WebGLRenderingContext": { - "modified": "2020-10-15T21:59:21.576Z", + "Learn/Getting_started_with_the_web/Installing_basic_software": { + "modified": "2020-07-23T08:51:53.513Z", "contributors": [ + "joaonunomota", + "diogo-panaca", + "Jacgrillon", "Anonymous" ] }, - "Web/API/WebGL_API": { - "modified": "2020-10-15T21:46:44.276Z", + "Learn/Getting_started_with_the_web/Dealing_with_files": { + "modified": "2020-07-20T16:01:08.653Z", "contributors": [ + "joaonunomota", + "diogo-panaca", "Anonymous" ] }, - "Web/API/WebGL_API/Constantes": { - "modified": "2019-03-23T22:01:30.802Z", + "Learn/Getting_started_with_the_web/Publishing_your_website": { + "modified": "2020-08-17T15:33:14.323Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/API/WebGL_API/Dados": { - "modified": "2019-03-23T22:01:33.105Z", + "Learn/CSS/Styling_text": { + "modified": "2020-07-16T22:26:00.007Z", "contributors": [ "Anonymous" ] }, - "Web/API/WebGL_API/Tipos": { - "modified": "2019-03-23T22:01:33.867Z", + "Learn/CSS/Howto/CSS_FAQ": { + "modified": "2020-07-16T22:25:45.869Z", "contributors": [ "Anonymous" ] }, - "Web/API/WebGL_API/Utilizar_Extensões": { - "modified": "2019-03-23T22:01:32.555Z", + "Learn/HTML/Howto/Add_a_hit_map_on_top_of_an_image": { + "modified": "2020-07-16T22:22:43.567Z", "contributors": [ "Anonymous" ] }, - "Web/API/WebSocket": { - "modified": "2020-10-15T22:32:53.586Z", + "Learn/HTML/Howto": { + "modified": "2020-07-16T22:22:30.740Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/API/WebSocket/WebSocket": { - "modified": "2020-10-15T22:33:03.555Z", + "Learn/HTML/Introduction_to_HTML/Creating_hyperlinks": { + "modified": "2020-07-16T22:23:46.700Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/WebSockets_API": { - "modified": "2020-10-15T22:32:45.764Z", + "Learn/HTML/Introduction_to_HTML/Marking_up_a_letter": { + "modified": "2020-07-16T22:23:13.979Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/WebSockets_API/Escrever_aplicação_cliente_de_WebSocket": { - "modified": "2020-08-11T17:49:59.287Z", + "Learn/HTML/Introduction_to_HTML/Debugging_HTML": { + "modified": "2020-07-16T22:24:15.706Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/WebSockets_API/Escrever_servidores_de_WebSocket": { - "modified": "2020-09-18T06:53:14.308Z", + "Learn/HTML/Introduction_to_HTML/Document_and_website_structure": { + "modified": "2020-07-16T22:24:08.727Z", "contributors": [ - "blunderous", - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/WebSockets_API/Escrever_um_servidor_WebSocket_em_C": { - "modified": "2020-12-04T13:57:23.773Z", + "Learn/HTML/Introduction_to_HTML/Structuring_a_page_of_content": { + "modified": "2020-07-16T22:24:20.585Z", "contributors": [ - "peterbe", - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/WebSockets_API/Escrever_um_servidor_WebSocket_em_Java": { - "modified": "2020-08-24T20:03:27.920Z", + "Learn/HTML/Introduction_to_HTML/Advanced_text_formatting": { + "modified": "2020-07-16T22:23:57.791Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/API/Web_Audio_API": { - "modified": "2019-03-23T22:12:41.433Z", + "Learn/HTML/Introduction_to_HTML": { + "modified": "2020-07-16T22:22:52.576Z", "contributors": [ - "Anonymous", - "erikadoyle" + "diogo-panaca", + "joaomc", + "Anonymous" ] }, - "Web/API/Web_Audio_API/Utilizar_api_audio_web": { - "modified": "2019-03-23T22:12:48.158Z", + "Learn/HTML/Introduction_to_HTML/Getting_started": { + "modified": "2020-07-16T22:23:06.412Z", "contributors": [ + "cmccarreiro", "Anonymous" ] }, - "Web/API/Web_Workers_API": { - "modified": "2019-03-23T22:02:18.370Z", + "Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML": { + "modified": "2020-07-16T22:23:23.598Z", "contributors": [ - "VsevolodGolovanov" + "Anonymous" ] }, - "Web/API/Web_Workers_API/Functions_and_classes_available_to_workers": { - "modified": "2019-03-23T22:02:20.388Z", + "Learn/HTML/Multimedia_and_embedding/Mozilla_splash_page": { + "modified": "2020-07-16T22:25:08.049Z", "contributors": [ + "diegobarcelar", "Anonymous" ] }, - "Web/API/Web_Workers_API/Utilizacao_de_web_workers": { - "modified": "2019-03-23T22:02:15.177Z", + "Learn/HTML/Multimedia_and_embedding/Video_and_audio_content": { + "modified": "2020-07-16T22:24:56.333Z", "contributors": [ - "allanfoppa", "Anonymous" ] }, - "Web/API/Window": { - "modified": "2019-03-23T22:01:06.730Z", + "Learn/HTML/Multimedia_and_embedding": { + "modified": "2020-07-16T22:24:28.825Z", "contributors": [ "Anonymous", - "goeffthomas" + "chrisdavidmills" ] }, - "Web/API/Window/barra_lateral": { - "modified": "2019-03-18T21:37:22.693Z", + "Learn/HTML/Tables/Structuring_planet_data": { + "modified": "2020-07-16T22:25:30.543Z", "contributors": [ "Anonymous" ] }, - "Web/API/Window/console": { - "modified": "2019-03-18T21:44:07.205Z", + "Learn/HTML/Tables/Advanced": { + "modified": "2020-07-16T22:25:27.234Z", "contributors": [ "Anonymous" ] }, - "Web/API/Window/open": { - "modified": "2019-03-23T22:01:10.139Z", + "Learn/HTML/Tables/Basics": { + "modified": "2020-07-16T22:25:22.105Z", "contributors": [ - "SphinxKnight", + "diogo-panaca", "Anonymous" ] }, - "Web/API/Window/postMessage": { - "modified": "2019-06-04T14:57:56.992Z", + "Learn/JavaScript/First_steps": { + "modified": "2020-07-16T22:29:54.837Z", "contributors": [ - "Anonymous" + "Anonymous", + "Elllenn" ] }, - "Web/API/Worker": { - "modified": "2019-03-23T22:02:29.683Z", + "Learn/Server-side/Django": { + "modified": "2020-07-16T22:36:35.255Z", "contributors": [ "Anonymous" ] }, - "Web/API/XMLHttpRequest": { - "modified": "2020-10-15T21:59:27.066Z", + "Learn/Server-side/Express_Nodejs/development_environment": { + "modified": "2020-07-16T22:38:00.728Z", "contributors": [ - "fscholz", "Anonymous" ] }, - "Web/API/notification": { - "modified": "2019-03-23T22:51:36.861Z", + "Learn/Server-side/Express_Nodejs": { + "modified": "2020-07-16T22:37:54.969Z", "contributors": [ "Anonymous", - "Japroriple" + "joao-neves95" ] }, - "Web/Accessibility/ARIA/ARIA_Techniques": { - "modified": "2020-09-18T21:14:54.007Z", + "Learn/Server-side/Express_Nodejs/Introduction": { + "modified": "2020-07-16T22:38:13.187Z", "contributors": [ - "Wind1808" + "Anonymous" ] }, - "Web/Accessibility/ARIA/ARIA_Techniques/Usando_o_role_status": { - "modified": "2020-09-19T05:54:31.819Z", + "Learn/Server-side": { + "modified": "2020-07-16T22:36:01.831Z", "contributors": [ - "Painatalman" + "Anonymous", + "joao-neves95" ] }, - "Web/Acessibilidade": { - "modified": "2019-09-09T14:20:12.758Z", + "Learn/Server-side/Node_server_without_framework": { + "modified": "2020-07-16T22:36:06.037Z", "contributors": [ - "SphinxKnight", "Anonymous", - "teoli", - "Verruckt", - "Kayalemao", - "RuiMaciel", - "Karla pa", - "GrandeBuzina" + "joao-neves95" ] }, - "Web/Acessibilidade/ARIA": { - "modified": "2019-03-18T21:47:01.413Z", + "Learn/Common_questions/How_does_the_Internet_work": { + "modified": "2020-07-16T22:35:37.920Z", "contributors": [ "Anonymous" ] }, - "Web/CSS": { - "modified": "2020-06-10T07:53:42.003Z", + "Learn/Common_questions/set_up_a_local_testing_server": { + "modified": "2020-07-16T22:35:53.519Z", "contributors": [ - "joaonunomota", - "SphinxKnight", - "Anonymous", - "Fernando-SilvaBR", - "albertocastro", - "teoli", - "Verruckt", - "Leandro Mercês Xavier", - "Takenbot", - "RuiMaciel" + "Anonymous" ] }, - "Web/CSS/:after": { - "modified": "2019-03-24T00:00:16.761Z", + "Learn/Common_questions": { + "modified": "2020-07-16T22:35:26.594Z", "contributors": [ - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/:before": { - "modified": "2019-03-24T00:00:19.264Z", + "Learn/Common_questions/What_is_a_domain_name": { + "modified": "2020-07-16T22:35:44.710Z", "contributors": [ - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/@font-face": { - "modified": "2019-03-23T23:13:15.857Z", + "Learn/Common_questions/What_is_a_web_server": { + "modified": "2020-07-16T22:35:31.962Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Web/CSS/@import": { - "modified": "2019-03-23T23:47:07.977Z", + "Learn/Common_questions/What_is_a_URL": { + "modified": "2020-07-16T22:35:30.214Z", "contributors": [ - "Anonymous", - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/@media": { - "modified": "2020-04-25T11:58:21.640Z", + "Learn/Common_questions/Pages_sites_servers_and_search_engines": { + "modified": "2020-07-16T22:35:40.437Z", "contributors": [ - "myspeleo", - "diogo-panaca", - "Anonymous", - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/At-rule": { - "modified": "2019-03-23T22:24:56.828Z", + "Learn/Tools_and_testing/Cross_browser_testing/Accessibility": { + "modified": "2020-09-24T09:24:04.432Z", "contributors": [ - "Anonymous" + "Painatalman" ] }, - "Web/CSS/CSS_Background_and_Borders": { - "modified": "2019-03-23T22:44:16.974Z", + "Learn/Tools_and_testing/Cross_browser_testing": { + "modified": "2020-07-16T22:39:01.215Z", "contributors": [ - "teoli" + "wbamberg", + "Anonymous" ] }, - "Web/CSS/CSS_Background_and_Borders/Múltiplos_planos_de_fundo": { - "modified": "2019-03-24T00:04:47.389Z", + "Glossary/Localization": { + "modified": "2019-03-24T00:03:56.319Z", "contributors": [ "Anonymous", - "teoli", - "Verruckt" + "fscholz", + "Verruckt", + "Kayalemao", + "Tagl" ] }, - "Web/CSS/CSS_Box_Model": { - "modified": "2019-03-23T22:12:41.880Z", + "orphaned/Localizar_descrições_de_extensões": { + "modified": "2019-03-24T00:02:35.408Z", "contributors": [ - "Sebastianz" + "SphinxKnight", + "fscholz", + "Verruckt" ] }, - "Web/CSS/CSS_Box_Model/Introducao_modelo_caixa_CSS": { - "modified": "2019-03-23T22:12:42.813Z", + "orphaned/Manipuladores_de_protocolo_web": { + "modified": "2019-03-23T23:52:53.802Z", "contributors": [ - "Anonymous" + "Verruckt", + "Fernandopsilveira", + "Leandro Mercês Xavier" ] }, - "Web/CSS/CSS_Colors/Ferramenta_selecao_cor": { - "modified": "2019-04-28T14:53:13.655Z", + "conflicting/MDN/Contribute": { + "modified": "2020-02-19T18:51:00.800Z", "contributors": [ - "diogo-panaca" + "jswisher", + "Anonymous" ] }, - "Web/CSS/CSS_Columns": { - "modified": "2019-03-18T21:38:41.627Z", + "MDN/At_ten/History_of_MDN": { + "modified": "2019-03-23T22:09:33.028Z", "contributors": [ - "mfluehr" + "Anonymous" ] }, - "Web/CSS/CSS_Flexible_Box_Layout": { - "modified": "2019-03-18T21:44:02.737Z", + "MDN/At_ten": { + "modified": "2019-03-23T22:50:14.757Z", "contributors": [ - "rachelandrew" + "Anonymous", + "Matoplays" ] }, - "Web/CSS/CSS_Flexible_Box_Layout/alinhamento_de_itens_num_recipiente_flex": { - "modified": "2019-06-11T07:33:08.010Z", + "orphaned/MDN/Community/Conversations": { + "modified": "2019-01-16T21:51:19.575Z", "contributors": [ - "BIGBenfica9", + "wbamberg", "Anonymous" ] }, - "Web/CSS/CSS_Flexible_Box_Layout/casos_de_utilizacao_tipicos_do_flexbox": { - "modified": "2019-03-18T21:43:55.771Z", + "orphaned/MDN/Community/Doc_sprints": { + "modified": "2019-03-18T21:19:58.227Z", "contributors": [ "Anonymous" ] }, - "Web/CSS/CSS_Flexible_Box_Layout/ordenacao_dos_itens_flex": { - "modified": "2019-07-22T03:58:30.968Z", + "orphaned/MDN/Community": { + "modified": "2019-09-11T08:01:31.979Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "Anonymous", + "wbamberg" ] }, - "Web/CSS/CSS_Flexible_Box_Layout/relação_do_flexbox_com_outros_métodos_de_layout": { - "modified": "2019-03-18T21:43:58.441Z", + "orphaned/MDN/Community/Whats_happening": { + "modified": "2019-03-23T22:42:12.854Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/CSS/CSS_Tipos": { - "modified": "2019-03-18T21:23:17.150Z", + "orphaned/MDN/Community/Working_in_community": { + "modified": "2020-02-19T19:07:51.992Z", "contributors": [ + "jswisher", + "wbamberg", "Anonymous" ] }, - "Web/CSS/Como_começar": { - "modified": "2019-03-23T23:44:54.310Z", + "MDN/Contribute/Howto/Convert_code_samples_to_be_live": { + "modified": "2020-03-02T17:27:21.266Z", "contributors": [ - "Anonymous", - "teoli", - "Leandro Mercês Xavier", - "Verruckt", - "Pilinio", - "Luisvulcanis" + "carlostojal", + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/CSS_legível": { - "modified": "2019-03-24T00:00:36.923Z", + "orphaned/MDN/Contribute/Howto/Set_the_summary_for_a_page": { + "modified": "2019-03-23T22:08:19.737Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Luis Henrique Sousa", - "Leandro Mercês Xavier" + "wbamberg", + "Saconte", + "Anonymous" ] }, - "Web/CSS/Como_começar/Caixas": { - "modified": "2019-03-24T00:00:34.956Z", + "orphaned/MDN/Contribute/Howto/Do_a_technical_review": { + "modified": "2019-05-13T07:55:49.326Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Web/CSS/Como_começar/Cascata_e_herança": { - "modified": "2019-03-24T00:00:35.429Z", + "orphaned/MDN/Contribute/Howto/Write_an_article_to_help_learn_about_the_Web": { + "modified": "2020-02-28T22:23:56.590Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/Como_o_CSS_trabalha": { - "modified": "2019-03-24T00:00:37.691Z", + "MDN/Contribute/Howto/Write_a_new_entry_in_the_Glossary": { + "modified": "2019-03-23T22:12:45.769Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "wbamberg", + "maarysantos", + "Anonymous" ] }, - "Web/CSS/Como_começar/Conteúdo": { - "modified": "2020-07-16T22:25:48.413Z", + "MDN/Contribute/Howto/Report_a_problem": { + "modified": "2020-01-07T12:19:34.416Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "peterbe", + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/Cor": { - "modified": "2019-03-24T00:00:35.276Z", + "MDN/Contribute/Howto/Create_and_edit_pages": { + "modified": "2019-04-04T11:57:15.432Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "diogo-panaca" ] }, - "Web/CSS/Como_começar/Disposição": { - "modified": "2019-03-24T00:00:37.327Z", + "orphaned/MDN/Contribute/Howto/Create_an_MDN_account": { + "modified": "2019-03-23T22:42:11.494Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/Como_começar/Estilos_de_texto": { - "modified": "2019-03-24T00:00:39.580Z", + "MDN/Contribute/Howto/Tag": { + "modified": "2019-11-13T11:32:17.983Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier", - "Luis Henrique Sousa" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/Como_começar/Gráficos_SVG": { - "modified": "2019-03-24T00:00:34.584Z", + "orphaned/MDN/Contribute/Howto/Do_an_editorial_review": { + "modified": "2019-03-23T22:20:12.878Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "Anonymous", + "wbamberg", + "samlopes_br" ] }, - "Web/CSS/Como_começar/JavaScript": { - "modified": "2019-03-24T00:00:40.211Z", + "orphaned/MDN/Contribute/Howto/Tag_JavaScript_pages": { + "modified": "2019-01-17T01:35:48.693Z", "contributors": [ - "fscholz", - "teoli", - "ethertank", - "Verruckt", - "Leandro Mercês Xavier" + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/Listas": { - "modified": "2019-03-24T00:00:36.171Z", + "orphaned/MDN/Contribute/Howto/Be_a_beta_tester": { + "modified": "2019-03-23T22:09:29.860Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Luis Henrique Sousa", - "Leandro Mercês Xavier" + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/Mídia": { - "modified": "2019-03-24T00:15:51.724Z", + "orphaned/MDN/Editor/Basics": { + "modified": "2020-09-30T15:43:23.869Z", "contributors": [ + "chrisdavidmills", "Anonymous", - "fscholz", - "teoli", - "maggots", - "Verruckt", - "Leandro Mercês Xavier" + "wbamberg" ] }, - "Web/CSS/Como_começar/O_que_é_CSS": { - "modified": "2019-03-24T00:00:33.943Z", + "orphaned/MDN/Editor": { + "modified": "2020-09-30T15:43:23.702Z", "contributors": [ - "Sebastianz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier", - "Pilinio" + "chrisdavidmills", + "Anonymous", + "wbamberg" ] }, - "Web/CSS/Como_começar/O_que_é_CSS?": { - "modified": "2019-03-23T23:43:00.605Z", + "MDN/Guidelines/Conventions_definitions": { + "modified": "2020-09-30T15:31:29.524Z", "contributors": [ - "teoli", - "Leandro Mercês Xavier" + "chrisdavidmills", + "jswisher", + "Anonymous", + "wbamberg" ] }, - "Web/CSS/Como_começar/Porque_usar_CSS": { - "modified": "2019-03-24T00:00:39.116Z", + "MDN/Guidelines/Writing_style_guide": { + "modified": "2020-09-30T15:31:29.280Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier", - "Pilinio" + "chrisdavidmills", + "joaonunomota", + "jswisher", + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Como_começar/Seletores": { - "modified": "2019-03-24T00:00:36.764Z", + "MDN/Guidelines/Does_this_belong_on_MDN": { + "modified": "2020-09-30T15:31:29.806Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "chrisdavidmills", + "jswisher", + "Anonymous" ] }, - "Web/CSS/Como_começar/Tabelas": { - "modified": "2019-03-24T00:00:35.865Z", + "MDN/Yari": { + "modified": "2019-09-09T15:53:50.658Z", "contributors": [ - "fscholz", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "SphinxKnight", + "Anonymous", + "wbamberg" ] }, - "Web/CSS/Consulta_de_mídia": { - "modified": "2019-04-09T16:57:57.913Z", + "MDN/About": { + "modified": "2019-09-10T08:55:19.644Z", "contributors": [ - "diogo-panaca", + "SphinxKnight", "Anonymous", - "Sebastianz", - "mrstork", - "teoli", - "Verruckt", - "Leandro Mercês Xavier" + "wbamberg", + "Dilson", + "jswisher" ] }, - "Web/CSS/Consultas_de_media": { - "modified": "2020-10-15T22:17:12.623Z", + "MDN/Contribute/Howto/Write_an_API_reference/Sidebars": { + "modified": "2020-09-30T12:57:10.465Z", "contributors": [ - "diogo-panaca" + "chrisdavidmills", + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Folhas_de_estilo_alternativas": { - "modified": "2019-03-23T23:53:49.046Z", + "orphaned/MDN/Structures/API_references": { + "modified": "2020-09-30T12:57:10.288Z", "contributors": [ - "teoli", - "FelipeMorais" + "chrisdavidmills", + "wbamberg" ] }, - "Web/CSS/Média_paginada": { - "modified": "2019-03-23T22:24:57.103Z", + "orphaned/MDN/Structures/API_references/What_does_an_API_reference_need": { + "modified": "2020-09-30T12:57:10.634Z", "contributors": [ + "chrisdavidmills", + "wbamberg", "Anonymous" ] }, - "Web/CSS/Pseudoclasses": { - "modified": "2019-03-18T21:15:25.227Z", + "MDN/Structures/Live_samples": { + "modified": "2020-09-30T12:57:10.000Z", "contributors": [ + "chrisdavidmills", + "wbamberg", "Anonymous" ] }, - "Web/CSS/Pseudoelementos": { - "modified": "2019-03-18T21:23:11.174Z", + "orphaned/MDN/Tools/Template_editing": { + "modified": "2020-09-30T16:53:23.123Z", "contributors": [ + "chrisdavidmills", + "wbamberg", "Anonymous" ] }, - "Web/CSS/Referência_CSS": { - "modified": "2020-07-20T13:36:56.218Z", - "contributors": [ - "joaonunomota", - "Anonymous", - "teoli", - "Moacir Bispo", - "Verruckt" - ] - }, - "Web/CSS/Replaced_element": { - "modified": "2019-03-23T22:32:04.311Z", + "orphaned/MDN/Tools/Page_watching": { + "modified": "2020-09-30T16:53:22.646Z", "contributors": [ - "andrekutianski", - "josketres" + "chrisdavidmills", + "wbamberg", + "Anonymous" ] }, - "Web/CSS/Shorthand_properties": { - "modified": "2019-03-18T21:44:05.610Z", + "orphaned/MDN/Troubleshooting": { + "modified": "2020-09-30T16:58:33.426Z", "contributors": [ + "chrisdavidmills", + "wbamberg", "Anonymous" ] }, - "Web/CSS/Usando_transformações_CSS": { - "modified": "2019-03-24T00:04:50.895Z", + "orphaned/Melhorias_do_Gerenciador_de_Downloads_no_Firefox_3": { + "modified": "2019-01-16T14:39:25.788Z", "contributors": [ - "teoli", - "Verruckt", - "Leandro Mercês Xavier", - "Jürgen Jeka" + "fscholz", + "Verruckt" ] }, - "Web/CSS/background": { - "modified": "2019-03-23T23:46:35.449Z", + "Mozilla/Add-ons/WebExtensions/Your_first_WebExtension": { + "modified": "2019-03-18T21:04:11.435Z", "contributors": [ - "SphinxKnight", - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/background-attachment": { - "modified": "2019-03-23T23:12:53.495Z", + "Mozilla/Add-ons/WebExtensions/Your_second_WebExtension": { + "modified": "2019-03-18T21:03:02.346Z", "contributors": [ - "SphinxKnight", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/background-color": { - "modified": "2019-03-23T22:16:20.029Z", + "Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension": { + "modified": "2019-03-18T21:03:04.427Z", "contributors": [ - "SphinxKnight", - "teoli", - "Verruckt", - "ethertank" + "Anonymous" ] }, - "Web/CSS/background-image": { - "modified": "2019-03-23T23:47:07.090Z", + "Mozilla/Add-ons/WebExtensions/API/storage": { + "modified": "2020-10-15T21:59:48.396Z", "contributors": [ - "SphinxKnight", - "teoli", - "Verruckt" + "wbamberg", + "Anonymous" ] }, - "Web/CSS/background-position": { - "modified": "2019-03-23T23:47:05.241Z", + "Mozilla/Add-ons/WebExtensions/API/devtools/panels": { + "modified": "2020-10-15T21:59:48.885Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/background-repeat": { - "modified": "2019-03-18T21:15:14.751Z", + "orphaned/Mozilla/Add-ons/WebExtensions/User_experience_best_practices": { + "modified": "2019-03-18T21:02:27.071Z", "contributors": [ - "SphinxKnight", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border": { - "modified": "2019-01-16T15:59:54.146Z", + "orphaned/Mozilla/Add-ons/WebExtensions/Porting_a_legacy_Firefox_add-on": { + "modified": "2019-03-18T20:56:20.829Z", "contributors": [ - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/border-bottom": { - "modified": "2019-03-23T23:47:10.248Z", + "Mozilla/Add-ons/WebExtensions/Match_patterns": { + "modified": "2020-10-15T22:25:44.918Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "martimafonso" ] }, - "Web/CSS/border-bottom-color": { - "modified": "2019-03-23T23:47:06.644Z", + "Mozilla/Add-ons/WebExtensions/What_next_": { + "modified": "2019-03-18T21:01:48.060Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-bottom-style": { - "modified": "2019-03-23T23:47:07.572Z", + "Mozilla/Add-ons/WebExtensions/Examples": { + "modified": "2019-03-18T21:03:01.761Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-bottom-width": { - "modified": "2019-03-23T23:47:10.824Z", + "orphaned/Mozilla/Add-ons/WebExtensions/WebExtensions_and_the_Add-on_ID": { + "modified": "2019-03-18T20:47:01.907Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-collapse": { - "modified": "2019-03-23T23:47:06.488Z", + "Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools": { + "modified": "2019-03-18T21:04:10.244Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-color": { - "modified": "2019-03-24T00:02:05.127Z", + "orphaned/Mozilla/Add-ons/WebExtensions/Temporary_Installation_in_Firefox": { + "modified": "2019-03-18T21:03:04.634Z", "contributors": [ - "wbamberg", - "teoli", - "gerson23", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-left": { - "modified": "2019-01-16T15:59:39.346Z", + "Mozilla/Add-ons/WebExtensions/Intercept_HTTP_requests": { + "modified": "2019-03-18T21:03:59.316Z", "contributors": [ - "teoli", - "Verruckt" + "carlosteixeiraa" ] }, - "Web/CSS/border-left-color": { - "modified": "2019-01-16T19:20:48.785Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Browser_action": { + "modified": "2019-03-18T21:04:05.718Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-left-style": { - "modified": "2019-01-16T15:59:50.769Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Page_actions": { + "modified": "2019-03-18T21:04:17.709Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-left-width": { - "modified": "2019-01-16T16:00:08.928Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Sidebars": { + "modified": "2019-03-18T21:04:06.139Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-right": { - "modified": "2019-01-16T15:59:50.709Z", + "Mozilla/Add-ons/WebExtensions/user_interface/devtools_panels": { + "modified": "2019-03-18T21:04:02.641Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-right-color": { - "modified": "2019-01-16T15:59:44.072Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Browser_styles": { + "modified": "2020-10-15T22:07:31.177Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-right-style": { - "modified": "2019-01-16T15:59:50.407Z", + "Mozilla/Add-ons/WebExtensions/user_interface": { + "modified": "2019-03-18T21:04:19.885Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-right-width": { - "modified": "2019-01-16T16:00:01.042Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Context_menu_items": { + "modified": "2019-03-18T21:04:09.803Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-spacing": { - "modified": "2019-03-23T23:47:07.851Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Notifications": { + "modified": "2019-03-18T21:04:17.481Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-top": { - "modified": "2019-01-17T10:27:59.370Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Omnibox": { + "modified": "2019-03-18T21:01:59.411Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-top-color": { - "modified": "2019-01-16T19:20:46.774Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Options_pages": { + "modified": "2019-03-18T21:04:14.023Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-top-style": { - "modified": "2019-01-16T15:59:52.923Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Extension_pages": { + "modified": "2019-03-18T21:03:04.123Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/border-top-width": { - "modified": "2019-01-16T16:00:01.372Z", + "Mozilla/Add-ons/WebExtensions/user_interface/Popups": { + "modified": "2019-08-10T13:56:46.929Z", "contributors": [ - "teoli", - "Verruckt" + "pedrosino", + "Anonymous" ] }, - "Web/CSS/border-width": { - "modified": "2019-03-23T23:12:52.902Z", + "Mozilla/Add-ons/WebExtensions/manifest.json/icons": { + "modified": "2020-10-15T21:59:47.019Z", "contributors": [ "wbamberg", - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/bottom": { - "modified": "2019-01-16T16:00:22.463Z", + "Mozilla/Add-ons/WebExtensions/What_are_WebExtensions": { + "modified": "2019-03-18T21:05:19.046Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/clear": { - "modified": "2019-03-23T23:35:13.332Z", + "orphaned/Mozilla/Add-ons/WebExtensions/Getting_started_with_web-ext": { + "modified": "2019-03-18T21:03:10.522Z", "contributors": [ - "wbamberg", - "teoli", - "Luis Henrique Sousa", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/color": { - "modified": "2019-01-16T19:20:48.419Z", + "orphaned/Mozilla/Add-ons/WebExtensions/Package_your_extension_": { + "modified": "2019-03-18T21:04:14.402Z", "contributors": [ - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/content": { - "modified": "2019-03-24T00:02:07.101Z", + "Mozilla/Add-ons/WebExtensions/Content_scripts": { + "modified": "2019-07-29T11:08:46.237Z", "contributors": [ - "teoli", - "Half-blood" + "duduindo", + "Anonymous" ] }, - "Web/CSS/counter-increment": { - "modified": "2019-03-23T23:47:04.420Z", + "Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs": { + "modified": "2020-10-15T20:55:03.457Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/counter-reset": { - "modified": "2019-03-23T23:47:10.117Z", + "orphaned/Mozilla/Add-ons/WebExtensions/Porting_a_Google_Chrome_extension": { + "modified": "2019-03-18T21:05:15.395Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous", + "Nunonmac101" ] }, - "Web/CSS/cursor": { - "modified": "2019-03-24T00:02:03.227Z", + "Mozilla/Firefox/Releases/3/Site_compatibility": { + "modified": "2019-03-23T23:47:04.199Z", "contributors": [ "wbamberg", - "teoli", - "Half-blood", + "Sheppy", "Verruckt" ] }, - "Web/CSS/direction": { - "modified": "2019-01-16T16:56:47.948Z", + "orphaned/O_DOM_e_o_JavaScript": { + "modified": "2019-12-13T21:10:33.944Z", "contributors": [ - "teoli", - "Verruckt" + "wbamberg", + "fferracioli" ] }, - "Web/CSS/display": { - "modified": "2019-03-23T23:49:28.516Z", + "orphaned/Plugins/Flash_Activation:_Browser_Comparison": { + "modified": "2019-03-18T20:56:19.824Z", "contributors": [ - "wbamberg", - "Anonymous", - "teoli", - "ethertank", - "Leandro Mercês Xavier", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/float": { - "modified": "2019-03-23T23:47:04.610Z", + "Plugins/Flash_to_HTML5": { + "modified": "2019-03-18T20:56:20.182Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/font": { - "modified": "2019-03-23T23:47:10.686Z", + "orphaned/Referência_do_DOM_Gecko/Prefácio": { + "modified": "2019-03-23T23:51:50.810Z", "contributors": [ - "wbamberg", - "teoli", - "Verruckt" + "khalid32", + "Leandro Mercês Xavier", + "Davis.peixoto" ] }, - "Web/CSS/font-size": { - "modified": "2019-03-23T23:47:15.600Z", + "orphaned/Referência_JSDBGAPI": { + "modified": "2019-03-23T23:44:44.830Z", "contributors": [ - "wbamberg", - "RCat", - "teoli", + "SphinxKnight", + "RuiMaciel" + ] + }, + "orphaned/Sobre_o_Document_Object_Model": { + "modified": "2019-03-23T23:46:25.664Z", + "contributors": [ + "SphinxKnight", "Verruckt" ] }, - "Web/CSS/font-size-adjust": { - "modified": "2019-03-23T23:47:06.762Z", + "orphaned/Tinderbox": { + "modified": "2019-03-23T23:45:30.178Z", "contributors": [ - "wbamberg", - "teoli", + "SphinxKnight", "Verruckt" ] }, - "Web/CSS/font-smooth": { - "modified": "2020-10-15T22:20:31.703Z", + "orphaned/Toolkit_API": { + "modified": "2019-01-16T16:23:47.926Z", "contributors": [ - "LPJFilho" + "Tagl" ] }, - "Web/CSS/font-style": { - "modified": "2019-03-23T23:51:37.862Z", + "orphaned/Tools/Add-ons": { + "modified": "2020-07-16T22:36:23.718Z", "contributors": [ - "wbamberg", - "fscholz", - "teoli", - "Luis Henrique Sousa" + "wbamberg" ] }, - "Web/CSS/font-weight": { - "modified": "2019-03-23T23:47:17.771Z", + "Tools/Keyboard_shortcuts": { + "modified": "2020-07-16T22:35:50.422Z", "contributors": [ - "gusbemacbe", - "SphinxKnight", - "teoli", - "Verruckt" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/grid-gap": { - "modified": "2020-10-15T22:00:32.351Z", + "Tools/Taking_screenshots": { + "modified": "2020-07-16T22:36:38.620Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/CSS/height": { - "modified": "2019-03-23T23:47:57.733Z", + "Tools/Settings": { + "modified": "2020-07-16T22:36:35.515Z", "contributors": [ "wbamberg", - "teoli", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/inherit": { - "modified": "2019-01-16T15:39:13.615Z", + "Tools/Web_Console/UI_Tour": { + "modified": "2020-07-16T22:34:17.467Z", "contributors": [ - "teoli", - "Hillus" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/layout_de_grelha_css": { - "modified": "2020-04-12T22:44:10.924Z", + "Tools/Web_Console/Helpers": { + "modified": "2020-07-16T22:34:13.111Z", "contributors": [ - "carlosaffrc", - "Anonymous" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/list-style": { - "modified": "2019-03-23T23:47:53.661Z", + "Tools/Web_Console/Keyboard_shortcuts": { + "modified": "2020-07-16T22:34:23.988Z", "contributors": [ - "SphinxKnight", - "teoli", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/CSS/top": { - "modified": "2019-01-16T14:40:15.687Z", + "Tools/Web_Console/Split_console": { + "modified": "2020-07-16T22:34:21.158Z", "contributors": [ - "teoli", - "Half-blood" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/transform": { - "modified": "2019-03-23T22:12:47.007Z", + "Tools/Web_Console": { + "modified": "2020-07-16T22:34:07.526Z", "contributors": [ - "Anonymous" + "Anonymous", + "wbamberg" ] }, - "Web/CSS/width": { - "modified": "2019-03-23T23:47:51.459Z", + "Tools/Web_Console/Console_messages": { + "modified": "2020-07-16T22:34:16.005Z", "contributors": [ "wbamberg", - "Redeagle48", - "teoli", - "Luis Henrique Sousa", - "Verruckt" + "Anonymous" ] }, - "Web/CSS/z-index": { - "modified": "2019-01-17T04:06:04.605Z", + "Tools/Web_Console/The_command_line_interpreter": { + "modified": "2020-07-16T22:34:19.541Z", "contributors": [ - "teoli", - "Verruckt", - "Luis Henrique Sousa" + "Anonymous" ] }, - "Web/Componentes_Web": { - "modified": "2019-08-20T17:28:31.563Z", + "Tools/Web_Console/Rich_output": { + "modified": "2020-07-16T22:34:20.453Z", "contributors": [ - "filipe095", "Anonymous" ] }, - "Web/Eventos": { - "modified": "2019-04-30T14:29:45.980Z", + "Tools/Debugger/UI_Tour": { + "modified": "2020-07-16T22:35:16.876Z", "contributors": [ "wbamberg", "Anonymous" ] }, - "Web/Guide": { - "modified": "2020-11-12T11:23:45.364Z", - "contributors": [ - "nuruldecarvalho", - "Anonymous", - "Onsteroids" - ] - }, - "Web/Guide/AJAX": { - "modified": "2019-03-23T23:43:06.644Z", + "Tools/Debugger/How_to/Open_the_debugger": { + "modified": "2020-07-16T22:35:09.351Z", "contributors": [ - "Anonymous", - "chrisdavidmills", - "Leandro Mercês Xavier", - "Takenbot", - "Dria", - "RuiMaciel" + "Anonymous" ] }, - "Web/Guide/AJAX/Como_começar": { - "modified": "2019-03-23T23:58:34.669Z", + "Tools/Performance/Call_Tree": { + "modified": "2020-07-16T22:36:20.006Z", "contributors": [ - "Anonymous", - "chrisdavidmills", - "flaviomicheletti", - "Leandro Mercês Xavier", - "Fmtakaki", - "Verruckt", - "TroyDF", - "Japa al", - "Mederafael", - "Juliandavi", - "Thomaskp", - "Caed", - "Takenbot", - "Filipesperandio", - "Pmdweb", - "RuiMaciel" + "wbamberg", + "Anonymous" ] }, - "Web/Guide/AJAX/Comunidade": { - "modified": "2019-03-18T21:47:01.551Z", + "Tools/Performance/Waterfall": { + "modified": "2020-07-16T22:36:18.250Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/Guide/Eventos": { - "modified": "2019-03-23T22:01:48.833Z", + "Tools/Performance/How_to": { + "modified": "2020-07-16T22:36:21.955Z", "contributors": [ - "Anonymous" + "Anonymous", + "wbamberg" ] }, - "Web/Guide/Gráficos": { - "modified": "2019-03-18T21:46:51.581Z", + "Tools/Performance/Frame_rate": { + "modified": "2020-07-16T22:36:19.201Z", "contributors": [ - "ivolvicente", + "wbamberg", "Anonymous" ] }, - "Web/Guide/HTML/Categorias_de_conteudo": { - "modified": "2019-03-18T21:30:45.160Z", + "Tools/Performance": { + "modified": "2020-07-16T22:36:13.622Z", "contributors": [ - "Anonymous" + "Anonymous", + "wbamberg" ] }, - "Web/Guide/HTML/Utilizar_estruturas_e_seccoes_de_HTML": { - "modified": "2019-03-18T21:46:45.859Z", + "Tools/Web_Audio_Editor": { + "modified": "2020-07-16T22:36:08.692Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/HTML": { - "modified": "2020-07-22T17:12:42.326Z", + "Tools/Style_Editor": { + "modified": "2020-07-16T22:35:01.029Z", "contributors": [ - "joaonunomota", - "SphinxKnight", - "duduindo", - "tyreecruz6", - "Anonymous", - "Devenancio", - "didi9999", - "jwhitlock" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/Aplicar_cor_elementos_HTML_utilizando_CSS": { - "modified": "2019-03-23T22:01:35.840Z", + "Tools/Storage_Inspector": { + "modified": "2020-07-16T22:36:10.303Z", "contributors": [ - "jwhitlock", + "wbamberg", "Anonymous" ] }, - "Web/HTML/Atributos": { - "modified": "2019-03-23T22:12:57.935Z", + "Tools/Memory": { + "modified": "2020-07-16T22:36:27.341Z", "contributors": [ - "jwhitlock", - "Anonymous", - "ricardomartins" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/Atributos/rel": { - "modified": "2020-10-15T22:34:32.449Z", + "Tools/Responsive_Design_Mode": { + "modified": "2020-07-16T22:35:22.282Z", "contributors": [ - "Painatalman" + "Anonymous" ] }, - "Web/HTML/Atributos_globais": { - "modified": "2019-03-23T22:02:25.995Z", + "Tools/Page_Inspector/Keyboard_shortcuts": { + "modified": "2020-07-16T22:34:52.351Z", "contributors": [ - "Anonymous", - "jwhitlock" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/CORS_settings_attributes": { - "modified": "2020-10-15T22:18:00.790Z", + "Tools/Page_Inspector/UI_Tour": { + "modified": "2020-07-16T22:34:49.596Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/HTML/Elemento": { - "modified": "2020-11-30T19:06:39.688Z", + "Tools/Page_Inspector/How_to/Open_the_Inspector": { + "modified": "2020-07-16T22:34:33.099Z", "contributors": [ - "jotafe32", - "joaonunomota", - "MacedoAna", "Anonymous", - "jwhitlock", - "teoli", - "Leandro Mercês Xavier" + "wbamberg" ] }, - "Web/HTML/Elemento/Audio": { - "modified": "2019-03-24T00:00:34.265Z", + "Tools/Page_Inspector/How_to/Examine_and_edit_CSS": { + "modified": "2020-07-16T22:34:43.588Z", "contributors": [ - "jwhitlock", - "teoli", - "Leandro Mercês Xavier" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/Elemento/Video": { - "modified": "2019-03-24T00:00:37.866Z", + "Tools/Page_Inspector/How_to/Examine_and_edit_the_box_model": { + "modified": "2020-07-16T22:34:34.516Z", "contributors": [ - "jwhitlock", - "teoli", - "Leandro Mercês Xavier" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/Elemento/fieldset": { - "modified": "2020-10-15T22:23:45.358Z", + "Tools/Page_Inspector/How_to/Inspect_and_select_colors": { + "modified": "2020-07-16T22:34:35.181Z", "contributors": [ + "wbamberg", "Anonymous" ] }, - "Web/HTML/Elemento/figcaption": { - "modified": "2019-03-24T00:12:29.922Z", + "Tools/Page_Inspector/How_to/Reposition_elements_in_the_page": { + "modified": "2020-07-16T22:34:46.213Z", "contributors": [ "wbamberg", - "jwhitlock", - "teoli", - "f.sanxz" + "Anonymous" ] }, - "Web/HTML/Elemento/head": { - "modified": "2020-10-15T21:59:43.855Z", + "Tools/Page_Inspector/How_to/Work_with_animations": { + "modified": "2020-07-16T22:34:37.073Z", "contributors": [ - "jwhitlock", + "wbamberg", "Anonymous" ] }, - "Web/HTML/Elemento/nav": { - "modified": "2020-10-15T21:57:44.552Z", + "Tools/Page_Inspector/How_to/Use_the_Inspector_API": { + "modified": "2020-07-16T22:34:45.056Z", "contributors": [ - "jwhitlock", - "JoseRicardoGomes" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/Elemento/progress": { - "modified": "2019-03-24T00:11:12.291Z", + "Tools/Page_Inspector/How_to/Edit_fonts": { + "modified": "2020-07-16T22:34:39.170Z", "contributors": [ "wbamberg", - "jwhitlock", - "teoli", - "gustavowiller", - "Leandro Mercês Xavier" + "Anonymous" ] }, - "Web/HTML/HTML5": { - "modified": "2019-03-24T00:15:44.005Z", + "Tools/Performance/UI_Tour": { + "modified": "2020-07-16T22:36:15.326Z", "contributors": [ - "InesFF", - "Anonymous", - "teoli", - "emilianocarvalho", - "vigia122", - "Dwchiang", - "Verruckt" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/HTML5/Forms_no_HTML5": { - "modified": "2019-03-24T00:05:42.238Z", + "Tools/Remote_Debugging/Thunderbird": { + "modified": "2020-07-16T22:35:40.059Z", "contributors": [ - "juliano_aguiar", - "teoli", - "Verruckt" + "wbamberg", + "Anonymous" ] }, - "Web/HTML/HTML5/Introdução_ao_HTML5": { - "modified": "2019-03-24T00:13:41.465Z", + "orphaned/Transformar_XML_com_XSLT": { + "modified": "2019-03-23T23:45:21.155Z", "contributors": [ "SphinxKnight", - "teoli", - "mauricio.araldi", - "xaky", - "Verruckt" - ] - }, - "Web/HTML/HTML5/Parser_HTML5": { - "modified": "2019-03-24T00:07:33.282Z", - "contributors": [ - "teoli", "Verruckt" ] }, - "Web/HTML/Referencia": { - "modified": "2019-09-09T07:20:05.681Z", + "orphaned/Transformar_XML_com_XSLT/Para_leitura_adicional": { + "modified": "2019-03-23T23:52:21.068Z", "contributors": [ "SphinxKnight", - "wbamberg", - "jwhitlock", - "Anonymous" + "Leandro Mercês Xavier", + "Pilinio", + "Verruckt" ] }, - "Web/HTML/Tipos_de_hiperligacao": { - "modified": "2019-03-23T22:02:19.809Z", + "orphaned/Tutorial_do_Canvas/Formas_de_desenho": { + "modified": "2019-01-16T14:01:56.255Z", "contributors": [ - "jwhitlock", - "Anonymous" + "guerreirogabriel" ] }, - "Web/HTML/Utilizar_a_cache_de_aplicacao": { - "modified": "2020-10-15T22:13:54.682Z", + "orphaned/Tutorial_do_Canvas": { + "modified": "2019-01-16T14:32:07.975Z", "contributors": [ - "Anonymous" + "fscholz", + "Verruckt", + "RuiMaciel" ] }, - "Web/HTTP": { - "modified": "2019-05-08T19:34:36.815Z", + "orphaned/Tutorial_do_Canvas/Utilização_básica": { + "modified": "2019-03-24T00:10:34.537Z", "contributors": [ - "wellick53", - "Joao-Henrique", - "CarlosAlbertoSzygalski", - "fscholz" + "guerreirogabriel", + "Edgarlaguiar", + "Luiz Carlos Moraes", + "Jes", + "Vitor.blacks" ] }, - "Web/HTTP/CORS": { - "modified": "2020-10-15T22:15:14.685Z", + "orphaned/Tutorial_XUL/Adicionando_botões": { + "modified": "2019-03-23T23:46:29.323Z", "contributors": [ - "mfuji09" + "Verruckt", + "Leandro Mercês Xavier", + "Rodmalkav" ] }, - "Web/HTTP/CORS/Errors": { - "modified": "2019-03-18T20:48:04.840Z", + "orphaned/Tutorial_XUL/Criando_uma_janela": { + "modified": "2019-03-23T23:45:36.338Z", "contributors": [ - "nchevobbe" + "SphinxKnight", + "jigs12", + "Leandro Mercês Xavier", + "Luis Henrique Sousa", + "Verruckt", + "Rodmalkav" ] }, - "Web/HTTP/CORS/Errors/CORSDidNotSucceed": { - "modified": "2019-07-29T10:54:39.520Z", + "orphaned/Tutorial_XUL": { + "modified": "2019-03-23T23:45:36.792Z", "contributors": [ - "duduindo", - "emagombe" + "SphinxKnight", + "Leandro Mercês Xavier" ] }, - "Web/HTTP/Headers": { - "modified": "2019-03-23T22:13:14.622Z", + "orphaned/Tutorial_XUL/Introdução": { + "modified": "2019-03-23T23:46:27.723Z", "contributors": [ - "fscholz" + "SphinxKnight", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/HTTP/Headers/Allow": { - "modified": "2020-07-25T17:41:28.755Z", + "orphaned/Um_pequeno_exemplo_usando_AJAX": { + "modified": "2019-01-17T03:48:56.314Z", "contributors": [ - "joaonunomota" + "Leandro Mercês Xavier" ] }, - "Web/HTTP/Headers/X-Content-Type-Options": { - "modified": "2020-10-15T21:53:51.221Z", + "orphaned/Usando_áudio_e_vídeo_no_Firefox": { + "modified": "2019-03-24T00:00:33.796Z", "contributors": [ - "tjgfernandes" + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Web/HTTP/Proxy_servers_and_tunneling": { - "modified": "2020-06-30T09:55:24.162Z", + "orphaned/Usando_privilégios_expandidos_em_navegadores_Mozilla": { + "modified": "2019-03-23T23:48:48.468Z", "contributors": [ - "lutzleonardo15" + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Web/HTTP/Status": { - "modified": "2020-10-15T22:17:14.857Z", + "Web/API/Document_object_model/Using_the_W3C_DOM_Level_1_Core": { + "modified": "2019-12-13T21:06:18.400Z", "contributors": [ - "zhouqichao" + "wbamberg", + "Anonymous", + "ethertank", + "fferracioli" ] }, - "Web/HTTP/Status/205": { - "modified": "2019-04-07T10:34:18.946Z", + "orphaned/Utilizando_meta_tags": { + "modified": "2019-03-23T23:45:18.005Z", "contributors": [ - "preira" + "eduardoungaratto", + "AndreGazola", + "Fleury" ] }, - "Web/HTTP/Status/405": { - "modified": "2020-07-25T17:18:32.968Z", + "orphaned/Venkman": { + "modified": "2019-03-24T00:02:38.559Z", "contributors": [ - "joaonunomota" + "SphinxKnight", + "fscholz", + "Verruckt" ] }, - "Web/HTTP/Status/502": { - "modified": "2020-10-15T22:31:56.172Z", + "Web/Accessibility/ARIA/ARIA_Techniques/Using_the_status_role": { + "modified": "2020-09-19T05:54:31.819Z", "contributors": [ - "joaonunomota" + "Painatalman" ] }, - "Web/HTTP/Status/504": { - "modified": "2020-10-15T22:32:01.046Z", + "Web/Accessibility/ARIA": { + "modified": "2019-03-18T21:47:01.413Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/JavaScript": { - "modified": "2020-09-29T15:05:06.845Z", + "Web/Accessibility": { + "modified": "2019-09-09T14:20:12.758Z", "contributors": [ - "jnascimentogcc", - "Anonymous", "SphinxKnight", - "diogo-panaca", - "ruiribeiro97", + "Anonymous", "teoli", - "jaydson", - "Charleno Pires", - "leobalter", "Verruckt", - "Leandro Mercês Xavier", - "Enigma", - "RuiMaciel" + "Kayalemao", + "RuiMaciel", + "Karla pa", + "GrandeBuzina" ] }, - "Web/JavaScript/Estruturas_de_dados": { - "modified": "2020-03-12T19:47:10.844Z", + "Web/API/Storage_API": { + "modified": "2020-10-15T22:08:44.199Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Gestao_Memoria": { - "modified": "2020-03-12T19:47:35.757Z", + "Web/API/Web_Authentication_API": { + "modified": "2020-10-15T22:03:06.934Z", "contributors": [ - "FgfdCBVCbnsebtgf" + "fscholz", + "Anonymous" ] }, - "Web/JavaScript/Guia": { - "modified": "2020-03-12T19:36:11.358Z", + "conflicting/Web/API/Web_Storage_API": { + "modified": "2019-03-18T21:46:00.224Z", "contributors": [ - "Anonymous", - "teoli", - "dancasttro", - "ethertank", - "trevorh", - "italotoffolo", - "clebermatheus", - "Verruckt" + "Anonymous" ] }, - "Web/JavaScript/Guia/Detalhes_do_modelo_de_objeto": { - "modified": "2020-03-12T19:44:04.803Z", + "Web/API/Canvas_API": { + "modified": "2019-03-23T22:01:56.072Z", "contributors": [ - "wbamberg", "Anonymous" ] }, - "Web/JavaScript/Guia/Expressoes_e_Operadores": { - "modified": "2020-03-12T19:38:04.189Z", + "Web/API/Canvas_API/Tutorial": { + "modified": "2019-03-18T21:24:18.272Z", "contributors": [ - "duduindo", - "teoli", - "italotoffolo" + "Anonymous" ] }, - "Web/JavaScript/Guia/Gramática_e_tipos": { - "modified": "2020-03-12T19:44:01.097Z", + "Web/API/Battery_Status_API": { + "modified": "2019-03-18T21:29:01.750Z", "contributors": [ - "mauraodev", "Anonymous" ] }, - "Web/JavaScript/Guia/Introdução": { - "modified": "2020-03-12T19:44:03.775Z", + "Web/API/File_and_Directory_Entries_API": { + "modified": "2019-03-18T21:46:51.385Z", "contributors": [ - "jhonatansychochi", - "Redeagle48", "Anonymous" ] }, - "Web/JavaScript/Guia/Introdução_ao_JavaScript": { - "modified": "2019-03-24T00:08:50.034Z", + "Web/API/Media_Streams_API": { + "modified": "2019-03-23T22:12:44.463Z", "contributors": [ - "teoli", - "Verruckt" + "Anonymous" ] }, - "Web/JavaScript/Guia/Sobre": { - "modified": "2019-03-24T00:08:17.375Z", + "Web/API/WebRTC_API": { + "modified": "2019-03-23T22:12:46.226Z", "contributors": [ "Anonymous", - "teoli", - "dancasttro", - "Verruckt" + "Gurigraphics" ] }, - "Web/JavaScript/Guia/Valores,_Variáveis_e_Literais": { - "modified": "2019-08-21T13:40:23.925Z", + "Web/API/WebRTC_API/Taking_still_photos": { + "modified": "2019-03-23T22:12:45.154Z", "contributors": [ - "chibichibibr", - "SphinxKnight", - "teoli", - "Verruckt" + "fscholz", + "wbamberg", + "Anonymous" ] }, - "Web/JavaScript/O_que_é_o_JavaScript": { - "modified": "2019-03-23T23:53:53.371Z", + "Web/API/Document/dir": { + "modified": "2019-03-23T23:22:09.179Z", "contributors": [ - "teoli", - "Sheppy", - "RafaelMS" + "khalid32", + "carlosrainhaaraujo" ] }, - "Web/JavaScript/Reference": { - "modified": "2020-07-11T02:27:11.550Z", + "Web/API/Ambient_Light_Events": { + "modified": "2020-10-15T22:07:41.555Z", "contributors": [ - "KINGRANDOLPH", - "Anonymous", - "dd-pardal", - "LJHarb" + "Anonymous" ] }, - "Web/JavaScript/Reference/Classes": { - "modified": "2020-10-15T22:00:39.801Z", + "Web/API/Geolocation_API": { + "modified": "2020-10-15T21:59:09.308Z", "contributors": [ - "preira", - "peter.kehl" + "Anonymous" ] }, - "Web/JavaScript/Reference/Classes/static": { - "modified": "2020-10-15T22:00:38.342Z", + "Web/API/Metadata": { + "modified": "2019-03-18T21:46:51.094Z", "contributors": [ - "Painatalman" + "Anonymous" ] }, - "Web/JavaScript/Reference/Errors": { - "modified": "2020-03-12T19:47:09.947Z", + "Web/API/NavigatorOnLine/Online_and_offline_events": { + "modified": "2019-03-23T23:49:32.329Z", "contributors": [ - "Sheppy" + "SphinxKnight", + "chrisdavidmills", + "Leandro Mercês Xavier", + "Roli", + "Verruckt" ] }, - "Web/JavaScript/Reference/Errors/Not_a_function": { - "modified": "2020-07-25T16:58:44.866Z", + "Web/API/Notifications_API/Using_the_Notifications_API": { + "modified": "2019-03-23T22:42:28.564Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/JavaScript/Reference/Errors/Stmt_after_return": { - "modified": "2020-03-12T19:47:09.548Z", + "Web/API/FileSystem": { + "modified": "2020-10-15T21:46:44.138Z", "contributors": [ - "Anonymous", - "joao-neves95", - "PANC" + "joaonunomota", + "Anonymous" ] }, - "Web/JavaScript/Reference/Errors/Unexpected_token": { - "modified": "2020-03-12T19:47:17.066Z", + "Web/API/Web_Audio_API/Using_Web_Audio_API": { + "modified": "2019-03-23T22:12:48.158Z", "contributors": [ - "pedlima" + "Anonymous" ] }, - "Web/JavaScript/Reference/Errors/declaração_função_sem_nome": { - "modified": "2020-03-12T19:48:30.296Z", + "Web/API/Web_Workers_API/Using_web_workers": { + "modified": "2019-03-23T22:02:15.177Z", "contributors": [ - "hudelgado" + "allanfoppa", + "Anonymous" ] }, - "Web/JavaScript/Reference/Extratos_e_declarações": { - "modified": "2020-10-15T21:46:52.013Z", + "Web/API/WebGL_API/Constants": { + "modified": "2019-03-23T22:01:30.802Z", "contributors": [ - "Anonymous", - "LucianoDos" + "Anonymous" ] }, - "Web/JavaScript/Reference/Extratos_e_declarações/bloco": { - "modified": "2020-10-15T22:29:44.918Z", + "Web/API/WebGL_API/Data": { + "modified": "2019-03-23T22:01:33.105Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Extratos_e_declarações/for": { - "modified": "2020-10-15T22:29:45.538Z", + "Web/API/WebGL_API/Types": { + "modified": "2019-03-23T22:01:33.867Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Extratos_e_declarações/return": { - "modified": "2020-10-15T21:59:53.428Z", + "Web/API/WebGL_API/Using_Extensions": { + "modified": "2019-03-23T22:01:32.555Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Extratos_e_declarações/throw": { - "modified": "2020-10-15T21:59:14.757Z", + "Web/API/WebSockets_API/Writing_WebSocket_client_applications": { + "modified": "2020-08-11T17:49:59.287Z", "contributors": [ - "Anonymous", - "joao-neves95" + "joaonunomota" ] }, - "Web/JavaScript/Reference/Funcionalidades_obsoletas": { - "modified": "2020-03-12T19:48:08.798Z", + "Web/API/WebSockets_API/Writing_WebSocket_servers": { + "modified": "2020-09-18T06:53:14.308Z", "contributors": [ - "Anonymous" + "blunderous", + "joaonunomota" ] }, - "Web/JavaScript/Reference/Funcoes": { - "modified": "2020-10-15T21:59:57.286Z", + "Web/API/WebSockets_API/Writing_WebSocket_server": { + "modified": "2020-12-04T13:57:23.773Z", "contributors": [ - "Anonymous" + "peterbe", + "joaonunomota" ] }, - "Web/JavaScript/Reference/Funcoes/Funcoes_seta": { - "modified": "2020-10-15T22:29:39.575Z", + "Web/API/WebSockets_API/Writing_a_WebSocket_server_in_Java": { + "modified": "2020-08-24T20:03:27.920Z", "contributors": [ - "Anonymous" + "joaonunomota" ] }, - "Web/JavaScript/Reference/Funcoes/arguments": { - "modified": "2020-10-15T22:13:56.842Z", + "Web/API/Window/sidebar": { + "modified": "2019-03-18T21:37:22.693Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Funcoes/parametros_rest": { - "modified": "2020-10-15T22:29:46.349Z", + "Web/Web_Components": { + "modified": "2019-08-20T17:28:31.563Z", "contributors": [ + "filipe095", "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects": { - "modified": "2020-03-12T19:39:49.774Z", + "Web/CSS/::after": { + "modified": "2019-03-24T00:00:16.761Z", "contributors": [ - "Anonymous", - "Redeagle48", - "SphinxKnight", - "fscholz" + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "Web/JavaScript/Reference/Global_Objects/Array": { - "modified": "2020-10-15T21:54:01.173Z", + "Web/CSS/::before": { + "modified": "2019-03-24T00:00:19.264Z", "contributors": [ - "joaonunomota", - "claudepache" + "teoli", + "Verruckt", + "Luis Henrique Sousa" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/concat": { - "modified": "2019-03-23T22:13:06.712Z", + "Learn/CSS/Howto/Generated_content": { + "modified": "2020-07-16T22:25:48.413Z", "contributors": [ - "ricardomartins" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/find": { - "modified": "2020-10-15T22:02:06.522Z", + "Web/SVG/Tutorial/SVG_and_CSS": { + "modified": "2019-03-24T00:00:34.584Z", "contributors": [ - "JMoreira93" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" + ] + }, + "Web/Progressive_web_apps/Responsive/Media_types": { + "modified": "2019-03-24T00:15:51.724Z", + "contributors": [ + "Anonymous", + "fscholz", + "teoli", + "maggots", + "Verruckt", + "Leandro Mercês Xavier" + ] + }, + "orphaned/Web/CSS/Como_começar/O_que_é_CSS?": { + "modified": "2019-03-23T23:43:00.605Z", + "contributors": [ + "teoli", + "Leandro Mercês Xavier" + ] + }, + "Web/CSS/Media_Queries/Using_media_queries": { + "modified": "2019-04-09T16:57:57.913Z", + "contributors": [ + "diogo-panaca", + "Anonymous", + "Sebastianz", + "mrstork", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/forEach": { - "modified": "2020-10-15T22:13:53.352Z", + "Web/CSS/Media_Queries": { + "modified": "2020-10-15T22:17:12.623Z", "contributors": [ - "ricardomartins" + "diogo-panaca" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/includes": { - "modified": "2020-10-15T22:04:42.050Z", + "Web/CSS/CSS_Box_Model/Introduction_to_the_CSS_box_model": { + "modified": "2019-03-23T22:12:42.813Z", "contributors": [ - "SandroMiguel" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/join": { - "modified": "2020-10-15T21:54:14.959Z", + "Web/CSS/CSS_Colors/Color_picker_tool": { + "modified": "2019-04-28T14:53:13.655Z", "contributors": [ - "joaonunomota", - "ricardomartins" + "diogo-panaca" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/map": { - "modified": "2020-10-15T22:33:11.742Z", + "Web/CSS/CSS_Flexible_Box_Layout/Aligning_Items_in_a_Flex_Container": { + "modified": "2019-06-11T07:33:08.010Z", "contributors": [ - "joaonunomota" + "BIGBenfica9", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/pop": { - "modified": "2020-10-15T21:58:52.123Z", + "Web/CSS/CSS_Flexible_Box_Layout/Typical_Use_Cases_of_Flexbox": { + "modified": "2019-03-18T21:43:55.771Z", "contributors": [ - "kapz" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/reverse": { - "modified": "2019-03-23T22:12:30.952Z", + "Web/CSS/CSS_Flexible_Box_Layout/Ordering_Flex_Items": { + "modified": "2019-07-22T03:58:30.968Z", "contributors": [ - "ricardomartins" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Array/slice": { - "modified": "2020-10-15T22:31:52.359Z", + "Web/CSS/CSS_Flexible_Box_Layout/Relationship_of_Flexbox_to_Other_Layout_Methods": { + "modified": "2019-03-18T21:43:58.441Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/ArrayBuffer": { - "modified": "2019-03-23T22:16:35.915Z", + "Web/CSS/CSS_Types": { + "modified": "2019-03-18T21:23:17.150Z", "contributors": [ - "anguelov" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/AsyncFunction": { - "modified": "2020-10-15T22:14:28.403Z", + "Web/CSS/Alternative_style_sheets": { + "modified": "2019-03-23T23:53:49.046Z", "contributors": [ - "ramongr" + "teoli", + "FelipeMorais" ] }, - "Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype": { - "modified": "2020-10-15T22:14:24.948Z", + "Web/CSS/CSS_Grid_Layout": { + "modified": "2020-04-12T22:44:10.924Z", "contributors": [ - "ramongr" + "carlosaffrc", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Boolean": { - "modified": "2020-10-15T21:59:47.399Z", + "Web/CSS/Paged_Media": { + "modified": "2019-03-23T22:24:57.103Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Function": { - "modified": "2019-03-23T22:14:25.079Z", + "Web/CSS/Pseudo-classes": { + "modified": "2019-03-18T21:15:25.227Z", "contributors": [ - "nmve" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Function/arguments": { - "modified": "2020-10-15T22:14:27.893Z", + "Web/CSS/Pseudo-elements": { + "modified": "2019-03-18T21:23:11.174Z", "contributors": [ - "ramongr" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Function/call": { - "modified": "2020-10-15T21:53:17.055Z", + "Web/CSS/Reference": { + "modified": "2020-07-20T13:36:56.218Z", "contributors": [ "joaonunomota", - "JuniorDiasOliveira", - "waveiro", - "Mega85" - ] - }, - "Web/JavaScript/Reference/Global_Objects/Infinity": { - "modified": "2020-10-15T22:31:55.049Z", - "contributors": [ - "joaonunomota" + "Anonymous", + "teoli", + "Moacir Bispo", + "Verruckt" ] }, - "Web/JavaScript/Reference/Global_Objects/Math": { - "modified": "2019-03-23T22:12:29.962Z", + "Web/CSS/CSS_Transforms/Using_CSS_transforms": { + "modified": "2019-03-24T00:04:50.895Z", "contributors": [ - "ricardomartins" + "teoli", + "Verruckt", + "Leandro Mercês Xavier", + "Jürgen Jeka" ] }, - "Web/JavaScript/Reference/Global_Objects/Math/ceil": { - "modified": "2020-10-15T21:58:11.563Z", + "Web/Events": { + "modified": "2019-04-30T14:29:45.980Z", "contributors": [ - "carlos-menezes", - "MarcioFonseca" + "wbamberg", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number": { - "modified": "2019-03-23T22:49:01.559Z", + "Web/Guide/AJAX/Getting_Started": { + "modified": "2019-03-23T23:58:34.669Z", "contributors": [ - "Redeagle48", - "fscholz" + "Anonymous", + "chrisdavidmills", + "flaviomicheletti", + "Leandro Mercês Xavier", + "Fmtakaki", + "Verruckt", + "TroyDF", + "Japa al", + "Mederafael", + "Juliandavi", + "Thomaskp", + "Caed", + "Takenbot", + "Filipesperandio", + "Pmdweb", + "RuiMaciel" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE": { - "modified": "2019-03-23T22:49:07.538Z", + "Web/Guide/AJAX/Community": { + "modified": "2019-03-18T21:47:01.551Z", "contributors": [ - "Redeagle48" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE": { - "modified": "2019-03-23T22:49:09.973Z", + "Web/Guide/Events": { + "modified": "2019-03-23T22:01:48.833Z", "contributors": [ - "Redeagle48" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY": { - "modified": "2020-10-15T21:38:19.186Z", + "Web/Guide/Graphics": { + "modified": "2019-03-18T21:46:51.581Z", "contributors": [ - "joaonunomota", - "Redeagle48" + "ivolvicente", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/NaN": { - "modified": "2019-03-23T22:49:09.414Z", + "Web/Guide/HTML/Content_categories": { + "modified": "2019-03-18T21:30:45.160Z", "contributors": [ - "Redeagle48" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/isFinite": { - "modified": "2019-03-23T22:49:12.149Z", + "Web/Guide/HTML/Using_HTML_sections_and_outlines": { + "modified": "2019-03-18T21:46:45.859Z", "contributors": [ - "SphinxKnight", - "Redeagle48" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/isInteger": { - "modified": "2019-03-23T22:49:17.052Z", + "Web/HTML/Applying_color": { + "modified": "2019-03-23T22:01:35.840Z", "contributors": [ - "SphinxKnight", - "Redeagle48" + "jwhitlock", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/isNaN": { - "modified": "2019-03-23T22:49:10.417Z", + "Web/HTML/Global_attributes": { + "modified": "2019-03-23T22:02:25.995Z", "contributors": [ - "SphinxKnight", - "Redeagle48" + "Anonymous", + "jwhitlock" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/prototype": { - "modified": "2019-03-23T22:49:04.241Z", + "Web/HTML/Attributes": { + "modified": "2019-03-23T22:12:57.935Z", "contributors": [ - "Redeagle48" + "jwhitlock", + "Anonymous", + "ricardomartins" ] }, - "Web/JavaScript/Reference/Global_Objects/Number/toString": { - "modified": "2019-03-23T22:49:00.338Z", + "Web/HTML/Attributes/rel": { + "modified": "2020-10-15T22:34:32.449Z", "contributors": [ - "Redeagle48" + "Painatalman" ] }, - "Web/JavaScript/Reference/Global_Objects/Object": { - "modified": "2020-10-15T21:30:54.647Z", + "Web/HTML/Attributes/crossorigin": { + "modified": "2020-10-15T22:18:00.790Z", "contributors": [ - "Anonymous", - "wbamberg", - "fscholz" + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty": { - "modified": "2019-03-23T22:42:57.159Z", + "Web/HTML/Element/audio": { + "modified": "2019-03-24T00:00:34.265Z", "contributors": [ - "gabrielpconceicao" + "jwhitlock", + "teoli", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/Object/prototype": { - "modified": "2020-10-15T22:13:51.986Z", + "Web/HTML/Element/fieldset": { + "modified": "2020-10-15T22:23:45.358Z", "contributors": [ "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/String": { - "modified": "2020-10-15T21:38:27.657Z", + "Web/HTML/Element/figcaption": { + "modified": "2019-03-24T00:12:29.922Z", "contributors": [ - "erickbRodrigues", - "Anonymous", - "ricardomartins", - "lpimenta-ptc", - "Sheppy" + "wbamberg", + "jwhitlock", + "teoli", + "f.sanxz" ] }, - "Web/JavaScript/Reference/Global_Objects/String/Trim": { - "modified": "2019-03-23T22:13:05.964Z", + "Web/HTML/Element/head": { + "modified": "2020-10-15T21:59:43.855Z", "contributors": [ - "ricardomartins" + "jwhitlock", + "Anonymous" ] }, - "Web/JavaScript/Reference/Global_Objects/String/indexOf": { - "modified": "2019-03-23T22:49:09.792Z", + "Web/HTML/Element": { + "modified": "2020-11-30T19:06:39.688Z", "contributors": [ - "SandroMiguel", - "Redeagle48" + "jotafe32", + "joaonunomota", + "MacedoAna", + "Anonymous", + "jwhitlock", + "teoli", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/String/length": { - "modified": "2019-03-23T22:49:00.693Z", + "Web/HTML/Element/nav": { + "modified": "2020-10-15T21:57:44.552Z", "contributors": [ - "Redeagle48" + "jwhitlock", + "JoseRicardoGomes" ] }, - "Web/JavaScript/Reference/Global_Objects/Symbol": { - "modified": "2019-03-23T22:24:48.766Z", + "Web/HTML/Element/progress": { + "modified": "2019-03-24T00:11:12.291Z", "contributors": [ - "ZeikJT" + "wbamberg", + "jwhitlock", + "teoli", + "gustavowiller", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance": { - "modified": "2019-03-23T22:24:53.893Z", + "Web/HTML/Element/video": { + "modified": "2019-03-24T00:00:37.866Z", "contributors": [ - "GoToLoop" + "jwhitlock", + "teoli", + "Leandro Mercês Xavier" ] }, - "Web/JavaScript/Reference/Global_Objects/encodeURI": { - "modified": "2020-03-12T19:42:17.895Z", + "orphaned/Learn/HTML/Forms/HTML5_updates": { + "modified": "2019-03-24T00:05:42.238Z", "contributors": [ - "kempcarlos" + "juliano_aguiar", + "teoli", + "Verruckt" ] }, - "Web/JavaScript/Reference/Operadores": { - "modified": "2020-10-15T21:46:57.076Z", + "Web/Guide/HTML/HTML5": { + "modified": "2019-03-24T00:15:44.005Z", "contributors": [ - "Anonymous" + "InesFF", + "Anonymous", + "teoli", + "emilianocarvalho", + "vigia122", + "Dwchiang", + "Verruckt" ] }, - "Web/JavaScript/Reference/Operadores/Operador_virgula": { - "modified": "2020-10-15T22:29:46.734Z", + "Web/Guide/HTML/HTML5/Introduction_to_HTML5": { + "modified": "2019-03-24T00:13:41.465Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "teoli", + "mauricio.araldi", + "xaky", + "Verruckt" ] }, - "Web/JavaScript/Reference/Operadores/Precedencia_operador": { - "modified": "2020-05-03T13:58:58.457Z", + "Web/Guide/HTML/HTML5/HTML5_Parser": { + "modified": "2019-03-24T00:07:33.282Z", "contributors": [ - "Anonymous" + "teoli", + "Verruckt" ] }, - "Web/JavaScript/Reference/Operadores/função": { - "modified": "2020-10-15T22:29:38.999Z", + "Web/HTML/Reference": { + "modified": "2019-09-09T07:20:05.681Z", "contributors": [ + "SphinxKnight", + "wbamberg", + "jwhitlock", "Anonymous" ] }, - "Web/JavaScript/Reference/Sobre": { - "modified": "2020-03-12T19:44:03.544Z", + "Web/HTML/Link_types": { + "modified": "2019-03-23T22:02:19.809Z", "contributors": [ + "jwhitlock", "Anonymous" ] }, - "Web/Manifest": { - "modified": "2020-10-15T22:23:27.262Z", + "Web/HTML/Using_the_application_cache": { + "modified": "2020-10-15T22:13:54.682Z", "contributors": [ - "nersofiripi", "Anonymous" ] }, - "Web/MathML": { - "modified": "2020-11-09T15:01:38.012Z", + "Web/JavaScript/Data_structures": { + "modified": "2020-03-12T19:47:10.844Z", "contributors": [ - "joaonunomota", - "Joao_Ledo_Fonseca", "Anonymous" ] }, - "Web/MathML/Attribute": { - "modified": "2020-08-21T12:44:51.026Z", - "contributors": [ - "joaonunomota", - "fscholz" - ] - }, - "Web/MathML/Attribute/Valores": { - "modified": "2020-07-22T19:30:01.211Z", - "contributors": [ - "joaonunomota" - ] - }, - "Web/MathML/Authoring": { - "modified": "2020-08-15T14:39:49.860Z", + "Web/JavaScript/Memory_Management": { + "modified": "2020-03-12T19:47:35.757Z", "contributors": [ - "joaonunomota" + "FgfdCBVCbnsebtgf" ] }, - "Web/MathML/Element": { - "modified": "2020-08-16T17:33:47.904Z", + "Web/JavaScript/Guide/Details_of_the_Object_Model": { + "modified": "2020-03-12T19:44:04.803Z", "contributors": [ - "joaonunomota", - "fscholz" + "wbamberg", + "Anonymous" ] }, - "Web/MathML/Element/maction": { - "modified": "2020-10-15T22:32:30.845Z", + "orphaned/Web/JavaScript/Guia/Expressoes_e_Operadores": { + "modified": "2020-03-12T19:38:04.189Z", "contributors": [ - "joaonunomota" + "duduindo", + "teoli", + "italotoffolo" ] }, - "Web/MathML/Element/math": { - "modified": "2020-10-15T22:32:00.988Z", + "Web/JavaScript/Guide/Grammar_and_types": { + "modified": "2020-03-12T19:44:01.097Z", "contributors": [ - "joaonunomota" + "mauraodev", + "Anonymous" ] }, - "Web/MathML/Element/menclose": { - "modified": "2020-10-15T22:31:58.519Z", + "Web/JavaScript/Guide": { + "modified": "2020-03-12T19:36:11.358Z", "contributors": [ - "joaonunomota" + "Anonymous", + "teoli", + "dancasttro", + "ethertank", + "trevorh", + "italotoffolo", + "clebermatheus", + "Verruckt" ] }, - "Web/MathML/Element/merror": { - "modified": "2020-10-15T22:31:57.892Z", + "orphaned/Web/JavaScript/Guia/Introdução_ao_JavaScript": { + "modified": "2019-03-24T00:08:50.034Z", "contributors": [ - "joaonunomota" + "teoli", + "Verruckt" ] }, - "Web/MathML/Element/mfenced": { - "modified": "2020-10-15T22:32:16.693Z", + "Web/JavaScript/Guide/Introduction": { + "modified": "2020-03-12T19:44:03.775Z", "contributors": [ - "joaonunomota" + "jhonatansychochi", + "Redeagle48", + "Anonymous" ] }, - "Web/MathML/Element/mfrac": { - "modified": "2020-10-15T22:32:37.302Z", + "orphaned/Web/JavaScript/Guia/Sobre": { + "modified": "2019-03-24T00:08:17.375Z", "contributors": [ - "joaonunomota" + "Anonymous", + "teoli", + "dancasttro", + "Verruckt" ] }, - "Web/MathML/Element/mglyph": { - "modified": "2020-10-15T22:32:17.025Z", + "orphaned/Web/JavaScript/Guia/Valores,_Variáveis_e_Literais": { + "modified": "2019-08-21T13:40:23.925Z", "contributors": [ - "joaonunomota" + "chibichibibr", + "SphinxKnight", + "teoli", + "Verruckt" ] }, - "Web/MathML/Element/mi": { - "modified": "2020-10-15T22:32:20.399Z", + "orphaned/Web/JavaScript/O_que_é_o_JavaScript": { + "modified": "2019-03-23T23:53:53.371Z", "contributors": [ - "joaonunomota" + "teoli", + "Sheppy", + "RafaelMS" ] }, - "Web/MathML/Element/mlabeledtr": { - "modified": "2020-10-15T22:32:27.553Z", + "Web/JavaScript/Reference/Errors/Unnamed_function_statement": { + "modified": "2020-03-12T19:48:30.296Z", "contributors": [ - "joaonunomota" + "hudelgado" ] }, - "Web/MathML/Element/mmultiscripts": { - "modified": "2020-10-15T22:32:37.118Z", + "Web/JavaScript/Reference/Statements/block": { + "modified": "2020-10-15T22:29:44.918Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mn": { - "modified": "2020-10-15T22:32:26.157Z", + "Web/JavaScript/Reference/Statements/for": { + "modified": "2020-10-15T22:29:45.538Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mo": { - "modified": "2020-10-15T22:32:19.754Z", + "Web/JavaScript/Reference/Statements": { + "modified": "2020-10-15T21:46:52.013Z", "contributors": [ - "joaonunomota" + "Anonymous", + "LucianoDos" ] }, - "Web/MathML/Element/mover": { - "modified": "2020-10-15T22:32:19.618Z", + "Web/JavaScript/Reference/Statements/return": { + "modified": "2020-10-15T21:59:53.428Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mpadded": { - "modified": "2020-10-15T22:32:28.264Z", + "Web/JavaScript/Reference/Statements/throw": { + "modified": "2020-10-15T21:59:14.757Z", "contributors": [ - "joaonunomota" + "Anonymous", + "joao-neves95" ] }, - "Web/MathML/Element/mphantom": { - "modified": "2020-10-15T22:32:22.218Z", + "Web/JavaScript/Reference/Deprecated_and_obsolete_features": { + "modified": "2020-03-12T19:48:08.798Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mroot": { - "modified": "2020-10-15T22:32:22.430Z", + "Web/JavaScript/Reference/Functions/arguments": { + "modified": "2020-10-15T22:13:56.842Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mrow": { - "modified": "2020-10-15T22:31:58.300Z", + "Web/JavaScript/Reference/Functions/Arrow_functions": { + "modified": "2020-10-15T22:29:39.575Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/ms": { - "modified": "2020-10-15T22:32:22.427Z", + "Web/JavaScript/Reference/Functions": { + "modified": "2020-10-15T21:59:57.286Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mspace": { - "modified": "2020-10-15T22:31:55.582Z", + "Web/JavaScript/Reference/Functions/rest_parameters": { + "modified": "2020-10-15T22:29:46.349Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/msqrt": { - "modified": "2020-10-15T22:32:22.151Z", + "orphaned/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype": { + "modified": "2020-10-15T22:14:24.948Z", "contributors": [ - "joaonunomota" + "ramongr" ] }, - "Web/MathML/Element/mstyle": { - "modified": "2020-10-15T22:33:04.564Z", + "Web/JavaScript/Reference/Operators/function": { + "modified": "2020-10-15T22:29:38.999Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/msub": { - "modified": "2020-10-15T22:32:21.086Z", + "Web/JavaScript/Reference/Operators": { + "modified": "2020-10-15T21:46:57.076Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/msubsup": { - "modified": "2020-10-15T22:32:22.170Z", + "Web/JavaScript/Reference/Operators/Comma_Operator": { + "modified": "2020-10-15T22:29:46.734Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/msup": { - "modified": "2020-10-15T22:32:20.360Z", + "Web/JavaScript/Reference/Operators/Operator_Precedence": { + "modified": "2020-05-03T13:58:58.457Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mtable": { - "modified": "2020-10-15T22:33:04.410Z", + "Web/JavaScript/Reference/About": { + "modified": "2020-03-12T19:44:03.544Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/mtd": { - "modified": "2020-10-15T22:32:00.353Z", + "Web/MathML/Attribute/Values": { + "modified": "2020-07-22T19:30:01.211Z", "contributors": [ "joaonunomota" ] }, - "Web/MathML/Element/mtext": { - "modified": "2020-10-15T22:31:59.109Z", + "Web/MathML/Examples/Deriving_the_Quadratic_Formula": { + "modified": "2020-08-16T17:37:40.689Z", "contributors": [ "joaonunomota" ] }, - "Web/MathML/Element/mtr": { - "modified": "2020-10-15T22:31:55.409Z", + "Web/MathML/Examples/MathML_Pythagorean_Theorem": { + "modified": "2020-08-16T17:39:52.993Z", "contributors": [ "joaonunomota" ] }, - "Web/MathML/Element/munder": { - "modified": "2020-10-15T22:32:18.823Z", + "Web/Progressive_web_apps/Developer_guide": { + "modified": "2020-04-23T09:38:24.576Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Element/munderover": { - "modified": "2020-10-15T22:32:21.240Z", + "Web/Progressive_web_apps/Responsive/responsive_design_building_blocks": { + "modified": "2019-04-16T06:29:21.711Z", "contributors": [ - "joaonunomota" + "diogo-panaca" ] }, - "Web/MathML/Element/semantics": { - "modified": "2020-10-15T22:32:26.955Z", + "Web/Security/Mixed_content": { + "modified": "2019-03-23T22:05:48.971Z", "contributors": [ - "joaonunomota" + "Anonymous", + "sideshowbarker" ] }, - "Web/MathML/Examples": { - "modified": "2020-08-18T09:59:11.744Z", + "Web/Security/Mixed_content/How_to_fix_website_with_mixed_content": { + "modified": "2019-03-23T22:05:54.761Z", "contributors": [ - "joaonunomota" + "Anonymous" ] }, - "Web/MathML/Examples/Derivar_a_Formula_Resolvente": { - "modified": "2020-08-16T17:37:40.689Z", + "Web/Security": { + "modified": "2019-09-10T16:45:22.612Z", "contributors": [ - "joaonunomota" + "SphinxKnight", + "Anonymous" ] }, - "Web/MathML/Examples/MathML_teorema_de_Pitagoras": { - "modified": "2020-08-16T17:39:52.993Z", + "Web/Security/Insecure_passwords": { + "modified": "2019-03-23T22:01:41.675Z", "contributors": [ - "joaonunomota" + "rborges77", + "Anonymous" ] }, - "Web/MathML/Index": { - "modified": "2020-08-16T17:30:38.516Z", + "Web/Security/Same-origin_policy": { + "modified": "2020-09-26T17:57:02.589Z", "contributors": [ - "joaonunomota" + "Samuel-Ferdnand" ] }, - "Web/Progressive_web_apps": { - "modified": "2020-04-23T09:44:00.269Z", + "Web/SVG/Applying_SVG_effects_to_HTML_content": { + "modified": "2019-03-23T22:01:45.461Z", "contributors": [ - "Anonymous", - "chrisdavidmills" + "Anonymous" ] }, - "Web/Progressive_web_apps/Guia_de_programacao": { - "modified": "2020-04-23T09:38:24.576Z", + "Web/SVG/Namespaces_Crash_Course/Example": { + "modified": "2019-03-23T22:01:57.842Z", "contributors": [ "Anonymous" ] }, - "Web/Progressive_web_apps/Identificavel": { - "modified": "2019-03-18T20:52:07.669Z", + "Web/SVG/SVG_animation_with_SMIL": { + "modified": "2020-04-23T08:20:39.391Z", "contributors": [ - "chrisdavidmills", "Anonymous" ] }, - "Web/Progressive_web_apps/Responsivo": { - "modified": "2019-03-18T20:52:08.064Z", + "Web/SVG/Tutorial/Introduction": { + "modified": "2020-04-23T09:22:08.765Z", "contributors": [ - "chrisdavidmills", "Anonymous" ] }, - "Web/Progressive_web_apps/Responsivo/Elementos_base_desenho_adaptavel": { - "modified": "2019-04-16T06:29:21.711Z", + "Web/SVG/Tutorial/SVG_In_HTML_Introduction": { + "modified": "2019-03-23T22:01:48.509Z", "contributors": [ - "diogo-panaca" + "Anonymous" ] }, - "Web/Progressive_web_apps/Seguro": { - "modified": "2019-03-18T20:52:08.238Z", + "Web/Tutorials": { + "modified": "2020-05-03T14:51:14.988Z", "contributors": [ - "chrisdavidmills", "Anonymous" ] }, - "Web/Reference": { - "modified": "2020-07-20T13:13:52.229Z", + "Web/XML/XML_introduction": { + "modified": "2019-05-01T21:54:16.756Z", "contributors": [ - "joaonunomota", - "Anonymous", - "carlosrainhaaraujo", - "kscarfone" + "ExE-Boss", + "Anonymous" ] }, - "Web/Reference/API": { - "modified": "2019-03-23T23:22:11.761Z", + "orphaned/Web/XSLT/Comunidade": { + "modified": "2019-01-16T16:00:25.874Z", "contributors": [ - "Anonymous", - "carlosrainhaaraujo" + "ExE-Boss", + "Leandro Mercês Xavier" ] }, - "Web/SVG": { - "modified": "2020-04-23T09:30:08.420Z", + "orphaned/Web/XSLT/Elementos": { + "modified": "2019-03-23T23:45:26.056Z", "contributors": [ - "Anonymous", - "teoli", - "guerreirogabriel", - "fscholz", - "Verruckt", - "RuiMaciel" + "ExE-Boss", + "Verruckt" ] }, - "Web/SVG/Aplicar_efeitos_SVG_conteudo_HTML": { - "modified": "2019-03-23T22:01:45.461Z", + "WebAssembly/Using_the_JavaScript_API": { + "modified": "2019-03-18T21:28:49.091Z", "contributors": [ "Anonymous" ] }, - "Web/SVG/Element": { - "modified": "2020-04-23T09:28:28.562Z", + "orphaned/XForms_especiais_para_Mozilla": { + "modified": "2019-03-23T23:56:39.810Z", "contributors": [ - "Anonymous", - "ricardomartins" + "Verruckt", + "Kayalemao" ] }, - "Web/SVG/Namespaces_Crash_Course": { - "modified": "2019-03-23T22:01:50.555Z", + "orphaned/XForms/Controles_Customizados": { + "modified": "2019-01-16T16:02:25.038Z", "contributors": [ - "Anonymous", - "somascope" + "Kayalemao", + "Leandro Mercês Xavier", + "Verruckt" ] }, - "Web/SVG/Namespaces_Crash_Course/Exemplo": { - "modified": "2019-03-23T22:01:57.842Z", + "orphaned/XForms": { + "modified": "2019-03-23T23:46:37.205Z", "contributors": [ - "Anonymous" + "Luis Henrique Sousa" ] }, - "Web/SVG/SVG_animacao_com_SMIL": { - "modified": "2020-04-23T08:20:39.391Z", + "Glossary/XHTML": { + "modified": "2019-03-23T23:40:29.099Z", "contributors": [ - "Anonymous" + "Anonymous", + "RuiMaciel" ] }, - "Web/SVG/Tutorial": { - "modified": "2019-01-16T14:01:46.161Z", + "orphaned/XML_no_Mozilla": { + "modified": "2019-11-21T20:42:12.364Z", "contributors": [ - "Anonymous", - "teoli", - "guerreirogabriel" + "wbamberg", + "Verruckt", + "Victorino" ] }, - "Web/SVG/Tutorial/Introducao": { - "modified": "2020-04-23T09:22:08.765Z", + "conflicting/Web/API/XMLHttpRequest": { + "modified": "2019-03-23T23:50:48.749Z", "contributors": [ - "Anonymous" + "SphinxKnight", + "Leandro Mercês Xavier", + "RuiMaciel" ] }, - "Web/SVG/Tutorial/SVG_na_Introducao_HTML": { - "modified": "2019-03-23T22:01:48.509Z", + "orphaned/XPath/Eixos": { + "modified": "2019-01-16T16:02:01.247Z", "contributors": [ - "Anonymous" + "Verruckt" ] }, - "Web/Security/Conteudo_misto": { - "modified": "2019-03-23T22:05:48.971Z", + "orphaned/XPath/Funções": { + "modified": "2019-01-16T16:07:00.758Z", "contributors": [ - "Anonymous", - "sideshowbarker" + "Verruckt" ] }, - "Web/Security/Mixed_content/Como_corrigir_um_site_da_Web_com_conteudo_misto_bloqueado": { - "modified": "2019-03-23T22:05:54.761Z", + "Learn/CSS/Building_blocks": { + "modified": "2019-03-24T00:00:34.956Z", "contributors": [ - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/Security/Secure_Contexts": { - "modified": "2019-03-23T22:01:19.367Z", + "Learn/CSS/Building_blocks/Cascade_and_inheritance": { + "modified": "2019-03-24T00:00:35.429Z", "contributors": [ - "Anonymous", - "Sheppy" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/Seguranca": { - "modified": "2019-09-10T16:45:22.612Z", + "Learn/CSS/First_steps/How_CSS_works": { + "modified": "2019-03-24T00:00:37.691Z", "contributors": [ - "SphinxKnight", - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/Seguranca/Palavras-passe_inseguras": { - "modified": "2019-03-23T22:01:41.675Z", + "Learn/CSS/Building_blocks/Values_and_units": { + "modified": "2019-03-24T00:00:35.276Z", "contributors": [ - "rborges77", - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/Seguranca/Same-origin_policy": { - "modified": "2020-09-26T17:57:02.589Z", + "Learn/CSS/First_steps/How_CSS_is_structured": { + "modified": "2019-03-24T00:00:36.923Z", "contributors": [ - "Samuel-Ferdnand" + "fscholz", + "teoli", + "Verruckt", + "Luis Henrique Sousa", + "Leandro Mercês Xavier" ] }, - "Web/Tutoriais": { - "modified": "2020-05-03T14:51:14.988Z", + "Learn/CSS/CSS_layout": { + "modified": "2019-03-24T00:00:37.327Z", "contributors": [ - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/WebAPI": { - "modified": "2019-03-23T22:01:53.174Z", + "Learn/CSS/Styling_text/Fundamentals": { + "modified": "2019-03-24T00:00:39.580Z", "contributors": [ - "Anonymous", - "wbamberg", - "fscholz" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier", + "Luis Henrique Sousa" ] }, - "Web/XML": { - "modified": "2020-04-23T08:26:21.649Z", + "Learn/CSS/First_steps": { + "modified": "2019-03-23T23:44:54.310Z", "contributors": [ "Anonymous", - "ExE-Boss" + "teoli", + "Leandro Mercês Xavier", + "Verruckt", + "Pilinio", + "Luisvulcanis" ] }, - "Web/XML/Introducao_a_XML": { - "modified": "2019-05-01T21:54:16.756Z", + "Learn/JavaScript/Client-side_web_APIs/Manipulating_documents": { + "modified": "2019-03-24T00:00:40.211Z", "contributors": [ - "ExE-Boss", - "Anonymous" + "fscholz", + "teoli", + "ethertank", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "Web/XSLT": { - "modified": "2019-03-24T00:03:57.070Z", + "Learn/CSS/Styling_text/Styling_lists": { + "modified": "2019-03-24T00:00:36.171Z", "contributors": [ - "ExE-Boss", - "Anonymous", "fscholz", + "teoli", "Verruckt", - "RuiMaciel" + "Luis Henrique Sousa", + "Leandro Mercês Xavier" ] }, - "Web/XSLT/Comunidade": { - "modified": "2019-01-16T16:00:25.874Z", + "conflicting/Learn/CSS/First_steps/How_CSS_works": { + "modified": "2019-03-24T00:00:33.943Z", "contributors": [ - "ExE-Boss", - "Leandro Mercês Xavier" + "Sebastianz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier", + "Pilinio" ] }, - "Web/XSLT/Elementos": { - "modified": "2019-03-23T23:45:26.056Z", + "conflicting/Learn/CSS/First_steps/How_CSS_works_0767812f50daab83155d62da97c6e460": { + "modified": "2019-03-24T00:00:39.116Z", "contributors": [ - "ExE-Boss", - "Verruckt" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier", + "Pilinio" ] }, - "WebAssembly": { - "modified": "2020-10-15T22:07:45.071Z", + "Learn/CSS/Building_blocks/Selectors": { + "modified": "2019-03-24T00:00:36.764Z", "contributors": [ - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "WebAssembly/Utilizar_API_JavaScript_WebAssembly": { - "modified": "2019-03-18T21:28:49.091Z", + "Learn/CSS/Building_blocks/Styling_tables": { + "modified": "2019-03-24T00:00:35.865Z", "contributors": [ - "Anonymous" + "fscholz", + "teoli", + "Verruckt", + "Leandro Mercês Xavier" ] }, - "XForms": { - "modified": "2019-03-23T23:46:37.205Z", + "Web/CSS/CSS_Backgrounds_and_Borders": { + "modified": "2019-03-23T22:44:16.974Z", "contributors": [ - "Luis Henrique Sousa" + "teoli" ] }, - "XForms/Controles_Customizados": { - "modified": "2019-01-16T16:02:25.038Z", + "Web/CSS/CSS_Backgrounds_and_Borders/Using_multiple_backgrounds": { + "modified": "2019-03-24T00:04:47.389Z", "contributors": [ - "Kayalemao", - "Leandro Mercês Xavier", + "Anonymous", + "teoli", "Verruckt" ] }, - "XForms_especiais_para_Mozilla": { - "modified": "2019-03-23T23:56:39.810Z", + "Web/CSS/gap": { + "modified": "2020-10-15T22:00:32.351Z", "contributors": [ - "Verruckt", - "Kayalemao" + "Anonymous" ] }, - "XHTML": { - "modified": "2019-03-23T23:40:29.099Z", + "conflicting/Web/JavaScript/Reference/Global_Objects/Number": { + "modified": "2019-03-23T22:49:04.241Z", "contributors": [ - "Anonymous", - "RuiMaciel" + "Redeagle48" ] }, - "XMLHttpRequest": { - "modified": "2019-03-23T23:50:48.749Z", + "conflicting/Web/JavaScript/Reference/Global_Objects/Object": { + "modified": "2020-10-15T22:13:51.986Z", "contributors": [ - "SphinxKnight", - "Leandro Mercês Xavier", - "RuiMaciel" + "Anonymous" ] }, - "XML_no_Mozilla": { - "modified": "2019-11-21T20:42:12.364Z", + "conflicting/Web/Progressive_web_apps": { + "modified": "2019-03-18T20:52:07.669Z", "contributors": [ - "wbamberg", - "Verruckt", - "Victorino" + "chrisdavidmills", + "Anonymous" ] }, - "XPath/Eixos": { - "modified": "2019-01-16T16:02:01.247Z", + "conflicting/Web/Progressive_web_apps/Responsive/responsive_design_building_blocks": { + "modified": "2019-03-18T20:52:08.064Z", "contributors": [ - "Verruckt" + "chrisdavidmills", + "Anonymous" ] }, - "XPath/Funções": { - "modified": "2019-01-16T16:07:00.758Z", + "conflicting/Web/Progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a": { + "modified": "2019-03-18T20:52:08.238Z", "contributors": [ - "Verruckt" + "chrisdavidmills", + "Anonymous" + ] + }, + "conflicting/Web/API": { + "modified": "2019-03-23T22:01:53.174Z", + "contributors": [ + "Anonymous", + "wbamberg", + "fscholz" ] } } \ No newline at end of file diff --git a/files/pt-pt/conflicting/glossary/api/index.html b/files/pt-pt/conflicting/glossary/api/index.html index cc99d2c980..cac9a8e45d 100644 --- a/files/pt-pt/conflicting/glossary/api/index.html +++ b/files/pt-pt/conflicting/glossary/api/index.html @@ -1,11 +1,12 @@ --- title: IPA -slug: Glossário/API +slug: conflicting/Glossary/API tags: - Glossário - IPA - Infraestrutura translation_of: Glossary/API +original_slug: Glossário/API ---

Uma IPA (Interface de Programação de Aplicação ou em inglês API) é um conjunto de funcionalidades e regras que existem dentro dum logiciário (a aplicação) que habilitam a interação entre o logiciário - em oposição a uma interface de utilizador humana. A IPA pode ser vista como um simples contrato (a interface) entre a aplicação que a oferece e os outros items, como os logiciários e equipamentos de terceiros.

diff --git a/files/pt-pt/conflicting/learn/css/first_steps/how_css_works/index.html b/files/pt-pt/conflicting/learn/css/first_steps/how_css_works/index.html index 2ee2937e47..e1c841d2c6 100644 --- a/files/pt-pt/conflicting/learn/css/first_steps/how_css_works/index.html +++ b/files/pt-pt/conflicting/learn/css/first_steps/how_css_works/index.html @@ -1,10 +1,11 @@ --- title: O que é CSS -slug: Web/CSS/Como_começar/O_que_é_CSS +slug: conflicting/Learn/CSS/First_steps/How_CSS_works tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/First_steps/How_CSS_works translation_of_original: Web/Guide/CSS/Getting_started/What_is_CSS +original_slug: Web/CSS/Como_começar/O_que_é_CSS ---

{{Next("CSS:Como começar:Porque usar CSS")}}

diff --git a/files/pt-pt/conflicting/learn/css/first_steps/how_css_works_0767812f50daab83155d62da97c6e460/index.html b/files/pt-pt/conflicting/learn/css/first_steps/how_css_works_0767812f50daab83155d62da97c6e460/index.html index 2adc531924..7a412579a8 100644 --- a/files/pt-pt/conflicting/learn/css/first_steps/how_css_works_0767812f50daab83155d62da97c6e460/index.html +++ b/files/pt-pt/conflicting/learn/css/first_steps/how_css_works_0767812f50daab83155d62da97c6e460/index.html @@ -1,10 +1,12 @@ --- title: Porque usar CSS -slug: Web/CSS/Como_começar/Porque_usar_CSS +slug: >- + conflicting/Learn/CSS/First_steps/How_CSS_works_0767812f50daab83155d62da97c6e460 tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/First_steps/How_CSS_works translation_of_original: Web/Guide/CSS/Getting_started/Why_use_CSS +original_slug: Web/CSS/Como_começar/Porque_usar_CSS ---

{{ PreviousNext("CSS:Como começar:O que é CSS", "CSS:Como começar:Como o CSS trabalha") }}

diff --git a/files/pt-pt/conflicting/mdn/contribute/index.html b/files/pt-pt/conflicting/mdn/contribute/index.html index 9c9ca16511..7d491bd72f 100644 --- a/files/pt-pt/conflicting/mdn/contribute/index.html +++ b/files/pt-pt/conflicting/mdn/contribute/index.html @@ -1,11 +1,12 @@ --- title: Contribuir para a MDN -slug: MDN_at_ten/Contribuir_para_MDN +slug: conflicting/MDN/Contribute tags: - Metadados MDN - Mozilla - contribuir translation_of: MDN_at_ten/Contributing_to_MDN +original_slug: MDN_at_ten/Contribuir_para_MDN ---
diff --git a/files/pt-pt/conflicting/web/api/index.html b/files/pt-pt/conflicting/web/api/index.html index fbcae3aea5..c439b1c63f 100644 --- a/files/pt-pt/conflicting/web/api/index.html +++ b/files/pt-pt/conflicting/web/api/index.html @@ -1,6 +1,6 @@ --- title: WebAPI -slug: Web/WebAPI +slug: conflicting/Web/API tags: - Aplicações - Apps @@ -9,6 +9,7 @@ tags: - Movel translation_of: Web/API translation_of_original: WebAPI +original_slug: Web/WebAPI ---

WebAPI é um termo utilizado para referir um conjunto de compatibilidade de dispositivo e APIs de acesso que permitem que as aplicações da Web e o conteúdo acedam ao dispositivo de hardware (tais como estado da bateria ou hardware de vibração do dispositivo), bem como aceder aos dados guardados no dispositivo (tais como o calendário ou lista de contactos). Ao adicionarmos estas APIs, nós esperamos que expanda o que a Web pode fazer hoje, para também incluirem o que apenas as plataformas proprietárias podiam fazer no passado.

diff --git a/files/pt-pt/conflicting/web/api/web_storage_api/index.html b/files/pt-pt/conflicting/web/api/web_storage_api/index.html index 192a51ee66..50bf4d81b4 100644 --- a/files/pt-pt/conflicting/web/api/web_storage_api/index.html +++ b/files/pt-pt/conflicting/web/api/web_storage_api/index.html @@ -1,6 +1,6 @@ --- title: API de Armazenamento da Web -slug: Web/API/API_de_Armazenamento_da_Web +slug: conflicting/Web/API/Web_Storage_API tags: - API - Armazenamento @@ -9,6 +9,7 @@ tags: - Armazenamento da Web - Referencia translation_of: Web/API/Web_Storage_API +original_slug: Web/API/API_de_Armazenamento_da_Web ---

{{DefaultAPISidebar("Web Storage API")}}

diff --git a/files/pt-pt/conflicting/web/api/xmlhttprequest/index.html b/files/pt-pt/conflicting/web/api/xmlhttprequest/index.html index 3b5d4adef9..3d7db7d8ae 100644 --- a/files/pt-pt/conflicting/web/api/xmlhttprequest/index.html +++ b/files/pt-pt/conflicting/web/api/xmlhttprequest/index.html @@ -1,11 +1,12 @@ --- title: XMLHttpRequest -slug: XMLHttpRequest +slug: conflicting/Web/API/XMLHttpRequest tags: - AJAX - - 'AJAX:Outros_Recursos' + - AJAX:Outros_Recursos - Outros_Recursos - Todas_as_Categorias +original_slug: XMLHttpRequest ---

 

diff --git a/files/pt-pt/conflicting/web/javascript/reference/global_objects/number/index.html b/files/pt-pt/conflicting/web/javascript/reference/global_objects/number/index.html index 9014ecdb24..e00342daeb 100644 --- a/files/pt-pt/conflicting/web/javascript/reference/global_objects/number/index.html +++ b/files/pt-pt/conflicting/web/javascript/reference/global_objects/number/index.html @@ -1,6 +1,6 @@ --- title: Number.prototype -slug: Web/JavaScript/Reference/Global_Objects/Number/prototype +slug: conflicting/Web/JavaScript/Reference/Global_Objects/Number tags: - JavaScript - Number @@ -8,6 +8,7 @@ tags: - Prototype translation_of: Web/JavaScript/Reference/Global_Objects/Number translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype +original_slug: Web/JavaScript/Reference/Global_Objects/Number/prototype ---
{{JSRef}}
diff --git a/files/pt-pt/conflicting/web/javascript/reference/global_objects/object/index.html b/files/pt-pt/conflicting/web/javascript/reference/global_objects/object/index.html index 411832665a..ab52d5bfc3 100644 --- a/files/pt-pt/conflicting/web/javascript/reference/global_objects/object/index.html +++ b/files/pt-pt/conflicting/web/javascript/reference/global_objects/object/index.html @@ -1,6 +1,6 @@ --- title: Object.prototype -slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +slug: conflicting/Web/JavaScript/Reference/Global_Objects/Object tags: - JavaScript - Object @@ -8,6 +8,7 @@ tags: - Propriedade translation_of: Web/JavaScript/Reference/Global_Objects/Object translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype +original_slug: Web/JavaScript/Reference/Global_Objects/Object/prototype ---
{{JSRef}}
diff --git a/files/pt-pt/conflicting/web/progressive_web_apps/index.html b/files/pt-pt/conflicting/web/progressive_web_apps/index.html index 712d465d91..bb2c9e7287 100644 --- a/files/pt-pt/conflicting/web/progressive_web_apps/index.html +++ b/files/pt-pt/conflicting/web/progressive_web_apps/index.html @@ -1,6 +1,6 @@ --- title: Identificável -slug: Web/Progressive_web_apps/Identificavel +slug: conflicting/Web/Progressive_web_apps tags: - Aplicações - Aplicações da Web modernas @@ -10,6 +10,7 @@ tags: - manifesto da Web translation_of: Web/Progressive_web_apps translation_of_original: Web/Progressive_web_apps/Discoverable +original_slug: Web/Progressive_web_apps/Identificavel ---
As soon as you publish a new web app, you want the world to know about it. Search engines do ok, but often more control is desired over how your apps are exposed in search results. The new W3C Manifest for a web application can help with this, along with other available features.
diff --git a/files/pt-pt/conflicting/web/progressive_web_apps/responsive/responsive_design_building_blocks/index.html b/files/pt-pt/conflicting/web/progressive_web_apps/responsive/responsive_design_building_blocks/index.html index 23bf84f782..96a1ff04a9 100644 --- a/files/pt-pt/conflicting/web/progressive_web_apps/responsive/responsive_design_building_blocks/index.html +++ b/files/pt-pt/conflicting/web/progressive_web_apps/responsive/responsive_design_building_blocks/index.html @@ -1,6 +1,7 @@ --- title: Desenho responsivo -slug: Web/Progressive_web_apps/Responsivo +slug: >- + conflicting/Web/Progressive_web_apps/Responsive/responsive_design_building_blocks tags: - Aplicações - Aplicações da Web progressivas @@ -8,6 +9,7 @@ tags: - Responsivo translation_of: Web/Progressive_web_apps/Responsive/responsive_design_building_blocks translation_of_original: Web/Progressive_web_apps/Responsive +original_slug: Web/Progressive_web_apps/Responsivo ---
As aplicações da Web responsivas utilizam tecnologias, tais como consultas de multimédia e viewport para se certificar que as suas UIs irão enquadrar qualquer fator de forma: pc, telemóvel, tablet, ou que quer que venha a seguir.
diff --git a/files/pt-pt/conflicting/web/progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a/index.html b/files/pt-pt/conflicting/web/progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a/index.html index 6ef841c83f..62d49e8bc5 100644 --- a/files/pt-pt/conflicting/web/progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a/index.html +++ b/files/pt-pt/conflicting/web/progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a/index.html @@ -1,6 +1,6 @@ --- title: Segurança -slug: Web/Progressive_web_apps/Seguro +slug: conflicting/Web/Progressive_web_apps_c5ce9d8c3500409dbf6f879e4fe3cb8a tags: - Aplicações - Aplicações da Web modernas @@ -11,6 +11,7 @@ tags: - Web translation_of: Web/Progressive_web_apps translation_of_original: Web/Progressive_web_apps/Safe +original_slug: Web/Progressive_web_apps/Seguro ---
A plataforma da Web fornece um mecanismo de entrega seguro que evita a espionagem e garante que o conteúdo não foi adulterado - desde que aproveite o HTTPS e desenvolva as suas aplicações com a segurança em mente.
diff --git a/files/pt-pt/games/index.html b/files/pt-pt/games/index.html index b7058ec932..93a326cd83 100644 --- a/files/pt-pt/games/index.html +++ b/files/pt-pt/games/index.html @@ -1,7 +1,8 @@ --- title: Desenvolvimento de Jogos -slug: Jogos +slug: Games translation_of: Games +original_slug: Jogos ---
{{GamesSidebar}}
diff --git a/files/pt-pt/games/tutorials/index.html b/files/pt-pt/games/tutorials/index.html index 55417d7bdc..bf6285b9cb 100644 --- a/files/pt-pt/games/tutorials/index.html +++ b/files/pt-pt/games/tutorials/index.html @@ -1,6 +1,6 @@ --- title: Tutoriais -slug: Jogos/Tutoriais +slug: Games/Tutorials tags: - Canvas - JavaScript @@ -8,6 +8,7 @@ tags: - Ritmos de Trabalho - Web translation_of: Games/Tutorials +original_slug: Jogos/Tutoriais ---
{{GamesSidebar}}
{{IncludeSubnav("/en-US/docs/Games")}}
diff --git a/files/pt-pt/glossary/404/index.html b/files/pt-pt/glossary/404/index.html index f1e0f934dc..b91d747d61 100644 --- a/files/pt-pt/glossary/404/index.html +++ b/files/pt-pt/glossary/404/index.html @@ -1,12 +1,13 @@ --- title: '404' -slug: Glossário/404 +slug: Glossary/404 tags: - Erros HTTP - Glossário - Infraestrutura - Navegação translation_of: Glossary/404 +original_slug: Glossário/404 ---

O 404 é um código de resposta padrão que significa que o {{Glossary("Server", "servidor")}} não consegue encontrar o recurso solicitado.

diff --git a/files/pt-pt/glossary/502/index.html b/files/pt-pt/glossary/502/index.html index 3c7750028c..f18df6cf19 100644 --- a/files/pt-pt/glossary/502/index.html +++ b/files/pt-pt/glossary/502/index.html @@ -1,6 +1,6 @@ --- title: '502' -slug: Glossário/502 +slug: Glossary/502 tags: - '502' - Bad Gateway @@ -9,6 +9,7 @@ tags: - Infraestrutura - Navegação translation_of: Glossary/502 +original_slug: Glossário/502 ---

Um erro {{Glossary("HTTP")}} significando "Bad Gateway".

diff --git a/files/pt-pt/glossary/accessibility/index.html b/files/pt-pt/glossary/accessibility/index.html index 6f8338d718..d9b4a45827 100644 --- a/files/pt-pt/glossary/accessibility/index.html +++ b/files/pt-pt/glossary/accessibility/index.html @@ -1,10 +1,11 @@ --- title: Acessibilidade -slug: Glossário/Acessibilidade +slug: Glossary/Accessibility tags: - Acessibilidade - Glossário translation_of: Glossary/Accessibility +original_slug: Glossário/Acessibilidade ---

A Acessibilidade da Web (A11Y)refere-se às melhores práticas para manter um site da Web utilizável, apesar das restrições físicas e técnicas. A acessibilidade da Web é formalmente definida e discutida no {{Glossary("W3C")}} através de {{Glossary("WAI","Web Accessibility Initiative")}} (WAI).

diff --git a/files/pt-pt/glossary/ajax/index.html b/files/pt-pt/glossary/ajax/index.html index 3dde7c92c4..9f5e77c3b8 100644 --- a/files/pt-pt/glossary/ajax/index.html +++ b/files/pt-pt/glossary/ajax/index.html @@ -1,13 +1,14 @@ --- title: Ajax -slug: Glossário/AJAX +slug: Glossary/AJAX tags: - AJAX - CodingScripting - Glossário - - 'I10n:priority' + - I10n:priority - Infraestrutura translation_of: Glossary/AJAX +original_slug: Glossário/AJAX ---

Ajax, que inicialmente significava Asynchronous JavaScript And XML (em português {{Glossary("JavaScript")}} e {{Glossary("XML")}} Assíncrono), é uma prática de programação de construção de páginas web complexas e dinâmicas utilizando uma tecnologia conhecida como {{Glossary("XHR_(XMLHttpRequest)","XMLHttpRequest")}}.

diff --git a/files/pt-pt/glossary/argument/index.html b/files/pt-pt/glossary/argument/index.html index 0b2cecac78..f4d102588f 100644 --- a/files/pt-pt/glossary/argument/index.html +++ b/files/pt-pt/glossary/argument/index.html @@ -1,12 +1,13 @@ --- title: Argumento -slug: Glossário/Argumento +slug: Glossary/Argument tags: - CodingScripting - Glossary - Glossário - JavaScript translation_of: Glossary/Argument +original_slug: Glossário/Argumento ---

Um argument é um {{glossary("value","valor")}} ({{Glossary("primitive","primitivo")}} ou {{Glossary("object","objeto")}}) passado como entrada para uma {{Glossary("function","função")}}.

diff --git a/files/pt-pt/glossary/aria/index.html b/files/pt-pt/glossary/aria/index.html index 4dfa6a754d..ae453a4bd7 100644 --- a/files/pt-pt/glossary/aria/index.html +++ b/files/pt-pt/glossary/aria/index.html @@ -1,10 +1,11 @@ --- title: ARIA -slug: Glossário/ARIA +slug: Glossary/ARIA tags: - Acessibilidade - Glossário translation_of: Glossary/ARIA +original_slug: Glossário/ARIA ---

ARIA (Accessible Rich {{glossary("Internet")}} Applications) é uma especificação da {{Glossary("W3C")}} para adicionar semântica e outros metadados ao {{Glossary("HTML")}} para atender usuários de tecnologia assistiva.

diff --git a/files/pt-pt/glossary/bigint/index.html b/files/pt-pt/glossary/bigint/index.html index 44726be185..0fb083825f 100644 --- a/files/pt-pt/glossary/bigint/index.html +++ b/files/pt-pt/glossary/bigint/index.html @@ -1,6 +1,6 @@ --- title: BigInt -slug: Glossário/BigInt +slug: Glossary/BigInt tags: - BigInt - Formato de Precisão Arbitrária @@ -8,5 +8,6 @@ tags: - JavaScript - Referencia translation_of: Glossary/BigInt +original_slug: Glossário/BigInt ---

Em {{Glossary("JavaScript")}}, BigInt é um tipo de dados numéricos que pode representar inteiros num {{interwiki("wikipedia", "Bignum", "formato de precisão arbitrária")}}. Em outras linguagens de programação podem existir diferentes tipos de dados numéricos, por exemplo: Inteiros, Flutuadores, Duplos, ou Bignums.

diff --git a/files/pt-pt/glossary/block_cipher_mode_of_operation/index.html b/files/pt-pt/glossary/block_cipher_mode_of_operation/index.html index c9f87eb850..a4e8945e2f 100644 --- a/files/pt-pt/glossary/block_cipher_mode_of_operation/index.html +++ b/files/pt-pt/glossary/block_cipher_mode_of_operation/index.html @@ -1,12 +1,13 @@ --- title: Modo de operação de cifra de bloco -slug: Glossário/Modo_de_operação_de_cifra_de_bloco +slug: Glossary/Block_cipher_mode_of_operation tags: - Criptografía - Glossário - Modo de operação de cifra de bloco - Segurança translation_of: Glossary/Block_cipher_mode_of_operation +original_slug: Glossário/Modo_de_operação_de_cifra_de_bloco ---

Um modo de operação de cifra de bloco, especifica como uma cifra de bloco deve ser usado para encriptar e decrepitar mensagens que são maiores que o bloco.

diff --git a/files/pt-pt/glossary/boolean/index.html b/files/pt-pt/glossary/boolean/index.html index dc4c3bfc21..503ac36e8c 100644 --- a/files/pt-pt/glossary/boolean/index.html +++ b/files/pt-pt/glossary/boolean/index.html @@ -1,6 +1,6 @@ --- title: Booliano -slug: Glossário/booliano +slug: Glossary/Boolean tags: - Booleano - Booliano @@ -10,6 +10,7 @@ tags: - Progração Scripting - tipos de dados translation_of: Glossary/Boolean +original_slug: Glossário/booliano ---

Na informática, um booliano é um tipo de dados lógico que pode ter apenas os valores verdadeiro ou falso. Por exemplo, em JavaScript, as condicionais de boolianos são frequentemente utilizadas ​​para decidir quais as secções de código a serem executadas (tal como em declarações if) ou repetir (tal como repetições for).

diff --git a/files/pt-pt/glossary/browser/index.html b/files/pt-pt/glossary/browser/index.html index 6adcf06dd5..f55166ad4a 100644 --- a/files/pt-pt/glossary/browser/index.html +++ b/files/pt-pt/glossary/browser/index.html @@ -1,10 +1,11 @@ --- title: Navegador -slug: Glossário/Navegador +slug: Glossary/Browser tags: - Glossário - Navegação translation_of: Glossary/Browser +original_slug: Glossário/Navegador ---

Um navegador da Web é um programa que obtém e exibe páginas a partir da {{Glossary("World Wide Web","Web")}}, e deixa os utilziadores acerem a mais páginas através de {{Glossary("hyperlink","hiperligações")}}.

diff --git a/files/pt-pt/glossary/cache/index.html b/files/pt-pt/glossary/cache/index.html index d3372eebf0..91eb49d39e 100644 --- a/files/pt-pt/glossary/cache/index.html +++ b/files/pt-pt/glossary/cache/index.html @@ -1,10 +1,11 @@ --- title: Cache -slug: Glossário/Cache +slug: Glossary/Cache tags: - Glossário - HTTP translation_of: Glossary/Cache +original_slug: Glossário/Cache ---

Um cache (web cache or cache HTTP) é um componente que armazena respostas HTTP temporariamente para que para que possa ser utilizado para pedidos HTTP subesequentes, desde que cumpra determinadas condições.

diff --git a/files/pt-pt/glossary/cia/index.html b/files/pt-pt/glossary/cia/index.html index 164bd5ab91..ba97dca690 100644 --- a/files/pt-pt/glossary/cia/index.html +++ b/files/pt-pt/glossary/cia/index.html @@ -1,10 +1,11 @@ --- title: CIA -slug: Glossário/CIA +slug: Glossary/CIA tags: - Glossário - Segurança translation_of: Glossary/CIA +original_slug: Glossário/CIA ---

A CIA (Confidentiality, Integrity, Availability) (em português Confidencialidade, Integridade, Disponibilidade), também chamada a tríade CIA ou a tríade AIC, é um modelo que orienta as políticas de segurança da informação de uma organização.

diff --git a/files/pt-pt/glossary/compile/index.html b/files/pt-pt/glossary/compile/index.html index 4242775302..4a2313b9e3 100644 --- a/files/pt-pt/glossary/compile/index.html +++ b/files/pt-pt/glossary/compile/index.html @@ -1,10 +1,11 @@ --- title: Compilar -slug: Glossário/Compilar +slug: Glossary/Compile tags: - CodingScripting - Glossário translation_of: Glossary/Compile +original_slug: Glossário/Compilar ---

Compilar é o processo de transformar um programa de computador em uma determinada linguagem de programação para o mesmo programa escrito em outro idioma (normalmente um idioma binário que o computador pode executar).

diff --git a/files/pt-pt/glossary/crlf/index.html b/files/pt-pt/glossary/crlf/index.html index 6ee96215ed..76de0cb1e8 100644 --- a/files/pt-pt/glossary/crlf/index.html +++ b/files/pt-pt/glossary/crlf/index.html @@ -1,6 +1,6 @@ --- title: CRLF -slug: Glossário/CRLF +slug: Glossary/CRLF tags: - CR - CRLF @@ -10,6 +10,7 @@ tags: - Nova Linha - carriage return translation_of: Glossary/CRLF +original_slug: Glossário/CRLF ---

CR e LF são caracteres de controlo ou {{interwiki("wikipedia", "bytecode")}} que podem ser utilizados para marcar uma quebra de linha num ficheiro de texto.

diff --git a/files/pt-pt/glossary/cross_axis/index.html b/files/pt-pt/glossary/cross_axis/index.html index 79b1d8d2c3..2882ed5be8 100644 --- a/files/pt-pt/glossary/cross_axis/index.html +++ b/files/pt-pt/glossary/cross_axis/index.html @@ -1,11 +1,12 @@ --- title: Eixo transversal -slug: Glossário/Eixo_transversal +slug: Glossary/Cross_Axis tags: - CSS - Glossário - flexbox translation_of: Glossary/Cross_Axis +original_slug: Glossário/Eixo_transversal ---

Numa {{glossary("flexbox")}}, ou eixo transveral é perpendicular ao {{glossary("main axis")}}, o que significa que se a direção for ao longo de uma linha (ou seja, {{cssxref("flex-direction")}} é row ou row-reverse) então o eixo transversal estende-se ao longo das colunas.

diff --git a/files/pt-pt/glossary/crud/index.html b/files/pt-pt/glossary/crud/index.html index 175789d7ed..60d0b0bf08 100644 --- a/files/pt-pt/glossary/crud/index.html +++ b/files/pt-pt/glossary/crud/index.html @@ -1,10 +1,11 @@ --- title: CRUD -slug: Glossário/CRUD +slug: Glossary/CRUD tags: - Glossário - Infraestrutura translation_of: Glossary/CRUD +original_slug: Glossário/CRUD ---

CRUD (Create, Read, Update, Delete) (em português criação, consulta, atualização e destruição) é um acrónimo para as formas como se pode operar com dados armazenados. É uma mnemónica para as quatro funções básicas de armazenamento persistente.  CRUD refere-se normalmente a operações realizadas numa base de dados ou datastore, mas pode também aplicar-se a funções de nível superior de uma aplicação, tais como soft delete, onde os dados não são realmente apagados, mas marcados como apagados.

diff --git a/files/pt-pt/glossary/dhtml/index.html b/files/pt-pt/glossary/dhtml/index.html index 29c7db34c9..ef3f833b39 100644 --- a/files/pt-pt/glossary/dhtml/index.html +++ b/files/pt-pt/glossary/dhtml/index.html @@ -1,9 +1,10 @@ --- title: DHTML -slug: DHTML +slug: Glossary/DHTML tags: - DHTML - Todas_as_Categorias translation_of: Glossary/DHTML +original_slug: DHTML ---

DHTML é uma sigla que signfica "dynamic HTML". O termo DHTML é geralmente usado como referência ao código que se encontra por detrás de páginas interactivas que não são baseadas em plugins como Flash ou Java. O termo reúne a funcionalidade combinada que é disponibilizada aos programadores usando HTML, CSS, Document Object Model e JavaScript

diff --git a/files/pt-pt/glossary/dom/index.html b/files/pt-pt/glossary/dom/index.html index b2106f7a82..7f3233b76c 100644 --- a/files/pt-pt/glossary/dom/index.html +++ b/files/pt-pt/glossary/dom/index.html @@ -1,11 +1,12 @@ --- title: DOM (Modelo de Objeto de Documento) -slug: Glossário/DOM +slug: Glossary/DOM tags: - CodingScripting - DOM - Glossário translation_of: Glossary/DOM +original_slug: Glossário/DOM ---

O DOM (Modelo de Objeto de Documento) é uma {{Glossary("API")}} que representa e interage com qualquer documento de {{Glossary("HTML")}} ou {{Glossary("XML")}}. O DOM é um modelo de documento carregado no {{glossary("navegador")}} e representando o documento como uma árvore de nodo, onde cada nodo representa parte do documento (por exemplo, um  {{Glossary("elemento")}}, string de texto, ou comentário) .

diff --git a/files/pt-pt/glossary/ecma/index.html b/files/pt-pt/glossary/ecma/index.html index 067a20cc61..ca2061a59e 100644 --- a/files/pt-pt/glossary/ecma/index.html +++ b/files/pt-pt/glossary/ecma/index.html @@ -1,10 +1,11 @@ --- title: ECMA -slug: Glossário/ECMA +slug: Glossary/ECMA tags: - Glossário - Mecanismos Web translation_of: Glossary/ECMA +original_slug: Glossário/ECMA ---

Ecma International (oficialmente Associação Européia dos Fabricantes de Computadores) é uma organização sem fins lucrativos que desenvolve os padrões para hardware de computadores, comunicações e linguagens de programação.

diff --git a/files/pt-pt/glossary/element/index.html b/files/pt-pt/glossary/element/index.html index 4acc682ed0..99cf652e10 100644 --- a/files/pt-pt/glossary/element/index.html +++ b/files/pt-pt/glossary/element/index.html @@ -1,11 +1,12 @@ --- title: Elemento -slug: Glossário/Elemento +slug: Glossary/Element tags: - CodingScripting - Glossário - HTML translation_of: Glossary/Element +original_slug: Glossário/Elemento ---

Um elemento faz parte de uma página da Web. Em XML e HTML, um elemento pode conter um item de dados ou parte de texto ou uma imagem, ou talvez nada. Um elemento típico inclui uma tag de abertura com alguns atributos, conteúdo de texto fechado e uma tag de fecho.Example: in <p class="nice">Hello world!</p>, '<p class="nice">' is an opening tag, 'class="nice"' is an attribute and its value, 'Hello world!' is enclosed text content, and '</p>' is a closing tag.

diff --git a/files/pt-pt/glossary/engine/index.html b/files/pt-pt/glossary/engine/index.html index f926844c24..693e42cbe4 100644 --- a/files/pt-pt/glossary/engine/index.html +++ b/files/pt-pt/glossary/engine/index.html @@ -1,11 +1,12 @@ --- title: Motor -slug: Glossário/Motor +slug: Glossary/Engine tags: - Codificação - Glossário - Precisa de Conteúdo translation_of: Glossary/Engine +original_slug: Glossário/Motor ---

O motor de {{glossary("JavaScript")}} é um interpretador que analisa e executa um programa JavaScript.

diff --git a/files/pt-pt/glossary/entity_header/index.html b/files/pt-pt/glossary/entity_header/index.html index e7181009c7..b3847c5b9f 100644 --- a/files/pt-pt/glossary/entity_header/index.html +++ b/files/pt-pt/glossary/entity_header/index.html @@ -1,10 +1,11 @@ --- title: Cabeçalho de entidade -slug: Glossário/Cabeçalho_de_entidade +slug: Glossary/Entity_header tags: - Glossário - WebMechanics translation_of: Glossary/Entity_header +original_slug: Glossário/Cabeçalho_de_entidade ---

Um cabeçalho de entidade é um {{glossary("header", "cabeçalho de HTTP")}} que descreve o conteúdo do corpo da mensagem. Cabeçalhos de entidade são usados em pedidos e respostas de HTTP. Cabeçalhos como {{HTTPHeader("Content-Length")}}, {{HTTPHeader("Content-Language")}}, {{HTTPHeader("Content-Encoding")}} são cabeçalhos de entidade.

diff --git a/files/pt-pt/glossary/favicon/index.html b/files/pt-pt/glossary/favicon/index.html index 639edc9921..b7bb4feec2 100644 --- a/files/pt-pt/glossary/favicon/index.html +++ b/files/pt-pt/glossary/favicon/index.html @@ -1,11 +1,12 @@ --- title: Favicon -slug: Glossário/Favicon +slug: Glossary/Favicon tags: - Glossário - Intro - favicon translation_of: Glossary/Favicon +original_slug: Glossário/Favicon ---

Um favicon (do inglês: favorite icon) é um pequeno ícone que acompanha o website, que é visualizado na barra do endereço, guia de páginas e no menu de favoritos. Note, no entanto, que a maior parte dos navegadores modernos substituíram o favicon na barra de endereço por uma imagem, indicando se o site utiliza {{Glossary("https","HTTPS")}}.

diff --git a/files/pt-pt/glossary/flexbox/index.html b/files/pt-pt/glossary/flexbox/index.html index 6964e7a36e..6949c35908 100644 --- a/files/pt-pt/glossary/flexbox/index.html +++ b/files/pt-pt/glossary/flexbox/index.html @@ -1,11 +1,12 @@ --- title: Flexbox -slug: Glossário/Flexbox +slug: Glossary/Flexbox tags: - CSS - Glossário - flexbox translation_of: Glossary/Flexbox +original_slug: Glossário/Flexbox ---

Flexbox é o nome geralmente dado ao Módulo de Layout em Caixa Flexível do CSS (CSS Flexible Box Layout Module), um modelo de layout com o propósito de alinhar elementos numa determinada direção — ao longo de uma linha ou de uma coluna.

diff --git a/files/pt-pt/glossary/git/index.html b/files/pt-pt/glossary/git/index.html index f43064220f..6d409b8d1f 100644 --- a/files/pt-pt/glossary/git/index.html +++ b/files/pt-pt/glossary/git/index.html @@ -1,10 +1,11 @@ --- title: Git -slug: Glossário/Git +slug: Glossary/Git tags: - Colaboração - Glossário translation_of: Glossary/Git +original_slug: Glossário/Git ---

Git é um sistema gratuito, de fonte aberta e distribuído de gestão do código fonte ({{Glossary("SCM", "GCS")}}). Facilita a gestão de bases de código com equipas de desenvolvimento distribuídas. O que o distingue dos sistemas SCM anteriores é a capacidade de fazer operações comuns (criar uma branch, fazer um commit, etc.) na sua máquina de desenvolvimento local, sem ter de alterar o repositório principal ou mesmo ter acesso de escrita a ele.

diff --git a/files/pt-pt/glossary/gzip_compression/index.html b/files/pt-pt/glossary/gzip_compression/index.html index 8be9011fc9..02a5ff637a 100644 --- a/files/pt-pt/glossary/gzip_compression/index.html +++ b/files/pt-pt/glossary/gzip_compression/index.html @@ -1,11 +1,12 @@ --- title: Compressão GZip -slug: Glossário/Compressao_GZip +slug: Glossary/GZip_compression tags: - Glossário - compressão - gzip translation_of: Glossary/GZip_compression +original_slug: Glossário/Compressao_GZip ---

gzip é um algoritmo de compressão que permite reduzir o tamanho dos ficheiros, permitindo transferências mais rápidas na rede. É normalmente suportado pelos servidores da Web e navegadores modernos, o que significa que os servidores podem comprimir automaticamente os ficheiros com o gzip antes de enviá-los, e os navegadores podem descomprimir os ficheiros depois de os receberem.

diff --git a/files/pt-pt/glossary/html/index.html b/files/pt-pt/glossary/html/index.html index 8cb677ae62..8ed02323a0 100644 --- a/files/pt-pt/glossary/html/index.html +++ b/files/pt-pt/glossary/html/index.html @@ -1,12 +1,13 @@ --- title: HTML -slug: Glossário/HTML +slug: Glossary/HTML tags: - Glossário - HTML - Programação Scripting - - 'l10n:priority' + - l10n:priority translation_of: Glossary/HTML +original_slug: Glossário/HTML ---
{{QuickLinksWithSubpages("/pt-PT/docs/Glossário")}}
diff --git a/files/pt-pt/glossary/hypertext/index.html b/files/pt-pt/glossary/hypertext/index.html index 0816740252..c561f8fc21 100644 --- a/files/pt-pt/glossary/hypertext/index.html +++ b/files/pt-pt/glossary/hypertext/index.html @@ -1,11 +1,12 @@ --- title: Hipertexto -slug: Glossário/Hipertexto +slug: Glossary/Hypertext tags: - Glossário - Mecânica da Web - Web translation_of: Glossary/Hypertext +original_slug: Glossário/Hipertexto ---
Sequência de texto que permite a remissão para outra localização (documento, ficheiro, página da Internet, etc.).

diff --git a/files/pt-pt/glossary/iana/index.html b/files/pt-pt/glossary/iana/index.html index f6a4d9c517..7e876ea547 100644 --- a/files/pt-pt/glossary/iana/index.html +++ b/files/pt-pt/glossary/iana/index.html @@ -1,10 +1,11 @@ --- title: IANA -slug: Glossário/IANA +slug: Glossary/IANA tags: - Glossário - Infraestrutura translation_of: Glossary/IANA +original_slug: Glossário/IANA ---

IANA (Internet Assigned Numbers Authority), em português "autoridade para atribuição de números de internet", é uma filial da {{glossary("ICANN")}} reposável pelo registo e / ou atribuição de {{glossary("domain name","nomes de dominio")}}, {{glossary("IP address","endreços IP")}}, e outros nomes e números utilizados pelos {{glossary("protocol","protocolos")}} da Internet.

diff --git a/files/pt-pt/glossary/idempotent/index.html b/files/pt-pt/glossary/idempotent/index.html index a84b97ecbd..354dc28eb7 100644 --- a/files/pt-pt/glossary/idempotent/index.html +++ b/files/pt-pt/glossary/idempotent/index.html @@ -1,7 +1,8 @@ --- title: Idempotent -slug: Glossário/Idempotent +slug: Glossary/Idempotent translation_of: Glossary/Idempotent +original_slug: Glossário/Idempotent ---

Um método HTTP é idempotente se, e só se, o mesmo pedido puder ser feito mais do que uma vez, tendo sempre o mesmo resultado e deixando o servidor no mesmo estado. Por outras palavras, um método idempotente não deve ter efeitos secundários. Implementados corretamente, os métodos {{HTTPMethod("GET")}}, {{HTTPMethod("HEAD")}}, {{HTTPMethod("PUT")}}, and {{HTTPMethod("DELETE")}} são idempotentes, mas não o método {{HTTPMethod("POST")}}. Todos os métodos {{glossary("safe")}} também são idempotentes.

diff --git a/files/pt-pt/glossary/index.html b/files/pt-pt/glossary/index.html index 55cefb9ab1..c8ee5a0bab 100644 --- a/files/pt-pt/glossary/index.html +++ b/files/pt-pt/glossary/index.html @@ -1,6 +1,6 @@ --- title: Glossário -slug: Glossário +slug: Glossary tags: - Beginner - Dicionário @@ -10,6 +10,7 @@ tags: - Terminologia - definições translation_of: Glossary +original_slug: Glossário ---
{{LearnBox({"title":"Aprenda um termo novo:"})}}
diff --git a/files/pt-pt/glossary/indexeddb/index.html b/files/pt-pt/glossary/indexeddb/index.html index 6857254a7b..362ca5c769 100644 --- a/files/pt-pt/glossary/indexeddb/index.html +++ b/files/pt-pt/glossary/indexeddb/index.html @@ -1,12 +1,13 @@ --- title: IndexedDB -slug: Glossário/IndexedDB +slug: Glossary/IndexedDB tags: - API - Banco de Dados - Glossário - Sql translation_of: Glossary/IndexedDB +original_slug: Glossário/IndexedDB ---

IndexedDB é uma {{glossary("API")}} de web para armazenar volumosas estruturas de dados dentro dos navegadores e indexá-los para buscas de alto desempenho. Sendo um RDBMS baseado em {{glossary("SQL")}}, IndexedDB é um sistema de banco de dados transacionais. Porém ele usa objectos {{glossary("JavaScript")}} ao invés de tabelas em colunas fixas para armazenar os dados.

diff --git a/files/pt-pt/glossary/isp/index.html b/files/pt-pt/glossary/isp/index.html index b8d180e53b..dc71c855cd 100644 --- a/files/pt-pt/glossary/isp/index.html +++ b/files/pt-pt/glossary/isp/index.html @@ -1,6 +1,6 @@ --- title: ISP -slug: Glossário/ISP +slug: Glossary/ISP tags: - Fornecedor de acesso à internet - Glossário @@ -8,6 +8,7 @@ tags: - Web - WebMechanics translation_of: Glossary/ISP +original_slug: Glossário/ISP ---

Um ISP (Fornecedor de Acesso à Internet ou em inglês Internet Service Provider) vende acesso à Internet e, por vezes, e-mail, alojamento Web e voz sobre IP, quer através de uma ligação telefónica (antigamente mais comum), quer através de uma ligação de banda larga, tal como um modem por cabo ou serviço DSL.

diff --git a/files/pt-pt/glossary/lazy_load/index.html b/files/pt-pt/glossary/lazy_load/index.html index b94fa537c9..f4fa4bec94 100644 --- a/files/pt-pt/glossary/lazy_load/index.html +++ b/files/pt-pt/glossary/lazy_load/index.html @@ -1,12 +1,13 @@ --- title: Lazy load -slug: Glossário/Lazy_load +slug: Glossary/Lazy_load tags: - Glossário - Lazy loading - Referencia - Web Performance translation_of: Glossary/Lazy_load +original_slug: Glossário/Lazy_load ---

O Lazy loading (carregamento preguiçoso) é uma estratégia que atrasa o carregamento de alguns recursos (por exemplo, imagens) até serem necessários pelo utilizador com base na actividade do utilizador e no seu padrão de navegação; normalmente, estes recursos só são carregados quando são visualizados. Se implementado correctamente, este atraso no carregamento de activos é ininterrupto para a experiência do utilizador e pode ajudar a melhorar o desempenho da carga inicial, incluindo o time to interactive, uma vez que são necessários menos recursos para que a página comece a funcionar.

diff --git a/files/pt-pt/glossary/localization/index.html b/files/pt-pt/glossary/localization/index.html index 38c936a7b1..d22f7537a1 100644 --- a/files/pt-pt/glossary/localization/index.html +++ b/files/pt-pt/glossary/localization/index.html @@ -1,6 +1,6 @@ --- title: Localização -slug: Localização +slug: Glossary/Localization tags: - Colaboração - Glossário @@ -8,6 +8,7 @@ tags: - Localização - Mecânica da Web translation_of: Glossary/Localization +original_slug: Localização ---
Localização (l10n) é o processo de adaptar uma interface do utilizador do software para uma cultura específica.

 

diff --git a/files/pt-pt/glossary/main_axis/index.html b/files/pt-pt/glossary/main_axis/index.html index 02f69020e3..07f9d5b45c 100644 --- a/files/pt-pt/glossary/main_axis/index.html +++ b/files/pt-pt/glossary/main_axis/index.html @@ -1,11 +1,12 @@ --- title: Eixo principal -slug: Glossário/Eixo_principal +slug: Glossary/Main_Axis tags: - CSS - Glossário - flexbox translation_of: Glossary/Main_Axis +original_slug: Glossário/Eixo_principal ---

O eixo principal num {{glossary("flexbox")}} tem a direção definida pela propriedade {{cssxref("flex-direction")}}. Esta propriedade pode ter os seguintes valores:

diff --git a/files/pt-pt/glossary/metadata/index.html b/files/pt-pt/glossary/metadata/index.html index 59cd3c3f6f..118cd4c4cf 100644 --- a/files/pt-pt/glossary/metadata/index.html +++ b/files/pt-pt/glossary/metadata/index.html @@ -1,12 +1,13 @@ --- title: Metadados -slug: Glossário/Metadados +slug: Glossary/Metadata tags: - Glossário - HTML - Programação Scripting - metadados translation_of: Glossary/Metadata +original_slug: Glossário/Metadados ---

Metadados é — na sua definição mais simples - dados que descrevem dados. Por exemplo, um documento {{glossary("HTML")}} é dados, mas HTML também pode conter metadados no seu elemento {{htmlelement("head")}} que descreve o documento — por exemplo, quem o escreveu, e o seu resumo.

diff --git a/files/pt-pt/glossary/mitm/index.html b/files/pt-pt/glossary/mitm/index.html index d4f2414032..8724874eae 100644 --- a/files/pt-pt/glossary/mitm/index.html +++ b/files/pt-pt/glossary/mitm/index.html @@ -1,10 +1,11 @@ --- title: MitM -slug: Glossário/MitM +slug: Glossary/MitM tags: - Glossário - Segurança translation_of: Glossary/MitM +original_slug: Glossário/MitM ---

Um Ataque Man-in-the-middle (MitM) interceta uma comunicação entre dois sistemas. Por exemplo, um roteador Wi-Fi pode estar comprometido.

diff --git a/files/pt-pt/glossary/node.js/index.html b/files/pt-pt/glossary/node.js/index.html index 156c3e365a..cd74805f32 100644 --- a/files/pt-pt/glossary/node.js/index.html +++ b/files/pt-pt/glossary/node.js/index.html @@ -1,12 +1,13 @@ --- title: Node.js -slug: Glossário/Node.js +slug: Glossary/Node.js tags: - Glossário - Infraestrutura - JavaScript - node.js translation_of: Glossary/Node.js +original_slug: Glossário/Node.js ---

Node.js é um ambiente de execução multiplataforma em {{Glossary("JavaScript")}} que permite aos programadores criarem aplicações de rede e 'lado do servidor' com JavaScript.

diff --git a/files/pt-pt/glossary/object/index.html b/files/pt-pt/glossary/object/index.html index c22e16f168..f2947707b7 100644 --- a/files/pt-pt/glossary/object/index.html +++ b/files/pt-pt/glossary/object/index.html @@ -1,6 +1,6 @@ --- title: Objeto -slug: Glossário/Objeto +slug: Glossary/Object tags: - Glossary - Glossário @@ -8,6 +8,7 @@ tags: - Objeto - Programação Scripting translation_of: Glossary/Object +original_slug: Glossário/Objeto ---

Objeto refere-se a uma estrutura de dados contendo dados e instruções para trabalhar com os dados. Os objetos às vezes referem-se a coisas do mundo real, por exemplo, um carro ou objeto de mapa num jogo de carros. {{glossary("JavaScript")}}, Java, C++, Python, e Ruby são exemplos de linguagens em {{glossary("OOP","programação orientada em objeto")}}.

diff --git a/files/pt-pt/glossary/object_reference/index.html b/files/pt-pt/glossary/object_reference/index.html index 1be540d26f..f368d7bbae 100644 --- a/files/pt-pt/glossary/object_reference/index.html +++ b/files/pt-pt/glossary/object_reference/index.html @@ -1,11 +1,12 @@ --- title: Referência de objeto -slug: Glossário/Referencia_de_objeto +slug: Glossary/Object_reference tags: - CodingScripting - Glossary - Glossário translation_of: Glossary/Object_reference +original_slug: Glossário/Referencia_de_objeto ---

Uma ligação para um {{glossary("object","objeto")}}. Referências de objeto podem ser utilziadas como objetos interligados.

diff --git a/files/pt-pt/glossary/oop/index.html b/files/pt-pt/glossary/oop/index.html index c37e75122c..a266f0149b 100644 --- a/files/pt-pt/glossary/oop/index.html +++ b/files/pt-pt/glossary/oop/index.html @@ -1,11 +1,12 @@ --- title: OOP -slug: Glossário/OOP +slug: Glossary/OOP tags: - Glossário - Principiante - Programação Scripting translation_of: Glossary/OOP +original_slug: Glossário/OOP ---

OOP (Programação Orientada em Objeto) é uma abordagem na programação em que os dados são encapsulados dentro de {{glossary("object","objetos")}} e onde o próprio objeto é operado, em vez de suas partes componentes.

diff --git a/files/pt-pt/glossary/ota/index.html b/files/pt-pt/glossary/ota/index.html index ec1f107800..4b787f6b5b 100644 --- a/files/pt-pt/glossary/ota/index.html +++ b/files/pt-pt/glossary/ota/index.html @@ -1,6 +1,6 @@ --- title: OTA -slug: Glossário/OTA +slug: Glossary/OTA tags: - Glossário - Infraestrutura @@ -8,6 +8,7 @@ tags: - Wireless - updates translation_of: Glossary/OTA +original_slug: Glossário/OTA ---

Over-The-Air (OTA ou "Pelo-Ar") refere-se à atualização automática de programas de dispositivos conectados a partir de um servidor central. Todos os proprietários de dispositivos ao receber um determinado conjunto de atualizações estão sob o mesmo "canal"; e cada dispositivo pode amiúde acessar vários canais (e.g. para "builds" de produção ou engenharia).

diff --git a/files/pt-pt/glossary/polyfill/index.html b/files/pt-pt/glossary/polyfill/index.html index f0261120c0..b72e8fd7cf 100644 --- a/files/pt-pt/glossary/polyfill/index.html +++ b/files/pt-pt/glossary/polyfill/index.html @@ -1,7 +1,8 @@ --- title: Polyfill -slug: Glossário/Polyfill +slug: Glossary/Polyfill translation_of: Glossary/Polyfill +original_slug: Glossário/Polyfill ---

Um polyfill é um pedaço de código (geralmente JavaScript) usado para fornecer funcionalidades modernas em browsers mais antigos que não o suportam nativamente.

diff --git a/files/pt-pt/glossary/prototype-based_programming/index.html b/files/pt-pt/glossary/prototype-based_programming/index.html index 8f64f4e216..9dde44c37f 100644 --- a/files/pt-pt/glossary/prototype-based_programming/index.html +++ b/files/pt-pt/glossary/prototype-based_programming/index.html @@ -1,10 +1,11 @@ --- title: Programação baseada em protótipo -slug: Glossário/Prototype-based_programming +slug: Glossary/Prototype-based_programming tags: - Glossário - Programação Scripting translation_of: Glossary/Prototype-based_programming +original_slug: Glossário/Prototype-based_programming ---

A programação baseada em protótipo é um estilo de {{Glossary("OOP", " programação orientada em objeto")}} em que as {{Glossary('Class', 'classes')}} não são explicitamente definidas, mas sim derivadas adicionando as propriedades e os métodos a uma instância de outra classe ou, com menos freqüência, adicione-os a um objeto vazio.

diff --git a/files/pt-pt/glossary/scm/index.html b/files/pt-pt/glossary/scm/index.html index abed4317c5..bb4f1d5f09 100644 --- a/files/pt-pt/glossary/scm/index.html +++ b/files/pt-pt/glossary/scm/index.html @@ -1,12 +1,13 @@ --- title: GCS -slug: Glossário/GCS +slug: Glossary/SCM tags: - CodingScripting - GCS - Glossário - SCM translation_of: Glossary/SCM +original_slug: Glossário/GCS ---

O GCS (Gestão de Controlo de Software ou Source Control Management) é um sistema de gestão do código fonte. Normalmente refere-se à utilização de software para o controlo de versões. Um programador pode modificar arquivos de código fonte sem ter medo de editar coisas úteis, porque um GCS mantém um registo de como o código fonte muda e quem faz as alterações.

diff --git a/files/pt-pt/glossary/server/index.html b/files/pt-pt/glossary/server/index.html index f1e161b3ee..dca22e6b38 100644 --- a/files/pt-pt/glossary/server/index.html +++ b/files/pt-pt/glossary/server/index.html @@ -1,6 +1,6 @@ --- title: Servidor -slug: Glossário/Servidor +slug: Glossary/Server tags: - Glossário - Infraestrutura @@ -8,6 +8,7 @@ tags: - Rede - Servidor translation_of: Glossary/Server +original_slug: Glossário/Servidor ---

Um servidor hardware é um computador compartilhado em uma rede que provê serviços a clientes. Um servidor software é um programa que provê serviços a programas clientes.

diff --git a/files/pt-pt/glossary/signature/index.html b/files/pt-pt/glossary/signature/index.html index c09761e84d..a368dc1fe0 100644 --- a/files/pt-pt/glossary/signature/index.html +++ b/files/pt-pt/glossary/signature/index.html @@ -1,10 +1,11 @@ --- title: Assinatura -slug: Glossário/Assinatura +slug: Glossary/Signature tags: - Desambiguação - Glossário translation_of: Glossary/Signature +original_slug: Glossário/Assinatura ---

O termo assinatura pode ter vários significados dependendo do contexto. Este pode referir-se a:

diff --git a/files/pt-pt/glossary/tag/index.html b/files/pt-pt/glossary/tag/index.html index 825a294e51..f25d60ec10 100644 --- a/files/pt-pt/glossary/tag/index.html +++ b/files/pt-pt/glossary/tag/index.html @@ -1,7 +1,8 @@ --- title: Tag -slug: Glossário/Etiqueta +slug: Glossary/Tag translation_of: Glossary/Tag +original_slug: Glossário/Etiqueta ---

Em {{Glossary("HTML")}} é utilizada uma tag para criar um {{Glossary("element","elemento")}}.  O name de um elemento de HTML é o name utilizado em parêntese angular, tal como <p> para parágrafo. Note que a etiqueta de fim name é precedida pelo caráter "barra oblíqua", "</p>", e nos elementos vazios a etiqueta de fim não é necessária, nem permitida. Se os atributos não forem mencionados, são utilizados os valores predefinidos, em cada caso. 

diff --git a/files/pt-pt/glossary/utf-8/index.html b/files/pt-pt/glossary/utf-8/index.html index 2541862ba3..d89092ed0b 100644 --- a/files/pt-pt/glossary/utf-8/index.html +++ b/files/pt-pt/glossary/utf-8/index.html @@ -1,6 +1,6 @@ --- title: UTF-8 -slug: Glossário/UTF-8 +slug: Glossary/UTF-8 tags: - CodingScripting - Glossário @@ -8,6 +8,7 @@ tags: - JavaScript - Utf-8 translation_of: Glossary/UTF-8 +original_slug: Glossário/UTF-8 ---

UTF-8 (UCS Transformation Format 8) é o {{Glossary("Character encoding", "caráter de codificação")}} mais comum da World Wide Web. Cada caráter é representado por um até quatro bytes. UTF-8 é compatível com versões anteriores de {{Glossary("ASCII")}} e pode representar qualquer caráter Unicode padrão.

diff --git a/files/pt-pt/glossary/value/index.html b/files/pt-pt/glossary/value/index.html index 169f9a0f67..f3bb6c32a6 100644 --- a/files/pt-pt/glossary/value/index.html +++ b/files/pt-pt/glossary/value/index.html @@ -1,6 +1,6 @@ --- title: Valor -slug: Glossário/Valor +slug: Glossary/Value tags: - CodingScripting - Glossary @@ -8,6 +8,7 @@ tags: - NeedsContent - Precisa de Conteúdo translation_of: Glossary/Value +original_slug: Glossário/Valor ---

No contexto de dados ou um objeto {{Glossary("Wrapper", "wrapper")}} em torno desses dados, o valor é o {{Glossary("Primitive","valor primitivo")}} que o objeto wrapper contém. No contexto de uma {{Glossary("Variable","variável")}} ou {{Glossary("Property","propriedade")}}, o valor pode ser um primitivo ou uma {{Glossary("Object reference","referência de objeto")}}.

diff --git a/files/pt-pt/glossary/viewport/index.html b/files/pt-pt/glossary/viewport/index.html index 98daacebe0..2d6ce9bc4b 100644 --- a/files/pt-pt/glossary/viewport/index.html +++ b/files/pt-pt/glossary/viewport/index.html @@ -1,12 +1,13 @@ --- title: Viewport -slug: Glossário/Viewport +slug: Glossary/Viewport tags: - CodingScripting - Glossário - Layout - viewport translation_of: Glossary/Viewport +original_slug: Glossário/Viewport ---

Um viewport representa uma área poligonal (normalmente rectangular) na computação gráfica que pode ser visualizada. Em termos de navegador web, refere-se à area do documento que que é possível visualizar.

diff --git a/files/pt-pt/glossary/visual_viewport/index.html b/files/pt-pt/glossary/visual_viewport/index.html index 3bd82858fb..15e0f838d9 100644 --- a/files/pt-pt/glossary/visual_viewport/index.html +++ b/files/pt-pt/glossary/visual_viewport/index.html @@ -1,12 +1,13 @@ --- title: Viewport Visual -slug: Glossário/Viewport_Visual +slug: Glossary/Visual_Viewport tags: - Glossário - VisualViewport - viewport - viewport visual translation_of: Glossary/Visual_Viewport +original_slug: Glossário/Viewport_Visual ---

A parte do {{Glossary("viewport")}} que é actualmente visível chama-se o "viewport visual". Este pode ser menor que o viewport do layout, por exemplo, quando o utilizador faz um zoom localizado. O viewport visual é a parte visível de um ecrã, excluindo teclados no ecrã, áreas fora de uma área do zoom localizado, ou qualquer outro artefacto no ecrã cuja escala seja independente das dimensões de uma página.

diff --git a/files/pt-pt/glossary/webextensions/index.html b/files/pt-pt/glossary/webextensions/index.html index a86c3706b6..cd9eca2847 100644 --- a/files/pt-pt/glossary/webextensions/index.html +++ b/files/pt-pt/glossary/webextensions/index.html @@ -1,12 +1,13 @@ --- title: Extensões da Web -slug: Glossário/Extensoes_da_Web +slug: Glossary/WebExtensions tags: - CodingScripting - Extensões da Web - Glossário - Precisa de Conteúdo translation_of: Glossary/WebExtensions +original_slug: Glossário/Extensoes_da_Web ---

'Extensões da Web' é um sistema cruzado de navegador para o desenvolvimento de extensões de navegador no Firefox. Este sistema fornece APIs, que em grande parte são suportadas em diferentes navegadores , tais como o Google Chrome, Microsoft Edge, Mozilla Firefox e Opera Browser.

diff --git a/files/pt-pt/glossary/webrtc/index.html b/files/pt-pt/glossary/webrtc/index.html index 452b4f3f24..23ca2c94b2 100644 --- a/files/pt-pt/glossary/webrtc/index.html +++ b/files/pt-pt/glossary/webrtc/index.html @@ -1,6 +1,6 @@ --- title: WebRTC -slug: Glossário/WebRTC +slug: Glossary/WebRTC tags: - Glossário - Infraestrutura @@ -9,6 +9,7 @@ tags: - VoIP - WebRTC translation_of: Glossary/WebRTC +original_slug: Glossário/WebRTC ---

WebRTC (Comunicações da Web em Tempo Real) é uma {{Glossary("API")}} que pode ser utilizada por aplicativos de videoconferência, chamadas de voz, e P2P.

diff --git a/files/pt-pt/glossary/webvtt/index.html b/files/pt-pt/glossary/webvtt/index.html index 774a41a3fc..fcfc456686 100644 --- a/files/pt-pt/glossary/webvtt/index.html +++ b/files/pt-pt/glossary/webvtt/index.html @@ -1,6 +1,6 @@ --- title: WebVTT -slug: Glossário/WebVTT +slug: Glossary/WebVTT tags: - Audio - CodingScripting @@ -9,6 +9,7 @@ tags: - Web - WebVTT translation_of: Glossary/WebVTT +original_slug: Glossário/WebVTT ---

WebVTT (Web Video Text Tracks) (em português Faixas de Texto de Vídeo da Web) é uma especificação {{Glossary("W3C")}} para um formato de ficheiro que marca os recursos da faixa de texto em combinação com o elemento HTML {{HTMLElement("track")}}.

diff --git a/files/pt-pt/glossary/whatwg/index.html b/files/pt-pt/glossary/whatwg/index.html index 9de7c80ab8..7460bb77c4 100644 --- a/files/pt-pt/glossary/whatwg/index.html +++ b/files/pt-pt/glossary/whatwg/index.html @@ -1,6 +1,6 @@ --- title: WHATWG -slug: Glossário/WHATWG +slug: Glossary/WHATWG tags: - Communidade - DOM @@ -11,6 +11,7 @@ tags: - Web - standards translation_of: Glossary/WHATWG +original_slug: Glossário/WHATWG ---

O WHATWG (Web Hypertext Application Technology Working Group) é uma comunidade que mantém e desenvolve padrões web, incluindo {{Glossary("DOM")}}, Fetch, e {{Glossary("HTML")}}. Funcionários da Apple, Mozilla, e Opera estabeleceram o WHATWG em 2004.

diff --git a/files/pt-pt/glossary/world_wide_web/index.html b/files/pt-pt/glossary/world_wide_web/index.html index ee86b296c5..d7b77d6746 100644 --- a/files/pt-pt/glossary/world_wide_web/index.html +++ b/files/pt-pt/glossary/world_wide_web/index.html @@ -1,6 +1,6 @@ --- title: World Wide Web -slug: Glossário/World_Wide_Web +slug: Glossary/World_Wide_Web tags: - Glossário - Infraestrutura @@ -8,6 +8,7 @@ tags: - WWW - World Wide Web translation_of: Glossary/World_Wide_Web +original_slug: Glossário/World_Wide_Web ---

A World Wide Web (Rede Mundial) — comumente conhecido como WWW, W3 ou Web - é um sistema interligado de páginas da Web públicas acessíveis através da {{Glossary('Internet')}}. A Web não é o mesmo que Internet: a Web é uma das muitas aplicações criadas no topo da Internet.

diff --git a/files/pt-pt/glossary/wrapper/index.html b/files/pt-pt/glossary/wrapper/index.html index 534568d817..dbc16d0857 100644 --- a/files/pt-pt/glossary/wrapper/index.html +++ b/files/pt-pt/glossary/wrapper/index.html @@ -1,12 +1,13 @@ --- title: Wrapper -slug: Glossário/Wrapper +slug: Glossary/Wrapper tags: - CodingScripting - Glossary - Glossário - Wrapper translation_of: Glossary/Wrapper +original_slug: Glossário/Wrapper ---

Em linguagem de programação, tal como JavaScript, um wrapper é uma função destinada a chamar uma ou mais outras funções, às vezes apenas por conveniência, e às vezes adaptando-as para executar uma tarefa ligeiramente diferente no processo.

diff --git a/files/pt-pt/glossary/xhtml/index.html b/files/pt-pt/glossary/xhtml/index.html index 26022cfd3a..c2bc963462 100644 --- a/files/pt-pt/glossary/xhtml/index.html +++ b/files/pt-pt/glossary/xhtml/index.html @@ -1,11 +1,12 @@ --- title: XHTML -slug: XHTML +slug: Glossary/XHTML tags: - CodingScripting - Glossário - XHTML translation_of: Glossary/XHTML +original_slug: XHTML ---

HTML pode viajar através da rede para um navegador quer em sintaxe de HTML ou uma sintaxe chamada de XML.

diff --git a/files/pt-pt/glossary/xml/index.html b/files/pt-pt/glossary/xml/index.html index 7f196eb491..c96b2a429b 100644 --- a/files/pt-pt/glossary/xml/index.html +++ b/files/pt-pt/glossary/xml/index.html @@ -1,11 +1,12 @@ --- title: XML -slug: Glossário/XML +slug: Glossary/XML tags: - Glossário - XML - - 'l10n:priority' + - l10n:priority translation_of: Glossary/XML +original_slug: Glossário/XML ---

XML - Linguagem de Marcação Extensível, é uma linguagem de marcação genérica especificada pelo W3C. A indústria de tecnologia de informação (TI) utiliza muitas linguagens com base em XML, tal como as linguagens de descrição de dados.

diff --git a/files/pt-pt/learn/accessibility/index.html b/files/pt-pt/learn/accessibility/index.html index 0b6cbcefd7..ba1b7e42b3 100644 --- a/files/pt-pt/learn/accessibility/index.html +++ b/files/pt-pt/learn/accessibility/index.html @@ -1,6 +1,6 @@ --- title: Acessibilidade -slug: Learn/Acessibilidade +slug: Learn/Accessibility tags: - ARIA - Acessibilidade @@ -14,6 +14,7 @@ tags: - Principiantes - modulo translation_of: Learn/Accessibility +original_slug: Learn/Acessibilidade ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/common_questions/how_does_the_internet_work/index.html b/files/pt-pt/learn/common_questions/how_does_the_internet_work/index.html index d2ba60f9a3..1eddf3b641 100644 --- a/files/pt-pt/learn/common_questions/how_does_the_internet_work/index.html +++ b/files/pt-pt/learn/common_questions/how_does_the_internet_work/index.html @@ -1,11 +1,12 @@ --- title: Como funciona Internet? -slug: Learn/Questoes_comuns/Como_funciona_a_Internet +slug: Learn/Common_questions/How_does_the_Internet_work tags: - Mecânica da Web - Principiante - Tutorial translation_of: Learn/Common_questions/How_does_the_Internet_work +original_slug: Learn/Questoes_comuns/Como_funciona_a_Internet ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/common_questions/index.html b/files/pt-pt/learn/common_questions/index.html index 62deec5d05..23788a5fd7 100644 --- a/files/pt-pt/learn/common_questions/index.html +++ b/files/pt-pt/learn/common_questions/index.html @@ -1,7 +1,8 @@ --- title: Questões Comuns -slug: Learn/Questoes_comuns +slug: Learn/Common_questions translation_of: Learn/Common_questions +original_slug: Learn/Questoes_comuns ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/common_questions/pages_sites_servers_and_search_engines/index.html b/files/pt-pt/learn/common_questions/pages_sites_servers_and_search_engines/index.html index 97655e6edf..ba4db13d68 100644 --- a/files/pt-pt/learn/common_questions/pages_sites_servers_and_search_engines/index.html +++ b/files/pt-pt/learn/common_questions/pages_sites_servers_and_search_engines/index.html @@ -2,12 +2,13 @@ title: >- Qual é a diferença entre página da Web, site da Web, servidor da Web e mecanismo de pesquisa? -slug: >- - Learn/Questoes_comuns/Qual_e_a_diferenca_entre_pagina_site_servidor_da_web_e_mecanismo_pesquisa +slug: Learn/Common_questions/Pages_sites_servers_and_search_engines tags: - Mecânica da Web - Principiante translation_of: Learn/Common_questions/Pages_sites_servers_and_search_engines +original_slug: >- + Learn/Questoes_comuns/Qual_e_a_diferenca_entre_pagina_site_servidor_da_web_e_mecanismo_pesquisa ---

In this article, we describe various web-related concepts: web pages, websites, web servers, and search engines. These terms are often confused by newcomers to the web or are incorrectly used. Let's learn what they each mean!

diff --git a/files/pt-pt/learn/common_questions/set_up_a_local_testing_server/index.html b/files/pt-pt/learn/common_questions/set_up_a_local_testing_server/index.html index 389407247d..33cc5b661e 100644 --- a/files/pt-pt/learn/common_questions/set_up_a_local_testing_server/index.html +++ b/files/pt-pt/learn/common_questions/set_up_a_local_testing_server/index.html @@ -1,6 +1,6 @@ --- title: Como configurar um servidor local de testes? -slug: Learn/Questoes_comuns/Congiurar_um_servidor_de_testes_local +slug: Learn/Common_questions/set_up_a_local_testing_server tags: - Aprender - Nodo @@ -10,6 +10,7 @@ tags: - django - servidores translation_of: Learn/Common_questions/set_up_a_local_testing_server +original_slug: Learn/Questoes_comuns/Congiurar_um_servidor_de_testes_local ---

Este artigo explica como configurar um servidor de testes local simples  na sua máquina, e como o utilizar.

diff --git a/files/pt-pt/learn/common_questions/what_is_a_domain_name/index.html b/files/pt-pt/learn/common_questions/what_is_a_domain_name/index.html index b490ab9789..78aea58546 100644 --- a/files/pt-pt/learn/common_questions/what_is_a_domain_name/index.html +++ b/files/pt-pt/learn/common_questions/what_is_a_domain_name/index.html @@ -1,6 +1,6 @@ --- title: O que é um nome de domíno? -slug: Learn/Questoes_comuns/O_que_e_um_nome_de_dominio +slug: Learn/Common_questions/What_is_a_domain_name tags: - Infraestrutura - Introdução @@ -8,6 +8,7 @@ tags: - Principiante - Web translation_of: Learn/Common_questions/What_is_a_domain_name +original_slug: Learn/Questoes_comuns/O_que_e_um_nome_de_dominio ---

In this article we discuss domain names: what they are, how they are structured, and how to get one.

diff --git a/files/pt-pt/learn/common_questions/what_is_a_url/index.html b/files/pt-pt/learn/common_questions/what_is_a_url/index.html index b61a73433e..c197a3df0a 100644 --- a/files/pt-pt/learn/common_questions/what_is_a_url/index.html +++ b/files/pt-pt/learn/common_questions/what_is_a_url/index.html @@ -1,11 +1,12 @@ --- title: O que é um URL? -slug: Learn/Questoes_comuns/O_que_e_um_URL +slug: Learn/Common_questions/What_is_a_URL tags: - Infraestrutura - Principiante - URL translation_of: Learn/Common_questions/What_is_a_URL +original_slug: Learn/Questoes_comuns/O_que_e_um_URL ---

This article discusses Uniform Resource Locators (URLs), explaining what they are and how they're structured.

diff --git a/files/pt-pt/learn/common_questions/what_is_a_web_server/index.html b/files/pt-pt/learn/common_questions/what_is_a_web_server/index.html index a91ef08d6c..471ef60b06 100644 --- a/files/pt-pt/learn/common_questions/what_is_a_web_server/index.html +++ b/files/pt-pt/learn/common_questions/what_is_a_web_server/index.html @@ -1,10 +1,11 @@ --- title: O que é um servidor da Web? -slug: Learn/Questoes_comuns/O_que_e_um_servidor_da_Web +slug: Learn/Common_questions/What_is_a_web_server tags: - Infraestrutura - Principiante translation_of: Learn/Common_questions/What_is_a_web_server +original_slug: Learn/Questoes_comuns/O_que_e_um_servidor_da_Web ---

Neste artigo, nós examinamos quais são os servidores da Web, como é que estes funcionam, e por que é que eles são importantes.

diff --git a/files/pt-pt/learn/css/building_blocks/cascade_and_inheritance/index.html b/files/pt-pt/learn/css/building_blocks/cascade_and_inheritance/index.html index b73abb297f..a35e695b08 100644 --- a/files/pt-pt/learn/css/building_blocks/cascade_and_inheritance/index.html +++ b/files/pt-pt/learn/css/building_blocks/cascade_and_inheritance/index.html @@ -1,10 +1,11 @@ --- title: Cascata e herança -slug: Web/CSS/Como_começar/Cascata_e_herança +slug: Learn/CSS/Building_blocks/Cascade_and_inheritance tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Building_blocks/Cascade_and_inheritance translation_of_original: Web/Guide/CSS/Getting_started/Cascading_and_inheritance +original_slug: Web/CSS/Como_começar/Cascata_e_herança ---

{{ PreviousNext("CSS:Como começar:Como o CSS trabalha", "CSS:Como começar:Seletores") }}

diff --git a/files/pt-pt/learn/css/building_blocks/index.html b/files/pt-pt/learn/css/building_blocks/index.html index dff3dfb0ac..62d3b77849 100644 --- a/files/pt-pt/learn/css/building_blocks/index.html +++ b/files/pt-pt/learn/css/building_blocks/index.html @@ -1,10 +1,11 @@ --- title: Caixas -slug: Web/CSS/Como_começar/Caixas +slug: Learn/CSS/Building_blocks tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Building_blocks translation_of_original: Web/Guide/CSS/Getting_started/Boxes +original_slug: Web/CSS/Como_começar/Caixas ---

{{ PreviousNext("CSS:Como começar:Listas", "CSS:Como começar:Disposição") }}

diff --git a/files/pt-pt/learn/css/building_blocks/selectors/index.html b/files/pt-pt/learn/css/building_blocks/selectors/index.html index f9d4505614..d10ad5f044 100644 --- a/files/pt-pt/learn/css/building_blocks/selectors/index.html +++ b/files/pt-pt/learn/css/building_blocks/selectors/index.html @@ -1,10 +1,11 @@ --- title: Seletores -slug: Web/CSS/Como_começar/Seletores +slug: Learn/CSS/Building_blocks/Selectors tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Building_blocks/Selectors translation_of_original: Web/Guide/CSS/Getting_started/Selectors +original_slug: Web/CSS/Como_começar/Seletores ---

{{ PreviousNext("CSS:Como começar:Cascata e herança", "CSS:Como começar:CSS legível") }}

diff --git a/files/pt-pt/learn/css/building_blocks/styling_tables/index.html b/files/pt-pt/learn/css/building_blocks/styling_tables/index.html index ff21a00c82..8967f90eb8 100644 --- a/files/pt-pt/learn/css/building_blocks/styling_tables/index.html +++ b/files/pt-pt/learn/css/building_blocks/styling_tables/index.html @@ -1,10 +1,11 @@ --- title: Tabelas -slug: Web/CSS/Como_começar/Tabelas +slug: Learn/CSS/Building_blocks/Styling_tables tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Building_blocks/Styling_tables translation_of_original: Web/Guide/CSS/Getting_started/Tables +original_slug: Web/CSS/Como_começar/Tabelas ---

{{ PreviousNext("CSS:Como começar:Disposição", "CSS:Como começar:Mídia") }}

diff --git a/files/pt-pt/learn/css/building_blocks/values_and_units/index.html b/files/pt-pt/learn/css/building_blocks/values_and_units/index.html index d5c15375d7..1c5855e14c 100644 --- a/files/pt-pt/learn/css/building_blocks/values_and_units/index.html +++ b/files/pt-pt/learn/css/building_blocks/values_and_units/index.html @@ -1,10 +1,11 @@ --- title: Cor -slug: Web/CSS/Como_começar/Cor +slug: Learn/CSS/Building_blocks/Values_and_units tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Introduction_to_CSS/Values_and_units#Colors translation_of_original: Web/Guide/CSS/Getting_started/Color +original_slug: Web/CSS/Como_começar/Cor ---

{{ PreviousNext("CSS:Como começar:Estilos de texto", "CSS:Como começar:Conteúdo") }}

diff --git a/files/pt-pt/learn/css/css_layout/index.html b/files/pt-pt/learn/css/css_layout/index.html index 0612aad9b5..c6eb9caafa 100644 --- a/files/pt-pt/learn/css/css_layout/index.html +++ b/files/pt-pt/learn/css/css_layout/index.html @@ -1,10 +1,11 @@ --- title: Disposição -slug: Web/CSS/Como_começar/Disposição +slug: Learn/CSS/CSS_layout tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/CSS_layout translation_of_original: Web/Guide/CSS/Getting_started/Layout +original_slug: Web/CSS/Como_começar/Disposição ---

{{ PreviousNext("CSS:Como começar:Caixas", "CSS:Como começar:Tabelas") }}

diff --git a/files/pt-pt/learn/css/first_steps/how_css_is_structured/index.html b/files/pt-pt/learn/css/first_steps/how_css_is_structured/index.html index 08ede46aa3..46e7d2db08 100644 --- a/files/pt-pt/learn/css/first_steps/how_css_is_structured/index.html +++ b/files/pt-pt/learn/css/first_steps/how_css_is_structured/index.html @@ -1,10 +1,11 @@ --- title: CSS legível -slug: Web/CSS/Como_começar/CSS_legível +slug: Learn/CSS/First_steps/How_CSS_is_structured tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Introduction_to_CSS/Syntax#Beyond_syntax_make_CSS_readable translation_of_original: Web/Guide/CSS/Getting_started/Readable_CSS +original_slug: Web/CSS/Como_começar/CSS_legível ---

{{ PreviousNext("CSS:Como começar:Seletores", "CSS:Como começar:Estilos de texto") }}

diff --git a/files/pt-pt/learn/css/first_steps/how_css_works/index.html b/files/pt-pt/learn/css/first_steps/how_css_works/index.html index bd667439ff..f73b96a63a 100644 --- a/files/pt-pt/learn/css/first_steps/how_css_works/index.html +++ b/files/pt-pt/learn/css/first_steps/how_css_works/index.html @@ -1,10 +1,11 @@ --- title: Como o CSS trabalha -slug: Web/CSS/Como_começar/Como_o_CSS_trabalha +slug: Learn/CSS/First_steps/How_CSS_works tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/First_steps/How_CSS_works translation_of_original: Web/Guide/CSS/Getting_started/How_CSS_works +original_slug: Web/CSS/Como_começar/Como_o_CSS_trabalha ---

{{ PreviousNext("CSS:Como começar:Porque usar CSS", "CSS:Como começar:Cascata e herança") }}

diff --git a/files/pt-pt/learn/css/first_steps/index.html b/files/pt-pt/learn/css/first_steps/index.html index fa514756bd..bb21186eda 100644 --- a/files/pt-pt/learn/css/first_steps/index.html +++ b/files/pt-pt/learn/css/first_steps/index.html @@ -1,12 +1,13 @@ --- title: Como começar -slug: Web/CSS/Como_começar +slug: Learn/CSS/First_steps tags: - CSS - - 'CSS:Como_começar' + - CSS:Como_começar - Todas_as_Categorias translation_of: Learn/CSS/First_steps translation_of_original: Web/Guide/CSS/Getting_started +original_slug: Web/CSS/Como_começar ---

 

diff --git a/files/pt-pt/learn/css/howto/css_faq/index.html b/files/pt-pt/learn/css/howto/css_faq/index.html index 357e271657..e0e558f33b 100644 --- a/files/pt-pt/learn/css/howto/css_faq/index.html +++ b/files/pt-pt/learn/css/howto/css_faq/index.html @@ -1,6 +1,6 @@ --- title: Perguntas Frequentes sobre CSS -slug: Learn/CSS/Howto/FAQ_de_CSS +slug: Learn/CSS/Howto/CSS_FAQ tags: - CSS - Exemplo @@ -9,6 +9,7 @@ tags: - Web - questões translation_of: Learn/CSS/Howto/CSS_FAQ +original_slug: Learn/CSS/Howto/FAQ_de_CSS ---

Why doesn't my CSS, which is valid, render correctly?

diff --git a/files/pt-pt/learn/css/howto/generated_content/index.html b/files/pt-pt/learn/css/howto/generated_content/index.html index 523c408aad..c9b979f870 100644 --- a/files/pt-pt/learn/css/howto/generated_content/index.html +++ b/files/pt-pt/learn/css/howto/generated_content/index.html @@ -1,9 +1,10 @@ --- title: Conteúdo -slug: Web/CSS/Como_começar/Conteúdo +slug: Learn/CSS/Howto/Generated_content tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Howto/Generated_content +original_slug: Web/CSS/Como_começar/Conteúdo ---

{{ PreviousNext("CSS:Como começar:Cor", "CSS:Como começar:Listas") }}

diff --git a/files/pt-pt/learn/css/styling_text/fundamentals/index.html b/files/pt-pt/learn/css/styling_text/fundamentals/index.html index 373688d00f..d4e2e23478 100644 --- a/files/pt-pt/learn/css/styling_text/fundamentals/index.html +++ b/files/pt-pt/learn/css/styling_text/fundamentals/index.html @@ -1,10 +1,11 @@ --- title: Estilos de texto -slug: Web/CSS/Como_começar/Estilos_de_texto +slug: Learn/CSS/Styling_text/Fundamentals tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Styling_text/Fundamentals translation_of_original: Web/Guide/CSS/Getting_started/Text_styles +original_slug: Web/CSS/Como_começar/Estilos_de_texto ---

{{ PreviousNext("CSS:Como começar:CSS legível", "CSS:Como começar:Cor") }}

diff --git a/files/pt-pt/learn/css/styling_text/index.html b/files/pt-pt/learn/css/styling_text/index.html index 5d00bc90c5..4707ead18c 100644 --- a/files/pt-pt/learn/css/styling_text/index.html +++ b/files/pt-pt/learn/css/styling_text/index.html @@ -1,6 +1,6 @@ --- title: Estilizar texto -slug: Learn/CSS/Estilo_de_texto +slug: Learn/CSS/Styling_text tags: - CSS - Hiperligações @@ -15,6 +15,7 @@ tags: - tipo de letra - tipos de letra da Web translation_of: Learn/CSS/Styling_text +original_slug: Learn/CSS/Estilo_de_texto ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/css/styling_text/styling_lists/index.html b/files/pt-pt/learn/css/styling_text/styling_lists/index.html index cff2108b51..654b8a240e 100644 --- a/files/pt-pt/learn/css/styling_text/styling_lists/index.html +++ b/files/pt-pt/learn/css/styling_text/styling_lists/index.html @@ -1,10 +1,11 @@ --- title: Listas -slug: Web/CSS/Como_começar/Listas +slug: Learn/CSS/Styling_text/Styling_lists tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/CSS/Styling_text/Styling_lists translation_of_original: Web/Guide/CSS/Getting_started/Lists +original_slug: Web/CSS/Como_começar/Listas ---

{{ PreviousNext("CSS:Como começar:Conteúdo", "CSS:Como começar:Caixas") }}

diff --git a/files/pt-pt/learn/getting_started_with_the_web/css_basics/index.html b/files/pt-pt/learn/getting_started_with_the_web/css_basics/index.html index 9b401915f7..066748249a 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/css_basics/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/css_basics/index.html @@ -1,15 +1,16 @@ --- title: CSS - Essencial -slug: Learn/Comecar_com_a_Web/CSS_basico +slug: Learn/Getting_started_with_the_web/CSS_basics tags: - Aprender - Beginner - CSS - CodingScripting - Estilo - - 'I10n:priority' + - I10n:priority - Web translation_of: Learn/Getting_started_with_the_web/CSS_basics +original_slug: Learn/Comecar_com_a_Web/CSS_basico ---
{{LearnSidebar}}
{{PreviousMenuNext("Learn/Comecar_com_a_Web/HTML_basicos", "Learn/Comecar_com_a_Web/Elementar_de_JavaScript", "Learn/Comecar_com_a_Web")}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/dealing_with_files/index.html b/files/pt-pt/learn/getting_started_with_the_web/dealing_with_files/index.html index 6489964938..0c168838bb 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/dealing_with_files/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/dealing_with_files/index.html @@ -1,16 +1,17 @@ --- title: Lidar com ficheiros -slug: Learn/Comecar_com_a_Web/Lidar_com_ficheiros +slug: Learn/Getting_started_with_the_web/Dealing_with_files tags: - Beginner - Ficheiros - Guía - HTML - Programação Scripting - - 'l10n:priority' + - l10n:priority - site da Web - teoria translation_of: Learn/Getting_started_with_the_web/Dealing_with_files +original_slug: Learn/Comecar_com_a_Web/Lidar_com_ficheiros ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/how_the_web_works/index.html b/files/pt-pt/learn/getting_started_with_the_web/how_the_web_works/index.html index 69fe6b79fa..6eaf47b5fc 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/how_the_web_works/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/how_the_web_works/index.html @@ -1,6 +1,6 @@ --- title: Como funciona a Web -slug: Learn/Comecar_com_a_Web/Como_funciona_a_Web +slug: Learn/Getting_started_with_the_web/How_the_Web_works tags: - Aprender - Beginner @@ -11,8 +11,9 @@ tags: - Infraestrutura - Servidor - TCP - - 'l10n:priority' + - l10n:priority translation_of: Learn/Getting_started_with_the_web/How_the_Web_works +original_slug: Learn/Comecar_com_a_Web/Como_funciona_a_Web ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/html_basics/index.html b/files/pt-pt/learn/getting_started_with_the_web/html_basics/index.html index 4601e08092..bad6619e6c 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/html_basics/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/html_basics/index.html @@ -1,14 +1,15 @@ --- title: HTML - Essencial -slug: Learn/Comecar_com_a_Web/HTML_basicos +slug: Learn/Getting_started_with_the_web/HTML_basics tags: - Aprender - CodingScripting - HTML - Principiante - Web - - 'l10n:priority' + - l10n:priority translation_of: Learn/Getting_started_with_the_web/HTML_basics +original_slug: Learn/Comecar_com_a_Web/HTML_basicos ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/index.html b/files/pt-pt/learn/getting_started_with_the_web/index.html index 59a4431592..aff432c058 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/index.html @@ -1,17 +1,18 @@ --- title: Primeiros passos na Web -slug: Learn/Comecar_com_a_Web +slug: Learn/Getting_started_with_the_web tags: - Beginner - CSS - Desenho - Guía - HTML - - 'I10n:priority' + - I10n:priority - Index - publicação - teoria translation_of: Learn/Getting_started_with_the_web +original_slug: Learn/Comecar_com_a_Web ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/installing_basic_software/index.html b/files/pt-pt/learn/getting_started_with_the_web/installing_basic_software/index.html index ebc5ddd3e3..b8ef979dd0 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/installing_basic_software/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/installing_basic_software/index.html @@ -1,6 +1,6 @@ --- title: Instalar software básico -slug: Learn/Comecar_com_a_Web/Installing_basic_software +slug: Learn/Getting_started_with_the_web/Installing_basic_software tags: - Aprender - Beginner @@ -9,8 +9,9 @@ tags: - Mecânicas da Web - Navegador - editor de texto - - 'l10n:priority' + - l10n:priority translation_of: Learn/Getting_started_with_the_web/Installing_basic_software +original_slug: Learn/Comecar_com_a_Web/Installing_basic_software ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/javascript_basics/index.html b/files/pt-pt/learn/getting_started_with_the_web/javascript_basics/index.html index fec3caaf51..8a3efc4ba4 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/javascript_basics/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/javascript_basics/index.html @@ -1,14 +1,15 @@ --- title: JavaScript - Essencial -slug: Learn/Comecar_com_a_Web/Elementar_de_JavaScript +slug: Learn/Getting_started_with_the_web/JavaScript_basics tags: - Aprender - Beginner - CodingScripting - JavaScript - Web - - 'l10n:priority' + - l10n:priority translation_of: Learn/Getting_started_with_the_web/JavaScript_basics +original_slug: Learn/Comecar_com_a_Web/Elementar_de_JavaScript ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/publishing_your_website/index.html b/files/pt-pt/learn/getting_started_with_the_web/publishing_your_website/index.html index 7e99504b95..63299c4e36 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/publishing_your_website/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/publishing_your_website/index.html @@ -1,6 +1,6 @@ --- title: Publicar o seu site na Web -slug: Learn/Comecar_com_a_Web/Publicar_o_seu_site_da_Web +slug: Learn/Getting_started_with_the_web/Publishing_your_website tags: - Aprender - Beginner @@ -12,6 +12,7 @@ tags: - Web - publicar translation_of: Learn/Getting_started_with_the_web/Publishing_your_website +original_slug: Learn/Comecar_com_a_Web/Publicar_o_seu_site_da_Web ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/getting_started_with_the_web/the_web_and_web_standards/index.html b/files/pt-pt/learn/getting_started_with_the_web/the_web_and_web_standards/index.html index 928a960b97..66f62d8178 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/the_web_and_web_standards/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/the_web_and_web_standards/index.html @@ -1,6 +1,6 @@ --- title: A Web e os padrões da Web -slug: Learn/Comecar_com_a_Web/A_web_e_os_padroes_da_web +slug: Learn/Getting_started_with_the_web/The_web_and_web_standards tags: - Aprender - Beginner @@ -9,6 +9,7 @@ tags: - Padrões da Web - Web translation_of: Learn/Getting_started_with_the_web/The_web_and_web_standards +original_slug: Learn/Comecar_com_a_Web/A_web_e_os_padroes_da_web ---

{{learnsidebar}}

diff --git a/files/pt-pt/learn/getting_started_with_the_web/what_will_your_website_look_like/index.html b/files/pt-pt/learn/getting_started_with_the_web/what_will_your_website_look_like/index.html index a5eacc3afa..8ca05fe1cb 100644 --- a/files/pt-pt/learn/getting_started_with_the_web/what_will_your_website_look_like/index.html +++ b/files/pt-pt/learn/getting_started_with_the_web/what_will_your_website_look_like/index.html @@ -1,6 +1,6 @@ --- title: Qual será a aparência do seu site da Web? -slug: Learn/Comecar_com_a_Web/Apresentacao_do_meu_site +slug: Learn/Getting_started_with_the_web/What_will_your_website_look_like tags: - Aprender - Beginner @@ -8,8 +8,9 @@ tags: - Design - Planear - Tipos de Letra - - 'l10n:priority' + - l10n:priority translation_of: Learn/Getting_started_with_the_web/What_will_your_website_look_like +original_slug: Learn/Comecar_com_a_Web/Apresentacao_do_meu_site ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/howto/add_a_hit_map_on_top_of_an_image/index.html b/files/pt-pt/learn/html/howto/add_a_hit_map_on_top_of_an_image/index.html index d70dd147fc..e4bab3053b 100644 --- a/files/pt-pt/learn/html/howto/add_a_hit_map_on_top_of_an_image/index.html +++ b/files/pt-pt/learn/html/howto/add_a_hit_map_on_top_of_an_image/index.html @@ -1,7 +1,8 @@ --- title: Adicionar um mapa de zona clicável numa imagem -slug: Learn/HTML/Como/Adicionar_um_mapa_de_zona_clicavel_numa_imagem +slug: Learn/HTML/Howto/Add_a_hit_map_on_top_of_an_image translation_of: Learn/HTML/Howto/Add_a_hit_map_on_top_of_an_image +original_slug: Learn/HTML/Como/Adicionar_um_mapa_de_zona_clicavel_numa_imagem ---

Aqui, nós explicamos como configurar um mapa de imagens, e algumas desvantagens para considerar primeiro.

diff --git a/files/pt-pt/learn/html/howto/index.html b/files/pt-pt/learn/html/howto/index.html index abbfb425f3..45284b8764 100644 --- a/files/pt-pt/learn/html/howto/index.html +++ b/files/pt-pt/learn/html/howto/index.html @@ -1,10 +1,11 @@ --- title: Utilizar HTML para resolver problemas comuns -slug: Learn/HTML/Como +slug: Learn/HTML/Howto tags: - HTML - Programação Scripting translation_of: Learn/HTML/Howto +original_slug: Learn/HTML/Como ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/advanced_text_formatting/index.html b/files/pt-pt/learn/html/introduction_to_html/advanced_text_formatting/index.html index 882f2eec7b..009c2cb6c0 100644 --- a/files/pt-pt/learn/html/introduction_to_html/advanced_text_formatting/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/advanced_text_formatting/index.html @@ -1,6 +1,6 @@ --- title: Formatação avançada de texto -slug: Learn/HTML/Introducao_ao_HTML/Formatacao_avancada_texto +slug: Learn/HTML/Introduction_to_HTML/Advanced_text_formatting tags: - Aprender - Guía @@ -10,6 +10,7 @@ tags: - abreviatura - semántica translation_of: Learn/HTML/Introduction_to_HTML/Advanced_text_formatting +original_slug: Learn/HTML/Introducao_ao_HTML/Formatacao_avancada_texto ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/creating_hyperlinks/index.html b/files/pt-pt/learn/html/introduction_to_html/creating_hyperlinks/index.html index 502bfda4cf..2e7a228447 100644 --- a/files/pt-pt/learn/html/introduction_to_html/creating_hyperlinks/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/creating_hyperlinks/index.html @@ -1,6 +1,6 @@ --- title: Criar hiperligações -slug: Learn/HTML/Introducao_ao_HTML/Criar_hiperligacoes +slug: Learn/HTML/Introduction_to_HTML/Creating_hyperlinks tags: - Aprender - Guía @@ -11,6 +11,7 @@ tags: - URL - título translation_of: Learn/HTML/Introduction_to_HTML/Creating_hyperlinks +original_slug: Learn/HTML/Introducao_ao_HTML/Criar_hiperligacoes ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/debugging_html/index.html b/files/pt-pt/learn/html/introduction_to_html/debugging_html/index.html index 9515ff4f37..fe3a77d5df 100644 --- a/files/pt-pt/learn/html/introduction_to_html/debugging_html/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/debugging_html/index.html @@ -1,6 +1,6 @@ --- title: Depurar HTML -slug: Learn/HTML/Introducao_ao_HTML/Depurar_HTML +slug: Learn/HTML/Introduction_to_HTML/Debugging_HTML tags: - Depuração - Erro @@ -9,6 +9,7 @@ tags: - Principiante - Validação translation_of: Learn/HTML/Introduction_to_HTML/Debugging_HTML +original_slug: Learn/HTML/Introducao_ao_HTML/Depurar_HTML ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/document_and_website_structure/index.html b/files/pt-pt/learn/html/introduction_to_html/document_and_website_structure/index.html index 059f26a497..06450aaf64 100644 --- a/files/pt-pt/learn/html/introduction_to_html/document_and_website_structure/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/document_and_website_structure/index.html @@ -1,6 +1,6 @@ --- title: "Estrutura do\_documento e do website" -slug: Learn/HTML/Introducao_ao_HTML/Estrutura_documento_website +slug: Learn/HTML/Introduction_to_HTML/Document_and_website_structure tags: - Guía - HTML @@ -9,6 +9,7 @@ tags: - pagina - semántica translation_of: Learn/HTML/Introduction_to_HTML/Document_and_website_structure +original_slug: Learn/HTML/Introducao_ao_HTML/Estrutura_documento_website ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/getting_started/index.html b/files/pt-pt/learn/html/introduction_to_html/getting_started/index.html index 981b23e556..d1aab102ec 100644 --- a/files/pt-pt/learn/html/introduction_to_html/getting_started/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/getting_started/index.html @@ -1,6 +1,6 @@ --- title: Começar com HTML -slug: Learn/HTML/Introducao_ao_HTML/Iniciacao_HTML +slug: Learn/HTML/Introduction_to_HTML/Getting_started tags: - Comentário - Elemento @@ -11,6 +11,7 @@ tags: - espaço em branco - referência de entidade translation_of: Learn/HTML/Introduction_to_HTML/Getting_started +original_slug: Learn/HTML/Introducao_ao_HTML/Iniciacao_HTML ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/index.html b/files/pt-pt/learn/html/introduction_to_html/index.html index 6e2ac788fd..c8a8ecce80 100644 --- a/files/pt-pt/learn/html/introduction_to_html/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/index.html @@ -1,6 +1,6 @@ --- title: Introdução ao HTML -slug: Learn/HTML/Introducao_ao_HTML +slug: Learn/HTML/Introduction_to_HTML tags: - CodingScripting - Estrutura @@ -11,6 +11,7 @@ tags: - head - semántica translation_of: Learn/HTML/Introduction_to_HTML +original_slug: Learn/HTML/Introducao_ao_HTML ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/marking_up_a_letter/index.html b/files/pt-pt/learn/html/introduction_to_html/marking_up_a_letter/index.html index 0545b789e0..e2e987b803 100644 --- a/files/pt-pt/learn/html/introduction_to_html/marking_up_a_letter/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/marking_up_a_letter/index.html @@ -1,6 +1,6 @@ --- title: Demarcar uma carta -slug: Learn/HTML/Introducao_ao_HTML/demarcar_uma_carta +slug: Learn/HTML/Introduction_to_HTML/Marking_up_a_letter tags: - Avaliação - HTML @@ -8,6 +8,7 @@ tags: - Principiante - Texto translation_of: Learn/HTML/Introduction_to_HTML/Marking_up_a_letter +original_slug: Learn/HTML/Introducao_ao_HTML/demarcar_uma_carta ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/structuring_a_page_of_content/index.html b/files/pt-pt/learn/html/introduction_to_html/structuring_a_page_of_content/index.html index 1f6310a395..7efe74d7fd 100644 --- a/files/pt-pt/learn/html/introduction_to_html/structuring_a_page_of_content/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/structuring_a_page_of_content/index.html @@ -1,6 +1,6 @@ --- title: Estruturar uma página de conteúdo -slug: Learn/HTML/Introducao_ao_HTML/Estruturar_pagina_de_conteudo +slug: Learn/HTML/Introduction_to_HTML/Structuring_a_page_of_content tags: - Avaliação - Estrutura @@ -8,6 +8,7 @@ tags: - Principiante - semántica translation_of: Learn/HTML/Introduction_to_HTML/Structuring_a_page_of_content +original_slug: Learn/HTML/Introducao_ao_HTML/Estruturar_pagina_de_conteudo ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/introduction_to_html/the_head_metadata_in_html/index.html b/files/pt-pt/learn/html/introduction_to_html/the_head_metadata_in_html/index.html index 099166b821..8693cf24a5 100644 --- a/files/pt-pt/learn/html/introduction_to_html/the_head_metadata_in_html/index.html +++ b/files/pt-pt/learn/html/introduction_to_html/the_head_metadata_in_html/index.html @@ -1,6 +1,6 @@ --- title: O que está em "head"? Metadados em HTML -slug: Learn/HTML/Introducao_ao_HTML/Os_metadados_de_head_em_HTML +slug: Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML tags: - Guía - HTML @@ -10,6 +10,7 @@ tags: - head - metadados translation_of: Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML +original_slug: Learn/HTML/Introducao_ao_HTML/Os_metadados_de_head_em_HTML ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/multimedia_and_embedding/index.html b/files/pt-pt/learn/html/multimedia_and_embedding/index.html index 724e0ca3f5..a20b442e8e 100644 --- a/files/pt-pt/learn/html/multimedia_and_embedding/index.html +++ b/files/pt-pt/learn/html/multimedia_and_embedding/index.html @@ -1,6 +1,6 @@ --- title: Multimédia e integração -slug: Learn/HTML/Multimedia_e_integracao +slug: Learn/HTML/Multimedia_and_embedding tags: - Aprender - Audio @@ -18,6 +18,7 @@ tags: - iframes - mapas de imagem translation_of: Learn/HTML/Multimedia_and_embedding +original_slug: Learn/HTML/Multimedia_e_integracao ---

{{LearnSidebar}}

diff --git a/files/pt-pt/learn/html/multimedia_and_embedding/mozilla_splash_page/index.html b/files/pt-pt/learn/html/multimedia_and_embedding/mozilla_splash_page/index.html index aad765e97a..23c82ac5c2 100644 --- a/files/pt-pt/learn/html/multimedia_and_embedding/mozilla_splash_page/index.html +++ b/files/pt-pt/learn/html/multimedia_and_embedding/mozilla_splash_page/index.html @@ -1,6 +1,6 @@ --- title: 'Avaliação: Página inicial da Mozilla' -slug: Learn/HTML/Multimedia_and_embedding/Pagina_de_boas_vindas_da_Mozilla +slug: Learn/HTML/Multimedia_and_embedding/Mozilla_splash_page tags: - Avaliação - HTML @@ -14,6 +14,7 @@ tags: - imagem - tamanhos translation_of: Learn/HTML/Multimedia_and_embedding/Mozilla_splash_page +original_slug: Learn/HTML/Multimedia_and_embedding/Pagina_de_boas_vindas_da_Mozilla ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/multimedia_and_embedding/video_and_audio_content/index.html b/files/pt-pt/learn/html/multimedia_and_embedding/video_and_audio_content/index.html index 2ab6414459..e9ef0a8bb2 100644 --- a/files/pt-pt/learn/html/multimedia_and_embedding/video_and_audio_content/index.html +++ b/files/pt-pt/learn/html/multimedia_and_embedding/video_and_audio_content/index.html @@ -1,6 +1,6 @@ --- title: Conteúdo de áudio e vídeo -slug: Learn/HTML/Multimedia_e_integracao/Conteudo_de_audio_e_vídeo +slug: Learn/HTML/Multimedia_and_embedding/Video_and_audio_content tags: - Artigo - Audio @@ -11,6 +11,7 @@ tags: - faixa - legendas translation_of: Learn/HTML/Multimedia_and_embedding/Video_and_audio_content +original_slug: Learn/HTML/Multimedia_e_integracao/Conteudo_de_audio_e_vídeo ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/tables/advanced/index.html b/files/pt-pt/learn/html/tables/advanced/index.html index 79f6bf801b..9aafceacb6 100644 --- a/files/pt-pt/learn/html/tables/advanced/index.html +++ b/files/pt-pt/learn/html/tables/advanced/index.html @@ -1,6 +1,6 @@ --- title: HTML - funcionalidades avançadas de tabela e acessibilidade -slug: Learn/HTML/Tables/Avancada +slug: Learn/HTML/Tables/Advanced tags: - Acessibilidade - Aprender @@ -16,6 +16,7 @@ tags: - legenda - tabela translation_of: Learn/HTML/Tables/Advanced +original_slug: Learn/HTML/Tables/Avancada ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/tables/basics/index.html b/files/pt-pt/learn/html/tables/basics/index.html index 98908322c9..7dac1c7d99 100644 --- a/files/pt-pt/learn/html/tables/basics/index.html +++ b/files/pt-pt/learn/html/tables/basics/index.html @@ -1,6 +1,6 @@ --- title: HTML - o essencial de tabela -slug: Learn/HTML/Tables/Basicos +slug: Learn/HTML/Tables/Basics tags: - Aprender - Artigo @@ -14,6 +14,7 @@ tags: - essencial - tabelas translation_of: Learn/HTML/Tables/Basics +original_slug: Learn/HTML/Tables/Basicos ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/html/tables/structuring_planet_data/index.html b/files/pt-pt/learn/html/tables/structuring_planet_data/index.html index 70fbf3601a..b64ba2d888 100644 --- a/files/pt-pt/learn/html/tables/structuring_planet_data/index.html +++ b/files/pt-pt/learn/html/tables/structuring_planet_data/index.html @@ -1,7 +1,8 @@ --- title: 'Avaliação: Estruturar os dados dos planetas' -slug: Learn/HTML/Tables/Avaliacao_Estruturar_os_dados_dos_planetas +slug: Learn/HTML/Tables/Structuring_planet_data translation_of: Learn/HTML/Tables/Structuring_planet_data +original_slug: Learn/HTML/Tables/Avaliacao_Estruturar_os_dados_dos_planetas ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/javascript/client-side_web_apis/manipulating_documents/index.html b/files/pt-pt/learn/javascript/client-side_web_apis/manipulating_documents/index.html index f752fdbf6c..c45af40a6a 100644 --- a/files/pt-pt/learn/javascript/client-side_web_apis/manipulating_documents/index.html +++ b/files/pt-pt/learn/javascript/client-side_web_apis/manipulating_documents/index.html @@ -1,10 +1,11 @@ --- title: JavaScript -slug: Web/CSS/Como_começar/JavaScript +slug: Learn/JavaScript/Client-side_web_APIs/Manipulating_documents tags: - - 'CSS:Como_começar' + - CSS:Como_começar translation_of: Learn/JavaScript/Client-side_web_APIs/Manipulating_documents translation_of_original: Web/Guide/CSS/Getting_started/JavaScript +original_slug: Web/CSS/Como_começar/JavaScript ---

{{ PreviousNext("CSS:Como começar:Mídia", "CSS:Como começar:XBL bindings") }}

diff --git a/files/pt-pt/learn/javascript/first_steps/index.html b/files/pt-pt/learn/javascript/first_steps/index.html index 02041b3355..c032772810 100644 --- a/files/pt-pt/learn/javascript/first_steps/index.html +++ b/files/pt-pt/learn/javascript/first_steps/index.html @@ -1,6 +1,6 @@ --- title: JavaScript - Os Primeiros Passos -slug: Learn/JavaScript/Primeiros_passos +slug: Learn/JavaScript/First_steps tags: - Artigo - Avaliação @@ -10,10 +10,11 @@ tags: - Operadores - Principiante - Variáveis - - 'l10n:priority' + - l10n:priority - modulo - strings translation_of: Learn/JavaScript/First_steps +original_slug: Learn/JavaScript/Primeiros_passos ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/django/index.html b/files/pt-pt/learn/server-side/django/index.html index 295b1e80b4..fb11f153e5 100644 --- a/files/pt-pt/learn/server-side/django/index.html +++ b/files/pt-pt/learn/server-side/django/index.html @@ -1,6 +1,6 @@ --- title: Framework da Web Django (Python) -slug: Learn/No-servidor/Django +slug: Learn/Server-side/Django tags: - Aprender - CodingScripting @@ -10,6 +10,7 @@ tags: - Python - django translation_of: Learn/Server-side/Django +original_slug: Learn/No-servidor/Django ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/express_nodejs/development_environment/index.html b/files/pt-pt/learn/server-side/express_nodejs/development_environment/index.html index 242d0be946..913c38f450 100644 --- a/files/pt-pt/learn/server-side/express_nodejs/development_environment/index.html +++ b/files/pt-pt/learn/server-side/express_nodejs/development_environment/index.html @@ -1,6 +1,6 @@ --- title: Configurar um meio de desenvolvimento Node -slug: Learn/No-servidor/Express_Nodejs/Configurar_um_meio_de_desenvolvimento_Node +slug: Learn/Server-side/Express_Nodejs/development_environment tags: - Ambiente de desenvolvimento - Aprender @@ -14,6 +14,7 @@ tags: - nodejs - npm translation_of: Learn/Server-side/Express_Nodejs/development_environment +original_slug: Learn/No-servidor/Express_Nodejs/Configurar_um_meio_de_desenvolvimento_Node ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/express_nodejs/index.html b/files/pt-pt/learn/server-side/express_nodejs/index.html index 1c7e7413ec..73e8f51f35 100644 --- a/files/pt-pt/learn/server-side/express_nodejs/index.html +++ b/files/pt-pt/learn/server-side/express_nodejs/index.html @@ -1,6 +1,6 @@ --- title: Framework da Web Express (Node.js/JavaScript) -slug: Learn/No-servidor/Express_Nodejs +slug: Learn/Server-side/Express_Nodejs tags: - Aprender - CodingScripting @@ -14,6 +14,7 @@ tags: - Programação no lado do servidor - node.js translation_of: Learn/Server-side/Express_Nodejs +original_slug: Learn/No-servidor/Express_Nodejs ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/express_nodejs/introduction/index.html b/files/pt-pt/learn/server-side/express_nodejs/introduction/index.html index c39acc6f1d..1524676241 100644 --- a/files/pt-pt/learn/server-side/express_nodejs/introduction/index.html +++ b/files/pt-pt/learn/server-side/express_nodejs/introduction/index.html @@ -1,6 +1,6 @@ --- title: Introdução a Express/Node -slug: Learn/No-servidor/Express_Nodejs/Introduction +slug: Learn/Server-side/Express_Nodejs/Introduction tags: - Aprender - CodingScripting @@ -10,6 +10,7 @@ tags: - lado do servidor - nodejs translation_of: Learn/Server-side/Express_Nodejs/Introduction +original_slug: Learn/No-servidor/Express_Nodejs/Introduction ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/index.html b/files/pt-pt/learn/server-side/index.html index b8cc8d35f7..40460e8235 100644 --- a/files/pt-pt/learn/server-side/index.html +++ b/files/pt-pt/learn/server-side/index.html @@ -1,6 +1,6 @@ --- title: Programação do site da Web no lado do servidor -slug: Learn/No-servidor +slug: Learn/Server-side tags: - Aprender - Código @@ -11,6 +11,7 @@ tags: - Servidor - Tópico translation_of: Learn/Server-side +original_slug: Learn/No-servidor ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/server-side/node_server_without_framework/index.html b/files/pt-pt/learn/server-side/node_server_without_framework/index.html index 85bd786b58..99857fe56b 100644 --- a/files/pt-pt/learn/server-side/node_server_without_framework/index.html +++ b/files/pt-pt/learn/server-side/node_server_without_framework/index.html @@ -1,6 +1,6 @@ --- title: Servidor de Node.js sem uma framework -slug: Learn/No-servidor/Servidor_node_sem_framework +slug: Learn/Server-side/Node_server_without_framework tags: - JavaScript - Nodo @@ -8,6 +8,7 @@ tags: - Servidor - sem estrutura translation_of: Learn/Server-side/Node_server_without_framework +original_slug: Learn/No-servidor/Servidor_node_sem_framework ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/tools_and_testing/cross_browser_testing/accessibility/index.html b/files/pt-pt/learn/tools_and_testing/cross_browser_testing/accessibility/index.html index c50c8854ba..f9199021f8 100644 --- a/files/pt-pt/learn/tools_and_testing/cross_browser_testing/accessibility/index.html +++ b/files/pt-pt/learn/tools_and_testing/cross_browser_testing/accessibility/index.html @@ -1,7 +1,8 @@ --- title: Como tratar de problemas de acessibilidade comuns -slug: Learn/Tools_and_testing/Teste_cruzado_de_navegador/Acessibilidade +slug: Learn/Tools_and_testing/Cross_browser_testing/Accessibility translation_of: Learn/Tools_and_testing/Cross_browser_testing/Accessibility +original_slug: Learn/Tools_and_testing/Teste_cruzado_de_navegador/Acessibilidade ---
{{LearnSidebar}}
diff --git a/files/pt-pt/learn/tools_and_testing/cross_browser_testing/index.html b/files/pt-pt/learn/tools_and_testing/cross_browser_testing/index.html index f788649424..e2e99b740d 100644 --- a/files/pt-pt/learn/tools_and_testing/cross_browser_testing/index.html +++ b/files/pt-pt/learn/tools_and_testing/cross_browser_testing/index.html @@ -1,6 +1,6 @@ --- title: Teste cruzado de navegador -slug: Learn/Tools_and_testing/Teste_cruzado_de_navegador +slug: Learn/Tools_and_testing/Cross_browser_testing tags: - Acessibilidade - Aprender @@ -16,6 +16,7 @@ tags: - cruzado navegador - modulo translation_of: Learn/Tools_and_testing/Cross_browser_testing +original_slug: Learn/Tools_and_testing/Teste_cruzado_de_navegador ---
{{LearnSidebar}}
diff --git a/files/pt-pt/mdn/about/index.html b/files/pt-pt/mdn/about/index.html index 1da67e04e5..7ab1b3740e 100644 --- a/files/pt-pt/mdn/about/index.html +++ b/files/pt-pt/mdn/about/index.html @@ -1,6 +1,6 @@ --- title: Sobre a MDN -slug: MDN/Sobre +slug: MDN/About tags: - Colaboração - Comunidade @@ -10,6 +10,7 @@ tags: - Licenças - Metadados da MDN translation_of: MDN/About +original_slug: MDN/Sobre ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/at_ten/history_of_mdn/index.html b/files/pt-pt/mdn/at_ten/history_of_mdn/index.html index ceaed18d08..8c49815a25 100644 --- a/files/pt-pt/mdn/at_ten/history_of_mdn/index.html +++ b/files/pt-pt/mdn/at_ten/history_of_mdn/index.html @@ -1,10 +1,11 @@ --- title: A História da MDN -slug: MDN_at_ten/Historia_da_MDN +slug: MDN/At_ten/History_of_MDN tags: - História - Metadados MDN translation_of: MDN_at_ten/History_of_MDN +original_slug: MDN_at_ten/Historia_da_MDN ---

In this talk, several contributors of the MDN project look at the past ten years of developer.mozilla.org, and at the decade to come. You will hear the story of different wiki software migrations, how a documentation community was built, and many more highlights of the history of the site. The group then also talks about current challenges and projects the MDN community is working on this year.

diff --git a/files/pt-pt/mdn/at_ten/index.html b/files/pt-pt/mdn/at_ten/index.html index fcd5f5875f..637fb0eb17 100644 --- a/files/pt-pt/mdn/at_ten/index.html +++ b/files/pt-pt/mdn/at_ten/index.html @@ -1,9 +1,10 @@ --- title: 10.º Aniversário da MDN -slug: MDN_at_ten +slug: MDN/At_ten tags: - MDN translation_of: MDN_at_ten +original_slug: MDN_at_ten ---
Celebrar 10 anos de documentação da sua Web.
diff --git a/files/pt-pt/mdn/contribute/howto/convert_code_samples_to_be_live/index.html b/files/pt-pt/mdn/contribute/howto/convert_code_samples_to_be_live/index.html index e0f16cc514..309ae4f848 100644 --- a/files/pt-pt/mdn/contribute/howto/convert_code_samples_to_be_live/index.html +++ b/files/pt-pt/mdn/contribute/howto/convert_code_samples_to_be_live/index.html @@ -1,11 +1,12 @@ --- title: Como converter exemplos de código para ficarem "live" -slug: MDN/Contribute/Howto/Como_converter_exemplos_de_codigo_para_ficarem_live +slug: MDN/Contribute/Howto/Convert_code_samples_to_be_live tags: - Como - Metadados MDN - Principiante translation_of: MDN/Contribute/Howto/Convert_code_samples_to_be_live +original_slug: MDN/Contribute/Howto/Como_converter_exemplos_de_codigo_para_ficarem_live ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/contribute/howto/create_and_edit_pages/index.html b/files/pt-pt/mdn/contribute/howto/create_and_edit_pages/index.html index e4d8572fe3..310334a95a 100644 --- a/files/pt-pt/mdn/contribute/howto/create_and_edit_pages/index.html +++ b/files/pt-pt/mdn/contribute/howto/create_and_edit_pages/index.html @@ -1,12 +1,13 @@ --- title: Como criar e editar páginas -slug: MDN/Contribute/Howto/Criar_e_editar_paginas +slug: MDN/Contribute/Howto/Create_and_edit_pages tags: - Guía - Introdução - MDN Meta - Principiante translation_of: MDN/Contribute/Howto/Create_and_edit_pages +original_slug: MDN/Contribute/Howto/Criar_e_editar_paginas ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/contribute/howto/report_a_problem/index.html b/files/pt-pt/mdn/contribute/howto/report_a_problem/index.html index 764d3fca0c..8145a208c9 100644 --- a/files/pt-pt/mdn/contribute/howto/report_a_problem/index.html +++ b/files/pt-pt/mdn/contribute/howto/report_a_problem/index.html @@ -1,11 +1,12 @@ --- title: Como comunicar um problema na MDN -slug: MDN/Contribute/Howto/Comunicar_um_problema +slug: MDN/Contribute/Howto/Report_a_problem tags: - Como... - Guía - Metadados MDN translation_of: MDN/Contribute/Howto/Report_a_problem +original_slug: MDN/Contribute/Howto/Comunicar_um_problema ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/contribute/howto/tag/index.html b/files/pt-pt/mdn/contribute/howto/tag/index.html index 2d0ca3d1d6..fe8f43b2c0 100644 --- a/files/pt-pt/mdn/contribute/howto/tag/index.html +++ b/files/pt-pt/mdn/contribute/howto/tag/index.html @@ -1,6 +1,6 @@ --- title: Como etiquetar devidamente as páginas -slug: MDN/Contribute/Howto/Etiqueta +slug: MDN/Contribute/Howto/Tag tags: - Como - Glossário @@ -11,6 +11,7 @@ tags: - Tutorial - contribuir translation_of: MDN/Contribute/Howto/Tag +original_slug: MDN/Contribute/Howto/Etiqueta ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/contribute/howto/write_a_new_entry_in_the_glossary/index.html b/files/pt-pt/mdn/contribute/howto/write_a_new_entry_in_the_glossary/index.html index 105853672c..4284498481 100644 --- a/files/pt-pt/mdn/contribute/howto/write_a_new_entry_in_the_glossary/index.html +++ b/files/pt-pt/mdn/contribute/howto/write_a_new_entry_in_the_glossary/index.html @@ -1,12 +1,13 @@ --- title: Como escrever e referenciar uma entrada no glossário -slug: MDN/Contribute/Howto/Como_escrever_uma_nova_entrada_no_Glossario +slug: MDN/Contribute/Howto/Write_a_new_entry_in_the_Glossary tags: - Como... - Glossário - Guia(2) - Metadados da MDN translation_of: MDN/Contribute/Howto/Write_a_new_entry_in_the_Glossary +original_slug: MDN/Contribute/Howto/Como_escrever_uma_nova_entrada_no_Glossario ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/contribute/howto/write_an_api_reference/sidebars/index.html b/files/pt-pt/mdn/contribute/howto/write_an_api_reference/sidebars/index.html index 8e28e33556..63a34dd7fe 100644 --- a/files/pt-pt/mdn/contribute/howto/write_an_api_reference/sidebars/index.html +++ b/files/pt-pt/mdn/contribute/howto/write_an_api_reference/sidebars/index.html @@ -1,6 +1,6 @@ --- title: Barras laterais de referência da API -slug: MDN/Structures/API_references/Barras_laterais_de_referencia_da_API +slug: MDN/Contribute/Howto/Write_an_API_reference/Sidebars tags: - API - Guía @@ -9,6 +9,7 @@ tags: - groupdata - onboarding translation_of: MDN/Structures/API_references/API_reference_sidebars +original_slug: MDN/Structures/API_references/Barras_laterais_de_referencia_da_API ---
{{MDNSidebar}}

Pode incluir uma barra lateral personalizada nas páginas de referência da API para exibir as hiperligações para as 'Interfaces' relacionadas, tutoriais, e outros recursos relevantes, apenas para essa API. Este artigo explica como.

diff --git a/files/pt-pt/mdn/guidelines/conventions_definitions/index.html b/files/pt-pt/mdn/guidelines/conventions_definitions/index.html index f3a57c70c3..67f3fbb27e 100644 --- a/files/pt-pt/mdn/guidelines/conventions_definitions/index.html +++ b/files/pt-pt/mdn/guidelines/conventions_definitions/index.html @@ -1,6 +1,6 @@ --- title: MDN - Convenções e Definições -slug: MDN/Guidelines/Convencoes_definicoes +slug: MDN/Guidelines/Conventions_definitions tags: - Documentação - Guía @@ -8,6 +8,7 @@ tags: - MDN - Metadados MDN translation_of: MDN/Guidelines/Conventions_definitions +original_slug: MDN/Guidelines/Convencoes_definicoes ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/guidelines/does_this_belong_on_mdn/index.html b/files/pt-pt/mdn/guidelines/does_this_belong_on_mdn/index.html index 429ffa389f..dc76b00182 100644 --- a/files/pt-pt/mdn/guidelines/does_this_belong_on_mdn/index.html +++ b/files/pt-pt/mdn/guidelines/does_this_belong_on_mdn/index.html @@ -1,11 +1,12 @@ --- title: Isto pertence aos MDN Web Docs? -slug: MDN/Guidelines/Isto_pertence_a_MDN +slug: MDN/Guidelines/Does_this_belong_on_MDN tags: - Guía - Linhas Diretrizes - Metadados MDN translation_of: MDN/Guidelines/Does_this_belong_on_MDN +original_slug: MDN/Guidelines/Isto_pertence_a_MDN ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/guidelines/writing_style_guide/index.html b/files/pt-pt/mdn/guidelines/writing_style_guide/index.html index fe96ad554e..5cf076f6f5 100644 --- a/files/pt-pt/mdn/guidelines/writing_style_guide/index.html +++ b/files/pt-pt/mdn/guidelines/writing_style_guide/index.html @@ -1,6 +1,6 @@ --- title: Guia de estilo de escrita -slug: MDN/Guidelines/Guia_de_estilo_de_escrita +slug: MDN/Guidelines/Writing_style_guide tags: - Documentação - Guia(2) @@ -8,6 +8,7 @@ tags: - MDN - Metadados MDN translation_of: MDN/Guidelines/Writing_style_guide +original_slug: MDN/Guidelines/Guia_de_estilo_de_escrita ---
{{MDNSidebar}}
diff --git a/files/pt-pt/mdn/structures/live_samples/index.html b/files/pt-pt/mdn/structures/live_samples/index.html index 91295fc37c..1e6380ba9e 100644 --- a/files/pt-pt/mdn/structures/live_samples/index.html +++ b/files/pt-pt/mdn/structures/live_samples/index.html @@ -1,12 +1,13 @@ --- title: Exemplos live -slug: MDN/Structures/Exemplos_live +slug: MDN/Structures/Live_samples tags: - Estruturas - Guia(2) - Intermediário - Metadados MDN translation_of: MDN/Structures/Live_samples +original_slug: MDN/Structures/Exemplos_live ---
{{MDNSidebar}}

Exemplos MDN supports turning sample code displayed in articles into running samples the reader can look at in action. These live samples can include HTML, CSS, and JavaScript in any combination. Note that "live" samples are not interactive; however, they do ensure that the output displayed for a sample matches the code of the sample exactly, because it is actually generated by the code sample.

diff --git a/files/pt-pt/mdn/yari/index.html b/files/pt-pt/mdn/yari/index.html index 3ffc29d8b6..1950f2c849 100644 --- a/files/pt-pt/mdn/yari/index.html +++ b/files/pt-pt/mdn/yari/index.html @@ -1,11 +1,12 @@ --- title: 'Kuma: Plataforma wiki da MDN' -slug: MDN/Kuma +slug: MDN/Yari tags: - Kuma - MDN Meta - Metadados MDN translation_of: MDN/Kuma +original_slug: MDN/Kuma ---
{{MDNSidebar}}{{IncludeSubnav("/pt-PT/docs/MDN")}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html b/files/pt-pt/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html index ecad403ae1..3dfff5adde 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/anatomy_of_a_webextension/index.html @@ -1,9 +1,10 @@ --- title: Anatomia de uma extensão -slug: Mozilla/Add-ons/WebExtensions/Anatomia_de_uma_extensao +slug: Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/Anatomy_of_a_WebExtension +original_slug: Mozilla/Add-ons/WebExtensions/Anatomia_de_uma_extensao ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/api/devtools/panels/index.html b/files/pt-pt/mozilla/add-ons/webextensions/api/devtools/panels/index.html index ebeb53d591..2d7cb8839d 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/api/devtools/panels/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/api/devtools/panels/index.html @@ -1,6 +1,6 @@ --- title: devtools.panels -slug: Mozilla/Add-ons/WebExtensions/API/devtools.panels +slug: Mozilla/Add-ons/WebExtensions/API/devtools/panels tags: - API - Extensões @@ -9,6 +9,7 @@ tags: - Referencia - devtools.panels translation_of: Mozilla/Add-ons/WebExtensions/API/devtools.panels +original_slug: Mozilla/Add-ons/WebExtensions/API/devtools.panels ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/api/storage/index.html b/files/pt-pt/mozilla/add-ons/webextensions/api/storage/index.html index d267faf520..f4551690f3 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/api/storage/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/api/storage/index.html @@ -1,6 +1,6 @@ --- title: Armazenamento -slug: Mozilla/Add-ons/WebExtensions/API/Armazenamento +slug: Mozilla/Add-ons/WebExtensions/API/storage tags: - API - Armazenamento @@ -11,6 +11,7 @@ tags: - Não Padrão - Referencia translation_of: Mozilla/Add-ons/WebExtensions/API/storage +original_slug: Mozilla/Add-ons/WebExtensions/API/Armazenamento ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html b/files/pt-pt/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html index e34a4013d3..839b88a764 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/browser_support_for_javascript_apis/index.html @@ -1,9 +1,10 @@ --- title: Suporte de navegador para as APIs de JavaScript -slug: Mozilla/Add-ons/WebExtensions/Suporte_navegador_APIs_JavaScript +slug: Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/Browser_support_for_JavaScript_APIs +original_slug: Mozilla/Add-ons/WebExtensions/Suporte_navegador_APIs_JavaScript ---

{{AddonSidebar}}

diff --git a/files/pt-pt/mozilla/add-ons/webextensions/content_scripts/index.html b/files/pt-pt/mozilla/add-ons/webextensions/content_scripts/index.html index 51356eed85..13daea5bbf 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/content_scripts/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/content_scripts/index.html @@ -1,9 +1,10 @@ --- title: Scripts de Conteúdo -slug: Mozilla/Add-ons/WebExtensions/Scripts_Conteudo +slug: Mozilla/Add-ons/WebExtensions/Content_scripts tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/Content_scripts +original_slug: Mozilla/Add-ons/WebExtensions/Scripts_Conteudo ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/examples/index.html b/files/pt-pt/mozilla/add-ons/webextensions/examples/index.html index 4a68068c6a..9e00250f9f 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/examples/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/examples/index.html @@ -1,9 +1,10 @@ --- title: Exemplos de extensões -slug: Mozilla/Add-ons/WebExtensions/Exemplos_extensoes +slug: Mozilla/Add-ons/WebExtensions/Examples tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/Examples +original_slug: Mozilla/Add-ons/WebExtensions/Exemplos_extensoes ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html b/files/pt-pt/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html index dc98e7fd37..ac5e8d664e 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/extending_the_developer_tools/index.html @@ -1,7 +1,8 @@ --- title: Extensão das ferramentas de desenvolvimento -slug: Mozilla/Add-ons/WebExtensions/Extensão_das_ferramentas_de_desenvolvimento +slug: Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools translation_of: Mozilla/Add-ons/WebExtensions/Extending_the_developer_tools +original_slug: Mozilla/Add-ons/WebExtensions/Extensão_das_ferramentas_de_desenvolvimento ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/intercept_http_requests/index.html b/files/pt-pt/mozilla/add-ons/webextensions/intercept_http_requests/index.html index b938b514d4..fef2c0534f 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/intercept_http_requests/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/intercept_http_requests/index.html @@ -1,12 +1,13 @@ --- title: Interceptar Pedidos HTTP -slug: Mozilla/Add-ons/WebExtensions/Interceptar_Pedidos_HTTP +slug: Mozilla/Add-ons/WebExtensions/Intercept_HTTP_requests tags: - Add-ons - Como-fazer - Extensões - ExtensõesWeb translation_of: Mozilla/Add-ons/WebExtensions/Intercept_HTTP_requests +original_slug: Mozilla/Add-ons/WebExtensions/Interceptar_Pedidos_HTTP ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/manifest.json/icons/index.html b/files/pt-pt/mozilla/add-ons/webextensions/manifest.json/icons/index.html index c9fd687771..66eb369f78 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/manifest.json/icons/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/manifest.json/icons/index.html @@ -1,11 +1,12 @@ --- title: Ícones (icons) -slug: Mozilla/Add-ons/WebExtensions/manifest.json/icones +slug: Mozilla/Add-ons/WebExtensions/manifest.json/icons tags: - Extensões - Extensões da Web - Extras translation_of: Mozilla/Add-ons/WebExtensions/manifest.json/icons +original_slug: Mozilla/Add-ons/WebExtensions/manifest.json/icones ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/match_patterns/index.html b/files/pt-pt/mozilla/add-ons/webextensions/match_patterns/index.html index 8c0f5e3480..e7330b3010 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/match_patterns/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/match_patterns/index.html @@ -1,7 +1,8 @@ --- title: dubla padrões em extensão manifestos -slug: Mozilla/Add-ons/WebExtensions/dubla_padrões +slug: Mozilla/Add-ons/WebExtensions/Match_patterns translation_of: Mozilla/Add-ons/WebExtensions/Match_patterns +original_slug: Mozilla/Add-ons/WebExtensions/dubla_padrões ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_action/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_action/index.html index c5da78003b..421dffbb28 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_action/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_action/index.html @@ -1,9 +1,10 @@ --- title: Botão da Barra de Ferramentas -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Ação_navegador +slug: Mozilla/Add-ons/WebExtensions/user_interface/Browser_action tags: - Extensão da Web translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Browser_action +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Ação_navegador ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_styles/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_styles/index.html index bc2f1bd2da..233cf4ff31 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_styles/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/browser_styles/index.html @@ -1,11 +1,12 @@ --- title: Estilos de navegador -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Estilos_de_navegador +slug: Mozilla/Add-ons/WebExtensions/user_interface/Browser_styles tags: - Extensões - Extensões da Web - Extras translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Browser_styles +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Estilos_de_navegador ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/context_menu_items/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/context_menu_items/index.html index 231a800bc3..bf69421558 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/context_menu_items/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/context_menu_items/index.html @@ -1,10 +1,11 @@ --- title: Itens do menu de contexto -slug: >- - Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Itens_do_menu_de_contexto +slug: Mozilla/Add-ons/WebExtensions/user_interface/Context_menu_items tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Context_menu_items +original_slug: >- + Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Itens_do_menu_de_contexto ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/devtools_panels/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/devtools_panels/index.html index a2bc9921ad..ffd1b942af 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/devtools_panels/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/devtools_panels/index.html @@ -1,12 +1,13 @@ --- title: Painéis das ferramentas de desenvolvimento -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/devtools_panels +slug: Mozilla/Add-ons/WebExtensions/user_interface/devtools_panels tags: - Extensões da Web - Guía - Interface do Utilizador - Principiante translation_of: Mozilla/Add-ons/WebExtensions/user_interface/devtools_panels +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/devtools_panels ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/extension_pages/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/extension_pages/index.html index 4bf94b9653..bea67ee60c 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/extension_pages/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/extension_pages/index.html @@ -1,7 +1,8 @@ --- title: Páginas de extensão -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Paginas_de_extensão +slug: Mozilla/Add-ons/WebExtensions/user_interface/Extension_pages translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Extension_pages +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Paginas_de_extensão ---
{{AddonSidebar()}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/index.html index 6ec29a7fcf..b18f1afd85 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/index.html @@ -1,11 +1,12 @@ --- title: Interface do utilizador -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador +slug: Mozilla/Add-ons/WebExtensions/user_interface tags: - Interface do Utilizador - Landing - WebExtensions translation_of: Mozilla/Add-ons/WebExtensions/user_interface +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/notifications/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/notifications/index.html index 5b38d4f29f..8c8c113425 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/notifications/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/notifications/index.html @@ -1,9 +1,10 @@ --- title: Notificações -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Notificacoes +slug: Mozilla/Add-ons/WebExtensions/user_interface/Notifications tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Notifications +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Notificacoes ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/omnibox/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/omnibox/index.html index c0f9f41dca..2470a05c32 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/omnibox/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/omnibox/index.html @@ -1,10 +1,11 @@ --- title: Sugestões da barra de endereço -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Omnibox +slug: Mozilla/Add-ons/WebExtensions/user_interface/Omnibox tags: - Extensões da Web - Interface do Utilizador translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Omnibox +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Omnibox ---
{{AddonSidebar()}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/options_pages/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/options_pages/index.html index b3bee11990..d3a560412f 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/options_pages/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/options_pages/index.html @@ -1,9 +1,10 @@ --- title: Página de opções -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Options_pages +slug: Mozilla/Add-ons/WebExtensions/user_interface/Options_pages tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Options_pages +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Options_pages ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/page_actions/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/page_actions/index.html index 7093d3355c..57407bc175 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/page_actions/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/page_actions/index.html @@ -1,10 +1,11 @@ --- title: Botão da barra de endereço -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Acoes_pagina +slug: Mozilla/Add-ons/WebExtensions/user_interface/Page_actions tags: - Extensões da Web - Interface do Utilizador translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Page_actions +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Acoes_pagina ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/popups/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/popups/index.html index 6bbf3f7ce8..043afd3ad5 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/popups/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/popups/index.html @@ -1,6 +1,6 @@ --- title: Janelas (Popups) -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Popups +slug: Mozilla/Add-ons/WebExtensions/user_interface/Popups tags: - Extensions - IU @@ -8,6 +8,7 @@ tags: - Janela - popup translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Popups +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Popups ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/sidebars/index.html b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/sidebars/index.html index 2cfa1800a7..02509b9229 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/user_interface/sidebars/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/user_interface/sidebars/index.html @@ -1,9 +1,10 @@ --- title: Barras laterais -slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Barras_laterais +slug: Mozilla/Add-ons/WebExtensions/user_interface/Sidebars tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/user_interface/Sidebars +original_slug: Mozilla/Add-ons/WebExtensions/interface_do_utilizador/Barras_laterais ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/what_are_webextensions/index.html b/files/pt-pt/mozilla/add-ons/webextensions/what_are_webextensions/index.html index c2d7ef5d71..ada2698b44 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/what_are_webextensions/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/what_are_webextensions/index.html @@ -1,10 +1,11 @@ --- title: O que são extensões? -slug: Mozilla/Add-ons/WebExtensions/O_que_sao_WebExtensions +slug: Mozilla/Add-ons/WebExtensions/What_are_WebExtensions tags: - Extensões - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/What_are_WebExtensions +original_slug: Mozilla/Add-ons/WebExtensions/O_que_sao_WebExtensions ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/what_next_/index.html b/files/pt-pt/mozilla/add-ons/webextensions/what_next_/index.html index f16f7e619b..c4ac2a8348 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/what_next_/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/what_next_/index.html @@ -1,11 +1,12 @@ --- title: E a seguir? -slug: Mozilla/Add-ons/WebExtensions/E_a_seguir +slug: Mozilla/Add-ons/WebExtensions/What_next_ tags: - Extensão da Web - Extensões - Principiante translation_of: Mozilla/Add-ons/WebExtensions/What_next_ +original_slug: Mozilla/Add-ons/WebExtensions/E_a_seguir ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/your_first_webextension/index.html b/files/pt-pt/mozilla/add-ons/webextensions/your_first_webextension/index.html index 21b34f2e2c..2b711124ca 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/your_first_webextension/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/your_first_webextension/index.html @@ -1,10 +1,11 @@ --- title: A sua primeira extensão -slug: Mozilla/Add-ons/WebExtensions/A_sua_primeira_extensao +slug: Mozilla/Add-ons/WebExtensions/Your_first_WebExtension tags: - Extensões da Web - Guía translation_of: Mozilla/Add-ons/WebExtensions/Your_first_WebExtension +original_slug: Mozilla/Add-ons/WebExtensions/A_sua_primeira_extensao ---
{{AddonSidebar}}
diff --git a/files/pt-pt/mozilla/add-ons/webextensions/your_second_webextension/index.html b/files/pt-pt/mozilla/add-ons/webextensions/your_second_webextension/index.html index 503f2b4ae9..9d3c22efac 100644 --- a/files/pt-pt/mozilla/add-ons/webextensions/your_second_webextension/index.html +++ b/files/pt-pt/mozilla/add-ons/webextensions/your_second_webextension/index.html @@ -1,9 +1,10 @@ --- title: A sua segunda extensão -slug: Mozilla/Add-ons/WebExtensions/A_sua_segunda_extensao +slug: Mozilla/Add-ons/WebExtensions/Your_second_WebExtension tags: - Extensões da Web translation_of: Mozilla/Add-ons/WebExtensions/Your_second_WebExtension +original_slug: Mozilla/Add-ons/WebExtensions/A_sua_segunda_extensao ---
{{AddonSidebar}}

Se já leu o artigo da A sua primeira extensão, já tem uma ideia de como escrever uma extensão. Neste artigo, nós iremos escrever uma extensão um pouco mais complexa que demonstra algumas mais das APIs. 
diff --git a/files/pt-pt/mozilla/developer_guide/index.html b/files/pt-pt/mozilla/developer_guide/index.html index 6f7396ce66..80dab6d83f 100644 --- a/files/pt-pt/mozilla/developer_guide/index.html +++ b/files/pt-pt/mozilla/developer_guide/index.html @@ -1,7 +1,8 @@ --- title: Guia do desenvolvedor -slug: Guia_do_desenvolvedor +slug: Mozilla/Developer_guide translation_of: Mozilla/Developer_guide +original_slug: Guia_do_desenvolvedor ---

There are lots of ways to contribute to the Mozilla project: coding, testing, improving the build process and tools, or contributing to the documentation. This guide provides information that will not only help you get started as a Mozilla contributor, but that you'll find useful to refer to even if you are already an experienced contributor.

diff --git a/files/pt-pt/mozilla/firefox/releases/1.5/index.html b/files/pt-pt/mozilla/firefox/releases/1.5/index.html index fdd748fd80..29dab49ca6 100644 --- a/files/pt-pt/mozilla/firefox/releases/1.5/index.html +++ b/files/pt-pt/mozilla/firefox/releases/1.5/index.html @@ -1,7 +1,8 @@ --- title: Firefox 1.5 para Desenvolvedores -slug: Firefox_1.5_para_Desenvolvedores +slug: Mozilla/Firefox/Releases/1.5 translation_of: Mozilla/Firefox/Releases/1.5 +original_slug: Firefox_1.5_para_Desenvolvedores ---
{{FirefoxSidebar}}

 

diff --git a/files/pt-pt/mozilla/firefox/releases/2/index.html b/files/pt-pt/mozilla/firefox/releases/2/index.html index 3701ecfc87..3ba2adba19 100644 --- a/files/pt-pt/mozilla/firefox/releases/2/index.html +++ b/files/pt-pt/mozilla/firefox/releases/2/index.html @@ -1,7 +1,8 @@ --- title: Firefox 2 para desenvolvedores -slug: Firefox_2_para_desenvolvedores +slug: Mozilla/Firefox/Releases/2 translation_of: Mozilla/Firefox/Releases/2 +original_slug: Firefox_2_para_desenvolvedores ---
{{FirefoxSidebar}}

Novas características para desenvolvedores no Firefox 2

diff --git a/files/pt-pt/mozilla/firefox/releases/3.5/index.html b/files/pt-pt/mozilla/firefox/releases/3.5/index.html index ec89c2b039..d175b9cc1c 100644 --- a/files/pt-pt/mozilla/firefox/releases/3.5/index.html +++ b/files/pt-pt/mozilla/firefox/releases/3.5/index.html @@ -1,7 +1,8 @@ --- title: Firefox 3.5 para desenvolvedores -slug: Firefox_3.5_para_desenvolvedores +slug: Mozilla/Firefox/Releases/3.5 translation_of: Mozilla/Firefox/Releases/3.5 +original_slug: Firefox_3.5_para_desenvolvedores ---
{{FirefoxSidebar}}

O Firefox 3.5 introduz várias funcionalidades novas, bem como suporte adicional e melhorado para uma larga variedade de padrões web. Este artigo oferece uma extensa lista, com links para artigos cobrindo as melhorias mais importantes.

Novas funcionalidades para desenvolvedores no Firefox 3.5

diff --git a/files/pt-pt/mozilla/firefox/releases/3.5/updating_extensions/index.html b/files/pt-pt/mozilla/firefox/releases/3.5/updating_extensions/index.html index f1eeef972a..613aa4f667 100644 --- a/files/pt-pt/mozilla/firefox/releases/3.5/updating_extensions/index.html +++ b/files/pt-pt/mozilla/firefox/releases/3.5/updating_extensions/index.html @@ -1,7 +1,8 @@ --- title: Atualizando extensões para o Firefox 3.5 -slug: Atualizando_extensões_para_o_Firefox_3.5 +slug: Mozilla/Firefox/Releases/3.5/Updating_extensions translation_of: Mozilla/Firefox/Releases/3.5/Updating_extensions +original_slug: Atualizando_extensões_para_o_Firefox_3.5 ---
{{FirefoxSidebar}}

{{ fx_minversion_header(3.5) }}

Este artigo proporciona informação útil para desenvolvedores tentando atualizar suas extensões para trabalharem corretamente no Firefox 3.5.

diff --git a/files/pt-pt/mozilla/firefox/releases/3.6/index.html b/files/pt-pt/mozilla/firefox/releases/3.6/index.html index 87e983ee35..1413f08199 100644 --- a/files/pt-pt/mozilla/firefox/releases/3.6/index.html +++ b/files/pt-pt/mozilla/firefox/releases/3.6/index.html @@ -1,7 +1,8 @@ --- title: Firefox 3.6 para desenvolvedores -slug: Firefox_3.6_para_desenvolvedores +slug: Mozilla/Firefox/Releases/3.6 translation_of: Mozilla/Firefox/Releases/3.6 +original_slug: Firefox_3.6_para_desenvolvedores ---