Javascript

ChatGPT said:

Here are 100 clean, practical lines on JavaScript for your study notes, revision, or teaching slides:

1. JavaScript is a high-level, interpreted programming language.
   
   

2. It was created by Brendan Eich in 1995.
   
   

3. JavaScript is lightweight and dynamic.
   
   

4. It is a core technology of the web, alongside HTML and CSS.
   
   

5. JavaScript is used to create interactive web pages.
   
   

6. It can be used for client-side and server-side development.
   
   

7. JavaScript is case-sensitive.
   
   

8. Statements end with a semicolon (optional but recommended).
   
   

9. JavaScript code can be included in HTML using <script> tags.
   
   

10. It can also be used in external .js files.
    
    

11. JavaScript supports primitive data types: string, number, boolean, null, undefined, symbol, bigint.
    
    

12. It also supports objects and arrays as reference types.
    
    

13. Variables can be declared using var, let, and const.
    
    

14. var is function-scoped; let and const are block-scoped.
    
    

15. const declares constants that cannot be reassigned.
    
    

16. JavaScript supports functions, which can be declared or assigned to variables.
    
    

17. Functions can be arrow functions: const add = (a, b) => a + b;
    
    

18. JavaScript supports object-oriented programming using prototypes and classes.
    
    

19. Classes were introduced in ES6 (2015).
    
    

20. JavaScript supports inheritance using prototypes.
    
    

21. JavaScript uses dynamic typing (no explicit type declarations).
    
    

22. Arrays can be declared as let arr = [1, 2, 3];.
    
    

23. Objects can be declared as let obj = { key: "value" };.
    
    

24. Strings can be enclosed in single, double, or backticks.
    
    

25. Backticks allow template literals: `Hello, ${name}`.
    
    

26. JavaScript uses === for strict equality, checking value and type.
    
    

27. == performs type coercion during comparison.
    
    

28. Conditional statements use if, else if, else.
    
    

29. Loops include for, while, do...while, and for...of.
    
    

30. for...in loops over object properties.
    
    

31. Functions can have default parameters: function greet(name = "Guest").
    
    

32. Functions can return values using return.
    
    

33. JavaScript has built-in methods like console.log().
    
    

34. Browser’s console helps in debugging JavaScript code.
    
    

35. JavaScript can manipulate the DOM (Document Object Model).
    
    

36. document.getElementById("id") selects an element by ID.
    
    

37. document.querySelector(".class") selects the first matching element.
    
    

38. document.querySelectorAll(".class") selects all matching elements.
    
    

39. Events can be handled using .addEventListener().
    
    

40. Example: button.addEventListener("click", function() { });
    
    

41. JavaScript can modify CSS using .style property.
    
    

42. JavaScript supports event bubbling and capturing.
    
    

43. Functions can be anonymous.
    
    

44. Functions can be immediately invoked: (function() { })();.
    
    

45. JavaScript has built-in objects like Math, Date, JSON.
    
    

46. Math.random() generates a random number between 0 and 1.
    
    

47. Date can get the current date and time: new Date().
    
    

48. JSON is used for data exchange in JavaScript.
    
    

49. JSON.stringify() converts objects to JSON strings.
    
    

50. JSON.parse() parses JSON strings to objects.
    
    

51. JavaScript supports error handling using try...catch.
    
    

52. Example:
    
    

js

CopyEdit

try { 

  riskyFunction(); 

} catch (error) { 

  console.log(error); 

}

53. JavaScript supports asynchronous programming.
    
    

54. Asynchronous operations can use callbacks.
    
    

55. Promises are used for better asynchronous flow.
    
    

56. Example Promise:
    
    

js

CopyEdit

let promise = new Promise((resolve, reject) => { resolve("done"); });

57. Promises use .then() for resolved results and .catch() for errors.
    
    

58. JavaScript supports async and await for clean async code.
    
    

59. Example:
    
    

js

CopyEdit

async function fetchData() { let data = await getData(); }

60. JavaScript can fetch APIs using fetch().
    
    

61. Example:
    
    

js

CopyEdit

fetch(url).then(res => res.json()).then(data => console.log(data));

62. JavaScript runs in browsers and Node.js environments.
    
    

63. Node.js allows JavaScript to run on servers.
    
    

64. JavaScript supports modules using export and import.
    
    

65. Example: export function greet() { } in one file.
    
    

66. Example: import { greet } from './file.js' in another file.
    
    

