DEV Community: Rock

Building a Fast Product Filter with Vanilla JavaScript

Rock — Tue, 21 Jul 2026 04:51:37 +0000

One of the easiest ways to improve an e-commerce store is by making it easier for customers to find what they're looking for. A slow or confusing filtering experience often leads to visitors leaving before they ever reach a product page.

While working on a clothing store, I spent some time simplifying the product filtering experience. The goal wasn't to build a complex search engine—it was simply to let shoppers narrow products by size, color, and price without refreshing the page.

The product data looked something like this:

const products = [
  { id: 1, name: "Slim Fit Jeans", size: "M", color: "Blue", price: 49.99 },
  { id: 2, name: "High Waist Skinny", size: "L", color: "Black", price: 59.99 },
  { id: 3, name: "Straight Leg Jeans", size: "S", color: "Blue", price: 44.99 }
];

Instead of writing separate logic for every filter, I created a single function that checks the active filter values and returns only the matching products.

function filterProducts(products, filters) {
  return products.filter(product => {
    const sizeMatch =
      !filters.size || product.size === filters.size;

    const colorMatch =
      !filters.color || product.color === filters.color;

    const priceMatch =
      !filters.maxPrice || product.price <= filters.maxPrice;

    return sizeMatch && colorMatch && priceMatch;
  });
}

Whenever a shopper changes one of the filters, the product list updates immediately.

document
  .getElementById("size-filter")
  .addEventListener("change", (event) => {
    filters.size = event.target.value;

    renderProducts(
      filterProducts(products, filters)
    );
  });

The renderProducts() function simply clears the existing product cards and displays the filtered results. Since everything happens in the browser, there's no need to reload the page, making the shopping experience feel much faster.

A few things made the biggest difference during testing:

Keep the filtering logic in one place instead of scattering conditions throughout the code.
Store the current filter state in a single object so multiple filters work together naturally.
Only re-render the product grid after filtering is complete.
If you're adding a price slider, debounce the input so the page isn't constantly re-rendering while the user drags the handle.

This approach scales surprisingly well for small and medium-sized catalogs. For larger stores, you can move the filtering logic to an API while keeping the same frontend structure.

I used a similar pattern while working on a women's jeans category, where shoppers typically want to narrow results by size, color, and budget before browsing individual products. Making those filters quick and responsive reduced unnecessary clicks and helped visitors get to the products they actually wanted much faster.

The implementation itself isn't complicated. The challenge is keeping the experience simple enough that customers never have to think about how it works—they just find what they're looking for.

Build a Better Kids’ Clothing Store: A Simple JavaScript Size Filter That Improves Shopping Experience

Rock — Mon, 20 Jul 2026 05:46:55 +0000

Here’s a quick tip for any parent or developer building a small e-commerce site for kids’ clothes: size filters can make or break the user experience.

When I was working on the product listing page for a clothing collection aimed at active boys, I noticed something. Parents weren't just browsing; they were on a mission. They wanted to filter by size immediately, and they wanted to see durable, comfortable fabrics at a glance.

Here’s a simple, lightweight approach using vanilla JavaScript to create a dynamic filter for a "Boys Clothing" collection. No frameworks, just clean DOM manipulation.

First, assume your HTML has a list of products, each with a data-size attribute:




Graphic Tee



Size: 5-6







Joggers



Size: 7-8

Now, a filter button group:

All Sizes
5-6 Years
7-8 Years

The JavaScript logic is straightforward:

document.querySelectorAll('.size-filter').forEach(button => {
  button.addEventListener('click', function() {
    const selectedSize = this.dataset.size;
    document.querySelectorAll('.product-card').forEach(card => {
      if (selectedSize === 'all' || card.dataset.size === selectedSize) {
        card.style.display = 'block';
      } else {
        card.style.display = 'none';
      }
    });
  });
});

