setter
======

A sintaxe **`set`** liga a propriedade da função para ser chamada quando existe uma tentativa de definir valor para essa propriedade.

Sintaxe
-------
```

{set prop(val) { . . . }}
{set [expression](val) { . . . }}
```

### Parâmetros

`prop`

Nome da propriedade ligada a função.

`val`

`Um apelido para variável que será atribuidada a prop.`

expression

Iniciando com ECMAScript 6, você pode usar também expressões para computar o nome da propriedade a ser definida na função.

Descrição
---------

Em JavaScript, um *setter* pode ser usado para executar uma função sempre que se tenta mudar uma propriedade específica. *Setters* são geralmente usados em conjunto com *getters*, para criar um tipo de pseudo-propriedade. No entanto é impossível ter-se um setter para uma propriedade que contenha um valor real.

Observe os seguintes itens ao trabalhar com a sintaxe *set*:

* Ele pode ter um identificador que é um número ou uma string;
* Deve ter exatamente um parâmetro (para mais informações, acesse: Mudança do ES5 incompatível: funções getter e setter literais tem exatamemente zero ou um parâmetros);
* Não deve ter a mesma nomenclatura seja ela para propriedades ou função.
 (`{ set x(v) { }, set x(v) { } }` e `{ x: ..., set x(v) { } }` é proibido.)

Um *setter* pode ser deletado usando o operator `delete` (en-US).

Exemplos
--------

### Definindo um setter em new Objects no inicializador

Vai definir um pseudo-property *current* para este objeto, quando atribuido um valor, vai mudar `log` com o valor passado:


```js
var o = {
  set current(str) {
    this.log[this.log.length] = str;
  },
  log: [],
};
```


Observe que *current* não está definido e qualquer tentativa de acesso irá resultar em *undefined*.

### Removendo um setter com o operador `delete`

Se você deseja remover o *setter*, poderá usar somente o `delete` (en-US):


```js
delete o.current;
```

### Definindo um setter para um Object existente usando o `defineProperty`

Para adicionar um *setter* para um Object existentem mais tarde, use `Object.defineProperty()`.


```js
var o = { a: 0 };

Object.defineProperty(o, "b", {
  set: function (x) {
    this.a = x / 2;
  },
});

o.b = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
console.log(o.a); // 5
```

### Usando um nome de propriedade computada

**Nota:** **Atenção:** Propriedades computadas são uma tecnologia experimental, parte da proposta ECMAScript 6, e não é amplamente suportada por todos os browsers ainda. Ele vai retornar um syntax error en ambientes que não tem suporte.


```js
var expr = "foo";

var obj = {
  baz: "bar",
  set [expr](v) {
    this.baz = v;
  },
};

console.log(obj.baz); // "bar"
obj.foo = "baz"; // run the setter
console.log(obj.baz); // "baz"
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-method-definitions |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

SpiderMonkey-specific notes
---------------------------

* Starting with JavaScript 1.8.1, setters are no longer called when setting properties in object and array initializers.
* From SpiderMonkey 38 on, a setter with a rest parameter is a `SyntaxError` (en-US) as per the ES6 specification.
See also
--------

* getter
* `delete` (en-US)
* `Object.defineProperty()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* Defining Getters and Setters in JavaScript Guide