Node.JS Tutorial: Setting Up Nicknames and User Management

Welcome.
Last time, we completed the first real-time chat feature.
Now, users can send messages to each other when accessing from multiple browsers simultaneously.
However, there's one missing piece:
All messages are displayed without indicating who sent them. This makes it impossible to tell which user sent a message.
In this lesson, we'll implement nickname functionality and user management to solve this issue.
Why Are Nicknames Important?
When using a messaging app, the first thing users typically do is set their name or profile.
Consider this chat example:
Hello.
Welcome.
Have a great day today.
Without names, it's hard to tell who sent which message.
But with nicknames displayed:
Chul-soo: Hello.
Young-hee: Welcome.
Min-su: Have a great day today.
Add just one user name, and the chat service feels much more complete.
When Should Users Enter Their Nickname?
Typically, chat services ask users to enter their nickname right after connecting.
After entering a name, users join the chat room.
In this project, we'll follow the same approach.
The chat screen will first prompt for a nickname. Once entered, users can start chatting.
Where to Store User Information?
When a user connects, the server must remember their information.
For example, we could store:
Socket ID
Nickname
Connection time
Current chat room
Currently, we're storing only nicknames, but future lessons will add more details.
What Is a Socket ID?
In Socket.IO, each user gets a unique Socket ID upon connecting.
This value differs for every user.
For example:
User A
Socket ID: f83kP2hL
User B
Socket ID: c91LmQa8
The server uses Socket IDs to distinguish between users.
Nicknames will also be managed alongside these Socket IDs.
Managing Users on the Server
When a user connects, the server stores their information.
For instance:
Socket ID
↓
Nickname
↓
Connection status
This user list will be used later for features like:
Online user list
Chat rooms
Private messages
Admin functions
How to Handle Nickname Conflicts?
This project initially allows duplicate nicknames.
However, in real services, multiple users with the same nickname can cause confusion.
In practice, teams often use methods like:
Duplicate checks
Automatic numbering
Nicknames tied to account registration
We'll address this later when adding login features.
Displaying Nicknames in Messages
Now, when users send messages, they'll include their nickname instead of just text.
The chat window will display:
Chul-soo
Hello.
----------------
Young-hee
Welcome.
Now it's easy to see who sent each message.
Why Is User Information Important?
Chat applications rely heavily on user information for many features:
Current online users
Connection duration
Admin privileges
Profile pictures
Last login time
Read receipts
In short, the user management system we're building today will serve as the foundation for most future features.
What Happens When a Connection Drops?
If a browser closes or internet disconnects, Socket.IO automatically triggers a connection end event.
The server should then delete that user's information.
If not, disconnected users will remain in the list.
In the next lesson, we'll use this event to implement join and leave notifications.
Future User Features
We're currently storing only nicknames, but future updates will add:
Profile images
Current connection status
Last login time
Admin privileges
Friend lists
Chat room participation details
Private message recipients
All these features will build on today's user management system.
Lesson Summary
This lesson covered how to collect nicknames and manage user data on the server.
We also explored Socket IDs and why user management matters in real-time chat applications.
Real-time chat isn't just about sending messages—it's about accurately managing user information.
The features we built today will form the foundation for online user lists, chat rooms, private messaging, and admin tools.
Next Lesson Preview
In the next lesson, we'll implement join and leave notification features.
We'll show real-time notifications when users enter or exit a chat room, creating a more immersive experience similar to actual messaging apps.
FAQ
Why is nickname functionality important in chat apps?
It allows users to identify who sent each message, making conversations clearer and more personal.
How does Socket.IO handle user connections?
Socket.IO assigns a unique ID (Socket ID) to each user upon connection, which the server uses to track individual users.
Korean Source
This article is an English localization of a Korean-language report from BlogScore. Original: [Node.JS 강좌] 6강 닉네임 설정과 사용자 관리하기