2023-10-21T08:00:00-04:00https://ximage.c-spanvideo.org ...

The Church in Colonial California

Tata Safari Pure Plus AT Prices: The price of the Tata Safari Pure Plus AT in New Delhi is Rs 20.69 Lakh (Ex-showroom). To know more about the Safari Pure Plus AT Images, Reviews, Offers & other ...

Tata Safari Pure Plus AT

Tata Safari Pure Plus S Dark Prices: The price of the Tata Safari Pure Plus S Dark in New Delhi is Rs 20.69 Lakh (Ex-showroom). To know more about the Safari Pure Plus S Dark Images, Reviews ...

Tata Safari Pure Plus S Dark

2023-10-17T12:00:55-04:00https://ximage.c-spanvideo.org ...

House Session, Part 1

Tata Harrier Pure Plus Prices: The price of the Tata Harrier Pure Plus in New Delhi is Rs 18.69 Lakh (Ex-showroom). To know more about the Harrier Pure Plus Images, Reviews, Offers & other details ...

Tata Harrier Pure Plus

All products featured on SELF are independently selected by our editors. However, when you buy something through our retail links, we may earn an affiliate commission. When you think of vitamin C ...

These Are the Biggest Vitamin C Benefits for Your Skin

Pure Excellence Training Academy is making big moves — including the one to its new location. The one-year-old business is owned by Keshia Neal who also owns and operates CPRwithJOY and Chara ...

Pure Excellence Training Academy gets new home, set to offer new classes by 2024

Could it be the revised packaging of the current, 2019-vintage model, where Mazda arguably sacrificed some practicality on the altar of style? Then there’s some tough competition from within ...

2024 Mazda 3 G20 Pure review

More than 90,000 dermatologists recommend the wrinkle-reducing serum. Michelle Tchea is a 5-time award-winning and bestselling author focused on travel, wellness, and luxury hospitality. A ...

This French Anti-aging Beauty Secret That Derms Love Has Become a Mainstay in My Routine — and It's Under $50

President Biden on Friday said the terrorist group Hamas, which brutally attacked Israel last weekend, is worse than al Qaeda, the organization behind the Sept. 11 ...

Biden says Hamas makes ‘al Qaeda look pure’

PuREC

purec

EDIT: I no longer stand by the sentiment of this post, but the technical concerns that cause PureComponent to frequently fail to prevent renders are still worth understanding. Wasted renders are a big problem in performant React.js code. The React core team came up with a solution: React.PureComponent. Let’s look at how it works, what problems it solves, and what problems it doesn’t solve. So, what is it? PureComponent is exactly like React.Component with one difference: it implements shouldComponentUpdate. This allows it to prevent renders based on some heuristic. PureComponent implements this as a shallow equality check on the new props vs the old props, and likewise for state. So if you have the props ‘a’ and ‘b’, it essentially does the following: This is great in theory because we can prevent expensive renders, drastically improving our performance. But, wait! “This is too good to be true”, I hear you saying. Well… you’re right. We run into issues from these !== checks. Let’s say Foo is a component extending from React.PureComponent. Here are some example uses of Foo: These three examples share the same problem: Foo will always rerender because the shouldComponentUpdate always returns true! In the first two, the shouldComponentUpdate checks if this.props.x !== nextProps.x, and since {} !== {}, and likewise for the .map, it will always see the props as having changed. The same thing happens with the children prop, where this.props.children !== nextProps.children. The minor issue here is that we’re doing the shouldComponentUpdate check with no gain, which is more expensive than the example I gave above because it has to iterate over the keys of both the current and next props objects. The larger issue is that we assume we’ve solved a performance problem, while only making it slightly worse most of the time. Hmm… so how do we prevent needless renders and diffing? A trick! Enter: . react-update-if-changed In this example, Foo is using react-update-if-changed instead of PureComponent. Instead of it checking if this.props.children !== nextProps.children, it just checks the updateIfChanged prop for equality. One equality check; that’s it. There are two remaining problems. We might have multiple values that can change, or one value that should be compared by deep equality. You can use the updateIfChangedEqual={[a, b]} prop in this situation. We still have to compute the <h1> in the above example (but not diff it), which might actually be expensive to compute. See the component in react-update-if-changed which addresses this. UpdateIfChanged React.PureComponent is rarely useful, but don’t give up hope on great performance in React.js! is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising & sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

React.PureComponent Considered Harmful

Memoization in React: Powerful Tool or Hidden Pitfall?

প্রতিক্রিয়ায় স্মৃতিচারণ: শক্তিশালী হাতিয়ার বা লুকানো পিটফল?

Memoisierung in React: Leistungsstarkes Tool oder versteckte Falle?

Memoización en React: ¿herramienta poderosa o trampa oculta?

Mémorisation dans React : outil puissant ou piège caché ?

रिएक्ट में मेमोइज़ेशन: शक्तिशाली टूल या छिपा हुआ नुकसान?

React でのメモ化: 強力なツールか隠れた落とし穴か?

React의 메모화: 강력한 도구인가 아니면 숨겨진 함정인가?

Memoização no React: ferramenta poderosa ou armadilha oculta?

Мемоизация в React: мощный инструмент или скрытая ловушка?

React'te Notlandırma: Güçlü Araç mı, Yoksa Gizli Tuzak mı?

Ghi nhớ trong React: Công cụ mạnh mẽ hay cạm bẫy tiềm ẩn?

React 中的记忆化：强大的工具还是隐藏的陷阱？

