1604893680

# Learn JavaScript the FUN way with CODR

In this lesson we look at a fun way to learn JavaScript in the form of codr.

There is active learning where you write code, and then there is passive learning where you review code. Codr sits in the middle, you are passive in that you are not writing code, but active in that you have to debug the code that is on screen.

This video is not sponsored by codr but they did reach out to me to see if it would be worthwhile sharing it with my audience. I did find it an interesting way of learning and teaching so here we go š¹

Codr: https://nevolin.be/codr/

#javascript #web-development #programming #developer

1624298400

## Learn JavaScript - Full Course for Beginners. DO NOT MISS!!!

This complete 134-part JavaScript tutorial for beginners will teach you everything you need to know to get started with the JavaScript programming language.
ā­ļøCourse Contentsā­ļø
0:00:00 Introduction
0:01:24 Running JavaScript
0:05:56 Declare Variables
0:06:15 Storing Values with the Assignment Operator
0:11:31 Initializing Variables with the Assignment Operator
0:11:58 Uninitialized Variables
0:12:40 Case Sensitivity in Variables
0:14:34 Subtract One Number from Another
0:14:52 Multiply Two Numbers
0:15:12 Dividing Numbers
0:15:30 Increment
0:15:58 Decrement
0:16:22 Decimal Numbers
0:16:48 Multiply Two Decimals
0:17:18 Divide Decimals
0:17:33 Finding a Remainder
0:19:22 Augmented Subtraction
0:20:18 Augmented Multiplication
0:20:51 Augmented Division
0:21:19 Declare String Variables
0:22:01 Escaping Literal Quotes
0:23:44 Quoting Strings with Single Quotes
0:25:18 Escape Sequences
0:26:46 Plus Operator
0:27:49 Plus Equals Operator
0:29:01 Constructing Strings with Variables
0:30:14 Appending Variables to Strings
0:31:11 Length of a String
0:32:01 Bracket Notation
0:33:27 Understand String Immutability
0:34:23 Find the Nth Character
0:34:51 Find the Last Character
0:35:48 Find the Nth-to-Last Character
0:36:28 Word Blanks
0:40:44 Arrays
0:41:43 Nest Arrays
0:42:33 Access Array Data
0:43:34 Modify Array Data
0:44:48 Access Multi-Dimensional Arrays
0:46:30 push()
0:47:29 pop()
0:48:33 shift()
0:49:23 unshift()
0:50:36 Shopping List
0:51:41 Write Reusable with Functions
0:53:41 Arguments
0:55:43 Global Scope
0:59:31 Local Scope
1:00:46 Global vs Local Scope in Functions
1:02:40 Return a Value from a Function
1:03:55 Undefined Value returned
1:04:52 Assignment with a Returned Value
1:05:52 Stand in Line
1:08:41 Boolean Values
1:09:24 If Statements
1:11:51 Equality Operator
1:13:18 Strict Equality Operator
1:14:43 Comparing different values
1:15:38 Inequality Operator
1:16:20 Strict Inequality Operator
1:17:05 Greater Than Operator
1:17:39 Greater Than Or Equal To Operator
1:18:09 Less Than Operator
1:18:44 Less Than Or Equal To Operator
1:19:17 And Operator
1:20:41 Or Operator
1:21:37 Else Statements
1:22:27 Else If Statements
1:23:30 Logical Order in If Else Statements
1:24:45 Chaining If Else Statements
1:27:45 Golf Code
1:32:15 Switch Statements
1:35:46 Default Option in Switch Statements
1:37:23 Identical Options in Switch Statements
1:39:20 Replacing If Else Chains with Switch
1:41:11 Returning Boolean Values from Functions
1:42:20 Return Early Pattern for Functions
1:43:38 Counting Cards
1:49:11 Build Objects
1:50:46 Dot Notation
1:51:33 Bracket Notation
1:52:47 Variables
1:53:34 Updating Object Properties
1:54:30 Add New Properties to Object
1:55:19 Delete Properties from Object
1:55:54 Objects for Lookups
1:57:43 Testing Objects for Properties
1:59:15 Manipulating Complex Objects
2:01:00 Nested Objects
2:01:53 Nested Arrays
2:03:06 Record Collection
2:10:15 While Loops
2:11:35 For Loops
2:13:56 Odd Numbers With a For Loop
2:15:28 Count Backwards With a For Loop
2:17:08 Iterate Through an Array with a For Loop
2:19:43 Nesting For Loops
2:22:45 Doā¦While Loops
2:24:12 Profile Lookup
2:28:18 Random Fractions
2:28:54 Random Whole Numbers
2:30:21 Random Whole Numbers within a Range
2:31:46 parseInt Function
2:32:36 parseInt Function with a Radix
2:33:29 Ternary Operator
2:34:57 Multiple Ternary Operators
2:36:57 var vs let
2:39:02 var vs let scopes
2:41:32 const Keyword
2:43:40 Mutate an Array Declared with const
2:44:52 Prevent Object Mutation
2:47:17 Arrow Functions
2:28:24 Arrow Functions with Parameters
2:49:27 Higher Order Arrow Functions
2:53:04 Default Parameters
2:54:00 Rest Operator
2:57:18 Destructuring Assignment: Objects
3:00:18 Destructuring Assignment: Nested Objects
3:01:55 Destructuring Assignment: Arrays
3:03:40 Destructuring Assignment with Rest Operator to Reassign Array
3:05:05 Destructuring Assignment to Pass an Object
3:06:39 Template Literals
3:10:43 Simple Fields
3:12:24 Declarative Functions
3:12:56 class Syntax
3:15:11 getters and setters
3:20:25 import vs require
3:22:33 export
3:23:40 * to Import
3:24:50 export default
3:25:26 Import a Default Export
šŗ The video in this post was made by freeCodeCamp.org
The origin of the article: https://www.youtube.com/watch?v=PkZNo7MFNFg&list=PLWKjhJtqVAblfum5WiQblKPwIbqYXkDoC&index=4

