​

Como resolver?

O ponto chave nesse desafio é entender como lidar com as coordenadas para calcular o que foi pedido dentro de uma classe.

Resolução

Para começar a resolver o desafio vamos construir a classe com os seus atributos, e após isso podemos então adicionar os métodos que irão realizar os cálculos utilizando esses atributos. O primeiro método seria obter o setor, o que pode ser feito avaliando se as coordenadas são maiores ou menos do que 0. Podemos utilizar o IF de uma única linha e também o retorno cedo que já utilizamos para reduzir o tamanho do nosso código. Já para o segundo método que é calcular a distância do ponto (0, 0) podemos aplicar a fórmula da raiz quadrada da soma de todos as coordenadas ao quadrado. Vejamos como fica o código:

class Point {  constructor(x, y, z) {
    this.x = x
    this.y = y
    this.z = z
  }

  getSector() {
    if (this.x >= 0 && this.y >= 0 && this.z >= 0) return 'Alfa'
    if (this.x >= 0 && this.y >= 0 && this.z < 0) return 'Beta'
    if (this.x >= 0 && this.y < 0 && this.z >= 0) return 'Gama'
    if (this.x >= 0 && this.y < 0 && this.z < 0) return 'Delta'
    if (this.x < 0 && this.y >= 0 && this.z >= 0) return 'Épsilon'
    if (this.x < 0 && this.y >= 0 && this.z < 0) return 'Zeta'
    if (this.x < 0 && this.y < 0 && this.z >= 0) return 'Sigma'
    if (this.x < 0 && this.y < 0 && this.z < 0) return 'Ômega'
  }

  getDistance() {
    return Math.sqrt((this.x ** 2) + (this.y ** 2) + (this.z ** 2))
  }
}

Refatorando

Ter várias condicionais pode até resolver o nosso problema, mas com certeza não a solução mais eficiente e elegante que poderíamos utilizar. Imagine que o desafio pedisse 4 coordenadas ao invés de 3? Isso faria com que precisássemos de muitas outras condicionais. Mas podemos escrever essa mesma classe de uma forma mais criativa e elegante, resultando em um código que será muito mais limpo. Para fazer isso vamos tirar vantagem dos objetos e arrays do javascript.

Utilizaremos uma tupla, ou seja, um array de posições fixas para as coordenadas, facilitando o processo de iterar sobre todas elas de uma só vez. Também vamos utilizar um objeto de setores que irá mapear os possíveis retornos da nossa função de acordo com um identificador. No nosso caso esse identificador pode ser um trio de sinais + ou -, que irão representar o enquadramento naquele setor. Esse objeto pode ser uma propriedade estática, por exemplo, pois não está atrelado a nenhuma instância, mas à classe em si.

Agora só precisamos modificar nosso método de obter o setor e a distância para trabalharem com a nova estrutura. No caso do setor, podemos utilizar o .map() para criar um array de sinais + ou - baseado no valor da coordenada e então juntar esse array em uma string de 3 sinais, exatamente no mesmo padrão do nosso objeto de setores. Por fim, só precisaremos retornar a propriedade estática de setores na mesmo posição que a nossa string, passando ela através da sintaxe de colchetes, ou seja, na mesmo posição que equivale ao conteúdo da variável. No caso da função da distância podemos utilizar o .reduce() para somar as iterações do nosso array de coordenadas elevando cada uma ao quadrado. Vejamos como fica o novo código:

class Point {
  constructor(x, y, z) {
    this.coordinates = [x, y, z]
  }

  static sectors = {
    '+++': 'Alfa',
    '++-': 'Beta',
    '+-+': 'Gama',
    '+--': 'Delta',
    '-++': 'Épsilon',
    '-+-': 'Zeta',
    '--+': 'Sigma',
    '---': 'Ômega',
  }

  getSector() {
    const signs = this.coordinates.map(coord => coord >= 0 ? '+' : '-').join('')
    return Point.sectors[signs]
  }

  getDistance() {
    return Math.sqrt(this.coordinates.reduce((accum, current) => accum + current ** 2, 0))
  }
}