My team recently discovered , the widely popular graphics library – (with a high NVD severity ). These vulnerabilities cause a denial-of-service and remote code execution. X11’s latest versions contain fixes for these vulnerabilities. two security vulnerabilities in X.Org libX11 CVE-2023-43786 and CVE-2023-43787 CVSS 7.8 The team constantly monitors open-source projects to find new vulnerabilities and malicious packages and shares them with the wider community to help improve their overall security posture. This 2-part blog series provides details of the inner workings of the vulnerable Xpm file format and deep-dives into exploiting these vulnerabilities. What is libX11? Xorg X11, often referred to as X Window System, is an graphical server protocol that enables the creation and management of graphical user interfaces in Unix-like operating systems. It provides a framework for running graphical applications, managing Windows, and handling user input in a networked environment. open-source The libx11 package offers the essential shared libraries that client applications require to render and present data on your desktop. What is libXpm? libXpm provides functions to read, write, and display images in the (XPM) format. X Pixmap XPM primarily aims to generate icon pixmaps with support for transparent pixels. It is based on the XBM syntax, and it can be either a plain text file in the XPM2 format or utilize a C programming language syntax, making it suitable for inclusion within a C program file. XPM image format – versions Predecessor – XBM Before XPM (X PixMap) came to be in 1989, there was the XBM format (X BitMap). A plain-text binary image format, used for storing icon and cursor bitmaps that were used in the X GUI. XBM files are structured as C source files. This is their main distinction from most image formats around today. That way, they can be incorporated into applications directly. However, due to this and the fact no compression can be employed (1 character to 1-byte mapping), they are also far larger than their raw pixel data. X BitMap (XBM) data comprises a sequence of static unsigned char arrays that store the raw monochrome pixel information. For example, the following C code is the XBM file for in the image: hello #define hello_width 35
#define hello_height 25
static char hello_bits[] = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 
  0x00, 0x88, 0x00, 0x00, 0x10, 0x00, 0x88, 0x00, 0x00, 0x10, 0x00, 0x88, 
  0x00, 0x00, 0xD0, 0xE1, 0x88, 0x78, 0x00, 0x30, 0x13, 0x89, 0xC4, 0x00, 
  0x10, 0x12, 0x89, 0x84, 0x00, 0x10, 0xF2, 0x89, 0x84, 0x00, 0x10, 0x12, 
  0x88, 0x84, 0x00, 0x10, 0x12, 0x88, 0x44, 0x00, 0x10, 0xE2, 0x89, 0x38, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00
}; Instead of the usual image file-format headers, XBM files have statements. The first pair of values defines the pixel dimensions of the bitmap, indicating its height and width. #define X BitMap (XBM) image data is structured as a continuous sequence of pixel values, which are stored within a static array. Given that each pixel is symbolized by a single bit (with 0 indicating white and 1 representing black), each byte in the array encompasses the data for eight individual pixels. Notably, the first byte’s least significant bit serves as the anchor for the upper-left pixel within the bitmap. XPM1 Meet XPM version 1. First released in 1989, it shares a lot of similarities with the XBM format outlined above. While XBM was monochrome, XPM1 introduced colors to the images. It uses additional macros and variables for colors and replaces bytes with characters for pixel data. For example, here is the same black-and-white picture in the XPM1 format: hello /* XPM */
static char *_hello[] = {
/* columns rows colors chars-per-pixel */
"35 25 2 1 ",
"  c white",
"b c black",
/* pixels */
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"    b              b   b           ",
"    b              b   b           ",
"    b              b   b           ",
"    b bbb    bbb   b   b   bbbb    ",
"    bb  bb  b   b  b   b  b   bb   ",
"    b    b  b   b  b   b  b    b   ",
"    b    b  bbbbb  b   b  b    b   ",
"    b    b  b      b   b  b    b   ",
"    b    b  b      b   b  b   b    ",
"    b    b   bbbb  b   b   bbb     ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   "
}; here denotes the number of colors in the image, and denotes the number of characters per pixel. XFACE_ncolors XFACE_chars_per_pixel Each will be replaced by the white color “#ffffff”, and each will be replaced by the black color “#000000”. a b XPM2 A year later, in 1990, the second version of the format was set to improve things. It simplified things and removed all C code from the image format. The simplified structure: ! XPM2
<Header>
<Colors>
<Pixels> The header line denotes the image dimensions similar to XPM1’s #define statements. The colors section defines the character values. A new type concept was introduced: – is for color pixel c – is for monochrome m – is for grayscale g – is for symbolic s The symbolic feature is used to assign colors by context, and to create variable names for them for easier reading. Example of an XPM2 image, with the same as shown in the previous examples: hello ! XPM2
35 25 2 1
a c #000000
b c #ffffff
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaabaaaaaaaaaaaaaabaaabaaaaaaaaaaa
aaaabaaaaaaaaaaaaaabaaabaaaaaaaaaaa
aaaabaaaaaaaaaaaaaabaaabaaaaaaaaaaa
aaaababbbaaaabbbaaabaaabaaabbbbaaaa
aaaabbaabbaabaaabaabaaabaabaaabbaaa
aaaabaaaabaabaaabaabaaabaabaaaabaaa
aaaabaaaabaabbbbbaabaaabaabaaaabaaa
aaaabaaaabaabaaaaaabaaabaabaaaabaaa
aaaabaaaabaabaaaaaabaaabaabaaabaaaa
aaaabaaaabaaabbbbaabaaabaaabbbaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Apart from hexadecimal color codes, the colors can also be specified using any of the X11 color names (e.g. ), with indicating transparency. red None XPM3 This is the current version of the XPM format. The version, released in 1991, brought back the C code, but instead of using a pure C code style, the values inside are essentially the same as in the XPM2 format. Example: /* XPM */
static char *_hello[] = {
/* columns rows colors chars-per-pixel */
"35 25 2 1 ",
"  c white",
"b c black",
/* pixels */
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"    b              b   b           ",
"    b              b   b           ",
"    b              b   b           ",
"    b bbb    bbb   b   b   bbbb    ",
"    bb  bb  b   b  b   b  b   bb   ",
"    b    b  b   b  b   b  b    b   ",
"    b    b  bbbbb  b   b  b    b   ",
"    b    b  b      b   b  b    b   ",
"    b    b  b      b   b  b   b    ",
"    b    b   bbbb  b   b   bbb     ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   ",
"                                   "
}; As discussed, the XPM format can also represent more sophisticated images, like the JFrog logo: DoS vulnerability – CVE-2023-43786 The CVE-2023-43786 vulnerability is essentially an endless loop resulting from an incorrect recursion stop condition calculation. Fix commit: https://gitlab.freedesktop.org/xorg/lib/libx11/-/commit/204c3393c4c90a29ed6bef64e43849536e863a86 is a function in libX11 that lets you place images onto an X Drawable, usually an X Window. With this function, one can transfer pixel information from an XImage structure to a designated drawable, like a window or a pixmap, and position it as needed. XPutImage xpmCreatePixmapFromImage The libXpm function calls for this function: xpmCreatePixmapFromImage XPutImage void
xpmCreatePixmapFromImage(
    Display	*display,
    Drawable	 d,
    XImage	*ximage,
    Pixmap	*pixmap_return)
{
    GC gc;
    XGCValues values;

    *pixmap_return = XCreatePixmap(display, d, ximage->width,
				   ximage->height, ximage->depth);
    /* set fg and bg in case we have an XYBitmap */
    values.foreground = 1;
    values.background = 0;
    gc = XCreateGC(display, *pixmap_return,
		   GCForeground | GCBackground, &values);

    XPutImage(display, *pixmap_return, gc, ximage, 0, 0, 0, 0,
	      ximage->width, ximage->height);

    XFreeGC(display, gc);
} In this function, is the source image pixel data to be displayed and is copied to the object (in this case ). ximage X Drawable pixmap_return XPutImage Here is the libX11 function: XPutImage int
XPutImage (
register Display *dpy,
Drawable d,
GC gc,
register XImage *image,
int req_xoffset,
int req_yoffset,
int x,
int y,
unsigned int req_width,
unsigned int req_height){
.....
PutSubImage(dpy, d, gc, &img, 0, 0, x, y,
(unsigned int) width, (unsigned int) height,
dest_bits_per_pixel, dest_scanline_pad);
UnlockDisplay(dpy);
SyncHandle();
Xfree(img.data);
return 0;
}
} LockDisplay(dpy);
FlushGC(dpy, gc);