š„ If youāre a beginner. I believe the article below will be useful to you ā What You Should Know Before Investing in Cryptocurrency - For Beginner
ā­ ā­ ā­The project is of interest to the community. Join to Get free āGEEK coinā (GEEKCASH coin)!
Thanks for visiting and watching! Please donāt forget to leave a like, comment and share!

#javascript #learn javascript #learn javascript for beginners #learn javascript - full course for beginners #javascript programming language

1596861540

## Learning JavaScript: Working with Strings

Strings are the second most common data type used in JavaScript, and in many cases, since JavaScript is so widely used for web applications, it is the prominent data type. In this article Iāll discuss how strings work in JavaScript and how to work with them efficiently and effectively. Iāll also discuss some newer abilities of strings that are just being discovered and used.

# Strings Defined

A string is any set of 0 or more characters enclosed in either single quotes or double quotes. The characters in a string can be alphabetic characters, numbers, symbols, and spaces. Here are some examples of JavaScript string literals:

``````"hello world"
'good bye, world!'
"1600 Pennsylvania Avenue"
'\$*&!@ it!'
``````

If you are using single quotes in your string, and you need to embed a single quote to write out a contraction, you use the backslash character (`\`) as an escape character. To see why you need to do this, letās look at what happens when you donāt escape a single quote by writing out such a string in the JavaScript shell:

``````js> 'can't'
typein:1:5 SyntaxError: unexpected token: identifier:
typein:1:5 'can't'
typein:1:5 .....^
``````

The interpreter canāt figure out what to do with the ātā after the single quote.

Now watch what happens when we escape the single quote:

``````js> 'can\'t'
"can't"
``````

The escape character tells the interpreter to treat the single quote as an apostrophe and not as an āend-of-stringā character.

You can embed other characters into a string, including the newline character (`\n`) and the tab character (`\t`). Here are some examples using the shell:

``````js> print("Hello, \n world!");
Hello,
world!
js> print("Hello, \tworld");
Hello,  world

``````

#javascript-training #learn-to-code #learn-to-program #javascript #javascript-tutorial #deep learning

1599072060

## Learning JavaScript: Computing with Object Methods

JavaScript has a set of built-in methods you can use with your user-defined objects. In this article Iām going to discuss several of these methods and how you can use them in your JavaScript programs.

## Object.assign

The `Object.assign` method is used to make a copy of one object into another object. The syntax template for this method is:

Object.assign(target, source);

where source is the object you are copying from and target is the object you are copying into. This method returns the target object if you want to assign it.

Here is a sample program that demonstrates how to use `Object.assign`:

``````function Student(name, id, grades) {
this.name = name;
this.id = id;
}
let st1 = new Student("",0,[]);
et st2 = new Student("Jane Doe", 123, [91, 92, 93]);
Object.assign(st1, st2);
``````

The output from this program is:

``````Jane Doe, 123
[91, 92, 93]
``````

A good reason to use this method is to make sure that a new object has all the properties and values of the old object. You may accidentally leave something out when writing your own method, while `Object.assign` will systematically make sure all properties and values are assigned to the new object.

## Object.create

The `Object.create` method creates a new object from an existing object prototype. Here is the syntax template for this method:

const|let|var object-name = Object.create(existing-object);

Letās look at a few examples to see how this method works in practice. The first example creates a new object from a function and then creates a second object using `Object.create`:

``````function Student(name, id, grades) {
this.name = name;
this.id = id;
}
let st1 = new Student("Bob Green", 1234, [81, 77, 92]);
let st2 = Object.create(st1);
``````

The output from this program is:

``````Bob Green, 1234
81,77,92
Bob Green, 1234
81,77,92
``````

Code must be written to change the properties of the newly created object.

#learn-to-code #javascript-development #learn-to-program #javascript #learning-javascript

1596632340

## Learning JavaScript: Statements, Arithmetic, and Math

In this article I will discuss how to perform arithmetic and more advanced mathematical operations in JavaScript. First, though, I need to discuss how statements are formed and used in JavaScript.

# Statements

JavaScript programs are made up of statements. A statement can be anything from a single function call or command to even just a variable name. JavaScript evaluates statements and then executes them.

For example, when you create a variable, you write a statement:

``````let number = 100;
``````

JavaScript recognizes this as a statement and evaluates it by following its grammar rules. In this case the rule is to assign the expression on the right-hand sign of the assignment operator to the variable on the left-hand side.

As I mentioned above, a statement can be just an expression, as in the following example:

``````js> 1;
1
``````

You can do the same thing with a variable:

``````js> let name = "Brendan";
js> name
"Brendan"
``````

Statements can be much more complicated than these examples, though, as youāll learn as you get deeper into JavaScript. So far, you have seen examples of two types of statements ā variable declaration and assignment statements and print statements.

# JavaScript Arithmetic

Arithmetic is performed in JavaScript using the arithmetic operators. There are five arithmetic operators:

• `+` (Addition)
• `-` (Subtraction)
• `*` (Multiplication)
• `/` (Division)
• `%` (Modulo/Remainder)

These operators are binary operators, meaning there must be values on either side of the operator. The `+` operator and the `-`operator can also be used as unary operators, in which can they are used to distinguish the sign (positive or negative) of a number.

The JavaScript arithmetic operators also have an order of operations, or precedence, they follow when used in a statement. The order of operations is: 1) modulo; 2) multiplication and division; 3) addition and subtraction.

You can use parentheses to modify the order of operations. When an arithmetic expression is placed inside parentheses, that expression is evaluated before any other operations.

For example, take the expression:

``````let n = 100 + 3 * 22;
``````

Does `n` get the value 2266, 103 * 26, or does the variable get the value 166? Without parentheses the value of `n` is 166 because the multiplication takes place before the addition due to the precedence of the multiplication operator over the addition operator.

#learn-to-code #learning-javascript #javascript #learn-to-program #deep learning

1598605800

## Learning JavaScript: Working with Objectsāāāthis, getters, and setters

JavaScript objects provide the reader with some special features that make object-based programmer more effective and more efficient. In this article Iām going to describe three of these features ā the `this` keyword, getters, and setters.

## The this Keyword

If there was ever a more confusing keyword in computer programming than the`this`keyword, I donāt know what it is. However, the concept behind `this` is not really that hard to understand. The keyword `this` refers to the current object that is in reference where the code using it is executed.

Examples are often better than explanations, so here is an example. First, letās write an object constructor function and a short program to test it:

``````function Person(n, a) {
this.name = n;
this.age = a;
}
let me = new Person("Mike", 63);
print(me.name + ", " + me.age);
``````

The output from this program is:

``````Mike, 63
``````

The `this` keyword is used to reference the current object properties in memory when the code is running. You can translate it as āassign the value in n to the name property of this particular object.ā

Another great use of `this` is to disambiguate code where the property name is the same as the parameter name, as in this rewrite of the constructor function:

``````function Person(name, age) {
this.name = name;
this.age = age;
}
``````

You canāt leave the `this `keyword out of a constructor definition but it still helps make the code clearer to the reader.

The `this` keyword plays an important role in working with objects in JavaScript and I hope Iāve made its use clearer to you.

#javascript-development #learning-javascript #learn-to-code #javascript #learn-to-program