DEV Community: kelen.cc

ZipPic: Free Image Compression Tool for Ultimate Compression Experience

kelen.cc — Tue, 27 Jan 2026 14:00:00 +0000

Image compression is an essential task in numerous daily work scenarios, such as creating banners, product images and article illustrations for independent websites. Overly large image files will cause slow page loading and prolonged "white screen" time, which may result in users closing the page directly. According to industry standards, web images are recommended to be compressed to 100KB–1MB (depending on specific dimensions). For example, Taobao product images are usually compressed to under 500KB to ensure fast browsing and improve user retention.

TinyPng and Squoosh are the most well-known tools on the market. Below is a comparison of the compression performance of these three different image compression tools:

TinyPng

TinyPng supports the compression of formats including AVIF, WebP, PNG and JPEG. It allows uploading up to 20 images at a time, with a 5MB limit per image, and users can manually set the target format.

Official Website: https://tinypng.com/

Advantages

Simple and user-friendly interface design for easy operation
Fast compression speed with relatively high output quality
Supports one-click packaging and CDN storage
Compatible with APNG animated images

Disadvantages

File upload restrictions: maximum 20 images per session and 5MB per file
Cloud-based upload is required, leading to slow access speeds for users in China
No support for custom compression quality settings

Squoosh

Developed by Google Chrome Labs, Squoosh is an open-source online image compression tool that supports the compression of JPEG, WebP, PNG and other formats. Users can adjust parameters to reduce image file size while maintaining high visual quality.

Official Website: https://squoosh.app/

Advantages

Customizable parameters: users can adjust image dimensions, reduce color depth, select compression algorithms, etc., to find the optimal balance between image quality and file size through parameter optimization.
No registration or login required; simply open the webpage to upload and compress images, featuring simple operation and a clean interface.
No need to upload images to CDN, ensuring user privacy and data security.
No single file size limit.

Disadvantages

Only single-image processing is supported currently, resulting in low efficiency for users who need batch compression of a large number of images.
English-only interface, which may cause initial comprehension difficulties for non-English speakers.
Does not support the compression of animated images such as GIF and APNG.

ZipPic

Finally, we highlight ZipPic, a free online image compression tool that requires no login. It combines the strengths of TinyPng and Squoosh while addressing their inherent shortcomings.

Official Website: https://zippic.app/

Advantages

Supports conversion and compression of static image formats (JPEG, PNG, AVIF, WEBP) as well as animated image formats (GIF, Animated WebP, APNG).
Enables batch image processing and one-click packaged download.
Comes with a built-in image cropping function to resize images as needed.
Multilingual support for user-friendly international usage.

Conclusion

A great image compression tool is one that meets 90% of the common functional needs in daily scenarios. We welcome your valuable suggestions and discussions in the comment section.

Image Compression Tool Comparison: Zippic vs. TinyPNG

kelen.cc — Sat, 13 Sep 2025 13:51:31 +0000

Image compression is a vital efficiency tool in various workflows. For content creators, it reduces image transfer times and bypasses platform format restrictions. In web development, smaller file sizes significantly enhance page load speeds, improving user retention. For design collaboration, it optimizes storage space and bandwidth, lowering operational costs across multiple dimensions.

Among the numerous image compression tools available, TinyPNG is widely recognized, while Zippic remains relatively under-discussed. This article provides a comprehensive comparison of these two tools across three key dimensions—UI functionality, compression performance, and security—to guide users in making an informed choice.

UI Design and Functionality Comparison

The ease of use and functional adaptability of a tool directly impact daily workflow efficiency. Let’s begin with an analysis of their UI and core limitations.

TinyPNG

TinyPNG features a clean, intuitive UI that supports batch image compression. However, it imposes clear restrictions: a maximum of 20 images per batch and a 5MB size limit per image. For users handling large files (e.g., design source files or high-resolution assets), these limitations may not suffice for all use cases.

Zippic

Zippic overcomes these constraints with a clear, user-friendly UI and supports compression without limits on the number or size of images. Whether processing dozens of assets or individual files exceeding 5MB, Zippic enables seamless batch uploads, offering greater flexibility across diverse scenarios.

Compression Performance Comparison

Compression performance is the core metric of any tool’s effectiveness. To ensure an objective evaluation, we tested both tools using a 2MB PNG image as a sample, compressing it into PNG, JPG, and AVIF formats, and compared the resulting file sizes.

1. PNG Format (Preserves Transparency)

TinyPNG: Reduced the file to 649KB.
Zippic: Further compressed it to 409KB.

Both tools maintained comparable image clarity, but Zippic demonstrated a more aggressive compression ratio.

2. JPG Format (Preferred for General Use)

TinyPNG: Output file size of 223KB.
Zippic: Reduced to 115KB, achieving nearly a 50% size reduction.

Zippic’s superior compression makes it ideal for size-sensitive scenarios, such as web images or mobile content publishing.

3. AVIF Format (Next-Generation Compression)

TinyPNG: Compressed to 59KB.
Zippic: Optimized to 41KB.

As an emerging format that balances detail retention with small file sizes, AVIF is increasingly popular. Zippic’s output excels in modern browser-compatible scenarios, striking an optimal balance between clarity and file size.

Security Comparison

Privacy and security are critical when handling sensitive images, such as user avatars, design drafts, or personal photos. The two tools differ significantly in their processing approaches:

Zippic: Utilizes local compression, processing images entirely on the user’s device without uploading to third-party servers. This approach eliminates the risk of data leaks, offering robust privacy protection.
TinyPNG: Requires images to be uploaded to cloud servers for processing, with the processed files returned to the user. While TinyPNG claims to delete images from its servers, users handling sensitive content may still have privacy concerns.

Conclusion and Recommendations

Both Zippic and TinyPNG are highly effective image compression tools, but their strengths cater to different needs:

