Playground - Implementa singleton en un chat

Mi solución.

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
      return true;
    }
  }
  sendMessage(Message) {
      this.users.forEach(x => x.receiveMessage(Message));
      return true;
  }
  removeUser(name) {
      const deleted = this.users.findIndex(x => x.name === name);
      this.users.splice(deleted, 1);
      return true;
  }
}

.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message));
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }

  removeUser(name) {
    const deletedUser = this.users.findIndex(user => user.name === name);
    this.users.splice(deletedUser, 1);
  }
}

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

import { User } from "./user";

export class Chat {
  constructor() {
    //singleton
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    for (let user of this.users) {
      user.receiveMessage(message)
    }
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    }
  }

  removeUser(name) {
    let indexToRemove = this.users.findIndex((u) => u.name == name)
    if (indexToRemove < 0) throw new Error('El usuario a eliminar no exister actualmente en la lista')
    return this.users.splice(indexToRemove, 1)
  }
}

my generic code

import { User } from "./user.js";

export class Chat {
  constructor() {
    this.users = []
    if (!Chat.instance) {
      Chat.instance = Object.freeze(this)
    }
    return Chat.instance
  }
  sendMessage(message) {
    for (const user of this.users) {
      user.messages.push(message)
    }
  }
  addUser(user) {
    if (user instanceof User) this.users.push(user)
  }
  removeUser(name) {
    const userIndex = this.users.findIndex((item) => item.name === name)
    this.users.splice(userIndex, 1)
  }
}

Mi solución:

Desafio Singleton completado:

Mi solución 💚 (uno de mis patrones favoritos es Singleton precisamente jeje)

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = []
      Chat.instance = Object.freeze(this)
    }
    return Chat.instance
  }

  sendMessage(message) {
    this.users.forEach(user => {
      user.receiveMessage(message)
    })
  }

  addUser(user) {
    if(user instanceof User)
      this.users.push(user)
  }

  removeUser(name) {
    let indexOfUser = this.users.findIndex(user => 
      user.name === name
    )
    
    if (indexOfUser !== -1) 
      this.users.splice(indexOfUser,1)
  }
}

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Implementa singleton en un chat

export class Chat {
  // Tu código aquí 👈
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }
  removeUser(userName) {
    const userToDelete = this.users.findIndex((user) => user.name == userName);
    this.users.splice(userToDelete, 1);
  }
  sendMessage(mesagge) {
    this.users.forEach((user) => {
      user.messages.push(mesagge);
    });
  }
}

export class Chat {
  constructor() {
    this.users = []

    if (!Chat.instance) {
      this.name = "Chat";
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    }
  }

  removeUser(name) {
    const index = this.users.findIndex(u => u.name === name)
    this.users.splice(index, 1)
  }

  sendMessage(message) {
    this.users.forEach(user => {
      user.receiveMessage(message)
    })
  }
}

export class Chat {
  users  = [];
  constructor() {
    if (!Chat.instance) {
      Chat.instance = this;
    }
    return Chat.instance;
  }
  sendMessage(message) {
    this.users.forEach((user) => {
      user.receiveMessage(message);
    });
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }
  removeUser(name) {
    const result = this.users.findIndex((user) => user.name === name);
    this.users.splice(result, 1);
  }
}

Hola mi solución .
9️⃣
8️⃣
7️⃣
6️⃣
5️⃣
4️⃣
3️⃣
2️⃣
1️⃣
0️⃣

exercise.js

import { User } from "./user";
export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.createInstance();
      Chat.instance = this;
    }
    return Chat.instance;
  }

  createInstance() {
    this.users = [];
  }

  sendMessage(message) {
    this.users.forEach((user) => {
      user.receiveMessage(message);
    });
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }

  removeUser(user) {
    this.users = this.users.filter((u) => u.name !== user);
  }
}

. SPOILER ❤️

.
.
.

.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.
.

import { User } from "./user";

export class Chat {
  // Tu código aquí 👈
  users = [];

  //integrate singleton
  constructor() {
    if (!Chat.instance) {
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach((user) => {
      user.receiveMessage(message)
    })
  }

  addUser(user) {
    if (user instanceof User) this.users.push(user)
  }

  removeUser(name) {
    const indexUser = this.users.findIndex((user) => user.name === name)
    this.users.splice(indexUser, 1)
  }

}

.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() {
    if (Chat.instance) {
      return Chat.instance;
    }

    this.users = [];
    Chat.instance = this;
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }

  removeUser(name) {
    this.users = this.users.filter(user => user.name !== name);
  }

  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message));
  }
}

