Top 63 JavaScript Reserved Words You Need To Know

JavaScript, being a versatile programming language, has a set of reserved words that serve as predefined keywords with specific meanings and functionalities. These reserved words have predefined purposes within the language, and you cannot use them as identifiers (such as variable names or function names) in your JavaScript code.

Understanding these reserved words is crucial for writing clean and error-free JavaScript programs. Let’s explore some of the commonly used reserved words in JavaScript:

1. `abstract`: Used to declare an abstract class or method, indicating that it should be implemented by derived classes.
2. `as`: Used in TypeScript and ECMAScript modules for aliasing imports.
3. `boolean`: Represents a data type with two possible values: `true` or `false`.
4. `break`: Terminates a loop or a switch statement.
5. `byte`: Represents an 8-bit integer value.
6. `case`: Specifies a branch in a switch statement.
7. `catch`: Catches and handles exceptions that occur in a try block.
8. `char`: Represents a character data type (not commonly used in JavaScript).
9. `class`: Declares a class.
10. `continue`: Skips the current iteration of a loop and proceeds to the next one.
11. `const`: Declares a constant variable with a value that cannot be changed.
12. `debugger`: Stops the execution of JavaScript code and allows debugging.
13. `default`: Specifies the default branch in a switch statement.
14. `delete`: Removes a property from an object.
15. `do`: Creates a loop that executes a block of code until a specified condition becomes false.
16. `double`: Represents a double-precision floating-point number (not commonly used in JavaScript).
17. `else`: Specifies the block of code to be executed if a condition in an if statement is false.
18. `enum`: Defines a set of named constants.
19. `export`: Exports functions, objects, or values from a module to make them accessible to other modules.
20. `extends`: Specifies that a class is derived from another class or an object inherits from another object.
21. `false`: Represents the Boolean value `false`.
22. `final`: Indicates that a class or method cannot be overridden or modified.
23. `finally`: Specifies a block of code to be executed after a try block, regardless of whether an exception is thrown or not.
24. `float`: Represents a floating-point number (not commonly used in JavaScript).
25. `for`: Creates a loop that consists of three optional expressions: initialization, condition, and iteration.
26. `function`: Declares a function.
27. `goto`: Reserved but not used in JavaScript.
28. `if`: Specifies a block of code to be executed if a condition is true.
29. `implements`: Specifies that a class implements an interface.
30. `import`: Imports functions, objects, or values from a module.
31. `in`: Checks if a specified property exists in an object.
32. `instanceof`: Checks if an object is an instance of a specified class.
33. `int`: Represents a 32-bit integer value.
34. `interface`: Declares an interface.
35. `is`: Reserved but not used in JavaScript.
36. `long`: Represents a 64-bit integer value.
37. `namespace`: Defines a namespace for organizing code and preventing naming conflicts.
38. `native`: Specifies that a method is implemented in native code.
39. `new`: Creates an instance of an object or calls a constructor function.
40. `null`: Represents the absence of any object value.
41. `package`: Declares a package for organizing classes and functions (used in olderversions of JavaScript).
42. `private`: Specifies that a member is accessible only within its class.
43. `protected`: Specifies that a member is accessible within its class and its subclasses.
44. `public`: Specifies that a member is accessible from anywhere.
45. `return`: Exits a function and specifies a value to be returned.
46. `short`: Represents a 16-bit integer value.
47. `static`: Specifies that a property or method belongs to a class rather than instances of the class.
48. `super`: Refers to the parent class or calls the parent class’s constructor.
49. `switch`: Evaluates an expression and executes code based on matching cases.
50. `synchronized`: Reserved but not used in JavaScript.
51. `this`: Refers to the current object or context.
52. `throw`: Throws an exception.
53. `throws`: Specifies the exceptions that a method may throw.
54. `transient`: Specifies that a property should not be serialized when an object is converted to a stream of bytes.
55. `true`: Represents the Boolean value `true`.
56. `try`: Specifies a block of code to be tested for errors.
57. `typeof`: Returns the type of a variable or expression.
58. `use`: Used in strict mode to enable ECMAScript features or enforce stricter syntax.
59. `var`: Declares a variable.
60. `void`: Specifies that a function does not return a value.
61. `volatile`: Reserved but not used in JavaScript.
62. `while`: Creates a loop that executes a block of code while a specified condition is true.
63. `with`: Extends the scope chain for a block of code (not recommended for use).

Understanding these reserved words and their specific purposes is essential for writing correct and maintainable JavaScript code. When naming variables, functions, or objects, it is advisable to avoid using these reserved words to prevent conflicts and ensure code readability. JavaScript’s reserved words provide a foundation for the language’s syntax and functionality, enabling developers to build powerful and dynamic web applications.