Zippic excels in flexibility and security. Its unrestricted batch processing and lack of file size limits make it suitable for handling large or numerous files, while local compression ensures superior privacy protection. It is ideal for design teams, heavy content creators, or users prioritizing data security.
TinyPNG, a well-established tool, offers a simple interface and reliable compression for basic needs (e.g., small batches of lightweight images). Its widespread recognition and low learning curve make it a dependable choice for casual users.

When choosing between the two, consider your primary needs: for large-scale or sensitive image processing with a focus on privacy, Zippic is the better option. For straightforward compression tasks and a familiar experience, TinyPNG remains a solid choice.

How to Quickly Batch Compress 1000 Images

kelen.cc — Sat, 06 Sep 2025 03:59:02 +0000

I recently discovered an excellent image compression tool called Zippic. Today, I’m sharing a guide on how to use Zippic for image compression.

What is Zippic?

Zippic is a free image compression tool that supports multiple image formats, including JPEG, JPG, PNG, WebP, AVIF, and even animated formats like GIF, PNG animations, and WebP animations. It delivers impressive compression quality.

How to Perform Batch Compression

To get started, visit the Zippic official website at https://www.zippic.cn/batch and follow these steps:

Select the images you want to compress. A list of selected images will appear at the bottom.
Choose the desired output image format.
Select the output image quality; the default settings are generally sufficient.
Click the "Start Compression" button.

A progress bar will appear in the image list. Simply wait for the compression to complete.

Once the compression is finished, the download button will become active. Clicking it will package the compressed images into a ZIP file for download to your local computer.

Compression Quality Comparison

Comparing a few images before and after compression, you’ll notice a significant reduction in file size while maintaining high image clarity and quality.

Summary

Zippic supports batch compression of multiple images with excellent quality. The entire compression process is performed locally, ensuring user privacy by eliminating the need to upload images to a server. If you need an efficient image compression tool, Zippic is worth trying. In the future, I’ll share more about Zippic’s cropping features, as well as its GIF and PNG animation generation capabilities, which are also highly practical. Thank you for reading!

How to efficiently compress image file size while maintaining image quality?

kelen.cc — Sun, 03 Aug 2025 14:05:29 +0000

In our daily work, image compression is often necessary, such as when publishing articles on websites or posting comments with images on forums, where file size restrictions are common. This article introduces a highly effective image compression tool that is simple to use.

Online Image Compression Tool: ZipPic

ZipPic is a free online image compression tool. Leveraging advanced compression algorithms, ZipPic achieves significantly smaller file sizes compared to other tools while maintaining the quality of compressed images.

Features of ZipPic

Local Compression: No cloud upload is required; all image compression is performed locally, ensuring better protection of user privacy.
User-Friendly Interface: ZipPic features a minimalist interface, supporting operations via drag-and-drop, paste, or file selection.
Compression Comparison: After compression, ZipPic automatically generates a side-by-side comparison of the original and compressed images, allowing users to evaluate file size and quality differences.
Format Support: ZipPic supports various image formats, including JPG, PNG, GIF, and AVIF, as well as animated formats like GIF, WEBP, and APNG.
Quality Customization: Users can adjust image quality via a slider, and ZipPic generates images at different quality levels, enabling users to select the most suitable option.

How to Use ZipPic

Visit the official website: https://www.zippic.com/

Select the desired output image format.

Choose the preferred image quality.

Upload the image, and compression will start automatically.

Compare the original and compressed images.

Download the compressed image.

Conclusion

ZipPic is a highly convenient image compression tool, offering impressive compression ratios while preserving image quality. It is strongly recommended for efficient and user-friendly image compression.

如何高效压缩图片体积，保持图片质量不变？

kelen.cc — Sun, 03 Aug 2025 14:02:56 +0000

我们日常工作中经常需要进行图片压缩，比如网站发布文章，或者在论坛发布带图评论，都有文件大小限制，那么如何进行图片压缩，本文介绍一款非常有用的图片压缩工具，使用起来非常简单。

在线图片压缩工具 ZipPic

ZipPic 是一款免费的在线图片压缩工具网站，凭借着压缩算法，ZipPic 压缩的图片体积比其他工具要小很多，而且压缩后的图片质量不会下降。

ZipPic 特点

本地压缩，无需上传云端，所有的图片压缩都在本地完成，可以更好保护用户的隐私。
操作简单，ZiPic 的界面非常简约，可以通过拖拽，粘贴、选择图片等三种方式进行操作图片。
压缩对比，压缩完成后，ZipPic 会自动生成压缩前的图片和压缩后的图片，方便用户对比压缩前后的图片大小和质量。
格式支持，ZipPic 支持的图片格式有 JPG、PNG、GIF、AVIF 等，动图包括 GIF、WEBP、APNG 等。
质量选择，可以通过拖拽选择你喜欢的图片质量，ZipPic 会自动生成不同质量图片，方便用户选择最合适的图片质量。

如何操作

我们打开官网 https://www.zippic.com/

选择你想要输出的图片格式

选择你想要的图片质量

选择图片，就会自动进行压缩

压缩前后图片对比

下载图片

总结

ZipPic 是一款非常便捷的图片压缩工具，压缩比例非常高，还能保持图片质量不变，非常值得推荐。

Image Loading Optimization for Search Engine Optimization

kelen.cc — Sat, 08 Mar 2025 10:14:45 +0000

The Importance of Image Loading for User Experience

The image loading speed is one of the core factors affecting the user experience. According to Google's research, for every additional second of page loading time, the user bounce rate may increase by 7%, and the conversion rate may decrease by about 20%. On mobile devices, delayed image loading can lead to layout shift (CLS), disrupting the visual smoothness. Moreover, if the loading of the first-screen image exceeds 2.5 seconds, it will directly affect the LCP (Largest Contentful Paint) indicator and reduce the page weight. High-quality and fast-loading images can enhance the credibility of the content and help users quickly understand the information (such as e-commerce product images). In contrast, poorly adapted images (such as those without reserved dimensions or with an overly large format) can cause layout confusion on mobile devices, significantly reducing user satisfaction. Optimizing image loading is not only a technical requirement but also a key strategy for improving user retention and conversion.