That’s it. In under 20 lines, you give parents instant control. I used this exact pattern while building out a "Boys Clothing" section for a project. It’s perfect for a collection like the one on Frishay, where you want to quickly show school-ready outfits or playtime gear without clutter.

The key takeaway? Keep the code minimal and the user goal clear. Active kids mean active parents; they don’t have time to scroll. Give them filters, and they’ll find that durable jogger set in seconds.https://frishay.com/collections/boys-clothing

The Parenting Hack That Ended Our Daily Wardrobe Battles: Durable, Comfortable Boys’ Clothing That Kids Actually Want to Wear

Rock — Mon, 20 Jul 2026 05:45:18 +0000

Ever struggled to get your kid to actually like what you pick out for them? I've been there. The "battle of the wardrobe" used to be a daily event in my house. Then I realized the secret isn't just about finding clothes that look good—it's about finding clothes that work for their lifestyle.

Here's what I learned from trial and error (and a few ruined shirts):

1. Fabric is Everything
For active kids, look for cotton blends with a bit of spandex. They stretch, breathe, and survive the playground. Avoid 100% stiff cotton for everyday wear—it restricts movement and fades fast.

2. The "Double Knee" Trick
Jeans with reinforced knees? Game changer. They last twice as long without looking worn out. Perfect for crawling, climbing, or just being a kid.

3. Prints That Hide Stains
Dark patterns or camo prints are your best friend. Yes, they look cool, but they also mask grass stains and dirt between washes. A win-win.

4. Layering Without the Bulk
Opt for lightweight hoodies and zip-up jackets. They're easy to take on and off (less arguing), and they pack small for trips.

5. The "Test Run" Rule
Before buying a full outfit, let them wear the shirt or pants for an hour at home. If they don't complain about tags, seams, or fit—you've found a winner.

I've been curating a small collection of durable, stylish options for my own kids. If you're looking for reliable boys' clothing that checks all these boxes, I found some great picks at Frishay's Boys Clothing Collection. They focus on comfort and durability without sacrificing style.

What's your go-to trick for dressing active kids? Drop it in the comments—I'm always looking for new hacks.

The Versatile Polo: How to Style Men’s Polo Shirts for Any Occasion

Rock — Sat, 18 Jul 2026 05:19:52 +0000

If there’s one item every man should have in his wardrobe, it’s a polo shirt. It bridges the gap between casual and formal, making it perfect for everything from brunch to business casual meetings. Here’s how to make the most of this essential piece.

First, choose quality materials. A good polo should be made from breathable cotton or a cotton-polyester blend that resists wrinkles. Look for a collar that stays crisp and a fit that’s tailored but not tight. I prefer polos with a two-button placket for a modern look.

For a smart-casual outfit, pair a solid-colored polo with chinos and loafers. Add a leather belt for polish. Going for a relaxed vibe? Tuck it into dark jeans with sneakers. The key is balance: if the polo is bright, keep the rest neutral.

I recently upgraded my collection with a few from Frishay, and I’m impressed by the variety—from classic pique to performance blends that wick moisture. They’re perfect for golf outings or casual Fridays at the office.

Pro tip: Roll the sleeves once for a more athletic look. And don’t be afraid to experiment with stripes or subtle patterns—they add personality without being loud.

Whether you’re dressing up or down, a polo shirt is your go-to. Explore the options at Frishay and elevate your style effortlessly.

How I Finally Stopped Buying Bad T-Shirts

Rock — Fri, 17 Jul 2026 04:39:56 +0000

How I Finally Stopped Buying Bad T-Shirts

For years, buying men's T-shirts felt like a gamble. Some looked great online but lost their shape after a couple of washes. Others were comfortable but fit like a tent. After wasting more money than I'd like to admit, I realized that finding a great T-shirt isn't about chasing trends—it's about knowing what to look for.

Here are the things that have made the biggest difference for me.

Start with the Fabric

The fabric determines how a T-shirt feels, how long it lasts, and whether you'll actually enjoy wearing it.

