日韩欧美人妻无码精品白浆,夜夜嗨AV免费入口,国产欧美官网在线看,高校回应聋哑女生因长相完美被质疑

運算符

JavaScript 運算符是真的多，尤其是 ES6 之后還在不停的加運算符，其他編程語言看 JS 就像怪物一樣，各種騷操作不斷~~

運算符分類

1、算術運算符

算術運算符的作用就是用來基礎計算，跟小學課本一樣，包含：加 +，減 -，乘 *，除 /，取余（也叫做取模） %，指數(shù) **，自增 ++，自減 --。

只是需注意：乘號不再是 x，除號也不再是 ÷！

與我們學過的運算法則一樣，乘法與除法優(yōu)先級比加減法高，如果要改變優(yōu)先級，需要使用括號 ()，只是一個算式中有多個括號還是使用小括號，不用中括號而已。

// 加法
console.log(3 + 5); // 8
console.log(3 + '5'); // '35'（字符串拼接）
// 減法、乘法、除法
console.log(10 - 3); // 7
console.log(2 * 4); // 8
console.log(10 / 2); // 5
// 取余、指數(shù)
console.log(10 % 3); // 1（余數(shù)）
console.log(2 ** 3); // 8（2的3次方）
// 自增/自減（注意前置與后置）
let a = 5;
console.log(a++); // 5（先返回原值，再自增）
console.log(++a); // 7（先自增，再返回新值）
// 使用括號改變優(yōu)先級
console.log((2 + 3) * 4); // 5 * 4 = 20
console.log(((2 + 3) - (5 -3)) * 4); // (5 - 2) * 4 = 12

2、比較運算符

一般用于邏輯比較，比如比較兩個值是否相等，比較兩個數(shù)的大小等等。包含：等于 ==，嚴格等于（全等于） ===，不等于 !=，嚴格不等于（不全等） !==，大于 >，小于 <，大于等于 >=，小于等于 <=

需特別注意：== 與 != 會存在類型轉換，所以 JS 建議使用 === 與 !==。

// 松散比較（類型轉換）
console.log(5 == '5');    // true（值相等）
console.log(0 == false);    // true（0和false在松散比較中等價）
console.log(5 != '5');    // false（值相等）
// 嚴格比較（值和類型）
console.log(5 === '5');    // false（類型不同）
console.log(0 === false);    // false（類型不同）
console.log(5 !== '5');    // true（類型不同）
// 其他比較
console.log(3 > 2);    // true
console.log('apple' > 'banana');    // false（按字母順序比較）
console.log(2 >= 2);    // true
console.log(2 <= 2);    // true

如果要比較值類型不同，建議顯示轉換類型再用 === 比較。比如：

const a = 5;
const b = '5';
if (a + '' === '5') {} // 將 a 轉換為字符串再比較
if (b - 0 === 5) {} // 將 b 轉換為數(shù)字再比較

3、邏輯運算符

用于邏輯判斷，包含：邏輯與 &&，邏輯或 ||，邏輯非 !。

需注意他們的短路特性。

// 邏輯與（&&）：短路特性
console.log(true && 'Hello');    // 'Hello'（返回最后一個真值）
console.log(false && 'Hello');   // false（遇到假值直接返回）
// 邏輯或（||）：短路特性
console.log(0 || 'default');     // 'default'（返回第一個真值）
console.log('A' || 'B');         // 'A'
// 邏輯非（!）
console.log(!true);              // false
console.log(!!'非空字符串');      // true（強制轉布爾值）
// 應用場景
// 默認值設置
function greet(name) {
  name = name || 'Guest';      // 若 name 為假值，返回 'Guest'
  console.log(`Hello, ${name}!`);
}
greet();                       // 'Hello, Guest!'
// 條件執(zhí)行函數(shù)
true && console.log('執(zhí)行了!'); // 輸出 '執(zhí)行了!'
false || console.log('執(zhí)行了!'); // 輸出 '執(zhí)行了!'

4、賦值運算符

用于給變量賦值，包含：賦值（等于） =，加等于（累加） +=，減等于（累減） -=，乘等于（累乘） *=，除等于（累除） /=，模等于（累模） %=，冪等于（累冪） **=。

let x = 10;
x += 5;   // x = x + 5 → 15
x *= 2;   // x = 15 * 2 → 30
x **= 2;  // x = 30^2 → 900
console.log(x); // 900

5、位運算符

二進制的位運算符，據(jù)說是最快的運算符，當然一般編程用不上，如果您用 JS 進行大量的計算操作時，比如：圖形圖像算法、加密算法等相關操作，這時候就必須需掌握位運算了！包含：按位與 &，按位或 |，按位異或 ^，按位非 ~，左移 <<，右移 >>，無符號右移 >>>。

這部分運算符涉及到底層的二進制運算，如果有興趣可以查找相關資料學習。

// 按位與（&）
console.log(5 & 3);      // 1（二進制 101 & 011 → 001）
// 按位或（|）
console.log(5 | 3);      // 7（101 | 011 → 111）
// 無符號右移（>>>）
console.log(-1 >>> 0);   // 4294967295（將負數(shù)轉為無符號整數(shù)）

6、三元運算符

又稱為三目運算符（吐槽下：亂七八糟的名字特多），一般用于簡化 if else 語句，但不建議過多嵌套，要不然代碼閱讀起來費勁。

語法：condition ? expr1 : expr2。

const age = 20;
const canVote = age >= 18 ? 'Yes' : 'No';
console.log(canVote); // 'Yes'
// 等價于
if (age >= 18) {
  console.log('Yes');
} else {
  console.log('No');
}
// 三元運算符的多次嵌套
const a = age > 80 ? '高齡老人' : (age > 60 ? '老年人' : (age > 40 ? '中年人' : '年輕人'))