The Impact of Image Size on Core Web Vitals Metrics

LCP (Largest Contentful Paint): Images are one of the main sources of LCP elements. It is necessary to ensure that the first-screen images are loaded within 2.5 seconds.
CLS (Cumulative Layout Shift): When images without reserved dimensions are loaded, it will cause the page to jump. This problem can be eliminated by using the width/height attributes.
FID (First Input Delay): Excessive image loading can block the main thread. It is recommended to control the priority of image resources within a reasonable range.

Basic Settings for Image Optimization

Image format selection (WebP/AVIF/JPEG/PNG)

Format	Compression Rate	Transparency Support	Browser Compatibility	Applicable Scenarios
WebP	★★★★☆	Supported	Modern browsers (over 92%)	Photos, complex graphics
AVIF	★★★★★	Supported	Chrome/Firefox	Scenarios where extreme compression is pursued
JPEG	★★★☆☆	Not supported	Fully compatible	Photos, images without transparency requirements
PNG	★★☆☆☆	Supported	Fully compatible	Icons, elements with transparent backgrounds

Image Compression Tools (TinyPNG/Squoosh)

TinyPNG: Supports PNG/JPEG formats, has a high compression rate, and does not require installation. It can compress up to 20 images at a time, with a maximum size of 5MB.
Squoosh: Supports WebP/AVIF/JPEG/PNG formats, allows for custom compression parameters, supports batch compression, and does not require installation.
ZipPic: In addition to supporting WebP/AVIF/JPEG/PNG formats, it also supports the GIF format and WebP animations. It has a high compression rate, does not require installation, and supports batch compression. It is more powerful than TinyPNG and Squoosh.

Let's take the image of Super Mario as an example.

The size comparisons after processing with the above three compression tools are as follows:

Original Image Size	After Compression by TinyPNG	After Compression by Squoosh	After Compression by ZipPic
514KB	124KB	436KB	136KB

Image Loading Optimization Strategies

Lazy Loading

Lazy loading means loading image resources only when the images enter the visible area. This can reduce the first-screen loading time and improve the user experience. Common implementation methods of lazy loading include:

IntersectionObserver API: Monitors whether an element enters the viewport and triggers the loading event.

const observer = new IntersectionObserver((entries) => {
  entries.forEach((entry) => {
    if (entry.isIntersecting) {
      const img = entry.target;
      img.src = img.dataset.src;
      observer.unobserve(img);
    }
  });
});

document.querySelectorAll("img").forEach((img) => {
  observer.observe(img);
});

lazyload.js: A lightweight image lazy loading library that supports functions such as image preloading, placeholder images, and lazy loading events.

<script src="https://cdn.jsdelivr.net/npm/lazyload@2.0.0-beta.2/lazyload.min.js"></script>
<img class="lazy" data-src="image.jpg" src="placeholder.jpg" />
<script>
  new LazyLoad();
</script>

Preloading

Preloading means loading image resources into the browser cache in advance. When users need to view the images, they can directly obtain them from the cache, which speeds up the image display.

Using the preload tag: In HTML, specify the resource to be preloaded through the rel="preload" attribute of the link tag, and at the same time, set the as attribute to specify that the resource type is an image.

<link rel="preload" href="important-image.jpg" as="image" />

JavaScript preloading: Achieve preloading by creating an Image object and setting the src attribute.

const preloadImages = (imageUrls) => {
  imageUrls.forEach((url) => {
    const img = new Image();
    img.src = url;
  });
};

const imagesToPreload = ["image1.jpg", "image2.jpg", "image3.jpg"];

preloadImages(imagesToPreload);

Responsive Images

Provide appropriate sizes and resolutions of images according to the screen sizes, resolutions, and pixel densities of different devices to avoid loading overly large or small images and improve the loading efficiency.

Using the srcset and sizes attributes: The srcset defines a set of image URLs and their corresponding width descriptors, and the sizes defines the width of the image to be selected under different screen widths.

<img
  src="default-image.jpg"
  srcset="small-image.jpg 480w, medium-image.jpg 800w, large-image.jpg 1200w"
  sizes="(max-width: 480px) 480px, (max-width: 800px) 800px, 1200px"
  alt="Responsive Image"
/>

Using the <picture> element: Different image sources can be selected according to different conditions (such as media queries, support for image formats, etc.).

<picture>
  <source media="(min-width: 800px)" srcset="large-image.jpg" />
  <source media="(min-width: 480px)" srcset="medium-image.jpg" />
  <img src="small-image.jpg" alt="Responsive Image" />
</picture>

Optimizing Image Format and Compression

Selecting the appropriate image format and performing reasonable compression can reduce the file size while ensuring the image quality, thus speeding up the loading speed.

Selecting the appropriate format: As mentioned earlier, WebP and AVIF formats have an advantage in compression rate and are well supported by modern browsers; JPEG is suitable for photo-like images; PNG is suitable for images with transparent backgrounds or simple graphics.
Further compression: In addition to using tools such as TinyPNG and Squoosh, automated compression plugins can also be integrated during the build process to perform batch processing on images, ensuring that all images in the project are optimized.

By comprehensively applying the above image loading optimization strategies, the performance and user experience of websites or applications can be significantly improved. While increasing the page loading speed, it can also reduce the user bounce rate and increase user retention and conversion rates.

NodeJs 23 New Features and Improvements

kelen.cc — Sun, 02 Feb 2025 11:52:44 +0000

The Node.js 23 version brings numerous new features and improvements to developers. Let's take an in-depth look at these changes and showcase how to use these new features through practical code examples.

Built-in WebSocket Client API

Node.js 23 now has a built-in WebSocket client API, eliminating the need to use third-party libraries. This significantly simplifies the use of WebSocket.