PutSubImage(dpy, d, gc, image, req_xoffset, req_yoffset, x, y,
	(unsigned int) width, (unsigned int) height,
	dest_bits_per_pixel, dest_scanline_pad);.........
} It calls to the function: PutSubImage static void
PutSubImage (
    register Display *dpy,
    Drawable d,
    GC gc,
    register XImage *image,
    int req_xoffset,
    int req_yoffset,
    int x, int y,
    unsigned int req_width,
    unsigned int req_height,
    int dest_bits_per_pixel,
    int dest_scanline_pad)
{
    int left_pad, BytesPerRow, Available;

    if ((req_width == 0) || (req_height == 0))
	return;

    Available = ((65536 < dpy->max_request_size) ? (65536 << 2)
                        : (dpy->max_request_size << 2)) - SIZEOF(xPutImageReq);
    if ((image->bits_per_pixel == 1) || (image->format != ZPixmap)) {               [1]
        left_pad = (image->xoffset + req_xoffset) & (dpy->bitmap_unit - 1);
        BytesPerRow = (ROUNDUP((long)req_width + left_pad,
                                dpy->bitmap_pad) >> 3) * image->depth;
    } else {                                                                        [2]
        left_pad = 0;
        BytesPerRow = ROUNDUP((long)req_width * dest_bits_per_pixel,                [3]
                                dest_scanline_pad) >> 3;
    }

    if ((BytesPerRow * req_height) <= Available) {                                  [4]
        PutImageRequest(dpy, d, gc, image, req_xoffset, req_yoffset, x, y,
                        req_width, req_height,
                        dest_bits_per_pixel, dest_scanline_pad);
    } else if (req_height > 1) {
        int SubImageHeight = Available / BytesPerRow;

        if (SubImageHeight == 0)
            SubImageHeight = 1;

        PutSubImage(dpy, d, gc, image, req_xoffset, req_yoffset, x, y,
                    req_width, (unsigned int) SubImageHeight,
                    dest_bits_per_pixel, dest_scanline_pad);

        PutSubImage(dpy, d, gc, image, req_xoffset,
                    req_yoffset + SubImageHeight, x, y + SubImageHeight,
                    req_width, req_height - SubImageHeight,
                    dest_bits_per_pixel, dest_scanline_pad);
    } else {                                                                        [5]
        int SubImageWidth = (((Available << 3) / dest_scanline_pad)                 [6]
                                * dest_scanline_pad) - left_pad;

        PutSubImage(dpy, d, gc, image, req_xoffset, req_yoffset, x, y,
                    (unsigned int) SubImageWidth, 1,
                    dest_bits_per_pixel, dest_scanline_pad);

        PutSubImage(dpy, d, gc, image, req_xoffset + SubImageWidth,
                    req_yoffset, x + SubImageWidth, y,
                    req_width - SubImageWidth, 1,
                    dest_bits_per_pixel, dest_scanline_pad);
    }
} Technical Vulnerability Details Let’s take the following example image: Available [the requested size] = (65,536 * 4) - 28 = 262,116
bits_per_pixel = 32
width = 90,000 pixels
height = 1 pixel Since the image is 32, the conditional statement at [1] will not pass, leading us to enter the alternative code block defined in [2]. bits_per_pixel It then calculates the on [3] then divides it by 8. In our example: BytesPerRow  = 90000 * 32 / 8 = 360,000 BytesPerRow In the example, the check on [4] would not pass, as 360000 is not less than the requested size 262116, and is not able to fit a single line of the requested width into a single request – this initiates the on [5]. else This determines the number of pixels that can be included in a single request. It then initiates a recursive call to the function to pass just that subset, followed by a subsequent recursive call to manage the remaining portion of the line. If needed, this remaining part may also be divided further through additional recursive calls. PutSubImage However, the calculation on [6] fails to take into account the bits per pixel, and the recursive call makes requests sending 2096928 pixels instead of 2096928 bits – which is larger than can be fit in a single request. This leads to , consistently resulting in a number too large to fit and trying again the process to retry with the same values. This recursion persists until the call stack is exhausted. an endless loop of attempting to split the line of pixels The changed the calculation on [6] and took into account the . In the example, it would result in a recursive call requesting to send just 65529 pixels, resulting in a BytesPerRow of 262116 that perfectly fits inside the available space, thus allowing the recursion to make forward progress and finish in just 2 calls. bug fix bits_per_pixel Example proof-of-concept image to trigger the bug: https://github.com/jfrog/jfrog-CVE-2023-43786-libX11_DoS/blob/main/cve-2023-43786.xpm How the bug can be triggered An example of an app that calls the vulnerable libXpm library function is the CLI utility , which is used to display Xpm images on the screen. sxpm It calls the vulnerable Xpm function, which then calls the vulnerable libX11 functions then . xpmCreatePixmapFromImage XPutImage PutSubImage Also published here. Read the second part of this article here: Uncovering and Exploiting a 35-Year-Old Vulnerability, *nix libX11: Part 2

Uncovering and Exploiting a 35-Year-Old Vulnerability, *nix libX11: Part 1

nix libX11-এ একটি 35-বছর-পুরোনো দুর্বলতা উন্মোচন করা: পার্ট 1

Enthüllung einer 35 Jahre alten Sicherheitslücke in nix libX11: Teil 1

Revelando una vulnerabilidad de 35 años en nix libX11: Parte 1

Dévoilement d'une vulnérabilité vieille de 35 ans dans nix libX11 : partie 1

निक्स लिबएक्स11 में 35 साल पुरानी भेद्यता का अनावरण: भाग 1

nix libX11 の 35 年前の脆弱性を明らかにする: パート 1

