diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.md b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.md index b10b0e86a52a43..297e522eb72a56 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.md @@ -27,18 +27,18 @@ Object.getOwnPropertyNames(obj) ### Usando `Object.getOwnPropertyNames()` ```js -var arr = ['a', 'b', 'c']; +var arr = ["a", "b", "c"]; console.log(Object.getOwnPropertyNames(arr).sort()); // logs ["0", "1", "2", "length"] // Array-like object -var obj = { 0: 'a', 1: 'b', 2: 'c' }; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.getOwnPropertyNames(obj).sort()); // logs ["0", "1", "2"] // Logging property names and values using Array.forEach -Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) { - console.log(val + ' -> ' + obj[val]); +Object.getOwnPropertyNames(obj).forEach(function (val, idx, array) { + console.log(val + " -> " + obj[val]); }); // logs // 0 -> a @@ -46,12 +46,17 @@ Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) { // 2 -> c // non-enumerable property -var my_obj = Object.create({}, { - getFoo: { - value: function() { return this.foo; }, - enumerable: false - } -}); +var my_obj = Object.create( + {}, + { + getFoo: { + value: function () { + return this.foo; + }, + enumerable: false, + }, + }, +); my_obj.foo = 1; console.log(Object.getOwnPropertyNames(my_obj).sort()); @@ -64,19 +69,19 @@ Se voce quer somente as propriedades enumeráveis, veja {{jsxref("Object.keys()" ```js function ParentClass() {} -ParentClass.prototype.inheritedMethod = function() {}; +ParentClass.prototype.inheritedMethod = function () {}; function ChildClass() { this.prop = 5; - this.method = function() {}; + this.method = function () {}; } -ChildClass.prototype = new ParentClass; -ChildClass.prototype.prototypeMethod = function() {}; +ChildClass.prototype = new ParentClass(); +ChildClass.prototype.prototypeMethod = function () {}; console.log( Object.getOwnPropertyNames( - new ChildClass() // ["prop", "method"] - ) + new ChildClass(), // ["prop", "method"] + ), ); ``` @@ -88,7 +93,7 @@ Isto usa a função {{jsxref("Array.prototype.filter()")}} para remover as chave var target = myObject; var enum_and_nonenum = Object.getOwnPropertyNames(target); var enum_only = Object.keys(target); -var nonenum_only = enum_and_nonenum.filter(function(key) { +var nonenum_only = enum_and_nonenum.filter(function (key) { var indexInEnum = enum_only.indexOf(key); if (indexInEnum == -1) { // not found in enum_only keys mean the key is non-enumerable, @@ -107,19 +112,19 @@ console.log(nonenum_only); No ES5, se o argumento desse método não é um objeto (um tipo primitivo), então isso causará um {{jsxref("TypeError")}}. No ES6, um argumento diferente de objeto será transformado em um objeto. ```js -Object.getOwnPropertyNames('foo'); +Object.getOwnPropertyNames("foo"); // TypeError: "foo" is not an object (ES5 code) -Object.getOwnPropertyNames('foo'); +Object.getOwnPropertyNames("foo"); // ["0", "1", "2", "length"] (ES6 code) ``` ## Especificações -| Esperificação | Status | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.4', 'Object.getOwnPropertyNames')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.5. | -| {{SpecName('ES6', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}} | {{Spec2('ES6')}} | | +| Esperificação | Status | Comentário | +| ---------------------------------------------------------------------------------------- | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.4', 'Object.getOwnPropertyNames')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.5. | +| {{SpecName('ES6', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md index e260dd0b64a8c8..d7badadb7075d4 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.md @@ -12,7 +12,7 @@ O **`Object.getOwnPropertySymbols()`** método retorna uma array com todas propr ## Sintaxe ```js -Object.getOwnPropertySymbols(obj) +Object.getOwnPropertySymbols(obj); ``` ### Parâmetro @@ -36,23 +36,23 @@ Como todos os objetos não possuem símbolos próprios inicialmente, o `Object.g ```js var obj = {}; -var a = Symbol('a'); -var b = Symbol.for('b'); +var a = Symbol("a"); +var b = Symbol.for("b"); -obj[a] = 'localSymbol'; -obj[b] = 'globalSymbol'; +obj[a] = "localSymbol"; +obj[b] = "globalSymbol"; var objectSymbols = Object.getOwnPropertySymbols(obj); console.log(objectSymbols.length); // retorno esperado 2 -console.log(objectSymbols); // retorno esperado (2) [Symbol(a), Symbol(b)] -console.log(objectSymbols[0]); // retorno esperado Symbol(a) +console.log(objectSymbols); // retorno esperado (2) [Symbol(a), Symbol(b)] +console.log(objectSymbols[0]); // retorno esperado Symbol(a) ``` ## Especificações -| Especificação | -| ---------------------------------------------------------------------------------------------------------------------------- | +| Especificação | +| -------------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-object.getownpropertysymbols', 'Object.getOwnPropertySymbols')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.md b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.md index 4effa676c66458..6146c05223363c 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.md @@ -39,10 +39,10 @@ Object.getPrototypeOf("foo"); ## Especificação -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------ | ------------------------ | ------------------ | -| {{SpecName('ES5.1', '#sec-15.2.3.2', 'Object.getPrototypeOf')}} | {{Spec2('ES5.1')}} | definição inicial. | -| {{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ------------------------------------------------------------------------- | ------------------ | ------------------ | +| {{SpecName('ES5.1', '#sec-15.2.3.2', 'Object.getPrototypeOf')}} | {{Spec2('ES5.1')}} | definição inicial. | +| {{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.md b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.md index 941e7aa656f33c..76defdfb4f87b5 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.md @@ -61,10 +61,10 @@ O seguinte exemplo diferencia entre propriedade diretas e propriedade herdadas d ```js o = new Object(); -o.prop = 'existe'; -o.hasOwnProperty('prop'); // Retorna true -o.hasOwnProperty('toString'); // Retorna false -o.hasOwnProperty('hasOwnProperty'); // Retorna false +o.prop = "existe"; +o.hasOwnProperty("prop"); // Retorna true +o.hasOwnProperty("toString"); // Retorna false +o.hasOwnProperty("hasOwnProperty"); // Retorna false ``` ### Percorrer através das propriedades de um objeto @@ -75,16 +75,15 @@ Vale observar que o loop {{jsxref("Statements/for...in", "for...in")}} percorre ```js var buz = { - fog: 'stack' + fog: "stack", }; for (var nome in buz) { - if (buz.hasOwnProperty(nome)) { - alert("this is fog (" + nome + ") for sure. Value: " + buz[nome]); - } - else { - alert(nome); // toString ou qualquer outra coisa - } + if (buz.hasOwnProperty(nome)) { + alert("this is fog (" + nome + ") for sure. Value: " + buz[nome]); + } else { + alert(nome); // toString ou qualquer outra coisa + } } ``` @@ -94,30 +93,30 @@ JavaScript não protege o nome `hasOwnProperty`, assim, se existir a possibilida ```js var foo = { - hasOwnProperty: function() { - return false; - }, - bar: 'Here be dragons' + hasOwnProperty: function () { + return false; + }, + bar: "Here be dragons", }; -foo.hasOwnProperty('bar'); // Sempre retorna false +foo.hasOwnProperty("bar"); // Sempre retorna false // Usando a propriedade hasOwnProperty de outro objeto e definindo 'this' como foo -({}).hasOwnProperty.call(foo, 'bar'); // true +({}).hasOwnProperty.call(foo, "bar"); // true // Também é possível usar hasOwnProperty do objeto -Object.prototype.hasOwnProperty.call(foo, 'bar'); // true +Object.prototype.hasOwnProperty.call(foo, "bar"); // true ``` Observe que neste ultimo caso nenhum novo objeto é criado. ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ------------------ | -| ECMAScript 3rd Edition. Implemented in JavaScript 1.5 | Standard | Definição inicial. | -| {{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------------------------- | ------------------ | ------------------ | +| ECMAScript 3rd Edition. Implemented in JavaScript 1.5 | Standard | Definição inicial. | +| {{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/index.md b/files/pt-br/web/javascript/reference/global_objects/object/index.md index af6d9e1f596cde..9f29cc2e52eeb6 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/index.md @@ -134,11 +134,11 @@ var o = new Object(Boolean()); ## Especificações -| Especificações | Status | Comentário | -| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.0. | -| {{SpecName('ES5.1', '#sec-15.2', 'Object')}} | {{Spec2('ES5.1')}} | ------------------------------------------------ | -| {{SpecName('ES6', '#sec-object-objects', 'Object')}} | {{Spec2('ES6')}} | Adicionado `Object.assign`, `Object.getOwnPropertySymbols`, `Object.setPrototypeOf` e `Object.is` | +| Especificações | Status | Comentário | +| -------------------------------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.2', 'Object')}} | {{Spec2('ES5.1')}} | ------------------------------------------------ | +| {{SpecName('ES6', '#sec-object-objects', 'Object')}} | {{Spec2('ES6')}} | Adicionado `Object.assign`, `Object.getOwnPropertySymbols`, `Object.setPrototypeOf` e `Object.is` | | {{SpecName('ESDraft', '#sec-object-objects', 'Object')}} | {{Spec2('ESDraft')}} | Adicionado `Object.entries`, `Object.values` e `Object.getOwnPropertyDescriptors`. | ## Compatibilidade diff --git a/files/pt-br/web/javascript/reference/global_objects/object/is/index.md b/files/pt-br/web/javascript/reference/global_objects/object/is/index.md index 995f3de7b0b6f3..3a4af225f5e39a 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/is/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/is/index.md @@ -47,21 +47,21 @@ Isso também _não_ _é_ o mesmo que ser igual de acordo com o operador {{jsxref ## Exemplos ```js -Object.is('foo', 'foo'); // true -Object.is(window, window); // true +Object.is("foo", "foo"); // true +Object.is(window, window); // true -Object.is('foo', 'bar'); // false -Object.is([], []); // false +Object.is("foo", "bar"); // false +Object.is([], []); // false var test = { a: 1 }; -Object.is(test, test); // true +Object.is(test, test); // true -Object.is(null, null); // true +Object.is(null, null); // true // Casos especiais -Object.is(0, -0); // false -Object.is(-0, -0); // true -Object.is(NaN, 0/0); // true +Object.is(0, -0); // false +Object.is(-0, -0); // true +Object.is(NaN, 0 / 0); // true ``` ## Polyfill para navegadores que não suportam ES6 @@ -70,9 +70,10 @@ Object.is(NaN, 0/0); // true ```js if (!Object.is) { - Object.is = function(x, y) { + Object.is = function (x, y) { // Algoritmo para verificar se os valores sao iguais - if (x === y) { // Passos 1-5, 7-10 + if (x === y) { + // Passos 1-5, 7-10 // Passos 6.b-6.e: +0 != -0 return x !== 0 || 1 / x === 1 / y; } else { @@ -85,9 +86,9 @@ if (!Object.is) { ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------ | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-object.is', 'Object.is')}} | {{Spec2('ES6')}} | Definição inicial. | +| Especificação | Status | Comentário | +| ------------------------------------------------------ | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-object.is', 'Object.is')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-object.is', 'Object.is')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.md b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.md index 2bcd92267959bc..32559aec143fa7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.md @@ -62,10 +62,10 @@ Object.isExtensible(1); ## Especificações -| Especificações | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.13', 'Object.isExtensible')}} | {{Spec2('ES5.1')}} | Initial definition. Implemented in JavaScript 1.8.5. | -| {{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}} | {{Spec2('ES6')}} | | +| Especificações | Status | Comentário | +| -------------------------------------------------------------------------- | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.13', 'Object.isExtensible')}} | {{Spec2('ES5.1')}} | Initial definition. Implemented in JavaScript 1.8.5. | +| {{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.isextensible', 'Object.isExtensible')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.md b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.md index 0f0ae80f2bcb0a..34d55385bebcb7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.md @@ -57,46 +57,50 @@ Object.isFrozen(oneProp); // === true // Um objeto não extensível e não modificável, // mas com uma propriedade configurável não será frozen. -var nonWritable = { e: 'plep' }; +var nonWritable = { e: "plep" }; Object.preventExtensions(nonWritable); -Object.defineProperty(nonWritable, 'e', { - writable: false +Object.defineProperty(nonWritable, "e", { + writable: false, }); // tornar não modificável Object.isFrozen(nonWritable); // === false // Alterando a propriedade para não configurável // tornará o objeto frozen. -Object.defineProperty(nonWritable, 'e', { - configurable: false +Object.defineProperty(nonWritable, "e", { + configurable: false, }); // make non-configurable Object.isFrozen(nonWritable); // === true // Um objeto não extensível com uma propriedade não configurável // mas modificável não será frozen. -var nonConfigurable = { release: 'the kraken!' }; +var nonConfigurable = { release: "the kraken!" }; Object.preventExtensions(nonConfigurable); -Object.defineProperty(nonConfigurable, 'release', { - configurable: false +Object.defineProperty(nonConfigurable, "release", { + configurable: false, }); Object.isFrozen(nonConfigurable); // === false // Alterando a propriedade para não modificável // tornará o objeto frozen. -Object.defineProperty(nonConfigurable, 'release', { - writable: false +Object.defineProperty(nonConfigurable, "release", { + writable: false, }); Object.isFrozen(nonConfigurable); // === true // Um objeto não extensível com um assessor de propriedade // configurável não será frozen. -var accessor = { get food() { return 'yum'; } }; +var accessor = { + get food() { + return "yum"; + }, +}; Object.preventExtensions(accessor); Object.isFrozen(accessor); // === false // ...Mas alterando essa propriedade para não configurável // o objeto se tornará frozen. -Object.defineProperty(accessor, 'food', { - configurable: false +Object.defineProperty(accessor, "food", { + configurable: false, }); Object.isFrozen(accessor); // === true @@ -128,10 +132,10 @@ Object.isFrozen(1); ## Specifications -| Specification | Status | Comment | -| ---------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.12', 'Object.isFrozen')}} | {{Spec2('ES5.1')}} | Initial definition. Implemented in JavaScript 1.8.5. | -| {{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}} | {{Spec2('ES6')}} | | +| Specification | Status | Comment | +| ------------------------------------------------------------------ | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.12', 'Object.isFrozen')}} | {{Spec2('ES5.1')}} | Initial definition. Implemented in JavaScript 1.8.5. | +| {{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.isfrozen', 'Object.isFrozen')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.md b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.md index 58024040b8291a..8271f11e5bc2e4 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.md @@ -57,13 +57,13 @@ const baz = new Baz(); // foo: Foo <- Object // bar: Bar <- Foo <- Object // baz: Baz <- Bar <- Foo <- Object -console.log(Baz.prototype.isPrototypeOf(baz)); // true -console.log(Baz.prototype.isPrototypeOf(bar)); // false -console.log(Baz.prototype.isPrototypeOf(foo)); // false -console.log(Bar.prototype.isPrototypeOf(baz)); // true -console.log(Bar.prototype.isPrototypeOf(foo)); // false -console.log(Foo.prototype.isPrototypeOf(baz)); // true -console.log(Foo.prototype.isPrototypeOf(bar)); // true +console.log(Baz.prototype.isPrototypeOf(baz)); // true +console.log(Baz.prototype.isPrototypeOf(bar)); // false +console.log(Baz.prototype.isPrototypeOf(foo)); // false +console.log(Bar.prototype.isPrototypeOf(baz)); // true +console.log(Bar.prototype.isPrototypeOf(foo)); // false +console.log(Foo.prototype.isPrototypeOf(baz)); // true +console.log(Foo.prototype.isPrototypeOf(bar)); // true console.log(Object.prototype.isPrototypeOf(baz)); // true ``` @@ -79,11 +79,11 @@ if (Foo.prototype.isPrototypeOf(baz)) { ## Specificações -| Especificação | Status | Comment | -| -------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Initial definition. | -| {{SpecName('ES5.1', '#sec-15.2.4.6', 'Object.prototype.isPrototypeOf')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comment | +| ------------------------------------------------------------------------------------------------ | -------------------- | ------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Initial definition. | +| {{SpecName('ES5.1', '#sec-15.2.4.6', 'Object.prototype.isPrototypeOf')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.md b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.md index fded9bed1bc9a4..16d46db18295f5 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.md @@ -42,14 +42,14 @@ Object.isSealed(empty); // === true // O mesmo não é verdadeiro em um objeto "não vazio", // a não ser que todas as suas propriedades sejam "não configuráveis". -var hasProp = { fee: 'fie foe fum' }; +var hasProp = { fee: "fie foe fum" }; Object.preventExtensions(hasProp); Object.isSealed(hasProp); // === false // Mas torne-os todos "não configuráveis" // e o objeto se tornará selado. -Object.defineProperty(hasProp, 'fee', { - configurable: false +Object.defineProperty(hasProp, "fee", { + configurable: false, }); Object.isSealed(hasProp); // === true @@ -71,7 +71,11 @@ var s2 = Object.seal({ p: 3 }); Object.isFrozen(s2); // === false // ('p' continua "escrevível") -var s3 = Object.seal({ get p() { return 0; } }); +var s3 = Object.seal({ + get p() { + return 0; + }, +}); Object.isFrozen(s3); // === true // (somente a configurabilidade importa nos assessores de propriedade) ``` @@ -90,10 +94,10 @@ Object.isSealed(1); ## Especificações -| Especificação | Estado | Comentário | -| ---------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.11', 'Object.isSealed')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.5. | -| {{SpecName('ES6', '#sec-object.issealed', 'Object.isSealed')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentário | +| ------------------------------------------------------------------ | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.11', 'Object.isSealed')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.5. | +| {{SpecName('ES6', '#sec-object.issealed', 'Object.isSealed')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.issealed', 'Object.isSealed')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/keys/index.md b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.md index 150f3740062672..e1ec3a5c8a3517 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/keys/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.md @@ -25,19 +25,28 @@ Object.keys(obj) ## Exemplos ```js -var arr = ['a', 'b', 'c']; +var arr = ["a", "b", "c"]; console.log(Object.keys(arr)); // console: ['0', '1', '2'] // array com objeto -var obj = { 0: 'a', 1: 'b', 2: 'c' }; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.keys(obj)); // console: ['0', '1', '2'] // array como objeto com ordenação aleatória por chave -var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; +var an_obj = { 100: "a", 2: "b", 7: "c" }; console.log(Object.keys(an_obj)); // console: ['2', '7', '100'] // getFoo é uma propriedade que não é enumerável -var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } }); +var my_obj = Object.create( + {}, + { + getFoo: { + value: function () { + return this.foo; + }, + }, + }, +); my_obj.foo = 1; console.log(Object.keys(my_obj)); // console: ['foo'] @@ -64,27 +73,32 @@ Para adicionar suporte Object.keys compatíveis em ambientes mais antigos que n ```js // De https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/keys if (!Object.keys) { - Object.keys = (function() { - 'use strict'; + Object.keys = (function () { + "use strict"; var hasOwnProperty = Object.prototype.hasOwnProperty, - hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'), - dontEnums = [ - 'toString', - 'toLocaleString', - 'valueOf', - 'hasOwnProperty', - 'isPrototypeOf', - 'propertyIsEnumerable', - 'constructor' - ], - dontEnumsLength = dontEnums.length; - - return function(obj) { - if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) { - throw new TypeError('Object.keys chamado de non-object'); + hasDontEnumBug = !{ toString: null }.propertyIsEnumerable("toString"), + dontEnums = [ + "toString", + "toLocaleString", + "valueOf", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "constructor", + ], + dontEnumsLength = dontEnums.length; + + return function (obj) { + if ( + typeof obj !== "object" && + (typeof obj !== "function" || obj === null) + ) { + throw new TypeError("Object.keys chamado de non-object"); } - var result = [], prop, i; + var result = [], + prop, + i; for (prop in obj) { if (hasOwnProperty.call(obj, prop)) { @@ -101,7 +115,7 @@ if (!Object.keys) { } return result; }; - }()); + })(); } ``` @@ -111,9 +125,9 @@ Para um simples Browser Polyfill, veja [Javascript - Object.keys Browser Compati ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------- | ------------------------ | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.14', 'Object.keys')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado em JavaScript 1.8.5. | +| Especificação | Status | Comentário | +| --------------------------------------------------------- | ------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.14', 'Object.keys')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado em JavaScript 1.8.5. | | {{SpecName('ES2015', '#sec-object.keys', 'Object.keys')}} | {{Spec2('ES2015')}} | | ## Browser compatibilidade diff --git a/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.md b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.md index 2b468a7fd8660d..deac47ff18dade 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.md @@ -51,16 +51,16 @@ Object.isExtensible(empty); // === falso // uma nova propriedade a um objeto não-extensível. var nonExtensible = { removable: true }; Object.preventExtensions(nonExtensible); -Object.defineProperty(nonExtensible, 'new', { - value: 8675309 +Object.defineProperty(nonExtensible, "new", { + value: 8675309, }); // lança um TypeError // No modo restrito, tentar adicionar novas propriedades a // um objeto não-extensível lança um TypeError. function fail() { - 'use strict'; + "use strict"; // lança um TypeError - nonExtensible.newProperty = 'FAIL'; + nonExtensible.newProperty = "FAIL"; } fail(); ``` @@ -70,7 +70,7 @@ O protótipo não-extensível de um objeto é imutável: ```js var fixed = Object.preventExtensions({}); // lança um 'TypeError'. -fixed.__proto__ = { oh: 'hai' }; +fixed.__proto__ = { oh: "hai" }; ``` ## Notas @@ -87,10 +87,10 @@ Object.preventExtensions(1); ## Especificações -| Specification | Status | Comment | -| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.10', 'Object.preventExtensions')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado em JavaScript 1.8.5. | -| {{SpecName('ES6', '#sec-object.preventextensions', 'Object.preventExtensions')}} | {{Spec2('ES6')}} | | +| Specification | Status | Comment | +| ------------------------------------------------------------------------------------ | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.10', 'Object.preventExtensions')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado em JavaScript 1.8.5. | +| {{SpecName('ES6', '#sec-object.preventextensions', 'Object.preventExtensions')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.preventextensions', 'Object.preventExtensions')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.md b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.md index 017e6e1c2e1bc0..b2c58c8c24ae80 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.md @@ -37,11 +37,11 @@ O exemplos a seguir mostram o uso de `propertyIsEnumerable` em um objeto e um ar ```js var o = {}; var a = []; -o.prop = 'is enumerable'; -a[0] = 'is enumerable'; +o.prop = "is enumerable"; +a[0] = "is enumerable"; -o.propertyIsEnumerable('prop'); // returns true -a.propertyIsEnumerable(0); // returns true +o.propertyIsEnumerable("prop"); // returns true +a.propertyIsEnumerable(0); // returns true ``` ### Objetos User-defined vs. built-in @@ -49,57 +49,59 @@ a.propertyIsEnumerable(0); // returns true Os exemplos a seguir demostram a enumerabilidade da propriedade user-defined vs. built-in : ```js -var a = ['is enumerable']; +var a = ["is enumerable"]; -a.propertyIsEnumerable(0); // returns true -a.propertyIsEnumerable('length'); // returns false +a.propertyIsEnumerable(0); // returns true +a.propertyIsEnumerable("length"); // returns false -Math.propertyIsEnumerable('random'); // returns false -this.propertyIsEnumerable('Math'); // returns false +Math.propertyIsEnumerable("random"); // returns false +this.propertyIsEnumerable("Math"); // returns false ``` ### Propriedade Direct vs. inherited ```js var a = []; -a.propertyIsEnumerable('constructor'); // returns false +a.propertyIsEnumerable("constructor"); // returns false function firstConstructor() { - this.property = 'is not enumerable'; + this.property = "is not enumerable"; } -firstConstructor.prototype.firstMethod = function() {}; +firstConstructor.prototype.firstMethod = function () {}; function secondConstructor() { - this.method = function() { return 'is enumerable'; }; + this.method = function () { + return "is enumerable"; + }; } -secondConstructor.prototype = new firstConstructor; +secondConstructor.prototype = new firstConstructor(); secondConstructor.prototype.constructor = secondConstructor; var o = new secondConstructor(); -o.arbitraryProperty = 'is enumerable'; +o.arbitraryProperty = "is enumerable"; -o.propertyIsEnumerable('arbitraryProperty'); // returns true -o.propertyIsEnumerable('method'); // returns true -o.propertyIsEnumerable('property'); // returns false +o.propertyIsEnumerable("arbitraryProperty"); // returns true +o.propertyIsEnumerable("method"); // returns true +o.propertyIsEnumerable("property"); // returns false -o.property = 'is enumerable'; +o.property = "is enumerable"; -o.propertyIsEnumerable('property'); // returns true +o.propertyIsEnumerable("property"); // returns true // These return false as they are on the prototype which // propertyIsEnumerable does not consider (even though the last two // are iteratable with for-in) -o.propertyIsEnumerable('prototype'); // returns false (as of JS 1.8.1/FF3.6) -o.propertyIsEnumerable('constructor'); // returns false -o.propertyIsEnumerable('firstMethod'); // returns false +o.propertyIsEnumerable("prototype"); // returns false (as of JS 1.8.1/FF3.6) +o.propertyIsEnumerable("constructor"); // returns false +o.propertyIsEnumerable("firstMethod"); // returns false ``` ## Especificações -| Specification | -| ---------------------------------------------------------------------------------------------------------------------------------------------------- | +| Specification | +| -------------------------------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-object.prototype.propertyisenumerable', 'Object.prototype.propertyIsEnumerable')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/proto/index.md b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.md index 45682e7f4520ba..284da3504ab2a2 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/proto/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.md @@ -30,68 +30,60 @@ console.log(shape.__proto__ === circle); // true ``` ```js -var shape = function () { -}; +var shape = function () {}; var p = { - a: function () { - console.log('aaa'); - } + a: function () { + console.log("aaa"); + }, }; shape.prototype.__proto__ = p; var circle = new shape(); -circle.a();//aaa +circle.a(); //aaa -console.log(shape.prototype === circle.__proto__);//true +console.log(shape.prototype === circle.__proto__); //true //ou -var shape = function () { -}; +var shape = function () {}; var p = { - a: function () { - console.log('a'); - } + a: function () { + console.log("a"); + }, }; var circle = new shape(); circle.__proto__ = p; - circle.a(); // a -console.log(shape.prototype === circle.__proto__);//false +console.log(shape.prototype === circle.__proto__); //false //ou -function test() { -} +function test() {} test.prototype.myname = function () { - console.log('myname'); - -} -var a = new test() - -console.log(a.__proto__ === test.prototype);//true + console.log("myname"); +}; +var a = new test(); -a.myname();//myname +console.log(a.__proto__ === test.prototype); //true +a.myname(); //myname //ou -var fn = function () { -}; +var fn = function () {}; fn.prototype.myname = function () { - console.log('myname'); -} + console.log("myname"); +}; var obj = { - __proto__: fn.prototype + __proto__: fn.prototype, }; - -obj.myname();//myname +obj.myname(); //myname ``` Nota: são dois underscores(underlines), seguidos de cinco caracteres "proto", seguidos por mais dois underscores(underlines). diff --git a/files/pt-br/web/javascript/reference/global_objects/object/seal/index.md b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.md index 7c7f9387b8061a..70b457db8300c6 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/seal/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.md @@ -34,13 +34,13 @@ Retorna a referência ao Objeto passado. ```js var obj = { - prop: function() {}, - foo: 'bar' + prop: function () {}, + foo: "bar", }; // Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas. -obj.foo = 'baz'; -obj.lumpy = 'woof'; +obj.foo = "baz"; +obj.lumpy = "woof"; delete obj.prop; var o = Object.seal(obj); @@ -49,26 +49,30 @@ o === obj; // true Object.isSealed(obj); // === true // Alterar o valor das propriedades em um objeto selado ainda funciona. -obj.foo = 'quux'; +obj.foo = "quux"; // Mas você não pode converter propriedades de dados em propriedades de acesso, e vice-versa. -Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError +Object.defineProperty(obj, "foo", { + get: function () { + return "g"; + }, +}); // throws a TypeError // Agora quaisquer mudanças, que não sejam aos valores da das propriedades, irão falhar. -obj.quaxxor = 'the friendly duck'; // silently doesn't add the property +obj.quaxxor = "the friendly duck"; // silently doesn't add the property delete obj.foo; // silently doesn't delete the property // e em modo rigoroso (strict mode) tais tentativas irão jogar erros do tipo TypeErrors. function fail() { - 'use strict'; + "use strict"; delete obj.foo; // throws a TypeError - obj.sparky = 'arf'; // throws a TypeError + obj.sparky = "arf"; // throws a TypeError } fail(); // Tentativas através do Object.defineProperty também irão falhar. -Object.defineProperty(obj, 'ohai', { value: 17 }); // lança um erro do tipo TypeError -Object.defineProperty(obj, 'foo', { value: 'eit' }); // altera o valor da propriedade existente +Object.defineProperty(obj, "ohai", { value: 17 }); // lança um erro do tipo TypeError +Object.defineProperty(obj, "foo", { value: "eit" }); // altera o valor da propriedade existente ``` ## Notas @@ -85,10 +89,10 @@ Object.seal(1); ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no Javascript 1.8.5. | -| {{SpecName('ES6', '#sec-object.seal', 'Object.seal')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ---------------------------------------------------------- | -------------------- | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.2.3.8', 'Object.seal')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no Javascript 1.8.5. | +| {{SpecName('ES6', '#sec-object.seal', 'Object.seal')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.seal', 'Object.seal')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.md b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.md index ff9e6f7f00db50..4d98677a143ecb 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.md @@ -44,10 +44,12 @@ Usando a propriedade mais antiga [`Object.prototype.__proto__`](/pt-BR/docs/Web/ ```js // Funciona somente no Chrome e FireFox, não funciona no IE: -Object.setPrototypeOf = Object.setPrototypeOf || function(obj, proto) { - obj.__proto__ = proto; - return obj; -} +Object.setPrototypeOf = + Object.setPrototypeOf || + function (obj, proto) { + obj.__proto__ = proto; + return obj; + }; ``` ## Adicionando 'Prototype' em cadeia @@ -56,32 +58,38 @@ Uma combinação de `Object.getPrototypeOf()` e [`Object.prototype.__proto__`](/ ```js /** -*** Object.appendChain(@object, @prototype) -* -* Acrescente o primeiro 'prototype' não nativo de uma cadeia a um novo 'prototype'. -* Retorna @object (se for um valor primitivo, será transformado em um objeto). -* -*** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body") -*** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body") -* -* Adicione o primeiro 'prototype' não nativo de uma cadeia ao objeto nativo Function.prototype, então anexar a nova função -* Function(["@arg"(s)], "@function_body") àquela cadeia. -* Retorna a função. -* -**/ - -Object.appendChain = function(oChain, oProto) { + *** Object.appendChain(@object, @prototype) + * + * Acrescente o primeiro 'prototype' não nativo de uma cadeia a um novo 'prototype'. + * Retorna @object (se for um valor primitivo, será transformado em um objeto). + * + *** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body") + *** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body") + * + * Adicione o primeiro 'prototype' não nativo de uma cadeia ao objeto nativo Function.prototype, então anexar a nova função + * Function(["@arg"(s)], "@function_body") àquela cadeia. + * Retorna a função. + * + **/ + +Object.appendChain = function (oChain, oProto) { if (arguments.length < 2) { - throw new TypeError('Object.appendChain - Argumentos insuficientes'); + throw new TypeError("Object.appendChain - Argumentos insuficientes"); } - if (typeof oProto !== 'object' && typeof oProto !== 'string') { - throw new TypeError('segundo argumento de Object.appendChain deve ser um objeto ou uma string'); + if (typeof oProto !== "object" && typeof oProto !== "string") { + throw new TypeError( + "segundo argumento de Object.appendChain deve ser um objeto ou uma string", + ); } var oNewProto = oProto, - oReturn = o2nd = oLast = oChain instanceof this ? oChain : new oChain.constructor(oChain); + oReturn = + (o2nd = + oLast = + oChain instanceof this ? oChain : new oChain.constructor(oChain)); - for (var o1st = this.getPrototypeOf(o2nd); + for ( + var o1st = this.getPrototypeOf(o2nd); o1st !== Object.prototype && o1st !== Function.prototype; o1st = this.getPrototypeOf(o2nd) ) { @@ -96,7 +104,7 @@ Object.appendChain = function(oChain, oProto) { this.setPrototypeOf(o2nd, oNewProto); return oReturn; -} +}; ``` ### Exemplos @@ -105,7 +113,7 @@ Object.appendChain = function(oChain, oProto) { ```js function Mammal() { - this.isMammal = 'yes'; + this.isMammal = "yes"; } function MammalSpecies(sMammalSpecies) { @@ -115,12 +123,12 @@ function MammalSpecies(sMammalSpecies) { MammalSpecies.prototype = new Mammal(); MammalSpecies.prototype.constructor = MammalSpecies; -var oCat = new MammalSpecies('Felis'); +var oCat = new MammalSpecies("Felis"); console.log(oCat.isMammal); // 'yes' function Animal() { - this.breathing = 'yes'; + this.breathing = "yes"; } Object.appendChain(oCat, new Animal()); @@ -132,7 +140,7 @@ console.log(oCat.breathing); // 'yes' ```js function MySymbol() { - this.isSymbol = 'yes'; + this.isSymbol = "yes"; } var nPrime = 17; @@ -153,8 +161,10 @@ function Person(sName) { this.identity = sName; } -var george = Object.appendChain(new Person('George'), - 'console.log("Hello guys!!");'); +var george = Object.appendChain( + new Person("George"), + 'console.log("Hello guys!!");', +); console.log(george.identity); // 'George' george(); // 'Hello guys!!' @@ -162,9 +172,9 @@ george(); // 'Hello guys!!' ## Especificações -| Especificação | Situação | Comentário | -| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Situação | Comentário | +| ----------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.md b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.md index 4f47260d3c75e1..e3ef5d52043ebc 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.md @@ -44,7 +44,10 @@ Por exemplo: ```js const testArray = [4, 7, 10]; -let euroPrices = testArray.toLocaleString('fr', { style: 'currency', currency: 'EUR'}); +let euroPrices = testArray.toLocaleString("fr", { + style: "currency", + currency: "EUR", +}); // "4,00 €,7,00 €,10,00 €" ``` @@ -58,10 +61,10 @@ Por exemplo: const testDate = new Date(Date.now()); // "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)" -let deDate = testDate.toLocaleString('de'); +let deDate = testDate.toLocaleString("de"); // "29.5.2020, 18:04:24" -var frDate = testDate.toLocaleString('fr'); +var frDate = testDate.toLocaleString("fr"); //"29/05/2020 à 18:04:24" ``` @@ -75,17 +78,17 @@ Por exemplo: const testNumber = 2901234564; // "2901234564" -let deNumber = testNumber.toLocaleString('de'); +let deNumber = testNumber.toLocaleString("de"); // "2.901.234.564" -let frNumber = testNumber.toLocaleString('fr'); +let frNumber = testNumber.toLocaleString("fr"); // "2 901 234 564" ``` ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------------------------------ | +| Especificação | +| -------------------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-object.prototype.tolocalestring', 'Object.prototype.toLocaleString')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.md b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.md index 08203a5a6bca13..1f8e2599e1aee0 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.md @@ -14,7 +14,7 @@ O método `toString()` retorna uma string representando o objeto. ## Sintaxe ```js -obj.toString() +obj.toString(); ``` ## Descrição @@ -23,7 +23,7 @@ Todo objeto possui um método `toString()` que é chamado automaticamente quando ```js var o = new Object(); -o.toString(); // retorna [object Object] +o.toString(); // retorna [object Object] ``` > **Nota:** Starting in JavaScript 1.8.5 `toString()` called on {{jsxref("Global_Objects/null", "null")}} returns `[object Null]`, and {{jsxref("Global_Objects/undefined", "undefined")}} returns `[object Undefined]`, as defined in the 5th Edition of ECMAScript and a subsequent Errata. See [Using toString to detect object type](#example:_using_tostring_to_detect_object_type). @@ -44,7 +44,7 @@ function Dog(name, breed, color, sex) { this.sex = sex; } -theDog = new Dog('Gabby', 'Lab', 'chocolate', 'female'); +theDog = new Dog("Gabby", "Lab", "chocolate", "female"); ``` Se você chamar o método `toString()` neste objeto, ele retornará o valor original herdado de {{jsxref("Global_Objects/Object", "Object")}}: @@ -57,9 +57,17 @@ O código abaixo cria e faz com que `dogToString()` sobrescreva o `toString()` o ```js Dog.prototype.toString = function dogToString() { - var ret = 'Dog ' + this.name + ' is a ' + this.sex + ' ' + this.color + ' ' + this.breed; + var ret = + "Dog " + + this.name + + " is a " + + this.sex + + " " + + this.color + + " " + + this.breed; return ret; -} +}; ``` Usando este código, toda vez que `theDog` for usado em um texto (string), JavaScript automaticamente chamará a função `dogToString()`, a qual retornará: @@ -75,13 +83,13 @@ Dog Gabby is a female chocolate Lab ```js var toString = Object.prototype.toString; -toString.call(new Date); // [object Date] -toString.call(new String); // [object String] -toString.call(Math); // [object Math] +toString.call(new Date()); // [object Date] +toString.call(new String()); // [object String] +toString.call(Math); // [object Math] // Since JavaScript 1.8.5 -toString.call(undefined); // [object Undefined] -toString.call(null); // [object Null] +toString.call(undefined); // [object Undefined] +toString.call(null); // [object Null] ``` ## Especificações diff --git a/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.md b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.md index 6e639fd1b06227..57a0994ca5ccbb 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.md @@ -34,7 +34,9 @@ Você pode criar uma função para ser chamada no lougar do método padrão `val Suponha que você tem um tipo de objeto `MyNumberType` e você quer criar um método `valueOf` para ele. O código a seguir atribui uma função definida por usuário para o método `valueOf` desse objeto: ```js -MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; }; +MyNumberType.prototype.valueOf = function () { + return customPrimitiveValue; +}; ``` Com o código anterior no lugar, a qualquer hora um objeto do tipo `MyNumberType` é usado em um contexto onde deve ser representado como um valor primitivo, o JavaScript chama automaticamente a função definida no código anterior. @@ -42,7 +44,7 @@ Com o código anterior no lugar, a qualquer hora um objeto do tipo `MyNumberType Um método `valueOf` de um objeto é geralmente chamado pelo JavaScript, mas você pode chamá-lo se quiser da seguinte maneira: ```js -myNumberType.valueOf() +myNumberType.valueOf(); ``` > **Nota:** Objetos em contexto de string convertidos através do método {{jsxref("Object.toString", "toString()")}}, o que é diferente de objetos {{jsxref("String")}} convertendo para string primiriva utlizando `valueOf`. Todos os objetos têm uma conversão string, somente se "`[object type]`". Mas muitos objetos não convertem para number, boolean, or function. @@ -53,11 +55,11 @@ myNumberType.valueOf() ```js function MyNumberType(n) { - this.number = n; + this.number = n; } -MyNumberType.prototype.valueOf = function() { - return this.number; +MyNumberType.prototype.valueOf = function () { + return this.number; }; var myObj = new MyNumberType(4); @@ -66,11 +68,11 @@ myObj + 3; // 7 ## Espeficações -| Especificação | Status | Cometário | -| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. Implemented in JavaScript 1.1. | -| {{SpecName('ES5.1', '#sec-15.2.4.4', 'Object.prototype.valueOf')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Cometário | +| ------------------------------------------------------------------------------------ | -------------------- | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. Implemented in JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.2.4.4', 'Object.prototype.valueOf')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/object/values/index.md b/files/pt-br/web/javascript/reference/global_objects/object/values/index.md index 9ae7c1a0a873e1..5afdd86f219cb9 100644 --- a/files/pt-br/web/javascript/reference/global_objects/object/values/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/object/values/index.md @@ -33,15 +33,24 @@ var obj = { foo: "bar", baz: 42 }; console.log(Object.values(obj)); // ['bar', 42] // array como objeto -var obj = { 0: 'a', 1: 'b', 2: 'c' }; +var obj = { 0: "a", 1: "b", 2: "c" }; console.log(Object.values(obj)); // ['a', 'b', 'c'] // array como objeto com ordenação de chave aleatória -var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; +var an_obj = { 100: "a", 2: "b", 7: "c" }; console.log(Object.values(an_obj)); // ['b', 'c', 'a'] // getFoo é a propriedade a qual não é enumerável -var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } }); +var my_obj = Object.create( + {}, + { + getFoo: { + value: function () { + return this.foo; + }, + }, + }, +); my_obj.foo = "bar"; console.log(Object.values(my_obj)); // ['bar'] @@ -55,8 +64,8 @@ console.log(Object.values("foo")); // ['f', 'o', 'o'] ## Especificações -| Especificações | Situação | Comentário | -| ------------------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| Especificações | Situação | Comentário | +| -------------------------------------------------------------- | -------------------- | ------------------- | | {{SpecName('ESDraft', '#sec-object.values', 'Object.values')}} | {{Spec2('ESDraft')}} | Initial definition. | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.md b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.md index 78a2e1facaa49c..0875afd6d6fa35 100644 --- a/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.md @@ -12,7 +12,7 @@ A função `parseFloat` analisa um argumento (convertendo-o para uma string prim ## Sintaxe ```js -parseFloat(string) +parseFloat(string); ``` ### Parâmetros @@ -63,20 +63,19 @@ As vezes é útil ter uma maneira mais rigorosa para analisar valores float, exp ```js var filterFloat = function (value) { - if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/ - .test(value)) - return Number(value); + if (/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/.test(value)) + return Number(value); return NaN; -} - -console.log(filterFloat('421')); // 421 -console.log(filterFloat('-421')); // -421 -console.log(filterFloat('+421')); // 421 -console.log(filterFloat('Infinity')); // Infinity -console.log(filterFloat('1.61803398875')); // 1.61803398875 -console.log(filterFloat('421e+0')); // NaN -console.log(filterFloat('421hop')); // NaN -console.log(filterFloat('hop1.61803398875')); // NaN +}; + +console.log(filterFloat("421")); // 421 +console.log(filterFloat("-421")); // -421 +console.log(filterFloat("+421")); // 421 +console.log(filterFloat("Infinity")); // Infinity +console.log(filterFloat("1.61803398875")); // 1.61803398875 +console.log(filterFloat("421e+0")); // NaN +console.log(filterFloat("421hop")); // NaN +console.log(filterFloat("hop1.61803398875")); // NaN ``` Observe que este código é somente um exemplo; ele não aceita números válidos, tais como 1. ou 0,5. diff --git a/files/pt-br/web/javascript/reference/global_objects/parseint/index.md b/files/pt-br/web/javascript/reference/global_objects/parseint/index.md index ea83199290fbb8..9ac7b083a0865d 100644 --- a/files/pt-br/web/javascript/reference/global_objects/parseint/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/parseint/index.md @@ -117,28 +117,27 @@ Muitas implementações não adotaram este comportamento a partir de 2013, e por ```js filterInt = function (value) { - if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) - return Number(value); + if (/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) return Number(value); return NaN; -} - -console.log(filterInt('421')); // 421 -console.log(filterInt('-421')); // -421 -console.log(filterInt('+421')); // 421 -console.log(filterInt('Infinity')); // Infinity -console.log(filterInt('421e+0')); // NaN -console.log(filterInt('421hop')); // NaN -console.log(filterInt('hop1.61803398875')); // NaN -console.log(filterInt('1.61803398875')); // NaN +}; + +console.log(filterInt("421")); // 421 +console.log(filterInt("-421")); // -421 +console.log(filterInt("+421")); // 421 +console.log(filterInt("Infinity")); // Infinity +console.log(filterInt("421e+0")); // NaN +console.log(filterInt("421hop")); // NaN +console.log(filterInt("hop1.61803398875")); // NaN +console.log(filterInt("1.61803398875")); // NaN ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------- | ------------------------ | ----------------- | -| ECMAScript 1st Edition. | Padrão | Definição inicial | -| {{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ------------------------------------------------------------- | ------------------ | ----------------- | +| ECMAScript 1st Edition. | Padrão | Definição inicial | +| {{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/all/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.md index 52cd143fdfb193..98fd3eb29569a2 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/all/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.md @@ -56,7 +56,7 @@ var p3 = new Promise((resolve, reject) => { }, 100); }); -Promise.all([p1, p2, p3]).then(valores=> { +Promise.all([p1, p2, p3]).then((valores) => { console.log(valores); // [3, 1337, "foo"] }); ``` @@ -65,17 +65,17 @@ Se o iterável conter valores que não são promises, eles serão ignorados, mas ```js // Essa será considerada como se o iterável passado fosse vazio, logo ela será resolvido -var p = Promise.all([1,2,3]); +var p = Promise.all([1, 2, 3]); // Essa será considerada como se o iterável passado contém apenas a promise resolvida com o valor "444", logo ela é resolvida -var p2 = Promise.all([1,2,3, Promise.resolve(444)]); +var p2 = Promise.all([1, 2, 3, Promise.resolve(444)]); // Esse será considerada como se o iterável passado contém apenas o valor de rejeição "555" da promise, logo ela é rejeitada -var p3 = Promise.all([1,2,3, Promise.reject(555)]); +var p3 = Promise.all([1, 2, 3, Promise.reject(555)]); // Utilizando setTimeout para executar código depois que a pilha estiver vazia -setTimeout(function() { - console.log(p); - console.log(p2); - console.log(p3); +setTimeout(function () { + console.log(p); + console.log(p2); + console.log(p3); }); // logs @@ -97,9 +97,9 @@ var p = Promise.all(arrayPromisesResolvidas); console.log(p); // Utilizando setTimeout para executar código depois que a pilha estiver vazia -setTimeout(function() { - console.log('a pilha está vazia agora'); - console.log(p); +setTimeout(function () { + console.log("a pilha está vazia agora"); + console.log(p); }); // logs, em ordem: @@ -114,9 +114,9 @@ A mesma coisa acontece se `Promise.all` for rejeitada: var arrayPromisesMisturadas = [Promise.resolve(33), Promise.reject(44)]; var p = Promise.all(arrayPromisesMisturadas); console.log(p); -setTimeout(function() { - console.log('a pilha está vazia agora'); - console.log(p); +setTimeout(function () { + console.log("a pilha está vazia agora"); + console.log(p); }); // logs @@ -131,10 +131,10 @@ Mas, `Promise.all` resolve sincromamente **se e somente se** o iterável passado var p = Promise.all([]); // será resolvida imediatamente var p2 = Promise.all([1337, "oi"]); // um valor que não é uma promise será ignorado, mas a avaliação será feita assíncronamente console.log(p); -console.log(p2) -setTimeout(function() { - console.log('a pilha está vazia agora'); - console.log(p2); +console.log(p2); +setTimeout(function () { + console.log("a pilha está vazia agora"); + console.log(p2); }); // logs @@ -150,30 +150,29 @@ setTimeout(function() { ```js var p1 = new Promise((resolve, reject) => { - setTimeout(() => resolve('um'), 1000); + setTimeout(() => resolve("um"), 1000); }); var p2 = new Promise((resolve, reject) => { - setTimeout(() => resolve('dois'), 2000); + setTimeout(() => resolve("dois"), 2000); }); var p3 = new Promise((resolve, reject) => { - setTimeout(() => resolve('três'), 3000); + setTimeout(() => resolve("três"), 3000); }); var p4 = new Promise((resolve, reject) => { - setTimeout(() => resolve('quatro'), 4000); + setTimeout(() => resolve("quatro"), 4000); }); var p5 = new Promise((resolve, reject) => { - reject(new Error('rejeitada')); + reject(new Error("rejeitada")); }); - // Usando .catch: Promise.all([p1, p2, p3, p4, p5]) -.then(valores => { - console.log(valores); -}) -.catch(erro => { - console.log(erro.message) -}); + .then((valores) => { + console.log(valores); + }) + .catch((erro) => { + console.log(erro.message); + }); // No console: // "rejeitada" @@ -183,27 +182,31 @@ Promise.all([p1, p2, p3, p4, p5]) ```js var p1 = new Promise((resolve, reject) => { - setTimeout(() => resolve('p1_resolução_atrasada'), 1000); + setTimeout(() => resolve("p1_resolução_atrasada"), 1000); }); var p2 = new Promise((resolve, reject) => { - reject(new Error('p2_rejeição_imediata')); + reject(new Error("p2_rejeição_imediata")); }); Promise.all([ - p1.catch(erro => { return erro }), - p2.catch(erro => { return erro }), -]).then(valores => { - console.log(valores[0]) // "p1_resolução_atrasada" - console.log(valores[1]) // "Erro: p2_rejeição_imediata" -}) + p1.catch((erro) => { + return erro; + }), + p2.catch((erro) => { + return erro; + }), +]).then((valores) => { + console.log(valores[0]); // "p1_resolução_atrasada" + console.log(valores[1]); // "Erro: p2_rejeição_imediata" +}); ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------------ | -| {{SpecName('ES2015', '#sec-promise.all', 'Promise.all')}} | {{Spec2('ES2015')}} | Definição inicial em um padrão ECMA. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------- | -------------------- | ------------------------------------ | +| {{SpecName('ES2015', '#sec-promise.all', 'Promise.all')}} | {{Spec2('ES2015')}} | Definição inicial em um padrão ECMA. | | {{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.md index 808f805dc8f8d0..3246acfeea12b7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.md @@ -32,8 +32,8 @@ Para cada objeto no array retornado, existe uma string `status`. Se o status for ## Especificaçṍes -| Specification | Status | Comment | -| ------------------------------------------------------------------------------------------- | ---------------------------- | ------- | +| Specification | Status | Comment | +| ------------------------------------------------------------------------------------------- | -------------------- | ------- | | [`Promise.allSettled()` (TC39 Stage 4 Draft)](https://tc39.es/proposal-promise-allSettled/) | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.md index 910f935752c231..a431c74bde8a1b 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.md @@ -35,24 +35,30 @@ Internamente chamamos `Promise.prototype.then` sobre o objeto que é chamando pa ```js // Sobrescrevendo o techo original de Promise.prototype.then/catch adicionando alguns logs -(function(Promise){ - var originalThen = Promise.prototype.then; - var originalCatch = Promise.prototype.catch; - - Promise.prototype.then = function(){ - console.log('> > > > > > chamando .then em %o com argumentos: %o', this, arguments); - return originalThen.apply(this, arguments); - }; - Promise.prototype.catch = function(){ - console.log('> > > > > > chamando .catch em %o com argumentos: %o', this, arguments); - return originalCatch.apply(this, arguments); - }; - +(function (Promise) { + var originalThen = Promise.prototype.then; + var originalCatch = Promise.prototype.catch; + + Promise.prototype.then = function () { + console.log( + "> > > > > > chamando .then em %o com argumentos: %o", + this, + arguments, + ); + return originalThen.apply(this, arguments); + }; + Promise.prototype.catch = function () { + console.log( + "> > > > > > chamando .catch em %o com argumentos: %o", + this, + arguments, + ); + return originalCatch.apply(this, arguments); + }; })(this.Promise); - // chamando um catch em uma Promise já resolvida. -Promise.resolve().catch(function XXX(){}); +Promise.resolve().catch(function XXX() {}); // logs: // > > > > > > chamando .catch na Promise{} com os argumentos: Arguments{1} [0: function XXX()] @@ -68,39 +74,49 @@ O método `catch` pode ser útil para manipulação de erros na composição da ### Usando o método `catch` ```js -var p1 = new Promise(function(resolve, reject) { - resolve('Sucesso'); +var p1 = new Promise(function (resolve, reject) { + resolve("Sucesso"); }); -p1.then(function(value) { +p1.then(function (value) { console.log(value); // "Sucesso!" - throw 'Ah, não!'; -}).catch(function(e) { - console.log(e); // "Ah, não!" -}).then(function(){ - console.log('Após um catch, a sequencia é restaurada'); -}, function () { - console.log('Não engatilhado devido ao catch'); -}); + throw "Ah, não!"; +}) + .catch(function (e) { + console.log(e); // "Ah, não!" + }) + .then( + function () { + console.log("Após um catch, a sequencia é restaurada"); + }, + function () { + console.log("Não engatilhado devido ao catch"); + }, + ); // O seguinte se comporta da mesma maneira que o anterior -p1.then(function(value) { +p1.then(function (value) { console.log(value); // "Sucesso!" - return Promise.reject('Ah, não!'); -}).catch(function(e) { - console.log(e); // "Ah, não!" -}).then(function(){ - console.log('Após um catch, a sequencia é restaurada'); -}, function () { - console.log('Não engatilhado devido ao catch'); -}); + return Promise.reject("Ah, não!"); +}) + .catch(function (e) { + console.log(e); // "Ah, não!" + }) + .then( + function () { + console.log("Após um catch, a sequencia é restaurada"); + }, + function () { + console.log("Não engatilhado devido ao catch"); + }, + ); ``` ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | --------------------------------------- | -| {{SpecName('ES6', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}} | {{Spec2('ES6')}} | Initial definition in an ECMA standard. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------------- | -------------------- | --------------------------------------- | +| {{SpecName('ES6', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}} | {{Spec2('ES6')}} | Initial definition in an ECMA standard. | | {{SpecName('ESDraft', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.md index ee92b927dbaacf..44e4d6f61dea1f 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.md @@ -46,16 +46,23 @@ O método `finally()` é bastante similar a chamar `.then(quandoEstabelecida, qu ```js let carregando = true; -fetch(minhaRequisicao).then(function(resposta) { +fetch(minhaRequisicao) + .then(function (resposta) { var tipoConteudo = response.headers.get("content-type"); - if(tipoConteudo && tipoConteudo.includes("application/json")) { + if (tipoConteudo && tipoConteudo.includes("application/json")) { return resposta.json(); } throw new TypeError("Opa, isso não é JSON!"); }) - .then(function(json) { /* processamento do seu JSON */ }) - .catch(function(erro) { console.log(erro); }) - .finally(function() { carregando = false; }); + .then(function (json) { + /* processamento do seu JSON */ + }) + .catch(function (erro) { + console.log(erro); + }) + .finally(function () { + carregando = false; + }); ``` ## Especificações diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/index.md index 24ef17f4467860..02b6d0c5c526dc 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/index.md @@ -33,7 +33,7 @@ new Promise((resolveOuter) => { resolveOuter( new Promise((resolveInner) => { setTimeout(resolveInner, 1000); - }) + }), ); }); ``` @@ -153,12 +153,12 @@ Promise.resolve(aThenable); // Uma promise cumprida com 42 Um objeto de configurações é um [ambiente](https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object) que fornece informações adicionais quando o código JavaScript está em execução. Isso inclui o mapa do domínio e do módulo, bem como informações específicas do HTML, como a origem. O objeto de configurações incumbente é rastreado para garantir que o navegador saibas qual usar para um determinado pedaço de código de usuário. -Para melhor visualizar isso, podemos dar uma olhada mais de perto em como o reino pode ser um problema. Um **reino** pode ser pensado aproximadamente como o objeto global. O que é único sobre os realms é que eles contêm todas as informações necessárias para executar o código JavaScript. Isso inclui objetos como [`Array`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array) e [`Error`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Error ). Cada objeto de configurações tem sua própria "cópia" e não são compartilhados. Isso pode causar algum comportamento inesperado em relação às promises. Para contornar isso, rastreamos algo chamado **objeto de configurações incumbentes**. Isso representa informações específicas do contexto do código do usuário responsável por uma determinada chamada de função. +Para melhor visualizar isso, podemos dar uma olhada mais de perto em como o reino pode ser um problema. Um **reino** pode ser pensado aproximadamente como o objeto global. O que é único sobre os realms é que eles contêm todas as informações necessárias para executar o código JavaScript. Isso inclui objetos como [`Array`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array) e [`Error`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Error). Cada objeto de configurações tem sua própria "cópia" e não são compartilhados. Isso pode causar algum comportamento inesperado em relação às promises. Para contornar isso, rastreamos algo chamado **objeto de configurações incumbentes**. Isso representa informações específicas do contexto do código do usuário responsável por uma determinada chamada de função. Para ilustrar isso um pouco mais, podemos dar uma olhada em como um [` + ``` @@ -390,13 +390,16 @@ function testPromise() { // para resolver ou rejeitar a promise log.insertAdjacentHTML( "beforeend", - `${thisPromiseCount}) Construtor de promise
` + `${thisPromiseCount}) Construtor de promise
`, ); // Este é apenas um exemplo para criar assincronismo - setTimeout(() => { - // Nós cumprimos a promise - resolve(thisPromiseCount); - }, Math.random() * 2000 + 1000); + setTimeout( + () => { + // Nós cumprimos a promise + resolve(thisPromiseCount); + }, + Math.random() * 2000 + 1000, + ); }); // Definimos o que fazer quando a promise é resolvida com a chamada then(), diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/race/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.md index dc47aaddb6ab8a..1bf8f8c411f9d2 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/race/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.md @@ -2,6 +2,7 @@ title: Promise.race() slug: Web/JavaScript/Reference/Global_Objects/Promise/race --- + {{JSRef}} O método **`Promise.race(iterable)`** retorna uma promise que resolve ou rejeita assim que uma das promises no iterável resolver ou rejeitar, com o valor ou razão daquela promise. @@ -26,51 +27,57 @@ A função `race` retorna uma `Promise` que é estabelecida da mesma forma que a ### Usando `Promise.race` – exemplos com `setTimeout` ```js -var p1 = new Promise(function(resolve, reject) { - setTimeout(resolve, 500, "one"); +var p1 = new Promise(function (resolve, reject) { + setTimeout(resolve, 500, "one"); }); -var p2 = new Promise(function(resolve, reject) { - setTimeout(resolve, 100, "two"); +var p2 = new Promise(function (resolve, reject) { + setTimeout(resolve, 100, "two"); }); -Promise.race([p1, p2]).then(function(value) { +Promise.race([p1, p2]).then(function (value) { console.log(value); // "two" // Ambos resolvem, mas p2 é mais rápido }); -var p3 = new Promise(function(resolve, reject) { - setTimeout(resolve, 100, "three"); -}); -var p4 = new Promise(function(resolve, reject) { - setTimeout(reject, 500, "four"); +var p3 = new Promise(function (resolve, reject) { + setTimeout(resolve, 100, "three"); }); - -Promise.race([p3, p4]).then(function(value) { - console.log(value); // "three" - // p3 é mais rápido, então ela resolve -}, function(reason) { - // Não é chamado +var p4 = new Promise(function (resolve, reject) { + setTimeout(reject, 500, "four"); }); -var p5 = new Promise(function(resolve, reject) { - setTimeout(resolve, 500, "five"); +Promise.race([p3, p4]).then( + function (value) { + console.log(value); // "three" + // p3 é mais rápido, então ela resolve + }, + function (reason) { + // Não é chamado + }, +); + +var p5 = new Promise(function (resolve, reject) { + setTimeout(resolve, 500, "five"); }); -var p6 = new Promise(function(resolve, reject) { - setTimeout(reject, 100, "six"); +var p6 = new Promise(function (resolve, reject) { + setTimeout(reject, 100, "six"); }); -Promise.race([p5, p6]).then(function(value) { - // Não é chamado -}, function(reason) { - console.log(reason); // "six" - // p6 é mais rápido, então ela rejeita -}); +Promise.race([p5, p6]).then( + function (value) { + // Não é chamado + }, + function (reason) { + console.log(reason); // "six" + // p6 é mais rápido, então ela rejeita + }, +); ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------- | -------------------- | ------------------------------------ | +| Especificação | Status | Comentário | +| -------------------------------------------------------- | ---------------- | ------------------------------------ | | {{SpecName('ES6', '#sec-promise.race', 'Promise.race')}} | {{Spec2('ES6')}} | Definição inicial em um padrão ECMA. | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.md index 878c18a26b9f4a..2fa301167f23e9 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.md @@ -27,24 +27,30 @@ O método estático `Promise.reject` retorna uma `Promise` que é rejeitada. Par ### Usando o método estático Promise.reject() ```js -Promise.reject("Testando reject estático").then(function(motivo) { - // não executado -}, function(motivo) { - console.log(motivo); // "Testando reject estático" -}); - -Promise.reject(new Error("falha")).then(function(erro) { - // não executado -}, function(erro) { - console.log(erro); // Stacktrace -}); +Promise.reject("Testando reject estático").then( + function (motivo) { + // não executado + }, + function (motivo) { + console.log(motivo); // "Testando reject estático" + }, +); + +Promise.reject(new Error("falha")).then( + function (erro) { + // não executado + }, + function (erro) { + console.log(erro); // Stacktrace + }, +); ``` ## Especificações -| Especificação | Situação | Comentário | -| ------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------ | -| {{SpecName('ES6', '#sec-promise.reject', 'Promise.reject')}} | {{Spec2('ES6')}} | Definição inicial em um padrão ECMA. | +| Especificação | Situação | Comentário | +| ---------------------------------------------------------------- | -------------------- | ------------------------------------ | +| {{SpecName('ES6', '#sec-promise.reject', 'Promise.reject')}} | {{Spec2('ES6')}} | Definição inicial em um padrão ECMA. | | {{SpecName('ESDraft', '#sec-promise.reject', 'Promise.reject')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.md index ef63f442b8b2a0..5ce2bbb2c5b151 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.md @@ -33,18 +33,21 @@ A função estática `Promise.resolve` retorna uma `Promise` de que será resolv ### Usando o método estático `Promise.resolve` ```js -Promise.resolve("Success").then(function(value) { - console.log(value); // "Success" -}, function(value) { - // not called -}); +Promise.resolve("Success").then( + function (value) { + console.log(value); // "Success" + }, + function (value) { + // not called + }, +); ``` ### Resolvendo um array ```js -var p = Promise.resolve([1,2,3]); -p.then(function(v) { +var p = Promise.resolve([1, 2, 3]); +p.then(function (v) { console.log(v[0]); // 1 }); ``` @@ -54,7 +57,7 @@ p.then(function(v) { ```js var original = Promise.resolve(true); var cast = Promise.resolve(original); -cast.then(function(v) { +cast.then(function (v) { console.log(v); // true }); ``` @@ -66,50 +69,65 @@ A ordem invertida dos logs acontece devido ao fato de que os handlers são chama ```js // Resolving a thenable object var p1 = Promise.resolve({ - then: function(onFulfill, onReject) { onFulfill("fulfilled!"); } + then: function (onFulfill, onReject) { + onFulfill("fulfilled!"); + }, }); -console.log(p1 instanceof Promise) // true, object casted to a Promise +console.log(p1 instanceof Promise); // true, object casted to a Promise -p1.then(function(v) { +p1.then( + function (v) { console.log(v); // "fulfilled!" - }, function(e) { + }, + function (e) { // not called -}); + }, +); // Thenable throws before callback // Promise rejects -var thenable = { then: function(resolve) { - throw new TypeError("Throwing"); - resolve("Resolving"); -}}; +var thenable = { + then: function (resolve) { + throw new TypeError("Throwing"); + resolve("Resolving"); + }, +}; var p2 = Promise.resolve(thenable); -p2.then(function(v) { - // not called -}, function(e) { - console.log(e); // TypeError: Throwing -}); +p2.then( + function (v) { + // not called + }, + function (e) { + console.log(e); // TypeError: Throwing + }, +); // Thenable throws after callback // Promise resolves -var thenable = { then: function(resolve) { - resolve("Resolving"); - throw new TypeError("Throwing"); -}}; +var thenable = { + then: function (resolve) { + resolve("Resolving"); + throw new TypeError("Throwing"); + }, +}; var p3 = Promise.resolve(thenable); -p3.then(function(v) { - console.log(v); // "Resolving" -}, function(e) { - // not called -}); +p3.then( + function (v) { + console.log(v); // "Resolving" + }, + function (e) { + // not called + }, +); ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------- | -| {{SpecName('ES6', '#sec-promise.resolve', 'Promise.resolve')}} | {{Spec2('ES2015')}} | Definição inicial no padrão ECMA. | +| Especificação | Status | Comentário | +| ------------------------------------------------------------------ | -------------------- | --------------------------------- | +| {{SpecName('ES6', '#sec-promise.resolve', 'Promise.resolve')}} | {{Spec2('ES2015')}} | Definição inicial no padrão ECMA. | | {{SpecName('ESDraft', '#sec-promise.resolve', 'Promise.resolve')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/then/index.md b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.md index 4cb7ae9bf93089..d06ea212aea710 100644 --- a/files/pt-br/web/javascript/reference/global_objects/promise/then/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.md @@ -37,17 +37,20 @@ Assim como o método .then() e {{jsxref("Promise.prototype.catch()")}} retornam ### Usando o método then ```js -var p1 = new Promise(function(resolve, reject) { +var p1 = new Promise(function (resolve, reject) { resolve("Success!"); // or // reject ("Error!"); }); -p1.then(function(value) { - console.log(value); // Success! -}, function(reason) { - console.log(reason); // Error! -}); +p1.then( + function (value) { + console.log(value); // Success! + }, + function (reason) { + console.log(reason); // Error! + }, +); ``` ### Encadeando @@ -55,14 +58,14 @@ p1.then(function(value) { Já que o método then() devolve uma **Promise**, você pode facilmente encadeá-los. ```js -var p2 = new Promise(function(resolve, reject) { +var p2 = new Promise(function (resolve, reject) { resolve(1); }); -p2.then(function(value) { +p2.then(function (value) { console.log(value); // 1 return value + 1; -}).then(function(value) { +}).then(function (value) { console.log(value); // 2 }); ``` @@ -70,28 +73,28 @@ p2.then(function(value) { No exemplo acima, o último **.then()** recebeu a soma value + 1, que resultou em 2, porém se o retorno de value + 1 fosse uma **Promise** que também retornasse value + 1, o resultado seria o mesmo. Note, no exemplo abaixo, que leva 1000ms para a impressão de 2 ocorrer. ```js -var p2 = new Promise(function(resolve, reject) { - resolve(1); +var p2 = new Promise(function (resolve, reject) { + resolve(1); }); -p2.then(function(value) { +p2.then(function (value) { console.log(value); // 1 return new Promise(function (resolve, reject) { setTimeout(function () { resolve(value + 1); }, 1000); }); -}).then(function(value) { +}).then(function (value) { console.log(value); // 2 }); ``` ## Especificações -| Especificações | Status | Comentários | -| ---------------------------------------------------------------------------------------------------- | -------------------- | ------------------------------------------ | -| [domenic/promises-unwrapping](https://github.com/domenic/promises-unwrapping) | Draft | Standardization work is taking place here. | -| {{SpecName('ES6', '#sec-promise.prototype.then', 'Promise.prototype.then')}} | {{Spec2('ES6')}} | Initial definition in an ECMA standard. | +| Especificações | Status | Comentários | +| ----------------------------------------------------------------------------- | ---------------- | ------------------------------------------ | +| [domenic/promises-unwrapping](https://github.com/domenic/promises-unwrapping) | Draft | Standardization work is taking place here. | +| {{SpecName('ES6', '#sec-promise.prototype.then', 'Promise.prototype.then')}} | {{Spec2('ES6')}} | Initial definition in an ECMA standard. | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/proxy/index.md b/files/pt-br/web/javascript/reference/global_objects/proxy/index.md index a8e1bb412ae7fe..9e32caae83e71c 100644 --- a/files/pt-br/web/javascript/reference/global_objects/proxy/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/proxy/index.md @@ -48,11 +48,9 @@ Neste exemplo simples, o número `37` é retornado como o valor padrão quando o ```js var handler = { - get: function(target, name) { - return name in target ? - target[name] : - 37; - } + get: function (target, name) { + return name in target ? target[name] : 37; + }, }; var p = new Proxy({}, handler); @@ -60,7 +58,7 @@ p.a = 1; p.b = undefined; console.log(p.a, p.b); // 1, undefined -console.log('c' in p, p.c); // false, 37 +console.log("c" in p, p.c); // false, 37 ``` ### Encaminhamento de Proxy @@ -82,13 +80,13 @@ Com um `Proxy`, você pode validar facilmente o valor passado para um objeto. Es ```js let validator = { - set: function(obj, prop, value) { - if (prop === 'age') { + set: function (obj, prop, value) { + if (prop === "age") { if (!Number.isInteger(value)) { - throw new TypeError('The age is not an integer'); + throw new TypeError("The age is not an integer"); } if (value > 200) { - throw new RangeError('The age seems invalid'); + throw new RangeError("The age seems invalid"); } } @@ -97,14 +95,14 @@ let validator = { // Indique o sucesso return true; - } + }, }; let person = new Proxy({}, validator); person.age = 100; console.log(person.age); // 100 -person.age = 'young'; // Lança uma exceção +person.age = "young"; // Lança uma exceção person.age = 300; // Lança uma exceção ``` @@ -115,40 +113,41 @@ Um proxy de função poderia facilmente estender um construtor com um novo const ```js function extend(sup, base) { var descriptor = Object.getOwnPropertyDescriptor( - base.prototype, 'constructor' + base.prototype, + "constructor", ); base.prototype = Object.create(sup.prototype); var handler = { - construct: function(target, args) { + construct: function (target, args) { var obj = Object.create(base.prototype); this.apply(target, obj, args); return obj; }, - apply: function(target, that, args) { + apply: function (target, that, args) { sup.apply(that, args); base.apply(that, args); - } + }, }; var proxy = new Proxy(base, handler); descriptor.value = proxy; - Object.defineProperty(base.prototype, 'constructor', descriptor); + Object.defineProperty(base.prototype, "constructor", descriptor); return proxy; } -var Person = function(name) { +var Person = function (name) { this.name = name; }; -var Boy = extend(Person, function(name, age) { +var Boy = extend(Person, function (name, age) { this.age = age; }); -Boy.prototype.sex = 'M'; +Boy.prototype.sex = "M"; -var Peter = new Boy('Peter', 13); -console.log(Peter.sex); // "M" +var Peter = new Boy("Peter", 13); +console.log(Peter.sex); // "M" console.log(Peter.name); // "Peter" -console.log(Peter.age); // 13 +console.log(Peter.age); // 13 ``` ### DOM manipulação de nós @@ -156,36 +155,38 @@ console.log(Peter.age); // 13 Às vezes, você deseja alternar o atributo ou o nome da classe de dois elementos diferentes. Veja como usar o manipulador [`set`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set). ```js -let view = new Proxy({ - selected: null -}, -{ - set: function(obj, prop, newval) { - let oldval = obj[prop]; - - if (prop === 'selected') { - if (oldval) { - oldval.setAttribute('aria-selected', 'false'); - } - if (newval) { - newval.setAttribute('aria-selected', 'true'); +let view = new Proxy( + { + selected: null, + }, + { + set: function (obj, prop, newval) { + let oldval = obj[prop]; + + if (prop === "selected") { + if (oldval) { + oldval.setAttribute("aria-selected", "false"); + } + if (newval) { + newval.setAttribute("aria-selected", "true"); + } } - } - // O comportamento para armazenar o valor padrão - obj[prop] = newval; + // O comportamento para armazenar o valor padrão + obj[prop] = newval; - // Indica o sucesso - return true; - } -}); + // Indica o sucesso + return true; + }, + }, +); -let i1 = view.selected = document.getElementById('item-1'); -console.log(i1.getAttribute('aria-selected')); // 'true' +let i1 = (view.selected = document.getElementById("item-1")); +console.log(i1.getAttribute("aria-selected")); // 'true' -let i2 = view.selected = document.getElementById('item-2'); -console.log(i1.getAttribute('aria-selected')); // 'false' -console.log(i2.getAttribute('aria-selected')); // 'true' +let i2 = (view.selected = document.getElementById("item-2")); +console.log(i1.getAttribute("aria-selected")); // 'false' +console.log(i2.getAttribute("aria-selected")); // 'true' ``` ### Correção de valor e uma propriedade extra @@ -193,44 +194,46 @@ console.log(i2.getAttribute('aria-selected')); // 'true' O objeto de proxy `produtos` avalia o valor passado e converte-o em uma matriz, se necessário. O objeto também suporta uma propriedade adicional chamada `latestBrowser` tanto em getters como em setters. ```js -let products = new Proxy({ - browsers: ['Internet Explorer', 'Netscape'] -}, -{ - get: function(obj, prop) { - // An extra property - if (prop === 'latestBrowser') { - return obj.browsers[obj.browsers.length - 1]; - } - - // O comportamento para armazenar o valor padrão - return obj[prop]; +let products = new Proxy( + { + browsers: ["Internet Explorer", "Netscape"], }, - set: function(obj, prop, value) { - // An extra property - if (prop === 'latestBrowser') { - obj.browsers.push(value); - return true; - } + { + get: function (obj, prop) { + // An extra property + if (prop === "latestBrowser") { + return obj.browsers[obj.browsers.length - 1]; + } - // Converta o valor se não for uma matriz - if (typeof value === 'string') { - value = [value]; - } + // O comportamento para armazenar o valor padrão + return obj[prop]; + }, + set: function (obj, prop, value) { + // An extra property + if (prop === "latestBrowser") { + obj.browsers.push(value); + return true; + } - // O comportamento para armazenar o valor padrão - obj[prop] = value; + // Converta o valor se não for uma matriz + if (typeof value === "string") { + value = [value]; + } - // Indicate success - return true; - } -}); + // O comportamento para armazenar o valor padrão + obj[prop] = value; + + // Indicate success + return true; + }, + }, +); console.log(products.browsers); // ['Internet Explorer', 'Netscape'] -products.browsers = 'Firefox'; // pass a string (by mistake) +products.browsers = "Firefox"; // pass a string (by mistake) console.log(products.browsers); // ['Firefox'] <- no problem, the value is an array -products.latestBrowser = 'Chrome'; +products.latestBrowser = "Chrome"; console.log(products.browsers); // ['Firefox', 'Chrome'] console.log(products.latestBrowser); // 'Chrome' ``` @@ -240,58 +243,61 @@ console.log(products.latestBrowser); // 'Chrome' Esta proxy estende uma matriz com alguns recursos de utilidade. Como você vê, você pode "definir" propriedades flexíveis sem usar [`Object.defineProperties`](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties). Este exemplo pode ser adaptado para encontrar uma linha de tabela por sua célula. Nesse caso, o alvo será [`table.rows`](/pt-BR/docs/DOM/table.rows) ```js -let products = new Proxy([ - { name: 'Firefox', type: 'browser' }, - { name: 'SeaMonkey', type: 'browser' }, - { name: 'Thunderbird', type: 'mailer' } -], -{ - get: function(obj, prop) { - // O comportamento para retornar o valor; Prop geralmente é um inteiro - if (prop in obj) { - return obj[prop]; - } - - // Obter o número de produtos; Com products.length - if (prop === 'number') { - return obj.length; - } - - let result, types = {}; +let products = new Proxy( + [ + { name: "Firefox", type: "browser" }, + { name: "SeaMonkey", type: "browser" }, + { name: "Thunderbird", type: "mailer" }, + ], + { + get: function (obj, prop) { + // O comportamento para retornar o valor; Prop geralmente é um inteiro + if (prop in obj) { + return obj[prop]; + } - for (let product of obj) { - if (product.name === prop) { - result = product; + // Obter o número de produtos; Com products.length + if (prop === "number") { + return obj.length; } - if (types[product.type]) { - types[product.type].push(product); - } else { - types[product.type] = [product]; + + let result, + types = {}; + + for (let product of obj) { + if (product.name === prop) { + result = product; + } + if (types[product.type]) { + types[product.type].push(product); + } else { + types[product.type] = [product]; + } } - } - // Obtém um produto por nome - if (result) { - return result; - } + // Obtém um produto por nome + if (result) { + return result; + } - // Obtém produtos por tipo - if (prop in types) { - return types[prop]; - } + // Obtém produtos por tipo + if (prop in types) { + return types[prop]; + } - // Obtém tipos de produto - if (prop === 'types') { - return Object.keys(types); - } + // Obtém tipos de produto + if (prop === "types") { + return Object.keys(types); + } - return undefined; - } -}); + return undefined; + }, + }, +); console.log(products[0]); // { name: 'Firefox', type: 'browser' } -console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' } -console.log(products['Chrome']); // undefined +console.log(products["Firefox"]); // { name: 'Firefox', type: 'browser' } +console.log(products["Chrome"]); // undefined console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }] console.log(products.types); // ['browser', 'mailer'] console.log(products.number); // 3 @@ -312,11 +318,15 @@ var docCookies = new Proxy(docCookies, { return oTarget[sKey] || oTarget.getItem(sKey) || undefined; }, set: function (oTarget, sKey, vValue) { - if (sKey in oTarget) { return false; } + if (sKey in oTarget) { + return false; + } return oTarget.setItem(sKey, vValue); }, deleteProperty: function (oTarget, sKey) { - if (sKey in oTarget) { return false; } + if (sKey in oTarget) { + return false; + } return oTarget.removeItem(sKey); }, enumerate: function (oTarget, sKey) { @@ -329,34 +339,38 @@ var docCookies = new Proxy(docCookies, { return sKey in oTarget || oTarget.hasItem(sKey); }, defineProperty: function (oTarget, sKey, oDesc) { - if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); } + if (oDesc && "value" in oDesc) { + oTarget.setItem(sKey, oDesc.value); + } return oTarget; }, getOwnPropertyDescriptor: function (oTarget, sKey) { var vValue = oTarget.getItem(sKey); - return vValue ? { - value: vValue, - writable: true, - enumerable: true, - configurable: false - } : undefined; + return vValue + ? { + value: vValue, + writable: true, + enumerable: true, + configurable: false, + } + : undefined; }, }); /* Teste Cookies */ -console.log(docCookies.my_cookie1 = 'First value'); -console.log(docCookies.getItem('my_cookie1')); +console.log((docCookies.my_cookie1 = "First value")); +console.log(docCookies.getItem("my_cookie1")); -docCookies.setItem('my_cookie1', 'Changed value'); +docCookies.setItem("my_cookie1", "Changed value"); console.log(docCookies.my_cookie1); ``` ## Especificações -| Especificações | Status | Comentário | -| ------------------------------------------------------------------------ | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-proxy-objects', 'Proxy')}} | {{Spec2('ES2015')}} | Definição Inicial. | +| Especificações | Status | Comentário | +| ------------------------------------------------------ | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-proxy-objects', 'Proxy')}} | {{Spec2('ES2015')}} | Definição Inicial. | | {{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}} | {{Spec2('ESDraft')}} | ? | ## Navegadores Compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.md b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.md index 74c3e50e8948e7..a6c74dc24f934d 100644 --- a/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.md @@ -54,12 +54,12 @@ try { var a = variavelNaoDefinida; } catch (e) { console.log(e instanceof ReferenceError); // true - console.log(e.message); // "variavelNaoDefinida não está definida" - console.log(e.name); // "ReferenceError" - console.log(e.fileName); // "Scratchpad/1" - console.log(e.lineNumber); // 2 - console.log(e.columnNumber); // 6 - console.log(e.stack); // "@Scratchpad/2:2:7\n" + console.log(e.message); // "variavelNaoDefinida não está definida" + console.log(e.name); // "ReferenceError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 2 + console.log(e.columnNumber); // 6 + console.log(e.stack); // "@Scratchpad/2:2:7\n" } ``` @@ -67,25 +67,25 @@ try { ```js try { - throw new ReferenceError('Olá', 'arquivoQualquer.js', 10); + throw new ReferenceError("Olá", "arquivoQualquer.js", 10); } catch (e) { console.log(e instanceof ReferenceError); // true - console.log(e.message); // "Olá" - console.log(e.name); // "ReferenceError" - console.log(e.fileName); // "arquivoQualquer.js" - console.log(e.lineNumber); // 10 - console.log(e.columnNumber); // 0 - console.log(e.stack); // "@Scratchpad/2:2:9\n" + console.log(e.message); // "Olá" + console.log(e.name); // "ReferenceError" + console.log(e.fileName); // "arquivoQualquer.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" } ``` ## Especificações -| Especificação | Estado | Comentário | -| -------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. | -| {{SpecName('ES5.1', '#sec-15.11.6.3', 'ReferenceError')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentário | +| --------------------------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. | +| {{SpecName('ES5.1', '#sec-15.11.6.3', 'ReferenceError')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.md b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.md index f46f7ec5756620..a6489720f3f47b 100644 --- a/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.md @@ -60,9 +60,9 @@ Reflect.apply("".charAt, "ponies", [3]); ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------ | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-reflect.apply', 'Reflect.apply')}} | {{Spec2('ES6')}} | Definição inicial. | +| Especificação | Status | Comentário | +| -------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-reflect.apply', 'Reflect.apply')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.md b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.md index 8d8aed7c52b234..fabceac77a4588 100644 --- a/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.md @@ -47,11 +47,11 @@ Prior to the introduction of `Reflect`, objects could be constructed using an ar ```js function OneClass() { - this.name = 'one'; + this.name = "one"; } function OtherClass() { - this.name = 'other'; + this.name = "other"; } // Calling this: @@ -77,12 +77,12 @@ When invoking `Reflect.construct()`, on the other hand, the `new.target` operato ```js function OneClass() { - console.log('OneClass'); - console.log(new.target); + console.log("OneClass"); + console.log(new.target); } function OtherClass() { - console.log('OtherClass'); - console.log(new.target); + console.log("OtherClass"); + console.log(new.target); } var obj1 = Reflect.construct(OneClass, args); @@ -114,9 +114,9 @@ d.getFullYear(); // 1776 ## Specifications -| Specification | Status | Comment | -| -------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | -| {{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}} | {{Spec2('ES2015')}} | Initial definition. | +| Specification | Status | Comment | +| ---------------------------------------------------------------------- | -------------------- | ------------------- | +| {{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}} | {{Spec2('ES2015')}} | Initial definition. | | {{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.md b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.md index c9a5238c1be55f..8a602d18b178a2 100644 --- a/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.md @@ -43,9 +43,9 @@ O método `Reflect.defineProperty` permite a adição precisa ou a modificação ### Usando `Reflect.defineProperty()` ```js -let obj = {} -Reflect.defineProperty(obj, 'x', {value: 7}) // true -obj.x // 7 +let obj = {}; +Reflect.defineProperty(obj, "x", { value: 7 }); // true +obj.x; // 7 ``` ### Verificando se a definição da propriedade foi bem-sucedida @@ -64,8 +64,8 @@ if (Reflect.defineProperty(target, property, attributes)) { ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------ | +| Especificação | +| -------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-reflect.defineproperty', 'Reflect.defineProperty')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/index.md b/files/pt-br/web/javascript/reference/global_objects/reflect/index.md index bb59d75f6e97f5..f6411c6e476585 100644 --- a/files/pt-br/web/javascript/reference/global_objects/reflect/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/reflect/index.md @@ -50,16 +50,16 @@ Alguns deste métodos são também os mesmos correspondentes aos métodos em {{j ```js const duck = { - name: 'Maurice', - color: 'white', - greeting: function() { + name: "Maurice", + color: "white", + greeting: function () { console.log(`Quaaaack! My name is ${this.name}`); - } -} + }, +}; -Reflect.has(duck, 'color'); +Reflect.has(duck, "color"); // true -Reflect.has(duck, 'haircut'); +Reflect.has(duck, "haircut"); // false ``` @@ -73,16 +73,16 @@ Reflect.ownKeys(duck); ### Adicionando uma nova propriedade ao objeto ```js -Reflect.set(duck, 'eyes', 'black'); +Reflect.set(duck, "eyes", "black"); // returns "true" if successful // "duck" now contains the property "eyes: 'black'" ``` ## Especificações -| Especificação | Situação | Comentário | -| ---------------------------------------------------------------------------- | ---------------------------- | ------------------------------- | -| {{SpecName('ES6', '#sec-reflect-object', 'Reflect')}} | {{Spec2('ES6')}} | Definição Inicial | +| Especificação | Situação | Comentário | +| --------------------------------------------------------- | -------------------- | ------------------------------- | +| {{SpecName('ES6', '#sec-reflect-object', 'Reflect')}} | {{Spec2('ES6')}} | Definição Inicial | | {{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}} | {{Spec2('ESDraft')}} | Reflect.enumerate foi removido. | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.md b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.md index 3a389371ef7edb..11cab7dc388673 100644 --- a/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.md @@ -64,9 +64,9 @@ Reflect.getOwnPropertyDescriptor(obj, "undefined"); ## Especificações -| Specification | Status | Comment | -| ---------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-reflect.set', 'Reflect.set')}} | {{Spec2('ES6')}} | Definição inicial. | +| Specification | Status | Comment | +| ---------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-reflect.set', 'Reflect.set')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-reflect.set', 'Reflect.set')}} | {{Spec2('ESDraft')}} | | ## Compatilibidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.md index a1964e842f04f5..1f843c2d8c3643 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.md @@ -41,15 +41,15 @@ O método de `compilação` é obsoleto. Você pode simplesmente usar o construt O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova flag. ```js -var regexObj = new RegExp('foo', 'gi'); -regexObj.compile('new foo', 'g'); +var regexObj = new RegExp("foo", "gi"); +regexObj.compile("new foo", "g"); ``` ## Especificações -| Especificação | Estado | Comentario | -| ---------------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------- | -| {{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}} | {{Spec2('ES6')}} | Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. | +| Especificação | Estado | Comentario | +| ------------------------------------------------------------------------------------ | -------------------- | ----------------------------------------------------------------------------------------------------------- | +| {{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}} | {{Spec2('ES6')}} | Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. | | {{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}} | {{Spec2('ESDraft')}} | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. | ## Browser compativeis diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.md index b067db74d1c077..098b258232aaa8 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.md @@ -34,8 +34,8 @@ Considere o exemplo abaixo: // Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles // Relembra "brown" e "jumps" // Ignora caixa (maiúsculo e minúsculo) -var re = /quick\s(brown).+?(jumps)/ig; -var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog'); +var re = /quick\s(brown).+?(jumps)/gi; +var result = re.exec("The Quick Brown Fox Jumps Over The Lazy Dog"); ``` A tabela a seguir provê os resultados do script: @@ -125,11 +125,11 @@ If your regular expression uses the "`g`" flag, you can use the `exec()` method ```js var myRe = /ab*/g; -var str = 'abbcdefabh'; +var str = "abbcdefabh"; var myArray; while ((myArray = myRe.exec(str)) !== null) { - var msg = 'Found ' + myArray[0] + '. '; - msg += 'Next match starts at ' + myRe.lastIndex; + var msg = "Found " + myArray[0] + ". "; + msg += "Next match starts at " + myRe.lastIndex; console.log(msg); } ``` @@ -148,7 +148,7 @@ Nota: Do not place the regular expression literal (or {{jsxref("RegExp")}} const You can also use `exec()` without creating a {{jsxref("RegExp")}} object: ```js -var matches = /(hello \S+)/.exec('This is a hello world!'); +var matches = /(hello \S+)/.exec("This is a hello world!"); console.log(matches[1]); ``` @@ -156,11 +156,11 @@ This will log a message containing 'hello world!'. ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Initial definition. Implemented in JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Initial definition. Implemented in JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.md index 1852073d77836d..3afe4968726cc8 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.md @@ -20,15 +20,15 @@ Você não pode alterar essa propriedade diretamente. ### Usando `ignoreCase` ```js -var regex = new RegExp('foo', 'i'); +var regex = new RegExp("foo", "i"); console.log(regex.ignoreCase); // true ``` ## Especificações -| Especificação | -| ---------------------------------------------------------------------------------------------------------------------------- | +| Especificação | +| ---------------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/index.md index 08ed9b33a03024..c56db9367b42d3 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/index.md @@ -46,7 +46,7 @@ Há dois modos de criar um objeto `RegExp`: uma notação literal e um construto ```js /ab+c/i; -new RegExp('ab+c', 'i'); +new RegExp("ab+c", "i"); ``` A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um _loop_, a expressão regular não será recompilada a cada iteração @@ -59,7 +59,7 @@ Quando se usa a função construtora, as regras de escapar em uma string (preced ```js var re = /\w+/; -var re = new RegExp('\\w+'); +var re = new RegExp("\\w+"); ``` ## Significado dos caracteres especiais nas expressões regulares @@ -696,8 +696,8 @@ O seguinte script usa o método {{jsxref("String.prototype.replace()", "replace( ```js var re = /(\w+)\s(\w+)/; -var str = 'John Smith'; -var newstr = str.replace(re, '$2, $1'); +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); console.log(newstr); ``` @@ -708,9 +708,9 @@ Isto retornará "Smith, John". O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(_split_) de linha fornecida neste exemplo funciona com todas as plataformas. ```js -var text = 'Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim'; +var text = "Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim"; var lines = text.split(/\r\n|\r|\n/); -console.log(lines) // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ] +console.log(lines); // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ] ``` Note que a ordem dos padrões na expressão regular importa. @@ -718,7 +718,7 @@ Note que a ordem dos padrões na expressão regular importa. ### Exemplo: Usando expressão regular sobre múltiplas linhas ```js -var s = 'Please yes\nmake my day!'; +var s = "Please yes\nmake my day!"; s.match(/yes.*day/); // Retorna null s.match(/yes[^]*day/); @@ -730,15 +730,15 @@ s.match(/yes[^]*day/); Este exemplo mostra como utilizar a sticky flag em expressões regulares. ```js -var text = 'First line\nSecond line'; +var text = "First line\nSecond line"; var regex = /(\S+) line\n?/y; var match = regex.exec(text); -console.log(match[1]); // prints 'First' +console.log(match[1]); // prints 'First' console.log(regex.lastIndex); // prints '11' var match2 = regex.exec(text); -console.log(match2[1]); // prints 'Second' +console.log(match2[1]); // prints 'Second' console.log(regex.lastIndex); // prints '22' var match3 = regex.exec(text); @@ -749,8 +749,12 @@ One can test at run-time whether o sticky flag é supported, using `try { … } ```js var supports_sticky; -try { RegExp('', 'y'); supports_sticky = true; } -catch(e) { supports_sticky = false; } +try { + RegExp("", "y"); + supports_sticky = true; +} catch (e) { + supports_sticky = false; +} console.log(supports_sticky); // prints 'true' ``` @@ -759,15 +763,15 @@ console.log(supports_sticky); // prints 'true' As mentioned above, `\w` ou `\W` only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "\_". To match caracteres from other languages such como Cyrillic ou Hebrew, use `\uhhhh`, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra. ```js -var text = 'Образец text на русском языке'; +var text = "Образец text на русском языке"; var regex = /[\u0400-\u04FF]+/g; var match = regex.exec(text); -console.log(match[0]); // prints 'Образец' +console.log(match[0]); // prints 'Образец' console.log(regex.lastIndex); // prints '7' var match2 = regex.exec(text); -console.log(match2[0]); // prints 'на' [não print 'text'] +console.log(match2[0]); // prints 'на' [não print 'text'] console.log(regex.lastIndex); // prints '15' // e assim vai @@ -778,17 +782,17 @@ Here's an external resource para getting o complete Unicode block range para dif ### Exemplo: Extracting subdomain name from URL ```js -var url = 'http://xxx.domain.com'; +var url = "http://xxx.domain.com"; console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx' ``` ## Especificações -| Specification | Status | Comment | -| ------------------------------------------------------------------------------------------------ | ------------------------ | -------------------------------------------------- | -| ECMAScript 1st Edition. | Standard | Initial definition. Implemented em JavaScript 1.1. | -| {{SpecName('ES5.1', '#sec-15.10', 'RegExp')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}} | {{Spec2('ES6')}} | | +| Specification | Status | Comment | +| ----------------------------------------------------------------------- | ------------------ | -------------------------------------------------- | +| ECMAScript 1st Edition. | Standard | Initial definition. Implemented em JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.10', 'RegExp')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.md index b99a0db7f79bb2..2c2fc8342e4dbf 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.md @@ -20,7 +20,7 @@ Você não pode alterar essa propriedade diretamente. Ela é somente para leitur ### Uilizando uma expressão regular com a flag _sticky_ ```js -var str = '#foo#'; +var str = "#foo#"; var regex = /foo/y; regex.lastIndex = 1; @@ -41,20 +41,20 @@ Exemplos de comportamento esperado: ```js var regex = /^foo/y; regex.lastIndex = 2; -regex.test('..foo'); // false - índice 2 não é o início da string +regex.test("..foo"); // false - índice 2 não é o início da string var regex2 = /^foo/my; regex2.lastIndex = 2; -regex2.test('..foo'); // false - índice 2 não é o início da string nem da linha +regex2.test("..foo"); // false - índice 2 não é o início da string nem da linha regex2.lastIndex = 2; -regex2.test('.\nfoo'); // true - índice 2 é o início da linha +regex2.test(".\nfoo"); // true - índice 2 é o início da linha ``` ## Especificações -| Especificação | Estado | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Estado | Comentário | +| -------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.md index 3471b37f4a7a5e..f15ec6c26ae159 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.md @@ -44,12 +44,12 @@ console.log(result); // true O exemplo a seguir mostra uma mensagem dependendo do sucesso do teste. ```js -function testinput(re, str){ +function testinput(re, str) { var midstring; if (re.test(str)) { - midstring = ' Contém '; + midstring = " Contém "; } else { - midstring = ' não contém '; + midstring = " não contém "; } console.log(str + midstring + re.source); } @@ -57,11 +57,11 @@ function testinput(re, str){ ## Specificações -| Specificações | Status | Comentário | -| ------------------------------------------------------------------------------------ | ------------------------ | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}} | {{Spec2('ES6')}} | | +| Specificações | Status | Comentário | +| ---------------------------------------------------------------- | ------------------ | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/tostring/index.md b/files/pt-br/web/javascript/reference/global_objects/regexp/tostring/index.md index 3dd5744b194652..b5b090a5143023 100644 --- a/files/pt-br/web/javascript/reference/global_objects/regexp/tostring/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/regexp/tostring/index.md @@ -12,7 +12,7 @@ O método **`toString()`** retorna uma string que representa uma expressão regu ## Sintaxe ```js -toString() +toString(); ``` ### Valor retornado @@ -33,10 +33,10 @@ representação da expressão regular como string. O exemplo a seguir exibe o valor em string de um objeto {{jsxref("RegExp")}} ```js -const myExp = new RegExp('a+b+c'); -console.log(myExp.toString()); // logs '/a+b+c/' -const foo = new RegExp('bar', 'g'); -console.log(foo.toString()); // logs '/bar/g' +const myExp = new RegExp("a+b+c"); +console.log(myExp.toString()); // logs '/a+b+c/' +const foo = new RegExp("bar", "g"); +console.log(foo.toString()); // logs '/bar/g' ``` ### Expressões regulares vazias e escape @@ -46,8 +46,8 @@ terminadores de linha como "\n" são utilizados ```js new RegExp().toString(); // "/(?:)/" -new RegExp('\n').toString() === '/\n/'; // verdadeiro, antes do ES5 -new RegExp('\n').toString() === '/\\n/'; // verdadeiro, introduzindo o ES5 +new RegExp("\n").toString() === "/\n/"; // verdadeiro, antes do ES5 +new RegExp("\n").toString() === "/\\n/"; // verdadeiro, introduzindo o ES5 ``` ## Especificações diff --git a/files/pt-br/web/javascript/reference/global_objects/set/add/index.md b/files/pt-br/web/javascript/reference/global_objects/set/add/index.md index f95d0a08651605..92c4abe813051e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/add/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/add/index.md @@ -38,9 +38,9 @@ console.log(mySet); ## Especificações -| Especificações | Status | Comentário | -| -------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-set.prototype.add', 'Set.prototype.add')}} | {{Spec2('ES6')}} | Definição inicial. | +| Especificações | Status | Comentário | +| ---------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-set.prototype.add', 'Set.prototype.add')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}} | {{Spec2('ESDraft')}} | | ## Compatilidade de Navegadores (Browser) diff --git a/files/pt-br/web/javascript/reference/global_objects/set/clear/index.md b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.md index 24e5474840c411..8a0b460a3ff77e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/clear/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.md @@ -22,20 +22,20 @@ var mySet = new Set(); mySet.add(1); mySet.add("foo"); -mySet.size; // 2 +mySet.size; // 2 mySet.has("foo"); // true mySet.clear(); -mySet.size; // 0 -mySet.has("bar") // false +mySet.size; // 0 +mySet.has("bar"); // false ``` ## Especificações -| Especificações | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | -| {{SpecName('ES6', '#sec-set.prototype.clear', 'Set.prototype.clear')}} | {{Spec2('ES6')}} | Definições iniciais | +| Especificações | Status | Comentário | +| -------------------------------------------------------------------------- | -------------------- | ------------------- | +| {{SpecName('ES6', '#sec-set.prototype.clear', 'Set.prototype.clear')}} | {{Spec2('ES6')}} | Definições iniciais | | {{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/set/delete/index.md b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.md index 050b4bae1f2396..52691d2cd112e7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/delete/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.md @@ -33,14 +33,14 @@ mySet.add("foo"); mySet.delete("bar"); // Retorna false. Nenhum elemento "bar" foi encontrado para deletar. mySet.delete("foo"); // Retorna true. remoção bem sucedida. -mySet.has("foo"); // Retorna false. O elemento "foo" não está mais presente. +mySet.has("foo"); // Retorna false. O elemento "foo" não está mais presente. ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-set.prototype.delete', 'Set.prototype.delete')}} | {{Spec2('ES6')}} | Definição inicial. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-set.prototype.delete', 'Set.prototype.delete')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/set/entries/index.md b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.md index 11ecf491c84bfa..3ca18a9e981638 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/entries/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.md @@ -32,9 +32,9 @@ console.log(setIter.next().value); // ["baz", "baz"] ## Especificações -| Especificações | Status | Comentário | -| -------------------------------------------------------------------------------------------------------- | ---------------------------- | ----------------- | -| {{SpecName('ES6', '#sec-set.prototype.entries', 'Set.prototype.entries')}} | {{Spec2('ES6')}} | Definição inicial | +| Especificações | Status | Comentário | +| ------------------------------------------------------------------------------ | -------------------- | ----------------- | +| {{SpecName('ES6', '#sec-set.prototype.entries', 'Set.prototype.entries')}} | {{Spec2('ES6')}} | Definição inicial | | {{SpecName('ESDraft', '#sec-set.prototype.entries', 'Set.prototype.entries')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/set/has/index.md b/files/pt-br/web/javascript/reference/global_objects/set/has/index.md index 855dabe55f134d..d817be69c46692 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/has/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/has/index.md @@ -32,25 +32,25 @@ Retorna `true` se um elemento com o valor especificado existe no objeto `Set`; ` ```js var mySet = new Set(); -mySet.add('foo'); +mySet.add("foo"); -mySet.has('foo'); // retorna true -mySet.has('bar'); // retorna false +mySet.has("foo"); // retorna true +mySet.has("bar"); // retorna false var set1 = new Set(); -var obj1 = {'key1': 1}; +var obj1 = { key1: 1 }; set1.add(obj1); -set1.has(obj1); // retorna true -set1.has({'key1': 1}); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes. -set1.add({'key1': 1}); // agora set1 contém 2 registros +set1.has(obj1); // retorna true +set1.has({ key1: 1 }); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes. +set1.add({ key1: 1 }); // agora set1 contém 2 registros ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-set.prototype.has', 'Set.prototype.has')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-set.prototype.has', 'Set.prototype.has')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-set.prototype.has', 'Set.prototype.has')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/set/index.md b/files/pt-br/web/javascript/reference/global_objects/set/index.md index ba43eefac30cd5..c57a26b0a18d2d 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/index.md @@ -64,26 +64,26 @@ meuSet.add(1); // meuSet [1] meuSet.add(5); // meuSet [1, 5] meuSet.add(5); // 5 já foi adicionando, portanto, meuSet [1, 5] meuSet.add("texto"); -var o = {a: 1, b: 2}; +var o = { a: 1, b: 2 }; meuSet.add(o); -meuSet.add({a: 1, b: 2}); // o está referenciando outro objeto +meuSet.add({ a: 1, b: 2 }); // o está referenciando outro objeto meuSet.has(1); // true meuSet.has(3); // false, 3 não foi adicionado ao set (Conjunto) -meuSet.has(5); // true -meuSet.has(Math.sqrt(25)); // true +meuSet.has(5); // true +meuSet.has(Math.sqrt(25)); // true meuSet.has("Texto".toLowerCase()); // true meuSet.has(o); // true meuSet.size; // 5 meuSet.delete(5); // remove 5 do set -meuSet.has(5); // false, 5 já foi removido +meuSet.has(5); // false, 5 já foi removido meuSet.size; // 4, nós simplesmente removemos um valor -console.log(meuSet) // Set { 1, 'texto', { a: 1, b: 2 }, { a: 1, b: 2 } } +console.log(meuSet); // Set { 1, 'texto', { a: 1, b: 2 }, { a: 1, b: 2 } } ``` ### Iterando objetos `Set` @@ -133,56 +133,56 @@ meuSet.forEach(function(value) { ```js function isSuperset(set, subset) { - for (var elem of subset) { - if (!set.has(elem)) { - return false; - } + for (var elem of subset) { + if (!set.has(elem)) { + return false; } - return true; + } + return true; } function uniao(setA, setB) { - var _uniao = new Set(setA); - for (var elem of setB) { - _uniao.add(elem); - } - return _uniao; + var _uniao = new Set(setA); + for (var elem of setB) { + _uniao.add(elem); + } + return _uniao; } function interseccao(setA, setB) { - var _interseccao = new Set(); - for (var elem of setB) { - if (setA.has(elem)) { - _interseccao.add(elem); - } + var _interseccao = new Set(); + for (var elem of setB) { + if (setA.has(elem)) { + _interseccao.add(elem); } - return _interseccao; + } + return _interseccao; } function diferencaSimetrica(setA, setB) { - var _diferenca = new Set(setA); - for (var elem of setB) { - if (_diferenca.has(elem)) { - _diferenca.delete(elem); - } else { - _diferenca.add(elem); - } + var _diferenca = new Set(setA); + for (var elem of setB) { + if (_diferenca.has(elem)) { + _diferenca.delete(elem); + } else { + _diferenca.add(elem); } - return _diferenca; + } + return _diferenca; } function diferenca(setA, setB) { - var _diferenca = new Set(setA); - for (var elem of setB) { - _diferenca.delete(elem); - } - return _diferenca; + var _diferenca = new Set(setA); + for (var elem of setB) { + _diferenca.delete(elem); + } + return _diferenca; } //Exemplos var setA = new Set([1, 2, 3, 4]), - setB = new Set([2, 3]), - setC = new Set([3, 4, 5, 6]); + setB = new Set([2, 3]), + setC = new Set([3, 4, 5, 6]); isSuperset(setA, setB); // => true uniao(setA, setC); // => Set [1, 2, 3, 4, 5, 6] @@ -210,9 +210,9 @@ alert(uneval([...mySet])); // Irá mostrar-lhe exatamente o mesmo Array como myA ```js // Use para remover elementos duplicados de um Array -const numeros = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5] +const numeros = [2, 3, 4, 4, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 5, 32, 3, 4, 5]; -console.log([...new Set(numeros)]) +console.log([...new Set(numeros)]); // [2, 3, 4, 5, 6, 7, 32] ``` @@ -220,17 +220,17 @@ console.log([...new Set(numeros)]) ### Relação com objetos `String` ```js -var texto = 'India'; +var texto = "India"; -var meuSet = new Set(texto); // Set ['I', 'n', 'd', 'i', 'a'] -meuSet.size; // 5 +var meuSet = new Set(texto); // Set ['I', 'n', 'd', 'i', 'a'] +meuSet.size; // 5 ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-set-objects', 'Set')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Status | Comentário | +| -------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-set-objects', 'Set')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-set-objects', 'Set')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/set/values/index.md b/files/pt-br/web/javascript/reference/global_objects/set/values/index.md index 70314ea31c7aab..2f66f9c47e4243 100644 --- a/files/pt-br/web/javascript/reference/global_objects/set/values/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/set/values/index.md @@ -27,9 +27,9 @@ Um novo objeto **`Iterator`** condendo os valores de cada elemento contido no `S ```js var mySet = new Set(); -mySet.add('foo'); -mySet.add('bar'); -mySet.add('baz'); +mySet.add("foo"); +mySet.add("bar"); +mySet.add("baz"); var setIter = mySet.values(); @@ -40,9 +40,9 @@ console.log(setIter.next().value); // "baz" ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------- | -| {{SpecName('ES2015', '#sec-set.prototype.values', 'Set.prototype.values')}} | {{Spec2('ES2015')}} | Definições iniciais. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------- | -------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-set.prototype.values', 'Set.prototype.values')}} | {{Spec2('ES2015')}} | Definições iniciais. | | {{SpecName('ESDraft', '#sec-set.prototype.values', 'Set.prototype.values')}} | {{Spec2('ESDraft')}} | | ## Browsers compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.md b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.md index 622631d61b1a15..3bd3caa3f8503e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.md @@ -22,7 +22,7 @@ Novo objeto `Iterator`. ### Usando `[@@iterator]()` ```js -var str = 'A\uD835\uDC68'; +var str = "A\uD835\uDC68"; var strIter = str[Symbol.iterator](); @@ -33,7 +33,7 @@ console.log(strIter.next().value); // "\uD835\uDC68" ### Usando `[@@iterator]()` com `for..of` ```js -var str = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A'; +var str = "A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A"; for (var v of str) { console.log(v); @@ -48,9 +48,9 @@ for (var v of str) { ## Especificações -| | Status | Comment | -| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}} | {{Spec2('ES2015')}} | Definição inicial. | +| | Status | Comment | +| --------------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.md b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.md index 075d89717913c1..eabb9a28238971 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.md @@ -43,8 +43,8 @@ irá retornar o seguinte código HTML: ## Especificações -| Specification | -| ------------------------------------------------------------------------------------------------------------ | +| Specification | +| ---------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.anchor', 'String.prototype.anchor')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/big/index.md b/files/pt-br/web/javascript/reference/global_objects/string/big/index.md index 9b772f53ccba61..ca10f86440a8e3 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/big/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/big/index.md @@ -31,23 +31,23 @@ O método `big()` cria uma string dentro de uma tag ``: Os exemplos abaixo usam métodos do objeto [String](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings) para alterar o tamanho de uma string: ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; -console.log(worldString.small()); // Olá, mundo -console.log(worldString.big()); // Olá, mundo +console.log(worldString.small()); // Olá, mundo +console.log(worldString.big()); // Olá, mundo console.log(worldString.fontsize(7)); // Olá, Mundo ``` Com o objeto `element.style` você pode selecionar o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo: ```js -document.getElementById('#oIdDoElemento').style.fontSize = '2em'; +document.getElementById("#oIdDoElemento").style.fontSize = "2em"; ``` ## Especificações -| Specification | -| ---------------------------------------------------------------------------------------------------- | +| Specification | +| ---------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/blink/index.md b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.md index 683f468560a1e6..ee08c5d7ed84c3 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/blink/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.md @@ -31,18 +31,18 @@ O método `blink()` cria uma string dentro de uma tag ``: Os exemplos abaixo usam métodos do objeto [String](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings) para alterar a formatação de uma string: ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; -console.log(worldString.blink()); // Olá, mundo -console.log(worldString.bold()); // Olá, mundo +console.log(worldString.blink()); // Olá, mundo +console.log(worldString.bold()); // Olá, mundo console.log(worldString.italics()); // Olá, mundo -console.log(worldString.strike()); // Olá, mundo +console.log(worldString.strike()); // Olá, mundo ``` ## Especificações -| Specification | -| ------------------------------------------------------------------------------------------------------------ | +| Specification | +| -------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/bold/index.md b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.md index fd9738b0e26913..1287b7492b6de3 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/bold/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.md @@ -29,18 +29,18 @@ O método `bold()` cria uma string dentro de uma tag ``: Os exemplos abaixo usam métodos do objeto [String](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings) para alterar a formatação de uma string: ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; -console.log(worldString.blink()); // Olá, mundo -console.log(worldString.bold()); // Olá, mundo +console.log(worldString.blink()); // Olá, mundo +console.log(worldString.bold()); // Olá, mundo console.log(worldString.italics()); // Olá, mundo -console.log(worldString.strike()); // Olá, mundo +console.log(worldString.strike()); // Olá, mundo ``` ## Especificações -| Specification | -| -------------------------------------------------------------------------------------------------------- | +| Specification | +| ------------------------------------------------------------------------------ | | {{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charat/index.md b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.md index f0db11cf33032b..d3d63b55f1d08f 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/charat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.md @@ -35,13 +35,13 @@ Se nenhum índice for passado para `charAt()`, `0` será usado por padrão. O exemplo a seguir mostra caracteres em diferentes locais em uma string `"Brave new world"`: ```js -var anyString = 'Brave new world'; +var anyString = "Brave new world"; -console.log("A letra no índice 0 é '" + anyString.charAt(0) + "'"); -console.log("A letra no índice 1 é '" + anyString.charAt(1) + "'"); -console.log("A letra no índice 2 é '" + anyString.charAt(2) + "'"); -console.log("A letra no índice 3 é '" + anyString.charAt(3) + "'"); -console.log("A letra no índice 4 é '" + anyString.charAt(4) + "'"); +console.log("A letra no índice 0 é '" + anyString.charAt(0) + "'"); +console.log("A letra no índice 1 é '" + anyString.charAt(1) + "'"); +console.log("A letra no índice 2 é '" + anyString.charAt(2) + "'"); +console.log("A letra no índice 3 é '" + anyString.charAt(3) + "'"); +console.log("A letra no índice 4 é '" + anyString.charAt(4) + "'"); console.log("A letra no índice 99 é '" + anyString.charAt(999) + "'"); ``` @@ -61,7 +61,7 @@ A letra no índice 99 é '' O seguinte código fornece um meio de garantir que passar por um loop de string sempre forneça um caractere inteiro, mesmo se a string contiver caracteres que não estão no [Plano Multilíngue Básico](). ```js -var str = 'A \uD87E\uDC04 Z'; // We could also use a non-BMP character directly +var str = "A \uD87E\uDC04 Z"; // We could also use a non-BMP character directly for (var i = 0, chr; i < str.length; i++) { if ((chr = getWholeChar(str, i)) === false) { continue; @@ -77,34 +77,34 @@ function getWholeChar(str, i) { var code = str.charCodeAt(i); if (isNaN(code)) { - return ''; // Position not found + return ""; // Position not found } - if (code < 0xD800 || code > 0xDFFF) { + if (code < 0xd800 || code > 0xdfff) { return str.charAt(i); } // High surrogate (could change last hex to 0xDB7F to treat high private // surrogates as single characters) - if (0xD800 <= code && code <= 0xDBFF) { - if (str.length <= (i + 1)) { - throw 'High surrogate without following low surrogate'; + if (0xd800 <= code && code <= 0xdbff) { + if (str.length <= i + 1) { + throw "High surrogate without following low surrogate"; } var next = str.charCodeAt(i + 1); - if (0xDC00 > next || next > 0xDFFF) { - throw 'High surrogate without following low surrogate'; - } - return str.charAt(i) + str.charAt(i + 1); + if (0xdc00 > next || next > 0xdfff) { + throw "High surrogate without following low surrogate"; + } + return str.charAt(i) + str.charAt(i + 1); } // Low surrogate (0xDC00 <= code && code <= 0xDFFF) if (i === 0) { - throw 'Low surrogate without preceding high surrogate'; + throw "Low surrogate without preceding high surrogate"; } var prev = str.charCodeAt(i - 1); // (could change last hex to 0xDB7F to treat high private // surrogates as single characters) - if (0xD800 > prev || prev > 0xDBFF) { - throw 'Low surrogate without preceding high surrogate'; + if (0xd800 > prev || prev > 0xdbff) { + throw "Low surrogate without preceding high surrogate"; } // We can pass over low surrogates now as the second component // in a pair which we have already processed @@ -115,7 +115,7 @@ function getWholeChar(str, i) { Em um ambiente ECMAScript 2016 que permite atribuição desestruturada, o seguinte código é uma alternativa mais sucinta e um pouco mais flexível, pois faz incremento para uma variável de incremento automaticamente (se o caractere justificar que seja um par substituto). ```js -var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly +var str = "A\uD87E\uDC04Z"; // We could also use a non-BMP character directly for (var i = 0, chr; i < str.length; i++) { [chr, i] = getWholeCharAndI(str, i); // Adapt this line at the top of each loop, passing in the whole string and @@ -129,34 +129,34 @@ function getWholeCharAndI(str, i) { var code = str.charCodeAt(i); if (isNaN(code)) { - return ''; // Position not found + return ""; // Position not found } - if (code < 0xD800 || code > 0xDFFF) { + if (code < 0xd800 || code > 0xdfff) { return [str.charAt(i), i]; // Normal character, keeping 'i' the same } // High surrogate (could change last hex to 0xDB7F to treat high private // surrogates as single characters) - if (0xD800 <= code && code <= 0xDBFF) { - if (str.length <= (i + 1)) { - throw 'High surrogate without following low surrogate'; + if (0xd800 <= code && code <= 0xdbff) { + if (str.length <= i + 1) { + throw "High surrogate without following low surrogate"; } var next = str.charCodeAt(i + 1); - if (0xDC00 > next || next > 0xDFFF) { - throw 'High surrogate without following low surrogate'; - } - return [str.charAt(i) + str.charAt(i + 1), i + 1]; + if (0xdc00 > next || next > 0xdfff) { + throw "High surrogate without following low surrogate"; + } + return [str.charAt(i) + str.charAt(i + 1), i + 1]; } // Low surrogate (0xDC00 <= code && code <= 0xDFFF) if (i === 0) { - throw 'Low surrogate without preceding high surrogate'; + throw "Low surrogate without preceding high surrogate"; } var prev = str.charCodeAt(i - 1); // (could change last hex to 0xDB7F to treat high private surrogates // as single characters) - if (0xD800 > prev || prev > 0xDBFF) { - throw 'Low surrogate without preceding high surrogate'; + if (0xd800 > prev || prev > 0xdbff) { + throw "Low surrogate without preceding high surrogate"; } // Return the next character instead (and increment) return [str.charAt(i + 1), i + 1]; @@ -169,12 +169,12 @@ Embora o exemplo anterior possa ser mais útil para programas que devem suportar ```js function fixedCharAt(str, idx) { - var ret = ''; - str += ''; + var ret = ""; + str += ""; var end = str.length; var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; - while ((surrogatePairs.exec(str)) != null) { + while (surrogatePairs.exec(str) != null) { var li = surrogatePairs.lastIndex; if (li - 2 < idx) { idx++; @@ -184,12 +184,15 @@ function fixedCharAt(str, idx) { } if (idx >= end || idx < 0) { - return ''; + return ""; } ret += str.charAt(idx); - if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) { + if ( + /[\uD800-\uDBFF]/.test(ret) && + /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1)) + ) { // Go one further, since one of the "characters" is part of a surrogate pair ret += str.charAt(idx + 1); } @@ -199,11 +202,11 @@ function fixedCharAt(str, idx) { ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------------------- | ------------------------ | ------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. | -| {{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ------------------------------------------------------------------------------ | ------------------ | ------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial definition. | +| {{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.md b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.md index 37a33c4bb716a5..efd2ae1e5ee2cb 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.md @@ -39,7 +39,7 @@ Compatibilidade com versões anteriores: Em versões históricas (como JavaScrip O exemplo a seguir retorna `65`, o valor Unicode para A. ```js -'ABC'.charCodeAt(0); // retorna 65 +"ABC".charCodeAt(0); // retorna 65 ``` ### Corrigindo o `charCodeAt()` para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida @@ -56,15 +56,16 @@ function fixedCharCodeAt(str, idx) { // Substituto elevado (poderia mudar o último hex para 0xDB7F para tratar // substitutos privados elevados como caracteres únicos) - if (0xD800 <= code && code <= 0xDBFF) { + if (0xd800 <= code && code <= 0xdbff) { hi = code; low = str.charCodeAt(idx + 1); if (isNaN(low)) { - throw 'High surrogate not followed by low surrogate in fixedCharCodeAt()'; + throw "High surrogate not followed by low surrogate in fixedCharCodeAt()"; } - return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + return (hi - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000; } - if (0xDC00 <= code && code <= 0xDFFF) { // Low surrogate + if (0xdc00 <= code && code <= 0xdfff) { + // Low surrogate // Retornamos false para permitir os loops pularem essa iteração já que já deveria //ter tratado os substitutos elevados acima, na iteração anterior return false; @@ -80,17 +81,16 @@ function fixedCharCodeAt(str, idx) { ```js function knownCharCodeAt(str, idx) { - str += ''; + str += ""; var code, - end = str.length; + end = str.length; var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; - while ((surrogatePairs.exec(str)) != null) { + while (surrogatePairs.exec(str) != null) { var li = surrogatePairs.lastIndex; if (li - 2 < idx) { idx++; - } - else { + } else { break; } } @@ -102,11 +102,11 @@ function knownCharCodeAt(str, idx) { code = str.charCodeAt(idx); var hi, low; - if (0xD800 <= code && code <= 0xDBFF) { + if (0xd800 <= code && code <= 0xdbff) { hi = code; low = str.charCodeAt(idx + 1); // Vá um adiante, já que um dos "characters" é parte de um par substituto - return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000; + return (hi - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000; } return code; } @@ -114,11 +114,11 @@ function knownCharCodeAt(str, idx) { ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ------------------------------------------------------------------------------------------ | -------------------- | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.md b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.md index 11d8f624e618f5..add50771b7000d 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.md @@ -35,18 +35,18 @@ O seguinte código cria no objeto global String a função `codePointAt()` confo ```js /*! https://mths.be/codepointat v0.2.0 by @mathias */ if (!String.prototype.codePointAt) { - (function() { - 'use strict'; // needed to support `apply`/`call` with `undefined`/`null` - var defineProperty = (function() { + (function () { + "use strict"; // needed to support `apply`/`call` with `undefined`/`null` + var defineProperty = (function () { // IE 8 only supports `Object.defineProperty` on DOM elements try { var object = {}; var $defineProperty = Object.defineProperty; var result = $defineProperty(object, object, object) && $defineProperty; - } catch(error) {} + } catch (error) {} return result; - }()); - var codePointAt = function(position) { + })(); + var codePointAt = function (position) { if (this == null) { throw TypeError(); } @@ -54,7 +54,8 @@ if (!String.prototype.codePointAt) { var size = string.length; // `ToInteger` var index = position ? Number(position) : 0; - if (index != index) { // better `isNaN` + if (index != index) { + // better `isNaN` index = 0; } // Account for out-of-bounds indices: @@ -64,28 +65,31 @@ if (!String.prototype.codePointAt) { // Get the first code unit var first = string.charCodeAt(index); var second; - if ( // check if it’s the start of a surrogate pair - first >= 0xD800 && first <= 0xDBFF && // high surrogate + if ( + // check if it’s the start of a surrogate pair + first >= 0xd800 && + first <= 0xdbff && // high surrogate size > index + 1 // there is a next code unit ) { second = string.charCodeAt(index + 1); - if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate + if (second >= 0xdc00 && second <= 0xdfff) { + // low surrogate // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae - return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + return (first - 0xd800) * 0x400 + second - 0xdc00 + 0x10000; } } return first; }; if (defineProperty) { - defineProperty(String.prototype, 'codePointAt', { - 'value': codePointAt, - 'configurable': true, - 'writable': true + defineProperty(String.prototype, "codePointAt", { + value: codePointAt, + configurable: true, + writable: true, }); } else { String.prototype.codePointAt = codePointAt; } - }()); + })(); } ``` @@ -94,25 +98,25 @@ if (!String.prototype.codePointAt) { ### Usando `codePointAt()` ```js -'ABC'.codePointAt(1) // retorna 66 -'\uD800\uDC00'.codePointAt(0) // retorna 65536 +"ABC".codePointAt(1); // retorna 66 +"\uD800\uDC00".codePointAt(0); // retorna 65536 -'XYZ'.codePointAt(42) // retorna undefined +"XYZ".codePointAt(42); // retorna undefined ``` ### Criando um loop com `codePointAt()` ```js -for (let codePoint of '\ud83d\udc0e\ud83d\udc71\u2764') { - console.log(codePoint.codePointAt(0).toString(16)) +for (let codePoint of "\ud83d\udc0e\ud83d\udc71\u2764") { + console.log(codePoint.codePointAt(0).toString(16)); } // retorna '1f40e', '1f471', '2764' ``` ## Especificações -| Especificação | -| ---------------------------------------------------------------------------------------------------------------------------- | +| Especificação | +| -------------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/concat/index.md b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.md index afac81c26ae406..e41911d3363412 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/concat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.md @@ -39,19 +39,19 @@ Se o argumento passado não for do tipo string, o mesmo será convertido em uma O exemplo a seguir concatena uma string à outra string originando uma terceira string. ```js -var hello = 'Olá, '; -console.log(hello.concat('Kevin', ' tenha um bom dia.')); +var hello = "Olá, "; +console.log(hello.concat("Kevin", " tenha um bom dia.")); // retorna 'Olá, Kevin tenha um bom dia.' ``` ## Especificações -| Especificação | Status | Comentários | -| -------------------------------------------------------------------------------------------------------- | ------------------------ | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentários | +| ------------------------------------------------------------------------------ | ------------------ | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.md b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.md index 385f437c20c8a6..b289044048c717 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.md @@ -33,11 +33,11 @@ Este método permite que você verifique se uma string termina ou não com deter ### Usando `endsWith()` ```js -var str = 'Ser ou não ser, eis a questão'; +var str = "Ser ou não ser, eis a questão"; -console.log(str.endsWith('questão')); // retorna true -console.log(str.endsWith('ser')); // retorna false -console.log(str.endsWith('ser', 14)); // retorna true +console.log(str.endsWith("questão")); // retorna true +console.log(str.endsWith("ser")); // retorna false +console.log(str.endsWith("ser", 14)); // retorna true ``` ## Polyfill @@ -46,23 +46,22 @@ Este método foi adicionada na especificação ECMAScript 6 e talvez não esteja ```js if (!String.prototype.endsWith) - String.prototype.endsWith = function(searchStr, Position) { - // This works much better than >= because - // it compensates for NaN: - if (!(Position < this.length)) - Position = this.length; - else - Position |= 0; // round position - return this.substr(Position - searchStr.length, - searchStr.length) === searchStr; + String.prototype.endsWith = function (searchStr, Position) { + // This works much better than >= because + // it compensates for NaN: + if (!(Position < this.length)) Position = this.length; + else Position |= 0; // round position + return ( + this.substr(Position - searchStr.length, searchStr.length) === searchStr + ); }; ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}} | {{Spec2('ES6')}} | Definição inicial. | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES6', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}} | {{Spec2('ES6')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.md b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.md index 94e6a1ab0385b9..9e2c5147866684 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.md @@ -29,14 +29,14 @@ O método `fixed()` cria uma string dentro de uma tag ``: O exemplo a seguir usa o método `fixed()` para alterar a formatação de uma string: ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; console.log(worldString.fixed()); // "Olá, mundo" ``` ## Especificações -| Specification | -| ------------------------------------------------------------------------------------------------------------ | +| Specification | +| -------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.md b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.md index 72ddb130b21545..35ea0c0efa5715 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.md @@ -35,25 +35,27 @@ Se você expressar uma cor em formato hexadecimal, deve usar o formato `rrggbb`. O exemplo a seguir usa o método `fontcolor()` para alterar a cor de uma string, produzindo uma string com a tag HTML ``. ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; -console.log(worldString.fontcolor('red') + ' está vermelho nesta linha'); +console.log(worldString.fontcolor("red") + " está vermelho nesta linha"); // 'Olá, mundo está vermelho nesta linha' -console.log(worldString.fontcolor('FF00') + ' está vermelho em hexadecimal nesta linha'); +console.log( + worldString.fontcolor("FF00") + " está vermelho em hexadecimal nesta linha", +); // 'Olá, mundo está vermelho em hexadecimal nesta linha' ``` Com o objeto [`element.style`](/pt-BR/docs/Web/API/ElementCSSInlineStyle/style) você pode obter o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo: ```js -document.getElementById('#oIdDoElemento').style.color = 'red'; +document.getElementById("#oIdDoElemento").style.color = "red"; ``` ## Especificações -| Specification | -| -------------------------------------------------------------------------------------------------------------------- | +| Specification | +| ---------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.md b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.md index d0d11f45b9eb5c..3e64752c08baf3 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.md @@ -35,23 +35,23 @@ Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do tex O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string: ```js -var worldString = 'Olá, mundo'; +var worldString = "Olá, mundo"; -console.log(worldString.small()); // Olá, mundo -console.log(worldString.big()); // Olá, mundo +console.log(worldString.small()); // Olá, mundo +console.log(worldString.big()); // Olá, mundo console.log(worldString.fontsize(7)); // Olá, mundo ``` Com o objeto [`element.style`](/pt-BR/docs/Web/API/ElementCSSInlineStyle/style) você pode obter o atributo `style` do elemento e manipulá-lo de forma mais genérica, por exemplo: ```js -document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +document.getElementById("#oIdDoElemento").style.fontSize = "0.7em"; ``` ## Especificações -| Specification | -| -------------------------------------------------------------------------------------------------------------------- | +| Specification | +| -------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.md b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.md index d02c60b5a1e21a..92f5817bb77f43 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.md @@ -35,7 +35,7 @@ Como `fromCharCode()` é um método estático de {{jsxref("String")}}, você sem O seguinte exemplo retorna a string "ABC". ```js -String.fromCharCode(65, 66, 67); // retorna "ABC" +String.fromCharCode(65, 66, 67); // retorna "ABC" ``` ## Fazendo-o funcionar com valores maiores @@ -44,11 +44,11 @@ Embora os valores Unicode mais comuns possam ser representados com um número de ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| --------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.md b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.md index 12548d2e078a92..b537850d106784 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.md @@ -32,19 +32,19 @@ Como o fromCodePoint() é um método estático do {{jsxref("String")}}, você se ### Usando `fromCodePoint()` ```js -String.fromCodePoint(42); // "*" -String.fromCodePoint(65, 90); // "AZ" -String.fromCodePoint(0x404); // "\u0404" -String.fromCodePoint(0x2F804); // "\uD87E\uDC04" -String.fromCodePoint(194564); // "\uD87E\uDC04" -String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07" - -String.fromCodePoint('_'); // RangeError +String.fromCodePoint(42); // "*" +String.fromCodePoint(65, 90); // "AZ" +String.fromCodePoint(0x404); // "\u0404" +String.fromCodePoint(0x2f804); // "\uD87E\uDC04" +String.fromCodePoint(194564); // "\uD87E\uDC04" +String.fromCodePoint(0x1d306, 0x61, 0x1d307); // "\uD834\uDF06a\uD834\uDF07" + +String.fromCodePoint("_"); // RangeError String.fromCodePoint(Infinity); // RangeError -String.fromCodePoint(-1); // RangeError -String.fromCodePoint(3.14); // RangeError -String.fromCodePoint(3e-2); // RangeError -String.fromCodePoint(NaN); // RangeError +String.fromCodePoint(-1); // RangeError +String.fromCodePoint(3.14); // RangeError +String.fromCodePoint(3e-2); // RangeError +String.fromCodePoint(NaN); // RangeError ``` ```js @@ -52,7 +52,7 @@ String.fromCodePoint(NaN); // RangeError // The following, on the other hand, can return a 4-byte character as well as the // usual 2-byte ones (i.e., it can return a single character which actually has // a string length of 2 instead of 1!) -console.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal +console.log(String.fromCodePoint(0x2f804)); // or 194564 in decimal ``` ## Polyfill @@ -62,19 +62,19 @@ O método **String.fromCodePoint** foi adicionado ao padrão ECMAScript na vers ```js /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ if (!String.fromCodePoint) { - (function() { - var defineProperty = (function() { + (function () { + var defineProperty = (function () { // IE 8 only supports `Object.defineProperty` on DOM elements try { var object = {}; var $defineProperty = Object.defineProperty; var result = $defineProperty(object, object, object) && $defineProperty; - } catch(error) {} + } catch (error) {} return result; - }()); + })(); var stringFromCharCode = String.fromCharCode; var floor = Math.floor; - var fromCodePoint = function() { + var fromCodePoint = function () { var MAX_SIZE = 0x4000; var codeUnits = []; var highSurrogate; @@ -82,26 +82,28 @@ if (!String.fromCodePoint) { var index = -1; var length = arguments.length; if (!length) { - return ''; + return ""; } - var result = ''; + var result = ""; while (++index < length) { var codePoint = Number(arguments[index]); if ( - !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` - codePoint < 0 || // not a valid Unicode code point - codePoint > 0x10FFFF || // not a valid Unicode code point + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10ffff || // not a valid Unicode code point floor(codePoint) != codePoint // not an integer ) { - throw RangeError('Invalid code point: ' + codePoint); + throw RangeError("Invalid code point: " + codePoint); } - if (codePoint <= 0xFFFF) { // BMP code point + if (codePoint <= 0xffff) { + // BMP code point codeUnits.push(codePoint); - } else { // Astral code point; split in surrogate halves + } else { + // Astral code point; split in surrogate halves // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae codePoint -= 0x10000; - highSurrogate = (codePoint >> 10) + 0xD800; - lowSurrogate = (codePoint % 0x400) + 0xDC00; + highSurrogate = (codePoint >> 10) + 0xd800; + lowSurrogate = (codePoint % 0x400) + 0xdc00; codeUnits.push(highSurrogate, lowSurrogate); } if (index + 1 == length || codeUnits.length > MAX_SIZE) { @@ -112,22 +114,22 @@ if (!String.fromCodePoint) { return result; }; if (defineProperty) { - defineProperty(String, 'fromCodePoint', { - 'value': fromCodePoint, - 'configurable': true, - 'writable': true + defineProperty(String, "fromCodePoint", { + value: fromCodePoint, + configurable: true, + writable: true, }); } else { String.fromCodePoint = fromCodePoint; } - }()); + })(); } ``` ## Especificações -| Specification | Status | Comment | -| ------------------------------------------------------------------------------------------------ | -------------------- | ------------------- | +| Specification | Status | Comment | +| ------------------------------------------------------------------------ | ---------------- | ------------------- | | {{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}} | {{Spec2('ES6')}} | Initial definition. | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/includes/index.md b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.md index bb7539bd494931..dd621e60882c44 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/includes/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.md @@ -33,7 +33,7 @@ Este método permite conferir se uma string contém um determinado conjunto de c O método `includes()` é case sensitive. Por exemplo, a seguinte expressão retorna `false`: ```js -'Bandeira do Brasil'.includes('brasil'); // retorna false +"Bandeira do Brasil".includes("brasil"); // retorna false ``` ## Exemplos @@ -41,13 +41,13 @@ O método `includes()` é case sensitive. Por exemplo, a seguinte expressão ret ### Utilizando `includes()` ```js -var str = 'Ser, ou não ser, eis a questão.'; +var str = "Ser, ou não ser, eis a questão."; -console.log(str.includes('Ser')); // true -console.log(str.includes('questão')); // true -console.log(str.includes('não existe')); // false -console.log(str.includes('ser', 1)); // true -console.log(str.includes('SER')); // false +console.log(str.includes("Ser")); // true +console.log(str.includes("questão")); // true +console.log(str.includes("não existe")); // false +console.log(str.includes("ser", 1)); // true +console.log(str.includes("SER")); // false ``` ## Implementação @@ -56,7 +56,8 @@ Este método foi adicionado à especificação ECMAScript 6 e pode não estar di ```js if (!String.prototype.includes) { - String.prototype.includes = function() {'use strict'; + String.prototype.includes = function () { + "use strict"; return String.prototype.indexOf.apply(this, arguments) !== -1; }; } @@ -64,8 +65,8 @@ if (!String.prototype.includes) { ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------ | -------------------- | ------------------ | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------------- | ---------------- | ------------------ | | {{SpecName('ES6', '#sec-string.prototype.includes', 'String.prototype.includes')}} | {{Spec2('ES6')}} | Definição inicial. | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/index.md b/files/pt-br/web/javascript/reference/global_objects/string/index.md index 632556090216e0..e2b2fc613c557c 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/index.md @@ -2,6 +2,7 @@ title: String slug: Web/JavaScript/Reference/Global_Objects/String --- + {{JSRef("Global_Objects", "String")}} ## Sumário @@ -56,13 +57,13 @@ Strings são úteis para guardar dados que podem ser representados em forma de t Há duas maneiras de acessar um caractere individual em uma string. A primeira é o método {{jsxref("String.charAt", "charAt")}}: ```js -return 'cat'.charAt(1); // returns "a" +return "cat".charAt(1); // returns "a" ``` A outra maneira (introduzido no ECMAScript 5) consiste em tratar a string como um objeto Array-like, onde os caráteres individuais correspondem a um índice numérico: ```js -return 'cat'[1]; // returns "a" +return "cat"[1]; // returns "a" ``` Para acesso de caracteres usando uma notação de colchetes, tentando deletar ou designar um valor a estas propriedades não haverá sucesso. As propriedades envolvidas não são nem escritas ou configuráveis. (Veja {{jsxref("Object.defineProperty")}} para mais informações.) @@ -74,12 +75,11 @@ Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScri ```js var a = "a"; var b = "b"; -if (a < b) // verdadeiro +if (a < b) + // verdadeiro print(a + " é menor que " + b); -else if (a > b) - print(a + " é maior que " + b); -else - print(a + " e " + b + " são iguais."); +else if (a > b) print(a + " é maior que " + b); +else print(a + " e " + b + " são iguais."); ``` Um resultado similar pode ser alcançado usando o método {{jsxref("String.localeCompare", "localeCompare")}} herdado pelas instâncias de `String`. @@ -95,16 +95,16 @@ var s_prim = "foo"; var s_obj = new String(s_prim); console.log(typeof s_prim); // Loga "string" -console.log(typeof s_obj); // Loga "object" +console.log(typeof s_obj); // Loga "object" ``` String primitivas e objetos `String` também dão resultados diferentes quando usado {{jsxref("Global_Objects/eval", "eval")}}. Primitivas passadas para `eval` são tratadas como código fonte; Objetos `String` são tratados como todos os outros objetos são, retornando o objeto. Por exemplo: ```js -s1 = "2 + 2"; // cria uma string primitiva -s2 = new String("2 + 2"); // cria um objeto de String -console.log(eval(s1)); // retorna o número 4 -console.log(eval(s2)); // retorna a string "2 + 2" +s1 = "2 + 2"; // cria uma string primitiva +s2 = new String("2 + 2"); // cria um objeto de String +console.log(eval(s1)); // retorna o número 4 +console.log(eval(s2)); // retorna a string "2 + 2" ``` Por estas razões, o código pode quebrar quando encontra objetos `String` quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção. @@ -135,7 +135,7 @@ Métodos de instância `String` também estão disponíveis no Firefox a partir ```js var num = 15; -alert(String.replace(num, /5/, '2')); +alert(String.replace(num, /5/, "2")); ``` [Genéricos](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods) também estão disponíveis em métodos {{jsxref("Global_Objects/Array", "Array")}}. @@ -147,32 +147,50 @@ O seguinte é uma implementação para fornecer suporte a navegadores sem suport // Assume que todos os métodos de instância String fornecidos // já presentes (podem ser usadas implementações para este se não disponível) (function () { - 'use strict'; - - var i, - // Nós também poderíamos construir o array de métodos com os seguintes, - // mas o método getOwnPropertyNames() não é implementável: - // Object.getOwnPropertyNames(String).filter(function (methodName) - // {return typeof String[methodName] === 'function'}); - methods = [ - 'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt', - 'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith', - 'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase', - 'toLocaleUpperCase', 'localeCompare', 'match', 'search', - 'replace', 'split', 'substr', 'concat', 'slice' - ], - methodCount = methods.length, - assignStringGeneric = function (methodName) { - var method = String.prototype[methodName]; - String[methodName] = function (arg1) { - return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); - }; - }; - - for (i = 0; i < methodCount; i++) { - assignStringGeneric(methods[i]); - } -}()); + "use strict"; + + var i, + // Nós também poderíamos construir o array de métodos com os seguintes, + // mas o método getOwnPropertyNames() não é implementável: + // Object.getOwnPropertyNames(String).filter(function (methodName) + // {return typeof String[methodName] === 'function'}); + methods = [ + "quote", + "substring", + "toLowerCase", + "toUpperCase", + "charAt", + "charCodeAt", + "indexOf", + "lastIndexOf", + "startsWith", + "endsWith", + "trim", + "trimLeft", + "trimRight", + "toLocaleLowerCase", + "toLocaleUpperCase", + "localeCompare", + "match", + "search", + "replace", + "split", + "substr", + "concat", + "slice", + ], + methodCount = methods.length, + assignStringGeneric = function (methodName) { + var method = String.prototype[methodName]; + String[methodName] = function (arg1) { + return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); + }; + }; + + for (i = 0; i < methodCount; i++) { + assignStringGeneric(methods[i]); + } +})(); ``` ## Instâncias de `String` @@ -206,11 +224,11 @@ for (let i = 0, n = inputValues.length; i < n; ++i) { ## Especificações -| Specification | Status | Comment | -| -------------------------------------------------------------------- | ------------------------ | -------------------- | -| ECMAScript 1st Edition. | Standard | Definições iniciais. | +| Specification | Status | Comment | +| ---------------------------------------------------- | ------------------ | -------------------- | +| ECMAScript 1st Edition. | Standard | Definições iniciais. | | {{SpecName('ES5.1', '#sec-15.5', 'String')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string-objects', 'String')}} | {{Spec2('ES6')}} | | +| {{SpecName('ES6', '#sec-string-objects', 'String')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.md b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.md index f84f145c3549e2..a536f9aaa47eb7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.md @@ -31,18 +31,18 @@ O índice da primeira ocorrência de _searchValue_, ou `-1` se não for encontra Uma string vazia no _searchValue_ produz resultados estranhos. Sem `fromIndex`, ou com qualquer `fromIndex` menor que o comprimento da string, o valor retornado é o próprio `fromIndex`: ```js -'Olá, mundo'.indexOf('') // retorna 0 -'Olá, mundo'.indexOf('', 0) // retorna 0 -'Olá, mundo'.indexOf('', 3) // retorna 3 -'Olá, mundo'.indexOf('', 8) // retorna 8 +"Olá, mundo".indexOf(""); // retorna 0 +"Olá, mundo".indexOf("", 0); // retorna 0 +"Olá, mundo".indexOf("", 3); // retorna 3 +"Olá, mundo".indexOf("", 8); // retorna 8 ``` Entretanto, com qualquer `fromIndex` igual ou maior que o comprimento da string, o valor retornado é o comprimento da string: ```js -'Olá, mundo'.indexOf('', 11) // retorna 10 -'Olá, mundo'.indexOf('', 13) // retorna 10 -'Olá, mundo'.indexOf('', 22) // retorna 10 +"Olá, mundo".indexOf("", 11); // retorna 10 +"Olá, mundo".indexOf("", 13); // retorna 10 +"Olá, mundo".indexOf("", 22); // retorna 10 ``` ## Descrição @@ -50,16 +50,16 @@ Entretanto, com qualquer `fromIndex` igual ou maior que o comprimento da string, Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é `0`, e o índice do último caractere de uma string chamada `stringName` é `stringName.length - 1`. ```js -"Blue Whale".indexOf("Blue"); // retorna 0 -"Blue Whale".indexOf("Whale"); // retorna 5 -"Blue Whale".indexOf("Blute"); // retorna -1 +"Blue Whale".indexOf("Blue"); // retorna 0 +"Blue Whale".indexOf("Whale"); // retorna 5 +"Blue Whale".indexOf("Blute"); // retorna -1 "Blue Whale".indexOf("Whale", 0); // retorna 5 "Blue Whale".indexOf("Whale", 5); // retorna 5 "Blue Whale".indexOf("Whale", 7); // retorna -1 -"Blue Whale".indexOf(""); // retorna 0 -"Blue Whale".indexOf("", 9); // retorna 9 -"Blue Whale".indexOf("", 10); // retorna 10 -"Blue Whale".indexOf("", 11); // retorna 10 +"Blue Whale".indexOf(""); // retorna 0 +"Blue Whale".indexOf("", 9); // retorna 9 +"Blue Whale".indexOf("", 10); // retorna 10 +"Blue Whale".indexOf("", 11); // retorna 10 ``` ### Verificando ocorrências @@ -80,10 +80,14 @@ O exemplo a seguir usa `indexOf()` para localizar valores dentro da string "`Bra ```js var anyString = "Brave new world"; -console.log("O índice do primeiro w partindo do começo é " + anyString.indexOf("w")); +console.log( + "O índice do primeiro w partindo do começo é " + anyString.indexOf("w"), +); // Exibe 8 -console.log("O índice de 'new' partindo do começo é " + anyString.indexOf("new")); +console.log( + "O índice de 'new' partindo do começo é " + anyString.indexOf("new"), +); // Exibe 6 ``` @@ -92,12 +96,14 @@ console.log("O índice de 'new' partindo do começo é " + anyString.indexOf("ne O exemplo a seguir define duas variáveis string. Ambas contém a mesma string, exceto que a segunda string tem letras maiúsculas. O primeiro método {{domxref("console.log()")}} exibe `19`. Porém, como o método `indexOf` é sensível a letras maiúsculas e minúsculas, a string `"cheddar"` não é encontrada em `myCapString`, portanto, o segundo método {{domxref("console.log()")}} exibe `-1`. ```js -var myString = "brie, pepper jack, cheddar"; +var myString = "brie, pepper jack, cheddar"; var myCapString = "Brie, Pepper Jack, Cheddar"; console.log('myString.indexOf("cheddar") é ' + myString.indexOf("cheddar")); // Exibe 19 -console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar")); +console.log( + 'myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar"), +); // Exibe -1 ``` @@ -106,13 +112,13 @@ console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar" O exemplo a seguir atribui à variável `count` o número de ocorrências da letra `x` na string `str`: ```js -const str = 'Serx ou não ser, eisx a questão' +const str = "Serx ou não ser, eisx a questão"; count = 0; pos = str.indexOf("x"); // retorna 3 -while ( pos != -1 ) { - count++; - pos = str.indexOf( "x", pos + 1 /* o mesmo que 3 + 1 */ ); +while (pos != -1) { + count++; + pos = str.indexOf("x", pos + 1 /* o mesmo que 3 + 1 */); } console.log(count); @@ -120,11 +126,11 @@ console.log(count); ## Especificações -| Especificação | Situação | Comentário | -| ------------------------------------------------------------------------------------------------------------ | ------------------------ | ------------------ | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. | -| {{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}} | {{Spec2('ES6')}} | | +| Especificação | Situação | Comentário | +| -------------------------------------------------------------------------------- | ------------------ | ------------------ | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. | +| {{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/italics/index.md b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.md index c681727fb08983..6b1b947d35c38e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/italics/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.md @@ -29,17 +29,17 @@ O método `italics()` cria uma string dentro de uma tag ``: O exemplo a seguir usa métodos do objeto global String para alterar a formatação de uma string: ```js -var worldString = 'Olá, mundo'; -console.log(worldString.blink()); // Olá, mundo -console.log(worldString.bold()); // Olá, mundo +var worldString = "Olá, mundo"; +console.log(worldString.blink()); // Olá, mundo +console.log(worldString.bold()); // Olá, mundo console.log(worldString.italics()); // Olá, mundo -console.log(worldString.strike()); // Olá, mundo +console.log(worldString.strike()); // Olá, mundo ``` ## Especificações -| Specification | -| ---------------------------------------------------------------------------------------------------------------- | +| Specification | +| ------------------------------------------------------------------------------------ | | {{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.md b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.md index 2d41f9691bedcc..0a246df94d8388 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.md @@ -29,14 +29,14 @@ O índice da última ocorrência referente ao valor especificado em `searchValue Os caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é `0`, e o índice do último caractere é `str.length - 1`. ```js -'ricardo'.lastIndexOf('r'); // retorna 4 -'ricardo'.lastIndexOf('a', 3); // retorna 3 -'ricardo'.lastIndexOf('a', 0); // retorna -1 -'ricardo'.lastIndexOf('x'); // retorna -1 -'ricardo'.lastIndexOf('r', -5); // retorna 0 -'ricardo'.lastIndexOf('r', 0); // retorna 0 -'ricardo'.lastIndexOf(''); // retorna 7 -'ricardo'.lastIndexOf('', 2); // retorna 2 +"ricardo".lastIndexOf("r"); // retorna 4 +"ricardo".lastIndexOf("a", 3); // retorna 3 +"ricardo".lastIndexOf("a", 0); // retorna -1 +"ricardo".lastIndexOf("x"); // retorna -1 +"ricardo".lastIndexOf("r", -5); // retorna 0 +"ricardo".lastIndexOf("r", 0); // retorna 0 +"ricardo".lastIndexOf(""); // retorna 7 +"ricardo".lastIndexOf("", 2); // retorna 2 ``` ### Sensível a maiúsculas e minúsculas @@ -44,7 +44,7 @@ Os caracteres em uma string são indexados da esquerda para a direita. O índice O método `lastIndexOf()` é sensível a letras maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna `-1`: ```js -'Blue Whale, Killer Whale'.lastIndexOf('blue'); // retorna -1 +"Blue Whale, Killer Whale".lastIndexOf("blue"); // retorna -1 ``` ## Exemplos @@ -54,22 +54,26 @@ O método `lastIndexOf()` é sensível a letras maiúsculas e minúsculas. Por e O seguinte exemplo usa `lastIndexOf()` para localizar valores nas string `"Brave new world"`. ```js -var anyString = 'Brave new world'; +var anyString = "Brave new world"; -console.log('O índice do primeiro w a partir do final é ' + anyString.lastIndexOf('w')); +console.log( + "O índice do primeiro w a partir do final é " + anyString.lastIndexOf("w"), +); // retorna 10 -console.log('O índice de "new" a partir do final é ' + anyString.lastIndexOf('new')); +console.log( + 'O índice de "new" a partir do final é ' + anyString.lastIndexOf("new"), +); // retorna 6 ``` ## Especificações -| Especificação | Estado | Comentários | -| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. | -| {{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentários | +| -------------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. | +| {{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/length/index.md b/files/pt-br/web/javascript/reference/global_objects/string/length/index.md index 18687e0708eed5..b502f9341b4dcd 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/length/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/length/index.md @@ -28,13 +28,15 @@ A propriedade estática `String.length` retorna o valor `1`. ### Uso básico ```js -var x = 'Mozilla'; -var empty = ''; +var x = "Mozilla"; +var empty = ""; -console.log('Mozilla possui ' + x.length + ' unidades de código de comprimento'); +console.log( + "Mozilla possui " + x.length + " unidades de código de comprimento", +); /* "Mozilla possui 7 unidades de código de comprimento" */ -console.log('A string vazia possui um comprimento de ' + empty.length); +console.log("A string vazia possui um comprimento de " + empty.length); /* "A string vazia possui um comprimento de 0" */ ``` @@ -55,11 +57,11 @@ console.log(myString.length); ## Especificação -| Especificação | Estado | Comentários | -| ---------------------------------------------------------------------------------------------------------------------------- | ------------------------ | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementada no JavaScript 1.0. | -| {{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentários | +| -------------------------------------------------------------------------------------------- | ------------------ | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementada no JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/link/index.md b/files/pt-br/web/javascript/reference/global_objects/string/link/index.md index 5f83d6a43f13f1..d69cb6b224c625 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/link/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/link/index.md @@ -35,17 +35,17 @@ Os links criados com o método `link()` tornam-se elementos na array de links do O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network. ```js -var hotText = 'MDN'; -var URL = 'https://developer.mozilla.org/'; +var hotText = "MDN"; +var URL = "https://developer.mozilla.org/"; -console.log('Clique para retornar à' + hotText.link(URL)); +console.log("Clique para retornar à" + hotText.link(URL)); // Clique para retornar à MDN ``` ## Especificações -| Specification | -| -------------------------------------------------------------------------------------------------------- | +| Specification | +| ------------------------------------------------------------------------------ | | {{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.md b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.md index bc40a4077c035c..c25ce77d87d85e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.md @@ -53,13 +53,13 @@ Ao comparar um grande número de strings, como na classificação de grandes arr ```js // A letra "a" está antes de "c" produzindo um valor negativo -'a'.localeCompare('c'); // -2 ou -1 (ou algum outro valor negativo) +"a".localeCompare("c"); // -2 ou -1 (ou algum outro valor negativo) // Alfabeticamente, a palavra "verificar" vem depois de "contra", produzindo um valor positivo -'verificar'.localeCompare('contra'); // 2 ou 1 (ou algum outro valor positivo) +"verificar".localeCompare("contra"); // 2 ou 1 (ou algum outro valor positivo) // "a" e "a" são equivalentes, resultando em um valor neutro de zero -'a'.localeCompare('a'); // 0 +"a".localeCompare("a"); // 0 ``` ### Ordenar um array @@ -67,8 +67,8 @@ Ao comparar um grande número de strings, como na classificação de grandes arr `localeCompare()` permite a ordenação sem distinção entre maiúsculas e minúsculas em um array. ```js -let items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu']; -items.sort( (a, b) => a.localeCompare(b, 'fr', {ignorePunctuation: true})); +let items = ["réservé", "Premier", "Cliché", "communiqué", "café", "Adieu"]; +items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true })); // ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé'] ``` @@ -81,9 +81,9 @@ Para verificar se uma implementação os suporta, use o argumento `"i"` (um requ ```js function localeCompareSupportsLocales() { try { - 'foo'.localeCompare('bar', 'i'); + "foo".localeCompare("bar", "i"); } catch (e) { - return e.name === 'RangeError'; + return e.name === "RangeError"; } return false; } @@ -94,8 +94,8 @@ function localeCompareSupportsLocales() { Os resultados fornecidos por `localeCompare()` variam entre os idiomas. Para obter a ordem de classificação do idioma usado na interface do usuário de seu aplicativo, certifique-se de especificar esse idioma (e possivelmente alguns idiomas substitutos) usando o argumento _`locales`_: ```js -console.log('ä'.localeCompare('z', 'de')); // um valor negativo: em alemão, ä é classificado antes de z -console.log('ä'.localeCompare('z', 'sv')); // um valor positivo: em sueco, ä é classificado após z +console.log("ä".localeCompare("z", "de")); // um valor negativo: em alemão, ä é classificado antes de z +console.log("ä".localeCompare("z", "sv")); // um valor positivo: em sueco, ä é classificado após z ``` ### Usando `options` @@ -104,10 +104,10 @@ Os resultados fornecidos por `localeCompare()` podem ser personalizados usando o ```js // em alemão, ä tem a como letra base -console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0 +console.log("ä".localeCompare("a", "de", { sensitivity: "base" })); // 0 // em sueco, ä e a são letras de base separadas -console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // um valor positivo +console.log("ä".localeCompare("a", "sv", { sensitivity: "base" })); // um valor positivo ``` ### Ordenação numérica @@ -117,7 +117,7 @@ console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // um valor console.log("2".localeCompare("10")); // 1 // numeric using options: -console.log("2".localeCompare("10", undefined, {numeric: true})); // -1 +console.log("2".localeCompare("10", undefined, { numeric: true })); // -1 // numeric using locales tag: console.log("2".localeCompare("10", "en-u-kn-true")); // -1 @@ -125,9 +125,9 @@ console.log("2".localeCompare("10", "en-u-kn-true")); // -1 ## Especificações -| Especificação | -| ---------------------------------------------------------------------------------------------------------------------------------------- | -| {{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}} | +| Especificação | +| ----------------------------------------------------------------------------------------------------- | +| {{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}} | | {{SpecName('ES Int Draft', '#sup-String.prototype.localeCompare', 'String.prototype.localeCompare')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/match/index.md b/files/pt-br/web/javascript/reference/global_objects/string/match/index.md index a534ea2966aaa4..8a66bf42300119 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/match/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/match/index.md @@ -100,7 +100,7 @@ console.log(matches_array); Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "`fox`" ou "`cat`" em um grupo denominado "`animal`": ```js -const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.'; +const paragraph = "The quick brown fox jumps over the lazy dog. It barked."; const capturingRegex = /(?fox|cat) jumps over/; const found = paragraph.match(capturingRegex); @@ -112,7 +112,7 @@ console.log(found.groups); // {animal: "fox"} ```js const str = "nada se perde, tudo se transforma"; -str.match(); // retorna [""] +str.match(); // retorna [""] ``` ### Um objeto não-RegExp como parâmetro @@ -122,26 +122,27 @@ Quando o parâmetro _`regexp`_ é uma string ou um número, ele é convertido im Se for um número positivo com um sinal positivo, `RegExp()` irá ignorar o sinal positivo. ```js -const str1 = "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript."; +const str1 = + "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript."; const str2 = "Meu avô tem 65 anos e minha avô tem 63."; const str3 = "O contrato foi declarado null (nulo) e void (sem efeito)"; -str1.match("número"); // "número" é um string. retorna ["número"] -str1.match(NaN); // o tipo de NaN é um número. retorna ["NaN"] -str1.match(Infinity); // o tipo de Infinity é um número. retorna ["Infinity"] -str1.match(+Infinity); // retorna ["Infinity"] -str1.match(-Infinity); // retorna ["-Infinity"] -str2.match(65); // retorna ["65"] -str2.match(+65); // Um número com sinal positivo. retorna ["65"] -str3.match(null); // retorna ["null"] +str1.match("número"); // "número" é um string. retorna ["número"] +str1.match(NaN); // o tipo de NaN é um número. retorna ["NaN"] +str1.match(Infinity); // o tipo de Infinity é um número. retorna ["Infinity"] +str1.match(+Infinity); // retorna ["Infinity"] +str1.match(-Infinity); // retorna ["-Infinity"] +str2.match(65); // retorna ["65"] +str2.match(+65); // Um número com sinal positivo. retorna ["65"] +str3.match(null); // retorna ["null"] ``` ## Especificações -| Especificações | Estado | Comentário | -| ---------------------------------------------------------------------------------------------------- | ------------------------ | ------------------------------------------------- | -| ECMAScript 3rd Edition. | Standard | Definição inicial. Implementado no JavaScript 1.2 | -| {{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}} | {{Spec2('ES6')}} | | +| Especificações | Estado | Comentário | +| ---------------------------------------------------------------------------- | ------------------ | ------------------------------------------------- | +| ECMAScript 3rd Edition. | Standard | Definição inicial. Implementado no JavaScript 1.2 | +| {{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.md b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.md index d4f43527bddb73..83f0aec70bd4c9 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.md @@ -36,12 +36,14 @@ Um [iterador](/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores) (que não Antes da adição do `matchAll()` ao JavaScript, era possível usar chamadas [regexp.exec](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec) (e regexes com a sinalização (flag) `/g`) em um loop para obter todas as correspondências: ```js -const regexp = RegExp('foo[a-z]*','g'); -const str = 'table football, foosball'; +const regexp = RegExp("foo[a-z]*", "g"); +const str = "table football, foosball"; let match; while ((match = regexp.exec(str)) !== null) { - console.log(`Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`); + console.log( + `Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`, + ); // retorna "Encontrou football início=6 fim=14." // retorna "Encontou foosball início=16 fim=24." } @@ -52,27 +54,31 @@ Com o `matchAll()` disponível, você pode evitar o loop {{jsxref("Statements/wh Em vez disso, usando o `matchAll()`, você obtém um iterador para usar com o mais conveniente {{jsxref ("Statements/for ... of", "for...of")}}, {{jsxref ("Operators/Spread_syntax" , "array spread")}} ou construções {{jsxref ("Array.from()")}}: ```js -const regexp = RegExp('foo[a-z]*','g'); -const str = 'table football, foosball'; +const regexp = RegExp("foo[a-z]*", "g"); +const str = "table football, foosball"; const matches = str.matchAll(regexp); for (const match of matches) { - console.log(`Encontrou ${match[0]} início=${match.index} fim=${match.index + match[0].length}.`); + console.log( + `Encontrou ${match[0]} início=${match.index} fim=${ + match.index + match[0].length + }.`, + ); } // retorna "Encontrou football início=6 fim=14." // retorna "Encontrou foosball início=16 fim=24." // O iterador de correspondências se esgota após a iterção for..of // Chame matchAll novamente para criar um novo iterador -Array.from(str.matchAll(regexp), m => m[0]); +Array.from(str.matchAll(regexp), (m) => m[0]); // Array [ "football", "foosball" ] ``` `matchAll()` retornará uma exceção se o sinalizador (flag) `g` estiver ausente. ```js -const regexp = RegExp('[a-c]',''); -const str = 'abc'; +const regexp = RegExp("[a-c]", ""); +const str = "abc"; str.matchAll(regexp); // retorna TypeError ``` @@ -80,10 +86,10 @@ str.matchAll(regexp); `matchAll()` cria internamente um clone da `regexp` - portanto, ao contrário de {{jsxref("Global_Objects/RegExp/exec", "regexp.exec()")}}, o `lastIndex` não muda conforme a string é verificada. ```js -const regexp = RegExp('[a-c]','g'); +const regexp = RegExp("[a-c]", "g"); regexp.lastIndex = 1; -const str = 'abc'; -Array.from(str.matchAll(regexp), m => `${regexp.lastIndex} ${m[0]}`); +const str = "abc"; +Array.from(str.matchAll(regexp), (m) => `${regexp.lastIndex} ${m[0]}`); // Array [ "1 b", "1 c" ] ``` @@ -95,7 +101,7 @@ Os grupos de captura são ignorados ao usar {{jsxref("Global_Objects/String/matc ```js let regexp = /t(e)(st(\d?))/g; -let str = 'test1test2'; +let str = "test1test2"; str.match(regexp); // Array ['test1', 'test2'] @@ -114,8 +120,8 @@ array[1]; ## Especificações -| Specification | -| -------------------------------------------------------------------------------------------------------------------- | +| Specification | +| -------------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.md b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.md index 754d2d4628d4cf..12e9de34090ec6 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.md @@ -41,22 +41,22 @@ O Unicode atribui um valor numérico exclusivo, denominado _ponto de código_, a - O ponto de código para `"n"` (U+006E) seguido pelo ponto de código para o til (U+0303). ```js -let string1 = '\u00F1'; -let string2 = '\u006E\u0303'; +let string1 = "\u00F1"; +let string2 = "\u006E\u0303"; -console.log(string1); // retorna ñ -console.log(string2); // retorna ñ +console.log(string1); // retorna ñ +console.log(string2); // retorna ñ ``` No entanto, como os pontos de código são diferentes, a comparação de strings não os tratará como iguais. E como o número de pontos de código em cada versão é diferente, eles até mesmo possuem comprimentos diferentes. ```js -let string1 = '\u00F1'; // ñ -let string2 = '\u006E\u0303'; // ñ +let string1 = "\u00F1"; // ñ +let string2 = "\u006E\u0303"; // ñ console.log(string1 === string2); // retorna false -console.log(string1.length); // retorna 1 -console.log(string2.length); // retorna 2 +console.log(string1.length); // retorna 1 +console.log(string2.length); // retorna 2 ``` O método `normalize()` ajuda a resolver esse problema convertendo uma string em uma forma normalizada comum para todas as sequências de pontos de código que representam os mesmos caracteres. Existem duas principais formas de normalização, uma baseada na **equivalência canônica** e a outra baseada na **compatibilidade**. @@ -68,15 +68,15 @@ Em Unicode, duas sequências de pontos de código têm equivalência canônica s Você pode usar o `normalize()` usando os argumentos `"NFD"` ou `"NFC"` para produzir uma forma de string que será a mesma para todas as strings canonicamente equivalentes. No exemplo abaixo, normalizamos duas representações do caractere `"ñ"`: ```js -let string1 = '\u00F1'; // ñ -let string2 = '\u006E\u0303'; // ñ +let string1 = "\u00F1"; // ñ +let string2 = "\u006E\u0303"; // ñ -string1 = string1.normalize('NFD'); -string2 = string2.normalize('NFD'); +string1 = string1.normalize("NFD"); +string2 = string2.normalize("NFD"); console.log(string1 === string2); // retorna true -console.log(string1.length); // retorna 2 -console.log(string2.length); // retorna 2 +console.log(string1.length); // retorna 2 +console.log(string2.length); // retorna 2 ``` #### Formas compostas e decompostas @@ -86,15 +86,15 @@ Observe que o comprimento da forma normalizada em `"NFD"` é `2`. Isso porque `" Você pode especificar `"NFC"` para obter a forma canônica **composta**, na qual vários pontos de código são substituídos por pontos de código únicos sempre que possível. A forma canônica composta para `"ñ"` é `"\u00F1"`: ```js -let string1 = '\u00F1'; // ñ -let string2 = '\u006E\u0303'; // ñ +let string1 = "\u00F1"; // ñ +let string2 = "\u006E\u0303"; // ñ -string1 = string1.normalize('NFC'); -string2 = string2.normalize('NFC'); +string1 = string1.normalize("NFC"); +string2 = string2.normalize("NFC"); -console.log(string1 === string2); // true -console.log(string1.length); // 1 -console.log(string2.length); // 1 +console.log(string1 === string2); // true +console.log(string1.length); // 1 +console.log(string2.length); // 1 console.log(string2.codePointAt(0).toString(16)); // f1 ``` @@ -114,23 +114,23 @@ Em alguns aspectos (como classificação), eles devem ser tratados como equivale Você pode usar o `normalize()` usando os argumentos `"NFKD"` ou `"NFKC"` para produzir uma forma de string que será a mesma para todas as strings compatíveis: ```js -let string1 = '\uFB00'; -let string2 = '\u0066\u0066'; +let string1 = "\uFB00"; +let string2 = "\u0066\u0066"; -console.log(string1); // ff -console.log(string2); // ff +console.log(string1); // ff +console.log(string2); // ff console.log(string1 === string2); // false -console.log(string1.length); // 1 -console.log(string2.length); // 2 +console.log(string1.length); // 1 +console.log(string2.length); // 2 -string1 = string1.normalize('NFKD'); -string2 = string2.normalize('NFKD'); +string1 = string1.normalize("NFKD"); +string2 = string2.normalize("NFKD"); -console.log(string1); // ff <- aparência visual modificada -console.log(string2); // ff +console.log(string1); // ff <- aparência visual modificada +console.log(string2); // ff console.log(string1 === string2); // true -console.log(string1.length); // 2 -console.log(string2.length); // 2 +console.log(string1.length); // 2 +console.log(string2.length); // 2 ``` Ao aplicar a normalização de compatibilidade, é importante considerar o que você pretende fazer com as strings, uma vez que a forma normalizada pode não ser apropriada para as aplicações. No exemplo acima, a normalização é apropriada para pesquisa, porque permite que um usuário encontre a string pesquisando por `"f"`. Mas pode não ser apropriado para exibição, porque a representação visual é diferente. @@ -146,44 +146,40 @@ Como na normalização canônica, você pode solicitar formulários compatíveis // U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA // U+0323: COMBINANDO PONTO ABAIXO -var str = '\u1E9B\u0323'; - +var str = "\u1E9B\u0323"; // Formato de Normalização Canônico de Composição (NFC) // U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA // U+0323: COMBINANDO PONTO ABAIXO -str.normalize('NFC'); // '\u1E9B\u0323' -str.normalize(); // igual à linha de cima - +str.normalize("NFC"); // '\u1E9B\u0323' +str.normalize(); // igual à linha de cima // Formato de Normalização Canônico de Decomposição (NFD) // U+017F: CARACTERE LATINO - LETRA S COMPRIDA // U+0323: COMBINANDO PONTO ABAIXO // U+0307: COMBINANDO PONTO ACIMA -str.normalize('NFD'); // '\u017F\u0323\u0307' - +str.normalize("NFD"); // '\u017F\u0323\u0307' // Formato de Normalização de Compatibilidade de Composição. (NFKC) // U+1E69: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA E ABAIXO -str.normalize('NFKC'); // '\u1E69' - +str.normalize("NFKC"); // '\u1E69' // Formato de Normalização de Compatibilidade de Decomposição (NFKD) // U+0073: CARACTERE LATINO - LETRA S COMPRIDA // U+0323: COMBINANDO PONTO ABAIXO // U+0307: COMBINANDO PONTO ACIMA -str.normalize('NFKD'); // '\u0073\u0323\u0307' +str.normalize("NFKD"); // '\u0073\u0323\u0307' ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padend/index.md b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.md index 98c42a44b5df8a..b561403d89d43e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/padend/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.md @@ -31,10 +31,10 @@ Uma {{jsxref("String")}} cuja composição vem da string original, completada po ### Usando padEnd ```js -'abc'.padEnd(10); // "abc " -'abc'.padEnd(10, "foo"); // "abcfoofoof" -'abc'.padEnd(6, "123456"); // "abc123" -'abc'.padEnd(1); // "abc" +"abc".padEnd(10); // "abc " +"abc".padEnd(10, "foo"); // "abcfoofoof" +"abc".padEnd(6, "123456"); // "abc123" +"abc".padEnd(1); // "abc" ``` ## Polyfill @@ -45,29 +45,28 @@ Rodando o seguinte código antes de qualquer código irá criar o método `Strin // https://github.com/uxitten/polyfill/blob/master/string.polyfill.js // https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd if (!String.prototype.padEnd) { - String.prototype.padEnd = function padEnd(targetLength,padString) { - targetLength = targetLength>>0; //floor if number or convert non-number to 0; - padString = String((typeof padString !== 'undefined' ? padString : ' ')); - if (this.length > targetLength) { - return String(this); - } - else { - targetLength = targetLength-this.length; - if (targetLength > padString.length) { - padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed - } - return String(this) + padString.slice(0,targetLength); - } - }; + String.prototype.padEnd = function padEnd(targetLength, padString) { + targetLength = targetLength >> 0; //floor if number or convert non-number to 0; + padString = String(typeof padString !== "undefined" ? padString : " "); + if (this.length > targetLength) { + return String(this); + } else { + targetLength = targetLength - this.length; + if (targetLength > padString.length) { + padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed + } + return String(this) + padString.slice(0, targetLength); + } + }; } ``` ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------------------------- | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------------- | -------------------- | ------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}} | {{Spec2('ESDraft')}} | Definição inicial no ECMAScript 2017. | -| {{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}} | {{Spec2('ES8')}} | | +| {{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}} | {{Spec2('ES8')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.md b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.md index d3e1ee2937353a..522332de78cc8e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.md @@ -31,11 +31,11 @@ Uma {{jsxref("String")}} de comprimento específico com uma string de preenchime ### Exemplos básicos ```js -'abc'.padStart(10); // " abc" -'abc'.padStart(10, "foo"); // "foofoofabc" -'abc'.padStart(6,"123465"); // "123abc" -'abc'.padStart(8, "0"); // "00000abc" -'abc'.padStart(1); // "abc" +"abc".padStart(10); // " abc" +"abc".padStart(10, "foo"); // "foofoofabc" +"abc".padStart(6, "123465"); // "123abc" +"abc".padStart(8, "0"); // "00000abc" +"abc".padStart(1); // "abc" ``` ## Polyfill @@ -46,28 +46,28 @@ Ao executar o seguinte código antes de qualquer outro código é criado o méto // https://github.com/uxitten/polyfill/blob/master/string.polyfill.js // https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/padStart if (!String.prototype.padStart) { - String.prototype.padStart = function padStart(targetLength, padString) { - targetLength = targetLength >> 0; //truncate if number, or convert non-number to 0; - padString = String(typeof padString !== 'undefined' ? padString : ' '); - if (this.length >= targetLength) { - return String(this); - } else { - targetLength = targetLength - this.length; - if (targetLength > padString.length) { - padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed - } - return padString.slice(0, targetLength) + String(this); - } - }; + String.prototype.padStart = function padStart(targetLength, padString) { + targetLength = targetLength >> 0; //truncate if number, or convert non-number to 0; + padString = String(typeof padString !== "undefined" ? padString : " "); + if (this.length >= targetLength) { + return String(this); + } else { + targetLength = targetLength - this.length; + if (targetLength > padString.length) { + padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed + } + return padString.slice(0, targetLength) + String(this); + } + }; } ``` ## Especificações -| Especificação | Status | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------- | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------------------------- | -------------------- | ---------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}} | {{Spec2('ESDraft')}} | Implementação inical no ECMAScript 2017. | -| {{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}} | {{Spec2('ES8')}} | | +| {{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}} | {{Spec2('ES8')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/raw/index.md b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.md index e480392ba3f0de..9873de47e24c28 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/raw/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.md @@ -46,7 +46,7 @@ Na maioria dos casos, `String.raw()` é usado com modelos de strings. A primeira ### Usando `String.raw()` ```js -String.raw`Hi\n${2+3}!`; +String.raw`Hi\n${2 + 3}!`; // 'Hi\n5!', o caractere após 'Hi' // não é um caractere de quebra de linha, // '\' e 'n' são dois caracteres. @@ -59,26 +59,30 @@ String.raw`Hi\u000A!`; // Você pode confirmar isso verificando a propriedade .length // da string. -let name = 'Bob'; +let name = "Bob"; String.raw`Hi\n${name}!`; // 'Hi\nBob!', substituições são processadas. // Normalmente você não chamaria String.raw() como uma função, // mas para simular `t${0}e${1}s${2}t` você pode fazer: -String.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t' +String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t' // Note que 'test', uma string, é um objeto array-like // O código abaixo é equivalente a: // `foo${2 + 3}bar${'Java' + 'Script'}baz` -String.raw({ - raw: ['foo', 'bar', 'baz'] -}, 2 + 3, 'Java' + 'Script'); // 'foo5barJavaScriptbaz' +String.raw( + { + raw: ["foo", "bar", "baz"], + }, + 2 + 3, + "Java" + "Script", +); // 'foo5barJavaScriptbaz' ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------- | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-string.raw', 'String.raw')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Especificação | Status | Comentário | +| -------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-string.raw', 'String.raw')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.md b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.md index d9697d8b7876fb..a7bcba4ebb9ec9 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.md @@ -30,14 +30,14 @@ Uma nova string contendo o número especificado de cópias da string original. ## Exemplos ```js -'abc'.repeat(-1); // RangeError -'abc'.repeat(0); // '' -'abc'.repeat(1); // 'abc' -'abc'.repeat(2); // 'abcabc' -'abc'.repeat(3.5); // 'abcabcabc' (o número será convertido para inteiro) -'abc'.repeat(1/0); // RangeError - -({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2); +"abc".repeat(-1); // RangeError +"abc".repeat(0); // '' +"abc".repeat(1); // 'abc' +"abc".repeat(2); // 'abcabc' +"abc".repeat(3.5); // 'abcabcabc' (o número será convertido para inteiro) +"abc".repeat(1 / 0); // RangeError + +({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2); // 'abcabc' (repeat() é um método genérico) ``` @@ -47,39 +47,43 @@ O método `repeat()` foi adicionado à especificação ECMAScript 2015 e pode ai ```js if (!String.prototype.repeat) { - String.prototype.repeat = function(count) { - 'use strict'; + String.prototype.repeat = function (count) { + "use strict"; if (this == null) { - throw new TypeError('não é possível converter ' + this + ' para um objeto'); + throw new TypeError( + "não é possível converter " + this + " para um objeto", + ); } - var str = '' + this; + var str = "" + this; count = +count; if (count != count) { count = 0; } if (count < 0) { - throw new RangeError('o núm. de repetições não pode ser negativo'); + throw new RangeError("o núm. de repetições não pode ser negativo"); } if (count == Infinity) { - throw new RangeError('o núm. de repetições deve ser menor que infinito'); + throw new RangeError("o núm. de repetições deve ser menor que infinito"); } count = Math.floor(count); if (str.length == 0 || count == 0) { - return ''; + return ""; } // Ao Garantir que count seja um inteiro de 31 bits nos dá uma grande otimização // na parte principal. Porém, navegadores atuais (de agosto de 2014 pra cá) // não conseguem mais manipular strings de 1 << 28 chars ou maiores, então: if (str.length * count >= 1 << 28) { - throw new RangeError('o núm. de repetições não deve estourar o tamanho máx. de uma string'); + throw new RangeError( + "o núm. de repetições não deve estourar o tamanho máx. de uma string", + ); } - var rpt = ''; + var rpt = ""; for (var i = 0; i < count; i++) { rpt += str; } return rpt; - } + }; } ``` @@ -255,9 +259,9 @@ console.log( ## Especificações -| Specification | Status | Comment | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------ | -| {{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}} | {{Spec2('ES2015')}} | Definição inicial. | +| Specification | Status | Comment | +| ---------------------------------------------------------------------------------- | -------------------- | ------------------ | +| {{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}} | {{Spec2('ES2015')}} | Definição inicial. | | {{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}} | {{Spec2('ESDraft')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replace/index.md b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.md index 06d3321e5036c5..9b11f01334510e 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/replace/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.md @@ -70,12 +70,12 @@ Para realizar uma pesquisa global e substituir, inclua a flag `g` na expressão A string substituidora pode incluir o seguinte padrão de substituição especial: -| **Padrão** | **Insere** | -| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `$$` | Insere um "$". | -| `$&` | Insere a string casada. | -| `` $` `` | Insere a porção da string que precede a substring combinada. | -| `$'` | Insere a porção da string que segue a substring combinada. | +| **Padrão** | **Insere** | +| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `$$` | Insere um "$". | +| `$&` | Insere a string casada. | +| `` $` `` | Insere a porção da string que precede a substring combinada. | +| `$'` | Insere a porção da string que segue a substring combinada. | | `$n` ou `$nn` | Onde `n` ou `nn` são dígitos decimais, insere a _n_-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}}. | ### Especificando uma função como parâmetro @@ -84,12 +84,12 @@ Você pode especificar uma função no segundo parâmetro. Neste caso, a funçã Os parâmetros da função são: -| **Possíveis nomes** | **Valor fornecido** | -| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -| `match` | A substring encontrada. Corresponde ao `$&` acima. | +| **Possíveis nomes** | **Valor fornecido** | +| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `match` | A substring encontrada. Corresponde ao `$&` acima. | | `p1, p2, ...` | O enésimo parâmetro entre parênteses da RegEx no primeiro parâmetro na função `replace()` {{jsxref("Global_Objects/RegExp", "RegExp")}}. (Corresponde a `$1`, `$2`, etc. acima.) Por exemplo, se `/(\a+)(\b+)/`, for o primeiro parâmetro, `p1` é a combinação para `\a+`, e `p2` para `\b+`. | -| `offset` | O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1. | -| `string` | A string completa que está sendo examinada. | +| `offset` | O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1. | +| `string` | A string completa que está sendo examinada. | (O número exato de argumentos dependerá se o primeiro parâmetro for uma {{jsxref("Global_Objects/RegExp", "RegExp")}} e de quantas combinações entre parênteses houver). @@ -99,9 +99,9 @@ O exemplo a seguir irá substituir o valor de `newString` para `'abc - 12345 - # function replacer(match, p1, p2, p3, offset, string) { // p1 não possui digitos, // p2 possui dígitos, e p3 não possui alfanuméricos - return [p1, p2, p3].join(' - '); + return [p1, p2, p3].join(" - "); } -var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer); +var newString = "abc12345#$*%".replace(/([^\d]*)(\d*)([^\w]*)/, replacer); // retorna "abc - 12345 - #$*%" ``` @@ -113,8 +113,8 @@ var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer); No exemplo a seguir foi definida uma expressão regular com a flag "`i`" (que ignora diferenças entre maiúsculas e minúsculas) no método `replace()`. ```js -var str = 'Twas the night before Xmas...'; -var newstr = str.replace(/xmas/i, 'Christmas'); +var str = "Twas the night before Xmas..."; +var newstr = str.replace(/xmas/i, "Christmas"); console.log(newstr); // retorna "Twas the night before Christmas..." @@ -128,8 +128,8 @@ Substituir globalmente, "`g`", só pode ser feito com uma expressão regular. No ```js var re = /maçãs/gi; -var str = 'As maçãs são redondas. As maçãs são suculentas.'; -var newstr = str.replace(re, 'laranjas'); +var str = "As maçãs são redondas. As maçãs são suculentas."; +var newstr = str.replace(re, "laranjas"); console.log(newstr); // retorna @@ -142,9 +142,9 @@ O script a seguir troca as palavras na string. Para o texto que vai substituir, ```js var re = /(\w+)\s(\w+)/; -var str = 'John Smith'; -var newstr = str.replace(re, '$2, $1'); -console.log(newstr); // Smith, John +var str = "John Smith"; +var newstr = str.replace(re, "$2, $1"); +console.log(newstr); // Smith, John ``` ### Usando uma função que modifica os caracteres coincidentes @@ -156,7 +156,7 @@ A função de substituição aceita a string coincidida como parâmetro e usa el ```js function styleHyphenFormat(propertyName) { function upperToHyphenLower(match, offset, string) { - return (offset ? '-' : '') + match.toLowerCase(); + return (offset ? "-" : "") + match.toLowerCase(); } return propertyName.replace(/[A-Z]/g, upperToHyphenLower); } @@ -167,7 +167,7 @@ Dado o seguinte parâmetro: `styleHyphenFormat('borderTop')`, o valor retornado Como queremos transformar o resultado da coincidencia antes da substituição final, nós devemos usar uma função. Isto força que a transformação seja feita antes da chamada do método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}. Se tivéssemos tentado isto sem a função, o método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}} não teria efeito. ```js -let newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // não funciona +let newString = propertyName.replace(/[A-Z]/g, "-" + "$&".toLowerCase()); // não funciona ``` Isso acontece porque `'$&'.toLowerCase()` será executada antes (resultando no mesmo que `'$&'`) em vez de usar os caracteres da string a ser transformada. @@ -181,7 +181,7 @@ A expressão regular `test` verifica por números que terminem com "`F`". O núm ```js function f2c(x) { function convert(str, p1, offset, s) { - return ((p1 - 32) * 5/9) + 'C'; + return ((p1 - 32) * 5) / 9 + "C"; } var s = String(x); var test = /(-?\d+(?:\.\d*)?)F\b/g; @@ -220,11 +220,15 @@ Um array de objetos. Um `'x'` denota um estado `'on'`, um `'-'` (hífen) denota **Código:** ```js -var str = 'x-x_'; +var str = "x-x_"; var retArr = []; -str.replace(/(x_*)|(-)/g, function(match, p1, p2) { - if (p1) { retArr.push({ on: true, length: p1.length }); } - if (p2) { retArr.push({ on: false, length: 1 }); } +str.replace(/(x_*)|(-)/g, function (match, p1, p2) { + if (p1) { + retArr.push({ on: true, length: p1.length }); + } + if (p2) { + retArr.push({ on: false, length: 1 }); + } }); console.log(retArr); @@ -234,11 +238,11 @@ O código gera um array de 3 objetos como desejado sem usar uma função de loop ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------ | ------------------------ | ------------------------------------------------- | -| ECMAScript 3rd Edition. | Standard | Defnição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------------------- | ------------------ | ------------------------------------------------- | +| ECMAScript 3rd Edition. | Standard | Defnição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.md b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.md index 25ec57e7d10f33..ae6ce31e7f3c77 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.md @@ -48,12 +48,12 @@ Este método não muda o objeto {{jsxref("String")}} original. Ele simplesmente A _string_ de substituição pode incluir os seguimentos padrões especiais de substituição: -| Padrão | Insere | -| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `$$` | Insere um `"$"`. | -| `$&` | Insere a _substring_ correspondente. | -| `` $` `` | Insere a porção da _string_ que precede a _substring_ correspondente. | -| `$'` | Insere a porção da _string_ que sucede a _substring_ correspondente. | +| Padrão | Insere | +| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `$$` | Insere um `"$"`. | +| `$&` | Insere a _substring_ correspondente. | +| `` $` `` | Insere a porção da _string_ que precede a _substring_ correspondente. | +| `$'` | Insere a porção da _string_ que sucede a _substring_ correspondente. | | `$n` | Onde `n` é um inteiro positivo menor que 100, insere a _`n`_-ésima _string_ submatch entre parênteses, desde que o primeiro argumento seja um objeto {{jsxref("RegExp")}}. Note que isso é indexado começando pelo `1`. | ### Especificando uma função como parâmetro @@ -64,12 +64,12 @@ Note que a função será chamada múltiplas vezes para cada ocorrência a ser s Os argumentos para funções são os seguintes: -| Nome possível | Valor fornecido | -| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `match` | A _substring_ correspondida. (Corresponde ao `$&` acima.) | +| Nome possível | Valor fornecido | +| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| `match` | A _substring_ correspondida. (Corresponde ao `$&` acima.) | | `p1, p2, ...` | A _n_-ésima string encontrada por um grupo de captura entre parênteses, desde que o primeiro argumento para `replace()` seja uma {{jsxref("RegExp")}}. (Corresponde a `$1`, `$2`, etc. acima.) Por exemplo, se `/(\a+)(\b+)/`, foi dado, `p1` é a correspondência para `\a+`, e `p2` para `\b+`. | -| `offset` | O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '`abcd`' e a substring correspondente for '`bc`', este argumento será `1`.) | -| `string` | A _string_ inteira será examinada. | +| `offset` | O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '`abcd`' e a substring correspondente for '`bc`', este argumento será `1`.) | +| `string` | A _string_ inteira será examinada. | (O número exato de argumentos depende se o primeiro argumento é um objeto {{jsxref("RegExp")}} — e, se então, quantas _subcorrespondências_ entre parênteses são especificadas.) @@ -78,7 +78,7 @@ Os argumentos para funções são os seguintes: ### Usando `replaceAll()` ```js -'aabbcc'.replaceAll('b', '.'); +"aabbcc".replaceAll("b", "."); // 'aa..cc' ``` @@ -94,14 +94,14 @@ TypeError: replaceAll must be called with a global RegExp Já o código abaixo vai funcionar: ```js example-good -'aabbcc'.replaceAll(/b/g, '.'); -"aa..cc" +"aabbcc".replaceAll(/b/g, "."); +("aa..cc"); ``` ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------------------ | +| Especificação | +| ------------------------------------------------------------------------------------------ | | {{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/search/index.md b/files/pt-br/web/javascript/reference/global_objects/string/search/index.md index 2289a08dea4c34..57bf274038c22a 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/search/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/search/index.md @@ -35,20 +35,20 @@ Para obter mais informações (mas em compensação a execução se torna mais l O exemplo a seguir pesquisa uma string com dois objetos `regexp` diferentes para mostrar uma pesquisa bem-sucedida (valor positivo) vs. uma pesquisa mal-sucedida (-1). ```js -let str = "hey JudE" -let re = /[A-Z]/g -let reDot = /[.]/g -console.log(str.search(re)) // retorna 4, que é o índice da primeira letra maiúscula "J" -console.log(str.search(reDot)) // retorna -1 pois não conseguiu encontrar o ponto "." +let str = "hey JudE"; +let re = /[A-Z]/g; +let reDot = /[.]/g; +console.log(str.search(re)); // retorna 4, que é o índice da primeira letra maiúscula "J" +console.log(str.search(reDot)); // retorna -1 pois não conseguiu encontrar o ponto "." ``` ## Especificações -| Specificação | Status | Comentário(s) | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}} | {{Spec2('ES6')}} | | +| Specificação | Status | Comentário(s) | +| ---------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/slice/index.md b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.md index b6f0d3c92b6e05..67061f7ba5282f 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/slice/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.md @@ -24,14 +24,14 @@ str.slice(startIndex[, endIndex]) - : É o índice, de base zero, onde se inicia a extração. Se for um número negativo, será o mesmo que executar _`str.length + startIndex`_ (por exemplo, se _`startIndex`_ for _`-3`_, será o mesmo que executar _`str.length - 3`_). ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; console.log(nome.slice(-3)); // retorna 'rdo' ``` Se _`startIndex`_ for maior ou igual a `str.length`, uma string vazia será retornada. ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; console.log(nome.slice(7)); // retorna ' ``` @@ -42,7 +42,7 @@ str.slice(startIndex[, endIndex]) Se omitido ou possuir valor de _`undefined`_, ou for maior que `str.length`, _`slice()`_ extrairá até o fim da string. ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; // omitindo fimSlice console.log(nome.slice(0)); // retorna 'Ricardo' @@ -58,14 +58,14 @@ str.slice(startIndex[, endIndex]) Se negativo, é o mesmo que executar _`str.length + endIndex`_ onde _`str.length`_ é o tamanho da string (por exemplo, se _`endIndex`_ é _`-3`_, é como executar `str.length - 3`). ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; console.log(nome.slice(0, -3)); // retorna 'Rica' ``` Se for um valor diferente de indefinido e, ao mesmo tempo não for um número, uma string vazia será retornada ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; let i; // variável criada sem valor atribuído // passando algum valor ≠ de undefined e ≠ de número @@ -77,14 +77,14 @@ str.slice(startIndex[, endIndex]) Se `endIndex` for definido e `startIndex` for negativo, `endIndex` deve ser negativo também, do contrário uma string vazia é retornada. ```js - const nome = 'Ricardo'; + const nome = "Ricardo"; console.log(nome.slice(-3, 0)); // retorna ``` Caso `endIndex` seja definido e `startIndex` e `endIndex` sejam ambos positivos ou negativos, `endIndex` deve ser maior que `startIndex`, do contrário uma string vazia é retornada. ```js - const nome = 'Ricado'; + const nome = "Ricado"; console.log(nome.slice(-1, -3)); // retorna console.log(nome.slice(3, 1)); // retorna ``` @@ -104,7 +104,7 @@ _`slice()`_ extrai até, mas não inclue _`endIndex`._ Por exemplo, _`str.slice(2, -1)`_ extrai a partir do terceiro carácter até o penúltimo caractere da string. ```js -const nome = 'Ricardo'; +const nome = "Ricardo"; console.log(nome.slice(2, -1)); // retorna 'card' ``` @@ -115,11 +115,11 @@ console.log(nome.slice(2, -1)); // retorna 'card' O exemplo a seguir usa _`slice()`_ para criar uma nova string. ```js -var str1 = 'A manhã está sobre nós', // o tamanho de str1 é 22 - str2 = str1.slice(3, 10), - str3 = str1.slice(2, -2), - str4 = str1.slice(13), - str5 = str1.slice(22); +var str1 = "A manhã está sobre nós", // o tamanho de str1 é 22 + str2 = str1.slice(3, 10), + str3 = str1.slice(2, -2), + str4 = str1.slice(13), + str5 = str1.slice(22); console.log(str2); // retorna 'anhã es' console.log(str3); // retorna 'manhã está sobre n' console.log(str4); // retorna 'sobre nós' @@ -131,37 +131,37 @@ console.log(str5); // retorna O exemplo a seguir usa o _`slice()`_ com índices negativos. ```js -var str = 'A manhã está sobre nós'; -str.slice(-3); // retorna 'nós' +var str = "A manhã está sobre nós"; +str.slice(-3); // retorna 'nós' str.slice(-3, -1); // retorna 'nó' -str.slice(0, -1); // retorna 'A manhã está sobre nó' +str.slice(0, -1); // retorna 'A manhã está sobre nó' ``` O exemplo abaixo percorre o índice no sentido anti-horário (de trás para frente) até chegar ao índice 11 da string, que será o início. Logo após, percorre o índice da string no sentido horário até chegar ao índice 16 da string, que será o fim. ```js -console.log(str.slice(-11, 16)) // retorna "á sob" +console.log(str.slice(-11, 16)); // retorna "á sob" ``` O exemplo abaixo percorre o índice no sentido horário até chegar ao índice 10 da string, que será o início. Logo após, percorre o índice da string no sentido anti-horário até chegar ao índice 7 da string, que será o fim. ```js -console.log(str.slice(10, -7)) // retorna "tá so" +console.log(str.slice(10, -7)); // retorna "tá so" ``` O exemplo abaixo percorre o índice no sentido anti-horário até chegar ao índice 5 da string, que será o início. Logo após, percorre o índice da string novamente no sentido anti-horário até chegar ao índice 1 da string, que será o fim. ```js -console.log(str.slice(-5, -1)) // retorna "e nó" +console.log(str.slice(-5, -1)); // retorna "e nó" ``` ## Especificações -| Specification | Status | Comment | -| ---------------------------------------------------------------------------------------------------- | ------------------------ | -------------------------------------------------- | -| ECMAScript 3rd Edition. | Standard | Initial definition. Implemented in JavaScript 1.2. | -| {{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}} | {{Spec2('ES6')}} | | +| Specification | Status | Comment | +| ---------------------------------------------------------------------------- | ------------------ | -------------------------------------------------- | +| ECMAScript 3rd Edition. | Standard | Initial definition. Implemented in JavaScript 1.2. | +| {{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}} | {{Spec2('ES6')}} | | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/small/index.md b/files/pt-br/web/javascript/reference/global_objects/string/small/index.md index 3ea1874293d788..fef5dc31663faa 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/small/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/small/index.md @@ -28,23 +28,23 @@ O método `small()` cria uma string dentro de uma tag ``: `"strOlá, mundo -console.log(worldString.big()); // Olá, mundo +console.log(worldString.small()); // Olá, mundo +console.log(worldString.big()); // Olá, mundo console.log(worldString.fontsize(7)); // Olá, mundo ``` Com o objeto [element.style](/pt-BR/docs/Web/API/ElementCSSInlineStyle/style) você pode pegar o atributo de estilo do elemento e manipulá-lo de forma mais genérica, por exemplo: ```js -document.getElementById('#oIdDoElemento').style.fontSize = '0.7em'; +document.getElementById("#oIdDoElemento").style.fontSize = "0.7em"; ``` ## Especificações -| Specification | -| ------------------------------------------------------------------------------------------------------------ | +| Specification | +| -------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/split/index.md b/files/pt-br/web/javascript/reference/global_objects/string/split/index.md index e2e2e2126eee18..8ad19bea919b37 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/split/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/split/index.md @@ -54,8 +54,8 @@ Se o separador for uma expressão regular que contenha parênteses de captura, c Quando a string está vazia, o `split()` irá retornar um array contendo uma string vazia ao invés de um array vazio. Se a string e o separador forem ambos strings vazias, um array vazio será retornado. ```js -const myString = '' -const splits = myString.split() +const myString = ""; +const splits = myString.split(); console.log(splits); @@ -70,14 +70,19 @@ function splitString(stringToSplit, separator) { console.log('A string original é: "' + stringToSplit + '"'); console.log('O separador é: "' + separator + '"'); - console.log('O array tem ' + arrayOfStrings.length + ' elementos: ' + arrayOfStrings.join(' / ')); + console.log( + "O array tem " + + arrayOfStrings.length + + " elementos: " + + arrayOfStrings.join(" / "), + ); } -var tempestString = 'Oh brave new world that has such people in it.'; -var monthString = 'Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez'; +var tempestString = "Oh brave new world that has such people in it."; +var monthString = "Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez"; -var space = ' '; -var comma = ','; +var space = " "; +var comma = ","; splitString(tempestString, space); splitString(tempestString); @@ -105,7 +110,7 @@ O array possui 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep No exemplo a seguir, `split()` procura por 0 ou mais espaços seguidos por um ponto e vírgula seguido por 0 ou mais espaços e, quando encontrar, remove os espaços e os pontos e vírgulas da string. `nameList` é o array retornado como resultado do `split()`. ```js -var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand '; +var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand "; console.log(names); @@ -127,8 +132,8 @@ Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand No exemplo a seguir, o `split()` procura por 0 ou mais espaços em uma string e retorna as 3 primeiras divisões que encontrar. ```js -var myString = 'Hello World. How are you doing?'; -var splits = myString.split(' ', 3); +var myString = "Hello World. How are you doing?"; +var splits = myString.split(" ", 3); console.log(splits); ``` @@ -144,7 +149,7 @@ O script exibirá o texto a seguir: Se o `separator` contém parênteses de captura, os resultados correspondentes são retornados no array. ```js -var myString = 'Hello 1 word. Sentence number 2.'; +var myString = "Hello 1 word. Sentence number 2."; var splits = myString.split(/(\d)/); console.log(splits); @@ -163,8 +168,8 @@ O script exibirá o texto a seguir: > **Aviso:** Esta não é a melhor maneira de reverter uma string: > > ```js example-bad -> const str = 'asdfghjkl' -> const strReverse = str.split('').reverse().join('') +> const str = "asdfghjkl"; +> const strReverse = str.split("").reverse().join(""); > // 'lkjhgfdsa' > > // split() retorna um array onde os métodos @@ -174,8 +179,8 @@ O script exibirá o texto a seguir: > Não funciona se a string contém `grapheme clusters`, mesmo ao usar uma divisão compatível com Unicode. (Use, por exemplo, [esrever](https://github.com/mathiasbynens/esrever) no lugar.) > > ```js example-bad -> const str = 'résumé' -> const strReverse = str.split(/(?:)/u).reverse().join('') +> const str = "résumé"; +> const strReverse = str.split(/(?:)/u).reverse().join(""); > // retorna "́emuśer" > ``` > @@ -183,11 +188,11 @@ O script exibirá o texto a seguir: ## Especificações -| Especificação | Status | Comentário | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.1. | -| {{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.md b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.md index fe785cf6377849..01472198697964 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.md @@ -36,11 +36,11 @@ Esse método permite determinar se uma string começa ou não com outra string. ```js //startswith -let str = 'Ser ou não ser, eis a questão.'; +let str = "Ser ou não ser, eis a questão."; -console.log(str.startsWith('Ser')) // true -console.log(str.startsWith('não ser')) // false -console.log(str.startsWith('não ser', 7)) // true +console.log(str.startsWith("Ser")); // true +console.log(str.startsWith("não ser")); // false +console.log(str.startsWith("não ser", 7)); // true ``` ## Polyfill @@ -62,8 +62,8 @@ Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------------------ | +| Especificação | +| ------------------------------------------------------------------------------------------ | | {{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}} | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/strike/index.md b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.md index 55458067cf0614..c06470adfb11fe 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/strike/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.md @@ -28,7 +28,7 @@ O método `strike()` cria uma string dentro uma tag ``: "`strOlá, mundo console.log(worldString.bold()); // Olá, mundo @@ -38,8 +38,8 @@ console.log(worldString.strike()); // Olá, mundo ## Especificações -| Specification | -| ------------------------------------------------------------------------------------------------------------ | +| Specification | +| ---------------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sub/index.md b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.md index 227b6e1d1c9260..99446fcae15716 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/sub/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.md @@ -28,21 +28,21 @@ O método `sub()` cria uma string dentro de uma tag ``: `"str"`. Os exemplos seguintes usam o métodos `sub()` e {{jsxref("String.prototype.sup()", "sup()")}} para formatar uma string: ```js -var superText = 'superscript'; -var subText = 'subscript'; +var superText = "superscript"; +var subText = "subscript"; -console.log('This is what a ' + superText.sup() + ' looks like.'); +console.log("This is what a " + superText.sup() + " looks like."); // This is what a superscript looks like -console.log('This is what a ' + subText.sub() + ' looks like.'); +console.log("This is what a " + subText.sub() + " looks like."); // This is what a subscript looks like. ``` ## Especificação -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}} | {{Spec2('ES6')}} | Definição inicial. Implementado no JavaScript 1.0. | +| Especificação | Status | Comentário | +| ---------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES6', '#sec-string.prototype.sub', 'String.prototype.sub')}} | {{Spec2('ES6')}} | Definição inicial. Implementado no JavaScript 1.0. | | {{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substr/index.md b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.md index cbda6bcc71ac77..3328e834ce6901 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/substr/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.md @@ -45,16 +45,16 @@ O `substr()` extrai caracteres de comprimento de uma `str`, contando a partir do ### Usando `substr()` ```js -var aString = 'Mozilla'; - -console.log(aString.substr(0, 1)); // 'M' -console.log(aString.substr(1, 0)); // '' -console.log(aString.substr(-1, 1)); // 'a' -console.log(aString.substr(1, -1)); // '' -console.log(aString.substr(-3)); // 'lla' -console.log(aString.substr(1)); // 'ozilla' +var aString = "Mozilla"; + +console.log(aString.substr(0, 1)); // 'M' +console.log(aString.substr(1, 0)); // '' +console.log(aString.substr(-1, 1)); // 'a' +console.log(aString.substr(1, -1)); // '' +console.log(aString.substr(-3)); // 'lla' +console.log(aString.substr(1)); // 'ozilla' console.log(aString.substr(-20, 2)); // 'Mo' -console.log(aString.substr(20, 2)); // '' +console.log(aString.substr(20, 2)); // '' ``` ## Polyfill @@ -63,33 +63,35 @@ JScript da Microsoft não suporta valores negativos para o índice de `start`. S ```js // only run when the substr() function is broken -if ('ab'.substr(-1) != 'b') { +if ("ab".substr(-1) != "b") { /** * Get the substring of a string * @param {integer} start where to start the substring * @param {integer} length how many characters to return * @return {string} */ - String.prototype.substr = function(substr) { - return function(start, length) { + String.prototype.substr = (function (substr) { + return function (start, length) { // call the original method - return substr.call(this, + return substr.call( + this, // did we get a negative start, calculate how much it is from the beginning of the string // adjust the start parameter for negative value start < 0 ? this.length + start : start, - length) - } - }(String.prototype.substr); + length, + ); + }; + })(String.prototype.substr); } ``` ## Especificações -| Specification | Status | Comment | -| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0. | -| {{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}} | {{Spec2('ES5.1')}} | Defined in the (informative) Compatibility Annex B | -| {{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}} | {{Spec2('ES6')}} | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers | +| Specification | Status | Comment | +| ---------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}} | {{Spec2('ES5.1')}} | Defined in the (informative) Compatibility Annex B | +| {{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}} | {{Spec2('ES6')}} | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers | | {{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}} | {{Spec2('ESDraft')}} | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substring/index.md b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.md index 76ee363f4fd441..2914db47ae2174 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/substring/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.md @@ -47,19 +47,19 @@ O seguinte exemplo usa `substring()` para mostrar caracteres da palavra 'Mozilla var anyString = "Mozilla"; // Mostra "Moz" -console.log(anyString.substring(0,3)); -console.log(anyString.substring(3,0)); +console.log(anyString.substring(0, 3)); +console.log(anyString.substring(3, 0)); // Mostra "lla" -console.log(anyString.substring(4,7)); -console.log(anyString.substring(7,4)); +console.log(anyString.substring(4, 7)); +console.log(anyString.substring(7, 4)); // Mostra "Mozill" -console.log(anyString.substring(0,6)); +console.log(anyString.substring(0, 6)); // Mostra "Mozilla" -console.log(anyString.substring(0,7)); -console.log(anyString.substring(0,10)); +console.log(anyString.substring(0, 7)); +console.log(anyString.substring(0, 10)); ``` ### Usando `substring()` com `length` @@ -68,13 +68,13 @@ O exemplo a seguir usa o método `substring()` e a propriedade {{jsxref ("String ```js // Mostra 'illa', os últimos 4 caracteres -let anyString = 'Mozilla' -let anyString4 = anyString.substring(anyString.length - 4) +let anyString = "Mozilla"; +let anyString4 = anyString.substring(anyString.length - 4); console.log(anyString4); // Mostra 'zilla', os últimos 5 caracteres -let anyString = 'Mozilla' -let anyString5 = anyString.substring(anyString.length - 5) +let anyString = "Mozilla"; +let anyString5 = anyString.substring(anyString.length - 5); console.log(anyString5); ``` @@ -87,9 +87,9 @@ Os argumentos de `substring()` representam os índices inicial e final, enquanto Além disso, `substr()` é considerado um **recurso legacy no ECMAScript** e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível. ```js -let text = 'Mozilla' -console.log(text.substring(2,5)) // retorna "zil" -console.log(text.substr(2,3)) // retorna "zil" +let text = "Mozilla"; +console.log(text.substring(2, 5)); // retorna "zil" +console.log(text.substr(2, 3)); // retorna "zil" ``` ### Diferenças entre `substring()` e `slice()` @@ -99,23 +99,23 @@ Os métodos `substring()` e {{jsxref("String.slice", "slice()")}} são quase id O método `substring()` troca seus dois argumentos se `indexStart` for maior que `indexEnd`, o que significa que uma string ainda será retornada. O método {{jsxref("String.slice", "slice()")}} retorna uma string vazia caso o mesmo ocorra. ```js -let text = 'Mozilla' -console.log(text.substring(5, 2)) // retorna "zil" -console.log(text.slice(5, 2)) // retorna "" +let text = "Mozilla"; +console.log(text.substring(5, 2)); // retorna "zil" +console.log(text.slice(5, 2)); // retorna "" ``` Se um ou ambos os argumentos forem negativos ou `NaN`, o método `substring()` os tratará como se fossem `0`. ```js -console.log(text.substring(-5, 2)) // retorna "Mo" -console.log(text.substring(-5, -2)) // retorna "" +console.log(text.substring(-5, 2)); // retorna "Mo" +console.log(text.substring(-5, -2)); // retorna "" ``` `slice()` também trata os argumentos `NaN` como `0`, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices. ```js -console.log(text.slice(-5, 2)) // retorna "" -console.log(text.slice(-5, -2)) // retorna "zil" +console.log(text.slice(-5, 2)); // retorna "" +console.log(text.slice(-5, -2)); // retorna "zil" ``` Veja a página {{jsxref("String.slice", "slice()")}} para mais exemplos com números negativos. @@ -126,10 +126,13 @@ O seguinte exemplo substitui uma substring dentro de uma string. Ela irá substi ```js function replaceString(oldS, newS, fullS) { -// Substitui oldS por newS na string fullS + // Substitui oldS por newS na string fullS for (var i = 0; i < fullS.length; i++) { if (fullS.substring(i, i + oldS.length) == oldS) { - fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length); + fullS = + fullS.substring(0, i) + + newS + + fullS.substring(i + oldS.length, fullS.length); } } return fullS; @@ -141,7 +144,7 @@ replaceString("World", "Web", "Brave New World"); Note que isto pode resultar em um loop infinito se `oldS` for um substring de `newS` — por exemplo, se você tentou substituir "`World`" com "`OtherWorld`". O melhor método para substituir strings é o seguinte: ```js -function replaceString(oldS, newS,fullS){ +function replaceString(oldS, newS, fullS) { return fullS.split(oldS).join(newS); } ``` @@ -150,11 +153,11 @@ O código acima serve como um exemplo para operações com substring. Se você p ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------------------- | ------------------------ | ------------------------------ | -| ECMAScript 1st Edition. | Standard | Implementado no JavaScript 1.0 | -| {{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| ------------------------------------------------------------------------------------ | ------------------ | ------------------------------ | +| ECMAScript 1st Edition. | Standard | Implementado no JavaScript 1.0 | +| {{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sup/index.md b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.md index 1a739b1257856a..6e792a854bf00c 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/sup/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.md @@ -28,20 +28,20 @@ O método `sup()` cria uma string dentro de uma tag ``: `"str"` O exemplo a seguir usa os métodos {{jsxref("String.prototype.sub()", "sub()")}} e `sup()` para formatar uma string: ```js -var superText = 'superscript'; -var supText = 'supscript'; +var superText = "superscript"; +var supText = "supscript"; -console.log('This is what a ' + superText.sup() + ' looks like.'); +console.log("This is what a " + superText.sup() + " looks like."); // "This is what a superscript looks like." -console.log('This is what a ' + supText.sup() + ' looks like.'); +console.log("This is what a " + supText.sup() + " looks like."); // "This is what a supscript looks like." ``` ## Especificações -| Specification | -| ---------------------------------------------------------------------------------------------------- | +| Specification | +| ---------------------------------------------------------------------------- | | {{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.md b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.md index 29ce05f83259e1..a1d57ab5324eb7 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.md @@ -40,20 +40,20 @@ O método `toLocaleLowerCase()` retorna o valor da string convertida em minúscu ### Usando `toLocaleLowerCase()` ```js -'ALFABETO'.toLocaleLowerCase(); // 'alfabeto' +"ALFABETO".toLocaleLowerCase(); // 'alfabeto' -'\u0130'.toLocaleLowerCase('tr') === 'i'; // true -'\u0130'.toLocaleLowerCase('en-US') === 'i'; // false +"\u0130".toLocaleLowerCase("tr") === "i"; // true +"\u0130".toLocaleLowerCase("en-US") === "i"; // false -let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish']; -'\u0130'.toLocaleLowerCase(locales) === 'i'; // true +let locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"]; +"\u0130".toLocaleLowerCase(locales) === "i"; // true ``` ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------------------------------------------ | -| {{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}} | +| Especificação | +| ------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}} | | {{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md index 15f7a7dbf8a5e4..4a39c42e6912fb 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.md @@ -43,21 +43,21 @@ Observe também que a conversão não é necessariamente um mapeamento de caract ### Usando `toLocaleUpperCase()` ```js -'alfabeto'.toLocaleUpperCase(); // 'ALFABETO' +"alfabeto".toLocaleUpperCase(); // 'ALFABETO' -'Gesäß'.toLocaleUpperCase(); // 'GESÄSS' +"Gesäß".toLocaleUpperCase(); // 'GESÄSS' -'i\u0307'.toLocaleUpperCase('lt-LT'); // 'I' +"i\u0307".toLocaleUpperCase("lt-LT"); // 'I' -let locales = ['lt', 'LT', 'lt-LT', 'lt-u-co-phonebk', 'lt-x-lietuva']; -'i\u0307'.toLocaleUpperCase(locales); // 'I' +let locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"]; +"i\u0307".toLocaleUpperCase(locales); // 'I' ``` ## Especificações -| Especificação | -| ------------------------------------------------------------------------------------------------------------------------------------------------ | -| {{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}} | +| Especificação | +| ------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}} | | {{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}} | ## Compatibilidade com navegadores diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.md b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.md index ee5c096dd68f2c..130d85a3a1f2e8 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.md @@ -26,16 +26,16 @@ O método `toLowerCase()` retorna o valor da string original convertido para min ### Usando `toLowerCase()` ```js -console.log('ALFABETO'.toLowerCase()); // 'alfabeto' +console.log("ALFABETO".toLowerCase()); // 'alfabeto' ``` ## Especificações -| Especificação | Estado | Comentário | -| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementada no JavaScript 1.0. | -| {{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentário | +| -------------------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementada no JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.md b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.md index 05923997913ca0..aad9ab7ce1ffa6 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.md @@ -24,18 +24,18 @@ O objeto {{jsxref("String")}} substitui o método `toString()` do objeto {{jsxre O exemplo a seguir exibe o valor string de um objeto {{jsxref("String")}}: ```js -var x = new String('Hello world'); +var x = new String("Hello world"); console.log(x.toString()); // retorna 'Hello world' ``` ## Especificações -| Especificação | Estado | Comentário | -| -------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.1. | -| {{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}} | {{Spec2('ES6')}} | | +| Especificação | Estado | Comentário | +| -------------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Definição inicial. Implementado no JavaScript 1.1. | +| {{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.md b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.md index a022d3e0c5f258..cdfd9592521a87 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.md @@ -31,16 +31,16 @@ O método `toUpperCase()` retorna o valor da string convertido para letras maiú ### Uso básico ```js -console.log('alfabeto'.toUpperCase()); // 'ALFABETO' +console.log("alfabeto".toUpperCase()); // 'ALFABETO' ``` ## Especificações -| Especificação | Status | Comentário | -| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | -------------------------------------------------- | -| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.0. | -| {{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}} | {{Spec2('ES5.1')}} | | -| {{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}} | {{Spec2('ES6')}} | | +| Especificação | Status | Comentário | +| -------------------------------------------------------------------------------------------- | -------------------- | -------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definição inicial. Implementado no JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}} | {{Spec2('ES6')}} | | | {{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}} | {{Spec2('ESDraft')}} | | ## Navegadores compatíveis diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trim/index.md b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.md index 0a0129b95b4962..d9ae37b906b1d8 100644 --- a/files/pt-br/web/javascript/reference/global_objects/string/trim/index.md +++ b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.md @@ -26,13 +26,13 @@ Os exemplos a seguir retornam o valor de `'foo'` sem espaços em branco: ```js //.trim() removendo whitespace de ambos os lados -var str = ' foo '; +var str = " foo "; console.log(str.trim()); // retorna 'foo' // Outro exemplo de .trim() removendo whitespace de // apenas um lado. -var str= 'foo '; +var str = "foo "; console.log(str.trim()); // retorna 'foo' ``` @@ -43,17 +43,17 @@ Executar o seguinte código antes antes de qualquer código irá criar o método ```js if (!String.prototype.trim) { String.prototype.trim = function () { - return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""); }; } ``` ## Especificações -| Specification | Status | Comment | -| ---------------------------------------------------------------------------------------------------- | ------------------------ | ---------------------------------------------------- | -| {{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.1. | -| {{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}} | {{Spec2('ES6')}} | | +| Specification | Status | Comment | +| -------------------------------------------------------------------------- | ------------------ | ---------------------------------------------------- | +| {{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}} | {{Spec2('ES5.1')}} | Definição inicial. Implementado no JavaScript 1.8.1. | +| {{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}} | {{Spec2('ES6')}} | | ## Navegadores compatíveis