Example code:

// Code interpretation
const WebSocket = require("node:ws");

const ws = new WebSocket("ws://example.com:8080");

ws.on("open", function open() {
  console.log("Connection established");
  ws.send("Hello, server!");
});

ws.on("message", function incoming(data) {
  console.log("Received message:", data.toString());
});

ws.on("close", function close() {
  console.log("Connection closed");
});

Web Streams API

Node.js 23 introduces the Web Streams API, making it more convenient to handle stream data.

Example code:

// Code interpretation
const { ReadableStream, WritableStream, TransformStream } = require("node:stream/web");

const readableStream = new ReadableStream({
  start(controller) {
    controller.enqueue("Hello");
    controller.enqueue("World");
    controller.close();
  },
});

const transformStream = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const writableStream = new WritableStream({
  write(chunk) {
    console.log(chunk);
  },
});

readableStream.pipeThrough(transformStream).pipeTo(writableStream);

Global Blob and BroadcastChannel API

The Blob and BroadcastChannel APIs can now be used globally.

Blob example:

// Code interpretation
const blob = new Blob(["Hello, World!"], { type: "text/plain" });
const text = await blob.text();
console.log(text); // Output: Hello, World!

BroadcastChannel example:

// Code interpretation
const channel = new BroadcastChannel("test_channel");

channel.postMessage("Hello, channel!");

channel.onmessage = (event) => {
  console.log("Received message:", event.data);
};

Native ESM Support

Node.js 23 further enhances support for ECMAScript modules (ESM).

Example code (math.mjs):

// Code interpretation
export function add(a, b) {
  return a + b;
}

export function multiply(a, b) {
  return a * b;
}

Using the module (main.mjs):

// Code interpretation
import { add, multiply } from "./math.mjs";

console.log(add(5, 3)); // Output: 8
console.log(multiply(4, 2)); // Output: 8

Experimental TypeScript Stripping

Node.js 23 introduces the experimental TypeScript stripping feature, allowing you to run TypeScript files directly.

Example code (hello.ts):

// Code interpretation
function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("Zhang San"));

Running command:

# Code interpretation
node --experimental-strip-types hello.ts

Built-in File Watching

Node.js 23 has a built-in file-watching feature, eliminating the need to use third-party tools like nodemon.

Example code (app.js):

// Code interpretation
console.log("Server is running...");

// Simulate server logic
setInterval(() => {
  console.log("Processing requests...");
}, 2000);

Running command:

# Code interpretation
node --watch app.js

Now, whenever you modify the app.js file, Node.js will automatically restart the application.

Native Environment Variable Support

Node.js 23 supports directly loading.env files without the need for libraries like dotenv.

Example.env file:

# Code interpretation
DB_HOST=localhost
DB_USER=root
DB_PASS=password123

Example code (config.js):

// Code interpretation
console.log(process.env.DB_HOST);
console.log(process.env.DB_USER);
console.log(process.env.DB_PASS);

Running command:

# Code interpretation
node --env-file=.env config.js

Test Runner Module

Node.js 23 introduces the experimental node:test module, facilitating the creation and running of JavaScript tests.

Example code (test.js):

// Code interpretation
const test = require("node:test");
const assert = require("node:assert");

test("Simple addition test", (t) => {
  assert.strictEqual(1 + 2, 3);
});

test("Asynchronous test", async (t) => {
  const result = await Promise.resolve(42);
  assert.strictEqual(result, 42);
});

Running tests:

# Code interpretation
node --test test.js

These new features and improvements make Node.js 23 a more powerful and user-friendly JavaScript runtime environment. Through these practical code examples, developers can better understand and utilize these new functions, improving development efficiency and code quality.

More articles can be found at: https://en.kelen.cc/

Small but Powerful Treasure Libraries for Front-end Development in 2025

kelen.cc — Sat, 01 Feb 2025 15:14:40 +0000

In the field of front-end development, small libraries with low integration costs and powerful functions are development tools that can significantly improve efficiency and user experience. Here are several small but powerful front-end libraries that you can't miss in 2025.

Original Source URL: https://en.kelen.cc/share/small-but-powerful-treasure-libraries-for-front-end-development

radash

Radash is a lightweight, functional programming utility library based on TypeScript. It is more modern than lodash. It is built on JavaScript's native methods, discarding the outdated functions in lodash and adding features like tryit and retry. Its source code is clear, and many functions can be directly copied and used. It is very efficient when dealing with operations on object arrays. For example:

import { sortBy } from "radash";

const users = [
  { name: "Alice", score: 85 },
  { name: "Bob", score: 70 },
  { name: "Charlie", score: 90 },
];

const sortedUsers = sortBy(users, "score", "desc");
console.log(sortedUsers);

In the above code, the sortBy function of radash is used to sort the user array in descending order according to the score property.

use-debounce

useDebounce

use-debounce is designed specifically for React development. It is less than 1Kb in size, is compatible with underscore/lodash, and supports server-side rendering. It can effectively avoid frequent interface calls when dealing with frequently triggered events. Here is a code example:

import React, { useState } from "react";
import { useDebounce } from "use-debounce";

const DebounceExample = () => {
  const [inputValue, setInputValue] = useState("");
  const [debouncedValue] = useDebounce(inputValue, 300);

  const handleChange = (e) => {
    setInputValue(e.target.value);
  };

  return (
    <div>
      <input type="text" onChange={handleChange} placeholder="Enter content" />
      <p>Debounced value: {debouncedValue}</p>
    </div>
  );
};

export default DebounceExample;

In this example, useDebounce debounces the value of the input box for 300 milliseconds.

timeago.js