nix libX11의 35년 된 취약점 공개: 1부

Revelando uma vulnerabilidade de 35 anos no nix libX11: Parte 1

Раскрытие 35-летней уязвимости в nix libX11: часть 1

Nix libX11'de 35 Yıllık Bir Güvenlik Açığı Ortaya Çıkarılıyor: Bölüm 1

Hé lộ lỗ hổng 35 năm tuổi trong nix libX11: Phần 1

揭露 nix libX11 中已有 35 年历史的漏洞：第 1 部分

Yeah, I said it! Callbacks are faster when running them parallel over async/await in parallel. And only faster when we run sequential callbacks. 4.8x 1.9x I've modified this article somewhat after I got some helpful and kind comments about my dodgy test. 😂🙏 Thank you to and for taking the time to steer the benchmarks in the right direction. My first faux pas was I wasn't actually waiting for the execution of the code to finish, which crazily skewed the results. The second was I was comparing parallel to sequential runtimes, which make the benchmarks worthless. Ricardo Lopes Ryan Poe So this is round 2 which addresses my initial errors. Previously, I said: Originally, I wrote, that NodeJS is 34.7x faster if we go back to callbacks! 🤣 Wrong. Not as impressive as my bad benchmarks before (and see comments for context), but still a sizeable difference. So what exactly did I test? I compared callbacks to promises and async/await when reading a file, 10,000 times. And maybe that's a silly test but I wanted to know, which is faster at I/O. Then I finally compared callbacks in Node.js to Go! Now, guess who won? I won't be mean. . Golang! TLDR Lower is better. Results are in . ms Now, true benchmarkers? Go easy on me on this one. But please do leave your comments to make me a better person. Everyone keeps saying that Node.js is slow! And it bugs me out. Because what does slow mean? As with all benchmarks, mine is contextual. I started reading about the , just to even begin to understand . Event Loop how it works But the main thing I've understood is that Node.js passes I/O tasks onto a queue that sits outside the main Node.js executable thread. This queue runs on . A number of threads could potentially handle these I/O operations. And that's where Node.js can shine, handling I/O. pure C Promises, however, get handled in the main, single executable thread. And async/await, is well, promises but now with blocking added. So are callbacks faster than promises? Let's put it to the test. First off. My ! Complements of working with . It's important to note what resources we're working with. Plenty memory and CPU. machine Kamma MacBook Pro (14-inch, 2021)
Chip      Apple M1 Pro
Memory    32 GB
Cores     10
NodeJS    v20.8.1 So we have a file with an message, . text.txt original Hello, world echo "Hello, world" > text.txt And we'll read this text file using native Node.js, which means, zero node module dependencies because we don't want to drag the speed down with the heaviest objects in the universe. Callbacks Parallel callbacks First, let's start with callbacks. I'm interested in how quickly the same file can be read as quickly as possible, all at once. And what's faster than parallel? parallel // > file-callback-parallel.test.mjs
import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs";

test('reading file 10,000 times with callback parallel', (t, done) => {
    let count = 0;
    for (let i = 0; i < 10000; i++) {
        fs.readFile("./text.txt", { encoding: 'utf-8'}, (err, data) => {
            assert.strictEqual(data, "Hello, world");
            count++
            if (count === 10000) {
                done()
            }
        })
    }
}); Sequential callbacks Second, we have callbacks again, but sequential (or rather blocking). I'm interested in how quickly the same file can be read sequentially. Having not done callbacks calling callbacks for ages, this was fun to try again. Albeit, it doesn't look pretty. // > file-callback-blocking.test.mjs
import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs";

let read = (i, callback) => {
    fs.readFile("./text.txt", { encoding: 'utf-8'}, (err, data) => {
        assert.strictEqual(data, "Hello, world");

        i += 1

        if (i === 10000) {
            return callback()
        }

        read(i, callback)
    })
}

test('reading file 10,000 times with callback blocking', (t, done) => {
    read(0, done)
}); Async/Await Then we have async/await. My favourite way of working with Nodejs. Parallel async/await It's as parallel as I can get with async/await. I load all the operations into an array and await them all using . readFile Promise.all // > file-async-parallel.test.mjs
import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs/promises";

test('reading file 10,000 times with async parallel', async (t) => {
    let allFiles = []
    for (let i = 0; i < 10000; i++) {
        allFiles.push(fs.readFile("./text.txt", { encoding: 'utf-8'}))
    }

    return await Promise.all(allFiles)
        .then(allFiles => {
            return allFiles.forEach((data) => {
                assert.strictEqual(data, "Hello, world");
            })
        })
}); Sequential Async/Await This was the easiest and most concise one to write. // > file-async-blocking.test.mjs

import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs/promises";

test('reading file 10,000 times with async blocking', async (t) => {
    for (let i = 0; i < 10000; i++) {
        let data = await fs.readFile("./text.txt", { encoding: 'utf-8'})
        assert.strictEqual(data, "Hello, world");
    }
}); Promises Finally, we have promises without async/await. I've long stopped using them in favour of but I was interested in whether they were performant or not. async/await Parallel promises // > file-promise-parallel.test.mjs
import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs/promises";

test('reading file 10,000 times with promise parallel', (t, done) => {
    let allFiles = []

    for (let i = 0; i < 10000; i++) {
        allFiles.push(fs.readFile("./text.txt", { encoding: 'utf-8'}))   
    }

    Promise.all(allFiles)
        .then(allFiles => {
            for (let i = 0; i < 10000; i++) {
                assert.strictEqual(allFiles[i], "Hello, world");
            }

            done()
        })
}); Sequential promises. Again, we want to wait for the execution of all operations. readFile // > file-promise-blocking.test.mjs
import test from 'node:test';
import assert from 'node:assert';
import fs from "node:fs/promises";

test('reading file 10,000 times with promises blocking', (t, done) => {
    let count = 0;
    for (let i = 0; i < 10000; i++) {
        let data = fs.readFile("./text.txt", { encoding: 'utf-8'})
            .then(data => {
                assert.strictEqual(data, "Hello, world")
                count++
                if (count === 10000) {
                    done()
                }
            })
    }
}); And voila! Results 🎉! I even ran it a few times to get a better reading. I ran each test by doing: node --test <file>.mjs It's also 4.7x faster than with promises in parallel! Reading a file 10,000 times with callbacks is over 5.8x faster than with async/await in parallel! So, in Node.js land, callbacks more performant! are Now is Go faster than Node.js? Well, I don't write in Go, so this may be truly terrible code because I asked ChatGPT to help me and yet, it pretty decent. seems Hey ho. Let's go. Our Golang code. package main

