摘要：基礎標識符所謂的標識符就是指變量函數屬性的名字，或者函數的參數。原始數組不會被改變。刪除或替換現(xiàn)有元素來修改數組并以數組形式返回被修改的內容。否則返回返回在數組中可以找到一個給定元素的第一個索引，如果不存在，則返回。

所謂的標識符,就是指變量、函數、屬性的名字，或者函數的參數。標識符主要有以下規(guī)則：

首字符必須是字母、下劃線_或者美元符$

其他字符可以是字母、下劃線_、美元符$或者數字

標識符的命名遵循駝峰命名，即myCar

用var操作符定義的變量將成為定義該變量的作用域中的局部變量.也就是說,如果在函數中使用var定義一個變量,那么這個變量在函數退出后就會被銷毀,如:

function test() {
  var message = "hi";
}
test();
console.log(message); //錯誤

a = 5 // 省略var操作符,創(chuàng)建的是一個全局變量

基本數據類型: number, string, boolean, undefined, symbol, null

復雜數據類型: object (三種引用類型: function, arrary, object)

特殊值: NaN, undefined, null

NaN有以下兩個特點:

1.任何涉及NaN的操作都會返回NaN,包括NaN/0 // NaN.

2.NaN與任何值都不相等,包括NaN本身,NaN==NaN // false.

鑒于上面兩點,判斷一個變量是否是NaN需要使用javascript提供的isNaN()方法,例: NaN.isNaN() // true

undefined聲明但是沒有初始化的變量的值即為undefined,可以理解為此處應該有一個值,但是實際上沒有,我們給它一個默認值undefined

// 聲明的變量
var a; //相當于var a=undefined;
console.log(typeof a); //undefiend

// 注意一下未聲明的變量會直接報錯的
console.log(b); //!報錯 b is not defined

null是表示缺少的標識，指示變量未指向任何對象，如果定義的變量準備在將來用于保存對象時，那么最好將變量初始化為null

typeof操作符返回一個字符串，表示未經計算的操作數的類型

let s = Symbol
typeof 5 ---------> number
typeof NaN -------> number
typeof "a" -------> string
typeof true ------> boolean
typeof undefined -> undefined
typeof s ---------> symbol

let fn = function() {}
typeof null ------> object
typeof [] --------> object
typeof {} --------> object
typeof fn --------> function

instanceof運算符用于測試構造函數的prototype屬性是否出現(xiàn)在對象的原型鏈中的任何位置

基本類型使用字面量賦值,使用instanceof并不能判斷其變量類型,因為字面量就是我們所見到的字符,沒有調用構造函數,也就不能在原型上找到

let a = 5
a instanceof Number // false

let b = false
b instanceof Boolean // false

let c = Symbol
c instanceof Symbol // false

但是復雜類型使用字面量賦值時,往往能判斷其變量類型,這是因為在js中根本不存在真正的空對象，即使是最簡單的{}對象也會包含從Object.prototype繼承而來的屬性和方法

let obj = {}
obj instanceof Object // true
[] instanceof Array // true

// 注意
null instanceof Object // false

所有的對象都有toLoacleString(),toString(),valueOf()

# 1.Number
    number.isNaN() // 判斷是否是NaN
    number.toFixed(2) // 保留小數點后兩位
    number.toString() // 將數字轉換成字符串
    
    Number可以配合Math對象來使用
    Math.random() // 隨機取0-1的數
    Math.abs(number) // 取絕對值
    Math.round(number) // 四舍五入
    Math.floor(number) // 向下取整
    Math.ceil(number) // 向上取整
    
# 2.String
    string.replace(searchValue, replaceValue) // 找到searchValue,只會在第一次的時候換成replaceValue,searchValue可以是正則表達式
    "abcda".replace("a", "b") // "bbcda"
    "abcda".replace(/a/g,"b") // "bbcdb"
    
    string.slice(start, end) // 從索引start到end的字符串,end可以為負數,負數表示倒數 
    "abcd".slice(0,3) //"abc"
    "abcd".slice(0,-1) //"abc"
    
    string.split(".") // 以.分割字符串,結果為一個數組[] 
    "192.168.1.0".split(".") // ["192", "168", "1", "0"]
    
