1577198588

Today we are going to show how to use javaScript Math.round Methods & how it works. We will give a simple example of math.round function.

The JavaScript Math.round() function is inbuild javascript function, which is used for returns the value of a given number to the nearest integer.

- JavaScript Math.round() Syntax
- Math.round() Method Example

```
Math.round(var);
```

This above syntax, you will be see function accepts a single parameter. This is the number that you want to round.

Below we are going to show you some of the javascript math.round() examples.

In this math.round () function example, we have passed the value in math.round function 6.6 and this function will round off our value and return it to us 7

```
var round =Math.round(6.6);
document.write("Number After Round : " + round);
```

Let’s see with nagetive value example – In this math.round () function, we have passed the nagetive value in math.round function -6.6 and this function will round off our value and return it to us -7

```
var round =Math.round(-6.6);
document.write("Number After Round : " + round);
```

#javascript #programming

1624298400

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:04:23 Comment Your Code

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:05 Add Two Numbers

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:18:22 Augmented Addition

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:55:31 Spread 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)**!

☞ **-----CLICK HERE-----**⭐ ⭐ ⭐

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

1596632340

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.

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.

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

1599748140

Javascript **Math.round()** is an inbuilt function that returns the value of a number rounded to the nearest integer. If the fractional portion of an argument is more than 0.5, the argument is turned to an integer with the next higher absolute value. If it is less than 0.5, then the argument is rounded to the integer with the lower value. If the fractional portion is exactly 0.5, then the argument is rounded to the next integer in the direction of +∞.

The syntax of Math.round() is following.

```
Math.round(x)
```

Where **x** is a number. The value of a given number rounded to the nearest integer.

#javascript #math.round #js math.round

1605017502

Other then the syntactical differences. The main difference is the way the this keyword behaves? In an arrow function, the this keyword remains the same throughout the life-cycle of the function and is always bound to the value of this in the closest non-arrow parent function. Arrow functions can never be constructor functions so they can never be invoked with the new keyword. And they can never have duplicate named parameters like a regular function not using strict mode.

this.name = "Bob";const person = {

name: “Jon”,`<span style="color: #008000">// Regular function</span> func1: <span style="color: #0000ff">function</span> () { console.log(<span style="color: #0000ff">this</span>); }, <span style="color: #008000">// Arrow function</span> func2: () => { console.log(<span style="color: #0000ff">this</span>); }`

}

person.func1(); // Call the Regular function

// Output: {name:“Jon”, func1:[Function: func1], func2:[Function: func2]}person.func2(); // Call the Arrow function

// Output: {name:“Bob”}

const person = (name) => console.log("Your name is " + name); const bob = new person("Bob"); // Uncaught TypeError: person is not a constructor

#arrow functions #javascript #regular functions #arrow functions vs normal functions #difference between functions and arrow functions

1596861540

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.

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