Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Clean Code in JavaScript

By : Padolsey

4.1 (7)

Clean Code in JavaScript

4.1 (7)

By: Padolsey

Overview of this book

Building robust apps starts with creating clean code. In this book, you’ll explore techniques for doing this by learning everything from the basics of JavaScript through to the practices of clean code. You’ll write functional, intuitive, and maintainable code while also understanding how your code affects the end user and the wider community. The book starts with popular clean-coding principles such as SOLID, and the Law of Demeter (LoD), along with highlighting the enemies of writing clean code such as cargo culting and over-management. You’ll then delve into JavaScript, understanding the more complex aspects of the language. Next, you’ll create meaningful abstractions using design patterns, such as the Class Pattern and the Revealing Module Pattern. You’ll explore real-world challenges such as DOM reconciliation, state management, dependency management, and security, both within browser and server environments. Later, you’ll cover tooling and testing methodologies and the importance of documenting code. Finally, the book will focus on advocacy and good communication for improving code cleanliness within teams or workplaces, along with covering a case study for clean coding. By the end of this book, you’ll be well-versed with JavaScript and have learned how to create clean abstractions, test them, and communicate about them via documentation.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Section 1: What is Clean Code Anyway?

Section 1: What is Clean Code Anyway?

Free Chapter

Setting the Scene

Setting the Scene

Why we write code

Writing code for humans

Summary

The Tenets of Clean Code

The Tenets of Clean Code

Reliability

Efficiency

Maintainability

Usability

Summary

The Enemies of Clean Code

The Enemies of Clean Code

Enemy #1 – JavaScript

Enemy #2 – management

Enemy #3 – Self

Enemy #4 – The cargo cult

Summary

SOLID and Other Principles

SOLID and Other Principles

The Law of Demeter

SOLID

The abstraction principle

Functional programming principles

Summary

Naming Things Is Hard

Naming Things Is Hard

What's in a name?

Naming anti-patterns

Consistency and hierarchy

Techniques and considerations

Summary

Section 2: JavaScript and Its Bits

Section 2: JavaScript and Its Bits

Primitive and Built-In Types

Primitive and Built-In Types

Primitive types

Objects

Functions

Arrays and iterables

RegExp

Summary

Dynamic Typing

Dynamic Typing

Detection

Conversion, coercion, and casting

Summary

Operators

Operators

What is an operator?

Arithmetic and numeric operators

Logical operators

Comparative operators

Assignment operators

Property access operators

Other operators and syntax

Bitwise operators

Summary

Parts of Syntax and Scope

Parts of Syntax and Scope

Expressions, statements, and blocks

Scopes and declarations

Summary

Control Flow

Control Flow

What is control flow?

Imperative versus declarative programming

The movement of control

Statements of control flow

Handling cyclomatic complexity

Asynchronous control flow

Summary

Section 3: Crafting Abstractions

Section 3: Crafting Abstractions

Design Patterns

Design Patterns

The perspective of a designer

Architectural design patterns

JavaScript modules

Modular design patterns

Planning and harmony

Summary

Real-World Challenges

Real-World Challenges

The DOM and single-page applications

Dependency management

Security

Summary

Section 4: Testing and Tooling

Section 4: Testing and Tooling

The Landscape of Testing

The Landscape of Testing

What is a test?

Types of testing

Test-Driven Development

Summary

Writing Clean Tests

Writing Clean Tests

Testing the right thing

Writing intuitive assertions

Creating clear hierarchies

Providing final clarity

Creating clean directory structures

Summary

Tools for Cleaner Code

Tools for Cleaner Code

Linters and formatters

Static typing

E2E testing tools

Automated builds and CI

Summary

Section 5: Collaboration and Making Changes

Section 5: Collaboration and Making Changes

Documenting Your Code

Documenting Your Code

Aspects of clean documentation

Documentation is everywhere

Writing for non-technical audiences

Summary

Other Peoples' Code

Other Peoples' Code

Inheriting code

Dealing with third-party code

Summary

Communication and Advocacy

Communication and Advocacy

Planning and setting requirements

Communication strategies

Identifying issues and driving change

Summary

Case Study

Case Study

The problem

The design

The implementation

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

4.1 (7)

5 star

71.4%

4 star

0

3 star

0

2 star

28.6%

1 star

0

Summary

In this chapter, we continued to explore the JavaScript language, zooming out from previous chapters to consider larger pieces of syntax, such as expressions, statements, and blocks. These are programmatic scaffolding components in which we can place the types and operations we've previously learned about. We also covered the complicated mechanisms of scopes, hoisting, and closures. Understanding how these concepts all work together is vital to understanding other people's JavaScript programs and constructing your own.

In the next chapter, we explore how to control flow within JavaScript. This'll allow us to weave together expressions and statements into larger bodies of logic in a clean way. We will then explore the art of abstraction design by learning about design patterns. Though the process of learning these topics individually may appear arduous, by...

Search

Your notes and bookmarks