# 3.Array
    Array.isArray(arr) // 檢測數組 true/false
    
    arr.concat() 方法用于連接兩個或多個數組
    array.join(".") // 將數組的每一項轉換成字符串,并用.連接
    ["192", "168", "1", "0"].join(".") // "192.168.1.0"
    
    let arr = [1, 2, 3, 4] // 以下arr默認都是 [1, 2, 3, 4] 后進先出叫棧,先進先出叫堆
    
    arr.slice(0,2) //[1,2] 返回一個新的數組對象，這一對象是一個由 begin和 end（不包括end）決定的原數組的淺拷貝。原始數組不會被改變。
    
    arr.splice(start, number, addItem) // 刪除或替換現(xiàn)有元素來修改數組,并以數組形式返回被修改的內容。此方法會改變原數組。
    arr.splice(0, 2, 3) // [3, 3, 4] // 從索引為0的位置刪除兩項(1,2),并插入一項(3)
    
    // 棧方法
    arr.unshift(0) // arr變成了[0, 1, 2, 3, 4],  修改數組長度,將0放到了數組的第一項
    arr.pop() // 3 修改數組長度,移除數組的最后一項并返回 arr變成了[1, 2, 3]
    
    // 堆方法
    arr.shift() // 1 修改數組長度,數組的第一項并返回 arr變成了[2, 3, 4]
    arr.push(5) // arr變成了[1, 2, 3, 4, 5], 修改數組長度,將5放到了數組的最后一項
    
    // 重排序
    arr.sort() // 首字符排列
    arr.sort((a,b) => a-b) // a-b從小到大, b-a從大到小
    
    arr.reverse() // 順序顛倒
    
    arr.filter(item => item >= 2) // [3, 4], 過濾數組元素生產新的數組,,不改變原數組
    
    // react 常用
    arr.map(item => item+1 ) //[2, 3, 4, 5] 對數組中的每個元素進行處理，得到新的數組,不改變原數組
    arr.map((item,index) => 
{item}
) //react中常用, jsx語法
    
    arr.findIndex(item => item > 2) //2 返回數組中滿足提供的測試函數的第一個元素的索引。否則返回-1
    
    arr.indexOf(item => item === 1) //0 返回在數組中可以找到一個給定元素的第一個索引，如果不存在，則返回-1。

更多方法請參考: MDN

==/!=先轉換再比較(強制轉型) ===/!==僅比較不轉換

null == undefined; //true 它們是類似的值
null === undefined; //false 它們是不同類型的值

條件操作符又稱三元運算符

let max = (num1>num2) ? num1 : num2

當判斷一個范圍時請使用if語句

var scroe = 80
if(scroe >= 90) {
    console.log("成績?yōu)閮?yōu)");
}else if(scroe >= 80) {
    console.log("成績?yōu)榱?)
}else if(scroe >= 60) {
    console.log("成績?yōu)榧案?)
}else {
    console.log("成績?yōu)椴患案?);
}

在對比有限個值時,值不能太多,一般在1-4之間,使用switch語句

switch(m) {
    case x:
        //語句
        break;
    case y: 
        //語句
        break;
    default:
        //語句
        break;
}

循環(huán)次數已知,選擇for循環(huán)

for(初始化條件表達式;條件表達式;條件改變表達式) {
    //循環(huán)體
}

循環(huán)次數未知,但是循環(huán)結束條件已知選擇while語句

while(條件表達式) {
    //循環(huán)體
}

循環(huán)體至少執(zhí)行一次時,選擇do while語句 例如:要先考試才能知道是否及格

do{
    //循環(huán)體
}while(條件表達式)

var score = 48;
do {
    console.log("沒及格,需要再來考試!");
    score += 15;
} while (score < 60);

break 直接跳出循環(huán)

var num = 0;
for (var i = 1; i < 10; i++) {
    if (i % 5 == 0) {
        break;
    }
    num++;
}
console.log(num); //4 當i=4時,num=4,再執(zhí)行循環(huán)i=5,跳出循環(huán),下面的num++并沒有執(zhí)行,此時num還是4;

continue 跳出本次循環(huán),繼續(xù)執(zhí)行下面的循環(huán)

var num = 0;
for (var i = 1; i < 10; i++) {
    if (i % 5 == 0) {
        continue;
    }
    num++;
}
console.log(num); //當i=4和9時,跳過了num++,循環(huán)完成時num=8;

// 函數執(zhí)行完之后會立即銷毀!!!
function sum(num1, num2) {
    return num1 + num2; //函數是否需要返回值是要看我們是否需要用到函數的返回值
}

function hello() {//函數在執(zhí)行完return之后會立即退出
    return;
    console.log("你好,世界!"); //這段語句不會執(zhí)行
} 

函數聲明:函數聲明整體提升,函數表達式/變量聲明:函數表達式命名提升

function test(a,b) {
   console.log(a)  
   console.log(b) 
   var b = 234
   console.log(b)  
   a = 123
   console.log(a) 
   function a() {}
   var a
   b = 234
   var b = function () {}
   console.log(a)
   function b () {}
   console.log(b)
}
test(1) // 打印結果為 fn a, fn b, 234, 123, 234, fn