Y seguimos avanzando lento pero seguimos, mi solucion:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

exercise.js

import { User } from "./user";

export class Chat {
  // Tu código aquí 👈
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  sendMessage(message) {
    for (const user in this.users) {
      this.users[user].receiveMessage(message);
    }
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
      return true;
    }
  }
  removeUser(name) {
    const ind = this.users.findIndex(user => user.name === name);
    this.users.splice(ind, 1);
  }
}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  users = [];

  constructor() {
    if (!Chat.instance) Chat.instance = Object.freeze(this);
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message));
  }

  addUser(user) {
    if (user instanceof User) this.users.push(user)
  }

  removeUser(name) {
    const index = this.users.findIndex(user => user.name === name);
    this.users.splice(index, 1);
  }
}

Aquí mi solución:
.
.
.
.
.
.
.
.
.
.

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = []
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.map(elem => elem.receiveMessage(message));
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }
  removeUser(name) {
    let index = this.users.findIndex(elem => elem.name === name);
    if (index >= 0) {
      this.users.splice(index, 1);
    }
  }
}

Bueno dejo mi aporte, y retomo los retos porque los deje hace una semana ya que hacer POO me da pereza y me parece complicado pero si se empieza hay que terminar.

.
.
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = []
      Chat.instance = Object.freeze(this)
    }
    return Chat.instance
  }

  sendMessage(message) {
    this.users.forEach((user) => user.receiveMessage(message))
  }

  addUser(user) {
    if(user instanceof User) this.users.push(user)
  }

  removeUser(name) {
    const idx = this.users.findIndex((user) => user.name === name)
    this.users.splice(idx, 1)
  }
}

El nombre de la propiedad que tiene el array con todos los usuarios se debe llamar users para pasar la prueba, aquí dejo mi código… 😃

export class Chat {
  // Tu código aquí 👈
    constructor(){
        
        this.users =[];
        if (!Chat.instance){
            Chat.instance=this;        
          
        }else{
            return Chat.instance;
        }
    }
 sendMessage(message){
    this.users.forEach(user=>user.receiveMessage(message));
}

 addUser(user){
    if (user instanceof User){
        this.users.push(user);
        return this.list;
    }else{
        return this.users;
    }
}
removeUser(name){
    let index= this.users.findIndex(user=>user.name===name);
    this.users.splice(index,1);
    return this.users;
}
}

Mi solucion.;
.
.
.
.
.
…

import { User } from "./user";

export class Chat {
  constructor() { 
    if (!Chat.instance) { 
      this.users = [],    
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  sendMessage(message) {
    this.users.forEach(element => element.receiveMessage(message))
  };
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  };
  removeUser(name) {
    let index = this.users.findIndex(user => user.name == name)
    this.users.splice(index, 1)
  };
}

Solución… 😄
.
Interesante reto, para el ejercicio en la clase Chat se debe intuir alguna propiedad a partir de la descripción de los métodos.
.
Para saber si un objeto es la instancia de una clase en específico se puede utilizar “instanceof”.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() { 
    if (!Chat.instance) { 
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach((user) => { 
      user.receiveMessage(message);
    });
  }

  addUser(user) { 
    if (user instanceof User) { 
      this.users.push(user);
    }
  }

  removeUser(name) { 
    let index = this.users.findIndex(user =>
      user.name === name
    );
    this.users.splice(index,1); 
  }
}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  users = []
  constructor() {
    !Chat.instance && (Chat.instance = Object.freeze(this))
    return Chat.instance
  }
  sendMessage(message) {
    this.users.map(user => user.receiveMessage(message))
  }
  addUser(user) {
    user instanceof User && this.users.push(user)
  }
  removeUser(name) {
    let index = this.users.findIndex(user => user.name === name)
    this.users.splice(index, 1)
  }
  showAddUsers() {
    return this.users
  }
}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  // Tu código aquí 👈
  // Tu código aquí 👈
  constructor() {
    this.users = [];
    if (!Chat.instance) {
      this.name = 'Chat';
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  addUser(user) {
    if (user instanceof User) this.users.push(user);
  }
  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message));
  }
  removeUser(name) {
    const index = this.users.findIndex((user) => user === name);
    this.users.splice(index, 1)
  }
}

Mi solución