import (
    "fmt"
    "io/ioutil"
    "time"
)

func main() {
    startTime := time.Now()

    for i := 0; i < 10000; i++ {
        data, err := ioutil.ReadFile("./text.txt")
        if err != nil {
            fmt.Printf("Error reading file: %v\n", err)
            return
        }
        if string(data) != "Hello, world" {
            fmt.Println("File content mismatch: got", string(data), ", want Hello, world")
            return
        }
    }

    duration := time.Since(startTime)
    fmt.Printf("Test execution time: %v\n", duration)
} And we run it as so: go run main.go And the results? Test execution time: 58.877125ms 🤯 Go is 4.9x faster than Node.js using sequential callbacks. Node.js only comes close with parallel execution. Node.js Async/await is 9.2x slower than Go. So yes. Node.js is slower. Still, 10,000 files in sub 300ms isn't to be scoffed at. But I've been humbled by Go's speediness! Now just a side note. Do I have bad benchmarks? I really did have terrible Benchmarks. Thank you again to Ricardo and Ryan. Yes, I did. Hopefully now they're better. But you may ask, who's really going to read the same file, over and over again? But for a relative test between things, I hope it's a helpful comparison. I also don't know how many threads Node.js is using. I don't know how my CPU cores affect Go vs Node.js performance. I could just rent an AWS machine with one core and compare. Is it because I'm on Mac M1? How would Node.js perform on a Linux or...Windows? 😱 And there's the practicality of, yes, reading a file is one thing, but at some point, you have to wait anyway for the file to be read to do something with the data in the file. So, speed on the main thread is still pretty important. Now, do you really want to use callbacks? I mean, do you really, really want to? I don't know. I definitely don't want to tell anyone what to do. But I like the clean syntax of async/awaits. They look better. They read better. I know better is subjective here but I remember callback-hell, and I was grateful when promises came into existence. It made Javascript bearable. Now, Golang is clearly faster than Node.js at its optimum, with callbacks, and with async/await, by 9.2x! So if we want good readability and performance, Golang is the winner. Although, I'd love to learn how Golang looks under the hood. Anywho. This was fun. It was more of an exercise to help me understand how callbacks and I/O work in the Event Loop. So to sign out Is Node.js slow? Or are we just using Node.js on slow mode? Probably where performance matters, Golang is worth the jump. I'll certainly be looking more at using Golang in future. Also appears . here

NodeJS: 4.8x Faster if You go Back to Callbacks!

নোডজেএস: আপনি কলব্যাকে ফিরে গেলে 4.8x দ্রুত!

NodeJS: 4,8x schneller, wenn Sie zu Rückrufen zurückkehren!

NodeJS: ¡4,8 veces más rápido si vuelves a las devoluciones de llamada!

NodeJS : 4,8 fois plus rapide si vous revenez aux rappels !

NodeJS: यदि आप कॉलबैक पर वापस जाते हैं तो 4.8 गुना तेज़!

NodeJS: コールバックに戻すと 4.8 倍高速になります!

NodeJS: 콜백으로 돌아가면 4.8배 더 빨라집니다!

NodeJS: 4,8x mais rápido se você voltar aos retornos de chamada!

NodeJS: в 4,8 раза быстрее, если вы вернетесь к обратным вызовам!

NodeJS: Geri Aramalara Geri Dönerseniz 4,8 Kat Daha Hızlı!

NodeJS: Nhanh hơn 4,8 lần nếu bạn quay lại Cuộc gọi lại!

NodeJS：如果您返回回调，速度会快 4.8 倍！

React Native has revolutionized mobile app development, providing a robust framework for building cross-platform applications with a single codebase. While many developers are familiar with the basics, there are several lesser-known tricks and advanced techniques that can significantly enhance your programming skills. In this article, we will delve into some cool and often overlooked features of React Native, showcasing how these hidden gems can elevate your development workflow. React Native Dynamic Styling with Platform-Specific Extensions One of React Native’s strengths is its ability to run on both iOS and Android seamlessly. However, sometimes, you need to apply styles specific to each platform. Instead of creating separate components for iOS and Android, you can use platform-specific extensions in your styles. const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    // Common styles for both platforms
  },
  text: {
    fontSize: 16,
    // Common text style
    ...Platform.select({
      ios: {
        color: 'blue', // Style for iOS
      },
      android: {
        color: 'green', // Style for Android
      },
    }),
  },
}); Optimizing FlatLists with PureComponent When working with large datasets in a , rendering performance becomes crucial. Using can significantly boost performance by preventing unnecessary renders. FlatList PureComponent import React, { PureComponent } from 'react';
import { FlatList, Text } from 'react-native';

class OptimizedFlatList extends PureComponent {
  render() {
    return (
      <FlatList
        data={this.props.data}
        keyExtractor={(item) => item.id.toString()}
        renderItem={({ item }) => <Text>{item.name}</Text>}
      />
    );
  }
} Enhance State Management with Immer Immutability is a key concept in React, and React Native is no exception. Immer simplifies state management by allowing you to write code that appears to be mutable while automatically producing immutable updates. import produce from 'immer';

const initialState = {
  counter: 0,
};

const reducer = (state = initialState, action) =>
  produce(state, (draft) => {
    switch (action.type) {
      case 'INCREMENT':
        draft.counter += 1;
        break;
      case 'DECREMENT':
        draft.counter -= 1;
        break;
    }
  }); Improving Image Loading with FastImage When dealing with images in your mobile app, loading performance is crucial. is a third-party library that provides a faster alternative to the standard component, supporting features like placeholder images and loading indicators. react-native-fast-image Image import FastImage from 'react-native-fast-image';

const MyImageComponent = () => (
  <FastImage
    style={{ width: 200, height: 200 }}
    source={{
      uri: 'https://example.com/image.jpg',
      priority: FastImage.priority.high,
    }}
    resizeMode={FastImage.resizeMode.contain}
  />
); Custom Native Modules for Bridging When the capabilities of React Native’s core modules are insufficient, you can create custom native modules to bridge native code with your seamlessly. This is particularly useful when integrating with device features or third-party libraries. JavaScript code Android Native Module // Example Android native module
@ReactMethod
public void showToast(String message) {
  Toast.makeText(getReactApplicationContext(), message, Toast.LENGTH_SHORT).show();
} iOS Native Module // Example iOS native module
RCT_EXPORT_MODULE(MyCustomModule);