可以看看多次嵌套的代碼是否是難以閱讀，為了項目的可維護性，真心不建議把三元運算符用于多次嵌套。

7、特殊運算符

JS 內置的關鍵字，包含：typeof， instanceof， delete， void， in， new。

// typeof 返回變量的類型字符串
console.log(typeof 42);          // 'number'
console.log(typeof null);        // 'object'（歷史遺留問題）
// instanceof 檢查對象是否是某個構造函數(shù)的實例（基于原型鏈）
class Person {}
const p = new Person();
console.log(p instanceof Person); // true
// delete 刪除對象的屬性或數(shù)組元素（對變量無效）
const obj = { a: 1 };
delete obj.a;                   // 刪除屬性
console.log(obj.a);             // undefined
// void 執(zhí)行表達式并返回 undefined
console.log(void (1 + 1));          // undefined 
// in 檢查對象或其原型鏈中是否包含指定屬性
console.log('toString' in obj);     // true（繼承自Object.prototype）
// new 創(chuàng)建構造函數(shù)實例（調用構造函數(shù)，綁定 this）
function Car(brand) {  
  this.brand = brand;  
}  
const myCar = new Car('Tesla');  
console.log(myCar.brand);           // 'Tesla'  
/* 等價于以下過程：
1. 創(chuàng)建一個空對象 {}
2. 將空對象的原型指向 Car.prototype
3. 執(zhí)行 Car 函數(shù)，this 指向該空對象
4. 返回新對象   */

8、ES6+ 運算符

ES6 之后新增的一些運算符，騷操作從這里開始。包含：展開運算符 ..., 可選鏈 ?., 空值合并 ??

// 展開運算符（...）
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5, 6];
console.log(...arr1); // 1 2 3
console.log(arr2); // [1, 2, 3, 4, 5, 6]
// 可選鏈（?.）
const user = { address: { city: 'Paris' } };
console.log(user?.address?.city);     // 'Paris'
console.log(user?.phone?.number);     // undefined（不會報錯）
// 空值合并（??）
const input = null;
const value = input ?? 'default';     // 'default'（僅針對 null/undefined）

類型轉換規(guī)則

當操作數(shù)類型不同時，JS 會按內部規(guī)則嘗試進行類型轉換：

const obj = { toString: () => '100' };
// 調用 valueOf() → toString()，若結果為原始值則繼續(xù)比較
console.log(obj > 50); // true（'100' → 100 > 50）
// true → 1，false → 0
console.log(true > -1); // true（1 > -1）
console.log(false < 1);  // true（0 < 1）
// null → 0
console.log(null > -1); // true（0 > -1）
// undefined → NaN
console.log(undefined > 0); // false（NaN 與任何值比較均為 false）
// 若字符串為合法數(shù)字 → 轉換為數(shù)字，否則 → NaN
console.log('123' > 50);   // true（123 > 50）
console.log('abc' > 0);    // false（'abc' → NaN）
// 對象與非對象比較
const arr = [10];
console.log(arr > 5); // true（[10].toString() → '10' → 10 > 5）
// 十六進制字符串
console.log('0x1f' > 30); // true（'0x1f' → 31 > 30）
// 空字符串與 0
console.log('' > -1);     // true（'' → 0 > -1）
console.log(0 == '');     // true（0 == 0）
// 布爾值的陷阱
console.log(true == '1');   // true（1 == 1）
console.log(false == '0');  // true（0 == 0）
console.log([1] > 0);      // true（[1].toString() → '1' → 1 > 0）
console.log([] > -1);      // true（[].toString() → '' → 0 > -1）
console.log([] == 0);      // true（0 == 0）
console.log([] == false);  // true（0 == 0）

常見問題

1、== 和 === 的區(qū)別是什么？

答：== 會進行類型轉換后比較，=== 嚴格比較值和類型。

2、邏輯運算符 && 和 || 的返回值是什么？

答：返回第一個決定表達式結果的子表達式值（短路求值）。

3、1 + '1' 和 '1' + 1 的結果是什么？

答：均為 '11'（字符串拼接）。

4、0 == false 和 '' == false 的結果是什么？為什么？

答：均為 true，因 == 會進行隱式轉換。

5、typeof null 返回什么？為什么？

答：'object'（歷史遺留問題）。

6、可選鏈 ?. 和空值合并 ?? 的作用是什么？

答：obj?.prop 避免訪問 null/undefined，a ?? b 僅在 a 為 null/undefined 時返回 b。

7、以下代碼的輸出是什么？

console.log(1 < 2 < 3); // true（等價于 (1 < 2) < 3 → true < 3 → 1 < 3 → true）
console.log(3 > 2 > 1); // false（等價于 (3 > 2) > 1 → true > 1 → 1 > 1 → false）

8、console.log(!!' ') 的輸出是什么？

答：true（非空字符串轉布爾值為 true）。

9、如何用短路求值簡化代碼？

const value = input || defaultValue;

10、如何安全訪問嵌套對象屬性？

答：使用可選鏈 obj?.a?.b ?? 'default'。

寫在最后

優(yōu)先使用 === 和 !== 避免 JS 的隱式轉換帶來的不確定性。

隱式轉換機制需特別注意，特別是在處理用戶輸入、API 接口響應數(shù)據(jù)時，稍不注意就掉坑了！！

如果您有大量計算工作量，那么必須啃書二進制的位運算符，否則使用十進制運算會拖慢程序運行速度。

轉自https://www.cnblogs.com/linx/p/18896521