timeago.js is only 2Kb. It is used to format dates into relative expressions to the current time, such as "a few minutes ago", "a few days ago", etc., and supports multiple languages. It can make time display more user-friendly in scenarios such as social media and forums. The usage method is as follows:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale = 1.0" />
    <title>timeago.js Example</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/timeago.js/4.0.2/timeago.min.js"></script>
  </head>

  <body>
    <time datetime="2024-12-01T12:00:00Z" class="timeago">2024-12-01 12:00:00</time>
    <script>
      const elements = document.querySelectorAll(".timeago");
      elements.forEach((element) => {
        timeago.render(element);
      });
    </script>
  </body>
</html>

This code uses timeago.js to convert the specified time into a relative time display.

react-use

React-use

react-use brings together various practical Hooks, covering functions from tracking battery status, geolocation, to setting favorites, debouncing, and video playback. Taking the use of useGeolocation to obtain geolocation as an example:

import React from "react";
import { useGeolocation } from "react-use";

const GeolocationExample = () => {
  const { latitude, longitude, error, isLoading } = useGeolocation();

  if (isLoading) return <div>Fetching location...</div>;
  if (error) return <div>Error fetching location: {error.message}</div>;

  return (
    <div>
      <p>Latitude: {latitude}</p>
      <p>Longitude: {longitude}</p>
    </div>
  );
};

export default GeolocationExample;

The above code uses the useGeolocation Hook of react-use to obtain the user's geolocation.

Day.js

Day.js is a simple date library with only 2Kb. It is basically compatible with Moment.js and supports multiple languages. It is concise and efficient in handling date parsing, formatting, calculation, comparison, etc. Here is an example:

import dayjs from "dayjs";

// Format the date
const formattedDate = dayjs("2024-12-01").format("YYYY-MM-DD HH:mm:ss");
console.log(formattedDate);

// Date calculation
const futureDate = dayjs().add(7, "day");
console.log(futureDate.format("YYYY-MM-DD"));

This code demonstrates the date formatting and calculation functions of Day.js.

filesize.js

filesize.js can convert numbers or strings into human-readable file sizes. Its minified version is only 2.94kb. It is widely used in scenarios such as file management systems and cloud storage applications. The usage method is as follows:

import filesize from "filesize";

const byteSize = 1048576; // 1MB
const humanSize = filesize(byteSize);
console.log(humanSize);

The above code converts the number of bytes into a human-readable file size format.

driver.js

driver.js is a page guidance library implemented in native JavaScript. It is easy to get started, and only 5kb after gzip compression. After a new product is launched or an application is updated, it can help users get familiar with new features. Here is an example:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale = 1.0" />
    <title>driver.js Example</title>
    <link rel="stylesheet" href="https://unpkg.com/driver.js/dist/driver.min.css" />
  </head>

  <body>
    <button id="targetButton">Click Me</button>
    <script src="https://unpkg.com/driver.js/dist/driver.min.js"></script>
    <script>
      const driver = new Driver();
      driver.defineSteps([
        {
          element: "#targetButton",
          popover: {
            title: "This is a button",
            description: "Click it to perform some operations",
          },
        },
      ]);
      driver.start();
    </script>
  </body>
</html>

This code uses driver.js to add a guidance prompt to the button.

@formkit/drag-and-drop

drag and drop

@formkit/drag-and-drop is a small drag-and-drop library about 4Kb. It is simple, flexible, and framework-independent, adhering to the data-first concept. Here is an example of implementing a file drag-and-drop upload function:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale = 1.0" />
    <title>File Drag-and-Drop Upload Example</title>
    <style>
      #dropzone {
        border: 2px dashed #ccc;
        padding: 50px;
        text-align: center;
      }
    </style>
  </head>

  <body>
    <div id="dropzone">Drag files here</div>
    <script src="https://unpkg.com/@formkit/drag-and-drop/dist/drag-and-drop.umd.js"></script>
    <script>
      const dropzone = document.getElementById("dropzone");
      const { dropzone: dz } = createDropzone(dropzone, {
        onDrop(files) {
          files.forEach((file) => {
            console.log("Uploading file:", file.name);
            // You can add the actual file upload logic here
          });
        },
      });
    </script>
  </body>
</html>

This example implements a simple file drag-and-drop upload function through @formkit/drag-and-drop.

These small but powerful front-end libraries are powerful and can meet a variety of development needs. In front-end development in 2025, you might as well try them to improve the efficiency of your projects.

More articles can be found at: https://en.kelen.cc/

16 Front-End Code Snippets Worth Checking Out

kelen.cc — Sun, 26 Jan 2025 01:58:28 +0000

In daily development, we all have some commonly used code snippets. They can be directly copied and used in various projects, which is very convenient. If you've taken over someone else's project, you may notice some identical utility-class methods across projects. These are the commonly used code snippets of previous developers.

Now, the front-end community is well-developed. There are many great libraries like lodash, dayjs, etc., which can meet our needs for handling arrays, dates, etc. This article won't repeat those common snippets.

1. Detect Clicks Outside an Element

When hiding pop-ups or collapsing dropdowns, use the contains method instead of layer-by-layer checking.

<div id="ele">Content</div>
<script>
  const ele = document.getElementById("ele");
  document.addEventListener("click", function (evt) {
    const isClickedOutside = !ele.contains(evt.target);
    if (isClickedOutside) {
      console.log("Clicked outside!");
    }
  });
</script>

2. Quickly Open the Official Website

To view a third-party library's homepage or code repository, use these npm commands:

# Open the homepage
npm home PACKAGE_NAME
# E.g., for React
npm home react

# Open the code repository
npm repo PACKAGE_NAME
# E.g., for React
npm repo react

3. One-Time Event Listener

Besides removing the listener in the event function, you can use the once parameter.

<button id="btn">Click</button>
<script>
  const handler = function () {
    console.log("Clicked once!");
  };
  const btn = document.getElementById("btn");
  btn.addEventListener("click", handler, { once: true });
</script>

4. Format Seconds into HH:mm:ss

For scenarios like showing audio/video duration, format seconds like this:

const formatSeconds = (s) =>
  [parseInt(s / 60 / 60), parseInt((s / 60) % 60), parseInt(s % 60)].join(":").replace(/\b(\d)\b/g, "0$1");
const seconds = 3661;
console.log(formatSeconds(seconds));

To show relative time like "Just now", try the timeago.js library.

5. Convert URL Parameters to an Object

Instead of using the query-string library, use the URLSearchParams API.

const getUrlParams = (query) =>
  Array.from(new URLSearchParams(query)).reduce(
    (p, [k, v]) => Object.assign({}, p, { [k]: p[k] ? (Array.isArray(p[k]) ? p[k] : [p[k]]).concat(v) : v }),
    {}
  );
const query = "?a=1&b=2&a=3";
console.log(getUrlParams(query));

6. Open a New Tab

When opening an external link, set rel="noopener noreferrer" to avoid security risks.

<a href="https://example.com" target="_blank" rel="noopener noreferrer">Open</a>
<script>
  function openNewTab() {
    window.open("https://example.com", "newTab", "noopener,noreferrer");
  }
</script>
<button onclick="openNewTab()">Open with window.open</button>

7. Display Uploaded Images

Use the FileReader API's readAsDataURL method to show uploaded images.

<input type="file" id="uploaded-file" />
<div id="result"></div>
<script>
  function readImage() {
    const fileReader = new FileReader();
    const file = document.getElementById("uploaded-file").files[0];
    if (file) {
      fileReader.readAsDataURL(file);
    }
    fileReader.addEventListener(
      "load",
      () => {
        const img = document.createElement("img");
        img.src = fileReader.result;
        document.getElementById("result").append(img);
      },
      { once: true }
    );
  }
  document.getElementById("uploaded-file").addEventListener("change", readImage);
</script>

8. File Download

Using the <a> tag's download attribute can trigger a download, but it has limitations.

<a href="/path/to/file" download>Download</a>
<script>
  function download(url) {
    const link = document.createElement("a");
    link.download = "file name";
    link.href = url;
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
  }
</script>
<button onclick="download('https://example.com/file')">Download with JS</button>

You can also set the response header on the server or use Blob and createObjectURL in the browser.

const data = JSON.stringify({ message: "Hello" });
const blob = new Blob([data], { type: "application/json" });
const url = window.URL.createObjectURL(blob);
download(url);
window.URL.revokeObjectURL(url);

9. Cache Results

Cache function results for complex calculations.

const memoize = (fn) =>
  (
    (cache = Object.create(null)) =>
    (arg) =>
      cache[arg] || (cache[arg] = fn(arg))
  )();
const complexCalculation = (num) => {
  let sum = 0;
  for (let i = 1; i <= num; i++) {
    sum += i;
  }
  return sum;
};
const memoizedCalculation = memoize(complexCalculation);
console.log(memoizedCalculation(10));
console.log(memoizedCalculation(10));

10. Multi-Line Ellipsis

Use CSS to truncate text with ellipses for single or multi-line.

.truncate-single {
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.truncate-multi {
  display: -webkit-box;
  -webkit-box-orient: vertical;
  -webkit-line-clamp: 2;
  overflow: hidden;
}

<div class="truncate-single">Long single-line text...</div>
<div class="truncate-multi">Long multi-line text... Long multi-line text...</div>

11. Select the Last Few Elements

Use CSS selectors to target specific elements.

li:nth-child(-n + 3) {
  text-decoration: underline;
}
li:nth-child(n + 2):nth-child(-n + 5) {
  color: #2563eb;
}
li:nth-last-child(-n + 2) {
  text-decoration-line: line-through;
}

<ul>
  <li>Item 1</li>
  <li>Item 2</li>
  <li>Item 3</li>
  <li>Item 4</li>
  <li>Item 5</li>
</ul>

12. Scrollbar Styles

Customize scrollbar styles with CSS or a third-party library like better-scroll.

::-webkit-scrollbar {
  width: 8px;
  height: 8px;
}
::-webkit-scrollbar-track {
  border-radius: 10px;
  background-color: #fafafa;
}
::-webkit-scrollbar-thumb {
  border-radius: 10px;
  background: rgb(191, 191, 191);
}
body {
  scrollbar-width: thin;
  scrollbar-color: #718096 #edf2f7;
}

13. Percentage Calculation-Largest Remainder Method

Use the largest remainder method to ensure percentage sums equal 1.

function getPercentWithPrecision(valueList, precision) {
  const digits = Math.pow(10, precision);
  const sum = valueList.reduce((total, cur) => total + cur, 0);
  const votesPerQuota = valueList.map((val) => (val / sum) * 100 * digits);
  const seats = votesPerQuota.map((val) => Math.floor(val));
  const remainder = votesPerQuota.map((val) => val - Math.floor(val));
  const totalSeats = 100 * digits;
  let currentSeats = votesPerQuota.reduce((total, cur) => total + Math.floor(cur), 0);
  while (totalSeats - currentSeats > 0) {
    let maxIdx = -1;
    let maxValue = Number.NEGATIVE_INFINITY;
    for (var i = 0; i < remainder.length; i++) {
      if (maxValue < remainder[i]) {
        maxValue = remainder[i];
        maxIdx = i;
      }
    }
    seats[maxIdx]++;
    remainder[maxIdx] = 0;
    currentSeats++;
  }
  return seats.map((val) => `${(val / totalSeats) * 100}%`);
}
const values = [56, 12, 48, 56];
console.log(getPercentWithPrecision(values, 2));

14. Limit Concurrency

Limit the number of concurrent requests when making many requests.

async function asyncPool(poolLimit, iterable, iteratorFn) {
  const ret = [];
  const executing = new Set();
  for (const item of iterable) {
    const p = Promise.resolve().then(() => iteratorFn(item, iterable));
    ret.push(p);
    executing.add(p);
    const clean = () => executing.delete(p);
    p.then(clean).catch(clean);
    if (executing.size >= poolLimit) {
      await Promise.race(executing);
    }
  }
  return Promise.all(ret);
}
const timeout = (i) => new Promise((resolve) => setTimeout(() => resolve(i), i));
asyncPool(2, [1000, 5000, 3000, 2000], timeout).then((results) => {
  console.log(results);
});

15. UUID Generation

Generate unique identifiers with this code.

const uuid = (a) =>
  a
    ? (a ^ ((Math.random() * 16) >> (a / 4))).toString(16)
    : ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, uuid);