export class Chat {
  users = [];
  constructor() {
    if (!Chat.instance) {
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  sendMessage(message) {
    for (let user of this.users) {
      user.receiveMessage(message);
    }
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }
  removeUser(name) {
    const userIndex = this.users.findIndex(user => user.name == name);
    this.users.splice(userIndex, 1);
  }
}

freeze mmm

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message));
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }

  removeUser(name) {
    const index = this.users.findIndex(user => user.name = name);
    if (index > -1) {
      this.users.splice(index, 1);
    }
  }
}

Mi solución:

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    for (let i=0; i<this.users.length; i++) {
      this.users[i].receiveMessage(message);
    }
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
    return this;
  }
  removeUser(name) {
    for (let i=0; i<this.users.length; i++) {
        if (this.users[i].name===name){
            this.users.splice(i,1);
            return this;
        }
    }
    return this;
  }
}

Dejo mi solución:
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  // Tu código aquí 👈

  constructor() {
    this.users = [];

    if (!Chat.instance) {
      Chat.instance = Object.freeze(this);
    }
    
    return Chat.instance;
  }

  sendMessage(message) {
    for (const user of this.users) user.receiveMessage(message);
  }

  addUser(user) {
    if (user instanceof User) this.users.push(user);
  }

  removeUser(name) {
    const index = this.users.findIndex(user => user.name === name);
    if (index == -1) throw new Error("El usuario no existe");
    this.users.splice(index, 1);
  }
}

Les dejo mi solución:
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }
  sendMessage(message) {
    for (let user of this.users) {
      user.receiveMessage(message)
    }
  }
  addUser(user) {
    if (user instanceof User) this.users.push(user);
  }
  removeUser(name) {
    this.users.splice(this.users.indexOf(this.users.find(user=>user.name===name)),1)
  }
}

Mi solución:
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  // Tu código aquí 👈
  constructor() {
    if (!Chat.instance) {
      this.users = []
      Chat.instance = Object.freeze(this)
    }
    return Chat.instance
  }
  sendMessage(message) {
    for (let user of this.users) {
      user.receiveMessage(message)
    }
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    }
  }
  removeUser(name) {
    const index = this.users.findIndex((user) => user.name === name)
    if (index !== -1) {this.users.splice(index, 1)}
  }
}

✅Mi solución:
.
.
.
.
.
.
.
.
.
…
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

import { User } from "./user";

export class Chat {
  constructor() {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach(user => {
      user.receiveMessage(message);
    });
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);
    }
  }

  removeUser(name) {
    const isUserInList = this.users.map(user => user.name)
      .includes(name);
    if (isUserInList) {
      const index = this.users.findIndex(user => user.name === name);
      this.users.splice(index, 1);
    }
  }
}

**Mi respuesta **

export class Chat {
  constructor(name) {
    if (!Chat.instance) {
      this.users = [];
      Chat.instance = Object.freeze(this);
    }
    return Chat.instance;
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user);

    }
  }

  sendMessage(message) {
    this.users.forEach(user => {
      user.receiveMessage(message);
    });
  }

  removeUser(name) {
    for (var i = 0; i < this.users.length; i++) {
      if (this.users[i].name === name) {
        this.users.splice(i, 1);
      }
    }
  }
}

Solución:

import { User } from "./user";

let users = new Array(User)
export class Chat {
  // Tu código aquí 👈
  constructor() {
    this.users = []
    if (!Chat.instance) {
      Chat.instance = Object.freeze(this)
    }
    return Chat.instance
  }
  sendMessage(message) {
    this.users.forEach(element => {
      element.receiveMessage(message)
    })
  }
  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    }
  }
  removeUser(name) {
    this.users = this.users.filter(element => element.name !== name)
  }
}

Mi solución
*
*
*
*
*
*

import { User } from "./user";

export class Chat {

  constructor() {
    this.users = []
    if (!Chat.instance) {
      Chat.instance = this
    }
    return Chat.instance;
  }

  sendMessage(message) {
    this.users.forEach(user => {
      user.receiveMessage(message)
    })
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    } 

  }

  removeUser(name) {
    this.users = this.users.filter(user => user.name !== name)
  }
}

import { User } from "./user";

export class Chat {
   
  constructor() {
    if (!Chat.instance) {
      this.users = []
      Chat.instance = Object.freeze(this);
    }
    
    return Chat.instance;
  }
  sendMessage(message) {
    this.users.forEach(user => user.receiveMessage(message))
  }

  addUser(user) {
    if (user instanceof User) {
      this.users.push(user)
    }
  }

  removeUser(nameUser) {
    const index = this.users
      .findIndex(({ name }) => name === nameUser)

    if (index >= -1) {
      this.users.shift(index, 1)
    }
  }
}