TINKER - Javascript Part II

--- tags: mstu5003, tinker, js --- # TINKER - Javascript Part II Andrea Xindi Chen Yichen An Sam Park  - See demonstration: https://codepen.io/jmk2142/pen/oGxwPQ - Tinker Markdown: https://hackmd.io/zJmA8GKJR5-Oe2Zy4r1wqw?both  ## Devtools You will also want to watch this video on the `console` as we will be using it extensively to Tinker this week. General Video on Console: https://youtu.be/GAqOggzH_GE?list=PLn93-yl6k7zUkSFNI8MQqmIVn017z8vKO One of the most important tools we'll use is the `DEBUGGER`. :::success **Debugger Demonstration and Youtube Video**  CODE: https://codepen.io/jmk2142/pen/RwZErre DEMO: https://cdpn.io/jmk2142/debug/RwZErre YOUTUBE: https://youtu.be/RdF7j4no0Ts ::: I recommend that at some point, you watch these demonstrations and use these tools to explore the Tinker. :::info In order to use `console.dir(object)` and see the object property/values, make sure your console setting is set to DEFAULT. ![](https://i.imgur.com/cmR16Mg.png) ::: ## Tinker GIST: TODOS > Good bye, "Hello World!" `Hello World` is probably the most common introductory program around as it's so simple. ```javascript= alert("Hello World!"); // Or alternatively... console.log("Hello World!"); ``` Unfortunately, it's not very useful. It doesn't really show the range of different programming concepts and to be quite frank, it's boring. Many beginners like us are interested in creating interactive applications and this requires a range of programming concepts. 1. HTML Elements 2. CSS 3. Variables 4. Operators 5. Functions 6. Control Statements 7. Events 8. Data Structures + Data (e.g. Arrays, Objects, Booleans, Numbers, Strings) And you really cant get a sense of how these things work together with a 1 line program like `Hello World!`. ### Enter TODOS Some clever programmer realized this and probably thought: > What's the simplest, _real_ program I can build that will incorporate all the important aspects of a basic interactive program? And the **TODOS** or **TODO LIST** program was born. The beauty of TODOS is that it has everything in a pretty simple package. It can be solved using a variety of different strategies and can be created to be _simpler_ or _more sophsiticated_ depending on ones needs. It tends to now be the defacto standard for demonstrating a full interactive application. Beginners AND advanced students alike build TODO apps as they learn new things. For example, our TODOS Tinker is designed to demonstrate the base JS concepts with a few _stretch_ challenges embedded in it. In my regular practice, when I have to learn a new library or framework, I will probably start by viewing an existing TODO app built with that specific library to see how that library works. Sort of like how you might compare a basic HTML page with a Bootstrap page (of the same content) to be able to compare and contrast the two. If you're interested, you can briefly look at [this page](http://todomvc.com/) which is an archive of the TODO application built in various different frameworks. And this is where I am hoping to take this class, the culmination of all the things we've been working towards - to understanding this first, real, interactive program and hopefully - you can apply some of these concepts in your own works. ## Tinker Tasks In this tinker, were going to: 1. Review prior concepts in this new context: - Variables, functions, events, and arrays 2. Observe, analyze, and study new concepts: - Control statements (E.g. `if`, `for`) - Logical operators (E.g. `===`,`&&`, `||`,`<`,`<=`,`>`,`>=`, etc.) - Objects (and `array` of `objects`) 3. Learn how to use more developer tools to study JS code - Source (i.e. debugger) - Console (i.e. `console.log`, `console.dir`) We will continue to observe, analyze and think about this program in terms of: > What is the STATE? > What is the SEQUENCE? > What is the CAUSALITY? ### Part 0: Conceptual Program Overview Play with the program and observe how it reacts to user interactions. - _Without_ talking about it in _programming terms_ explain the user observable steps/process of the following three interactions and how the program responds. - Adding a todo -Write in the to do list in the form input, then click the "Add" button - Completing a todo -Click the radio button in the front, the item will have a strikethrough and italicized - Removing a todo(s) -Click the remove button -This removes the checked off items from the list Be specific but imagine you are talking to a _non-programmer_. Think about this in terms of observable actions and reactions. > User puts toast in the toaster. Sets the length of the timer. Pushes the lever to start the toaster. The toast pops out the toaster after the time is completed and goes "DING". - For each of the interactions above write in _pseudocode_ the steps of how the program for that interaction unfold and results. Pseudocode is semi-formal structure to write out the gist of how your program would work. It uses some keywords but is largely language agnostic. There isn't a single correct way to do it but the following are some rules that can help. ```markdown= # To do list WRITE an "to do item" in the input form CLICK the "Add" button ... ... ``` - RULES: - One statement per line - CAPITALIZE initial _keywords_ - READ, WRITE, IF, ELSE, REPEAT, UNTIL, AND, OR - Indent to show hierarchy and groups of operation - Keep statements language independent ```markdown= # Making toast for a big family READ loaf of bread READ slice of loaf Put slice in toaster WRITE time to toast Start the toaster Cook the toast READ time WRITE time by one second less REPEAT UNTIL time is zero Remove toast REPEAT for all slices in loaf # Serving toast WRITE number of slices total READ number of family members READ toastiness IF toast is burnt AND (total slices >= number of family members) throw away toast decrement slices total ELSE serve toast to family member ``` - Using your pseudocode, identify the function(s) in the actual JS code that relate to your pseudocode. - Compare and contrast your pseudocode with the actual code. - Explain what similarities and differences you noticed about the instructions / steps / processes in the code vs. your psuedocode. - Manipulate different parts of the code as you see fit. Why did you decide to manipulate that part? What happened? (More structured tinkering to follow.) ### Part 1: Variables, Functions, Arrays, and Events - Sam - Explain the `data` variable. - What does this data (and the data inside) represent conceptually? Contains the data for the to-do list including id, task, and status - If I wanted to access the second object, how would I do that in code? data.task(1) - If I wanted to access the `done` property of the first object, how would I do that? data.done(0) - Look through the rest of the code where this `data` array is used. When the user does things, am I manipulating the visual display and updating the data to reflect those changes? Or am I manipulating the data and updating the visual display to reflect those changes? when new to do item is added, a that is added as a new object in the data array by function newTodo() - Is this what you would have thought of? Yes - What might be the significance of this program design decision? This design allows new items to be added and also assign different characteristics as objects such as the task, unique id, status, etc - What do these lines in my code do? ```javascript= var todosEl = document.querySelector('#todos'); var inputEl = document.querySelector('input'); var completedEl = document.querySelector('#counter'); ``` It assigns the input values to the variables that will be displayed in html. For example, the first line assigns the task input to todoEl which is displayed by as list with id="todos" - Why declare these (see above) variables at the Global scope instead of in the functions? - Or not at all... (E.g. `document.querySelector('#todos');`) So that it can be used by any functions. - The `toggleComplete` function has an event parameter. Inside the function I access `event.currentTarget`. What is the difference between `event.currentTarget` and `event.target` which we used previously? event.currentTarget uses the current target that is attached - Hint 1: You can add a `console.log(event)` etc. inside that function to test the value of `event.target` and `event.currentTarget`. - Hint 2: When testing, click on a todo to "complete" it. Click on two areas: the `li` as well as the `i` (font icon) element to see the differences. - Hint 3: You can pass multiple arguments to `console.log()`. I often pass two: first a string label, second the thing I want to log. This will basically make the logs easier to identify if you use `console.log()` a lot. ```javascript= console.log("SOME LABEL: ", dataToLog); ``` - In the `toggleComplete` function, there is a `event.currentTarget.id`. Is that `id` the same thing as the id property in my todo objects in the `data` array? - Explain. - Yes, this id identifies each unique task as object in the data array - What does `!something` mean? (The exclamation mark) and how is it used in this code when we `toggleComplete`? !something is "not" something, so this sets the object in the array from true to false or false to true - Try calling some of the functions directly from the console. Some will work. Some won't. - Explain what you find. - Some functions are dependent on other functions and variables outside of the function, so calling it in just the console won't work - Look at the function declarations in the JS panel. - _Where_ is each function being called? - _When_ is each function, actually called? - What parameter(s) does that function have? - What is the argument that is passed into the function when it is called? - Use the console (in Chrome devtools) to `console.log()` and `console.dir()` the following. What is the difference between `console.log` and `console.dir` and why is `console.dir` kind of more useful for looking at some kinds of data? ```javascript= console.log(data); console.log(todosEl); console.dir(data); console.dir(todosEl); ``` ### Part 2: Objects and Arrays of Objects - Yichen - Manipulate the different _properties_ of the _objects_ inside the `data` array. - Change all todo objects' `done` property to `true`. - Change some of the task values. - Run your code and explain how this changes what you see and why. Change the string in task with directly affect the rows on the web page. When I give the 'done' var true value, the task is considered compeleted.![](https://i.imgur.com/RFqhyXS.png) - `console.dir()` the `data` array. Goto the console and _OPEN_ the `> Array(3)` text by clicking on it. Go deeper by opening up the nested objects. Analyze what you see. Then add a new todo through the user interface. `console.dir()` the `data` array again and investigate the insides. - What is the difference between `data` before and after adding a new todo? There are four elements show up in the array![](https://i.imgur.com/Ny7DR0b.png) . - Run the following code: ```javascript= data.push({ done: true, task: "Goto Aikido Lessons", id: getTimeStamp() }); console.dir(data); ``` - What did the code above do? This code adds another task into the array. - Does our page reflect the changes made? Why or why not? Prove it. The page reflect the change made.Once I clicked on the page, change showed up. - Does order matter in `Objects`? The order affects the sequence of tasks. - What is the difference between `Object` keys (E.g. `done`, `task`, `id`) and `Array` indices (E.g. `0`, `1`, `2`)? - How are they similar? Different console command can achieve the same goal. ```javascript= var myAry = [123, "Code", true]; var myObj = { id: 123, task: "Code", done: true } console.log(myAry[1]); console.log(myObj["task"]); console.log(myObj.task); ``` - Compare the following in the console: ```javascript= var element = document.querySelector('ul'); var author = { first: "Mark", last: "Twain" } var example = { theAnswer: 42, student: true, hobby: "Fishing", sayHello: function(){ alert("Hello"); }, favNums: [1,2,3], favAuthor: author }; console.dir(example); console.dir(element); ``` - What is an `element` really? Element is 'ul'. - How does our `element` relate in terms of similarities and differences to `example`? The element is assigned by the existing data. And the value inside the'example' are new defined. - If I wanted to call the function in the `example` object, how would I do that? Prove it. console.dir(example.sayHello); - Try the following code in the console. How does dot notation and bracket notation differ and why would you want to use one or the other? ```javascript= var x = "username"; var user = { username: "happyCat" } console.log(user.username); console.log(user["username"]); console.log(user[x]); console.log(user.x); ``` - Identify various areas where the `.` object notation is used and explain the thing on the left side of the `.` and the thing on the right side of the `.` - E.g. `document.querySelector()` `document` is... `querySelector` is... - HINT: There are MANY choices here. An example is 'todo.done'. On the left of '.' we have todo which is a defined variable and on the right side of '.' we have done which is a property in the data array. - In two areas of my code, I use what is called a `filter` function. It's a function that arrays can use like `list.pop()`, `list.push()`. - How does a filter function work? It creates a new array with filter test set. - What is the significance of the function argument that is passed INTO the filter parameters? It creates a new array with filter test set. - With regard to the function that is passed into the filter as an argument, that function must `return` a boolean or evaluate to a boolean. What is the purpose of this? To make sure each variable passed into the function either pass the filter or fail to pass the filter. - What does the _filter function_ return? E.g. `var x = list.filter(...); // What was returned to x?` - CAUTION: NOT the function argument that goes into the filter. - HINT: If you don't know, can you use console to "test" an idea out? All array elements that are 'true'. - Does filtering an array _change_ the original array? No, it dosen't. ### Part 3 Control Structures - Andrea - I use the `if` statement in several places in this code. Explain why a conditional is necessary in: - `updateTodoItems` - `updateRemoveButton` - `onEnterKey` - `validateTask` - `addTodoItem` - `getTodoData` - HINT: You might want to `console.log` the boolean condition where you see the `if` statements to understand what condition we are evaluating. ```javascript= if (booleanCondition) { ... } console.log(booleanCondition); ``` - Comment on how the boolean condition works as there are many different examples. - `updateTodoItems` ![](https://i.imgur.com/9yvJge3.png) If it's not ticked it shows false - `updateRemoveButton` ![](https://i.imgur.com/8sHhbBw.png) if it's done the count adds up - `onEnterKey` identify if the user press the enter or not - `validateTask` filter the empty input and add some actual task - `addTodoItem` ![](https://i.imgur.com/46rPlAd.png) since they are not empty(false),we can add the new tasks into the list - `getTodoData` the computer need to know the input exist in the list or not, and then it could show the data of this element. - In this code, there are two kinds of `for` loops. The more traditional that looks like: ```javascript= for (var i=0; i < list.length; i++) { // CODE } ``` and a `for of` loop that looks like: ```javascript= for (item of list) { // CODE } ``` - How does a `for of` loop work? it will go through the list and look for item, in a loop - What does the `item` represent? (It can be named anything: `x`, `item`, `thing` etc.) 'item' is the variable or element - Why are `for of` loops convenient compared to the traditional `for`? 'for of'loops can output all value and properties of one item - For what purpose(s) do I employ a `for` or `for of` loop in this program? they can go on repeat to pass the variables in the list to the function - On Facebook or Pinterest, or Twitter, how does a loop through data relate to the display of content? Users can refresh page on certain hashtags or keywords and continue finding related results ### Part 3 Specific Routines - Andrea - Take a look at the `updateTodoItems`. Comment it out and replace it with this alternate, but functionally identical version. How does this function work and how do they relate / differ? ```javscript= function updateTodoItems() { todosEl.innerHTML = ""; if (!data.length) { var liElement = document.createElement('li'); liElement.innerText = "Nothing todo..."; todosEl.appendChild(liElement); } else { for (todo of data) { var liElement = document.createElement('li'); var iElement = document.createElement('i'); liElement.id = todo.id; liElement.onclick = toggleComplete; if (todo.done) { liElement.className = "complete"; iElement.className = "fa fa-check-circle-o"; } else { iElement.className = "fa fa-circle-o"; } liElement.appendChild(iElement); liElement.innerText = todo.task; todosEl.appendChild(liElement); } } updateRemoveBtn(); } ``` ![](https://i.imgur.com/WDfBC97.png) With this new code, the radio button (**toggle complete**) in the front is gone - Take a look at the helper function `getTimeStamp`. This function will return a number, in milliseconds, the current time stamp since January 1, 1970. - I call this when I create new todo items, what are some ideas as to why I might be using a timestamp for todo `ids`? A time stamp is the number of milliseconds that have passed since January 1, 1970. As the time continues to change, we can make sure it is different everytime because it's based on the time entered - Take a look at the incomplete functions `markAllComplete` and `updateItemsLeft`. - Can you complete these and add the functionality to this app? `<h2 id="itemsLeft"></h2> ` ```javascript= //added var leftEl = document.querySelector('#itemsLeft'); function initializeTodos() { updateTodoItems(); } updateItemsLeft(); //added var completeCount = 0; data.forEach(todo => { if(todo.done == false) completeCount++; }); leftEl.innerHTML = `You have ${completeCount} left to do`; ``` ### Part 4 Debugging, Tools - Yichen Using the Chrome debugger (source) tool create breakpoints and watch the program execute line by line, part by part. Experience how this tool can give you insight into your program's _STATE_, _SEQUENCE_, _CAUSALITY_. #### Chrome Debugger - Set breakpoints at the following locations of your program - `function initializeTodos` - `function onEnterKey` - `function addTodoItem` - `function toggleComplete` - Use the `Step over the next function call` feature to watch how the program pauses during the _SEQUENCE_ of its routines. - Use the `Step into the next function call` feature to watch how the program pauses during the _SEQUENCE_ of its routines. - What is the difference between `Step over` and `Step into` and how does this help you understand programs? 'step into' is debugger goes into the next function and breaks. 'step over' debugger goes through the next function and breaks afterwrads. - Use `Step into` until you've reached the line `var inputEl = document.querySelector('input');`. Should be highlighted in blue. - Highlight the variable `todosEl` on the line before it and `right click` on it. Select _Evaluate in console_. - What does the console print? Console prints the html code. - Highlight the variable `inputEl` on this highlighted blue line. - Why does the console say `inputEl` is undefined? '<input type="text" onkeypress="onEnterKey(event)">' - When you step through your code, does the blue line represent code that is about to be executed or code that has already executed? How do you know? The blue line represents code that has already executed. - Watch how debugger annotates your source code with the updated _state_ of different variables as your program progresses. - How does the debugger behave when you enter a loop in your program? It continues the loop. - How does the debugger behave when you reach the a `filter` function call? It displays the data filtered. - What does filter do and how does it work? It creates a new array with filter test set. ### Part X: Putting all together **Explain the program line by line with sufficient details, part by part.** :::success - Line by line - Part by part - Be sure to copy blocks of code into this markdown using code formatting/fences as references to your explanations. - For repetitive code, you can explain how a line works then summarize how it would work for the rest. ::: **Make it yours (group's)** :::success - Try to extend this program to do something cool, as a group, your own original idea(s). - What is something that a Todo list or todo list user might benefit from? The todo list can be used in many different ways. For example, in games, players will be given a list of tasks they can finish to upgrade, so game designers can use this code. It can just be used as a daily record of our lives. It is useful for us to keep track. And once we finish something we can cross it out and gain a sense of achievement. :::