console.log(uuid());

16. Open Modal and Prevent Body Scroll

Prevent the body from scrolling when opening a modal.

<button onclick="openModal()">Open Modal</button>
<div id="modal" style="display: none;">Modal Content</div>
<script>
  function openModal() {
    document.body.style.overflow = "hidden";
    document.getElementById("modal").style.display = "block";
  }
  function closeModal() {
    document.body.style.removeProperty("overflow");
    document.getElementById("modal").style.display = "none";
  }
</script>

Original article link: https://en.kelen.cc/posts/16-front-end-code-snippets-worth-checking-out

7 Useful Git Commands You Absolutely Must Know

kelen.cc — Sat, 18 Jan 2025 03:09:32 +0000

Since Git was born in 2005, core commands such as clone, pull, push, merge, checkout, and commit have existed and supported daily development work. With the evolution of version control requirements, Git has been continuously iterated and updated, introducing many enhanced features and new commands. This article will focus on seven recently added Git commands and explore how they further improve work efficiency!

git switch: Safely Switch Branches

The git switch command was introduced in Git version 2.23.0 to address the problem of the git checkout command having too many responsibilities and to make Git commands more intuitive and easier to understand.

Before Git 2.23, git checkout was used both for switching branches and restoring file contents, which was easily confusing. By splitting the functions of git checkout, the Git team created two new, more specialized commands:

git switch: Specifically used for switching between branches.
git restore: Specifically used for restoring file contents.

Using git switch to switch branches is very simple. Here is the basic usage:

# Switch to an existing branch
$ git switch <branch-name>
# Create and switch to a new branch
$ git switch -c <new-branch-name>
# Create and track a local branch from a remote repository
$ git switch -c <new-branch-name> --track <remote>/<branch-name>
# Return to the previous branch
$ git switch -

Note: If you encounter the error message 'switch' is not a git command, it may be because your Git version is lower than 2.23.0. You can check the Git version by running git --version and upgrade to the latest version to use these new features.

git restore: Safely Undo Changes

The git restore command was also introduced in Git version 2.23.0 and is specifically used to restore the contents of files in the working directory.

git restore is mainly used to undo changes in the working directory. It can be used to discard uncommitted working tree modifications, restore deleted files, or reset files to a previous commit state. Here is the basic usage of git restore:

# Restore a file in the working directory to the state of the last commit
$ git restore <file>
# Restore a file from a specified commit to the working directory
$ git restore --source=<commit> <file>
# Unstage changes (similar to git reset HEAD <file>)
$ git restore --staged <file>
# Restore all files to the state of a specified commit
$ git restore --source=<commit>.
# Restore all deleted files
$ git restore -w -- *
# Discard changes in the staging area and the working directory (i.e., restore to the state of a specified commit)
$ git restore --staged --worktree <file>

When using git restore, you can optionally specify --staged to affect the staging area or --worktree to affect the working directory. If both options are specified, both the staging area and the working directory will be affected.

git restore is a relatively safe operation because it does not change the branch history. It only affects the working directory and/or the staging area.

git worktree: Work on Multiple Branches Simultaneously

The git worktree command was introduced in Git version 2.5. It allows you to create multiple working directories (worktrees) in the same repository, and each working directory can check out a different branch or commit. This provides developers with the ability to handle multiple tasks simultaneously, such as developing and testing on different branches without having to switch branches back and forth.

Here is the basic usage of git worktree:

# Add a new working directory and check out a specified branch
$ git worktree add <path> [<branch>]
# List all working directories
$ git worktree list
# Remove a working directory (you must first ensure that there are no uncommitted changes in the directory)
$ git worktree remove <path>
# Move a working directory to a new location
$ git worktree move <current-path> <new-path>

For example, if you want to add a new working directory to check out a branch named feature-branch, you can do the following:

$ git worktree add../my-feature-worktree feature-branch

This will create a new working directory under the ../my-feature-worktree directory and check out the feature-branch branch.

git sparse-checkout: Efficiently Handle Large Repositories

The git sparse-checkout was introduced in Git version 2.25.0. This function is a significant improvement over the previously existing sparse checkout mechanism. With git sparse-checkout, developers can more efficiently clone large repositories by checking out only some files or directories instead of the entire project.

To enable sparse-checkout, you first need to set the repository to use the sparse checkout mode:

# Enable sparse-checkout mode
$ git sparse-checkout init
# Set the patterns or paths you want to include
$ git sparse-checkout set <pattern>...

For example, if you only want to check out the files in the src directory and its subdirectories, you can do the following:

$ git sparse-checkout set src/

If you want to add multiple patterns or paths, you can list all the paths after the set command or call the command multiple times.

In addition to the set command, you can also use add and list to manage the sparse checkout mode:

# Add additional paths to the sparse checkout mode
$ git sparse-checkout add <pattern>...
# List the existing sparse checkout patterns
$ git sparse-checkout list

If you no longer need the sparse checkout mode, you can disable it and restore the full checkout state by using the following command:

# Disable sparse-checkout mode and restore full checkout
$ git sparse-checkout disable

If you want to keep reading, quickly click on the link and check it out!

https://en.kelen.cc/posts/7-useful-git-commands-you-absolutely-must-know#git sparse-checkout: Efficiently Handle Large Repositories

Useful CSS Selectors You Might Not Know