I usually look for cotton with a small amount of stretch. A little elastane helps the shirt keep its shape without sacrificing comfort. Soft ringspun or combed cotton is another feature worth paying attention to because it feels noticeably better than standard cotton, especially if you're wearing it all day.

Don't Chase Trends—Find the Right Fit

The fit matters more than the logo or the brand.

A good T-shirt should follow your body's shape without feeling restrictive. The shoulder seams should sit naturally on your shoulders, and the sleeves should end around the middle of your upper arm. If you're active or wear T-shirts to the gym, a slightly athletic fit tends to move better and feels less bulky.

When the fit is right, even a plain T-shirt looks polished.

Pay Attention to the Neckline

It's a small detail, but it changes the overall look.

Crew necks are the easiest choice because they work with almost everything. If you prefer something a little different, a subtle V-neck or scoop neck can create a cleaner silhouette without looking overdone. The important thing is avoiding necklines that are either too tight or too loose.

Build Around Versatile Colors

Instead of filling your wardrobe with bold prints, build a solid foundation first.

White, black, navy, and grey are the colors I wear most because they work with almost everything. Once you have those covered, adding a few shades like olive, burgundy, or beige gives you more variety without making outfits harder to match.

Simple colors tend to stay stylish much longer than graphic-heavy designs.

Take Care of Them Properly

Even a quality T-shirt won't last if it's washed carelessly.

Turning shirts inside out before washing helps preserve the fabric and color. I also prefer cold water and let them air dry whenever possible. It takes a little longer, but they stay in better condition for much longer.

The Difference Is in the Details

I've realized that upgrading a wardrobe doesn't require buying dozens of new clothes. Sometimes replacing a few poor-quality basics with well-made essentials makes a bigger impact than following every fashion trend.

Over the past several months, I've focused on buying fewer but better T-shirts, and getting dressed has become much easier. Everything matches, everything fits, and I don't have to think twice before heading out.

If you're planning to refresh your collection, take a look at the men's T-shirts from Frishay. The collection focuses on comfortable fabrics, modern fits, and versatile colors that work for everyday wear.

Sometimes the simplest pieces end up being the ones you wear the most.

Building a Shared Wishlist App for Couples with Flask and SQLite

Rock — Thu, 16 Jul 2026 06:42:49 +0000

When you're in a relationship, keeping track of gift ideas for each other can be a fun but chaotic process. You might text links back and forth, forget what you've already seen, or struggle to find something that feels truly personal. Instead of letting those ideas get lost, why not build a simple shared wishlist app? This is a great beginner-to-intermediate project for sharpening your Flask skills, and it solves a real problem.

We'll create a basic Flask app with SQLite where two people can log in, add items, mark them as purchased, and leave notes. Think of it as a private, collaborative list for anniversaries, birthdays, or just because.

First, set up your environment. You'll need Flask and Flask-SQLAlchemy.

pip install flask flask-sqlalchemy

Now, create a file called app.py. We'll start with the database model. For a couple, we can keep it simple: one table for users and one for wishes.

from flask import Flask, render_template, request, redirect, url_for, flash
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-here'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///wishlist.db'
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.init_app(app)

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    password = db.Column(db.String(120), nullable=False)
    wishes = db.relationship('Wish', backref='author', lazy=True)