RCT_EXPORT_METHOD(showAlert:(NSString *)message) {
  UIAlertController *alert = [UIAlertController
    alertControllerWithTitle:@"React Native Alert"
    message:message
    preferredStyle:UIAlertControllerStyleAlert];

  UIAlertAction *okAction = [UIAlertAction
    actionWithTitle:@"OK"
    style:UIAlertActionStyleDefault
    handler:nil];

  [alert addAction:okAction];

  UIViewController *rootViewController = [UIApplication sharedApplication].delegate.window.rootViewController;
  [rootViewController presentViewController:alert animated:YES completion:nil];
} Code Splitting with React Navigation: Improve app performance by using code splitting with , a common navigation library for React Native. This technique loads only the necessary components when they are needed, reducing the initial load time of your app. react-navigation const HomeScreen = React.lazy(() => import('./HomeScreen'));

const AppNavigator = createBottomTabNavigator({
  Home: HomeScreen,
  // other screens...
});

const AppContainer = createAppContainer(AppNavigator);

export default function App() {
  return (
    <React.Suspense fallback={<ActivityIndicator />}>
      <AppContainer />
    </React.Suspense>
  );
} Enhanced Gesture Handling with Gesture Handler is a powerful library that provides a set of components for handling gestures in your mobile app. This library can significantly enhance touch interactions, making your app more responsive and user-friendly. react-native-gesture-handler import { GestureHandlerRootView, PanGestureHandler } from 'react-native-gesture-handler';

export default function MyComponent() {
  return (
    <GestureHandlerRootView>
      <PanGestureHandler
        onGestureEvent={(event) => console.log(event)}
      >
        <View style={{ width: 100, height: 100, backgroundColor: 'blue' }} />
      </PanGestureHandler>
    </GestureHandlerRootView>
  );
} Persistent Data Storage with AsyncStorage React Native provides a simple and efficient way to persist data locally using the module. This is particularly useful for storing user preferences, authentication tokens, or any other data that needs to persist across app restarts. AsyncStorage import { AsyncStorage } from 'react-native';

// Save data to AsyncStorage
AsyncStorage.setItem('userToken', 'abc123');

// Retrieve data from AsyncStorage
AsyncStorage.getItem('userToken').then((value) => {
  console.log(value); // Output: 'abc123'
}); Conclusion In the ever-evolving landscape of , React Native continues to stand out as a versatile and powerful framework. By incorporating these lesser-known tricks and advanced techniques into your development arsenal, you can take your React Native skills to the next level. Whether you’re aiming to optimize performance, improve state management, or enhance user interactions, these hidden marvels will undoubtedly contribute to the success of your mobile applications. So, dive into the world of React Native’s advanced features and unlock the full potential of mobile development. mobile development

Advanced Tricks in React Native Programming for Mobile Development

has become one of the most popular libraries for building user interfaces, thanks to its component-based architecture and efficient rendering mechanism. However, as your React application grows in complexity, it's essential to pay attention to performance optimization. In this article, we will explore best practices for optimizing React applications with practical examples to help you create faster and more responsive web applications. React JavaScript Understanding React Performance Before diving into optimization techniques, let's understand the key concepts related to React performance. Virtual DOM React uses a Virtual DOM (VDOM) to improve performance. It's a lightweight in-memory representation of the actual DOM. When changes occur in your application, React first updates the VDOM and then calculates the most efficient way to update the real DOM. This reduces unnecessary DOM manipulations, resulting in faster rendering. Reconciliation Reconciliation is the process by which React updates the DOM to match the current component tree. React compares the previous VDOM with the new one, identifies the differences, and updates only the parts of the DOM that have changed. Efficient reconciliation is crucial for a performant React application. Best Practices for React Performance Optimization Now, let's explore some best practices to optimize the performance of your React applications. 1. Use React.memo() is a higher-order component that memoizes the rendering of a functional component. It prevents unnecessary re-renders by comparing the current props with the previous ones. Here's an example: React.memo() import React from 'react';

const MemoizedComponent = React.memo(function MyComponent(props) {
  // Component logic
}); 2. Implement PureComponent If you're using class components, consider using instead of . performs a shallow comparison of props and state to determine whether a component should update. PureComponent Component PureComponent import React, { PureComponent } from 'react';

class MyComponent extends PureComponent {
  // Component logic
} 3. Use Key Prop in Lists When rendering lists of components, always provide a unique prop. React uses keys to identify elements efficiently during reconciliation. Incorrect or missing keys can lead to performance issues. key <ul>
  {items.map((item) => (
    <li key={item.id}>{item.name}</li>
  ))}
</ul> 4. Avoid Inline Function Definitions Avoid defining functions within the render method, as it can lead to unnecessary re-renders. Instead, define functions outside the render method or use arrow functions for concise event handlers. class MyComponent extends React.Component {
  handleClick = () => {
    // Handle click
  }

  render() {
    return <button onClick={this.handleClick}>Click me</button>;
  }
} 5. Use Code Splitting Code splitting allows you to split your application into smaller chunks, loading only the code needed for a specific route or feature. This reduces the initial load time and improves performance. import React, { lazy, Suspense } from 'react';

const LazyComponent = lazy(() => import('./LazyComponent'));

function MyComponent() {
  return (
    <Suspense fallback={<div>Loading...</div>}>
      <LazyComponent />
    </Suspense>
  );
} 6. Optimize Expensive Renders with useMemo and useCallback The hook allows you to memoize expensive calculations, while memoizes functions to prevent unnecessary re-creation. Use them when needed to optimize performance-critical components. useMemo useCallback import React, { useMemo, useCallback } from 'react';

function MyComponent({ data }) {
  const expensiveResult = useMemo(() => calculateExpensive(data), [data]);
  const handleClick = useCallback(() => doSomethingWithResult(expensiveResult), [expensiveResult]);

  return (
    <div>
      <button onClick={handleClick}>Click me</button>
    </div>
  );
} FAQ Section Q1: What is the Virtual DOM in React? The is a lightweight in-memory representation of the actual DOM in a web page. React uses it to optimize DOM manipulation by first updating the Virtual DOM and then calculating the most efficient way to update the real DOM. Virtual DOM Q2: Why should I avoid inline function definitions in React? Inline function definitions in the render method can lead to unnecessary re-renders of components. It's better to define functions outside the render method or use arrow functions for event handlers to improve performance. Q3: How does code splitting improve React application performance? Code splitting allows you to load only the code necessary for a specific route or feature, reducing the initial load time of your application. This results in better performance and a smoother user experience. Conclusion Optimizing the performance of your React applications is crucial for delivering a responsive and efficient user experience. By following the best practices discussed in this article and understanding the underlying concepts of React's Virtual DOM and reconciliation, you can create high-performance web applications that delight your users. Remember to continually profile and measure your application's performance to identify bottlenecks and areas for improvement. React's rich ecosystem of tools and libraries, such as React DevTools and performance monitoring solutions, can help you in this process.

