{"id":13619805,"url":"https://github.com/nas5w/javascript-tips-and-tidbits","last_synced_at":"2025-05-16T05:02:33.980Z","repository":{"id":66175458,"uuid":"169744559","full_name":"nas5w/javascript-tips-and-tidbits","owner":"nas5w","description":"A continuously-evolving compendium of javascript tips based on common areas of confusion or misunderstanding.","archived":false,"fork":false,"pushed_at":"2024-05-04T23:34:20.000Z","size":77,"stargazers_count":1193,"open_issues_count":8,"forks_count":74,"subscribers_count":74,"default_branch":"master","last_synced_at":"2025-04-08T14:12:05.399Z","etag":null,"topics":["javascript"],"latest_commit_sha":null,"homepage":null,"language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/nas5w.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2019-02-08T14:10:51.000Z","updated_at":"2025-03-28T18:58:59.000Z","dependencies_parsed_at":"2024-06-12T00:00:55.303Z","dependency_job_id":"fcdb294a-2ddc-4d52-a4f1-e8823911dd4c","html_url":"https://github.com/nas5w/javascript-tips-and-tidbits","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nas5w%2Fjavascript-tips-and-tidbits","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nas5w%2Fjavascript-tips-and-tidbits/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nas5w%2Fjavascript-tips-and-tidbits/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nas5w%2Fjavascript-tips-and-tidbits/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/nas5w","download_url":"https://codeload.github.com/nas5w/javascript-tips-and-tidbits/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254471028,"owners_count":22076582,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["javascript"],"created_at":"2024-08-01T21:00:48.962Z","updated_at":"2025-05-16T05:02:33.905Z","avatar_url":"https://github.com/nas5w.png","language":null,"readme":"\u003cdiv align=\"center\"\u003e\n  \u003cimg alt=\"JavaScript Tips \u0026 Tidbits\" src=\"https://i.imgur.com/K7MVMOn.png\" /\u003e\n\u003c/div\u003e\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\u003cp align=\"center\"\u003e\n  A continuously-evolving compendium of javascript tips based on common areas of confusion or misunderstanding.\n\u003c/p\u003e\n\n---\n\n**Want to learn more about JavaScript development? Consider:** \n- Signing up for my [free newsletter](https://howthewebworks.substack.com) where I explain how the web works!\n- Subscribing to my [free youtube channel](https://www.youtube.com/c/devtutsco) where I teach JavaScript, Typescript, and React tutorials!\n\n---\n\n\n## Contents\n\n-   [Value vs. Reference Variable Assignment](#value-vs-reference-variable-assignment)\n-   [Closures](#closures)\n-   [Destructuring](#destructuring)\n-   [Spread Syntax](#spread-syntax)\n-   [Rest Syntax](#rest-syntax)\n-   [Array Methods](#array-methods)\n-   [Generators](#generators)\n-   [Identity Operator (===) vs. Equality Operator (==)](#identity-operator--vs-equality-operator)\n-   [Object Comparison](#object-comparison)\n-   [Callback Functions](#callback-functions)\n-   [Promises](#promises)\n-   [Async Await](#async-await)\n-   [DOM Manipulation](#dom-manipulation)\n-   [Interview Questions](#interview-questions)\n-   [Miscellaneous](#miscellaneous)\n\n## Value vs. Reference Variable Assignment\n\nUnderstanding how JavaScript assigns to variables is foundational to writing bug-free JavaScript. If you don't understand this, you could easily write code that unintentionally changes values.\n\nWhen JavaScript assigns one of the seven primitive type (i.e., Boolean, Null, Undefined, String, Number, Symbol, and BigInt.) to a variable, the JavaScript runtime gets to determine whether that primitive is assigned by *reference* or by *value*. It doesn't really matter how it's done because primitives can't be mutated (they're *immutable*). However, when the assigned value is an `Array`, `Function`, or `Object` a reference to the array/function/object in memory is assigned.\n\nExample time! In the following snippet, `var2` is set as equal to `var1`. Since `var1` is a primitive type (`String`), `var2` is set as equal to `var1`'s String value and can be thought of as completely distinct from `var1` at this point. Accordingly, reassigning `var2` has no effect on `var1`.\n\n```javascript\nconst var1 = 'My string';\nlet var2 = var1;\n\nvar2 = 'My new string';\n\nconsole.log(var1);\n// 'My string'\nconsole.log(var2);\n// 'My new string'\n```\n\nLet's compare this with object assignment.\n\n```javascript\nconst var1 = { name: 'Jim' };\nconst var2 = var1;\n\nvar2.name = 'John';\n\nconsole.log(var1);\n// { name: 'John' }\nconsole.log(var2);\n// { name: 'John' }\n```\n\nHow this is working: \n- The object `{ name: 'Jim' }` is created in memory\n- The variable `var1` is assigned a *reference* to the created object\n- The variable `var2` is set to equal `var1`... which is a reference to that same object in memory!\n- `var2` is mutated, which really means *the object var2 is referencing is mutated*\n- `var1` is pointing to the same object as `var2`, and therefore we see this mutation when accessing `var1`\n\nOne might see how this could cause problems if you expected behavior like primitive assignment! This can get especially ugly if you create a function that unintentionally mutates an object.\n\nFor more on variable assignment and primitive/object mutability, see \u003ca href=\"https://typeofnan.dev/variable-assignment-primitive-object-mutation/\" rel=\"\"\u003ethis article\u003c/a\u003e.\n\n## Closures\n\nClosure is an important javascript pattern to give private access to a variable. In this example, `createGreeter` returns an anonymous function that has access to the supplied `greeting`, \"Hello.\" For all future uses, `sayHello` will have access to this greeting!\n\n```javascript\nfunction createGreeter(greeting) {\n    return function(name) {\n        console.log(greeting + ', ' + name);\n    };\n}\n\nconst sayHello = createGreeter('Hello');\n\nsayHello('Joe');\n// Hello, Joe\n```\n\nIn a more real-world scenario, you could envision an initial function `apiConnect(apiKey)` that returns some methods that would use the API key. In this case, the `apiKey` would just need to be provided once and never again.\n\n```javascript\nfunction apiConnect(apiKey) {\n    function get(route) {\n        return fetch(`${route}?key=${apiKey}`);\n    }\n\n    function post(route, params) {\n        return fetch(route, {\n            method: 'POST',\n            body: JSON.stringify(params),\n            headers: {\n                Authorization: `Bearer ${apiKey}`\n            }\n        });\n    }\n\n    return { get, post };\n}\n\nconst api = apiConnect('my-secret-key');\n\n// No need to include the apiKey anymore\napi.get('http://www.example.com/get-endpoint');\napi.post('http://www.example.com/post-endpoint', { name: 'Joe' });\n```\n\n## Destructuring\n\nDon't be thrown off by javascript parameter destructuring! It's a common way to cleanly extract properties from objects.\n\n```javascript\nconst obj = {\n    name: 'Joe',\n    food: 'cake'\n};\n\nconst { name, food } = obj;\n\nconsole.log(name, food);\n// 'Joe' 'cake'\n```\n\nIf you want to extract properties under a different name, you can specify them using the following format.\n\n```javascript\nconst obj = {\n    name: 'Joe',\n    food: 'cake'\n};\n\nconst { name: myName, food: myFood } = obj;\n\nconsole.log(myName, myFood);\n// 'Joe' 'cake'\n```\n\nIn the following example, destructuring is used to cleanly pass the `person` object to the `introduce` function. In other words, destructuring can be (and often is) used directly for extracting parameters passed to a function. If you're familiar with React, you probably have seen this before!\n\n```javascript\nconst person = {\n    name: 'Eddie',\n    age: 24\n};\n\nfunction introduce({ name, age }) {\n    console.log(`I'm ${name} and I'm ${age} years old!`);\n}\n\nintroduce(person);\n// \"I'm Eddie and I'm 24 years old!\"\n```\n\n## Spread Syntax\n\nA javascript concept that can throw people off but is relatively simple is the spread operator! In the following case, `Math.max` can't be applied to the `arr` array because it doesn't take an array as an argument, it takes the individual elements as arguments. The spread operator `...` is used to pull the individual elements out the array.\n\n```javascript\nconst arr = [4, 6, -1, 3, 10, 4];\nconst max = Math.max(...arr);\nconsole.log(max);\n// 10\n```\n\n## Rest Syntax\n\nLet's talk about javascript rest syntax. You can use it to put any number of arguments passed to a function into an array!\n\n```javascript\nfunction myFunc(...args) {\n    console.log(args[0] + args[1]);\n}\n\nmyFunc(1, 2, 3, 4);\n// 3\n```\n\n## Array Methods\n\nJavaScript array methods can often provide you incredible, elegant ways to perform the data transformation you need. As a contributor to StackOverflow, I frequently see questions regarding how to manipulate an array of objects in one way or another. This tends to be the perfect use case for array methods.\n\nI will cover a number of different array methods here, organized by similar methods that sometimes get conflated. This list is in no way comprehensive: I encourage you to review and practice all of them discussed on MDN (my favorite JavaScript reference).\n\n### map, filter, reduce\n\nThere is some confusion around the javascript array methods `map`, `filter`, `reduce`. These are helpful methods for transforming an array or returning an aggregate value.\n\n-   **map:** return array where each element is transformed as specified by the function\n\n```javascript\nconst arr = [1, 2, 3, 4, 5, 6];\nconst mapped = arr.map(el =\u003e el + 20);\nconsole.log(mapped);\n// [21, 22, 23, 24, 25, 26]\n```\n\n-   **filter:** return array of elements where the function returns true\n\n```javascript\nconst arr = [1, 2, 3, 4, 5, 6];\nconst filtered = arr.filter(el =\u003e el === 2 || el === 4);\nconsole.log(filtered);\n// [2, 4]\n```\n\n-   **reduce:** accumulate values as specified in function\n\n```javascript\nconst arr = [1, 2, 3, 4, 5, 6];\nconst reduced = arr.reduce((total, current) =\u003e total + current, 0);\nconsole.log(reduced);\n// 21\n```\n\n_Note:_ It is always advised to specify an _initialValue_ or you could receive an error. For example:\n\n```javascript\nconst arr = [];\nconst reduced = arr.reduce((total, current) =\u003e total + current);\nconsole.log(reduced);\n// Uncaught TypeError: Reduce of empty array with no initial value\n```\n\n_Note:_ If there’s no initialValue, then reduce takes the first element of the array as the initialValue and starts the iteration from the 2nd element\n\nYou can also read this [tweet](https://twitter.com/sophiebits/status/1099014182261776384?s=20) by Sophie Alpert (@sophiebits), when it is recommended to use \u003ccode\u003ereduce\u003c/code\u003e\n\n### find, findIndex, indexOf\n\nThe array methods `find`, `findIndex`, and `indexOf` can often be conflated. Use them as follows.\n\n-   **find:** return the first instance that matches the specified criteria. Does not progress to find any other matching instances.\n\n```javascript\nconst arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\nconst found = arr.find(el =\u003e el \u003e 5);\nconsole.log(found);\n// 6\n```\n\nAgain, note that while everything after 5 meets the criteria, only the first matching element is returned. This is actually super helpful in situations where you would normally break a `for` loop when you find a match!\n\n-   **findIndex:** This works almost identically to find, but rather than returning the first matching element it returns the index of the first matching element. Take the following example, which uses names instead of numbers for clarity.\n\n```javascript\nconst arr = ['Nick', 'Frank', 'Joe', 'Frank'];\nconst foundIndex = arr.findIndex(el =\u003e el === 'Frank');\nconsole.log(foundIndex);\n// 1\n```\n\n-   **indexOf:** Works almost identically to findIndex, but instead of taking a function as an argument it takes a simple value. You can use this when you have simpler logic and don't need to use a function to check whether there is a match.\n\n```javascript\nconst arr = ['Nick', 'Frank', 'Joe', 'Frank'];\nconst foundIndex = arr.indexOf('Frank');\nconsole.log(foundIndex);\n// 1\n```\n\n### push, pop, shift, unshift\n\nThere are a lot of great array method to help add or remove elements from arrays in a targeted fashion.\n\n-   **push:** This is a relatively simple method that adds an item to the end of an array. It modifies the array in-place and the function itself returns the length of the new array.\n\n```javascript\nconst arr = [1, 2, 3, 4];\nconst pushed = arr.push(5);\nconsole.log(arr);\n// [1, 2, 3, 4, 5]\nconsole.log(pushed);\n// 5\n```\n\n-   **pop:** This removes the last item from an array. Again, it modifies the array in place. The function itself returns the item removed from the array.\n\n```javascript\nconst arr = [1, 2, 3, 4];\nconst popped = arr.pop();\nconsole.log(arr);\n// [1, 2, 3]\nconsole.log(popped);\n// 4\n```\n\n-   **shift:** This removes the first item from an array. Again, it modifies the array in place. The function itself returns the item removed from the array.\n\n```javascript\nconst arr = [1, 2, 3, 4];\nconst shifted = arr.shift();\nconsole.log(arr);\n// [2, 3, 4]\nconsole.log(shifted);\n// 1\n```\n\n-   **unshift:** This adds one or more elements to the beginning of an array. Again, it modifies the array in place. Unlike a lot of the other methods, the function itself returns the new length of the array.\n\n```javascript\nconst arr = [1, 2, 3, 4];\nconst unshifted = arr.unshift(5, 6, 7);\nconsole.log(arr);\n// [5, 6, 7, 1, 2, 3, 4]\nconsole.log(unshifted);\n// 7\n```\n\n### splice, slice\n\nThese methods either modify or return subsets of arrays.\n\n-   **splice:** Change the contents of an array by removing or replacing existing elements and/or adding new elements. This method modifies the array in place.\n\n```javascript\nThe following code sample can be read as: at position 1 of the array, remove 0 elements and insert b.\nconst arr = ['a', 'c', 'd', 'e'];\narr.splice(1, 0, 'b');\nconsole.log(arr);\n// ['a', 'b', 'c', 'd', 'e']\n```\n\n-   **slice:** returns a shallow copy of an array from a specified start position and before a specified end position. If no end position is specified, the rest of the array is returned. Importantly, this method does not modify the array in place but rather returns the desired subset.\n\n```javascript\nconst arr = ['a', 'b', 'c', 'd', 'e'];\nconst sliced = arr.slice(2, 4);\nconsole.log(sliced);\n// ['c', 'd']\nconsole.log(arr);\n// ['a', 'b', 'c', 'd', 'e']\n```\n\n### sort\n\n-   **sort:** sorts an array based on the provided function which takes a first element and second element argument. Modifies the array in place. If the function returns negative or 0, the order remains unchanged. If positive, the element order is switched.\n\n```javascript\nconst arr = [1, 7, 3, -1, 5, 7, 2];\nconst sorter = (firstEl, secondEl) =\u003e firstEl - secondEl;\narr.sort(sorter);\nconsole.log(arr);\n// [-1, 1, 2, 3, 5, 7, 7]\n```\n\nPhew, did you catch all of that? Neither did I. In fact, I had to reference the MDN docs a lot while writing this - and that's okay! Just knowing what kind of methods are out there with get you 95% of the way there.\n\n## Generators\n\nDon't fear the `*`. The generator function specifies what `value` is yielded next time `next()` is called. Can either have a finite number of yields, after which `next()` returns an `undefined` value, or an infinite number of values using a loop.\n\n```javascript\nfunction* greeter() {\n    yield 'Hi';\n    yield 'How are you?';\n    yield 'Bye';\n}\n\nconst greet = greeter();\n\nconsole.log(greet.next().value);\n// 'Hi'\nconsole.log(greet.next().value);\n// 'How are you?'\nconsole.log(greet.next().value);\n// 'Bye'\nconsole.log(greet.next().value);\n// undefined\n```\n\nAnd using a generator for infinite values:\n\n```javascript\nfunction* idCreator() {\n    let i = 0;\n    while (true) yield i++;\n}\n\nconst ids = idCreator();\n\nconsole.log(ids.next().value);\n// 0\nconsole.log(ids.next().value);\n// 1\nconsole.log(ids.next().value);\n// 2\n// etc...\n```\n\n## Identity Operator (===) vs. Equality Operator (==)\n\nBe sure to know the difference between the identify operator (`===`) and equality operator (`==`) in javascript! The `==` operator will do type conversion prior to comparing values whereas the `===` operator will not do any type conversion before comparing.\n\n```javascript\nconsole.log(0 == '0');\n// true\nconsole.log(0 === '0');\n// false\n```\n\n## Object Comparison\n\nA mistake I see javascript newcomers make is directly comparing objects. Variables are pointing to references to the objects in memory, not the objects themselves! One method to actually compare them is converting the objects to JSON strings. This has a drawback though: `JSON.stringify` is not able to stringify a lot of object types (e.g., functions and sets)! A safer way to compare objects is to pull in a library that specializes in deep object comparison (e.g., lodash's isEqual).\n\nThe following objects appear equal but they are in fact pointing to different references.\n\n```javascript\nconst joe1 = { name: 'Joe' };\nconst joe2 = { name: 'Joe' };\n\nconsole.log(joe1 === joe2);\n// false\n```\n\nConversely, the following evaluates as true because one object is set equal to the other object and are therefore pointing to the same reference (there is only one object in memory).\n\n```javascript\nconst joe1 = { name: 'Joe' };\nconst joe2 = joe1;\n\nconsole.log(joe1 === joe2);\n// true\n```\n\nMake sure to review the Value vs. Reference section above to fully understand the ramifications of setting a variable equal to another variable that's pointing to a reference to an object in memory!\n\n## Callback Functions\n\nFar too many people are intimidated by javascript callback functions! They are simple, take this example. The `console.log` function is being passed as a callback to `myFunc`. It gets executed when `setTimeout` completes. That's all there is to it!\n\n```javascript\nfunction myFunc(text, callback) {\n    setTimeout(function() {\n        callback(text);\n    }, 2000);\n}\n\nmyFunc('Hello world!', console.log);\n// 'Hello world!'\n```\n\n## Promises\n\nOnce you understand javascript callbacks you'll soon find yourself in nested \"callback hell.\" This is where Promises help! Wrap your async logic in a `Promise` and `resolve` on success or `reject` on fail. Use `then` to handle success and `catch` to handle failure.\n\n```javascript\nconst myPromise = new Promise(function(res, rej) {\n    setTimeout(function() {\n        if (Math.random() \u003c 0.9) {\n            return res('Hooray!');\n        }\n        return rej('Oh no!');\n    }, 1000);\n});\n\nmyPromise\n    .then(function(data) {\n        console.log('Success: ' + data);\n    })\n    .catch(function(err) {\n        console.log('Error: ' + err);\n    });\n\n// If Math.random() returns less than 0.9 the following is logged:\n// \"Success: Hooray!\"\n// If Math.random() returns 0.9 or greater the following is logged:\n// \"Error: Oh no!\"\n```\n\n### Avoid the nesting anti-pattern of promise chaining!\n\n`.then` methods can be chained. I see a lot of new comers end up in some kind of call back hell inside of a promise when it's completely unnecessary.\n\n```javascript\n//The wrong way\ngetSomedata.then(data =\u003e {\n    getSomeMoreData(data).then(newData =\u003e {\n        getSomeRelatedData(newData =\u003e {\n            console.log(newData);\n        });\n    });\n});\n```\n\n```javascript\n//The right way\ngetSomeData\n    .then(data =\u003e {\n        return getSomeMoreData(data);\n    })\n    .then(data =\u003e {\n        return getSomeRelatedData(data);\n    })\n    .then(data =\u003e {\n        console.log(data);\n    });\n```\n\nYou can see how it's much easier to read the second form and with ES6 implicit returns we could even simplify that further:\n\n```javascript\ngetSomeData\n    .then(data =\u003e getSomeMoreData(data))\n    .then(data =\u003e getSomeRelatedData(data))\n    .then(data =\u003e console.log(data));\n```\nBecause the function supplied to .then will be called with the the result of the resolve method from the promise we can omit the ceremony of creating an anonymous function altogether. This is equivalent to above:\n\n```javascript\ngetSomeData\n    .then(getSomeMoreData)\n    .then(getSomeRelatedData)\n    .then(console.log);\n```\n\n## Async Await\n\nOnce you get the hang of javascript promises, you might like `async await`, which is just \"syntactic sugar\" on top of promises. In the following example we create an `async` function and within that we `await` the `greeter` promise.\n\n```javascript\nconst greeter = new Promise((res, rej) =\u003e {\n    setTimeout(() =\u003e res('Hello world!'), 2000);\n});\n\nasync function myFunc() {\n    const greeting = await greeter;\n    console.log(greeting);\n}\n\nmyFunc();\n// 'Hello world!'\n```\n\n### Async functions return a promise\n\nOne important thing to note here is that the result of an `async` function is a promise.\n\n```javascript\nconst greeter = new Promise((res, rej) =\u003e {\n    setTimeout(() =\u003e res('Hello world!'), 2000);\n});\n\nasync function myFunc() {\n    return await greeter;\n}\n\nconsole.log(myFunc()); // =\u003e Promise {}\n\nmyFunc().then(console.log); // =\u003e Hello world!\n```\n\n## DOM Manipulation\n\n### Create Your Own Query Selector Shorthand\n\nWhen working with JS in the browser, instead of writing `document.querySelector()`/`document.querySelectorAll()` multiple times, you could do the following thing:\n\n```javascript\nconst $ = document.querySelector.bind(document);\nconst $$ = document.querySelectorAll.bind(document);\n\n// Usage\nconst demo = $('#demo');\n// Select all the `a` tags\n[...$$(\"a[href *='#']\")].forEach(console.log);\n```\n\n## Interview Questions\n\n### Traversing a Linked List\n\nHere's a javascript solution to a classic software development interview question: traversing a linked list. You can use a while loop to recursively iterate through the linked list until there are no more values!\n\n```javascript\nconst linkedList = {\n    val: 5,\n    next: {\n        val: 3,\n        next: {\n            val: 10,\n            next: null\n        }\n    }\n};\n\nconst arr = [];\nlet head = linkedList;\n\nwhile (head !== null) {\n    arr.push(head.val);\n    head = head.next;\n}\n\nconsole.log(arr);\n// [5, 3, 10]\n```\n\n## Miscellaneous\n\n### Increment and Decrement\n\nEver wonder what the difference between `i++` and `++i` was? Did you know both were options? `i++` returns `i` and then increments it whereas `++i` increments `i` and then returns it.\n\n```javascript\nlet i = 0;\nconsole.log(i++);\n// 0\n```\n\n```javascript\nlet i = 0;\nconsole.log(++i);\n// 1\n```\n\n# Contributing\n\nContributions welcome! All I ask is that you open an issue and we discuss your proposed changes before you create a pull request.\n","funding_links":[],"categories":["Others"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnas5w%2Fjavascript-tips-and-tidbits","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnas5w%2Fjavascript-tips-and-tidbits","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnas5w%2Fjavascript-tips-and-tidbits/lists"}