Cold rice fried new - javascript base 2

Posted by ozzysworld on Wed, 08 May 2019 00:00:03 +0200

JavaScript Foundation 2

Learning objectives:

  1. Operators in JavaScript

Expressions and Statements

Expression

An expression can produce a value, possibly an operation, a function call, a literal quantity, and so on.Expressions can be placed anywhere you want.

For example: 5+6

Sentence

Statements can be understood as an action, and looping and judging statements are the most classic ones.A program consists of many statements.A statement, usually ending with; orIt is not recommended to omit.

Operator

Operator, also known as operator

Expressions generally consist of operators and operands (common expressions)

Arithmetic Operators

Add, subtract, multiply and divide inside math

// + - * / %
// Same as in math
var x = 5;
var y = 10;
console.log(x + y);
console.log(x - y);
console.log(x * y);
console.log(x / y);
console.log(x % y);

// Two more special
console.log(x/0); // Infinity
console.log(x % 0 ); // NaN

Unary operator

An operator with only one operand is called a unary operator

Operators that can carry two operands are called binary operators, so all the previous lessons are binary operators.

// ++ Self+1
// --Self-1
var num = 5;
console.log(++num);  // 6
console.log(--num);  // 5

++ num is first an expression, and since it is an expression, it has a return value.

The difference between the front and back is this return value

  • Front

Let the operand itself + 1 (-1) before returning the result of the operation.

var num  = 5;
console.log(++num);// 6;
console.log(num); // 6
var num1 = 7;
console.log(num + ++num1);//14   6+8
console.log(num1);// 8

console.log(--num1);// 7
  • Rear

Return the result of the operand first, then + 1 (-1) for the operand itself

var num = 5;
console.log(num++);// 5
console.log(num);//6
var num1  = 7;
console.log(num + num1++); // 6+7 13
console.log(num1);// 8
  • Consolidation exercises
var a = 1;var b= ++a + ++a;console.log(b);//2 + 3 b=5
var a = 1;var b= a++ + ++a;console.log(b);//1 + 3(++a before a became 2) b=4
var a = 1;var b = a++ + a++;console.log(b);// 1 + 2 b=3
var a = 1;var b = ++a + a++;console.log(b);// 2 + 2 b=4

Logical operators

Logical operators are also called Boolean operators.

  • && (Logical AND): Both operands are true, resulting in true, otherwise false.also
  • || (logical or): One of the two operands is true, resulting in true, otherwise false.
  • ! (Logical NOT): Reverse
// Logical Operators and &&or||Not!
var a = true;
var b = false;
console.log(a && b);
console.log(a || b);
console.log(!a)

When do I use logical operators?

When judgment or looping is needed in the future, a large number of logical operations will be used.

Implicit Conversion of Boolean Types
var num = 123;
console.log(Boolean(num));// Cast

// Implicit Conversion
// Case 0,'',NaN,undefined,null in case 5 converted to false
if(num){
    console.log('Conversion Successful');
}
var msg;
if(msg){
    console.log('true');
}else{
    console.log('false');
}
//Determine whether a variable exists
//console.log(typeof aaa === 'undefined');

// Implicit Conversion Using None
var str = 'Ha-ha';
var isOk = !!str; //  true, reverse false, reverse
console.log(isOk);

Relational Operators

The relational operator is also called the comparison operator

The return value used to compare the size of two numbers or the difference is a Boolean type

> ,<, >=,<= ,== ,!= ,=== ,!==

var a = 10;
var b = 5;
var c = '10';

// Compare the sizes of two numbers to return a Boolean value
console.log(a>b);
console.log(a<b);

// When they are equal,
// == !=
console.log(a==b);
console.log(a!=b);
//==Determines whether the values of variables are equal, regardless of type
//===Determine whether the types are the same before they are equal
//For strictness, always recommend ===
console.log(a==c);
// === !==
console.log(a===b);
console.log(a!==b);
// Returns true only if both values and data types are the same
console.log(a===c);

==Determines whether the values of variables are equal, regardless of type
===Determine whether the types are the same before they are equal
For strictness, always recommend ===

Assignment Operators

= ,+= ,-= , *= ,/= ,%=

var num = 5;
var num1 = num * 5; 
// Simplified grammar
num1++; // Self-increasing 1
num1 = num1 + 5; // Self-increasing 5
// Simplified grammar
num1 += 5; //  Equivalent to Above
// Same as
num1 -= 5;
num1 *= 5;
num1 /= 5;
num1 %= 5;

Operator precedence

Operator precedence

  1. () highest priority
  2. Unary operator ++ -!
  3. Arithmetic operators */% before + -
  4. Relational Operator > >= < <=
  5. Relational Operator==!=====!==
  6. Logical Operator First &&Then||
  7. Assignment Operators
// Exercise 1
4 >= 6 || 'people' != 'Avatar' && !(12 * 2 == 144) && true;
//Parse first step parentheses
(4 >= 6) || ('people' != 'Avatar') && (!(12 * 2 == 144)) && true;
//Step 2
(4 >= 6) || ('people' != 'Avatar') && (!(24 == 144)) && true;
//Step 3
(4 >= 6) || ('people' != 'Avatar') && (!false) && true;
//Step 4
(4 >= 6) || ('people' != 'Avatar') && true && true;
//Step 5
false || true && true && true;
//Step 6
false || true;
//Step 7
true;

// Exercise 2
var num = 10;
5 == num / 2 && (2 + 2 * num).toString() === '22';
//Parse first step parentheses
(5 == num / 2) && ((2 + 2 * num).toString() === '22');
//Step 2
(5 == 5) && ((2 + 20).toString() === '22');
//Step 3
true && (22.toString() === '22');
//Step 4
true && ('22' === '22');
//Step 5
true && true;
//Step 6
true;

Topics: Javascript

Hot Topics

©2025 Programmer Think