class Wish(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    url = db.Column(db.String(500))
    note = db.Column(db.Text)
    purchased = db.Column(db.Boolean, default=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

Next, add a route to display the wishlist. This is where the couple can see all their shared ideas.

@app.route('/')
@login_required
def index():
    wishes = Wish.query.all()
    return render_template('index.html', wishes=wishes)

The template is where the magic happens. In templates/index.html, you can loop through wishes and show a toggle button for purchased status. Here's a snippet:

{% for wish in wishes %}



{{ wish.title }}

    {% if wish.url %}
        View Item
    {% endif %}


{{ wish.note }}



        {{ 'Mark as Purchased' if not wish.purchased else 'Unmark' }}



{% endfor %}

This is a minimal but functional start. You can expand it with categories, images, or even a shared calendar for gifting deadlines.

The real value here is that you're not just coding for the sake of coding—you're building something that strengthens a relationship. It turns gift-giving into a collaborative, thoughtful experience rather than a last-minute scramble. And if you're looking for inspiration for actual gifts, you might check out curated collections like the one at Frishay for couple gifts, but the app itself is what makes the process personal.

By the end, you'll have a fully functional app that you and your partner can use daily. It's a perfect weekend project that combines database design, authentication, and front-end logic. Plus, it's way more romantic than another CRUD tutorial.

# Building a Lightweight Product Filter with Vanilla JavaScript

Rock — Wed, 15 Jul 2026 06:32:43 +0000

Building a Lightweight Product Filter with Vanilla JavaScript

While building a small e-commerce project, I wanted users to filter products instantly without refreshing the page. Instead of relying on a frontend framework, I opted for a simple solution using HTML data attributes, vanilla JavaScript, and a little CSS.

The goal was straightforward: let visitors filter items by size while keeping the interface fast, responsive, and easy to maintain.

HTML Structure

Each product card stores its information in data-* attributes. This keeps the markup clean and makes filtering straightforward.

<div class="filters">
  <button class="filter-btn" data-filter="all">All</button>
  <button class="filter-btn" data-filter="small">S</button>
  <button class="filter-btn" data-filter="medium">M</button>
  <button class="filter-btn" data-filter="large">L</button>
</div>

<div class="product-grid">
  <div class="product-card" data-size="medium" data-style="cargo">
    Cargo Shorts
  </div>

  <div class="product-card" data-size="large" data-style="chino">
    Chino Shorts
  </div>

  <!-- More product cards -->
</div>

Using data attributes means you can add new filter categories later without changing your overall structure.

JavaScript Filtering Logic

The filtering logic listens for button clicks and simply shows or hides product cards based on the selected size.

const filterButtons = document.querySelectorAll(".filter-btn");
const productCards = document.querySelectorAll(".product-card");

filterButtons.forEach((button) => {
  button.addEventListener("click", () => {
    const filterValue = button.dataset.filter;

    productCards.forEach((card) => {
      const cardSize = card.dataset.size;

      if (filterValue === "all" || cardSize === filterValue) {
        card.classList.remove("hidden");
      } else {
        card.classList.add("hidden");
      }
    });

    filterButtons.forEach((btn) => btn.classList.remove("active"));
    button.classList.add("active");
  });
});

The implementation is intentionally minimal:

No external libraries
No virtual DOM
No unnecessary complexity
Easy to extend with additional filters like color, category, or brand

Adding Smooth Transitions

Instead of having products instantly disappear, a small transition creates a smoother user experience.

.product-card {
  overflow: hidden;
  transition: opacity 0.3s ease, max-height 0.3s ease;
}

.product-card.hidden {
  opacity: 0;
  max-height: 0;
  margin: 0;
  padding: 0;
}

These subtle animations make the interface feel much more polished without affecting performance.

Why This Approach Works

For many projects, especially smaller storefronts or internal dashboards, a lightweight solution is often the better choice.

Some advantages include:

Fast page interactions
Zero dependencies
Easy debugging
Beginner-friendly code
Excellent browser support

Because everything is driven by HTML data attributes, you can easily expand this approach to support:

Multiple filter groups
Search functionality
Sorting
Category filtering
Price ranges
Combined filters

Final Thoughts

Vanilla JavaScript is still an excellent choice for interactive UI components like product filtering. Unless your application truly requires a large framework, simple DOM manipulation can provide an experience that's fast, maintainable, and easy to understand.

Sometimes the simplest solution ends up being the most reliable. This filtering pattern is reusable across almost any catalog or gallery, making it a handy technique to keep in your frontend toolbox.

The Algorithm for the Perfect Casual Shirt: Fit, Fabric & Function

Rock — Tue, 14 Jul 2026 05:36:00 +0000

Let's be honest: finding the perfect casual shirt can feel like debugging a complex piece of code. You have to test for multiple variables. But once you find the right one, it's a game-changer.

Here's the algorithm I use:

1. Fit (The Most Important Variable)
A shirt should follow your body's contour without being tight. The shoulder seam should align with your shoulder bone. The sleeves should end at your wrist bone. If it's too loose, you look sloppy. Too tight, you look uncomfortable.

2. Fabric (The Runtime Environment)
Cotton is the standard, but look for blends that offer breathability and wrinkle resistance. A little bit of elastane gives you stretch for movement. Linen is great for summer but wrinkles easily.

3. Style (The User Interface)
Consider the collar: a button-down collar is more casual, while a spread collar is slightly dressier. Pockets add utility, but a clean front is more modern.

4. Color Palette (The API)
Neutrals (white, navy, grey) are your core functions. They work with everything. Then add a few accent colors (like olive or burgundy) for variety.

I recently applied this logic and found a great collection of shirts that meet all these criteria. They're comfortable, durable, and look great for both work and weekends.

Check them out: https://frishay.com/collections/men-shirts

What's your go-to shirt style?

The Perfect Men’s T-Shirt: A Simple Guide to Fit, Fabric, and Timeless Style

Rock — Mon, 13 Jul 2026 11:15:05 +0000

Let's talk about the humble t-shirt. It's the backbone of every guy's wardrobe, but finding the perfect one can be surprisingly tricky. I've gone through my fair share of t-shirts that shrunk after one wash, lost their shape, or just didn't feel right.

Over time, I've figured out what to look for. First, the fabric. A good quality cotton or a cotton blend is essential. It should feel soft against your skin but durable enough to withstand regular wear and washing. Second, the fit. You want something that's not too tight and not too baggy. A modern fit that skims your body without being restrictive is ideal.

Style-wise, the options are endless. Solid colors like navy, black, and white are timeless and go with everything. But don't be afraid to experiment with patterns or subtle textures. A well-chosen t-shirt can elevate a simple outfit of jeans and sneakers.

Another tip: pay attention to the neckline. A crew neck is classic, but a V-neck can add a bit of variety. And for goodness sake, make sure the sleeves aren't too long or too short. It's the little details that make a big difference.

If you're on the hunt for some new tees, our collection has a variety of modern designs and high-quality fabrics. You'll find something for everyday wear, workouts, or just hanging out.

Browse the collection here: Shop Men T-Shirts

fashion #style #menswear #t-shirts

The Ultimate Everyday Shirt Guide: Timeless Fits, Fabrics, and Styles for Men

Rock — Mon, 13 Jul 2026 11:12:55 +0000

Shirts are a staple in any developer's wardrobe, but finding the right one can be tricky. I've spent years trying different fits, fabrics, and styles, and I've finally cracked the code. Here's what I've learned.

First, fit is king. A shirt that's too baggy looks sloppy, while one that's too tight restricts movement. Look for a slim or regular fit that allows you to move your arms freely without pulling at the buttons. The shoulder seams should align with your shoulders, and the collar should fit comfortably—you should be able to slide two fingers inside.

Fabric choice matters more than you think. Cotton is breathable and comfortable, but it wrinkles easily. If you're on the go, consider a cotton-poly blend or a wrinkle-resistant fabric. For a more polished look, Oxford cloth or chambray are great options. They're durable, versatile, and look good both tucked and untucked.

Now, let's talk trends. Classic patterns like checks, stripes, and solid colors are always in style. But don't be afraid to experiment with subtle prints or textured fabrics. A light blue Oxford shirt is a must-have—it goes with everything from jeans to chinos to suits.

Practical outfit ideas? For a casual day, pair a chambray shirt with dark jeans and sneakers. For a smart-casual look, tuck a checked shirt into khakis and add desert boots. And for those days when you need to look sharp, a white or light blue shirt with a blazer is a winner.

If you're looking to refresh your shirt collection, I've been checking out the men's shirts at Frishay. They have a wide range of styles and fits that are both affordable and durable. It's a great place to start if you're building a versatile wardrobe.

What's your go-to shirt for everyday wear? Share your favorites in the comments.

Effortless Everyday Elegance: Refresh Your Wardrobe with Versatile Styles from Frishay

Rock — Mon, 13 Jul 2026 11:07:45 +0000

I've been trying to simplify my wardrobe without sacrificing style, and it's all about finding those key pieces that just work. For me, that means dresses that can go from a Zoom call to a dinner date with a change of accessories, and tops that are comfortable enough for a full day but still look put together. The modern woman's wardrobe needs to be flexible. I've been really into soft fabrics and cuts that flatter without being fussy. Seasonal trends are fun, but I'm more interested in pieces that build confidence. A great pair of trousers or a well-fitted blouse can make you feel unstoppable. I've been shopping around and found a collection that nails this balance of trendy and timeless. It's full of versatile outfits that are both comfortable and fashion-forward. If you're looking to refresh your everyday style with pieces that actually make you feel good, check this out: https://frishay.com/collections/women-clothes

How to Find the Perfect Pair of Women's Jeans

Rock — Fri, 10 Jul 2026 06:16:00 +0000

Ever found yourself staring at a pair of jeans in your closet, wondering if they’re actually the one? I’ve been there. After years of trial and error, I’ve learned that the perfect pair of women’s jeans isn’t just about the brand—it’s about matching the cut to your body type and lifestyle. Let’s break down the three most common fits and how to style them, with a little help from my latest obsession.

1. Skinny Jeans: The Timeless Classic

Skinny jeans are a wardrobe staple for good reason. They hug your curves from hip to ankle, making them ideal for pairing with oversized sweaters or structured blazers. Pro tip: Look for a mid-rise with a bit of stretch (try 2% elastane). For a casual look, tuck in a graphic tee and add white sneakers. Need a dressier vibe? Swap the sneakers for ankle boots.

2. Straight-Leg Jeans: The Comfort Hero

If you’re tired of feeling squeezed, straight-leg jeans are your best friend. They offer a relaxed fit through the thigh without being baggy. I love these for running errands or working from home. Style them with a tucked-in blouse and a belt to define your waist. For a modern twist, roll the hem to show off your favorite loafers.

3. Bootcut Jeans: The Retro Comeback

Bootcut jeans are making a huge comeback, and they’re incredibly flattering. The slight flare balances out wider hips and elongates your legs. Wear them with heeled boots or chunky platform sneakers. A fitted turtleneck or cropped jacket completes the silhouette.

Why Fit Matters More Than Brand

I’ve tried premium denim that felt like cardboard and budget pairs that felt like butter. The secret is in the fabric composition. Look for a blend of cotton, polyester, and elastane for that “second skin” feel. And always check the rise—high-waisted styles (10-12 inches) are universally flattering.

My Current Go-To

I recently discovered a collection that nails all three fits without breaking the bank. The women’s jeans at Frishay have a surprisingly soft hand feel and come in washes that don’t fade after one wash. Their straight-leg pair is my new weekday uniform.

Quick Code Tip

If you’re building a product filter for a denim store, here’s a simple function to sort by rise:

const jeans = [
  { name: &#039;High Rise&#039;, rise: 11 },
  { name: &#039;Mid Rise&#039;, rise: 9 },
  { name: &#039;Low Rise&#039;, rise: 7 }
];
const byRise = jeans.sort((a, b) =&gt; a.rise - b.rise);

The right jeans make you feel unstoppable. What’s your go-to fit? Let me know in the comments.