Best Practices for React Performance Optimization

Today, optimizing the performance of a React application is crucial to providing users with a smooth and efficient experience. Users expect fast and responsive web applications, and any lag or slowness can result in lost users and business opportunities. When a application is optimized, loading times are significantly reduced, allowing users to quickly access content and start interacting without unnecessary waiting. Additionally, transitions and animations become smoother, creating a more enjoyable and professional user experience. Unexpected errors and crashes are also minimized, providing greater stability and reliability to the application. React In this blog, we will explore 7 of the top practices and techniques to optimize the performance of your React application. 1. Identifying Performance Bottlenecks The first step in optimizing your React application is identifying performance bottlenecks. Use browser development tools like to analyze and measure the application’s performance. Identify components or processes that consume excessive resources or cause unnecessary re-renders. Chrome DevTools 2. Optimizing Rendering Memoization techniques like and help avoid unnecessary re-renders by caching the rendering result. Use React.memo() and PureComponents: React memo PureComponent For more fine-grained control over component updates, use to define specific conditions for when a component should or should not update. Implement shouldComponentUpdate: shouldComponentUpdate 3. Efficient Data Handling Be cautious with state updates triggered by user interactions or data changes. Minimize State Updates: Avoid unnecessary state updates by using functional updates with useState or state management libraries like or for optimized state handling. Zustand Redux The Context API allows efficient data sharing between components without the need for prop drilling. Utilize React’s Context API: Use it appropriately to avoid excessive re-renders caused by unnecessary context updates. 4. Code Splitting and Lazy Loading Split your application into smaller chunks and dynamically import components using and features. Dynamic Imports: React’s lazy Suspense This way, React will only load the necessary components when needed, improving initial loading time. Divide your application code based on routes, loading only the code required for each route, resulting in faster initial page loads. Route-based Code Splitting: 5. Performance Profiling Tools Utilize to identify performance bottlenecks and measure component rendering time. React Profiler: React’s built-in Profiler Integrate performance monitoring libraries like React Performance and to gain insights into your application’s performance and identify areas for improvement. Performance Monitoring Libraries: React DevTools Profiler 6. Memoization and Caching Use memoization techniques like or to cache expensive computations and avoid redundant calculations. Memoize Expensive Computations: memoize-one useMemo Implement client-side caching for API responses using libraries like or (Stale-While-Revalidate) to reduce unnecessary network requests. Client-side API Response Caching: Axios Cache Adapter SWR 7. Code and Bundle Optimization Split your code into smaller modules and eliminate unused code using tools like and to optimize bundle size. Code Splitting and Tree Shaking: Webpack Babel Enable on your server to reduce the data size transmitted, resulting in faster network transfer. Gzip Compression: Gzip compression That’s all for now. While there are many other techniques you can explore to optimize your React applications, the ones we have covered are the most common ones. Conclusion By applying these best practices and techniques, you can significantly enhance the performance of your React application, providing users with a fast, responsive, and enjoyable experience. Read more: Using React Router v6 for Private and Public Routes with Access Validation Enhance Your Photos with the CSS Contrast, Brightness, Saturation, and Sepia Functions Want to connect with the Author? Love connecting with friends all around the world on . Twitter Also published . here

Supercharge Your React Applications: 7 Best Practices and Techniques