67. Arrays have useful methods: .push(), .pop(), .shift(), .unshift().
    
    

68. .map() applies a function to each array element and returns a new array.
    
    

69. .filter() returns a new array with elements that match a condition.
    
    

70. .reduce() applies a function to accumulate array values.
    
    

71. .forEach() executes a function for each array element.
    
    

72. Objects can be accessed using dot notation: obj.key.
    
    

73. Objects can also be accessed using bracket notation: obj["key"].
    
    

74. You can loop over arrays using for...of.
    
    

75. Example:
    
    

js

CopyEdit

for (let item of arr) { console.log(item); }

76. You can loop over object keys using for...in.
    
    

77. JavaScript has a typeof operator to check data types.
    
    

78. Example: typeof "Hello" returns "string".
    
    

79. JavaScript uses lexical scoping.
    
    

80. Functions have closures, remembering the scope in which they were created.
    
    

81. JavaScript uses hoisting for variable and function declarations.
    
    

82. Variables declared with var are hoisted and initialized with undefined.
    
    

83. let and const declarations are hoisted but not initialized.
    
    

84. Functions declared with function are hoisted entirely.
    
    

85. JavaScript uses the event loop for handling asynchronous operations.
    
    

86. The call stack handles synchronous code.
    
    

87. The task queue handles callbacks and async operations.
    
    

88. JavaScript supports regular expressions using /pattern/.
    
    

89. Example: /\d+/ matches one or more digits.
    
    

90. JavaScript can manipulate strings using methods like .toUpperCase(), .toLowerCase(), .trim().
    
    

91. Strings are immutable in JavaScript.
    
    

92. JavaScript can create and manipulate dates with Date methods like .getFullYear(), .getMonth().
    
    

93. JavaScript has utility libraries like Lodash and Moment.js for advanced operations.
    
    

94. JavaScript engines like V8 (Chrome) and SpiderMonkey (Firefox) execute JS code.
    
    

95. Modern JavaScript uses ES6 features like arrow functions, classes, and destructuring.
    
    

96. Destructuring allows unpacking values:
    
    

js

CopyEdit

let [a, b] = [1, 2];

let { x, y } = { x: 10, y: 20 };

97. JavaScript can interact with Web APIs like Geolocation, LocalStorage, and Canvas.
    
    

98. LocalStorage can store key-value pairs in the browser: localStorage.setItem("key", "value").
    
    

99. JavaScript is essential for modern frameworks like React, Angular, and Vue.
    
    

100. JavaScript is continuously evolving, making it one of the most powerful and in-demand languages in the world.
     
     

If you need next:
✅ A JavaScript syntax cheat sheet
✅ 10 beginner JavaScript mini projects
✅ 50 JavaScript interview questions
✅ A JavaScript practice test for mastery

Here are 100 practical JavaScript “cheat code” lines for daily coding, testing, and memory building:

1. console.log("Hello World"); // print to console
   
   

2. let x = 5; // declare variable
   
   

3. const y = 10; // constant value
   
   

4. var z = 15; // old-style variable
   
   

5. x += 2; // increment by 2
   
   

6. x++; // increment by 1
   
   

7. x--; // decrement by 1
   
   

8. console.log(typeof x); // check type
   
   

9. let str = "JavaScript"; // string value
   
   

10. let bool = true; // boolean value
    
    

11. let arr = [1, 2, 3]; // array
    
    

12. let obj = {name: "Alice", age: 25}; // object
    
    

13. arr.push(4); // add to end
    
    

14. arr.pop(); // remove from end
    
    

15. arr.shift(); // remove from start
    
    

16. arr.unshift(0); // add to start
    
    

17. arr.length; // array length
    
    

18. arr.includes(2); // check if array includes
    
    

19. let sum = arr.reduce((a, b) => a + b); // sum array
    
    

20. arr.map(x => x * 2); // double array values
    
    

21. arr.filter(x => x > 1); // filter values > 1
    
    

22. arr.find(x => x === 2); // find specific value
    
    

23. arr.indexOf(2); // find index of 2
    
    

24. for (let i = 0; i < arr.length; i++) { console.log(arr[i]); } // loop
    
    

25. for (let item of arr) { console.log(item); } // for..of
    
    

26. for (let key in obj) { console.log(key); } // for..in
    
    

27. if (x > 5) { console.log("Greater"); } // if statement
    
    