kelen.cc — Mon, 13 Jan 2025 15:06:21 +0000

CSS selectors play a crucial role in web development for styling web pages. While many are familiar with the common selectors, there are several less common but very useful ones.

What Are CSS Selectors?

CSS selectors are patterns that help in selecting elements on a web page for styling. They can target elements based on attributes, classes, IDs, and more.

Common CSS Selectors

Here are some commonly used ones:

Element Selector: Targets all elements of a specific type. For example, to style all <div> elements:

  div {
    border: 1px solid black;
  }

Class Selector: Selects elements with a particular class. If we have a class "text - large":

  .text - large {
    font-size: 20px;
  }

ID Selector: Targets an element with a specific ID. For an element with ID "header":

  #header {
    background-color: blue;
  }

Attribute Selector: Used for elements with specific attribute values. For example, to style all links that are external (using the "rel" attribute):

  a[rel="external"] {
    color: red;
  }

Less Common but Useful CSS Selectors

Child Selector(>)

It targets direct children of an element. For a parent element with class "container":

.container > p {
  margin-left: 10px;
}

Descendant Selector( )

This selects all descendants within an element. If we have a div with ID "main" and want to style all <span> elements inside it:

#main span {
  color: green;
}

Adjacent Sibling Selector(+)

Selects an element that immediately follows another specific element. For example, after an <h3> element, if there's a <p> element:

h3 + p {
  font-weight: bold;
}

General Sibling Selector(~)

Targets elements that are siblings of another element, not necessarily adjacent. If we have a div with class "item" and want to style all following siblings with class "detail":

.item ~ .detail {
  padding-top: 5px;
}

Attribute Selector with Partial Match(^=, $=, *=)

Starts with (^=): To style all images with sources starting with "https://example.com/images/":

  img[src^="https://example.com/images/"]
  {
    border-radius: 5px;
  }

Ends with ($=): For all forms with a method ending with "post":

  form[method$="post"] {
    background-color: #f0f0f0;
  }

Contains (*=): To style all links containing "product" in the href attribute:

  a[href*="product"] {
    text-decoration: underline;
  }

Negation Pseudo - Class(:not())

It selects elements that do not match a certain selector. For example, all elements except those with class "hidden":

:not(.hidden) {
  display: block;
}

Target Pseudo - Class(:target)

When the URL fragment matches an element's ID. For a section with ID "contact" in the URL:

#contact:target {
  background-color: yellow;
}

Language Pseudo - Class(:lang())

Targets elements based on language attributes. For elements with lang="en-US":

:lang(en-US) {
  font-family: Arial, sans - serif;
}

Has Pseudo - Class(:has())

The :has() pseudo - class is used to select elements that contain a specific child or descendant. For example, to style a div that contains an image:

div:has(> img) {
  padding: 10px;
}

Selection Pseudo - Class(::selection)

This pseudo - class allows you to style the part of the text that the user has selected. For example, when a user selects some text within a paragraph:

p::selection {
  background - color: purple;
  color: white;
}

Conclusion

These less common CSS selectors offer additional ways to target and style elements precisely. They can enhance the flexibility and functionality of our CSS code, making it more powerful and efficient in creating visually appealing and well structured web pages.

More information can be found at https://en.kelen.cc/

Common Array Operations in JavaScript

kelen.cc — Tue, 08 Feb 2022 03:47:42 +0000

Array is one of the most common data structures in JavaScript. I will briefly record and summarize some of its operations here.

This paper mainly includes:

Create an array
Check if it's an array
Array-like object and transform it to array
Remove duplicate elements

Create an array

Creating an array is a basic skill, which includes the following methods:

const arr = [1, 2, 3];
const arr2 = new Array(3); // [,,]
const arr3 = new Array(2, 3); // [2, 3]
const arr4 = Array.of(2, 3); // [2, 3]

The one we usually use the most is array literals.

Check if it's an array

The main way to tell if it's an array is:

// one
Array.isArray(arr);
// two
arr instanceof Array;
// three
Object.prototype.toString.call(arr) === "[object Array]";
// four
arr.constructor === Array;

The first one is the most common way.

Array-like object and transform it to array

We sometimes encounter arrays that are not real arrays, it is called array-like object. but we can transform it to array. eg: arguments or HTMLCollection.

const eles = document.querySelectorAll("a"); // HTMLCollection
// one
Array.prototype.slice.call(eles);
// two
Array.from(eles);
// three
[...eles];
// four
function toArray(arrayLike) {
  let res = [];
  for (item of arrayLike) {
    res.push(item);
  }
  return res;
}
// five
Array.apply(null, eles);
// six
[].concat.apply([], eles);

Remove duplicate elements

Array de-duplication essentially requires that two elements are compared for equality, and if they are, an element is discarded. For accurate judgment, we use Object.is for comparison.

Set

The Set object lets you store unique values of any type, whether primitive values or object references.

function unique(arr){
  return Array.from(new Set(arr)); // or [...new Set(arr)];
}

reduce with includes

reduce : executes a reducer function for array element, and returns the final accumulated value.
includes : returns true if the value is present in the array.

function unique(arr){
  return arr.reduce((acc, cur) => {
    if (!acc.includes(cur)) {
      acc.push(cur);
    }
    return acc;
  }, []);
}

for loop with Map

Map : The Map object holds key-value pairs and remembers the original insertion order of the keys. Any value (both objects and primitive values) may be used as either a key or a value.

function unique(arr) {
  const map = new Map();
  const ret = [];
  for (let i = 0; i < arr.length; i++) {
    if (!map.has(arr[i])) {
      map.set(arr[i], true);
      ret.push(arr[i]);
    }
  }
  return ret;
}

filter with indexOf

indexOf : returns the first index at which a given element can be found in the array, or -1 if it is not present.

function unique(arr) {
  return arr.filter((item, index) => arr.indexOf(item) === index);
}

The original link: https://en.kelen.cc