PDFs are extensively utilized in business settings, making their security a crucial aspect of numerous workflows. When developing a web application that involves opening PDFs, it’s likely that you will encounter password-protected documents. However, implementing this functionality from scratch can be time-consuming and incur significant maintenance costs, which might not align with your team’s current roadmap. With Foxit’s , presenting PDFs in a browser-based application becomes a seamless task. In this step-by-step tutorial, you will learn how to configure a Node application that harnesses the power of Foxit PDF SDK for Web. This integration allows you to effortlessly open password-protected PDFs directly in the browser, granting authorized users the ability to preview the documents. For those who prefer to skip the tutorial and access a fully functional version of the application, you can find it readily . JavaScript PDF library available on GitHub Building a Web Application to Display Password Protected PDFs HTML provides convenient built-in file upload features that enable users to interact with files from their local machines within the browser. However, displaying PDFs using JavaScript can be a bit more intricate, particularly when dealing with password protection. In this comprehensive tutorial, you will construct a web application comprising a PDF upload form and an optional password field. When a password-protected PDF is uploaded, and the correct password is entered, users will be able to preview the file seamlessly. On the other hand, if an incorrect password is provided, an error message will be displayed, prompting users to retry. To develop this application, you will utilize the web framework for backend development, for styling purposes, and for integrating PDF functionality. Express Pure CSS Foxit’s PDF SDK Prerequisites version 8+ and version 5+ NodeJS NPM Foxit PDF SDK for Web ( ) free trial download is available here Your Foxit license key and serial number Creating a New Express App The Express generator makes it easy to set up a new application. Simply run the following command in your terminal: npx express-generator --git --view=hbs This command will create a new application with a file and template files. .gitignore Handlebars Add the npm package ( use to access your Foxit license key and serial number) and install Express’ dependencies: dotenv npm i dotenv && npm i After you’ve downloaded Foxit PDF SDK for Web, you will find your license key and serial number in the file. Next, create a new file at the root directory of your web application called and add the two values: examples/license-key.js .env LICENSE_SN=""
LICENSE_KEY="" Copy the Foxit library into your web application so you can access it from the front end. Next, copy the directory from Foxit PDF SDK you downloaded and paste it into your web application’s directory. Now the Foxit JavaScript PDF library will be available within your web application. lib/ public/ Lastly, you don’t want sensitive info or proprietary packages to end up in version control, so add the below to your file: .gitignore ...
public/lib/
.env Once your web application has all the necessary dependencies in place, you can proceed to create the route responsible for displaying the PDF preview using Foxit. Setting Up The Route Every page in an Express application has a route, including the PDF upload page you’ll create in this demo. Update the file to pass the license key and serial number to the view: routes/index.js var express = require('express');
var router = express.Router();
router.get('/', function(req, res, next) {
  res.render('index', {
    licenseSN: process.env.LICENSE_SN,
    licenseKey: process.env.LICENSE_KEY,
  });
});
module.exports = router; Allowing you to easily update your credentials on the server, without needing hard-code credentials that require a code change. By adding an authentication layer to your Express application, you can control access to the Foxit credentials and restrict visibility to authorized users. Before the variables are available, you need to include the library which loads variables from your file. Open and add the following to the top of the file: process.env dotenv .env app.js require('dotenv').config();
... Your and are being securely stored and passed to the front end only when required. Next, you will address the display portion of the web application. LICENSE_SN LICENSE_KEY Uploading and Displaying PDFs Foxit’s PDF SDK will handle the majority of the work involved in checking the password and displaying the PDF to the user, but you need to administer the user interface for both file and password inputs. Prior to this, you need to update the layout so it includes base styles and then you can scale the ‘viewport`. This will result in a PDF preview which is correctly sized to the user’s display. Open the file and replace it with the following: views/layout.hbs <!DOCTYPE html> 
<html lang="en"> 
<head> 
  <title>Foxit PDF Previewer</title> 
  <meta charset="UTF-8"> 
  <meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no"/> 
  <link rel="stylesheet" href="https://unpkg.com/purecss@2.0.3/build/pure-min.css" integrity="sha384-cg6SkqEOCV1NbJoCu11+bm0NvBRc8IYLRGXkmNrqUBfTjmMYwNKPWBTIKyw9mHNJ" crossorigin="anonymous"> 
  <link rel='stylesheet' href='/stylesheets/style.css' /> 
</head> 
<body> 
<div class="container"> 
  {{{body}}} 
</div> 
</body> 
</html> This will load the styling library, but you can use any other front end styling framework you’re familiar with. PureCSS Open the file and replace it with the below: views/index.hbs <h1>PDF Previewer</h1> 
<p>Use the form below to preview any password-protected PDF file in this web application.</p> 

 
<form class="pure-form"> 
  <fieldset> 
    <input type="password" id="password" placeholder="Enter PDF Password" /> 
    <input class="original-pdf-upload-button" type="file" name="file" id="file" accept=".pdf,.fdf,.xfdf" multiple="multiple" /> 
    <label class="pure-button new-pdf-upload-button" for="file">Select a PDF file</label> 
  </fieldset> 
</form> 

  
<div id="pdf-viewer"></div> 

  
<script src="/lib/PDFViewCtrl.full.js"></script> 
<script> 
  var PDFViewer = PDFViewCtrl.PDFViewer; 
  var pdfViewer = new PDFViewer({ 
    libPath: '/lib', 
    jr: { 
      licenseSN: "{{ licenseSN }}", 
      licenseKey: "{{ licenseKey }}", 
    }, 
  }); 
  pdfViewer.init('#pdf-viewer'); 
  
  document.getElementById('file').onchange = function (e) { 
    if (!this.value) { 
      return; 
    } 
    var pdf,fdf; 
    for (var i = e.target.files.length; i--;) { 
      var file = e.target.files[i]; 
      var filename = file.name; 
      if (/\.pdf$/i.test(filename)) { 
        pdf = file 
      } else if (/\.(x)?fdf$/i.test(filename)) { 
        fdf = file 
      } 
    } 
    var options = {password: '', fdf: {file: fdf}}; 
    if (document.getElementById('password').value) { 
      options.password = document.getElementById('password').value; 
      document.getElementById('password').value = ''; 
    } 
    pdfViewer.openPDFByFile(pdf, options); 
    this.value = ''; 
  }; 
</script> This file serves three purposes. First, it includes a PDF upload form with a password field. The file upload input element has a , this acts as a nicely styled upload button. Next, the tag wraps the Foxit PDF reader which is used in the function in the custom JavaScript. The last section of this file loads Foxit’s class and initializes it using the code inside the tags. <label> <div id=”pdf-viewer”> pdfViewer.init PDFViewCtrl.PDFViewer <script> The application’s functionality is nearly complete, but before you test, open up file and replace with the following: public/stylesheets/style.css body { 
  background-color: #f7f7f7; 
  color: #333333; 
} 
.container { 
  background-color: #ffffff; 
  margin: 0 auto; 
  padding: 30px; 
} 
/* File upload button styling */ 
.original-pdf-upload-button { 
  width: 0.1px; 
  height: 0.1px; 
  opacity: 0; 
  overflow: hidden; 
  position: absolute; 
  z-index: -1; 
} 
.new-pdf-upload-button { 
  top: -2px; 
  position: relative; 
} Allowing you to style the PDF upload button so it has a consistent look with the other PureCSS buttons, and also adds a bit of padding to your application. To test your application, first save your work and then run from your terminal. Node will spin up a server, and your web app will be available at . npm start localhost:3000 To handle the scenario where a user enters an incorrect password while uploading a password-protected PDF file, you can enhance the existing code to display an error message and allow the user to try again. Here’s how you can implement this functionality: Handling Errors Foxit’s method returns a , if you would like to know when it resolves, add a callback to the or methods. pdfViewer.openPDFByFile promise then catch Within your file, replace the line with the below: views/index.hbs pdfViewer.openPDFByFile… ... 
    pdfViewer.openPDFByFile(pdf, options) 
      .catch(error => { 
        console.error(error); 
        document.getElementById('wrong-password').style.display = 'block'; 
      }); 
... Add a new paragraph element at the top of the file called : id=”wrong-password” <p id="wrong-password" class="error"><strong>Whoops!</strong> 
  It looks like the password you entered was incorrect. 
  Please enter a password and try uploading your file again. 
</p> 
... Lastly, you’ll need to add some styling so the error message is only shown then the method is called. Within your file, add the below: catch public/stylesheets/style.css ... 
#wrong-password { 
  display: none; 
} 
.error { 
  background-color: #f5c0c0; 
  color: #792525; 
  padding: 10px; 
} If you enter an incorrect password (or leave the password field blank) and a password-protected PDF has been uploaded, you will see an error message, as you can see below: In this tutorial, you have learned how to build a secure Node web application that enables users to preview password-protected PDFs in their browser. By leveraging Foxit PDF SDK, you can significantly reduce development time and effort. Foxit PDF SDK offers extensive and a wide range of examples to assist you in building various applications. documentation It’s worth noting that Foxit provides PDF SDKs not only for web applications but also for . This means you can utilize the power of Foxit PDF SDK across different environments, ensuring consistent and reliable PDF processing capabilities throughout your applications. other platforms such as mobile and native apps Also published . here

Stories, News & Mentions about PUREC

Purec’s Stories on HackerNoon

Purec's News & Mentions