28. else { console.log("Not greater"); } // else
    
    

29. x === 5 ? "Yes" : "No"; // ternary
    
    

30. function greet(name) { return "Hello " + name; } // function
    
    

31. const greet = name => "Hello " + name; // arrow function
    
    

32. (function() { console.log("IIFE"); })(); // IIFE
    
    

33. const [a, b] = [1, 2]; // array destructuring
    
    

34. const {name, age} = obj; // object destructuring
    
    

35. let str2 = \Hello ${name}`;` // template literal
    
    

36. "abc".toUpperCase(); // uppercase
    
    

37. "ABC".toLowerCase(); // lowercase
    
    

38. " trim ".trim(); // trim spaces
    
    

39. "JavaScript".includes("Script"); // check substring
    
    

40. "Hello".split(""); // split into array
    
    

41. [..."Hello"]; // spread string to array
    
    

42. let merged = [...arr, 4, 5]; // merge arrays
    
    

43. let copy = {...obj}; // shallow copy object
    
    

44. JSON.stringify(obj); // object to JSON
    
    

45. JSON.parse('{"name":"Alice"}'); // JSON to object
    
    

46. new Date(); // current date
    
    

47. Date.now(); // current timestamp
    
    

48. Math.random(); // random number 0-1
    
    

49. Math.floor(Math.random() * 10); // random 0-9
    
    

50. Math.max(1, 2, 3); // max value
    
    

51. Math.min(1, 2, 3); // min value
    
    

52. Math.round(4.5); // round number
    
    

53. isNaN("abc"); // check NaN
    
    

54. Number("123"); // convert to number
    
    

55. String(123); // convert to string
    
    

56. Boolean(0); // convert to boolean
    
    

57. parseInt("10", 10); // parse integer
    
    

58. parseFloat("10.5"); // parse float
    
    

59. typeof 42; // returns "number"
    
    

60. typeof "abc"; // returns "string"
    
    

61. typeof true; // returns "boolean"
    
    

62. typeof {}; // returns "object"
    
    

63. typeof []; // returns "object" (arrays are objects)
    
    

64. typeof null; // returns "object" (quirk)
    
    

65. typeof undefined; // returns "undefined"
    
    

66. null === undefined; // false
    
    

67. null == undefined; // true
    
    

68. console.error("Error message"); // error log
    
    

69. console.warn("Warning message"); // warning log
    
    

70. console.table(arr); // display array as table
    
    

71. alert("Hello!"); // alert popup
    
    

72. prompt("Enter your name"); // input popup
    
    

73. confirm("Are you sure?"); // confirm popup
    
    

74. setTimeout(() => console.log("Delayed"), 1000); // delay 1s
    
    

75. setInterval(() => console.log("Repeating"), 1000); // repeat every 1s
    
    

76. clearTimeout(timerId); // clear timeout
    
    

77. clearInterval(intervalId); // clear interval
    
    

78. try { JSON.parse("{"); } catch (e) { console.error(e); } // try-catch
    
    

79. document.getElementById("id"); // get by ID
    
    

80. document.querySelector(".class"); // get by selector
    
    

81. document.querySelectorAll("div"); // get all elements
    
    

82. element.textContent = "Text"; // set text
    
    

83. element.innerHTML = "<b>Bold</b>"; // set HTML
    
    

84. element.style.color = "red"; // change style
    
    

85. element.addEventListener("click", () => alert("Clicked")); // event listener
    
    

86. window.localStorage.setItem("key", "value"); // set localStorage
    
    

87. window.localStorage.getItem("key"); // get localStorage
    
    

88. window.localStorage.removeItem("key"); // remove localStorage
    
    

89. window.localStorage.clear(); // clear all localStorage
    
    

90. navigator.geolocation.getCurrentPosition(pos => console.log(pos)); // get location
    
    

91. fetch("https://api.example.com") // fetch API
    
    

92. .then(response => response.json()) // parse JSON
    
    

93. .then(data => console.log(data)) // handle data
    
    

94. .catch(error => console.error(error)); // catch error
    
    

95. class Person { constructor(name) { this.name = name; } } // class
    
    

96. let p = new Person("Alice"); // instantiate class
    
    

97. p instanceof Person; // true
    
    

98. Array.isArray(arr); // check if array
    
    

99. new Promise((resolve, reject) => resolve("Done")); // promise
    
    

100. async function getData() { let data = await fetch(url); } // async/await